正文

0.前言

文章較長，而且內容相對來說比較枯燥，希望對C++物件的記憶體佈局、虛表指標、虛基類指標等有深入瞭解的朋友可以慢慢看。
本文的結論都在VS2013上得到驗證。不同的編譯器在記憶體佈局的細節上可能有所不同。
文章如果有解釋不清、解釋不通或疏漏的地方，懇請指出。

1.何為C++物件模型?

引用《深度探索C++物件模型》這本書中的話：

有兩個概念可以解釋C++物件模型：

1. 語言中直接支援面向物件程式設計的部分。
2. 對於各種支援的底層實現機制。

直接支援面向物件程式設計，包括了建構函式、解構函式、多型、虛擬函式等等，這些內容在很多書籍上都有討論，也是C++最被人熟知的地方（特性）。而物件模型的底層實現機制卻是很少有書籍討論的。物件模型的底層實現機制並未標準化，不同的編譯器有一定的自由來設計物件模型的實現細節。在我看來，物件模型研究的是物件在儲存上的空間與時間上的更優，並對C++面向物件技術加以支援，如以虛指標、虛表機制支援多型特性。

2.文章內容簡介

這篇文章主要來討論C++物件在記憶體中的佈局，屬於第二個概念的研究範疇。而C++直接支援面向物件程式設計部分則不多講。文章主要內容如下：

• 虛擬函式表解析。含有虛擬函式或其父類含有虛擬函式的類，編譯器都會為其新增一個虛擬函式表,vptr，先了解虛擬函式表的構成，有助對C++物件模型的理解。
• 虛基類表解析。虛繼承產生虛基類表(vbptr)，虛基類表的內容與虛擬函式表完全不同，我們將在講解虛繼承時介紹虛擬函式表。
• 物件模型概述：介紹簡單物件模型、表格驅動物件模型，以及非繼承情況下的C++物件模型。
• 繼承下的C++物件模型。分析C++類物件在下面情形中的記憶體佈局：
  1. 單繼承：子類單一繼承自父類，分析了子類重寫父類虛擬函式、子類定義了新的虛擬函式情況下子類物件記憶體佈局。
  2. 多繼承：子類繼承於多個父類，分析了子類重寫父類虛擬函式、子類定義了新的虛擬函式情況下子類物件記憶體佈局，同時分析了非虛繼承下的菱形繼承。
  3. 虛繼承：分析了單一繼承下的虛繼承、多重基層下的虛繼承、重複繼承下的虛繼承。
• 理解物件的記憶體佈局之後，我們可以分析一些問題：
  1. C++封裝帶來的佈局成本是多大？
  2. 由空類組成的繼承層次中，每個類物件的大小是多大？

至於其他與記憶體有關的知識，我假設大家都有一定的瞭解，如記憶體對齊，指標操作等。本文初看可能晦澀難懂，要求讀者有一定的C++基礎，對概念一有一定的掌握。

3.理解虛擬函式表

3.1.多型與虛表

C++中虛擬函式的作用主要是為了實現多型機制。多型，簡單來說，是指在繼承層次中，父類的指標可以具有多種形態——當它指向某個子類物件時，通過它能夠呼叫到子類的函式，而非父類的函式。

class Base {     virtualvoid print(void);    }
class Drive1 :public Base{    virtualvoid print(void);    }
class Drive2 :public Base{    virtualvoid print(void);    }

Base * ptr1 = new Base; 
Base * ptr2 = new Drive1;  
Base * ptr3 = new Drive2;

ptr1->print(); //呼叫Base::print()
prt2->print();//呼叫Drive1::print()
prt3->print();//呼叫Drive2::print()

這是一種執行期多型，即父類指標唯有在程式執行時才能知道所指的真正型別是什麼。這種執行期決議，是通過虛擬函式表來實現的。

3.2.使用指標訪問虛表

如果我們豐富我們的Base類,使其擁有多個virtual函式：

class Base
{
public:
 
    Base(int i) :baseI(i){};

    virtualvoid print(void){ cout << "呼叫了虛擬函式Base::print()"; }

    virtualvoid setI(){cout<<"呼叫了虛擬函式Base::setI()";}

    virtual ~Base(){}
 
private:
 
    int baseI;

};

當一個類本身定義了虛擬函式，或其父類有虛擬函式時，為了支援多型機制，編譯器將為該類新增一個虛擬函式指標（vptr）。虛擬函式指標一般都放在物件記憶體佈局的第一個位置上，這是為了保證在多層繼承或多重繼承的情況下能以最高效率取到虛擬函式表。

當vprt位於物件記憶體最前面時，物件的地址即為虛擬函式指標地址。我們可以取得虛擬函式指標的地址：

