C++中的（純）虛函數(virtual function)

C++中的純虛函數

在C++中的一種函數申明被稱之為：純虛函數(pure virtual function).它的申明格式如下： class CShape { public:     virtual void Show() =0; }; 注意紅色部分，在普通的虛函數後面加上" =0"這樣就聲明了一個pure virtual function.      在什麼情況下使用純虛函數(pure vitrual function)? 1，當想在基類中抽象出一個方法，且該基類隻做能被繼承，而不能被執行個體化； 2，這個方法必須在派生類(derived class)中被實作；    如果滿足以上兩點，可以考慮将該方法申明為pure virtual function. 我們來舉個例子，我們先定義一個形狀的類(Cshape)，但凡是形狀我們都要求其能顯示自己。是以我們定義了一個類如下： class CShape {     virtual void Show() {}; }; 但沒有CShape這種形狀，是以我們不想讓CShape這個類被執行個體化，我們首先想到的是将Show函數的定義（實作）部分删除如下： class CShape {     virtual void Show(); }; 當我們使用下面的語句執行個體化一個CShape時： CShape cs;  //這是我們不允許的，但僅用上面的代碼是可以通過編譯（但link時失敗）。      怎麼樣避免一個CShape被執行個體化，且在編譯時就被發現？ 答案是：使用pure virtual funcion. 我們再次修改CShape類如下： class CShape { public:     virtual void Show() =0; }; 這時在執行個體化CShape時就會有以下報錯資訊： error C2259: 'CShape' : cannot instantiate abstract class due to following members: warning C4259: 'void __thiscall CShape::Show(void)' : pure virtual function was not defined      我們再來看看被繼承的情況,我們需要一個CPoint2D的類，它繼承自CShape.他必須實作基類(CShape)中的Show()方法。    其實使用最初的本意是讓每一個派生自CShape的類，都要實作Show()方法，但時常我們可能在一個派生類中忘記了實作Show(),為了避免這種情況，pure virtual funcion發揮作用了。    我們看以下代碼： class CPoint2D:public CShape

{

public:

 CPoint2D()

 {

  printf("CPoint2D ctor is invoked/n");

 };

 void Msg()

 {

  printf("CPoint2D.Msg() is invoked/n");

 };  

};   當我們執行個體化CPoint2D時，在編譯時(at the compiling)也會出現如下的報錯: error C2259: 'CShape' : cannot instantiate abstract class due to following members: warning C4259: 'void __thiscall CShape::Show(void)' : pure virtual function was not defined    如上，我們預防了在派生類中忘記實作基類方法。 也許compiler會說： 哼！如果不在派生類的中實作在Show方法，我編譯都不會讓你通過。

  //-------------------------------------------------------- //now,show the completed code, //Platform:Winxp+VC6.0 //-------------- #include <iostream>

#include <stdio.h>

using namespace std; class CShape

{

public:

 virtual void Show()=0;

};

class CPoint2D:public CShape

{

public:

 void Msg()

 {

  printf("CPoint2D.Msg() is invoked/n");

 };

 void Show()

 {

  printf("Show() from CPoint2D/n");

 };

};

void main()

{

 CPoint2D p2d;   //如果派生類(CPoint2D)沒有實作Show()，則編譯不通過

 p2d.Msg();

 //

 CShape *pShape = &p2d;

 pShape->Show();  //不能執行個體化基類

 //CShape cs;

}

========================================================================= 

C++中的虛函數(virtual function)

1.簡介 

    虛函數是C++中用于實作多态(polymorphism)的機制。核心理念就是通過基類通路派生類定義的函數。假設我們有下面的類層次：

class A

{

public:

    virtual void foo() { cout << "A::foo() is called" << endl;}

};

class B: public A

{

public:

    virtual void foo() { cout << "B::foo() is called" << endl;}

};

那麼，在使用的時候，我們可以：

A * a = new B();

a->foo();       // 在這裡，a雖然是指向A的指針，但是被調用的函數(foo)卻是B的!

    這個例子是虛函數的一個典型應用，通過這個例子，也許你就對虛函數有了一些概念。它虛就虛在所謂“推遲聯編”或者“動态聯編”上，一個類函數的調用并不是在編譯時刻被确定的，而是在運作時刻被确定的。由于編寫代碼的時候并不能确定被調用的是基類的函數還是哪個派生類的函數，是以被成為“虛”函數。

    虛函數隻能借助于指針或者引用來達到多态的效果，如果是下面這樣的代碼，則雖然是虛函數，但它不是多态的：

class A

{

public:

    virtual void foo();

};

class B: public A

{

    virtual void foo();

};

void bar()

{

    A a;

    a.foo();   // A::foo()被調用

}

1.1 多态 

    在了解了虛函數的意思之後，再考慮什麼是多态就很容易了。仍然針對上面的類層次，但是使用的方法變的複雜了一些：

