C++-對象繼承中的內存佈局

關於單繼承和多繼承的簡單概念可參考此文章（以下編譯環境均爲WIN32+VS2015）

虛函數表

對C++ 瞭解的人都應該知道虛函數（Virtual Function）是通過一張虛函數表（Virtual Table）來實現的。簡稱爲V-Table。在這個表中，主是要一個類的虛函數的地址表，這張表解決了繼承、覆蓋的問題，保證其容真實反應實際的函數。

首先先通過一個例子來引入虛函數表，假如現在有三個類如下：

class A //包含虛函數的類
{
public:
    virtual void func1()
    {}

    virtual void func2()
    {}
};

class B//空類
{};

class C //包含成員函數不包含成員變量的類
{
    void fun()
    {}
};

void Test1()
{
    cout << sizeof(A) << endl;
    cout << sizeof(B) << endl;
    cout << sizeof(C) << endl;
}

就上述的代碼，將會分別輸出4，1，1

造成A的大小爲4的原因就是：在A中存放了一個指向A類的虛函數表的指針。而32位下一個指針大小爲4字節，所以就爲4。

A類實例化後在內存中對應如下：

注：在虛函數表中用0來結尾。

通過內存中的顯示我們就能知道編譯器應該將虛函數表的指針存在於對象實例中最前面的位置，所以可以&a轉成int，取得虛函數表的地址，再強轉成（int）方便接下來可以每次只訪問四個字節大小（虛函數表可看做是一個函數指針數組，由於32位下指針是4字節，所以轉爲（int））。將取得的int指針傳給下面的打印虛函數表的函數，就能夠打印出對應的地址信息。

typedef void(*FUNC) ();

//int*VTavle = (int*)(*(int*)&a)
//傳參完成後就可打印出對應的信息。
void PrintVTable(int* VTable)
{
    cout << " 虛表地址>" << VTable << endl;
    for (int i = 0; VTable[i] != 0; ++i)
    {
        printf(" 第%d個虛函數地址 :0X%x,->", i, VTable[i]);
        FUNC f = (FUNC)VTable[i];
        f();
    }
    cout << endl;
}

接下來就來分析各種繼承關係中對應的內存模型以及虛函數表

單繼承（無虛函數覆蓋）

class A
{
public:
    virtual void func1()
    {
        cout << "A::func1" << endl;
    }

    virtual void func2()
    {
        cout << "A::func2" << endl;
    }

public:
    int _a;
};

class B : public A
{
public:
    virtual void func3()
    {
        cout << "B::func3" << endl;
    }

    virtual void func4()
    {
        cout << "B::func4" << endl;
    }

public:
    int _b;
};
void Test1()
{
    B b;
    b._a = 1;
    b._b = 2;

    int* VTable = (int*)(*(int*)&b);
    PrintVTable(VTable);
}

將內存中的顯示和我們寫的顯示虛函數表對應起來如下：

小結：

1）虛函數按照其聲明順序放於表中。

2）父類的虛函數在子類的虛函數前面。（由於子類單繼承父類，直接使用父類的虛函數表）

一般繼承（成員變量+虛函數覆蓋）

在上面例子進行稍微修改，使得子類中有對父類虛函數的覆蓋，進行和之前同樣的測試：

class A
{
public:
    virtual void func1()
    {
        cout << "A::func1" << endl;
    }

    virtual void func2()
    {
        cout << "A::func2" << endl;
    }

public:
    int _a;
};

class B : public A
{
public:
    virtual void func1()
    {
        cout << "B::func1" << endl;
    }

    virtual void func3()
    {
        cout << "B::func3" << endl;
    }

public:
    int _b;
};

小結：

1）覆蓋的func()函數被放到了虛表中原來父類虛函數的位置。

2）沒有被覆蓋的函數依舊。

多重繼承（成員變量+虛函數覆蓋）

class A
{
public:
    virtual void func1()
    {
        cout << "A::func1" << endl;
    }

    virtual void func2()
    {
        cout << "A::func2" << endl;
    }

public:
    int _a;
};

class B 
{
public:
    virtual void func3()
    {
        cout << "B::func1" << endl;
    }


public:
    int _b;
};

class C : public A , public B
{
    //覆蓋A::func1()
    virtual void func1()
    {
        cout << "C::func1()"<<endl;
    }

    virtual void func4()
    {
        cout << "C::func4()" << endl;
    }
public:
    int _c;
};

再次調試觀察：

小結：

多重繼承後的子類將與自己第一個繼承的父類公用一份虛函數表。（上述例子中A爲C的第一個繼承類）

菱形繼承（成員變量 + 虛函數覆蓋）

class A
{
public:
    virtual void func1()
    {
        cout << "A::func1" << endl;
    }

public:
    int _a;
};

class B : public A
{
public:
    virtual void func2()
    {
        cout << "B::func2" << endl;
    }

public:
    int _b;
};

class C : public A 
{
    virtual void func3()
    {
        cout << "C::func3()" << endl;
    }

public:
    int _c;
};

class D : public B , public C
{
    virtual void func2()
    {
        cout << "D::fun2()" << endl;
    }

    virtual void func4()
    {
        cout << "D::fun4()" << endl;
    }
public:
    int _d;
};

void Test1()
{
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;

    int* VTable = (int*)(*(int*)&d);
    PrintVTable(VTable);
}

掌握了單繼承和多繼承的規律，按照總結的一步步分析，就可以最終得到D的虛函數表。

由於子類B繼承父類A，所以B與A公用一個虛函數表，又因爲B是D多繼承中的第一個繼承的類，所以B，D共用一個虛函數表。

菱形的虛擬繼承（成員變量 + 虛函數覆蓋）

參考下面這個例子：

class A
{
public:
    virtual void func1()
    {
        cout << "A::func1()" << endl;
    }
    virtual void func2()
    {
        cout << "A::func2()" << endl;
    }

public:
    int _a;
};

class B : virtual public A//虛繼承A，覆蓋func1()
{
public:
    virtual void func1()
    {
        cout << "B::func1()" << endl;
    }
    virtual void func3()
    {
        cout << "B::func3()" << endl;
    }

public:
    int _b;
};

class C : virtual public A //虛繼承A，覆蓋func1()
{
    virtual void func1()
    {
        cout << "C::func1()" << endl;
    }

    virtual void func3()
    {
        cout << "C::func3()" << endl;
    }

public:
    int _c;
};

class D : public B , public C//虛繼承B，C,覆蓋func1()
{
    virtual void func1()
    {
        cout << "D::func1()" << endl;
    }

    virtual void func4()
    {
        cout << "D::func4()" << endl;
    }

public:
    int _d;
};

typedef void(*FUNC) ();

void PrintVTable(int* VTable)
{
    cout << " 虛表地址>" << VTable << endl;
    for (int i = 0; VTable[i] != 0; ++i)
    {
        printf(" 第%d個虛函數地址 :0X%x,->", i, VTable[i]);
        FUNC f = (FUNC)VTable[i];
        f();
    }
    cout << endl;
}

void Test1()
{
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;

    cout <<"sizeof(A) = "<< sizeof(A) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;
    cout << "sizeof(C) = " << sizeof(C) << endl;

    //打印d的虛函數表
    int* VTable = (int*)(*(int*)&d);
    PrintVTable(VTable);

    //打印C的虛函數表
    VTable = (int*)*(int*)((char*)&d + sizeof(B)-sizeof(A));    
    PrintVTable(VTable);

    //打印A的虛函數表
    VTable = (int*)*(int*)((char*)&d + sizeof(B)+sizeof(C)-2*sizeof(A)+4);  
    PrintVTable(VTable);

}