Base b(1000);
int * vptrAdree = (int *)(&b);  
cout << "虛擬函式指標（vprt）的地址是：\t"<<vptrAdree << endl;

我們執行程式碼出結果：

我們強行把類物件的地址轉換為 int* 型別，取得了虛擬函式指標的地址。虛擬函式指標指向虛擬函式表,虛擬函式表中儲存的是一系列虛擬函式的地址，虛擬函式地址出現的順序與類中虛擬函式宣告的順序一致。對虛擬函式指標地址值，可以得到虛擬函式表的地址，也即是虛擬函式表第一個虛擬函式的地址:

    typedefvoid(*Fun)(void);
    Fun vfunc = (Fun)*( (int *)*(int*)(&b));
    cout << "第一個虛擬函式的地址是：" << (int *)*(int*)(&b) << endl;
    cout << "通過地址，呼叫虛擬函式Base::print()：";
    vfunc();

• 我們把虛表指標的值取出來： ＊(int＊)(&b)，它是一個地址，虛擬函式表的地址
• 把虛擬函式表的地址強制轉換成 int* : ( int ＊) ＊( int＊ )( &b )
• 再把它轉化成我們Fun指標型別 ： (Fun )＊(int ＊)＊(int＊)(&b)

這樣，我們就取得了類中的第一個虛擬函式，我們可以通過函式指標訪問它。
執行結果：

同理,第二個虛擬函式setI()的地址為：

 (int * )(*(int*)(&b)+1)

同樣可以通過函式指標訪問它，這裡留給讀者自己試驗。

到目前為止，我們知道了類中虛表指標vprt的由來，知道了虛擬函式表中的內容，以及如何通過指標訪問虛擬函式表。下面的文章中將常使用指標訪問物件記憶體來驗證我們的C++物件模型，以及討論在各種繼承情況下虛表指標的變化，先把這部分的內容消化完再接著看下面的內容。

4.物件模型概述

在C++中，有兩種資料成員（class data members）：static 和nonstatic,以及三種類成員函式（class member functions）:static、nonstatic和virtual:

現在我們有一個類Base，它包含了上面這5中型別的資料或函式：

class Base
{
public:
 
    Base(int i) :baseI(i){};
  
    int getI(){ return baseI; }
 
    staticvoid countI(){};
 
    virtual ~Base(){}

    virtualvoid print(void){ cout << "Base::print()"; }

    
 
private:
 
    int baseI;
 
    static int baseS;
};

那麼，這個類在記憶體中將被如何表示？5種資料都是連續存放的嗎？如何佈局才能支援C++多型？ 我們的C++標準與編譯器將如何塑造出各種資料成員與成員函式呢？

4.1.簡單物件模型

說明：在下面出現的圖中，用藍色邊框框起來的內容在記憶體上是連續的。
這個模型非常地簡單粗暴。在該模型下，物件由一系列的指標組成，每一個指標都指向一個數據成員或成員函式，也即是說，每個資料成員和成員函式在類中所佔的大小是相同的，都為一個指標的大小。這樣有個好處——很容易算出物件的大小，不過賠上的是空間和執行期效率。想象一下，如果我們的Point3d類是這種模型，將會比C語言的struct多了許多空間來存放指向函式的指標，而且每次讀取類的資料成員，都需要通過再一次定址——又是時間上的消耗。
所以這種物件模型並沒有被用於實際產品上。

4.2.表格驅動模型

這個模型在簡單物件模型的基礎上又新增一個間接層，它把類中的資料分成了兩個部分：資料部分與函式部分，並使用兩張表格，一張存放資料本身，一張存放函式的地址（也即函式比成員多一次定址），而類物件僅僅含有兩個指標，分別指向上面這兩個表。這樣看來，物件的大小是固定為兩個指標大小。這個模型也沒有用於實際應用於真正的C++編譯器上。

4.3.非繼承下的C++物件模型

概述：在此模型下，nonstatic 資料成員被置於每一個類物件中，而static資料成員被置於類物件之外。static與nonstatic函式也都放在類物件之外，而對於virtual 函式，則通過虛擬函式表+虛指標來支援，具體如下：

• 每個類生成一個表格，稱為虛表（virtual table，簡稱vtbl）。虛表中存放著一堆指標，這些指標指向該類每一個虛擬函式。虛表中的函式地址將按宣告時的順序排列，不過當子類有多個過載函式時例外，後面會討論。
• 每個類物件都擁有一個虛表指標(vptr)，由編譯器為其生成。虛表指標的設定與重置皆由類的複製控制（也即是建構函式、解構函式、賦值操作符）來完成。vptr的位置為編譯器決定，傳統上它被放在所有顯示宣告的成員之後，不過現在許多編譯器把vptr放在一個類物件的最前端。關於資料成員佈局的內容，在後面會詳細分析。
  另外，虛擬函式表的前面設定了一個指向type_info的指標，用以支援RTTI（Run Time Type Identification，執行時型別識別）。RTTI是為多型而生成的資訊，包括物件繼承關係，物件本身的描述等，只有具有虛擬函式的物件在會生成。