void bar(A * a)

{

    a->foo();  // 被調用的是A::foo() 還是B::foo()？

}

因為foo()是個虛函數，是以在bar這個函數中，隻根據這段代碼，無從确定這裡被調用的是A::foo()還是B::foo()，但是可以肯定的說：如果a指向的是A類的執行個體，則A::foo()被調用，如果a指向的是B類的執行個體，則B::foo()被調用。

這種同一代碼可以産生不同效果的特點，被稱為“多态”。

1.2 多态有什麼用？ 

    多态這麼神奇，但是能用來做什麼呢？這個命題我難以用一兩句話概括，一般的C++教程（或者其它面向對象語言的教程）都用一個畫圖的例子來展示多态的用途，我就不再重複這個例子了，如果你不知道這個例子，随便找本書應該都有介紹。我試圖從一個抽象的角度描述一下，回頭再結合那個畫圖的例子，也許你就更容易了解。

    在面向對象的程式設計中，首先會針對資料進行抽象（确定基類）和繼承（确定派生類），構成類層次。這個類層次的使用者在使用它們的時候，如果仍然在需要基類的時候寫針對基類的代碼，在需要派生類的時候寫針對派生類的代碼，就等于類層次完全暴露在使用者面前。如果這個類層次有任何的改變（增加了新類），都需要使用者“知道”（針對新類寫代碼）。這樣就增加了類層次與其使用者之間的耦合，有人把這種情況列為程式中的“bad smell”之一。

    多态可以使程式員脫離這種窘境。再回頭看看1.1中的例子，bar()作為A-B這個類層次的使用者，它并不知道這個類層次中有多少個類，每個類都叫什麼，但是一樣可以很好的工作，當有一個C類從A類派生出來後，bar()也不需要“知道”（修改）。這完全歸功于多态--編譯器針對虛函數産生了可以在運作時刻确定被調用函數的代碼。

1.3 如何“動态聯編” 

    編譯器是如何針對虛函數産生可以再運作時刻确定被調用函數的代碼呢？也就是說，虛函數實際上是如何被編譯器處理的呢？Lippman在深度探索C++對象模型[1]中的不同章節講到了幾種方式，這裡把“标準的”方式簡單介紹一下。

    我所說的“标準”方式，也就是所謂的“VTABLE”機制。編譯器發現一個類中有被聲明為virtual的函數，就會為其搞一個虛函數表，也就是VTABLE。VTABLE實際上是一個函數指針的數組，每個虛函數占用這個數組的一個slot。一個類隻有一個VTABLE，不管它有多少個執行個體。派生類有自己的VTABLE，但是派生類的VTABLE與基類的VTABLE有相同的函數排列順序，同名的虛函數被放在兩個數組的相同位置上。在建立類執行個體的時候，編譯器還會在每個執行個體的記憶體布局中增加一個vptr字段，該字段指向本類的VTABLE。通過這些手段，編譯器在看到一個虛函數調用的時候，就會将這個調用改寫，針對1.1中的例子：

void bar(A * a)

{

    a->foo();

}

會被改寫為：

void bar(A * a)

{

    (a->vptr[1])();

}

    因為派生類和基類的foo()函數具有相同的VTABLE索引，而他們的vptr又指向不同的VTABLE，是以通過這樣的方法可以在運作時刻決定調用哪個foo()函數。

    雖然實際情況遠非這麼簡單，但是基本原理大緻如此。

1.4 overload和override 

    虛函數總是在派生類中被改寫，這種改寫被稱為“override”。我經常混淆“overload”和“override”這兩個單詞。但是随着各類C++的書越來越多，後來的程式員也許不會再犯我犯過的錯誤了。但是我打算澄清一下：

override是指派生類重寫基類的虛函數，就象我們前面B類中重寫了A類中的foo()函數。重寫的函數必須有一緻的參數表和傳回值（C++标準允許傳回值不同的情況，這個我會在“文法”部分簡單介紹，但是很少編譯器支援這個feature）。這個單詞好象一直沒有什麼合适的中文詞彙來對應，有人譯為“覆寫”，還貼切一些。 

overload約定成俗的被翻譯為“重載”。是指編寫一個與已有函數同名但是參數表不同的函數。例如一個函數即可以接受整型數作為參數，也可以接受浮點數作為參數。 

2. 虛函數的文法 

    虛函數的标志是“virtual”關鍵字。

2.1 使用virtual關鍵字 

    考慮下面的類層次：

class A

{

public:

    virtual void foo();

};

class B: public A

{

public:

    void foo();    // 沒有virtual關鍵字!

};

class C: public B  // 從B繼承，不是從A繼承！

{

public:

    void foo();    // 也沒有virtual關鍵字！

};

    這種情況下，B::foo()是虛函數，C::foo()也同樣是虛函數。是以，可以說，基類聲明的虛函數，在派生類中也是虛函數，即使不再使用virtual關鍵字。

