• 虛函數表
• 一般繼承（無虛函數覆寫）
• 一般繼承( 有虛函數覆寫)
• 靜態代碼發生了什么
• 評價多態
• 常見問答與實戰
• • 問答
  • • 為什么虛函數必須是類的成員函數？
    • 為什么類的靜態成員函數不能為虛函數？
    • 為什么構造函數不能為虛函數？
• 問答實戰
• • 基類構造中的虛函數
  • 父類指針間接調用

虛函數表

C++的多態是通過一張虛函數表（Virtual Table）來實現的，簡稱為 V-Table。在這個表中，主要是一個類的虛函數的地址表，這張表解決了繼承、覆寫的問題，保證其真實反應實際的函數。這樣， 在有虛函數的類的實例中這個表被分配在了這個實例的內存中，定義類的時候是沒有的.所以當我們用父類的指針來操作一個子類對象的時候，這張虛函數表就顯得由為重要了，它就像一個地圖一樣，指明了實際所應該調用的函數。

這里我們著重看一下這張虛函數表。C++的編譯器應該保證虛函數表的指針存在于對象實例中最前面的位置（這是為了保證取到虛函數表的有最高的性能——如果有多層繼承或是多重繼承的情況下）。 這意味著我們通過對象實例的地址得到這張虛函數表，然后就可以遍歷其中函數指針，并調用相應的函數。

假設我們有這樣的一個類：

#include <iostream> using namespace std;class Base { public:void f() { cout << "Base::f" << endl; }void g() { cout << "Base::g" << endl; }void h() { cout << "Base::h" << endl; }int a; };int main() {cout << "Base size:" << sizeof(Base) << endl;return 0; }

運行結果為：

我們對于代碼進行修改：給類內第一個函數加上virtual

#include <iostream>using namespace std;class Base { public:virtual void f() { cout << "Base::f" << endl; }void g() { cout << "Base::g" << endl; }void h() { cout << "Base::h" << endl; }int a; };int main() {cout << "Base size:" << sizeof(Base) << endl;return 0; }

運行結果為：

我們把類內所有的函數都加上virtual

#include <iostream>using namespace std;class Base { public:virtual void f() { cout << "Base::f" << endl; }virtual void g() { cout << "Base::g" << endl; }virtual void h() { cout << "Base::h" << endl; }int a; };int main() {cout << "Base size:" << sizeof(Base) << endl;return 0; }

運行結果為：

按照上面的說法，我們可以通過 Base 的實例來得到虛函數表。
內存模型圖解說明：

上面的0x4042f8地址放在實例的最前面，效率比較高，一進來就能夠找得到。0x4042f8是V-t的入口地址。所有的虛函數都在這個表里面進行排位，函數的本質就是地址，上面三個函數就代表三個地址。

#include <iostream> using namespace std; class Base { public:virtual void f() { cout << "Base::f" << endl; }virtual void g() { cout << "Base::g" << endl; }virtual void h() { cout << "Base::h" << endl; } };typedef void (*FUNC)();int main() {cout << "Base size:" << sizeof(Base) << endl;Base b;cout << "對象的起始地址：" << &b << endl;cout << "虛函數表的地址：" << (int**)*(int*)&b << endl;cout << "虛函數表第一個函數的地址:"<< *((int**)*(int*)&b) << endl;cout << "虛函數表第二個函數的地址:" << *((int**)*(int*)&b + 1) << endl;//注意不要轉為 FUNC 來打印，cout 沒有重載FUNC pf = (FUNC)(*((char**)*(int*)&b));pf();pf = (FUNC)(*((void**)*(int*)&b + 1));pf();pf = (FUNC)(*((void**)*(int*)&b + 2));pf();return 0; }

運行結果為：

通過這個示例，我們可以看到，我們可以通過強行把&b 轉成 int* ，取得虛函數表的地址，然后，再次取址就可以得到第一個虛函數的地址了，也就是 Base::f()，這在上面的程序中得到了驗證（把 int* 強制轉成了函數指針）。

畫個圖解釋一下。如下所示：

注意：在上面這個圖中，我在虛函數表的最后多加了一個結點，這是虛函數表的結束結點，就像字符串的結束符’\0’一樣，其標志了虛函數表的結束。這個結束標志的值在不同的編譯器下是不同的。

下面，我將分別說明"無覆寫"和"有覆寫"時的虛函數表的樣子。沒有覆寫父類的虛函數是毫無意義的。我之所以要說明沒有覆寫的情況，主要目的是為了給一個對比。在比較之下，我們可以更加清楚地知道其內部的具體實現。

一般繼承（無虛函數覆寫）

