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);

}

---

接下来就慢慢分析：

1）先通过调试查看内存中是如何分配的，并和我们打印出的虚函数表对应起来：

注：由于B，C是虚继承A，所以编译器为了解决菱形继承所带来的“二义性”以及“数据冗余”，便将A放在最末端，并在子类中存放一个虚基表，方便找到父类；而虚基表的前四个字节存放的是对于自己虚函数表的偏移量，再往下四个字节才是对于父类的偏移量。

---

2）接下来就抽象出来分析模型

---

总结

1）虚函数按照其声明顺序放于表中；

2）父类的虚函数在子类的虚函数前面（由于子类单继承父类，直接使用父类的虚函数表）；

3）覆盖的func()函数被放到了虚表中原来父类虚函数的位置；

4）没有被覆盖的函数依旧；

5）如果B，C虚继承A，并且B，C内部没有再声明或定义虚函数，则B，C没有对应的虚函数表；

6）在菱形的虚拟继承中，要注意A为B，C所共有的，在打印对应虚函数表时要注意偏移量。

---

如有图片看不清，请点击此处。