C++对象的内存布局下篇
这篇博客是接上一篇,实际上本来是一篇的,但是我为了方便大家阅读,拆成了两篇,毕竟一篇特别长的博客实际上读起来非常的累,分成两篇就好多了.
-
让我们继续下一个例子,这个例子要复杂一点,是菱形继承,而且涉及到了虚基类.
先说一下为什么要虚基类,是为了避免下图这种情况:
image.png
上面图中这种情况,B1和B2的基类都是B(B1和B2对B都是public继承),所以在D对象中我们实际上有两个B的对象,B1对象中有一个,B2对象中有一个,造成空间资源浪费的情况,虽然有些情况下这可能正是我们想要的,有两个B的副本互不影响,但是部分情况,这可能并不是我们想要的.为此,C++引入了虚基类的概念.
虚拟继承的目的就是为了解决重复继承中多个重复间接父类的问题.为了解决上面的问题,我们只需要在B1和B2继承B的语句中在public后面加上关键字virtual即可,这便是虚拟继承,继承图如下所示:
image.png
不过在这里大家要注意下,这个图只是方便大家理解的,我的代码并不是这个结构了,前面的两个例子的概念图和代码中类的结构都是配套的,但是这个例子的两个概念图都是方便大家理解意思的,代码中类的结构并不和这个结构一样,因为这个图表示的类结构比较复杂,我觉得完全没有必要,只要理解虚基类在内存中到底是怎么布局,再复杂的问题都可以分解为我说的三个例子的组合.这几个概念图都是我从上面的那篇博客中截下来的,方便大家理解(主要原因是我懒得自己画这个图了(笑)),其他的结果图和结构都是我自己的,作为代码的参考
下面贴出代码:
#include <iostream>
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()的一个函数一样.
结语:到这里,总结的差不多了,费了我一天的时间来查资料,敲代码测试和写博客,不过感觉还是非常充实的,毕竟确实学到了很多很多的东西,毕竟古人说的好"朝闻道夕死可矣"(笑).
