C++ 多继承和虚继承的内存布局（转）

转自：http://www.oschina.net/translate/cpp-virtual-inheritancephp

警告. 本文有点技术难度，须要读者了解C++和一些汇编语言知识。html

在本文中，咱们解释由gcc编译器实现多继承和虚继承的对象的布局。虽然在理想的C++程序中不须要知道这些编译器内部细节，但不幸的是多重继承（特别是虚拟继承）的实现方式有各类各样的不太明确的结论（尤为是，关于向下转型指针，使用指向指针的指针，还有虚拟基类的构造方法的调用命令）。若是你了解多重继承是如何实现的，你就能预见到这些结论并运用到你的代码中。并且，若是你关心性能，理解虚拟继承的开销也是很是有用的。最后，这颇有趣。 :-)c++

多重继承

首先咱们考虑一个（非虚拟）多重继承的相对简单的例子。看看下面的C++类层次结构。程序员

1

2

3

4

5

6

7

8

9

使用UML图，咱们能够把这个层次结构表示为：

注意Top被继承了两次（在Eiffel语言中这被称做重复继承）。这意味着类型Bottom的一个实例bottom将有两个叫作a的元素（分别为bottom.Left::a和bottom.Right::a）。api

Left、Right和Bottom在内存中是如何布局的？让咱们先看一个简单的例子。Left和Right拥有以下的结构：函数

Left
Top::a
Left::b

Right
Top::a
Right::c

请注意第一个属性是从Top继承下来的。这意味着在下面两条语句后布局

1 2	`Left* left = <b>` `new` `</b> Left();` `Top* top = left;`

left和top指向了同一地址，咱们能够把Left Object当成Top Object来使用(很明显，Right与此也相似)。那Buttom呢？GCC的建议以下：

Bottom
Left::Top::a
Left::b
Right::Top::a
Right::c
Bottom::d

若是咱们提高Bottom指针，会发生什么事呢？

1 2	`Bottom* bottom = <b>` `new` `</b> Bottom();` `Left* left = bottom;`

这段代码工做正常。咱们能够把一个Bottom的对象看成一个Left对象来使用，由于两个类的内存部局是同样的。那么，若是将其提高为Right呢？会发生什么事？性能

1	`Right* right = bottom;`

为了执行这条语句，咱们须要判断指针的值以便让它指向Bottom中对应的段。

	Bottom
	Left::Top::a
	Left::b
right	Right::Top::a
	Right::c
	Bottom::d

通过这一步，咱们能够像操做正常Right对象同样使用right指针访问bottom。虽然，bottom与right如今指向两个不一样的内存地址。出于完整性的缘故，思考一下执行下面这条语句时会出现什么情况。

1	`Top* top = bottom;`

是的，什么也没有。这条语句是有歧义的：编译器将会报错。

1	error: `Top ' is an ambiguous base of `Bottom'

两种方式能够避免这样的歧义

1 2	`Top* topL = (Left) bottom;` `Top topR = (Right*) bottom;`

执行这两条语句后，topL和left会指向一样的地址，topR和right也会指向一样的地址。

虚拟继承

为了不重复继承Top，咱们必须虚拟继承Top：测试

1

2

3

4

5

6

7

8

9

这就获得了以下的层次结构（也许是你一开始就想获得的）

虽然从程序员的角度看，这也许更加的明显和简便，但从编译器的角度看，这就变得很是的复杂。从新考虑下Bottom的布局，其中的一个（也许没有）多是：网站

Bottom

Left::Top::a

Left::b

Right::c

Bottom::d

这个布局的优势是，布局的第一部分与Left的布局重叠了，这样咱们就能够很容易的经过一个Left指针访问 Bottom类。但是咱们怎么处理

1	`Right* right = bottom;`

咱们将哪一个地址赋给right呢? 通过这个赋值，若是right是指向一个普通的Right对象，咱们应该就能使用 right了。可是这是不可能的！Right自己的内存布局是彻底不一样的，这样咱们就没法像访问一个"真正的"Right对象同样，来访问升级的Bottom对象。并且，也没有其它（简单的）能够正常运做的Bottom布局。

解决办法是复杂的。咱们先给出解决方案，以后再来解释它。

你应该注意到了这个图中的两个地方。第一，字段的顺序是彻底不一样的（事实上，差很少是相反的）。第二，有几个vptr指针。这些属性是由编译器根据须要自动插入的（使用虚拟继承，或者使用虚拟函数的时候）。编译器也在构造器中插入了代码，来初始化这些指针。

