virtual inherit内存布局问题

class A
...{
public:
 int i;
};
class B1:virtual public A
...{
public:
 int i;
};

class B2:virtual public A
...{
public:
 int i;
};

class B3: public A
...{
public:
 int i;
};

class B4: public A
...{
public:
 int i;
};

class C1:public B1,public B2
...{
public:
 int i;
};

class C2: public B3,public B4
...{
public:
 int i;
};

 

int _tmain(int argc, _TCHAR* argv[])
...{
 cout << sizeof(A) << endl; // 4
 cout << sizeof(B1) << endl; // 12
 cout << sizeof(B3) << endl; // 8
 cout << sizeof(C1) << endl; // 24 
 cout << sizeof(C2) << endl; // 20
}

其中A的内存结构
sizeof(A) == 4
----
1~4:A::i --- 4word
----
B1的内存结构(same as B2)
sizeof(B1) == 12 
-----
1~4: B1::A* 编译器产生的指向父类的指针因为虚继承指向父类的指针4word也就是指向9~12中的A
5~8: B1::i int 4 word
9~12:B1对象中的基类A的内容
----
C1的内存结构
sizeof(C1) == 24
----
(1~8是C1中的B1对象)
1~4: B1::A* 编译器产生的指向父类的指针因为虚继承指向父类的指针4word也就是指向20~24中的A
5~8: B1::i int 4 word
(9~16是C1中的B2对象)
9~12: B2::A* 编译器产生的指向父类的指针因为虚继承指向父类的指针4word也就是指向20~24中的A
12~16: B2::i int 4 word
(16~20是c1中的数据部分)
16~20 C1::i 4 word
(20~24是C1中的A)
20~24 A::i 4 word
----
我们看如果
B1* pb1 = new B1();
A* pa = static_cast<A*>(pb1);
会发生什么。
首先编译器会找到pb1的对象，把pb1对象的1~4字节指针的所指向的地址赋给b
如果
B1* pb1 = new C1();
A* pa = static_cast<A*>(pb1);
编译器也会进行相同的操作，并且指向正确位置(虽然偏移的地址量不同)

接下来我们可以看普通继承
B3的内存分布(B4类似)
sizeof(B3)8
----
(1~4为B3中的A)
1~4 A::i
(5~8)
5~8 B3::i
----
C2的内存分布
sizeof(C3)16
----
(1~4为B3中的A)
1~4 A::i
(5~8)
5~8 B3::i
(9~12为B4中的A)
9~12 A::i
12~16 B4::i
17~20 C2::i
----
大家可以看到如果不使用虚继承C2对象里面有2个A对象。所以以下代码不合法因为有2个A对象
 C2* c2 = new C2();
 A* pa = static_cast<A*>(c2);
但是我们可以看到下面代码合法
 C2* c2 = new C2();
 B3* pb1 = static_cast<B3*>(c2);
 B4* pb2 = static_cast<B4*>(c2);
 A* paOfB3 = static_cast<A*>(pb1);
 A* paOfB4 = static_cast<A*>(pb2);
注意paOfB3  != paOfB4.
按照C2内存分配的原则(paOfB4 - paOfB3) == 8
明白了。呵呵？

附小欣欣的解释还有我的跟贴
这是由于c++支持多重继承而引起的某些问题，例如

class A{
 public:
   void foo();
};

class B: public A{
};

class C: public A{
};

class D: public B, public C{
};

D *p = new D();

p->foo();

这是会触发编译错误，大体是因为有两个可供选择而不能作出决断的函数调用。


需要将普通集成改为虚拟继承。