圖說C++對象模型：對象內存佈局詳解

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 {     virtual void print(void);    }
class Drive1 :public Base{    virtual void print(void);    }
class Drive2 :public Base{    virtual void 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){};

    virtual void print(void){ cout << "調用了虛函數Base::print()"; }

    virtual void setI(){cout<<"調用了虛函數Base::setI()";}

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

};

當一個類自己定義了虛函數，或其父類有虛函數時，爲了支持多態機制，編譯器將爲該類添加一個虛函數指針（vptr）。虛函數指針通常都放在對象內存佈局的第一個位置上，這是爲了保證在多層繼承或多重繼承的狀況下能以最高效率取到虛函數表。

當vprt位於對象內存最前面時，對象的地址即爲虛函數指針地址。咱們能夠取得虛函數指針的地址：

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

咱們運行代碼出結果：

咱們強行把類對象的地址轉換爲 int* 類型，取得了虛函數指針的地址。虛函數指針指向虛函數表,虛函數表中存儲的是一系列虛函數的地址，虛函數地址出現的順序與類中虛函數聲明的順序一致。對虛函數指針地址值，能夠獲得虛函數表的地址，也便是虛函數表第一個虛函數的地址:

typedef void(*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; }
 
    static void countI(){};
 
    virtual ~Base(){}

    virtual void 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（）
    typedef void(*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父類虛函數
    virtual void print(void){ cout << "Drive::Drive_print()" ; }
    // Derive聲明的新的虛函數
        virtual void Drive_print(){ cout << "Drive::Drive_print()" ; }
    virtual ~Derive(){}
private:
    int DeriveI;
};

繼承類圖爲：

一個派生類如何在機器層面上塑造其父類的實例呢？在簡單對象模型中，能夠在子類對象中爲每一個基類子對象分配一個指針。以下圖：

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

在表格驅動對象模型中，咱們能夠爲子類對象增長第三個指針：基類指針(bptr)，基類指針指向指向一個基類表(base class table),一樣的，因爲間接性致使了空間和存取時間上的額外負擔，優勢則是無須改變子類對象自己就能夠更改基類。表格驅動模型的圖就再也不貼出來了。

在C++對象模型中，對於通常繼承（這個通常是相對於虛擬繼承而言），若子類重寫（overwrite）了父類的虛函數，則子類虛函數將覆蓋虛表中對應的父類虛函數(注意子類與父類擁有各自的一個虛函數表)；若子類並沒有overwrite父類虛函數，而是聲明瞭本身新的虛函數，則該虛函數地址將擴充到虛函數表最後（在vs中沒法經過監視看到擴充的結果，不過咱們經過取地址的方法能夠作到，子類新的虛函數確實在父類子物體的虛函數表末端）。而對於虛繼承，若子類overwrite父類虛函數，一樣地將覆蓋父類子物體中的虛函數表對應位置，而若子類聲明瞭本身新的虛函數，則編譯器將爲子類增長一個新的虛表指針vptr，這與通常繼承不一樣,在後面再討論。

咱們使用代碼來驗證以上模型

typedef void(*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; }
 
    static void countI(){};
 
    virtual void 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; }

    static void countI(){};

    virtual void 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){};
 
    virtual void print(void){ cout << "Drive_multyBase::print" ; }
 
    virtual void Drive_print(){ cout << "Drive_multyBase::Drive_print" ; }
 
private:
    int Drive_multyBaseI;
};

繼承類圖爲：

此時Drive_multyBase 的對象模型是這樣的：

咱們使用代碼驗證：

typedef void(*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)) + 2) << endl;
 
 
    //[1]
    cout << "[1]Base::baseI=" << *(int*)((int *)(&d) + 1);
    cout << "\t地址：" << (int *)(&d) + 1;
    cout << endl;
 
 
    //[2]
    cout << "[2]Base_::vptr";
    cout << "\t地址：" << (int *)(&d)+2 << endl;
 
        //vprt[0]析構函數沒法經過地址調用，故手動輸出
        cout << "  [0]" << "Drive_multyBase::~Derive" << endl;
 
        //vprt[1]
        cout << "  [1]";
        Fun fun4 = (Fun)*((int *)*((int *)(&d))+1);
        fun4();
        cout << "\t地址:\t" << *((int *)*((int *)(&d))+1) << endl;
 
    //[3]
    cout << "[3]Base_2::base2I=" << *(int*)((int *)(&d) + 3);
    cout << "\t地址：" << (int *)(&d) + 3;
    cout << endl;
 
    //[4]
    cout << "[4]Drive_multyBase::Drive_multyBaseI=" << *(int*)((int *)(&d) + 4);
    cout << "\t地址：" << (int *)(&d) + 4;
    cout << endl;
 
    getchar();
}

