多重继承地内存分布

1、实用标准文案指针的比较再以上面 Bottom类继承关系为例讨论，下面这段代码会打印Equal 吗？1Bottom* b =new Bottom();2Right* r = b;34if (r = b)5printf( Equal! /n );先明确下这两个指针实际上是指向不同地址的，r 指针实际上在b 指针所指地址上偏移8字节 ，但是，这些C+ 内部细节不能告诉C+ 程序员，所以C+ 编译器在比较r 和 b 时，会把 r 减去 8 字节，然后再来比较，所以打印出的值是Equal.多重继承首先我们先来考虑一个很简单(non-virtual)的多重继承。 看看下面这个C+ 类层次结构。1 clas

2、s Top2 3 public :4 int a;5 ;6精彩文档实用标准文案7 class Left :publicTop8 9 public : 10 int b; 11 ; 1213 class Right : public Top14 15 public :16 int c;17 ;1819 class Bottom : public Left, public Right20 21 public :22 int d;23 ;24用 UML 表述如下 :精彩文档实用标准文案注意到 Top 类实际上被继承了两次，(这种机制在Eiffel 中被称作repeated inheritance)，

3、这就意味着在一个bottom对象中实际上有两个a 属性(attributes，可以通过bottom.Left:a和 bottom.Right:a访问 ) 。那么 Left 、Right 、Bottom在内存中如何分布的呢？我们先来看看简单的Left 和 Right内存分布：Right类的布局和 Left 是一样的，因此我这里就没再画图了。刺猬注意到上面类各自的第一个属性都是继承自Top 类，这就意味着下面两个赋值语句:精彩文档实用标准文案1Left* left = new Left();2Top* top = left;left 和 top实际上是指向两个相同的地址，我们可以把Left 对象当

4、作一个Top 对象 (同样也可以把Right对象当 Top 对象来使用 )。但是 Botom对象呢 ?GCC 是这样处理的：但是现在如果我们upcast一个 Bottom指针将会有什么结果?1 Bottom* bottom =newBottom();2 Left* left = bottom;这段代码运行正确。这是因为GCC 选择的这种内存布局使得我们可以把Bottom对象当作 Left 对象，它们两者 (Left 部分 )正好相同。 但是，如果我们把Bottom对象指针upcast到 Right对象呢 ?1 Right* right = bottom;如果我们要使这段代码正常工作的话，我们需

5、要调整指针指向Bottom中相应的部分。精彩文档实用标准文案通过调整，我们可以用right指针访问 Bottom对象，这时 Bottom对象表现得就如Right对象。但是bottom和 right指针指向了不同的内存地址。最后，我们考虑下:1 Top* top = bottom;恩，什么结果也没有，这条语句实际上是有歧义(ambiguous)的，编译器会报错: error:Top is an ambiguous base of Bottom。其实这两种带有歧义的可能性可以用如下语句加以区分：1 Top* topL = (Left*) bottom;2 Top* topR = (Right*)

6、bottom;这两个赋值语句执行之后，topL和 left指针将指向同一个地址，同样 topR和 right也将指向同一个地址。虚拟继承为了避免上述Top 类的多次继承，我们必须虚拟继承类Top 。1 class Top2 3 public :4 int a;5 ;6精彩文档实用标准文案7 class Left : virtual public Top8 9 public :10 int b;11 ;1213 class Right : virtual public Top14 15 public :16 int c;17 ;1819 class Bottom : public Left, p

7、ublic Right20 21 public :22 int d;23 ;24上述代码将产生如下的类层次图(其实这可能正好是你最开始想要的继承方式)。对于程序员来说，这种类层次图显得更加简单和清晰，不过对于一个编译器来说，这就复杂得多了。我们再用Bottom的内存布局作为例子考虑，它可能是这样的:精彩文档实用标准文案这种内存布局的优势在于它的开头部分(Left 部分 )和 Left 的布局正好相同， 我们可以很轻易地通过一个Left 指针访问一个Bottom对象。不过，我们再来考虑考虑Right:1 Right* right = bottom;虚拟继承为了避免上述Top 类的多次继承，我们必

8、须虚拟继承类Top 。1 class Top2 3 public :4 int a;5 ;67 class Left : virtual public Top8 9 public :10 int b;11 ;1213 class Right : virtual public Top14 15 public :16 int c;17 ;1819 class Bottom : public Left, public Right20 21 public :22 int d;精彩文档实用标准文案23 ;24上述代码将产生如下的类层次图(其实这可能正好是你最开始想要的继承方式)。对于程序员来说，这种类层

