多重继承和虚继承的内存布局

这篇文章主要讲解虚继承的C++对象内存分布问题，从中也引出了dynamic_cast和static_cast本质区别、虚函数表的格式等一些大部分C++程序员都似是而非的概念。原文见这里 (By Edsko de Vries, January 2006)

      敬告:  本文是介绍 C++ 的技术文章，假定读者对于 C++ 有比较深入的认识，同时也需要一些汇编知识。

    本文我们将阐释GCC 编译器针对多重继承和虚拟继承下的对象内存布局。尽管在理想的使用环境中，一个 C++ 程序员并不需要了解这些编译器内部实现细节，实际上，编译器针对多重继承 ( 特别是虚拟继承 ) 的各种实现细节对于我们编写 C++ 代码都或多或少产生一些影响 ( 比如 downcasting pointer 、 pointers to pointers  以及虚基类构造函数的调用顺序 ) 。如果你能明白多重继承是如何实现的，那么你自己就能够预见到这些影响，进而能够在你的代码中很好地应对它们。再者，如果你十分在意的代码的运行效率，正确地理解虚继承也是很有帮助的。最后嘛，这个 hack 的过程是很有趣的哦 :)

   

多重继承

   首先我们先来考虑一个很简单(non-virtual) 的多重继承。看看下面这个 C++ 类层次结构。

 1 class  Top
 2 {
 3 public :
 4    int  a;
 5 };
 6
 7 class  Left : public  Top
 8 {
 9 public :
10    int  b;
11 };
12
13 class  Right : public  Top
14 {
15 public :
16    int  c;
17 };
18
19 class  Bottom : public  Left, public  Right
20 {
21 public :
22    int  d;
23 };
24
    用UML 表述如下:

    注意到Top 类实际上被继承了两次， ( 这种机制在 Eif fel中被称作 repeated inheritance ) ，这就意味着在一个bottom 对象中实际上有两个 a 属性( attributes ，可以通过bottom.Left::a 和  bottom.Right::a 访问 )  。

    那么Left 、 Right 、 Bottom 在内存中如何分布的呢？我们先来看看简单的 Left 和 Right 内存分布：

       [Right 类的布局和Left是一样的，因此我这里就没再画图了。刺猬]

       注意到上面类各自的第一个属性都是继承自Top 类，这就意味着下面两个赋值语句:

1 Left* left = new  Left();
2 Top* top = left;

       left和 top 实际上是指向两个相同的地址，我们可以把 Left 对象当作一个 Top 对象 ( 同样也可以把 Right 对象当 Top 对象来使用 ) 。但是 Botom 对象呢 ?GCC 是这样处理的：

     但是现在如果我们upcast  一个 Bottom 指针将会有什么结果 ?   

1 Bottom* bottom = new  Bottom();
2 Left* left = bottom;  

       这段代码运行正确。这是因为GCC 选择的这种内存布局使得我们可以把 Bottom 对象当作 Left 对象，它们两者 (Left 部分 ) 正好相同。但是，如果我们把 Bottom 对象指针 upcast 到 Right 对象呢 ?

1 Right* right = bottom;

      如果我们要使这段代码正常工作的话，我们需要调整指针指向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*) bottom;  

  这两个赋值语句执行之后，topL 和 left 指针将指向同一个地址，同样 topR 和 right 也将指向同一个地址 。

虚拟继承

   为了避免上述Top 类的多次继承，我们必须虚拟继承类 Top 。

 1 class Top
 2 {
 3     public :
 4         int  a;
 5 };
 6
 7 class Left : virtual public Top
 8 {
 9     public :
10         int  b;
11 };
12
13 class Right : virtual public Top
14 {
15     public :
16         int  c;
17 };
18
19 class Bottom : public Left, public Right
20 {
21     public :
22         int  d;
23 };
24 

   上述代码将产生如下的类层次图( 其实这可能正好是你最开始想要的继承方式 ) 。

     对于程序员来说，这种类层次图显得更加简单和清晰，不过对于一个编译器来说，这就复杂得多了。我们再用Bottom 的内存布局作为例子考虑，它可能是这样的 :

      

      这种内存布局的优势在于它的开头部分(Left 部分 ) 和 Left 的布局正好相同，我们可以很轻易地通过一个 Left 指针访问一个 Bottom 对象。不过，我们再来考虑考虑 Right:

1 Right* right = bottom;

  这里我们应该把什么地址赋值给right 指针呢？理论上说，通过这个赋值语句，我们可以把这个 right 指针当作真正指向一个 Right 对象的指针 ( 现在指向的是 Bottom) 来使用。但实际上这是不现实的！一个真正的 Right 对象内存布局和 Bottom 对象 Right 部分是完全不同的，所以其实我们不可能再把这个 upcasted 的 bottom 对象当作一个真正的 right 对象来使用了。而且，我们这种布局的设计不可能还有改进的余地了。这里我们先看看实际上内存是怎么分布的，然后再解释下为什么这么设计。

      上图有两点值得大家注意。第一点就是类中成员分布顺序是完全不一样的( 实际上可以说是正好相反 ) 。第二点，类中增加了 vptr 指针，这些是被编译器在编译过程中插入到类中的 ( 在设计类时如果使用了虚继承，虚函数都会产生相关 vptr) 。同时，在类的构造函数中会对相关指针做初始化，这些也是编译器完成的工作。Vptr指针指向了一个“ virtual table ”。在类中每个虚基类都会存在与之对应的一个 vptr 指针。为了给大家展示 virtual table 作用，考虑下如下代码。

