C++之：虛函數表

一、文章來由

虛函數表究竟存放在哪裡？

二、概念

C++中的虛函數的作用主要是實現了多態的機制。關於多態，簡而言之就是用父類型別的指針指向其子類的實例，然後通過父類的指針調用實際子類的成員函數。這種技術可以讓父類的指針有“多種形態”，這是一種泛型技術。所謂泛型技術，說白了就是試圖使用不變的代碼來實現可變的算法。比如：模板技術，RTTI技術，虛函數技術，要麼是試圖做到在編譯時決議，要麼試圖做到運行時決議。

對C++ 了解的人都應該知道虛函數（Virtual Function）是通過一張虛函數表（Virtual Table）來實現的。簡稱為V-Table。在這個表中，主是要一個類的虛函數的地址表，這張表解決了繼承、覆蓋的問題，保證其容真實反應實際的函數。這樣，在有虛函數的類的實例中這個表被分配在了這個實例的內存中，所以，當我們用父類的指針來操作一個子類的時候，這張虛函數表就顯得由為重要了，它就像一個地圖一樣，指明了實際所應該調用的函數。這裡我們著重看一下這張虛函數表。C++的編譯器應該是保證：虛函數表的指針存在於對象實例中最前面的位置（這是為了保證取到虛函數表的有最高的性能——如果有多層繼承或是多重繼承的情況下）。 這意味著我們通過對象實例的地址得到這張虛函數表，然後就可以遍歷其中函數指針，並調用相應的函數。

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 main()
{
    //freopen("input.txt","r",stdin);

    typedef void(*Fun)(void); 
    Base b;

    Fun pFun = NULL;

    cout << "虛函數表地址：" << (int*)(&b) << endl;
    cout << "虛函數表 — 第一個函數地址：" << (int*)(*(int*)(&b)) << endl;

    // Invoke virtual functions

    pFun = (Fun)*((int*)*(int*)(&b));  // Base::f()
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b)+1);  // Base::g()
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b)+2);  // Base::h()
    pFun();

    return 0;
}

vs2012 環境下輸出：

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

Base 實例虛表結構圖如下：<喎?http://www.Bkjia.com/kf/ware/vc/" target="_blank" class="keylink">vcD4NCjxwPjxpbWcgYWx0PQ=="這裡寫圖片描述" src="http://www.bkjia.com/uploads/allimg/160326/0424242102-1.jpg" title="\" />

注意：在上面這個圖中，虛函數表的最後多加了一個結點，這是虛函數表的結束結點，就像字符串的結束符“/0”一樣，其標志了虛函數表的結束。這個結束標志的值在不同的編譯器下是不同的。在WinXP+VS2003下，這個值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，這個值是如果1，表示還有下一個虛函數表，如果值是0，表示是最後一個虛函數表。

而且，只要繼承父類的虛函數，其子類不論寫不寫virtual都是虛函數。

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

};

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

class Derive : public Base2{

public:
    void f() { cout << "Derive::f" << endl; }
};

typedef void(*Fun)(void);

int main() {
    Base2 *b2 = new Derive;

    b2->f();

    return 0;
}

輸出：
Derive::f

三、不同情況下的虛表

下面沒有覆蓋父類的虛函數是毫無意義的。之所以要講述沒有覆蓋的情況，主要目的是為了給一個對比。在比較之下，可以更加清楚地知道其內部的具體實現。

1、一般繼承（無虛函數覆蓋）

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

1）虛函數按照其聲明順序放於表中。

2）父類的虛函數在子類的虛函數前面。

2、一般繼承（有虛函數覆蓋）

對於派生類的實例，其虛函數表為

1）覆蓋的f()函數被放到了虛表中原來父類虛函數的位置。

2）沒有被覆蓋的函數依舊。

3、多重繼承（無虛函數覆蓋）

對於子類實例中的虛函數表為

1） 每個父類都有自己的虛表。

2） 子類的成員函數被放到了第一個父類的表中。（所謂的第一個父類是按照聲明順序來判斷的）

4、多重繼承（有虛函數覆蓋）

子類虛函數結構

    Derive d;
    Base1 *b1 = &d;
    Base2 *b2 = &d;
    Base3 *b3 = &d;
    b1->f(); //Derive::f()
    b2->f(); //Derive::f()
    b3->f(); //Derive::f()

    b1->g(); //Base1::g()
    b2->g(); //Base2::g()
    b3->g(); //Base3::g()

四、虛函數表安全性

1、通過父類型的指針訪問子類自己的虛函數

我們知道，子類沒有覆蓋父類的虛函數是一件毫無意義的事情。雖然在上面的圖中我們可以看到 Base1 的虛表中有Derive的虛函數，但我們根本不可能使用下面的語句來調用子類的自有虛函數：

