C++对象模型之详述C++对象的内存布局

void visitVtbl(int **vtbl, int count)
{
    cout << vtbl << endl;
    cout << "\t[-1]: " << (long)vtbl[-1] << endl;

    typedef void (*FuncPtr)();
    for (int i = 0; vtbl[i] && i < count; ++i)
    {
        cout << "\t[" << i << "]: " << vtbl[i] << " -> ";
        FuncPtr func = (FuncPtr)vtbl[i];
        func();
    }
}

class Base
{
    public:
        Base()
        {
            mBase1 = 101;
            mBase2 = 102;
        }
        virtual void func1()
        {
            cout << "Base::func1()" << endl;
        }
        virtual void func2()
        {
            cout << "Base::func2()" << endl;
        }
    private:
        int mBase1;
        int mBase2;
};

class Derived : public Base
{
    public:
        Derived():
            Base()
        {
            mDerived1 = 1001;
            mDerived2 = 1002;
        }
        virtual void func2()
        {
            cout << "Derived::func2()" << endl;
        }
        virtual void func3()
        {
            cout << "Derived::func3()" << endl;
        }
    private:
        int mDerived1;
        int mDerived2;
};

int main()
{
    Derived d;
    int *p = (int*)&d;
    visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;

    return 0;
}

class Base1
{
    public:
        Base1()
        {
            mBase1 = 101;
        }
        virtual void funcA()
        {
            cout << "Base1::funcA()" << endl;
        }
        virtual void funcB()
        {
            cout << "Base1::funcB()" << endl;
        }
    private:
        int mBase1;
};

class Base2
{
    public:
        Base2()
        {
            mBase2 = 102;
        }
        virtual void funcA()
        {
            cout << "Base2::funcA()" << endl;
        }
        virtual void funcC()
        {
            cout << "Base2::funcC()" << endl;
        }
    private:
        int mBase2;
};

class Derived : public Base1, public Base2
{
    public:
        Derived():
            Base1(),
            Base2()
        {
            mDerived = 1001;
        }
        virtual void funcD()
        {
            cout << "Derived::funcD()" << endl;
        }
        virtual void funcA()
        {
            cout << "Derived::funcA()" << endl;
        }
    private:
        int mDerived;
};

int main()
{
    Derived d;
    int *p = (int*)&d;
    visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    ++p; visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;

    return 0;
}

class Base
{
    public:
        Base()
        {
            mBase = 11;
        }
        virtual void funcA()
        {
            cout << "Base::funcA()" << endl;
        }
        virtual void funcX()
        {
            cout << "Base::funcX()" << endl;
        }
    protected:
        int mBase;
};
class Base1 : public Base
{
    public:
        Base1():
            Base()
        {
            mBase1 = 101;
        }
        virtual void funcA()
        {
            cout << "Base1::funcA()" << endl;
        }
        virtual void funcB()
        {
            cout << "Base1::funcB()" << endl;
        }
    private:
        int mBase1;
};
class Base2 : public Base
{
    public:
        Base2():
            Base()
        {
            mBase2 = 102;
        }
        virtual void funcA()
        {
            cout << "Base2::funcA()" << endl;
        }
        virtual void funcC()
        {
            cout << "Base2::funcC()" << endl;
        }
    private:
        int mBase2;
};
class Derived : public Base1, public Base2
{
    public:
        Derived():
            Base1(),
            Base2()
        {
            mDerived = 1001;
        }
        virtual void funcD()
        {
            cout << "Derived::funcD()" << endl;
        }
        virtual void funcA()
        {
            cout << "Derived::funcA()" << endl;
        }
    private:
        int mDerived;
};

int main()
{
    Derived d;
    int *p = (int*)&d;
    visitVtbl((int**)*(int**)p, 4);
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;
    ++p; visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;
    return 0;
}

class Base  { ...... }; 
class Base1 : virtual public Base  { ...... };

int main()
{
    Base1 b1;
    int *p = (int*)&b1;
    visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    ++p; visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    return 0;
}

class Base  { ...... }; 
class Base1 : virtual public Base  { ...... };
class Base2 : virtual public Base  { ...... };
class Derived : public Base1, public Base2 { ...... };

使用如下的代码对对象的内存布局进行测试：

int main()
{
    Derived d;
    int *p = (int*)&d;
    visitVtbl((int**)*(int**)p, 3);
    ++p; cout << *p << endl;
    ++p; visitVtbl((int**)*(int**)p, 2);
    ++p; cout << *p << endl;
    ++p; cout << *p << endl;
    ++p; visitVtbl((int**)*(int**)p, 2);
    ++p; cout << *p << endl;
    return 0;
}

其运行结果如下：

根据测试的输出的结果，可以得出类Derived的对象的内存布局图如下：

使用虚继承后，在派生类的对象中只存在一份的Base子对象，从而避免了二义性。由于是多重继承，且有一个虚基类（Base），所以Derived类拥有三个虚函数表，其对象存在三个vptr。如上图所示，第一个虚函数表是由于多重继承而与第一基类（Base1）共享的主要实例，第二个虚函数表是与其他基类（Base2）有关的次要实例，第三个是虚基类的虚函数表。