9、次图显得更加简单和清晰，不过对于一个编译器来说，这就复杂得多了。我们再用Bottom的内存布局作为例子考虑，它可能是这样的:这种内存布局的优势在于它的开头部分(Left 部分 )和 Left 的布局正好相同， 我们可以很轻易地通过一个Left 指针访问一个Bottom对象。不过，我们再来考虑考虑Right:1 Right* right = bottom;精彩文档实用标准文案这里我们应该把什么地址赋值给right指针呢？理论上说，通过这个赋值语句，我们可以把这个 right 指针当作真正指向一个Right 对象的指针 (现在指向的是 Bottom)来使用。但实际上这是不现实的！一个真正的Righ

10、t 对象内存布局和 Bottom对象 Right部分是完全不同的，所以其实我们不可能再把这个upcasted 的 bottom 对象当作一个真正的 right 对象来使用了。 而且，我们这种布局的设计不可能还有改进的余地了。这里我们先看看实际上内存是怎么分布的，然后再解释下为什么这么设计。上图有两点值得大家注意。第一点就是类中成员分布顺序是完全不一样的(实际上可以说是正好相反 )。第二点，类中增加了vptr 指针，这些是被编译器在编译过程中插入到类中的(在设计类时如果使用了虚继承，虚函数都会产生相关vptr) 。同时，在类的构造函数中会对相关指针做初始化，这些也是编译器完成的工作。Vptr指针

11、指向了一个“virtual table”。在类中每个虚基类都会存在与之对应的一个vptr指针。为了给大家展示virtual table作用，考虑下如下代码。1 Bottom* bottom = new Bottom();2 Left* left = bottom;3 int p = left-a;第二条的赋值语句让left 指针指向和bottom同样的起始地址(即它指向Bottom对象的“顶部” )。我们来考虑下第三条的赋值语句。精彩文档实用标准文案1movlleft , %eax# % eax = left2movl(% eax ), % eax# % eax = left .vptr.Le

12、ft3movl(% eax ), % eax# % eax =virtual base offset4addlleft , % eax# % eax = left+ virtual base offset5movl(% eax ), % eax# % eax = left .a6movl% eax , p# p = left .a总结下， 我们用 left指针去索引 ( 找到 )virtual table，然后在virtual table中获取到虚基类的偏移 (virtual base offset, vbase)，然后在 left指针上加上这个偏移量，这样我们就获取到了Bottom类中 To

13、p 类的开始地址。从上图中，我们可以看到对于Left 指针，它的 virtual base offset是 20 ，如果我们假设Bottom中每个成员都是4 字节大小，那么Left 指针加上20 字节正好是成员a 的地址。我们同样可以用相同的方式访问Bottom中 Right部分。1 Bottom* bottom = new Bottom();2 Right* right = bottom;3 int p = right-a;right指针就会指向在Bottom对象中相应的位置。精彩文档实用标准文案这里对于p 的赋值语句最终会被编译成和上述left 相同的方式访问a 。唯一的不同是就是 vpt

14、r ，我们访问的vptr现在指向了virtual table另一个地址，我们得到的virtual base offset也变为 12 。我们画图总结下：当然，关键点在于我们希望能够让访问一个真正单独的Right对象也如同访问一个经过upcasted（到 Right对象）的Bottom对象一样。这里我们也在Right对象中引入vptrs 。精彩文档实用标准文案OK ，现在这样的设计终于让我们可以通过一个Right指针访问Bottom对象了。不过，需要提醒的是以上设计需要承担一个相当大的代价：我们需要引入虚函数表，对象底层也必须扩展以支持一个或多个虚函数指针，原来一个简单的成员访问现在需要通过虚函

15、数表两次间接寻址 (编译器优化可以在一定程度上减轻性能损失)。Downcasting如我们猜想， 将一个指针从一个派生类到一个基类的转换(casting) 会涉及到在指针上添加偏移量。可能有朋友猜想，downcasting一个指针仅仅减去一些偏移量就行了吧。实际上，非虚继承情况下确实是这样，但是，对于虚继承来说，又不得不引入其它的复杂问题。这里我们在上面的例子中添加一些继承关系:1 class AnotherBottom : public Left, public Right2 3 public :4 int e;5 int f;6 ;这个继承关系如下图所示:精彩文档实用标准文案那么现在考虑如

16、下代码1 Bottom* bottom1 =new Bottom();2AnotherBottom* bottom2 =newAnotherBottom();3Top* top1 = bottom1;4Top* top2 = bottom2;5Left* left = static_cast (top1);下面这图展示了Bottom和 AnotherBottom的内存布局，同时也展示了各自top 指针所指向的位置。现在我们来考虑考虑从top1到 left 的 static_cast，注意这里我们并不清楚对于top1指针指向的对象是Bottom还是 AnotherBottom。这里是根本不能编译

