C++虛擬函式表和物件儲存

C++中的虛擬函式實現了多型的機制，也就是用父型別指標指向其子類的例項，然後通過父類的指標呼叫實際子類的成員函式，這種技術可以讓父類的指標有“多種形態”，這也是一種泛型技術，也就是使用不變的程式碼來實現可變的演算法

本文不再闡述虛擬函式的使用方法，而是從虛擬函式的實現機制上做一個清晰的剖析

參考博文：https://blog.csdn.net/u012879957/article/details/81027287

想了解實現機制，就必須先了解物件的儲存方式

物件資料和函式的儲存方式

我們知道，用類去定義物件，系統會為每一個物件分配儲存空間

在你的印象中類的儲存可能是下圖這樣的：

上圖表示要分別為物件的資料和函式的程式碼分配儲存空間，這樣肯定是不行的，記憶體利用率太低了，所以C++編譯系統採用的是以下的方法：

每個物件佔用儲存空間的只是該物件的資料部分（虛擬函式指標和虛基類指標也屬於資料部分），函式程式碼屬於公用部分

我們常說的“A物件的成員函式”，是從邏輯的角度而言的，而成員函式的物理儲存方式其實不是如此

C++記憶體分割槽

C++的記憶體分割槽大概分成五個部分：

1. 棧（stack）：是由編譯器在需要時自動分配，不需要時自動清除的變數儲存區，通常存放區域性變數、函式引數等。
2. 堆（heap）：是由new分配的記憶體塊，由程式設計師釋放（編譯器不管），一般一個new
   與一個delete對應，一個new[]與一個delete[]對應，如果程式設計師沒有釋放掉，資源將由作業系統在程式結束後自動回收
3. 自由儲存區：是由malloc等分配的記憶體塊，和堆十分相似，用free來釋放
4. 全域性/靜態儲存區：全域性變數和靜態變數被分配到同一塊記憶體中
5. 常量儲存區：這是一塊特殊儲存區，裡邊存放常量，不允許修改

（堆和自由儲存區其實不過是同一塊區域，new底層實現程式碼中呼叫了malloc，new可以看成是malloc智慧化的高階版本）

你可能會問：靜態成員函式和非靜態成員函式都是在類的定義時放在記憶體的程式碼區的，因而可以說它們都是屬於類的，但是類為什麼只能直接呼叫靜態類成員函式，而非靜態類成員函式(即使函式沒有引數)只有類物件才能呼叫呢

原因是：類的非靜態類成員函式其實都內含了一個指向類物件的指標型引數(即this指標)，因此只有類物件才能呼叫(此時this指標有實值)

虛擬函式表

C++通過繼承和虛擬函式來實現多型性，虛擬函式是通過一張虛擬函式表實現的，虛擬函式表解決了繼承、覆蓋、新增虛擬函式的問題，保證其真實反應實際的函式

不太熟悉的朋友，以下內容可能看的很懵，個人建議上下來回看

虛擬函式表原理簡述

C++實現虛擬函式的方法是：為每個類物件新增一個隱藏成員，隱藏成員儲存了一個指標，這個指標叫虛表指標（vptr），它指向一個虛擬函式表（virtual function table, vtbl）

虛擬函式表就像一個數組，表中有許多的槽（slot），每個槽中存放的是一個虛擬函式的地址（可以理解為數組裡存放著指向每個虛擬函式的指標）

即：每個類使用一個虛擬函式表，每個類物件用一個虛表指標

在有虛擬函式的類的例項物件中，這個表被分配在了這個例項物件的記憶體中（就和上面說的一樣），當我們用父類的指標來操作一個子類的時候，這張表就像一個地圖一樣，指明瞭實際所應該呼叫的函式

大概結構如下：

在上面這個圖中，虛擬函式表的最後多加了一個結點，這是虛擬函式表的結束結點，就像字串的結束符/0一樣，其標誌了虛擬函式表的結束，這個結束標誌的值在不同的編譯器下可能是不同的

舉個例子：
基類物件包含一個虛表指標，指向基類的虛擬函式表
派生類物件也將包含一個虛表指標，指向派生類虛擬函式表

• 如果派生類重寫了基類的虛方法，該派生類虛擬函式表將儲存重寫的虛擬函式的地址，而不是基類的虛擬函式地址
• 如果基類中的虛方法沒有在派生類中重寫，那麼派生類將繼承基類中的虛方法，而且派生類中虛擬函式表將儲存基類中未被重寫的虛擬函式的地址，但如果派生類中定義了新的虛方法，則該虛擬函式的地址也將被新增到派生類虛擬函式表中

你可能已經暈了，沒有關係，接下來我們用例項程式碼演示一下

找到虛擬函式表

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; }
};

按照上面的說法，我們可以通過Base的例項來得到虛擬函式表，這個表（陣列）存了指向f，g，h這三個函式的指標

