虛擬繼承實現原理

轉自：http://blog.csdn.net/jinri1234/article/details/5702011

虛繼承又叫虛擬繼承，是多重繼承中特有的概念。虛基類是爲解決多重繼承而出現的。首先還是先給出虛繼承和虛基類的定義。

虛繼承：在繼承定義中包含了virtual關鍵字的繼承關係；
虛基類：在虛繼承體系中的通過virtual繼承而來的基類，需要注意的是：struct CSubClass : public virtual CBase {}; 其中CBase稱之爲CSubClass的虛基類，而不是說CBase就是個虛基類，因爲CBase還可以不不是虛繼承體系中的基類。

1. 語法

語法有語言的本身的定義所決定，總體上來說非常的簡單，如下：
struct CSubClass : public virtual CBaseClass {};
其中可以採用public、protected、private三種不同的繼承關鍵字進行修飾，只要確保包含virtual就可以了，這樣一來就形成了虛繼承體系，同時CBaseClass就成爲了CSubClass的虛基類了。其實並沒有那麼的簡單，如果出現虛繼承體系的進一步繼承會出現什麼樣的狀況呢？
       如下所示：
            /*
             * 帶有數據成員的基類
             */
            struct CBaseClass1
            {
                CBaseClass1( size_t i ) : m_val( i ) {}

                size_t m_val;
            };
            /*
             * 虛擬繼承體系
             */
            struct CSubClassV1 : public virtual CBaseClass1
            {
                CSubClassV1( size_t i ) : CBaseClass1( i ) {}
            };
            struct CSubClassV2 : public virtual CBaseClass1
            {
                CSubClassV2( size_t i ) : CBaseClass1( i ) {}
            };
            struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
            {
                CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
            };
            struct CDiamondSubClass1 : public CDiamondClass1
            {
                CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
            };
       注意上面代碼中的CDiamondClass1和CDiamondSubClass1兩個類的構造函數初始化列表中的內容。可以發現其中均包含了虛基類CBaseClass1的初始化工作，如果沒有這個初始化語句就會導致編譯時錯誤，爲什麼會這樣呢？一般情況下不是只要在CSubClassV1和CSubClassV2中包含初始化就可以了麼？要解釋該問題必須要明白虛繼承的語義特徵，所以參看下面語義部分的解釋。

2. 語義
       從語義上來講什麼是虛繼承和虛基類呢？上面僅僅是從如何在C++語言中書寫合法的虛繼承類定義而已。首先來了解一下virtual這個關鍵字在C++中的公共含義，在C++語言中僅僅有兩個地方可以使用virtual這個關鍵字，一個就是類成員虛函數和這裏所討論的虛繼承。不要看這兩種應用場合好像沒什麼關係，其實他們在背景語義上具有virtual這個詞所代表的共同的含義，所以纔會在這兩種場合使用相同的關鍵字。
       那麼virtual這個詞的含義是什麼呢？
       virtual在《美國傳統詞典[雙解]》中是這樣定義的：
   adj.（形容詞）
   1. Existing or resulting in essence or effect though not in actual fact, form, or name:
   實質上的，實際上的：雖然沒有實際的事實、形式或名義，但在實際上或效果上存在或產生的；
2. Existing in the mind, especially as a product of the imagination. Used in literary criticism of text.
   虛的，內心的：在頭腦中存在的，尤指意想的產物。用於文學批評中。