类Derived的成员与Base1中的成员排列顺序相同，首先是以声明顺序排列其普通基类的成员，接着是派生类的成员，最后是虚基类的成员。

派生自虚基类的派生类的虚函数表中，也不含有虚基类中的virtual函数，派生类重写的virtual函数会在所有虚函数表中得到更新。

在类Derived的对象中，Base（虚基类）子对象部分为共享区域，而其他部分为不变区域。

7、关于虚析构函数的说明

上面的的例子中，为了让测试程序正常的运行，我们都没有定义一个virtual的析构函数，但是这并不表示它不是本文的讨论内容。

若基类声明了一个virtual析构函数，则其派生类的析构函数会更新其所有的虚函数表中的析构函数的项，把该项中的函数地址更新为派生类的析构函数的函数地址。因为当基类的析构函数为virtual时，若用户不显示提供一个析构函数，编译器则会自动合成一个，所以若基类声明了一个virtual析构函数，则其派生 类中必然存在一个virtual的析构函数，并用这个virutal析构函数更新虚函数表。

8、类型信息

在C++中，可以使用关键字typeid来获得一个对象所对应的类型信息，例如，以下代码：

Base *p;

......

cout << typeid(*p).name() << endl;

由于p是一个指针，它可以指向一个Base的对象，若者是Base的派生类，那么我们如何知道p所指的对象是什么类型呢？

通过观察2-6节中的例子的输出，可以发现，无论一个类有多少个虚函数，其下标为-1的项的值（即类型信息的值，是一个整数）都是相等的。所以通过指向派生类的基类指针或派生类指针来获取其类型信息时，都能获得其真实的信息。例如对于如下的测试代码（类的关系和实现是第5节中的钻石型虚拟继承）：

int main()
{
    Derived d;
    Base *basePtr = &d;
    Base1 *base1Ptr = &d;
    Base2 *base2Ptr = &d;
    Derived *derivedPtr = &d;
    cout << typeid(*basePtr).name() << endl;
    cout << typeid(*base1Ptr).name() << endl;
    cout << typeid(*base2Ptr).name() << endl;
    cout << typeid(*derivedPtr).name() << endl;
    return 0;
}

其输出结果如下

从上面的运行可以看出，一个派生类的对象，无论被其任何基类的指针指向，都能通过typeid正确地获得其所指的对象的真实类型。

运行结果解释：

要理解运行的结果，就要理解当把一个派生类对象指针赋值给其基类指针时会发生什么样的行为。当使用基类的指针指向一个派生类的对象时，编译器会安插相应的代码，调整指针的指向，使基类的指针指向派生类对象中其对应的基类子对象的起始处。

所以通过测试代码中的指针赋值，产生如下的结果：

basePtr 指向了对象d中的Base子对象的地址起始处，即指向了Base::vptr

base1Ptr 指向了对象d中的Base1子对象的地址起始处，即指向了Base1::vptr

base2Ptr 指向了对象d中的Base2子对象的地址起始处，即指向了Base2::vptr

derivedPtr 指向了对象d的地址起始处，即指向了Base1::vptr

即现在这些指针都指向了对应的类型的子对象，且其都包括一个vptr，所以就可以通过虚函数表中的第-1项的信息来获取类型信息，而这些信息都是相同的，且为表示该对象为类Derived的对象，所以就能正确地输出其类型信息。

9、虚函数调用的原理

我们知道，在C++中使用指向对象的指针或引用才能触发虚函数的调用，产生多态的结果。例如对于如下的代码片断：

Base *p;

......

p->vfunc(); // vfunc是Base中声明的virtual函数

由于指针p可以指向一个Base的对象，也可以指向Base的派生类的对象，而编译器在编译时并不知道p所指向的真实对象到底是什么，那么究竟如何判断呢？

从各种的C++对象的内存分布中可以看到，尽管虚函数表中的虚函数地址可能被更新（派生类重写基类的virtual函数）或添加新的项（派生类声明新的virtual函数），但是一个相同签名的虚函数在虚函数表中的索引值却是不变的。所以无论p指向的是Base的对象，还是Base的派生类的对象，其virtual函数vfunc在虚函数表中的索引是不变的（均为1）。

在了解了C++对象的内存布局后，就能轻松地回答这个问题了。因为在编译时，编译器根本无需判断p所指向的具体对象是什么，而是根据指针p所指向的对象的Base子对象中的虚函数表来实现函数调用的。编译器可能会把virtual函数调用的代码修改为如下的伪代码：

(*p->vptr[1])(p); // 假设vfunc函数在虚函数表中的索引值为1，参数p为this指针

若p指向的是一个Base的对象，则调Base的虚函数表中索引值为1的函数。若p指向的是一个Base的派生类的对象，则调用Base的派生类对象的Base子对象的虚函数表中的索引值为1的函数。这样便实现了多态 。这种函数调用是根据指针p所指的对象的虚函数表来实现的，在编译时由于无法确定指针p所指的真实对象，所以无法确定真实要调用哪一个函数，只有在运行时根据指针p所指的对象来动态决定。所以说，虚函数是在运行时动态绑定的，而不是在编译时静态绑定的。

C++对象模型之详述C++对象的内存布局

原文：http://blog.csdn.net/ljianhui/article/details/46408645