typedef void(*Fun)(void);

int main()
{
    Base bObj;
    Fun pFun = NULL;    
    //指向void* pf(void)類的函式的指標pFun

    cout << "虛擬函式表的地址：" << (int*)(&bObj) << endl;
    cout << "虛擬函式表的第一個函式地址：" << (int*) * (int*)(&bObj) << endl;
    //再次取址得到第一個虛擬函式的地址

    //第一個虛擬函式
    pFun = (Fun) * ((int*) * (int*)(&bObj));
    pFun();
}

我們拆分開來慢慢看這段程式碼

typedef void(*Fun)(void);

typedef void(*Fun)(void)是利用類型別名宣告一個函式指標，指向的地址為NULL，等價於typedef decltype(void) *Fun

現在插入幾個斷點，以觀察指標pFun的變化：

Base例項化了物件了bObj，然後Fun pFun=NULL則是聲明瞭一個返回指向函式的指標

這裡斷點斷在Fun pFun=NULL之前，可以看到pFun還未被初始化

初始化pFun=NULL後值變成了0x00000000

例項出物件bObj後，我們用(int*)(&bObj)強行把&bObj轉成int*，取得虛擬函式表的地址，也就是一個指向虛擬函式表這個陣列的首元素的地址的指標，對這個指標再次取址就可以得到第一個虛擬函式（陣列首元素）的地址了，也就是第一個虛擬函式Base::f()的地址

cout << "虛擬函式表的地址：" << (int*)(&bObj) << endl;
cout << "虛擬函式表的第一個函式地址：" << (int*) * (int*)(&bObj) << endl;
//再次取址得到第一個虛擬函式的地址

//第一個虛擬函式
pFun = (Fun) * ((int*) * (int*)(&bObj));
pFun();

你可能看不太懂這個操作，對(int*) * (int*)(&bObj)可以這樣理解，(int*)(&bObj)就是物件bObj被強制轉換成了int*了的地址，如果直接呼叫*(int*)(&bObj)則是指向物件bObj地址所指向的資料，但是此處是個虛擬函式表，所以指不過去，必須通過(int*)將其轉換成函式指標來進行指向，(int*) * (int*)(&bObj)的指向就變成了物件bObj中第一個函式的地址

又因為pFun是由Fun這個函式宣告的函式指標，所以相當於是Fun的實體，必須再將這個地址轉換成pFun認識的型別，即加上(Fun)*進行強制轉換

整個過程簡單來說，就是從bObj地址開始讀取四個位元組的內容（&bObj），然後將這個內容解釋成一個記憶體地址((int*)(&bObj))，再訪問這個地址((int*) * (int*)(&bObj))，最後將這個地址中存放的值再解釋成一個函式的地址((Fun) * ((int*) * (int*)(&bObj)))

可以看到pFun的值已經等於虛擬函式表首元素（_vfptr[0]）的值0x00b41168了，也就是說pFun這個指向函式的指標已經指向了函式f()（記住虛擬函式表存的是指向虛擬函式的指標，所以值就是這些虛擬函式的地址）

控制檯的輸出：

和陣列一樣，如果要呼叫Base::g()和Base::h()，我們可以：

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

再看一次這張圖，是不是更清晰了一點？

現在我們來看看出現繼承時的情況

單繼承（無覆蓋）

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 g1() { cout << "Derive::g1()" << endl; }
    virtual void h1() { cout << "Derive::h1()" << endl; }
};

typedef void(*Fun)(void);

int main()
{
    //Base bObj;
    Derive dObj;
    Fun pFun = NULL;
    cout << "虛擬函式表的地址:" << (int*)(&dObj) << endl;
    cout << "虛擬函式表的第一個函式地址:" << (int*) * (int*)(&dObj) << endl;
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 0);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 1);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 2);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 3);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 4);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 5);
    pFun();
    return 0;
}

通過vs斷點，我們發現到+3時，pFun的值變成了虛擬函式f1的地址：

執行結果：

這個沒有覆蓋的繼承關係中，子類沒有過載任何父類的函式，我們例項化了一個物件dOb，它的虛擬函式表如下：

也就是說

1. 虛擬函式按照其宣告順序放於表中
2. 父類的虛擬函式在子類的虛擬函式前

單繼承（有覆蓋）

現在我們修改下Derive類

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::f()" << endl; }
    virtual void g1() { cout << "Derive::g1()" << endl; }
    virtual void h1() { cout << "Derive::h1()" << endl; }
};

這個繼承關係中，Derive的f()過載了Base類中的f()，下面我們用同樣的方法除錯，main函式基本不變

int main()
{
    //Base bObj;
    Derive dObj;
    Fun pFun = NULL;
    cout << "虛擬函式表的地址:" << (int*)(&dObj) << endl;
    cout << "虛擬函式表的第一個函式地址:" << (int*) * (int*)(&dObj) << endl;
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 0);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 1);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 2);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 3);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 4);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 5);
    pFun();
    return 0;
}

