以下内容转自：

http://blog.csdn.net/haoel/article/details/3081328

http://blog.csdn.net/haoel/article/details/3081385

http://blog.csdn.net/haoel/article/details/1948051#reply

一、多重继承

以下程序展示：

1、没有成员变量的虚拟函数在子类中的布局

2、子类可以通过指针访问父类中的private虚函数。

 

下图中，我们在子类中覆盖了父类的f()函数。

 

 

 

下面是对于子类实例中的虚函数表的图：

 

 

 

1. #include <iostream> 
2. using namespace std; 
3.   
4. class Base1 { 
5. public: 
6.             virtual void f() { cout << "Base1::f" << endl; } 
7.             virtual void g() { cout << "Base1::g" << endl; } 
8.             virtual void h() { cout << "Base1::h" << endl; } 
9. private: 
10.             virtual void i() { cout << "Base1::i" << endl; }
    }; 
11.   
12. class Base2 { 
13. public: 
14.             virtual void f() { cout << "Base2::f" << endl; } 
15.             virtual void g() { cout << "Base2::g" << endl; } 
16.             virtual void h() { cout << "Base2::h" << endl; } 
17. }; 
18.   
19. class Base3 { 
20. public: 
21.             virtual void f() { cout << "Base3::f" << endl; } 
22.             virtual void g() { cout << "Base3::g" << endl; } 
23.             virtual void h() { cout << "Base3::h" << endl; } 
24. }; 
25.   
26.   
27. class Derive : public Base1, public Base2, public Base3 { 
28. public: 
29.             virtual void f() { cout << "Derive::f" << endl; } 
30.             virtual void g1() { cout << "Derive::g1" << endl; } 
31. }; 
32.   
33.   
34. typedef void(*Fun)(void); 
35.   
36. int main() 
37. { 
38.             Fun pFun = NULL; 
39.   
40.             Derive d; 
41.             int** pVtab = (int**)&d; 
42.   
43.             //Base1's vtable 
44.             pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0); 
45.             pFun(); 
46.             pFun = (Fun)pVtab[0][0]; 
47.             pFun(); 
48.   
49.             //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1); 
50.             pFun = (Fun)pVtab[0][1]; 
51.             pFun(); 
52.   
53.             //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2); 
54.             pFun = (Fun)pVtab[0][2]; 
55.             pFun(); 
56.   
57.             //Derive's vtable 
58.             //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3); 
59.             pFun = (Fun)pVtab[0][3]; 
60.             pFun(); 
61.   
62.             //The tail of the vtable 
63.             pFun = (Fun)pVtab[0][4]; 
64.             cout<<pFun<<endl; 
65.   
66.               
67.             //Base2's vtable 
68.             //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0); 
69.             pFun = (Fun)pVtab[1][0]; 
70.             pFun(); 
71.   
72.             //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
73.  
74.  pFun = (Fun)*((int*)*((int*)&d + 1) + 1);
75. //这里其实就是(&d)[1][1] = *((&d)[1] + 1)
76. // *((&d)[1] + 1) = *(*( &d + 1) + 1)
77. //指针的运算需要指定类型，所以要在指针之前加上类型，因为虚函数表的指针size和int的size一样，
78. //所以定义成int*比较方便。
79. // (Fun)*((int*)*((int*)&d + 1) + 1);
80.  
81.             pFun = (Fun)pVtab[1][1]; 
82.             pFun(); 
83.   
84.             pFun = (Fun)pVtab[1][2]; 
85.             pFun(); 
86.   
87.             //The tail of the vtable 
88.             pFun = (Fun)pVtab[1][3]; 
89.             cout<<pFun<<endl; 
90.   
91.   
92.   
93.             //Base3's vtable 
94.             //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0); 
95.             pFun = (Fun)pVtab[2][0]; 
96.             pFun(); 
97.   
98.             //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1); 
99.             pFun = (Fun)pVtab[2][1]; 
100.             pFun(); 
101.   
102.             pFun = (Fun)pVtab[2][2]; 
103.             pFun(); 
104.   
105.             //The tail of the vtable 
106.             pFun = (Fun)pVtab[2][3]; 
107.             cout<<pFun<<endl; 
108.   
109.             return 0; 
110. } 

运行结果：

可以看见，最后一个虚函数数组的尾巴为0,其他的为1。

二、带成员变量的多重继承

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类只overwrite了父类的f()函数，而还有一个是自己的函数（我们这样做的目的是为了用g1()作为一个标记来标明子类的虚函数表）。而且每个类中都有一个自己的成员变量：

 

内存分配如下：

 

我们可以看到：

1）  每个父类都有自己的虚表。

2）  子类的成员函数被放到了第一个父类的表中。

3）  内存布局中，其父类布局依次按声明顺序排列。

4）  每个父类的虚表中的f()函数都被overwrite成了子类的f()。这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

三、重复继承

下图是一个继承图，我们重载了父类的f()函数。

 

 

其类继承的源代码如下所示。其中，每个类都有两个变量，一个是×××（4字节），一个是字符（1字节），而且还有自己的虚函数，自己overwrite父类的虚函数。如子类D中，f()覆盖了超类的函数， f1() 和f2() 覆盖了其父类的虚函数，Df()为自己的虚函数。

下面是对于子类实例中的虚函数表的图：

 

 

 

我们可以看见，最顶端的父类B其成员变量存在于B1和B2中，并被D给继承下去了。而在D中，其有B1和B2的实例，于是B的成员在D的实例中存在两份，一份是B1继承而来的，另一份是B2继承而来的。所以，如果我们使用以下语句，则会产生二义性编译错误：

 

D d;

d.ib = 0;               //二义性错误

d.B1::ib = 1;           //正确

d.B2::ib = 2;           //正确

注意，上面例程中的最后两条语句存取的是两个变量。虽然我们消除了二义性的编译错误，但B类在D中还是有两个实例，这种继承造成了数据的重复，我们叫这种继承为重复继承。重复的基类数据成员可能并不是我们想要的。所以，C++引入了虚基类的概念。

 

四、钻石型多重虚拟继承

 

虚拟继承的出现就是为了解决重复继承中多个间接父类的问题的。钻石型的结构是其最经典的结构。也是我们在这里要讨论的结构：

 

上述的“重复继承”只需要把B1和B2继承B的语法中加上virtual 关键，就成了虚拟继承，其继承图如下所示：

 

 

 

上图和前面的“重复继承”中的类的内部数据和接口都是完全一样的，只是我们采用了虚拟继承：其省略后的源码如下所示：

 

class  B {

……};

class B1 : virtual public B{

……};

class B2: virtual public B{

……};

class D : public B1, public B2{ …… };

 

1）无论是GCC还是VC++，除了一些细节上的不同，其大体上的对象布局是一样的。也就是说，先是B1（×××），然后是B2（绿色），接着是D（灰色），而B这个超类（青蓝色）的实例都放在最后的位置。

2）关于虚函数表，尤其是第一个虚表，GCC和VC++有很重大的不一样。但仔细看下来，还是VC++的虚表比较清晰和有逻辑性。

3）VC++和GCC都把B这个超类放到了最后，而VC++有一个NULL分隔符把B和B1和B2的布局分开。GCC则没有。