在此模型下，Base的物件模型如圖：

先在VS上驗證類物件的佈局：

Base b(1000);

可見物件b含有一個vfptr，即vprt。並且只有nonstatic資料成員被放置於物件內。我們展開vfprt：

vfptr中有兩個指標型別的資料（地址），第一個指向了Base類的解構函式，第二個指向了Base的虛擬函式print，順序與宣告順序相同。
這與上述的C++物件模型相符合。也可以通過程式碼來進行驗證：

void testBase( Base&p)
{
    cout << "物件的記憶體起始地址：" << &p << endl;
    cout << "type_info資訊:" << endl;
    RTTICompleteObjectLocator str = *((RTTICompleteObjectLocator*)*((int*)*(int*)(&p) - 1));
 
 
    string classname(str.pTypeDescriptor->name);
    classname = classname.substr(4, classname.find("@@") - 4);
    cout <<  "根據type_info資訊輸出類名:"<< classname << endl;
 
    cout << "虛擬函式表地址:" << (int *)(&p) << endl;
 
    //驗證虛表
    cout << "虛擬函式表第一個函式的地址：" << (int *)*((int*)(&p)) << endl;
    cout << "解構函式的地址:" << (int* )*(int *)*((int*)(&p)) << endl;
    cout << "虛擬函式表中，第二個虛擬函式即print（）的地址：" << ((int*)*(int*)(&p) + 1) << endl;
 
    //通過地址呼叫虛擬函式print（）
    typedefvoid(*Fun)(void);
    Fun IsPrint=(Fun)* ((int*)*(int*)(&p) + 1);
    cout << endl;
    cout<<"呼叫了虛擬函式"；
    IsPrint(); //若地址正確，則呼叫了Base類的虛擬函式print（）
    cout << endl;
 
    //輸入static函式的地址
    p.countI();//先呼叫函式以產生一個例項
    cout << "static函式countI()的地址：" << p.countI << endl;
 
    //驗證nonstatic資料成員
    cout << "推測nonstatic資料成員baseI的地址：" << (int *)(&p) + 1 << endl;
    cout << "根據推測出的地址，輸出該地址的值：" << *((int *)(&p) + 1) << endl;
    cout << "Base::getI():" << p.getI() << endl;
 
}

Base b(1000);
testBase(b);

結果分析：

• 通過 (int *)(&p)取得虛擬函式表的地址
• type_info資訊的確存在於虛表的前一個位置。通過((int)(int*)(&p) - 1))取得type_infn資訊，併成功獲得類的名稱的Base
• 虛擬函式表的第一個函式是解構函式。
• 虛擬函式表的第二個函式是虛擬函式print()，取得地址後通過地址呼叫它（而非通過物件），驗證正確
• 虛表指標的下一個位置為nonstatic資料成員baseI。
• 可以看到，static成員函式的地址段位與虛表指標、baseI的地址段位不同。

好的，至此我們瞭解了非繼承下類物件五種資料在記憶體上的佈局，也知道了在每一個虛擬函式表前都有一個指標指向type_info，負責對RTTI的支援。而加入繼承後類物件在記憶體中該如何表示呢？

5.繼承下的C++物件模型

5.1.單繼承

如果我們定義了派生類

class Derive : public Base
{
public:
    Derive(int d) :Base(1000),      DeriveI(d){};
    //overwrite父類虛擬函式
    virtualvoid print(void){ cout << "Drive::Drive_print()" ; }
    // Derive宣告的新的虛擬函式
        virtualvoid Drive_print(){ cout << "Drive::Drive_print()" ; }
    virtual ~Derive(){}
private:
    int DeriveI;
};

繼承類圖為：

一個派生類如何在機器層面上塑造其父類的例項呢？在簡單物件模型中，可以在子類物件中為每個基類子物件分配一個指標。如下圖：

簡單物件模型的缺點就是因間接性導致的空間存取時間上的額外負擔，優點則是類的大小是固定的，基類的改動不會影響子類物件的大小。

在表格驅動物件模型中，我們可以為子類物件增加第三個指標：基類指標(bptr)，基類指標指向指向一個基類表(base class table),同樣的，由於間接性導致了空間和存取時間上的額外負擔，優點則是無須改變子類物件本身就可以更改基類。表格驅動模型的圖就不再貼出來了。

