C++虛函式表和物件存盤
C++中的虛函式實作了多型的機制，也就是用父型別指標指向其子類的實體，然后通過父類的指標呼叫實際子類的成員函式，這種技術可以讓父類的指標有“多種形態”，這也是一種泛型技術，也就是使用不變的代碼來實作可變的演算法
本文不再闡述虛函式的使用方法，而是從虛函式的實作機制上做一個清晰的剖析
參考博文：https://blog.csdn.net/u012879957/article/details/81027287
想了解實作機制，就必須先了解物件的存盤方式
物件資料和函式的存盤方式
我們知道，用類去定義物件，系統會為每一個物件分配存盤空間
在你的印象中類的存盤可能是下圖這樣的：
上圖表示要分別為物件的資料和函式的代碼分配存盤空間，這樣肯定是不行的，記憶體利用率太低了，所以C++編譯系統采用的是以下的方法：
每個物件占用存盤空間的只是該物件的資料部分（虛函式指標和虛基類指標也屬于資料部分），函式代碼屬于公用部分
我們常說的“A物件的成員函式”，是從邏輯的角度而言的，而成員函式的物理存盤方式其實不是如此
C++記憶體磁區
C++的記憶體磁區大概分成五個部分：
- 堆疊（stack）：是由編譯器在需要時自動分配，不需要時自動清除的變數存盤區，通常存放區域變數、函式引數等，
- 堆（heap）：是由
malloc等分配的記憶體塊，和堆十分相似，用free來釋放 - 自由存盤區：是由
new分配的記憶體塊，由程式員釋放（編譯器不管），一般一個new與一個delete對應，一個new[]與一個delete[]對應，如果程式員沒有釋放掉，資源將由作業系統在程式結束后自動回收 - 全域/靜態存盤區：全域變數和靜態變數被分配到同一塊記憶體中
- 常量存盤區：這是一塊特殊存盤區，里邊存放常量，不允許修改
（堆和自由存盤區其實不過是同一塊區域，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，它的虛函式表如下：
也就是說
- 虛函式按照其宣告順序放于表中
- 父類的虛函式在子類的虛函式前
單繼承（有覆寫）
現在我們修改下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的值變成了空
也就是說現在虛函式表的結構是這樣的：
也就是說
- 覆寫的f()函式被放到了虛表中原來父類虛函式的位置
- 沒有被覆寫的函式依舊
因為這個特性，我們就可以看到對于下面這樣的程式：
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(); //挖藕？
}
最后注意
虛函式表不一定是存在最開頭，但是目前各個編譯器大多是這樣設定的
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/103694.html
標籤：C++
上一篇：資料結構、演算法及應用