C++ 中virtual 用法

一、virtual 修飾基類中的函數，派生類重寫該函數：

#include 
using namespace std;
class A{
public:
     virtual  void  display(){  cout<<"A"<<ENDL; }
     };
class B :  public A{
public:
            void  display(){ cout<<"B"<<ENDL; }
     };
void doDisplay(A *p)
{
p->display();
delete p;
}
int main(int argc,char* argv[])
{
doDisplay(new B());
return 0;
}

　　

這段代碼打印出的結果為B，但是當把A類中的virtual去掉之后打印出的就為A。

當基類中沒有virtual的時候，編譯器在編譯的時候把p看做A類的對象，調用的自然就是A類的方法。

但是加上virtual之后，將dispaly方法變成了虛方法，這樣調用的時候編譯器會看調用的究竟是誰的實例化對象，這樣就實現了多態的效果。

也就是說，當基類的派生類中有重寫過基類的虛方法的時候，使用基類的指針指向派生類的對象，調用這個方法實際上調用的會是派生類最后實現的方法

 

二、派生類 virtual  繼承基類

#include 
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(){ out<<"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;
}

　　

1）這段代碼的終端輸出結果為：
Person構造
Teacher構造
Student構造
TS構造
TS析構
Student析構
Teacher析構
Person析構

2）當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 
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;
}

　　

1）這段代碼的運行結果為：
Person構造
Teacher構造
Student構造
TS構造
TS析構
Student析構
Teacher析構
Person析構

2）但是當我們把Person類中析構前面的virtual去掉之后的運行結果為：
Person構造
Teacher構造
Student構造
TS構造
Person析構
程序崩潰

很明顯這個結果不是我們想要的程序，崩潰造成的后果是不可預計的，所以我們一定要注意在基類的析構函數前面加上virtual，

使其變成虛析構在C++程序中使用虛函數，虛繼承和虛析構是很好的習慣 可以避免許多的問題。

 

虛析構：

如果一個類用作基類，我們通常需要virtual來修飾它的析構函數，這點很重要。

如果基類的析構函數不是虛析構，當我們用delete來釋放基類指針(它其實指向的是派生類的對象實例)占用的內存的時候，只有基類的析構函數被調用，而派生類的析構函數不會被調用，

這就可能引起內存泄露。如果基類的析構函數是虛析構，那么在delete基類指針時，繼承樹上的析構函數會被自低向上依次調用，即最底層派生類的析構函數會被首先調用，

然后一層一層向上直到該指針聲明的類型。

 

虛繼承：

虛擬繼承是多重繼承中特有的概念。虛擬基類是為解決多重繼承而出現的。【菱形繼承】

如:類D繼承自類B1、B2，而類B1、B2都繼承自類A，因此在類D中兩次出現類A中的變量和函數。

為了節省內存空間，可以將B1、B2對A的繼承定義為虛擬繼承，而A就成了虛擬基類。實現的代碼如下：

class A

class B1:public virtual A;

class B2:public virtual A;

class D:public B1,public B2;

　　

虛擬繼承在一般的應用中很少用到，所以也往往被忽視，這也主要是因為在C++中，多重繼承是不推薦的，也並不常用，

而一旦離開了多重繼承，虛擬繼承就完全失去了存在的必要因為這樣只會降低效率和占用更多的空間。

 

參考鏈接：https://blog.csdn.net/yuanchunsi/article/details/78686417