我們採用第一個定義，也就是說被virtual所修飾的事物或現象在本質上是存在的，但是沒有直觀的形式表現，無法直接描述或定義，需要通過其他的間接方式或手段才能夠體現出其實際上的效果。那麼在C++中就是採用了這個詞意，不可以在語言模型中直接調用或體現的，但是確實是存在可以被間接的方式進行調用或體現的。比如：虛函數必須要通過一種間接的運行時（而不是編譯時）機制才能夠激活（調用）的函數，而虛繼承也是必須在運行時才能夠進行定位訪問的一種體制。存在，但間接。其中關鍵就在於存在、間接和共享這三種特徵。對於虛函數而言，這三個特徵是很好理解的，間接性表明了他必須在運行時根據實際的對象來完成函數尋址，共享性表象在基類會共享被子類重載後的虛函數，其實指向相同的函數入口。
       對於虛繼承而言，這三個特徵如何理解呢？存在即表示虛繼承體系和虛基類確實存在，間接性表明了在訪問虛基類的成員時同樣也必須通過某種間接機制來完成（下面模型中會講到），共享性表象在虛基類會在虛繼承體系中被共享，而不會出現多份拷貝。那現在可以解釋語法小節中留下來的那個問題了，“爲什麼一旦出現了虛基類，就必須在沒有一個繼承類中都必須包含虛基類的初始化語句”。由上面的分析可以知道，虛基類是被共享的，也就是在繼承體系中無論被繼承多少次，對象內存模型中均只會出現一個虛基類的子對象（這和多繼承是完全不同的），這樣一來既然是共享的那麼每一個子類都不會獨佔，但是總還是必須要有一個類來完成基類的初始化過程（因爲所有的對象都必須被初始化，哪怕是默認的），同時還不能夠重複進行初始化，那到底誰應該負責完成初始化呢？C++標準中（也是很自然的）選擇在每一次繼承子類中都必須書寫初始化語句（因爲每一次繼承子類可能都會用來定義對象），而在最下層繼承子類中實際執行初始化過程。所以上面在每一個繼承類中都要書寫初始化語句，但是在創建對象時，而僅僅會在創建對象用的類構造函數中實際的執行初始化語句，其他的初始化語句都會被壓制不調用。

3. 模型
爲了實現上面所說的三種語義含義，在考慮對象的實現模型（也就是內存模型）時就很自然了。在C++中對象實際上就是一個連續的地址空間的語義代表，我們來分析虛繼承下的內存模型。
3.1. 存在
也就是說在對象內存中必須要包含虛基類的完整子對象，以便能夠完成通過地址完成對象的標識。那麼至於虛基類的子對象會存放在對象的那個位置（頭、中間、尾部）則由各個編譯器選擇，沒有差別。（在VC8中無論虛基類被聲明在什麼位置，虛基類的子對象都會被放置在對象內存的尾部）
3.2. 間接
間接性表明了在直接虛基承子類中一定包含了某種指針（偏移或表格）來完成通過子類訪問虛基類子對象（或成員）的間接手段（因爲虛基類子對象是共享的，沒有確定關係），至於採用何種手段由編譯器選擇。（在VC8中在子類中放置了一個虛基類指針vbc，該指針指向虛函數表中的一個slot，該slot中存放則虛基類子對象的偏移量的負值，實際上就是個以補碼錶示的int類型的值，在計算虛基類子對象首地址時，需要將該偏移量取絕對值相加，這個主要是爲了和虛表中只能存放虛函數地址這一要求相區別，因爲地址是原碼錶示的無符號int類型的值）
3.3. 共享
共享表明了在對象的內存空間中僅僅能夠包含一份虛基類的子對象，並且通過某種間接的機制來完成共享的引用關係。在介紹完整個內容後會附上測試代碼，體現這些內容。
    4. 性能
       由於有了間接性和共享性兩個特徵，所以決定了虛繼承體系下的對象在訪問時必然會在時間和空間上與一般情況有較大不同。
4.1. 時間
在通過繼承類對象訪問虛基類對象中的成員（包括數據成員和函數成員）時，都必須通過某種間接引用來完成，這樣會增加引用尋址時間（就和虛函數一樣），其實就是調整this指針以指向虛基類對象，只不過這個調整是運行時間接完成的。（在VC8中通過打開彙編輸出，可以查看*.cod文件中的內容，在訪問虛基類對象成員時會形成三條mov間接尋址語句，而在訪問一般繼承類對象時僅僅只有一條mov常量直接尋址語句）
4.2. 空間
由於共享所以不同在對象內存中保存多份虛基類子對象的拷貝，這樣較之多繼承節省空間。
    5. 應用
