C++对象的内存布局下篇

这篇博客是接上一篇,实际上本来是一篇的,但是我为了方便大家阅读,拆成了两篇,毕竟一篇特别长的博客实际上读起来非常的累,分成两篇就好多了.

1. 让我们继续下一个例子,这个例子要复杂一点,是菱形继承,而且涉及到了虚基类.
   先说一下为什么要虚基类,是为了避免下图这种情况:

   
   
   image.png

   上面图中这种情况,B1和B2的基类都是B(B1和B2对B都是public继承),所以在D对象中我们实际上有两个B的对象,B1对象中有一个,B2对象中有一个,造成空间资源浪费的情况,虽然有些情况下这可能正是我们想要的,有两个B的副本互不影响,但是部分情况,这可能并不是我们想要的.为此,C++引入了虚基类的概念.

   虚拟继承的目的就是为了解决重复继承中多个重复间接父类的问题.为了解决上面的问题,我们只需要在B1和B2继承B的语句中在public后面加上关键字virtual即可,这便是虚拟继承,继承图如下所示:

   
   
   image.png

   不过在这里大家要注意下,这个图只是方便大家理解的,我的代码并不是这个结构了,前面的两个例子的概念图和代码中类的结构都是配套的,但是这个例子的两个概念图都是方便大家理解意思的,代码中类的结构并不和这个结构一样,因为这个图表示的类结构比较复杂,我觉得完全没有必要,只要理解虚基类在内存中到底是怎么布局,再复杂的问题都可以分解为我说的三个例子的组合.这几个概念图都是我从上面的那篇博客中截下来的,方便大家理解(主要原因是我懒得自己画这个图了(笑)),其他的结果图和结构都是我自己的,作为代码的参考

   下面贴出代码:

#include 
using namespace std;
struct A
{
        A(long v = 10): x(v) {}
        virtual void foo()
        {
                cout << "A::foo" << endl;
        }
        virtual void orFunc()
        {
                cout << "A::orFunc" << endl;
        }
        long x;
};
struct B : public virtual A
{
        B(long v = 20): y(v) {}
        virtual void orFunc()
        {
                cout << "B::orFunc" << endl;
        }
        virtual void fooB()
        {
                cout << "B::foo" << endl;
        }
        long y;
};
struct C : public virtual A
{
        C(long v = 30): z(v) {}
        virtual void orFunc()
        {
                cout << "C::orFunc" << endl;
        }
        virtual void fooC()
        {
                cout << "C::foo" << endl;
        }
        long z;
};
struct D : public B, public C
{
        D(long v = 100): B(20), C(30), A(10), l(v) {}
        virtual void orFunc()
        {
                cout << "D::orFunc" << endl;
        }
        virtual void fooD()
        {
                cout << "D::foo" << endl;
        }
        long l;
};
typedef void(*func)(void);
void printFunc(long **p, const int& index, const int& num)
{
        cout << "p[" << index << "] -> ";
        cout << endl;
        for(int i = 0; i < num; i++)
        {
                auto pFunc = (func)p[index][i];
                cout << '\t' << "[" << i << "]";
                pFunc();
        }
}
int main()
{
        cout << "-----------------------------" << endl;
        A a;
        long **pVtab = (long **)&a;
        cout << "A:" << endl;
        for(int i = 0; i < 2; i++)
        {
                if((long) pVtab[i] < 10000)
                        cout << dec << (long)pVtab[i] << endl;
                else
                        printFunc(pVtab, i, 2);
        }
        cout << "-----------------------------" << endl;
        cout << "B" << endl;
        B b;
        pVtab = (long **)&b;
        for(int i = 0; i < (sizeof(B) / sizeof(long)); i++)
        {
                if((long) pVtab[i] < 10000)
                        cout << dec << (long)pVtab[i] << endl;
                else
                {
                        if(i == 0)
                                printFunc(pVtab, i, 2);
                        else 
                                printFunc(pVtab,i,1);
                }
        }
        cout << "-----------------------------" << endl;
        cout << "D" << endl;
        D d;
        pVtab = (long **)&d;
        for(int i = 0; i < (sizeof(D) / sizeof(long)); i++)
        {
                if((long) pVtab[i] < 10000)
                        cout << dec << (long)pVtab[i] << endl;
                else
                {
                        if(0 == i)
                                printFunc(pVtab, i, 3);
                        else if(2 == i)
                                printFunc(pVtab, i, 2);
                        else 
                                printFunc(pVtab, i, 1);
                }
        }
        cout << "-----------------------------" << endl;
}

再贴出结果:

image.png

这里我的结果是三个对象的内存布局,分别是A,B,D,在图上也能看出来,这里需要注意的是当A作为虚基类的时候,A的虚表的第二项并不是直接指向派生类的orFunc(),而是指向一个virtual thunk to实际的函数,这里讲的可能不清楚,不过没关系,等下在图上我会画出来.
下面我画出D对象的内存布局,B对象的内存布局我就不画了,基本差不多.

image.png

下面有几点是我们需要注意的:

• D仍然和第一个父类(在这里即B)共享虚函数表,虚函数表中函数顺序是先B后D,先声明的靠前,后声明的在后面
• 重写的函数会覆盖掉基类中的函数,譬如上图中的D::orFunc()覆盖掉了B::orFunc()和C::orFunc().
• 在这里,A作为虚基类比较孤独(笑),他一个人坐落在对象的底部,和其他对象也没啥联系.
• 这里的***是有点意思的,我用gdb查看的话,gdb会告诉提示出来:virtual thunk to D::orFunc(),上网查了一下,简单来说像是转化为D::orFunc()的一个函数一样.

结语:到这里,总结的差不多了,费了我一天的时间来查资料,敲代码测试和写博客,不过感觉还是非常充实的,毕竟确实学到了很多很多的东西,毕竟古人说的好"朝闻道夕死可矣"(笑).