C++ 中的虛函數用于解決動態多態問題，虛函數的作用是允許在派生類中重新定義與積累同名的函數，并且可以通過基類指針或引用來訪問基類和派生類中的同名函數。

首先寫兩個簡單的類，類 B 繼承自類 A，即 A 是基類，B 是派生類。

• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?

class A{public:    void print(){        cout << "A" << endl;    }};
class B : public A {public:    void print(){        cout << "B" << endl;    }};
int main(){    B b;    //創建一個 B 類對象 b；    A &a = b;  //a 是 b 的一個 A 類引用；    A *pa = &b; //pa 是一個指向 A 類對象的指針；    a.print();    pa->print();    b.print();    return 0;}

程序中，A 類和 B 類均定義了一個同名函數 print ，但兩個函數的功能不同，編譯系統按照同名覆蓋原則決定調用對象。

?

另外一點，引用的本質是指針常量，可以認為 a，pa 都指向了 b。（ 注意區分常量指針與指針常量，常量指針可以類比于整型指針，即指向一個常量的指針，指針的指向可以修改；指針常量類比于整型常量，即一個指針是個常量，也就是指針只能固定的指向某一單元，指針常量的指向不可改而指向的值可以修改。)

• ?
• ?
• ?

int a, b；int * const p1 = &a; //指針常量const?int?*p2?=?&b;?//常量指針

執行函數后，我們發現結果為

因為 a 是 A 類的一個引用，所以 a 的 print( ) 依舊是 A 類的成員函數；pa 是 A 類的指針，同理；而 b 是 B 類的對象，調用的 print( ) 為 B 類的成員函數。簡言之就是，沒有 virtual 時，調用哪一類的成員函數取決于調用對象 a ，pa，b 在定義時的類型。而此時，若 B 類對象 b 想調用直接基類 A 的 print 函數，則應當 b.A::print( )。

?

這種 a，pa，b 能調用哪個同名函數在對象定義時已經確定好了的多態，我們稱之為靜態多態。什么是多態？同一個 print 函數在不同的對象中有不同的作用，這就呈現了多態。

?

這里再提一點，原本基類指針是用來指向基類對象的，如果用它指向派生類對象，此時基類指針指向的是派生類對象中的基類部分。在沒有虛函數時，基類指針是無法調用派生類對象中的成員函數的。

而當我們在 A 類中 print( ) 前加上關鍵字 virtual，變成虛函數時

• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?

class A{public:    virtual void print(){        cout << "A" << endl;    }};
class B : public A{public:    void print(){        cout << "B" << endl;    }};

再次執行主函數，結果為

這是因為 virtual 跟著對象走，即調用的 print( ) 究竟是 A 類還是 B 類的成員函數取決于“ 調用者 ” a，pa 所指的對象 b 屬于哪一類，而不再是取決于 a，pa 本身在定義時的類型了。

?

這種用基類指針或引用指向某一派生類對象，從而能夠調用指針指向的派生類對象中的函數的多態，我們稱為動態多態，virtual 正是實現動態多態的關鍵字。

虛函數表

接著剛才的話題，在 A 類中有虛函數的前提下，我們繼續討論

• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?

class C{public:    void print(){        cout << "C" << endl;    }};
int main(){    cout << "sizeof(A): " << sizeof(A) << endl;    cout << "sizeof(B): " << sizeof(B) << endl;    cout << "sizeof(C): " << sizeof(C) << endl;    A a;    B b;    C c;    cout << "sizeof(a): " << sizeof(a) << endl;    cout << "sizeof(b): " << sizeof(b) << endl;    cout << "sizeof(c): " << sizeof(c) << endl;    return 0;}

執行結果為

為什么有虛函數的 A 類大小為 8 字節，繼承 A 的 B 為 8 字節，而沒有虛函數的 C 類是 1 字節呢？聯想到 64 位操作系統下指針占8個字節內存，而 A 大小也是 8 字節，是巧合嗎？

?

事實上，在包含虛函數的類中，在該類的存儲空間中，會有一個指向虛函數表的指針，正是這個指針使 A 的大小變為 8 字節。而指針所指的虛函數表本質上是 A 類中定義的所有虛函數名構成的列表。

?

A 中只定義了一個虛函數 print( ) ，所以虛函數表中也只有一個虛函數名 print，通過這個虛函數名，再找到整個虛函數 print( ) 在內存中的存儲位置 ( B 同理 ) 。

驗證虛函數表的存在性

虛函數表看不見摸不著，怎么確定它的存在呢？

• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?
• ?

int main(){    A a;    B b;    a.print();    b.print();    cout << "-------------------" << endl;    typedef void (*func)();    //利用函數指針 func；    ((func**)(&a))[0][0]();    //((func**)(&a))[0] 代表對象 a 的內存空間中的第一個元素：指向虛函數表的指針；    ((func**)(&b))[0][0]();   //((func**)(&a))[0][0] 表示虛函數表中第一個函數名；    return 0;}

從結果中我們可以發現，((func**)(&a))[0][0]();?等效于?a.print();，即確實證明了對象 a 的內存空間中存有一個指向虛函數表的指針，虛函數表的第一個函數名正是 print 。
?