談了那麼多語言特性和內容，那麼在什麼情況下需要使用虛繼承，而一般應該如何使用呢？這個問題其實很難有答案，一般情況下如果你確性出現多繼承沒有必要，必須要共享基類子對象的時候可以考慮採用虛繼承關係（C++標準ios體系就是這樣的）。由於每一個繼承類都必須包含初始化語句而又僅僅只在最底層子類中調用，這樣可能就會使得某些上層子類得到的虛基類子對象的狀態不是自己所期望的（因爲自己的初始化語句被壓制了），所以一般建議不要在虛基類中包含任何數據成員（不要有狀態），只可以作爲接口類來提供。

附錄：測試代碼
#include <ctime>
#include <iostream>

/*
* 帶有數據成員的基類
*/
struct CBaseClass1
{
    CBaseClass1( size_t i ) : m_val( i ) {}

    size_t m_val;
};
/*
* 虛擬繼承體系
*/
struct CSubClassV1 : public virtual CBaseClass1
{
    CSubClassV1( size_t i ) : CBaseClass1( i ) {}
};

struct CSubClassV2 : public virtual CBaseClass1
{
    CSubClassV2( size_t i ) : CBaseClass1( i ) {}
};

struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
{
    CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
};

struct CDiamondSubClass1 : public CDiamondClass1
{
    CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
};
/*
* 正常繼承體系
*/
struct CSubClassN1 : public CBaseClass1
{
    CSubClassN1( size_t i ) : CBaseClass1( i ) {}
};
struct CSubClassN2 : public CBaseClass1
{
    CSubClassN2( size_t i ) : CBaseClass1( i ) {}
};
struct CMultiClass1 : public CSubClassN1, public CSubClassN2
{
    CMultiClass1( size_t i ) : CSubClassN1( i ), CSubClassN2( i ) {}
};
struct CMultiSubClass1 : public CMultiClass1
{
    CMultiSubClass1( size_t i ) : CMultiClass1( i ) {}
};
/*
* 不帶有數據成員的接口基類
*/
struct CBaseClass2
{
    virtual void func() {};
    virtual ~CBaseClass2() {}
};
/*
* 虛擬繼承體系
*/
// struct CBaseClassX { CBaseClassX() {i1 = i2 = 0xFFFFFFFF;} size_t i1, i2;};
struct CSubClassV3 : public virtual CBaseClass2
{
};
struct CSubClassV4 : public virtual CBaseClass2
{
};
struct CDiamondClass2 : public CSubClassV3, public CSubClassV4
{
};
struct CDiamondSubClass2 : public CDiamondClass2
{
};

/*
* 正常繼承體系
*/
struct CSubClassN3 : public CBaseClass2
{
};
struct CSubClassN4 : public CBaseClass2
{
};
struct CMultiClass2 : public CSubClassN3, public CSubClassN4
{
};
struct CMultiSubClass2 : public CMultiClass2
{
};

/*
* 內存佈局用類聲明.
*/
struct CLayoutBase1
{
    CLayoutBase1() : m_val1( 0 ), m_val2( 1 ) {}

    size_t m_val1, m_val2;
};
struct CLayoutBase2
{
    CLayoutBase2() : m_val1( 3 ) {}

    size_t m_val1;
};
struct CLayoutSubClass1 : public virtual CBaseClass1, public CLayoutBase1, public CLayoutBase2
{
    CLayoutSubClass1() : CBaseClass1( 2 ) {}
};

#define MAX_TEST_COUNT 1000 * 1000 * 16
#define TIME_ELAPSE() ( std::clock() - start * 1.0 ) / CLOCKS_PER_SEC