運行結果：

5.2.2 菱形繼承

菱形繼承也稱爲鑽石型繼承或重複繼承，它指的是基類被某個派生類簡單重複繼承了屢次。這樣，派生類對象中擁有多份基類實例（這會帶來一些問題）。爲了方便敘述，咱們不使用上面的代碼了，而從新寫一個重複繼承的繼承層次：

class B
 
{
 
public:
 
    int ib;
 
public:
 
    B(int i=1) :ib(i){}
 
    virtual void f() { cout << "B::f()" << endl; }
 
    virtual void Bf() { cout << "B::Bf()" << endl; }
 
};
 
class B1 : public B
 
{
 
public:
 
    int ib1;
 
public:
 
    B1(int i = 100 ) :ib1(i) {}
 
    virtual void f() { cout << "B1::f()" << endl; }
 
    virtual void f1() { cout << "B1::f1()" << endl; }
 
    virtual void Bf1() { cout << "B1::Bf1()" << endl; }
 
 
 
};
 
class B2 : public B
 
{
 
public:
 
    int ib2;
 
public:
 
    B2(int i = 1000) :ib2(i) {}
 
    virtual void f() { cout << "B2::f()" << endl; }
 
    virtual void f2() { cout << "B2::f2()" << endl; }
 
    virtual void Bf2() { cout << "B2::Bf2()" << endl; }
 
};
 
 
class D : public B1, public B2
 
{
 
public:
 
    int id;
 
 
 
public:
 
    D(int i= 10000) :id(i){}
 
    virtual void f() { cout << "D::f()" << endl; }
 
    virtual void f1() { cout << "D::f1()" << endl; }
 
    virtual void f2() { cout << "D::f2()" << endl; }
 
    virtual void Df() { cout << "D::Df()" << endl; }
 
};

這時，根據單繼承，咱們能夠分析出B1，B2類繼承於B類時的內存佈局。又根據通常多繼承，咱們能夠分析出D類的內存佈局。咱們能夠得出D類子對象的內存佈局以下圖：

D類對象內存佈局中，圖中青色表示b1類子對象實例，黃色表示b2類子對象實例，灰色表示D類子對象實例。從圖中能夠看到，因爲D類間接繼承了B類兩次，致使D類對象中含有兩個B類的數據成員ib，一個屬於來源B1類，一個來源B2類。這樣不只增大了空間，更重要的是引發了程序歧義：

D d;
 
d.ib =1 ;               //二義性錯誤,調用的是B1的ib仍是B2的ib？
 
d.B1::ib = 1;           //正確
 
d.B2::ib = 1;           //正確

儘管咱們能夠經過明確指明調用路徑以消除二義性，但二義性的潛在性尚未消除，咱們能夠經過虛繼承來使D類只擁有一個ib實體。

6.虛繼承

虛繼承解決了菱形繼承中最派生類擁有多個間接父類實例的狀況。虛繼承的派生類的內存佈局與普通繼承不少不一樣，主要體如今：

• 虛繼承的子類，若是自己定義了新的虛函數，則編譯器爲其生成一個虛函數指針（vptr）以及一張虛函數表。該vptr位於對象內存最前面。
  • vs非虛繼承：直接擴展父類虛函數表。
• 虛繼承的子類也單獨保留了父類的vprt與虛函數表。這部份內容接與子類內容以一個四字節的0來分界。
• 虛繼承的子類對象中，含有四字節的虛表指針偏移值。

爲了分析最後的菱形繼承，咱們仍是先從單虛繼承繼承開始。

6.1.虛基類表解析