下面，再讓我們來看看繼承時的虛函數表是什么樣的。假設有如下所示的一個繼承關系：

請注意，在這個繼承關系中，子類沒有覆寫任何父類的函數。那么，在派生類的實例中，其虛函數表如下所示：

代碼演示：

#include <iostream> using namespace std; class Base { public:virtual void f() { cout << "Base::f" << endl; }virtual void g() { cout << "Base::g" << endl; }virtual void h() { cout << "Base::h" << endl; } }; class Derive :public Base { public:virtual void f1() { cout << "Derive::f1" << endl; }virtual void g2() { cout << "Derive::g1" << endl; }virtual void h2() { cout << "Derive::h1" << endl; } };typedef void (*FUNC)(); int main() {cout << "Base size:" << sizeof(Base) << endl;Derive d;cout << "對象的起始地址：" << &d << endl;cout << "虛函數表的地址：" << (int**)*(int*)&d << endl;cout << "虛函數表第一個函數的地址：" << *((void**)*(int*)&d) << endl;cout << "虛函數表第二個函數的地址：" << *((void**)*(int*)&d + 1) << endl;FUNC pf = (FUNC)(*((char**)*(int*)&d));pf();pf = (FUNC)(*((void**)*(int*)&d + 1));pf();pf = (FUNC)(*((void**)*(int*)&d + 2));pf();pf = (FUNC)(*((void**)*(int*)&d + 3));pf();pf = (FUNC)(*((void**)*(int*)&d + 4));pf();pf = (FUNC)(*((void**)*(int*)&d + 5));pf();return 0; }

運行結果為：

對于實例：Derive d; 的虛函數表如下：

我們可以看到下面幾點：
1）虛函數按照其聲明順序放于表中。
2）父類的虛函數在子類的虛函數前面。

一般繼承( 有虛函數覆寫)

覆蓋父類的虛函數是很顯然的事情，不然，虛函數就變得毫無意義。下面，我們來看一下，如果子類中有虛函數重載覆寫了父類的虛函數，會是一個什么樣子？假設，我們有下面這樣的一個繼承關系。

為了讓大家看到被繼承過后的效果，在這個類的設計中，我只覆蓋了父類的一個函數：f()。那么，對于派生類的實例，其虛函數表會是下面的一個樣子。

我們對于代碼進行修改：讓子類的覆寫一個父類的虛函數：

#include <iostream> using namespace std; class Base { public:virtual void f() { cout << "Base::f" << endl; }virtual void g() { cout << "Base::g" << endl; }virtual void h() { cout << "Base::h" << endl; } };class Derive :public Base { public:virtual void f() { cout << "Derive::f1" << endl; }virtual void g2() { cout << "Derive::g1" << endl; }virtual void h2() { cout << "Derive::h1" << endl; } };typedef void (*FUNC)();int main() {cout << "Base size:" << sizeof(Base) << endl;Derive d;cout << "對象的起始地址：" << &d << endl;cout << "虛函數表的地址：" << (int**)*(int*)&d << endl;cout << "虛函數表第一個函數的地址：" << *((void**)*(int*)&d) << endl;cout << "虛函數表第二個函數的地址：" << *((void**)*(int*)&d + 1) << endl;FUNC pf = (FUNC)(*((char**)*(int*)&d));pf();pf = (FUNC)(*((void**)*(int*)&d + 1));pf();pf = (FUNC)(*((void**)*(int*)&d + 2));pf();pf = (FUNC)(*((void**)*(int*)&d + 3));pf();pf = (FUNC)(*((void**)*(int*)&d + 4));pf();pf = (FUNC)(*((void**)*(int*)&d + 5));pf();return 0; }

運行結果為：

圖解說明：

我們從表中可以看到下面幾點，
1）覆寫的 f()函數被放到了虛表中原來父類同名虛函數的位置。
2）沒有被覆蓋的函數依舊存在。

這樣，我們就可以看到對于下面這樣的程序：

Base *b = new Derive(); b->f();

由 b 所指的內存中的虛函數表的 f() 的位置已經被 Derive::f() 函數地址所取代，于是在實際調用發生時，是 Derive::f()被調用了。這就實現了多態。

靜態代碼發生了什么

當編譯器看到這段代碼的時候，并不知道 b 真實身份。編譯器能作的就是用一段代碼代替這段語句。

Base *b = new Derive(); b->f();

1，明確 b 類型。
2，然后通過指針虛函數表的指針 vptr 和偏移量,匹配虛函數的入口。
3，根據入口地址調用虛函數。

一旦發生多態就會去首先遍歷虛函數表，如果符合虛函數覆寫，那么子類將會覆寫父類的虛函數。如果不符合虛函數覆寫，那么子類只是簡單的實現對于父類的繼承關系。

