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++程序中使用虚函数，虚继承和虚析构是很好的习惯 可以避免许多的问题。