vptr (virtual pointers)指向一个 “虚拟表”。类的每一个虚拟基类都有一个vptr指针。要想知道这个虚拟表 (vtable)是怎样运用的，看看下面的C++ 代码。

1 2	`Bottom* bottom = <b>` `new` `</b> Bottom();` `Left* left = bottom; <b>` `int` `</b> p = left->a;`

第二个赋值使left指向了bottom的所在地址（即，它指向了Bottom对象的“顶部”）。咱们想一想最后一条赋值语句的编译状况（稍微简化了）：

1

2

3

4

5

6

 
              movl left, %eax # %eax = left 
             
              movl (%eax), %eax # %eax = left.vptr.Left 
             
              movl (%eax), %eax # %eax =  
              virtual 
              base offset 
             
              addl left, %eax # %eax = left +  
              virtual 
              base offset 
             
              movl (%eax), %eax # %eax = left.a 
             
              movl %eax, p # p = left.a

用语言来描述的话，就是咱们用left指向虚拟表，而且由它得到了“虚拟基类偏移”(vbase)。这个偏移以后就加到了left，而后left就用来指向Bottom对象的Top部分。从这张图你能够看到Left的虚拟基类偏移是20；若是假设Bottom中的全部字段都是4个字节，那么给left加上20字节将会确实指向a字段。

通过这个设置，咱们就能够一样的方法访问Right部分。按这样

1 2	`Bottom* bottom = <b>` `new` `</b> Bottom();` `Right* right = bottom; <b>` `int` `</b> p = right->a;`

以后right将指向Bottom对象的合适的部位：

	Bottom
	vptr.Left
	Left::b
right	vptr.Right
	Right::c
	Bottom::d
	Top::a

对top的赋值如今能够编译成像前面Left一样的方式。惟一的不一样就是如今的vptr是指向了虚拟表的不一样部位：取得的虚拟表偏移是12，这彻底正确（肯定！）。咱们能够将其图示归纳：

固然，这个例子的目的就是要像访问真正Right对象同样访问升级的Bottom对象。所以，咱们必须也要给Right（和Left）布局引入vptrs：

如今咱们就能够经过一个Right指针，一点也不费事的访问Bottom对象了。不过，这是付出了至关大的代价：咱们要引入虚拟表，类须要扩展一个或更多个虚拟指针，对一个对象的一个简单属性的查询如今须要两次间接的经过虚拟表（即便编译器某种程度上能够减少这个代价）。

向下转换

如咱们所见，将一个派生类的指针转换为一个父类的指针(或者说，向上转换)可能涉及到给指针增添一个偏移。有人可能会想了，这样向下转换（反方向的）就能够简单的经过减去一样的偏移来实现。确实，对非虚拟继承来讲是这样的。但是，虚拟继承（绝不奇怪的！）带来了另外一种复杂性。

假设咱们像下面这个类这样扩展继承层次。

1

2

3

 
              class 
              AnotherBottom :  
              public 
              Left,  
              public 
              Right 
             
 
              {  
              public 
              :  
              int 
              e;  
              int 
              f; 
             
 
              }; 
             

继承层次如今看起来是这样

如今考虑一下下面的代码。

1

2

3

4

5

 
              Bottom* bottom1 =  
              new 
              Bottom(); 
             
              AnotherBottom* bottom2 =  
              new 
              AnotherBottom(); 
             
              Top* top1 = bottom1; 
             
              Top* top2 = bottom2; 
             
              Left* left =  
              static_cast 
              <Left*>(top1);

下图显示了Bottom和AnotherBottom的布局，并且在最后一个赋值后面显示了指向top的指针。

	Bottom
	vptr.Left
	Left::b
	vptr.Right
	Right::c
	Bottom::d
top1	Top::a

	AnotherBottom
	vptr.Left
	Left::b
	vptr.Right
	Right::c
	AnotherBottom::e
	AnotherBottom::f
top2	Top::a

如今考虑一下怎么去实现从top1到left的静态转换，同时要想到，咱们并不知道top1是否指向一个Bottom类型的对象，或者是指向一个AnotherBottom类型的对象。因此这办不到！这个重要的偏移依赖于top1运行时的类型（Bottom则20，AnotherBottom则24）。编译器将报错：