在C++對象模型中，虛繼承而來的子類會生成一個隱藏的虛基類指針（vbptr），在Microsoft Visual C++中，虛基類表指針老是在虛函數表指針以後，於是，對某個類實例來講，若是它有虛基類指針，那麼虛基類指針可能在實例的0字節偏移處（該類沒有vptr時，vbptr就處於類實例內存佈局的最前面，不然vptr處於類實例內存佈局的最前面），也可能在類實例的4字節偏移處。
一個類的虛基類指針指向的虛基類表，與虛函數表同樣，虛基類表也由多個條目組成，條目中存放的是偏移值。第一個條目存放虛基類表指針（vbptr）所在地址到該類內存首地址的偏移值，由第一段的分析咱們知道，這個偏移值爲0（類沒有vptr）或者-4（類有虛函數，此時有vptr）。咱們經過一張圖來更好地理解。

虛基類表的第2、第三...個條目依次爲該類的最左虛繼承父類、次左虛繼承父類...的內存地址相對於虛基類表指針的偏移值，這點咱們在下面會驗證。

6.2.簡單虛繼承

若是咱們的B1類虛繼承於B類：

//類的內容與前面相同
class B{...}
class B1 : virtual public B

根據咱們前面對虛繼承的派生類的內存佈局的分析，B1類的對象模型應該是這樣的：

咱們經過指針訪問B1類對象的內存，以驗證上面的C++對象模型：

