C++中virtual的用法

虚函数

#include <iostream>  
using namespace std;  

class Base  
{  
    public:Base(){}  
    public:virtual void print(){ cout << "Base"; }  
};  

class Derived :public Base  
{  
    public:Derived(){}  
    public:void print(){ cout << "Derived"; }  
};  

int main()  
{  
    Base *point = new Derived();  
    point->print();  
}  

这段代码打印出的结果为Derived，但是当把Base类中的virtual去掉之后打印出的就为Base。当基类中没有virtual的时候，编译器在编译的时候把point看做Base类的对象，调用的自然就是Base类的方法。但是加上virtual之后，将print方法变成了虚方法，这样调用的时候编译器会看调用的究竟是谁的实例化对象，这样就实现了多态的效果。也就是说，当基类的派生类中有重写过基类的虚方法的时候，使用基类的指针指向派生类的对象，调用这个方法实际上调用的会是派生类最后实现的方法

纯虚函数

C++语言为我们提供了一种语法结构，通过它可以指明，一个虚拟函数只是提供了一个可被子类型改写的接口。但是，它本身并不能通过虚拟机制被调用。这就是纯虚拟函数（purevirtual function）。 纯虚拟函数的声明如下所示：

class Query {
public:
    // 声明纯虚拟函数
    virtual ostream& print( ostream&=cout ) const = 0;
    // ...
};

这里函数声明后面紧跟赋值0。

包含一个或多个纯虚拟函数的类被编译器识别为抽象基类。抽象基类不能被实例化，一般用于继承。

虚拟继承（virtual public）

#include <iostream>  
using namespace std;  

class Person{  
public:      
    Person(){ cout << "Person构造" << endl; }  
    ~Person(){ cout << "Person析构" << endl; }  
};  

class Teacher : virtual public Person{  
public:      
    Teacher(){ cout << "Teacher构造" << endl; }  
    ~Teacher(){ cout << "Teacher析构" << endl; }  
};  

class Student : virtual public Person{  
public:        
    Student(){ cout << "Student构造" << endl; }  
    ~Student(){ cout << "Student析构" << endl; }  
};  

class TS : public Teacher, public Student{  
public:              
    TS(){ cout << "TS构造" << endl; }  
    ~TS(){ cout << "TS析构" << endl; }  
};  

int main(int argc, char* argv[])  
{  
    TS ts;  
    return 0;  
}  

这段代码的终端输出结果为：

Person构造
Teacher构造
Student构造
TS构造
TS析构
Student析构
Teacher析构
Person析构

当Teacher类和Student类没有虚继承Person类的时候，也就是把virtual去掉时候终端输出的结果为：

Person构造
Teacher构造
Person构造
Student构造
TS构造
TS析构
Student析构
Person析构
Teacher析构
Person析构

大家可以很清楚的看到这个结果明显不是我们所期望的。我们在构造TS的时候需要先构造他的基类，也就是Teacher类和Student类。而Teacher类和Student类由都继承于Person类。这样就导致了构造TS的时候实例化了两个Person类。同样的道理，析构的时候也是析构了两次Person类，这是非常危险的，也就引发出了virtual的第三种用法，虚析构。

#include <iostream>  
using namespace std;  
class Person{  
public:          
    Person()  { name = new char[16]; cout << "Person构造" << endl; }  
    virtual  ~Person()  { delete[]name; cout << "Person析构" << endl; }  
private:  
    char *name;  
};

class Teacher :virtual public Person{  
public:           
    Teacher(){ cout << "Teacher构造" << endl; }  
    ~Teacher(){ cout << "Teacher析构" << endl; }  
};

class Student :virtual public Person{  
public:           
    Student(){ cout << "Student构造" << endl; }  
    ~Student(){ cout << "Student析构" << endl; }  
};

class TS : public Teacher, public Student{  
public:               
    TS(){ cout << "TS构造" << endl; }  
    ~TS(){ cout << "TS析构" << endl; }  
};

int main(int argc, char* argv[])  
{  
    Person *p = new TS();  
    delete p;  
    return 0;  

这段代码的运行结果为：

Person构造
Teacher构造
Student构造
TS构造
TS析构
Student析构
Teacher析构
Person析构

但是当我们把Person类中析构前面的virtual去掉之后的运行结果为：

Person构造
Teacher构造
Student构造
TS构造
Person析构

程序崩溃
很明显这个结果不是我们想要的程序，崩溃造成的后果是不可预计的。

所以我们一定要注意在基类的析构函数前面加上virtual，使其变成虚析构在C++程序中使用虚函数，虚继承和虚析构是很好的习惯 可以避免许多的问题。