int main( int argc, char *argv[] )
{
    /*
     * 類體系中的尺寸.
     */
    std::cout << "================================ sizeof ================================" << std::endl;
    std::cout << "    ----------------------------------------------------------------" << std::endl;
    std::cout << "sizeof( CBaseClass1 )       = " << sizeof( CBaseClass1 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassV1 )       = " << sizeof( CSubClassV1 ) << std::endl;
    std::cout << "sizeof( CSubClassV2 )       = " << sizeof( CSubClassV2 ) << std::endl;
    std::cout << "sizeof( CDiamondClass1 )    = " << sizeof( CDiamondClass1 ) << std::endl;
    std::cout << "sizeof( CDiamondSubClass1 ) = " << sizeof( CDiamondSubClass1 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassN1 )       = " << sizeof( CSubClassN1 ) << std::endl;
    std::cout << "sizeof( CSubClassN2 )       = " << sizeof( CSubClassN2 ) << std::endl;
    std::cout << "sizeof( CMultiClass1 )      = " << sizeof( CMultiClass1 ) << std::endl;
    std::cout << "sizeof( CMultiSubClass1 )   = " << sizeof( CMultiSubClass1 ) << std::endl;

    std::cout << "    ----------------------------------------------------------------" << std::endl;
    std::cout << "sizeof( CBaseClass2 )       = " << sizeof( CBaseClass2 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassV3 )       = " << sizeof( CSubClassV3 ) << std::endl;
    std::cout << "sizeof( CSubClassV4 )       = " << sizeof( CSubClassV4 ) << std::endl;
    std::cout << "sizeof( CDiamondClass2 )    = " << sizeof( CDiamondClass2 ) << std::endl;
    std::cout << "sizeof( CDiamondSubClass2 ) = " << sizeof( CDiamondSubClass2 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassN3 )       = " << sizeof( CSubClassN3 ) << std::endl;
    std::cout << "sizeof( CSubClassN4 )       = " << sizeof( CSubClassN4 ) << std::endl;
    std::cout << "sizeof( CMultiClass2 )      = " << sizeof( CMultiClass2 ) << std::endl;
    std::cout << "sizeof( CMultiSubClass2 )   = " << sizeof( CMultiSubClass2 ) << std::endl;
    /*
     * 對象內存佈局
     */
    std::cout << "================================ layout ================================" << std::endl;
    std::cout << "    --------------------------------MI------------------------------" << std::endl;
    CLayoutSubClass1 *lsc = new CLayoutSubClass1;
    std::cout << "sizeof( CLayoutSubClass1 )   = " << sizeof( CLayoutSubClass1 ) << std::endl;
    std::cout << "CLayoutBase1 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase1 *)lsc - (char*)lsc << std::endl;
    std::cout << "CBaseClass1 offset of CLayoutSubClass1 is " << (char*)(CBaseClass1 *)lsc - (char*)lsc << std::endl;
    std::cout << "CLayoutBase2 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase2 *)lsc - (char*)lsc << std::endl;

    int *ptr = (int*)lsc;
    std::cout << "vbc in CLayoutSubClass1 is " << *(int*)ptr[3] << std::endl;

    delete lsc;

    std::cout << "    --------------------------------SI------------------------------" << std::endl;
    CSubClassV1 *scv1 = new CSubClassV1( 1 );
    std::cout << "sizeof( CSubClassV1 )   = " << sizeof( CSubClassV1 ) << std::endl;
    std::cout << "CBaseClass1 offset of CSubClassV1 is " << (char*)(CBaseClass1 *)scv1 - (char*)scv1 << std::endl;

    ptr = (int*)scv1;
    std::cout << "vbc in CSubClassV1 is " << *(int*)ptr[0] << std::endl;

    delete scv1;

    /*
     * 性能測試
     */
    std::cout << "================================ Performance ================================" << std::endl;
    double times[4];
    size_t idx = 0;

    CSubClassV1 *ptr1 = new CDiamondClass1( 1 );
    std::clock_t start = std::clock();
    {
        for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
            ptr1->m_val = i;
    }
    times[idx++] = TIME_ELAPSE();
    delete static_cast<CDiamondClass1*>( ptr1 );

    CSubClassN1 *ptr2 = new CMultiClass1( 0 );
    start = std::clock();
    {
        for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
            ptr2->m_val = i;
    }
    times[idx++] = TIME_ELAPSE();
    delete static_cast<CMultiClass1*>( ptr2 );

    std::cout << "CSubClassV1::ptr1->m_val " << times[0] << " s" << std::endl;
    std::cout << "CSubClassN1::ptr2->m_val " << times[1] << " s" << std::endl;

    return 0;
}