int main()
{
B1 a;
    cout <<"B1對象內存大小爲："<< sizeof(a) << endl;
 
    //取得B1的虛函數表
    cout << "[0]B1::vptr";
    cout << "\t地址：" << (int *)(&a)<< endl;
 
    //輸出虛表B1::vptr中的函數
    for (int i = 0; i<2;++ i)
    {
        cout << "  [" << i << "]";
        Fun fun1 = (Fun)*((int *)*(int *)(&a) + i);
        fun1();
        cout << "\t地址：\t" << *((int *)*(int *)(&a) + i) << endl;
    }
 
    //[1]
    cout << "[1]vbptr "  ;
    cout<<"\t地址：" << (int *)(&a) + 1<<endl;  //虛表指針的地址
    //輸出虛基類指針條目所指的內容
    for (int i = 0; i < 2; i++)
    {
        cout << "  [" << i << "]";
 
        cout << *(int *)((int *)*((int *)(&a) + 1) + i);
 
        cout << endl;
    }
 
 
    //[2]
    cout << "[2]B1::ib1=" << *(int*)((int *)(&a) + 2);
    cout << "\t地址：" << (int *)(&a) + 2;
    cout << endl;
 
    //[3]
    cout << "[3]值=" << *(int*)((int *)(&a) + 3);
    cout << "\t\t地址：" << (int *)(&a) + 3;
    cout << endl;
 
    //[4]
    cout << "[4]B::vptr";
    cout << "\t地址：" << (int *)(&a) +3<< endl;
 
    //輸出B::vptr中的虛函數
    for (int i = 0; i<2; ++i)
    {
        cout << "  [" << i << "]";
        Fun fun1 = (Fun)*((int *)*((int *)(&a) + 4) + i);
        fun1();
        cout << "\t地址:\t" << *((int *)*((int *)(&a) + 4) + i) << endl;
    }
 
    //[5]
    cout << "[5]B::ib=" << *(int*)((int *)(&a) + 5);
    cout << "\t地址: " << (int *)(&a) + 5;
    cout << endl;

運行結果：

這個結果與咱們的C++對象模型圖徹底符合。這時咱們能夠來分析一下虛表指針的第二個條目值12的具體來源了，回憶上文講到的：

第2、第三...個條目依次爲該類的最左虛繼承父類、次左虛繼承父類...的內存地址相對於虛基類表指針的偏移值。

在咱們的例子中，也就是B類實例內存地址相對於vbptr的偏移值，也便是：[4]-[1]的偏移值，結果即爲12，從地址上也能夠計算出來：007CFDFC-007CFDF4結果的十進制數正是12。如今，咱們對虛基類表的構成應該有了一個更好的理解。

6.3.虛擬菱形繼承

若是咱們有以下繼承層次：

class B{...}
class B1: virtual public  B{...}
class B2: virtual public  B{...}
class D : public B1,public B2{...}

類圖以下所示：

菱形虛擬繼承下，最派生類D類的對象模型又有不一樣的構成了。在D類對象的內存構成上，有如下幾點：

• 在D類對象內存中，基類出現的順序是：先是B1（最左父類），而後是B2（次左父類），最後是B（虛祖父類）
• D類對象的數據成員id放在B類前面，兩部分數據依舊以0來分隔。
• 編譯器沒有爲D類生成一個它本身的vptr，而是覆蓋並擴展了最左父類的虛基類表，與簡單繼承的對象模型相同。
• 超類B的內容放到了D類對象內存佈局的最後。

菱形虛擬繼承下的C++對象模型爲：

下面使用代碼加以驗證：

int main()
{
    D d;
    cout << "D對象內存大小爲：" << sizeof(d) << endl;
 
    //取得B1的虛函數表
    cout << "[0]B1::vptr";
    cout << "\t地址：" << (int *)(&d) << endl;
 
    //輸出虛表B1::vptr中的函數
    for (int i = 0; i<3; ++i)
    {
        cout << "  [" << i << "]";
        Fun fun1 = (Fun)*((int *)*(int *)(&d) + i);
        fun1();
        cout << "\t地址：\t" << *((int *)*(int *)(&d) + i) << endl;
    }
 
    //[1]
    cout << "[1]B1::vbptr ";
    cout << "\t地址：" << (int *)(&d) + 1 << endl;  //虛表指針的地址
    //輸出虛基類指針條目所指的內容
    for (int i = 0; i < 2; i++)
    {
        cout << "  [" << i << "]";
 
        cout << *(int *)((int *)*((int *)(&d) + 1) + i);
 
        cout << endl;
    }
 
 
    //[2]
    cout << "[2]B1::ib1=" << *(int*)((int *)(&d) + 2);
    cout << "\t地址：" << (int *)(&d) + 2;
    cout << endl;
 
    //[3]
    cout << "[3]B2::vptr";
    cout << "\t地址：" << (int *)(&d) + 3 << endl;
 
    //輸出B2::vptr中的虛函數
    for (int i = 0; i<2; ++i)
    {
        cout << "  [" << i << "]";
        Fun fun1 = (Fun)*((int *)*((int *)(&d) + 3) + i);
        fun1();
        cout << "\t地址:\t" << *((int *)*((int *)(&d) + 3) + i) << endl;
    }
 
    //[4]
    cout << "[4]B2::vbptr ";
    cout << "\t地址：" << (int *)(&d) + 4 << endl;  //虛表指針的地址
    //輸出虛基類指針條目所指的內容
    for (int i = 0; i < 2; i++)
    {
        cout << "  [" << i << "]";
 
        cout << *(int *)((int *)*((int *)(&d) + 4) + i);
 
        cout << endl;
    }
 
    //[5]
    cout << "[5]B2::ib2=" << *(int*)((int *)(&d) + 5);
    cout << "\t地址: " << (int *)(&d) + 5;
    cout << endl;
 
    //[6]
    cout << "[6]D::id=" << *(int*)((int *)(&d) + 6);
    cout << "\t地址: " << (int *)(&d) + 6;
    cout << endl;
 
    //[7]
    cout << "[7]值=" << *(int*)((int *)(&d) + 7);
    cout << "\t\t地址：" << (int *)(&d) + 7;
    cout << endl;
 
    //間接父類
    //[8]
    cout << "[8]B::vptr";
    cout << "\t地址：" << (int *)(&d) + 8 << endl;
 
    //輸出B::vptr中的虛函數
    for (int i = 0; i<2; ++i)
    {
        cout << "  [" << i << "]";
        Fun fun1 = (Fun)*((int *)*((int *)(&d) + 8) + i);
        fun1();
        cout << "\t地址:\t" << *((int *)*((int *)(&d) + 8) + i) << endl;
    }
 
    //[9]
    cout << "[9]B::id=" << *(int*)((int *)(&d) + 9);
    cout << "\t地址: " << (int *)(&d) +9;
    cout << endl;
 
    getchar();
}

查看運行結果：

7.一些問題解答

7.1.C++封裝帶來的佈局成本是多大？

在C語言中，「數據」和「處理數據的操做（函數）」是分開來聲明的，也就是說，語言自己並無支持「數據和函數」之間的關聯性。
在C++中，咱們經過類來將屬性與操做綁定在一塊兒，稱爲ADT，抽象數據結構。

C語言中使用struct（結構體）來封裝數據，使用函數來處理數據。舉個例子，若是咱們定義了一個struct Point3以下：

typedef struct Point3
{
    float x;
    float y;
    float z;
} Point3;

爲了打印這個Point3d，咱們能夠定義一個函數：

void Point3d_print(const Point3d *pd)
{
    printf("(%f,%f,%f)",pd->x,pd->y,pd_z);
}

而在C++中，咱們更傾向於定義一個Point3d類，以ADT來實現上面的操做:

class Point3d
{
    public:
        point3d (float x = 0.0,float y = 0.0,float z = 0.0)
            : _x(x), _y(y), _z(z){}

        float x() const {return _x;}
        float y() const {return _y;}
        float z() const {return _z;}
    
    private:
        float _x;
        float _y;
        float _z;
}；

    inline ostream&
    operator<<(ostream &os, const Point3d &pt)
    {
        os<<"("<<pr.x()<<","
            <<pt.y()<<","<<pt.z()<<")";
    }

看到這段代碼，不少人第一個疑問多是：加上了封裝，佈局成本增長了多少？答案是class Point3d並無增長成本。學過了C++對象模型，咱們知道，Point3d類對象的內存中，只有三個數據成員。

上面的類聲明中，三個數據成員直接內含在每個Point3d對象中，而成員函數雖然在類中聲明，卻不出如今類對象（object）之中，這些函數(non-inline)屬於類而不屬於類對象，只會爲類產生惟一的函數實例。

因此，Point3d的封裝並無帶來任何空間或執行期的效率影響。而在下面這種狀況下，C++的封裝額外成本纔會顯示出來：

• 虛函數機制（virtual function） , 用以支持執行期綁定，實現多態。
• 虛基類 （virtual base class） ，虛繼承關係產生虛基類，用於在多重繼承下保證基類在子類中擁有惟一實例。

不只如此，Point3d類數據成員的內存佈局與c語言的結構體Point3d成員內存佈局是相同的。C++中處在同一個訪問標識符（指public、private、protected）下的聲明的數據成員，在內存中一定保證以其聲明順序出現。而處於不一樣訪問標識符聲明下的成員則無此規定。對於Point3類來講，它的三個數據成員都處於private下，在內存中一塊兒聲明順序出現。咱們能夠作下實驗：

void TestPoint3Member(const Point3d& p)
{
 
    cout << "推測_x的地址是：" << (float *) (&p) << endl;
    cout << "推測_y的地址是：" << (float *) (&p) + 1 << endl;
    cout << "推測_z的地址是：" << (float *) (&p) + 2 << endl;
 
    cout << "根據推測出的地址輸出_x的值：" << *((float *)(&p)) << endl;
    cout << "根據推測出的地址輸出_y的值：" << *((float *)(&p)+1) << endl;
    cout << "根據推測出的地址輸出_z的值：" << *((float *)(&p)+2) << endl;
 
}

//測試代碼
    Point3d a(1,2,3);
    TestPoint3Member(a);

運行結果：

從結果能夠看到，_x,_y,_z三個數據成員在內存中緊挨着。

總結一下：
不考慮虛函數與虛繼承，當數據都在同一個訪問標識符下，C++的類與C語言的結構體在對象大小和內存佈局上是一致的，C++的封裝並無帶來空間時間上的影響。

7.2.下面這個空類構成的繼承層次中，每一個類的大小是多少？

今有類以下：

class B{};
class B1 :public virtual  B{};
class B2 :public virtual  B{};
class D : public B1, public B2{};

int main()
{
    B b;
    B1 b1;
    B2 b2;
    D d;
    cout << "sizeof(b)=" << sizeof(b)<<endl;
    cout << "sizeof(b1)=" << sizeof(b1) << endl;
    cout << "sizeof(b2)=" << sizeof(b2) << endl;
    cout << "sizeof(d)=" << sizeof(d) << endl;
    getchar();
}

輸出結果是：

解析：

• 編譯器爲空類安插1字節的char，以使該類對象在內存得以配置一個地址。
• b1虛繼承於b，編譯器爲其安插一個4字節的虛基類表指針（32爲機器），此時b1已不爲空，編譯器再也不爲其安插1字節的char（優化）。
• b2同理。
• d含有來自b1與b2兩個父類的兩個虛基類表指針。大小爲8字節。

完

轉載請註明原出處：http://www.cnblogs.com/QG-whz/p/4909359.html