在C++物件模型中，對於一般繼承（這個一般是相對於虛擬繼承而言），若子類重寫（overwrite）了父類的虛擬函式，則子類虛擬函式將覆蓋虛表中對應的父類虛擬函式(注意子類與父類擁有各自的一個虛擬函式表)；若子類並無overwrite父類虛擬函式，而是聲明瞭自己新的虛擬函式，則該虛擬函式地址將擴充到虛擬函式表最後（在vs中無法通過監視看到擴充的結果，不過我們通過取地址的方法可以做到，子類新的虛擬函式確實在父類子物體的虛擬函式表末端）。而對於虛繼承，若子類overwrite父類虛擬函式，同樣地將覆蓋父類子物體中的虛擬函式表對應位置，而若子類聲明瞭自己新的虛擬函式，則編譯器將為子類增加一個新的虛表指標vptr，這與一般繼承不同,在後面再討論。

我們使用程式碼來驗證以上模型

typedefvoid(*Fun)(void);
 
int main()
{
    Derive d(2000);
    //[0]
    cout << "[0]Base::vptr";
    cout << "\t地址：" << (int *)(&d) << endl;
        //vprt[0]
        cout << "  [0]";
        Fun fun1 = (Fun)*((int *)*((int *)(&d)));
        fun1();
        cout << "\t地址:\t" << *((int *)*((int *)(&d))) << endl;
 
        //vprt[1]解構函式無法通過地址呼叫，故手動輸出
        cout << "  [1]" << "Derive::~Derive" << endl;
 
        //vprt[2]
        cout << "  [2]";
        Fun fun2 = (Fun)*((int *)*((int *)(&d)) + 2);
        fun2();
        cout << "\t地址:\t" << *((int *)*((int *)(&d)) + 2) << endl;
    //[1]
    cout << "[2]Base::baseI=" << *(int*)((int *)(&d) + 1);
    cout << "\t地址：" << (int *)(&d) + 1;
    cout << endl;
    //[2]
    cout << "[2]Derive::DeriveI=" << *(int*)((int *)(&d) + 2);
    cout << "\t地址：" << (int *)(&d) + 2;
    cout << endl;
    getchar();
}

執行結果：

這個結果與我們的物件模型符合。

5.2.多繼承

5.2.1一般的多重繼承（非菱形繼承）

單繼承中（一般繼承），子類會擴充套件父類的虛擬函式表。在多繼承中，子類含有多個父類的子物件，該往哪個父類的虛擬函式表擴充套件呢？當子類overwrite了父類的函式，需要覆蓋多個父類的虛擬函式表嗎？

• 子類的虛擬函式被放在宣告的第一個基類的虛擬函式表中。
• overwrite時，所有基類的print()函式都被子類的print()函式覆蓋。
• 記憶體佈局中，父類按照其宣告順序排列。

其中第二點保證了父類指標指向子類物件時，總是能夠呼叫到真正的函式。

為了方便檢視，我們把程式碼都貼上過來

class Base
{
public:
 
    Base(int i) :baseI(i){};
    virtual ~Base(){}
 
    int getI(){ return baseI; }
 
    staticvoid countI(){};
 
    virtualvoid print(void){ cout << "Base::print()"; }
 
private:
 
    int baseI;
 
    static int baseS;
};
class Base_2
{
public:
    Base_2(int i) :base2I(i){};

    virtual ~Base_2(){}

    int getI(){ return base2I; }

    staticvoid countI(){};

    virtualvoid print(void){ cout << "Base_2::print()"; }
 
private:
 
    int base2I;
 
    static int base2S;
};
 
class Drive_multyBase :public Base, public Base_2
{
public:

    Drive_multyBase(int d) :Base(1000), Base_2(2000) ,Drive_multyBaseI(d){};
 
    virtualvoid print(void){ cout << "Drive_multyBase::print" ; }
 
    virtualvoid Drive_print(){ cout << "Drive_multyBase::Drive_print" ; }
 
private:
    int Drive_multyBaseI;
};

繼承類圖為：

此時Drive_multyBase 的物件模型是這樣的：

我們使用程式碼驗證：

typedefvoid(*Fun)(void);
 
int main()
{
    Drive_multyBase d(3000);
    //[0]
    cout << "[0]Base::vptr";
    cout << "\t地址：" << (int *)(&d) << endl;
 
        //vprt[0]解構函式無法通過地址呼叫，故手動輸出
        cout << "  [0]" << "Derive::~Derive" << endl;
 
        //vprt[1]
        cout << "  [1]";
        Fun fun1 = (Fun)*((int *)*((int *)(&d))+1);
        fun1();
        cout << "\t地址:\t" << *((int *)*((int *)(&d))+1) << endl;
 
 
        //vprt[2]
        cout << "  [2]";
        Fun fun2 = (Fun)*((int *)*((int *)(&d)) + 2);
        fun2();
        cout << "\t地址:\t" << *((int *)*((int *)(&d)) +