1 Bottom* bottom = new Bottom();
2 Left* left = bottom;
3 int  p = left->a;
    第二条 的赋值语句让left 指针指向和 bottom 同样的起始地址 ( 即它指向 Bottom 对象的“顶部” ) 。我们来考虑下第三条的赋值语句。

1 movl   left , %eax         # %eax  = left
2 movl   (%eax ), %eax       # %eax  = left .vptr.Left
3 movl   (%eax ), %eax       # %eax  = virtual  base  offset  
4 addl   left , %eax         # %eax  = left  + virtual  base  offset
5 movl   (%eax ), %eax       # %eax  = left .a
6 movl   %eax , p            # p  = left .a

       总结下，我们用left 指针去索引 ( 找到 )virtual table ，然后在 virtual table 中获取 到 虚基类的偏移( virtual base offset , vbase)，然后在 left 指针上加上这个偏移量，这样我们就获取到了 Bottom 类中 Top 类的开始地址。 从上图中，我们可以看到对于 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 。唯一的不同是就是 vptr ，我们访问的 vptr 现在指向了 virtual table 另一个地址，我们得到的 virtual base offset 也变为 12 。我们画图总结下：

   当然，关键点在于我们希望能够让访问一个真正单独的Right 对象也如同访问一个经过 upcasted （到 Right 对象）的 Bottom 对象一样。这里我们也在 Right 对象中引入 vptrs 。

    OK，现在这样的设计终于让我们可以通过一个 Right 指针访问 Bottom 对象了。不过，需要提醒的是以上设计需要承担一个相当大的代价：我们需要引入虚函数表，对象底层也必须扩展以支持一个或多个虚函数指针，原来一个简单的成员访问现在需要通过虚函数表两次间接寻址 ( 编译器优化可以在一定程度上减轻性能损失 ) 。

 

Downcasting

   如我们猜想，将一个指针从一个派生类到一个基类的转换(casting) 会涉及到在指针上添加偏移量。可能有朋友猜想， downcasting 一个指针仅仅减去一些偏移量就行了吧。实际上，非虚继承情况下确实是这样，但是，对于虚继承来说，又不得不引入其它的复杂问题。这里我们在上面的例子中添加一些继承关系:

1 class AnotherBottom : public Left, public Right
2 {
3     public :
4         int  e;
5         int  f;
6 };

   这个继承关系如下图所示:

   那么现在考虑如下代码

1 Bottom* bottom1 = new  Bottom();
2 AnotherBottom* bottom2 = new  AnotherBottom();
3 Top* top1 = bottom1;
4 Top* top2 = bottom2;
5 Left* left = static_cast <Left*>(top1);
   下面这图展示了Bottom 和 AnotherBottom 的内存布局，同时也展示了各自 top 指针所指向的位置。

      现在我们来考虑考虑从top1 到 left 的 static_cast ，注意这里我们并不清楚对于 top1 指针指向的对象是 Bottom 还是 AnotherBottom 。这里是根本不能编译通过的！因为根本不能确认 top1 运行时需要调整的偏移量 ( 对于 Bottom 是 20 ，对于 AnotherBottom 是 24) 。所以编译器将会提出错误: error: cannot convert from base `Top' to derived type `Left' via virtual base `Top'。这里我们需要知道运行时信息，所以我们需要使用dynamic_cast：

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

    不过，编译器仍然会报错的 error: cannot dynamic_cast `top' (of type `class Top*') to type `class Left*' (source type is not polymorphic)。 关键问题在于使用dynamic_cast （和使用 typeid 一样）需要知道指针所指对象的运行时信息。 但是，回头看看上面的结构图，我们就会发现 top1 指针所指的仅仅是一个整数成员 a 。编译器没有在 Bottom 类中包含针对 top 的 vptr ，它认为这完全没有必要。为了强制编译器在 Bottom 中包含 top 的 vptr ，我们可以在 top 类里面添加一个虚析构函数。

1 class  Top
2 {
3     public :
4         virtual  ~Top() {}
5         int  a;
6 };

    这就迫使编译器为Top 类添加了一个 vptr 。下面来看看 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 的实现。

 

总结

    最后，我们再聊聊一些相关内容。

   

二级指针

   这里的问题初看摸不着头脑，但是细细想来有些问题还是显而易见的。这里我们考虑一个问题，还是以上节的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;

   编译器能通过这两条语句吗？实际上编译器会报错: error: invalid conversion from `Bottom**' to `Right**'
  为什么?  不妨反过来想想，如果能够将 bb 赋值给 rr ，如下图所示。所以这里 bb 和 rr 两个指针都指向了 b ， b 和 r 都指向了 Bottom 对象的相应部分。那么现在考虑考虑如果给 *rr 赋值将会发生什么。