可以看到第一個函式變成了Derive::f()，並且執行到pFun = (Fun) * ((int*) * (int*)(&dObj) + 5)時，pFun的值變成了空

也就是說現在虛擬函式表的結構是這樣的：

也就是說

1. 覆蓋的f()函式被放到了虛表中原來父類虛擬函式的位置
2. 沒有被覆蓋的函式依舊

因為這個特性，我們就可以看到對於下面這樣的程式：

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

由b所指的記憶體中的虛擬函式表的f()的位置已經被Derive::f()函式地址所取代，於是在實際呼叫發生時，是Derive::f()被呼叫了，這就實現了C++的動態多型

多重繼承（無覆蓋）

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 f1() { cout << "Derive::f1()" << endl; }
    virtual void g1() { cout << "Derive::g1()" << endl; }
};

typedef void(*Fun)(void);

int main()
{
    //Base bObj;
    Derive dObj;
    Fun pFun = NULL;
    cout << "虛擬函式表的地址:" << (int*)(&dObj) << endl;
    cout << "虛擬函式表的第一個函式地址:" << (int*) * (int*)(&dObj) << endl;
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 0);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 1);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 2);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 3);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 4);
    pFun();
    pFun = (Fun) * ((int*) * (int*)(&dObj) + 5);
    pFun();
    return 0;
}

經過斷點可以看到，當執行到這裡

pFun變成了空指標

控制檯結果

為什麼+5之後找不到了呢？因為在多繼承下，虛擬函式表儲存方式發生了點變化，我們之前說到C++編譯器在物件內加入了一個隱藏成員，現在你可以理解為，在多繼承時加入了多個隱藏成員，也就是說我們現在有多個虛擬函式表，具體排列方式如下圖：

那我們有沒有辦法訪問呢？強大的C++當然是有的，細心的你應該發現了，這個表（陣列）其實只是變成了一個二維陣列

int main()
{
    Fun pFun = NULL;
    Derive dObj;
    int** pVtab = (int**)& dObj;
    //Base1's vtable
    pFun = (Fun)pVtab[0][0];
    //等價於：pFun = (Fun) * ((int*) * (int*)((int*)& dObj + 0) + 0);
    pFun();
    pFun = (Fun)pVtab[0][1];
    pFun();
    pFun = (Fun)pVtab[0][2];
    pFun();

    //Derive's vtable
    pFun = (Fun)pVtab[0][3];
    pFun();
    //The tail of the vtable
    pFun = (Fun)pVtab[0][4];
    cout << pFun << endl;

    //Base2's vtable
    pFun = (Fun)pVtab[1][0];
    pFun();
    pFun = (Fun)pVtab[1][1];
    pFun();
    pFun = (Fun)pVtab[1][2];
    pFun();
    //The tail of the vtable
    pFun = (Fun)pVtab[1][3];
    cout << pFun << endl;

    //Base3's vtable
    pFun = (Fun)pVtab[2][0];
    pFun();
    pFun = (Fun)pVtab[2][1];
    pFun();
    pFun = (Fun)pVtab[2][2];
    pFun();
    pFun = (Fun)pVtab[2][3];
    cout << pFun << endl;
    return 0;
}

也就是說

多重繼承（有覆蓋）

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; }
};

main函式不再贅述，最終你會發現現在的虛擬函式表是這樣的：

安全性問題

水能載舟，亦可賽艇亦能覆舟，接下來讓我們看看虛擬函式表可以用來乾點什麼壞事吧

通過父型別的指標訪問子類自己的虛擬函式

雖然在上面的圖中我們可以看到Base1的虛表中有Derive的虛擬函式，但我們根本不可能使用下面的語句來呼叫子類的自有虛擬函式：

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

任何妄圖使用父類指標呼叫子類中的未覆蓋父類的成員函式的行為都會被編譯器視為非法，所以，這樣的程式根本無法編譯通過

但通過多繼承部分的程式碼你應該已經發現了

在執行時，我們可以通過指標的方式訪問虛擬函式表來達到違反C++語義的行為（也就是我們在多重繼承中使用的程式碼）

Fun pFun = NULL;
Derive dObj;
int** pVtab = (int**)& dObj;
//Base1's vtable
pFun = (Fun)pVtab[0][0];
//等價於：pFun = (Fun) * ((int*) * (int*)((int*)& dObj + 0) + 0);
//Derive's vtable
pFun = (Fun)pVtab[0][3];
pFun();
//The tail of the vtable
pFun = (Fun)pVtab[0][4];
cout << pFun << endl;

訪問非public的虛擬函式

父類非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(); //挖藕？
}

最後注意

虛擬函式表不一定是存在最開頭，但是目前各個編譯器大多是這樣設定