一篇文章徹底弄懂C++虛函數的實現機制

Posted on by

1、虛函數簡介

C++中有兩種方式實現多態，即重載和覆蓋。

  • 重載：是指允許存在多個同名函數，而這些函數的參數表不同（參數個數不同、參數類型不同或者兩者都不同）。
  • 覆蓋：是指子類重新定義父類虛函數的做法，簡而言之就是用父類型別的指針指向其子類的實例，然後通過父類的指針調用實際子類的成員函數。這種技術可以讓父類的指針擁有“多種形態”，這是一種泛型技術。所謂泛型技術，說白瞭就是試圖使用不變的代碼來實現可變的算法，比如：模板元編程是在編譯期完成的泛型技術，RTTI、虛函數則是在運行時完成的泛型技術。

關於虛函數的具體使用方法，建議大傢先去閱讀相關的C++的書籍，本文隻剖析虛函數的實現機制，讓大傢對虛函數有一個更加清晰的認識，並不對虛函數的具體使用方法作過多介紹。本文是依據個人經驗和查閱相關資料最終編寫的，如有錯漏，希望大傢多多指正。

2、虛函數表簡介

學過C++的人都應該知道虛函數（Virtual Function）是通過虛函數表（Virtual Table，簡稱為V-Table）來實現的。虛函數表主要存儲的是指向一個類的虛函數地址的指針，通過使用虛函數表，繼承、覆蓋的問題都都得到瞭解決。假如一個類有虛函數，當我們構建這個類的實例時，將會額外分配一個指向該類虛函數表的指針，當我們用父類的指針來操作一個子類的時候，這個指向虛函數表的指針就派上用場瞭，它指明瞭此時應該使用哪個虛函數表，而虛函數表本身就像一個地圖一樣，為編譯器指明瞭實際所應該調用的函數。指向虛函數表的指針是存在於對象實例中最前面的位置（這是為瞭保證取到虛函數表的有最高的性能——如果有多層繼承或是多重繼承的情況下），這就意味著理論上我們可以通過對象實例的地址得到這張虛函數表（實際上確實可以做到），然後對虛函數表進行遍歷，並調用其中的函數。

前面說瞭一大堆理論，中看不中用，下面還是通過一個實際的例子驗證一下前面講的內容，首先定義一個Base類，該類有三個虛函數，代碼如下：

#include <iostream>
#include <string>

typedef void (*Fun)(void);