測試環境：
    軟件環境：Visual Studio2005 Pro + SP1, boost1.34.0
    硬件環境：PentiumD 3.0GHz, 4G RAM
測試數據：
================================ sizeof ================================
    ----------------------------------------------------------------
sizeof( CBaseClass1 )       = 4

sizeof( CSubClassV1 )       = 8
sizeof( CSubClassV2 )       = 8
sizeof( CDiamondClass1 )    = 12
sizeof( CDiamondSubClass1 ) = 12

sizeof( CSubClassN1 )       = 4
sizeof( CSubClassN2 )       = 4
sizeof( CMultiClass1 )      = 8
sizeof( CMultiSubClass1 )   = 8
    ----------------------------------------------------------------
sizeof( CBaseClass2 )       = 4

sizeof( CSubClassV3 )       = 8
sizeof( CSubClassV4 )       = 8
sizeof( CDiamondClass2 )    = 12
sizeof( CDiamondSubClass2 ) = 12

sizeof( CSubClassN3 )       = 4
sizeof( CSubClassN4 )       = 4
sizeof( CMultiClass2 )      = 8
sizeof( CMultiSubClass2 )   = 8
================================ layout ================================
    --------------------------------MI------------------------------
sizeof( CLayoutSubClass1 )   = 20
CLayoutBase1 offset of CLayoutSubClass1 is 0
CBaseClass1 offset of CLayoutSubClass1 is 16
CLayoutBase2 offset of CLayoutSubClass1 is 8
vbc in CLayoutSubClass1 is -12
    --------------------------------SI------------------------------
sizeof( CSubClassV1 )   = 8
CBaseClass1 offset of CSubClassV1 is 4
vbc in CSubClassV1 is 0
================================ Performance ================================
CSubClassV1::ptr1->m_val 0.062 s
CSubClassN1::ptr2->m_val 0.016 s

結果分析：
    1. 由於虛繼承引入的間接性指針所以導致了虛繼承類的尺寸會增加4個字節；
    2. 由Layout輸出可以看出，虛基類子對象被放在了對象的尾部（偏移爲16），並且vbc指針必須緊緊的接在虛基類子對象的前面，所以vbc指針所指向的內容爲“偏移 - 4”；
    3. 由於VC8將偏移放在了虛函數表中，所以爲了區分函數地址和偏移，所以偏移是用補碼int表示的負值；
    4. 間接性可以通過性能來看出，在虛繼承體系同通過指針訪問成員時的時間一般是一般類訪問情況下的4倍左右，符合彙編語言輸出文件中的彙編語句的安排。

轉自：http://www.cppblog.com/chemz/archive/2008/10/16/26135.html

#include <iostream>

using namespace std;

class BB

{

private:

int m_bb;

public:

BB() {m_bb=11;}

virtual ~BB(){}

virtual void vfbb() { cout<<"BB::vfbb"<<endl;}

};

class B1:virtual public BB

{

private:

int m_b1;

public:

B1() {m_b1=1;}

virtual ~B1(){}

virtual void vfb1() { cout<<"B1::vfb1"<<endl;}

};

class B2:virtual public BB

{

private:

int m_b2;

public:

B2() {m_b2=2;}

virtual ~B2(){}

virtual void vfb2() { cout<<"B2::vfb2"<<endl;}

};

class DD:public B1, public B2

{

private:

int m_dd;

public:

DD(){m_dd=4;}

virtual ~DD(){}

virtual void vfdd() { cout<<"DD::vfdd"<<endl;}

};

typedef void (*Fun)();

int main()

{

Fun pFun;

DD d;

cout<<((int*)*(int*)(&d))<<endl; //指向虛函數表

cout<<((int*)*((int*)(&d)+1))<<endl; //

cout<<((int*)*((int*)(&d)+2))<<endl;

cout<<((int*)*((int*)(&d)+3))<<endl;

cout<<((int*)*((int*)(&d)+4))<<endl;

cout<<((int*)*((int*)(&d)+5))<<endl;

cout<<((int*)*((int*)(&d)+6))<<endl;

cout<<((int*)*((int*)(&d)+7))<<endl;

cout<<((int*)*((int*)(&d)+8))<<endl;