1 2	error: cannot convert from base `Top ' to derived type `Left' `via` `virtual` base `Top'

由于咱们须要运行时的信息，因此应该用一个动态转换来替代实现：

1	`Left* left = <b>` `dynamic_cast` `<</b>Left*<b>></b>(top1);`

但是，编译器仍然不满意：

1 2	`error: cannot` `dynamic_cast` `top ' (of type `class Top' `) to type` ` `class` `Left' (source type is not polymorphic)`

（注：polymorphic多态的）

问题在于，动态转换（转换中使用到typeid）须要top1所指向对象的运行时类型信息。可是，若是你看看这张图，你就会发现，在top1指向的位置，咱们仅仅只有一个integer (a)而已。编译器没有包含指向Top的虚拟指针，由于它不认为这是必需的。为了强制编译器包含进这个vptr指针，咱们能够给Top增长一个虚拟的析构器：

1

2

3

 
              <b> 
              class 
              </b> Top 
             
 
              { <b> 
              public 
              </b>: <span><b> 
              virtual 
              </b> ~Top() {}</span> <b> 
              int 
              </b> a; 
             
 
              }; 
             

这个修改须要指向Top的vptr指针。Bottom的新布局是

(固然相似的其它类也有一个新的指向Top的vptr指针)。如今编译器为动态转换插进了一个库调用：

1	`left = __dynamic_cast(top1, typeinfo_for_Top, typeinfo_for_Left, -1);`

这个函数__dynamic_cast定义在stdc++库中(相应的头文件是cxxabi.h)；参数为Top的类型信息，Left和Bottom(经过vptr.Top)，这个转换能够执行。 (参数 -1 标示出Left和Top之间的关系如今仍是未知)。更多详细资料，请参考tinfo.cc 的具体实现。

总结语

最后，咱们来看看一些没告终的部分。

指针的指针

这里出现了一点使人迷惑的问题，可是若是你仔细思考下一的话它其实很简单。咱们来看一个例子。假设使用上一节用到的类层次结构(向下类型转换).在前面的小节咱们已经看到了它的结果：

1 2	`Bottom* b = <b>` `new` `</b> Bottom();` `Right* r = b;`

(在将b的值赋给r以前，须要将它调整8个字节，从而让它指向Bottom对象的Right部分).所以，咱们能够合法地将一个Bottom* 赋值给一个Right*的指针。可是Bottom**和Right**又会怎样呢？

1 2	`Bottom bb = &b;` `Right rr = bb;`

编译器会接受这样的形式吗？咱们快速测试一下，编译器会报错：

1	error: invalid conversion from `Bottom ' to `Right'

为何呢？假设编译器能够接受从bb到rr的赋值。咱们能够只管的看到结果以下：

1	`<img alt=` `"double pointers"` `src=` `"http://static.oschina.net/uploads/img/201309/25161720_1KNi.png"` `>`

所以，bb和rr都指向b，而且b和r指向Bottom对象的正确的章节。如今考虑当咱们赋值给*rr时会发生什么(注意*rr的类型时Right*,所以这个赋值是有效的):

1	`*rr = b;`

这样的赋值和上面的赋值给r在根本上是一致的。所以，编译器会用一样的方式实现它！特别地，它会在赋值给*rr以前将b的值调整8个字节。办事*rr指向的是b！咱们再一次图示化这个结果：

只要咱们经过*rr来访问Bottom对象这都是正确的，可是只要咱们经过b自身来访问它，全部的内存引用都会有8个字节的偏移---明显这是个不理想的状况。

所以，总的来讲，及时*a 和*b经过一些子类型相关，**aa和**bb倒是不相关的。

虚拟基类的构造函数

编译器必须确保对象的全部虚指针都被正确的初始化。特别是，编译器确保了类的全部虚基类都被调用，而且只被调用一次。若是你不显示地调用虚拟超类(无论他们在继承层次结构中的距离有多远)，编译器都会自动地插入调用他们缺省构造函数。