class Base
{
public:
    virtual void f()
    {
        std::cout << "Base::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

接下來按照前面的說法，我們通過Base類的實例對象base來獲取虛函數表，代碼如下：

int main(int argc, char* argv[])
{
    Base base;
    Fun fun = nullptr;

    std::cout << "指向虛函數表指針的地址：" << (long*)(&base) << std::endl;
    std::cout << "虛函數表的地址：" << (long*)*(long*)(&base) << std::endl;

    fun = (Fun)*((long*)*(long*)(&base));
    std::cout << "虛函數表中第一個函數的地址：" << (long*)fun << std::endl;
    fun();

    fun = (Fun)*((long*)*(long*)(&base) + 1);
    std::cout << "虛函數表中第二個函數的地址：" << (long*)fun << std::endl;
    fun();

    fun = (Fun)*((long*)*(long*)(&base) + 2);
    std::cout << "虛函數表中第三個函數的地址：" << (long*)fun << std::endl;
    fun();
}

運行結果圖2-1所示（Linux 3.10.0 + GCC 4.8.5）：

圖2-1 程序運行結果

在上面的例子中我們通過把&base強制轉換成long *，來取得指向虛函數表的指針的地址，然後對這個地址取值就可以得到對應的虛函數表瞭。得到對應虛函數表的首地址後，就可以通過不斷偏移該地址，依次得到指向真實虛函數的指針瞭。這麼說有點繞也有點暈，下面通過一幅圖解釋一下前面說的內容，詳見圖2-2

圖2-2 基類虛函數表內存佈局

當然，上述內容也可以在GDB中調試驗證，後續的內容也將全部在GDB下直接驗證，調試的示例見圖2-3：

圖2-3 GDB查看基類虛函數表內存佈局

3、有繼承關系的虛函數表剖析

前面分析虛函數表的場景是沒有繼承關系的，然而在實際開發中，沒有繼承關系的虛函數純屬浪費表情，所以接下來我們就來看看有繼承關系下虛函數表會呈現出什麼不一樣的特點，分析的時候會分別就單繼承無虛函數覆蓋、單繼承有虛函數覆蓋、多重繼承、多層繼承這幾個場景進行說明。

3.1、單繼承無虛函數覆蓋的情況

先定義一個Base類，再定義一個Derived類，Derived類繼承於Base類，代碼如下：

#include <iostream>
#include <string>

class Base
{
public:
    virtual void f()
    {
        std::cout << "Base::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void f1()
    {
        std::cout << "Derived::f1()" << std::endl;
    }

    virtual void g1()
    {
        std::cout << "Derived::g1()" << std::endl;
    }

    virtual void h1()
    {
        std::cout << "Derived::h1()" << std::endl;
    }
};

繼承關系如圖3-1所示：

圖3-1 類繼承關系UML圖

測試的代碼如下，因為等下要使用GDB來驗證，所以就隨便寫點，定義個Derived類實例就行瞭

int main(int argc, char* argv[])
{
    Derived derived;
    derived.f();
}

派生類Derived的虛函數表內存佈局如圖3-2所示：

圖3-2 單繼承無虛函數覆蓋情況下派生類虛函數表內存佈局

接下來就用GDB調試一下，驗證上圖的內存佈局是否正確，如圖3-3所示：

圖3-3 GDB查看單繼承無虛函數覆蓋情況下派生類虛函數表內存佈局

從調試結果可以看出圖3-2是正確的，Derived的虛函數表中先放Base的虛函數，再放Derived的虛函數。

3.2、單繼承有虛函數覆蓋的情況

派生類覆蓋基類的虛函數是很有必要的事情，不這麼做的話虛函數的存在將毫無意義。下面我們就來看一下如果派生類中有虛函數覆蓋瞭基類的虛函數的話，對應的虛函數表會是一個什麼樣子。還是老規矩先定義兩個有繼承關系的類，註意一下我這裡隻覆蓋瞭基類的g()

#include <iostream>
#include <string>

class Base
{
public:
    virtual void f()
    {
        std::cout << "Base::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void f1()
    {
        std::cout << "Derived::f1()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Derived::g()" << std::endl;
    }

    virtual void h1()
    {
        std::cout << "Derived::h1()" << std::endl;
    }
};

繼承關系如圖3-4所示：

圖3-4 類繼承關系UML圖

測試的代碼如下，因為等下要使用GDB來驗證，所以就隨便寫點，定義個Derived類實例就行瞭

int main(int argc, char* argv[])
{
    Derived derived;
    derived.g();
}

派生類Derived的虛函數表內存佈局如圖3-5所示：

圖3-5 單繼承有虛函數覆蓋情況下派生類虛函數表內存佈局

接下來就用GDB調試一下，驗證上圖的內存佈局是否正確，如圖3-6所示：

圖3-6 GDB查看單繼承有虛函數覆蓋情況下派生類虛函數表內存佈局

從調試結果可以看出圖3-5是正確的，並且可以得到以下幾點信息：

覆蓋的g()被放到瞭虛表中原來父類虛函數的位置沒有被覆蓋的虛函數位置排序依舊不變

有瞭前面的理論基礎，我們可以知道對於下面的代碼，由base所指的內存中的虛函數表的Base::g()的位置已經被Derived::g()所取代，於是在實際調用發生時，調用的是Derived::g()，從而實現瞭多態

int main(int argc, char* argv[])
{
    Base* base = new Derived();
    base->f();
    base->g();
    base->h();
}

輸出結果如圖3-7所示：

圖3-7 程序運行結果

註意：在前面的例子中，我們分配內存的實例對象的類型是Derived，但是卻用Base的指針去引用它，這個過程中數據並沒有發生任何的轉換，實例的真實類型依舊是Derived，但是由於我們使用時用的是Base類型，所以函數調用要依據Base類來，不能胡亂調用，比如說我們此時是無法調用Derived的f1()和h1()的。由於這個是個單繼承，不存在虛函數表選擇問題，相對比較簡單。

3.3、多重繼承的情況

多重繼承就不分開講有覆蓋和無覆蓋的情況瞭，其實結合前面講的就差不多知道是什麼個情況瞭，下面的例子中會設計成派生類既有自己的虛函數，又有用於覆蓋基類的虛函數，這樣就能兼顧有覆蓋和無覆蓋的情況瞭。

類的設計如下：

#include <iostream>
#include <string>

class Base1
{
public:
    virtual void f()
    {
        std::cout << "Base1::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base1::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base1::h()" << std::endl;
    }
};

class Base2
{
public:
    virtual void f()
    {
        std::cout << "Base2::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base2::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base2::h()" << std::endl;
    }
};

class Base3
{
public:
    virtual void f()
    {
        std::cout << "Base3::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base3::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base3::h()" << std::endl;
    }
};

class Derived : public Base1, public Base2, public Base3
{
public:
    virtual void f()
    {
        std::cout << "Derived::f()" << std::endl;
    }

    virtual void g1()
    {
        std::cout << "Derived::g1()" << std::endl;
    }

    virtual void h1()
    {
        std::cout << "Derived::h1()" << std::endl;
    }
};

繼承關系如圖3-8所示：

圖3-8 類繼承關系UML圖

測試的代碼如下：

int main(int argc, char* argv[])
{
    Derived* d = new Derived();
    Base1* b1 = d;
    Base2* b2 = d;
    Base3* b3 = d;
    std::cout << (long*)(*(long*)b1) << std::endl;
    std::cout << (long*)(*(long*)b2) << std::endl;
    std::cout << (long*)(*(long*)b3) << std::endl;
}

輸出結果如圖3-9所示：

圖3-9 程序運行結果

輸出信息非常有趣，明明b1、b2、b3指向的都是d，但是它們各自取出來的虛函數表的地址卻完全不同，按理來說不是應該相同嗎？別急，下面我們通過圖3-10來看一看多繼承下派生類虛函數表的內存佈局是什麼樣的

圖3-10 多重繼承情況下派生類虛函數表內存佈局

從圖3-10中可以看出以下幾點信息：

  • 在派生類中，每個基類都有一個屬於自己的虛函數表
  • 派生類自己特有的虛函數被放到瞭第一個基類的表中（第一個基類是按照繼承順序來確定的）

這裡我們就會得出一個新問題瞭，對於上面例子中的b1，這個沒啥問題，因為它的類型Base1就是第一個被繼承的，所以我們當然可以認為這個不會出任何問題，但是對於b2呢，它被繼承的位置可不是第一個啊，運行時要怎麼確定它的虛函數表呢？它有沒有可能一不小心找到Base1的虛函數去？恰好這個例子中幾個基類的虛函數名字和參數又都是完全相同的。這裡其實就涉及到編譯器的處理瞭，當我們執行賦值操作Base2* b2 = d;時，編譯器會自動把b2的虛函數表指針指向正確的位置，這個過程應該是編譯器做的，所以虛函數所實現的多態應該是“靜動結合”的，有部分工作需要在編譯時期完成的。

下面我們依然借助GDB來看一下實際的內存佈局，詳見圖3-11，從調試信息中可以看出此時確實有三張虛函數表，對應三個基類

圖3-11 GDB查看多重繼承情況下派生類虛函數表內存佈局

第一張表的數據如圖3-12所示，可以看到和圖3-10描述的內容是一致的，Derived自己特有的虛函數確實被加入到瞭第一張表中瞭，這裡指示虛函數表結束的表示好像是那個0xfffffffffffffff8，不知道是不是固定的，有知道的小夥伴麻煩評論區告訴我一下謝謝

圖3-12 派生類第一張虛函數表

第二張表的數據如圖3-13所示，這裡的結束符變成瞭0xfffffffffffffff0，搞不懂

圖3-13 派生類第二張虛函數表

第三張表的數據如圖3-14所示，這裡的結束符終於是0x0瞭

圖3-14 派生類第三張虛函數表

補充說明：如果繼承的某個類沒有虛函數的話，比如說將上面的Base2修改為以下格式：

class Base2
{
public:
    void f()
    {
        std::cout << "Base2::f()" << std::endl;
    }

    void g()
    {
        std::cout << "Base2::g()" << std::endl;
    }

    void h()
    {
        std::cout << "Base2::h()" << std::endl;
    }
};

main函數不變，再運行以下程序，輸出結果如圖3-15所示，說明此時就沒有指向Base2虛函數表的指針瞭，因為它本來就沒有虛函數表

圖3-15 程序運行結果

3.4、多層繼承的情況

多層繼承的在有前面的基礎上來理解就非常簡單瞭，測試程序如下：

#include <iostream>
#include <string>

class Base
{
public:
    virtual void f()
    {
        std::cout << "Base::f()" << std::endl;
    }

    virtual void g()
    {
        std::cout << "Base::g()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "Base::h()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void f()
    {
        std::cout << "Derived::f()" << std::endl;
    }

    virtual void g1()
    {
        std::cout << "Derived::g1()" << std::endl;
    }
};

class DDerived : public Derived
{
public:
    virtual void f()
    {
        std::cout << "DDerived::f()" << std::endl;
    }

    virtual void h()
    {
        std::cout << "DDerived::h()" << std::endl;
    }

    virtual void g2()
    {
        std::cout << "DDerived::g2()" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    DDerived dd;
    dd.f();
}

繼承關系如圖3-16所示：

圖3-16 類繼承關系UML圖

派生類DDerived的虛函數表內存佈局如圖3-17所示：

圖3-17 多層繼承情況下派生類虛函數表內存佈局

多層繼承的情況這裡就不使用GDB去看內存佈局瞭，比較簡單，大傢可以自行去測試一下。

4、總結

本文先對虛函數的概念進行瞭簡單介紹，引出瞭虛函數表這個實現虛函數的關鍵要素，然後對不同繼承案例下虛函數表的內存佈局進行說明，並使用GDB進行實戰驗證。相信看完這篇文章後聰明的你會對虛函數有更加深刻的理解瞭。

到此這篇關於C++虛函數實現機制的文章就介紹到這瞭,更多相關C++虛函數實現機制內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：