C++ 深入理解 虚继承、多重继承和直接继承

【摘要】

本文从5段代码实例出发，通过类中类的普通继承，类的虚继承，类的多重继承，多个虚函数类的普通继承、虚继承与多重继承，几个交叉概念，详细的阐释了继承、虚函数与虚继承的基本概念，深入剖析了继承于虚继承的区别于联系。

【Exp.001-虚继承】

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. class A {  
4. public:  
5.     int a;  
6. };//sizeof(A)=4  
7.   
8. class B : virtual public A {  
9. public:  
10. 　　int b;  
11. };//sizeof(B)=4(A副本)+4(虚表指针)+4(自己变量)=12  
12.   
13. class C : virtual public B {       
14. };//sizeof(c)= 12(B副本)+4(虚表指针) = 16，如果这里改为直接继承，那么sizeof(c)=12  
15.   
16. int main() {  
17.     printf("%d\n", sizeof(C));      
18.     return 0;   
19. }  

解析：这里需要理解虚继承基类对派生类的空间大小的影响，理解虚指针在虚继承中为子类带来了哪些空间的改变。

【Exp.002-多重继承】

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. class A {  
4. public:  
5.     int a;  
6. };//sizeof(A) = 4  
7.   
8. class B : virtual public A {  
9. };// sizeof(B) =4+4=8  
10.   
11. class C : virtual public A {          
12. };//sizeof(C) =4+4=8  
13.   
14. class D : public B, public C{         
15. };  
16. //sizeof(D)=8+8-4=12 这里需要注意要减去4，因为B和C同时继承A，只需要保存一个A的副本就好了，sizeof(D)=4(A的副本)+4(B的虚表)+4(C的虚表)=12  
17.   
18. int main() {  
19.     printf("%d\n", sizeof(D));  
20.     return 0;   
21. }  

解析：这里需要关注 class D 的数据空间大小，理解多重虚继承对派生类虚指针以及派生类空间的影响。

【Exp.003-普通继承（含有：空类、虚函数）】

[cpp]  view plain  copy

1. class A     
2. {     
3. };    
4.   
5. class B     
6. {  
7.     char ch;     
8.     virtual void func0()  {  }   
9. };   
10.   
11. class C    
12. {  
13.     char ch1;  
14.     char ch2;  
15.     virtual void func()  {  }    
16.     virtual void func1()  {  }   
17. };  
18.   
19. class D: public A, public C  
20. {     
21.     int d;     
22.     virtual void func()  {  }   
23.     virtual void func1()  {  }  
24. };     
25.   
26. class E: public B, public C  
27. {     
28.     int e;     
29.     virtual void func0()  {  }   
30.     virtual void func1()  {  }  
31. };  
32.   
33. int main(void)  
34. {  
35.     cout<<"A="<<sizeof(A)<<endl;//result=1  空类所占空间的大小为 1  
36.     cout<<"B="<<sizeof(B)<<endl;//result=8  1+4   对齐 8   
37.     cout<<"C="<<sizeof(C)<<endl;//result=8  1+1+4 对齐 8  
38.     cout<<"D="<<sizeof(D)<<endl;//result=12 C的副本+D本身=8+4=12  
39.     cout<<"E="<<sizeof(E)<<endl;//result=20 B的副本+C的副本+E本身=8+8+4=20  
40.     return 0;  
41. }  

这里需要区分一下：

①没有继承的时候，存在虚函数则需要加上虚指针，如果有多个也只需要加上一个，因为只有一个虚指针；

②对于普通继承，类D和类E中自己的虚函数，大小为0，因为，它没有虚表；

③对于虚继承中，派生类中存在一个或多个虚函数的时候，它本身就有一个虚表，指向自己的虚表，所以要加4。

【Exp.004-虚继承（多重继承和虚函数）】

[cpp]  view plain  copy

1. class CommonBase  
2. {  
3.     int co;  
4. };// size = 4  
5.   
6. class Base1: virtual public CommonBase            
7. {  
8. public:  
9.     virtual void print1() {  }  
10.     virtual void print2() {  }  
11. private:  
12.     int b1;  
13. };//4副本+4虚指针+4自身+4(虚继承+虚函数构成指针多一个)=16  
14.   
15.   
16. class Base2: virtual public CommonBase          
17. {  
18. public:  
19.     virtual void dump1() {  }  
20.     virtual void dump2() {  }  
21. private:  
22.     int b2;  
23. };//同理16  
24.   
25. class Derived: public Base1, public Base2       
26. {  
27. public:  
28.     void print2() {  }  
29.     void dump2() {  }  
30. private:  
31.     int d;  
32. };//16+16-4+4=32  

解析：如果不是虚继承的类，即便有虚函数也不会因此增加存储空间，如果是虚继承的类，没有虚函数就添加一个虚指针空间，有虚函数不论多少个，就添加两个虚指针空间。

【Exp.005-虚继承与虚函数】

[cpp]  view plain  copy

1. class A  
2. {  
3. public:  
4.     virtual void aa() {  }  
5.     virtual void aa2() {  }  
6. private:  
7.     char ch[3];  
8. }; // 1+4 = 补齐 = 8  
9.   
10. class B: virtual public A  
11. {  
12. public:  
13.     virtual void bb() {  }  
14.     virtual void bb2() {  }  
15. }; // 8（副本）+4(虚继承)+4（虚指针） = 16  
16.   
17. int main(void)  
18. {  
19.     cout<<"A's size is "<<sizeof(A)<<endl;//        4+4=8  
20.     cout<<"B's size is "<<sizeof(B)<<endl;//        A的副本+4+4=16  
21.     return 0;  
22. }  

解析：如果不是虚继承的类，即便有虚函数也不会因此增加存储空间，如果是虚继承的类，没有虚函数就添加一个虚指针空间，有虚函数不论多少个，就添加两个虚指针空间。

【小结】

重要的事情讲三遍！！！

如果不是虚继承的类，即便有虚函数也不会因此增加存储空间，如果是虚继承的类，没有虚函数就添加一个虚指针空间，有虚函数不论多少个，就添加两个虚指针空间！！！