这样也会引来一些不能够预期的错误。以上面给出的类层次结构做为示例，并添加上构造函数的部分：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

 
              <b> 
              class 
              </b> Top 
             
              { <b> 
              public 
              </b>: 
             
              Top() { a = -1; } 
             
              Top(<b> 
              int 
              </b> _a) { a = _a; } <b> 
              int 
              </b> a; 
             
              }; <b> 
              class 
              </b> Left : <b> 
              public 
              </b> Top 
             
              { <b> 
              public 
              </b>: 
             
              Left() { b = -2; } 
             
              Left(<b> 
              int 
              </b> _a, <b> 
              int 
              </b> _b) : Top(_a) { b = _b; } <b> 
              int 
              </b> b; 
             
              }; <b> 
              class 
              </b> Right : <b> 
              public 
              </b> Top 
             
              { <b> 
              public 
              </b>: 
             
              Right() { c = -3; } 
             
              Right(<b> 
              int 
              </b> _a, <b> 
              int 
              </b> _c) : Top(_a) { c = _c; } <b> 
              int 
              </b> c; 
             
              }; <b> 
              class 
              </b> Bottom : <b> 
              public 
              </b> Left, <b> 
              public 
              </b> Right 
             
              { <b> 
              public 
              </b>: 
             
              Bottom() { d = -4; } 
             
              Bottom(<b> 
              int 
              </b> _a, <b> 
              int 
              </b> _b, <b> 
              int 
              </b> _c, <b> 
              int 
              </b> _d) : Left(_a, _b), Right(_a, _c) 
             
              { 
             
              d = _d; 
             
              } <b> 
              int 
              </b> d; 
             
              };

(首先考虑非虚拟的状况。)你会指望下面的代码段输出什么：

1

2

3

 
              Bottom bottom(1,2,3,4); 
             
              printf 
              ( 
              "%d %d %d %d %d\n" 
              , bottom.Left::a, bottom.Right::a, 
             
              bottom.b, bottom.c, bottom.d);

你可能会但愿获得下面的结果，而且也获得了下面的结果：

1	`1 1 2 3 4`

然而，如今考虑虚拟的状况(咱们虚拟继承自Top类)。若是咱们仅仅作那样一个改变，并再一次运行程序，咱们会获得：

1	`-1 -1 2 3 4`

为何呢？经过跟踪构造函数的执行，会发现：

1

2

3

4

 
              Top::Top() 
             
              Left::Left(1,2) 
             
              Right::Right(1,3) 
             
              Bottom::Bottom(1,2,3,4)

就像上面解释的同样，编译器在Bottom类执行其余构造函数以前中插入调用了缺省构造函数。而后，当Left去调用它自身的超类的构造函数时(Top),咱们会发现Top已经被初始化了所以构造函数不会被调用。

为了不这种状况，你应该显示的调用虚基类的构造函数：

1

2

3

4

 
              Bottom( 
              int 
              _a,  
              int 
              _b,  
              int 
              _c,  
              int 
              _d): Top(_a), Left(_a,_b), Right(_a,_c) 
             
              { 
             
              d = _d; 
             
              }

指针等价

再假设一样的（虚拟）类继承等级，你但愿这样就打印“相等”吗？

1

2

3

 
              Bottom* b =  
              new 
              Bottom(); 
             
              Right* r = b;  
              if 
              (r == b) 
             
              printf 
              ( 
              "Equal!\n" 
              );

记住这两个地址并不实际相等（r偏移了8个字节）。可是这应该对用户彻底透明；所以，实际上编译器在r与b比较以前，就给r减去了8个字节；这样，这两个地址就被认为是相等的了。

转换为void类型的指针

最后，咱们来思考一下当将一个对象转换为void类型的指针时会发生什么事情。编译器必须保证一个指针转换为void类型的指针时指向对象的顶部。使用虚函数表这很容易实现。你可能已经想到了指向top域的偏移量是什么。它是虚函数指针到对象顶部的偏移量。所以，转化为void类型的指针操做可使用查询虚函数表的方式来实现。然而必定要确保使用动态类型转换，以下：

dynamic_cast<void*>(b);

参考文献

[1] CodeSourcery, 特别是C++ ABI Summary, Itanium C++ ABI(不考虑名字，这些文档是在平台无关的上下文中引用的；特别低，structure of the vtables给出了虚函数表的详细信息)。

libstdc++实现的动态类型转化，和同RTTI和命名调整定义在 tinfo.cc中。

[2]libstdc++ 网站，特别是 C++ Standard Library API这一章节。

[3]Jan Gray 写的C++: Under the Hood

[4]Bruce Eckel的Thinking in C++(第二卷) 第9章"多重继承"。做者容许下载这本书download.