虛繼承與虛基類的本質(zhì)
    虛繼承和虛基類的定義是非常的簡單的，同時也是非常容易判斷一個繼承是否是虛繼承
的，雖然這兩個概念的定義是非常的簡單明確的，但是在C++語言中虛繼承作為一個比較生
僻的但是又是絕對必要的組成部份而存在著，并且其行為和模型均表現(xiàn)出和一般的繼承體系
之間的巨大的差異（包括訪問性能上的差異），現(xiàn)在我們就來徹底的從語言、模型、性能和
應用等多個方面對虛繼承和虛基類進行研究。
    首先還是先給出虛繼承和虛基類的定義。
    虛繼承：在繼承定義中包含了virtual關鍵字的繼承關系；
    虛基類：在虛繼承體系中的通過virtual繼承而來的基類，需要注意的是：
            struct CSubClass : public virtual CBase {}; 其中CBase稱之為CSubClass
            的虛基類，而不是說CBase就是個虛基類，因為CBase還可以不不是虛繼承體系
            中的基類。
    有了上面的定義后，就可以開始虛繼承和虛基類的本質(zhì)研究了，下面按照語法、語義、
模型、性能和應用五個方面進行全面的描述。

    1. 語法
       語法有語言的本身的定義所決定，總體上來說非常的簡單，如下：
           struct CSubClass : public virtual CBaseClass {};
       其中可以采用public、protected、private三種不同的繼承關鍵字進行修飾，只要
       確保包含virtual就可以了，這樣一來就形成了虛繼承體系，同時CBaseClass就成為
       了CSubClass的虛基類了。
       其實并沒有那么的簡單，如果出現(xiàn)虛繼承體系的進一步繼承會出現(xiàn)什么樣的狀況呢？
       如下所示：
            /*
             * 帶有數(shù)據(jù)成員的基類
             */
            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兩個類的構(gòu)造函數(shù)初始化列
       表中的內(nèi)容。可以發(fā)現(xiàn)其中均包含了虛基類CBaseClass1的初始化工作，如果沒有這
       個初始化語句就會導致編譯時錯誤，為什么會這樣呢？一般情況下不是只要在
       CSubClassV1和CSubClassV2中包含初始化就可以了么？要解釋該問題必須要明白虛
       繼承的語義特征，所以參看下面語義部分的解釋。
      
    2. 語義
       從語義上來講什么是虛繼承和虛基類呢？上面僅僅是從如何在C++語言中書寫合法的
       虛繼承類定義而已。首先來了解一下virtual這個關鍵字在C++中的公共含義，在C++
       語言中僅僅有兩個地方可以使用virtual這個關鍵字，一個就是類成員虛函數(shù)和這里
       所討論的虛繼承。不要看這兩種應用場合好像沒什么關系，其實他們在背景語義上
       具有virtual這個詞所代表的共同的含義，所以才會在這兩種場合使用相同的關鍵字。
       那么virtual這個詞的含義是什么呢？
       virtual在《美國傳統(tǒng)詞典[雙解]》中是這樣定義的：
           adj.（形容詞）
           1. Existing or resulting in essence or effect though not in actual
              fact, form, or name:
              實質(zhì)上的，實際上的：雖然沒有實際的事實、形式或名義，但在實際上或效
              果上存在或產(chǎn)生的；
           2. Existing in the mind, especially as a product of the imagination.
              Used in literary criticism of text.
              虛的，內(nèi)心的：在頭腦中存在的，尤指意想的產(chǎn)物。用于文學批評中。
       我們采用第一個定義，也就是說被virtual所修飾的事物或現(xiàn)象在本質(zhì)上是存在的，
       但是沒有直觀的形式表現(xiàn)，無法直接描述或定義，需要通過其他的間接方式或手段
       才能夠體現(xiàn)出其實際上的效果。
       那么在C++中就是采用了這個詞意，不可以在語言模型中直接調(diào)用或體現(xiàn)的，但是確
       實是存在可以被間接的方式進行調(diào)用或體現(xiàn)的。比如：虛函數(shù)必須要通過一種間接的
       運行時（而不是編譯時）機制才能夠激活（調(diào)用）的函數(shù)，而虛繼承也是必須在運行
       時才能夠進行定位訪問的一種體制。存在，但間接。其中關鍵就在于存在、間接和共
       享這三種特征。
       對于虛函數(shù)而言，這三個特征是很好理解的，間接性表明了他必須在運行時根據(jù)實際
       的對象來完成函數(shù)尋址，共享性表象在基類會共享被子類重載后的虛函數(shù)，其實指向
       相同的函數(shù)入口。
       對于虛繼承而言，這三個特征如何理解呢？存在即表示虛繼承體系和虛基類確實存在，
       間接性表明了在訪問虛基類的成員時同樣也必須通過某種間接機制來完成（下面模型
       中會講到），共享性表象在虛基類會在虛繼承體系中被共享，而不會出現(xiàn)多份拷貝。
       那現(xiàn)在可以解釋語法小節(jié)中留下來的那個問題了，“為什么一旦出現(xiàn)了虛基類，就必
       須在沒有一個繼承類中都必須包含虛基類的初始化語句”。由上面的分析可以知道，
       虛基類是被共享的，也就是在繼承體系中無論被繼承多少次，對象內(nèi)存模型中均只會
       出現(xiàn)一個虛基類的子對象（這和多繼承是完全不同的），這樣一來既然是共享的那么
       每一個子類都不會獨占，但是總還是必須要有一個類來完成基類的初始化過程（因為
       所有的對象都必須被初始化，哪怕是默認的），同時還不能夠重復進行初始化，那到
       底誰應該負責完成初始化呢？C++標準中（也是很自然的）選擇在每一次繼承子類中
       都必須書寫初始化語句（因為每一次繼承子類可能都會用來定義對象），而在最下層
       繼承子類中實際執(zhí)行初始化過程。所以上面在每一個繼承類中都要書寫初始化語句，
       但是在創(chuàng)建對象時，而僅僅會在創(chuàng)建對象用的類構(gòu)造函數(shù)中實際的執(zhí)行初始化語句，
       其他的初始化語句都會被壓制不調(diào)用。
      
    3. 模型
       為了實現(xiàn)上面所說的三種語義含義，在考慮對象的實現(xiàn)模型（也就是內(nèi)存模型）時就
       很自然了。在C++中對象實際上就是一個連續(xù)的地址空間的語義代表，我們來分析虛
       繼承下的內(nèi)存模型。
       3.1. 存在
           也就是說在對象內(nèi)存中必須要包含虛基類的完整子對象，以便能夠完成通過地址
           完成對象的標識。那么至于虛基類的子對象會存放在對象的那個位置（頭、中間、
           尾部）則由各個編譯器選擇，沒有差別。（在VC8中無論虛基類被聲明在什么位置，
           虛基類的子對象都會被放置在對象內(nèi)存的尾部）
       3.2. 間接
           間接性表明了在直接虛基承子類中一定包含了某種指針（偏移或表格）來完成通
           過子類訪問虛基類子對象（或成員）的間接手段（因為虛基類子對象是共享的，
           沒有確定關系），至于采用何種手段由編譯器選擇。（在VC8中在子類中放置了
           一個虛基類指針vbc，該指針指向虛函數(shù)表中的一個slot，該slot中存放則虛基
           類子對象的偏移量的負值，實際上就是個以補碼表示的int類型的值，在計算虛
           基類子對象首地址時，需要將該偏移量取絕對值相加，這個主要是為了和虛表
           中只能存放虛函數(shù)地址這一要求相區(qū)別，因為地址是原碼表示的無符號int類型
           的值）
       3.3. 共享
           共享表明了在對象的內(nèi)存空間中僅僅能夠包含一份虛基類的子對象，并且通過
           某種間接的機制來完成共享的引用關系。在介紹完整個內(nèi)容后會附上測試代碼，
           體現(xiàn)這些內(nèi)容。
    4. 性能
       由于有了間接性和共享性兩個特征，所以決定了虛繼承體系下的對象在訪問時必然
       會在時間和空間上與一般情況有較大不同。
       4.1. 時間
           在通過繼承類對象訪問虛基類對象中的成員（包括數(shù)據(jù)成員和函數(shù)成員）時，都
           必須通過某種間接引用來完成，這樣會增加引用尋址時間（就和虛函數(shù)一樣），
           其實就是調(diào)整this指針以指向虛基類對象，只不過這個調(diào)整是運行時間接完成的。
           （在VC8中通過打開匯編輸出，可以查看*.cod文件中的內(nèi)容，在訪問虛基類對象
           成員時會形成三條mov間接尋址語句，而在訪問一般繼承類對象時僅僅只有一條mov
           常量直接尋址語句）
       4.2. 空間
           由于共享所以不同在對象內(nèi)存中保存多份虛基類子對象的拷貝，這樣較之多繼承
           節(jié)省空間。
    5. 應用
       談了那么多語言特性和內(nèi)容，那么在什么情況下需要使用虛繼承，而一般應該如何使
       用呢？
       這個問題其實很難有答案，一般情況下如果你確性出現(xiàn)多繼承沒有必要，必須要共享
       基類子對象的時候可以考慮采用虛繼承關系（C++標準ios體系就是這樣的）。由于每
       一個繼承類都必須包含初始化語句而又僅僅只在最底層子類中調(diào)用，這樣可能就會使
       得某些上層子類得到的虛基類子對象的狀態(tài)不是自己所期望的（因為自己的初始化語
       句被壓制了），所以一般建議不要在虛基類中包含任何數(shù)據(jù)成員（不要有狀態(tài)），只
       可以作為接口類來提供。

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

/*
 * 帶有數(shù)據(jù)成員的基類
 */
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 ) {}
};
/*
 * 不帶有數(shù)據(jù)成員的接口基類
 */
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
{
};

/*
 * 內(nèi)存布局用類聲明.
 */
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;
    /*
     * 對象內(nèi)存布局
     */
    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;
}

測試環(huán)境：
    軟件環(huán)境：Visual Studio2005 Pro + SP1, boost1.34.0
    硬件環(huán)境：PentiumD 3.0GHz, 4G RAM
測試數(shù)據(jù)：
================================ 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

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