2.2 純虛函數 

    如下聲明表示一個函數為純虛函數：

class A

{

public:

    virtual void foo()=0;   // =0标志一個虛函數為純虛函數

};

    一個函數聲明為純虛後，純虛函數的意思是：我是一個抽象類！不要把我執行個體化！純虛函數用來規範派生類的行為，實際上就是所謂的“接口”。它告訴使用者，我的派生類都會有這個函數。

2.3 虛析構函數 

    析構函數也可以是虛的，甚至是純虛的。例如：

class A

{

public:

    virtual ~A()=0;   // 純虛析構函數

};

    當一個類打算被用作其它類的基類時，它的析構函數必須是虛的。考慮下面的例子：

class A

{

public:

    A() { ptra_ = new char[10];}

    ~A() { delete[] ptra_;}        // 非虛析構函數

private:

    char * ptra_;

};

class B: public A

{

public:

    B() { ptrb_ = new char[20];}

    ~B() { delete[] ptrb_;}

private:

    char * ptrb_;

};

void foo()

{

    A * a = new B;

    delete a;

}

    在這個例子中，程式也許不會象你想象的那樣運作，在執行delete a的時候，實際上隻有A::~A()被調用了，而B類的析構函數并沒有被調用！這是否有點兒可怕？

    如果将上面A::~A()改為virtual，就可以保證B::~B()也在delete a的時候被調用了。是以基類的析構函數都必須是virtual的。

    純虛的析構函數并沒有什麼作用，是虛的就夠了。通常隻有在希望将一個類變成抽象類（不能執行個體化的類），而這個類又沒有合适的函數可以被純虛化的時候，可以使用純虛的析構函數來達到目的。

2.4 虛構造函數？ 

    構造函數不能是虛的。

3. 虛函數使用技巧 3.1 private的虛函數 

    考慮下面的例子：

class A

{

public:

    void foo() { bar();}

private:

    virtual void bar() { ...}

};

class B: public A

{

private:

    virtual void bar() { ...}

};

    在這個例子中，雖然bar()在A類中是private的，但是仍然可以出現在派生類中，并仍然可以與public或者protected的虛函數一樣産生多态的效果。并不會因為它是private的，就發生A::foo()不能通路B::bar()的情況，也不會發生B::bar()對A::bar()的override不起作用的情況。

    這種寫法的語意是：A告訴B，你最好override我的bar()函數，但是你不要管它如何使用，也不要自己調用這個函數。

3.2 構造函數和析構函數中的虛函數調用 

    一個類的虛函數在它自己的構造函數和析構函數中被調用的時候，它們就變成普通函數了，不“虛”了。也就是說不能在構造函數和析構函數中讓自己“多态”。例如：

class A

{

public:

    A() { foo();}        // 在這裡，無論如何都是A::foo()被調用！

    ~A() { foo();}       // 同上

    virtual void foo();

};

class B: public A

{

public:

    virtual void foo();

};

void bar()

{

    A * a = new B;

    delete a;

}

    如果你希望delete a的時候，會導緻B::foo()被調用，那麼你就錯了。同樣，在new B的時候，A的構造函數被調用，但是在A的構造函數中，被調用的是A::foo()而不是B::foo()。

3.3 多繼承中的虛函數 3.4 什麼時候使用虛函數 

    在你設計一個基類的時候，如果發現一個函數需要在派生類裡有不同的表現，那麼它就應該是虛的。從設計的角度講，出現在基類中的虛函數是接口，出現在派生類中的虛函數是接口的具體實作。通過這樣的方法，就可以将對象的行為抽象化。

    以設計模式[2]中Factory Method模式為例，Creator的factoryMethod()就是虛函數，派生類override這個函數後，産生不同的Product類，被産生的Product類被基類的AnOperation()函數使用。基類的AnOperation()函數針對Product類進行操作，當然Product類一定也有多态（虛函數）。

    另外一個例子就是集合操作，假設你有一個以A類為基類的類層次，又用了一個std::vector<A *>來儲存這個類層次中不同類的執行個體指針，那麼你一定希望在對這個集合中的類進行操作的時候，不要把每個指針再cast回到它原來的類型（派生類），而是希望對他們進行同樣的操作。那麼就應該将這個“一樣的操作”聲明為virtual。

    現實中，遠不隻我舉的這兩個例子，但是大的原則都是我前面說到的“如果發現一個函數需要在派生類裡有不同的表現，那麼它就應該是虛的”。這句話也可以反過來說：“如果你發現基類提供了虛函數，那麼你最好override它”。

4.參考資料 

[1] 深度探索C++對象模型，Stanley B.Lippman，侯捷譯

[2] Design Patterns, Elements of Reusable Object-Oriented Software, GOF