評價多態

1，實現了動態綁定。
2，犧牲了一些空間和效率，每次new虛函數表，并且每次調用需要遍歷虛函數表，但也是值重的。

常見問答與實戰

問答

為什么虛函數必須是類的成員函數？

虛函數誕生的目的就是為了實現多態，多態發生在父子類中，在類外定義虛函數毫無實際用處，編譯不過。

為什么類的靜態成員函數不能為虛函數？

如果定義為虛函數，那么它就是動態綁定的，也就是在派生類中可以被覆蓋的，這與靜態成員函數的定義（在內存中只有一份拷貝；通過類名或對象引用訪問靜態成員）本身就是相矛盾的。== 編譯不過。==

為什么構造函數不能為虛函數？

因為如果構造函數為虛函數的話，它將在執行期間被構造，而執行期則需要對象已經建立，構造函數所完成的工作就是為了建立合適的對象，因此在沒有構建好的對象上不可能執行多態（虛函數的目的就在于實現多態性）的工作。在繼承體系中，構造的順序就是從基類到派生類，其目的就在于確保對象能夠成功地構建。構造函數同時承擔著虛函數表的建立，如果它本身都是虛函數的話，如何確保 vtbl 的構建成功呢？編譯不過。注意：當基類的構造函數內部有虛函數時，會出現什么情況呢？結果是在構造函數中，虛函數機制不起作用了，調用虛函數如同調用一般的成員函數一樣。當基類的析構函數內部有虛函數時，又如何工作呢？與構造函數相同，只有"局部"的版本被調用。但是，行為相同，原因是不一樣的。構造函數只能調用"局部"版本，是因為調用時還沒有派生類版本的信息。析構函數則是因為派生類版本的信息已經不可靠了。我們知道，析構函數的調用順序與構造函數相反，是從派生類的析構函數到基類的析構函數。當某個類的析構函數被調用時，其派生類的析構函數已經被調用了，相應的數據也已被丟失，如果再調用虛函數的派生類的版本，就相當于對一些不可靠的數據進行操作，這是非常危險的。因此，在析構函數中，虛函數機制也是不起作用的。

問答實戰

基類構造中的虛函數

如下代碼輸出什么？

#include <iostream> using namespace std;class A { public:A() {p = this; //子類的對象賦值給父類的指針p->func(); //發生了調用}virtual void func() //父類中有虛函數 {cout << "aaaaaaaaaaaaaaaa" << endl;} private:A* p; };class B :public A { public:virtual void func() //子類覆寫父類的虛函數{cout << "bbbbbbbbbbbbbbbbb" << endl;} };int main() {B b;return 0; }

運行結果為：

我們進行解釋說明：要實現多態首先建立在構造結束。
構造結束意味著虛函數表生成了。虛函數表在構造徹底結束之后生成。那么也就是說B b;在創建對象的時候先執行：

class A { public:A() {p = this; //子類的對象賦值給父類的指針p->func(); //發生了調用}virtual void func() //父類中有虛函數 {cout << "aaaaaaaaaaaaaaaa" << endl;} private:A* p; };

生成對象之后先調用父類A的構造器，這個時候子類B的構造器沒有完成，那么虛函數表就沒有生成那么這個時候調用func( ) 只能就近原則，不能形成多態。所以就有了上面的打印結果。

那么接下來我們給出另一種情況：讓生成的對象構造完成，代碼演示：

#include <iostream> using namespace std;class A { public:A() {}virtual void func() //父類中有虛函數 {cout << "aaaaaaaaaaaaaaaa" << endl;}~A(){p = this; //子類的對象賦值給父類的指針p->func(); //發生了調用} private:A* p; };class B :public A { public:virtual void func() //子類覆寫父類的虛函數{cout << "bbbbbbbbbbbbbbbbb" << endl;} };int main() {B b;return 0; }

運行結果為：

我們進行解釋說明：
構造的時候先構造類A，再構造類B，但是在析構的時候先析構類B在析構類A。那么在析構的時候類B已經析構完畢。所以類B的存在就沒有意義了，所以唯一存在有意義的就是類A。

父類指針間接調用

#include <iostream> using namespace std;class Base { public:void foo() {this->func(); //子類調用父類的虛函數}virtual void func() //父類有虛函數{cout << "Base" << endl;} };class Derive :public Base { public:virtual void func() //子類覆寫父類的虛函數{cout << "Derive" << endl;} };int main() {Derive d;d.foo();return 0; }

運行結果為：

總結

以上是生活随笔為你收集整理的C++多态：多态实现原理剖析，虚函数表，评价多态，常见问答与实战【C++多态】（55）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。