17、通过的！因为根本不精彩文档实用标准文案能确认 top1运行时需要调整的偏移量(对于 Bottom是 20 ，对于 AnotherBottom是 24) 。所以编译器将会提出错误: error: cannot convert from base Top to derived type Leftvia virtual base Top。这里我们需要知道运行时信息，所以我们需要使用dynamic_cast：1 Left* left =dynamic_cast(top1);不过，编译器仍然会报错的error: cannot dynamic_cast top (of type class Top*) t

18、otype class Left* (source type is not polymorphic)。关键问题在于使用dynamic_cast（和使用typeid一样）需要知道指针所指对象的运行时信息。但是，回头看看上面的结构图，我们就会发现top1指针所指的仅仅是一个整数成员a。编译器没有在Bottom类中包含针对 top 的 vptr ，它认为这完全没有必要。为了强制编译器在Bottom中包含 top 的 vptr ，我们可以在top 类里面添加一个虚析构函数。1 class Top2 3public:4virtualTop() 5 int a;6 ;这就迫使编译器为Top 类添加了一个v

19、ptr 。下面来看看Bottom新的内存布局：精彩文档实用标准文案是的，其它派生类 (Left 、Right) 都会添加一个vptr.top，编译器为dynamic_cast生成了一个库函数调用。1 left = _dynamic_cast(top1, typeinfo_for_Top, typeinfo_for_Left, -1 );_dynamic_cast定义在 libstdc+(对应的头文件是cxxabi.h) ，有了 Top 、Left 和 Bottom的类型信息，转换得以执行。其中，参数-1 代表的是类Left 和类 Top 之间的关系未明。如果想详细了解，请参看tinfo.cc的

20、实现。二级指针这里的问题初看摸不着头脑，但是细细想来有些问题还是显而易见的。这里我们考虑一个问题，还是以上节的Downcasting中的类继承结构图作为例子。1 Bottom* b =new Bottom();2 Right* r = b;(在把 b 指针的值赋值给指针r 时， b 指针将加上8 字节，这样r 指针才指向Bottom对象中 Right 部分 )。因此我们可以把 Bottom* 类型的值赋值给 Right* 对象。但是 Bottom* 和Right* 两种类型的指针之间赋值呢？1 Bottom* bb = &b;2 Right* rr = bb;编译器能通过这两条语句吗？实际上编

21、译器会报错: error: invalid conversion fromBottom* to Right*为什么 ? 不妨反过来想想，如果能够将bb 赋值给 rr ，如下图所示。所以这里bb 和 rr 两精彩文档实用标准文案个指针都指向了b ，b 和 r 都指向了Bottom对象的相应部分。那么现在考虑考虑如果给*rr赋值将会发生什么。1 *rr = b;注意 *rr 是 Right* 类型 ( 一级 )的指针，所以这个赋值是有效的！这个就和我们上面给r 指针赋值一样(*rr 是一级的Right* 类型指针，而r 同样是一级Right* 指针 )。所以，编译器将采用相同的方式实现对*rr 的

22、赋值操作。实际上，我们又要调整 b 的值，加上8 字节，然后赋值给*rr ，但是现在 *rr 其实是指向b 的 ! 如下图呃，如果我们通过rr 访问 Bottom对象， 那么按照上图结构我们能够完成对Bottom对象的访问，但是如果是用b 来访问 Bottom对象呢，所有的对象引用实际上都偏移了8 字节明显是错误的！精彩文档实用标准文案总而言之，尽管*a 和 *b 之间能依靠类继承关系相互转化，而*a 和*b 不能有这种推论。虚基类的构造函数编译器必须要保证所有的虚函数指针要被正确的初始化。特别是要保证类中所有虚基类的构造函数都要被调用，而且还只能调用一次。如果你写代码时自己不显示调用构造函数

23、，编译器会自动插入一段构造函数调用代码。这将会导致一些奇怪的结果，同样考虑下上面的类继承结构图，不过要加入构造函数。1 class Top2 3 public :4Top() a = -1; 5 Top( int _a) a = _a; 6 int a;7 ;89 class Left :publicTop10 11 public :12Left() b = -2 ; 13 Left( int _a, int _b) : Top(_a) b = _b; 14 int b;15 ;16精彩文档实用标准文案17 class Right :publicTop18 19 public :20Right() c = -3; 21 Right( int _a, int _c) : Top(_a) c = _c; 22 int c;23 ;2425 class Bottom :publicLeft,publicRight26 27 public :28Bottom() d = -4 ; 29Bottom( int _a, int _b, int _c, int _d) : Left(_a, _b), Right(_a, _c)30 31 d = _d;3