1 *rr = b;  

  注意 *rr 是 Right* 类型 ( 一级 ) 的指针，所以这个赋值是有效的！

    这个就和我们上面给r 指针赋值一样 (*rr 是一级的 Right* 类型指针，而 r 同样是一级 Right* 指针 ) 。所以，编译器将采用相同的方式实现对 *rr 的赋值操作。实际上，我们又要调整 b 的值，加上 8 字节，然后赋值给 *rr ，但是现在 **rr 其实是指向 b 的 ! 如下图

    呃，如果我们通过rr 访问 Bottom 对象，那么按照上图结构我们能够完成对 Bottom 对象的访问，但是如果是用 b 来访问 Bottom 对象呢，所有的对象引用实际上都偏移了 8 字节——明显是错误的！

   总而言之，尽管*a 和 *b 之间能依靠类继承关系相互转化，而 **a 和 **b 不能有这种推论。

虚基类的构造函数

   编译器必须要保证所有的虚函数指针要被正确的初始化。特别是要保证类中所有虚基类的构造函数都要被调用，而且还只能调用一次。 如果你写代码时自己不显示调用构造函数，编译器会自动插入一段构造函数调用代码。这将会导致一些奇怪的结果，同样考虑下上面的类继承结构图，不过要加入构造函数。

 1 class  Top
 2 {
 3 public :
 4    Top() { a = -1 ; }
 5    Top(int  _a) { a = _a; }
 6    int  a;
 7 };
 8
 9 class  Left : public  Top
10 {
11 public :
12    Left() { b = -2 ; }
13    Left(int  _a, int  _b) : Top(_a) { b = _b; }
14    int  b;
15 };
16
17 class  Right : public  Top
18 {
19 public :
20    Right() { c = -3 ; }
21    Right(int  _a, int  _c) : Top(_a) { c = _c; }
22    int  c;
23 };
24
25 class  Bottom : public  Left, public  Right
26 {
27 public :
28    Bottom() { d = -4 ; }
29    Bottom(int  _a, int  _b, int  _c, int  _d) : Left(_a, _b), Right(_a, _c)
30     {
31       d = _d;
32     }
33    int  d;
34 };
35 
   先来考虑下不包含虚函数的情况，下面这段代码输出什么?

1 Bottom bottom(1 ,2 ,3 ,4 );
2 printf(" %d   %d   %d   %d   %d /n " , bottom.Left::a, bottom.Right::a, bottom.b, bottom.c, bottom.d);
   你可能猜想会有这样结果：

1 1 2 3 4
   但是，如果我们考虑下包含虚函数的情况呢，如果我们从Top 虚继承派生出子类，那么我们将得到如下结果：

-1 -1 2 3 4
   如本节开头所讲，编译器在Bottom 中插入了一个 Top 的默认构造函数，而且这个默认构造函数安排在其他的构造函数之前，当 Left 开始调用它的基类构造函数时，我们发现 Top 已经构造初始化好了，所以相应的构造函数不会被调用。如果跟踪构造函数，我们将会看到

Top::Top()
Left::Left(1,2)
Right::Right(1,3)
Bottom::Bottom(1,2,3,4)
   为了避免这种情况，我们应该显示地调用虚基类的构造函数

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

 

 

 

到void*  的转换

 1 dynamic_cast <void *>(b);

    最后我们来考虑下把一个指针转换到void * 。编译器会把指针调整到对象的开始地址。通过查 vtable ，这个应该是很容易实现。看看上面的 vtable 结构图，其中 offset to top 就是 vptr 到对象开始地址。另外因为要查阅 vtable ，所以需要使用 dynamic_cast 。

指针的比较

   再以上面Bottom类继承关系为例讨论，下面这段代码会打印Equal吗？

1 Bottom* b = new  Bottom();
2 Right* r = b;
3       
4 if (r == b)
5    printf("Equal! /n " );
   先明确下这两个指针实际上是指向不同地址的，r指针实际上在b指针所指地址上偏移8字节 ，但是，这些C++内部细节不能告诉C++程序员，所以C++编译器在比较r和b时，会把r减去8字节，然后再来比较，所以打印出的值是"Equal".

 

参考文献   

[1] CodeSourcery , in particular the C++ ABI Summary , the Itanium C++ ABI (despite the name, this document is referenced in a platform-independent context; in particular, the structure of the vtables is detailed here). The libstdc++ implementation of dynamic casts, as well RTTI and name unmangling/demangling, is defined in tinfo.cc .

[2] The libstdc++ website, in particular the section on the C++ Standard Library API .

[3] C++: Under the Hood by Jan Gray.

[4] Chapter 9, “Multiple Inheritance” of Thinking in C++ (volume 2) by Bruce Eckel . The author has made this book available for download .