Base1 *b1 = new Derive();
b1->f1();  //編譯出錯

任何妄圖使用父類指針想調用子類中的未覆蓋父類的成員函數的行為都會被編譯器視為非法，所以，這樣的程序根本無法編譯通過。但在運行時，我們可以通過指針的方式訪問虛函數表來達到違反C++語義的行為。

下面的例子就可以做到。

下面是一個關於多重繼承的虛函數表訪問的例程：

#include 
using namespace std;

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

};

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

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


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


typedef void(*Fun)(void);

int main()
{
            Fun pFun = NULL;

            Derive d;
            int** pVtab = (int**)&d;

            //Base1's vtable
            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
            pFun = (Fun)pVtab[0][0];
            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
            pFun = (Fun)pVtab[0][1];
            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
            pFun = (Fun)pVtab[0][2];
            pFun();

            //Derive's vtable
            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
            pFun = (Fun)pVtab[0][3];
            pFun();

            //The tail of the vtable
            pFun = (Fun)pVtab[0][4];
            cout<

2、訪問non-public的虛函數

另外，如果父類的虛函數是private或是protected的，但這些非public的虛函數同樣會存在於虛函數表中，所以，我們同樣可以使用訪問虛函數表的方式來訪問這些non-public的虛函數，這是很容易做到的。

如：

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

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {
    Derive d;
    Fun  pFun = (Fun)*((int*)*(int*)(&d)+0);
    pFun();
}

VC查看虛函數表

我們可以在VC的IDE環境中的Debug狀態下展開類的實例就可以看到虛函數表了（並不是很完整的）

附：基礎回顧

1、多態

概念：

多態性就是指同樣的消息被類的不同的對象接收時導致的完全不同的行為的一種現象。這裡所說的消息即對類成員函數的調用。多態實質是一個函數名稱的多種形態。

C++兩種類型多態：

（1）編譯時多態是通過靜態聯編實現的；

（2）運行時多態則是通過動態聯編實現的。

函數聯編：

對一個函數的調用，在編譯或運行時確定將其連接到相應的函數體的代碼，實質是把一個標示名與一個存儲地址（函數代碼段入口）聯系在一起的過程。

2、虛函數

C++中的動態聯編是通過虛函數實現的，虛函數必須存在於繼承的環境下。

當一個類的成員函數說明為虛函數後，就可以在該類的（直接或間接）派生類中定義與其基類虛函數原型相同（注意是函數原型一定要完全相同，否則會隱藏該虛函數）的函數。

虛函數可以在一個或多個派生類中被重新定義，要求在派生類中重新定義時，必須與基類中的函數原型完全相同，包括函數名、返回類型、參數個數和參數類型的順序。這時無論在派生類的相應成員函數前是否加上關鍵字virtual，都將視其為虛函數，如果函數原型不同，只是函數名相同，C++將視其為一般的函數重載，而不是虛函數。只有類的成員函數才能聲明為虛函數，全局函數及靜態成員函數不能聲明為虛函數。

3、純虛函數

純虛函數是在基類中只聲明虛函數而不給出具體的函數定義體，將它的具體定義放在各派生類中，稱此虛函數為純虛函數。

通過該基類的指針或引用就可以調用所有派生類的虛函數，基類只是用於繼承，僅作為一個接口，具體功能在派生類中實現.

純虛函數的聲明如下：（注：要放在基類的定義體中）

   virtual 函數原型=0；

注意：

（1）聲明了純虛函數的類，稱為抽象類；

（2）抽象類中可以有多個純虛函數；

（3）不能聲明抽象類的對象，但可以聲明指向抽象類的指針變量和引用變量；

（4）抽象類也可以定義其他非純虛函數；

（5）如果派生類中沒有重新定義基類中的純虛函數，則在派生類中必須再將該虛函數聲明為純虛函數；

（6）從抽象類可以派生出具體或抽象類，但不能從具體類派生出抽象類（這條在vs2012上實驗是錯誤的，詳見後面代碼）；

（7）在一個復雜的類繼承結構中，越上層的類抽象程度越高，有時甚至無法給出某些成員函數的實現，顯然，抽象類是一種特殊的類，它一般處於類繼承結構的較外層；

（8）引入抽象類的目的，主要是為了能將相關類組織在一個類繼承結構中，並通過抽象類來為這些相關類提供統一的操作接口。

驗證第六條：

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

};

class Base2 : public Base{
public:
    virtual void g()=0;
};

class Derive : public Base2{

public:
    void g() { cout << "Derive::g" << endl; }
};

int main() {
    Base2 *b2 = new Derive;

    b2->f();
    b2->g();

    return 0;
}

最後輸出：
Base::f
Derive::g

說明也可以從具體類派生抽象類。