C++中virtual的三種用法

virtual用法一


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 執行個體化的第二種方法：

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的第三種用法，虛析構，虛繼承。

virtual用法三

using namespace std;
class Person
{   
    public:
        Person()
            {
                name=new char[16];
                cout<<"Person構造"<<ENDL;
            }
        virtual ~Person()
            {
                delete []name;
                cout<<"Perso析構"<<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++程式中使用虛函數，虛繼承和虛析構是很好的習慣 可以避免許多的問題。

虛析構：

如果一個類用作基類，我們通常需要virtual來修飾它的析構函數，這點很重要。如果基類的析構函數不是虛析構，當我們用delete來釋放基類指針(它其實指向的是派生類的對象執行個體)占用的記憶體的時候，隻有基類的析構函數被調用，而派生類的析構函數不會被調用，這就可能引起記憶體洩露。如果基類的析構函數是虛析構，那麼在delete基類指針時，繼承樹上的析構函數會被自低向上依次調用，即最底層派生類的析構函數會被首先調用，然後一層一層向上直到該指針聲明的類型。

虛繼承：

虛拟繼承是多重繼承中特有的概念。虛拟基類是為解決多重繼承而出現的。如:類D繼承自類B1、B2，而類B1、B2都繼承自類A，是以在類D中兩次出現類A中的變量和函數。為了節省記憶體空間，可以将B1、B2對A的繼承定義為虛拟繼承，而A就成了虛拟基類。實作的代碼如下：

class A

class B1:public virtual A;