图文例解C++类的多重继承与虚拟继承

        在过去的学习中，我们始终接触的单个类的继承，但是在现实生活中，一些新事物往往会拥有两个或者两个以上事物的属性，为了解决这个问题，C++引入了多重继承的概念， C++允许为一个派生类指定多个基类，这样的继承结构被称做多重继承。

　　举个例子，交通工具类可以派生出汽车和船连个子类，但拥有汽车和船共同特性水陆两用汽车就必须继承来自汽车类与船类的共同属性。

　　由此我们不难想出如下的图例与代码：

　　当一个派生类要使用多重继承的时候，必须在派生类名和冒号之后列出所有基类的类名，并用逗好分隔。

1. #include <iostream>  
2. using namespace std;  
3.   
4. class Vehicle  
5. {  
6.     public:  
7.         Vehicle(int weight = 0)  
8.         {  
9.             Vehicle::weight = weight;  
10.         }  
11.         void SetWeight(int weight)  
12.         {  
13.             cout<<"重新设置重量"<<endl;  
14.             Vehicle::weight = weight;  
15.         }  
16.         virtual void ShowMe() = 0;  
17.     protected:  
18.         int weight;  
19. };  
20. class Car:public Vehicle//汽车  
21. {  
22.     public:  
23.         Car(int weight=0,int aird=0):Vehicle(weight)  
24.         {  
25.             Car::aird = aird;  
26.         }  
27.         void ShowMe()  
28.         {  
29.             cout<<"我是汽车！"<<endl;  
30.         }  
31.     protected:  
32.         int aird;  
33. };  
34.   
35. class Boat:public Vehicle//船  
36. {  
37.     public:  
38.         Boat(int weight=0,float tonnage=0):Vehicle(weight)  
39.         {  
40.             Boat::tonnage = tonnage;  
41.         }  
42.         void ShowMe()  
43.         {  
44.             cout<<"我是船！"<<endl;  
45.         }  
46.     protected:  
47.         float tonnage;  
48. };  
49.   
50. class AmphibianCar:public Car,public Boat//水陆两用汽车,多重继承的体现  
51. {  
52.     public:  
53.         AmphibianCar(int weight,int aird,float tonnage)  
54.         :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage)  
55.         //多重继承要注意调用基类构造函数  
56.         {  
57.           
58.         }  
59.         void ShowMe()  
60.         {  
61.             cout<<"我是水陆两用汽车！"<<endl;  
62.         }  
63. };  
64. int main()  
65. {  
66.     AmphibianCar a(4,200,1.35f);//错误  
67.     a.SetWeight(3);//错误  
68.     system("pause");   
69. }

 

上面的代码从表面看，看不出有明显的语发错误，但是它是不能够通过编译的。这有是为什么呢？
　　这是由于多重继承带来的继承的模糊性带来的问题。

先看如下的图示：

　　在图中深红色标记出来的地方正是主要问题所在，水陆两用汽车类继承了来自Car类与Boat类的属性与方法，Car类与Boat类同为AmphibianCar类的基类，在内存分配上AmphibianCar获得了来自两个类的SetWeight()成员函数，当我们调用a.SetWeight(3)的时候计算机不知道如何选择分别属于两个基类的被重复拥有了的类成员函数SetWeight()。

　　由于这种模糊问题的存在同样也导致了AmphibianCar a(4,200,1.35f);执行失败，系统会产生Vehicle”不是基或成员的错误。

　　以上面的代码为例，我们要想让AmphibianCar类既获得一个Vehicle的拷贝，而且又同时共享用Car类与Boat类的数据成员与成员函数就必须通过C++所提供的虚拟继承技术来实现。

　　我们在Car类和Boat类继承Vehicle类出，在前面加上virtual关键字就可以实现虚拟继承，使用虚拟继承后，当系统碰到多重继承的时候就会自动先加入一个Vehicle的拷贝，当再次请求一个Vehicle的拷贝的时候就会被忽略，保证继承类成员函数的唯一性。

　　修改后的代码如下，注意观察变化：

1. #include <iostream>  
2. using namespace std;  
3.   
4. class Vehicle  
5. {  
6.     public:  
7.         Vehicle(int weight = 0)  
8.         {  
9.             Vehicle::weight = weight;  
10.             cout<<"载入Vehicle类构造函数"<<endl;  
11.         }  
12.         void SetWeight(int weight)  
13.         {  
14.             cout<<"重新设置重量"<<endl;  
15.             Vehicle::weight = weight;  
16.         }  
17.         virtual void ShowMe() = 0;  
18.     protected:  
19.         int weight;  
20. };  
21. class Car:virtual public Vehicle//汽车，这里是虚拟继承  
22. {  
23.     public:  
24.         Car(int weight=0,int aird=0):Vehicle(weight)  
25.         {  
26.             Car::aird = aird;  
27.             cout<<"载入Car类构造函数"<<endl;  
28.         }  
29.         void ShowMe()  
30.         {  
31.             cout<<"我是汽车！"<<endl;  
32.         }  
33.     protected:  
34.         int aird;  
35. };  
36.   
37. class Boat:virtual public Vehicle//船,这里是虚拟继承  
38. {  
39.     public:  
40.         Boat(int weight=0,float tonnage=0):Vehicle(weight)  
41.         {  
42.             Boat::tonnage = tonnage;  
43.             cout<<"载入Boat类构造函数"<<endl;  
44.         }  
45.         void ShowMe()  
46.         {  
47.             cout<<"我是船！"<<endl;  
48.         }  
49.     protected:  
50.         float tonnage;  
51. };  
52.   
53. class AmphibianCar:public Car,public Boat//水陆两用汽车,多重继承的体现  
54. {  
55.     public:  
56.         AmphibianCar(int weight,int aird,float tonnage)  
57.         :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage)  
58.         //多重继承要注意调用基类构造函数  
59.         {  
60.             cout<<"载入AmphibianCar类构造函数"<<endl;  
61.         }  
62.         void ShowMe()  
63.         {  
64.             cout<<"我是水陆两用汽车！"<<endl;  
65.         }  
66.         void ShowMembers()  
67.         {  
68.             cout<<"重量："<<weight<<"顿，"<<"空气排量："<<aird<<"CC，"<<"排水量："<<tonnage<<"顿"<<endl;  
69.         }  
70. };  
71. int main()  
72. {  
73.     AmphibianCar a(4,200,1.35f);  
74.     a.ShowMe();  
75.     a.ShowMembers();  
76.     a.SetWeight(3);  
77.     a.ShowMembers();  
78.     system("pause");   
79. }

 

注意观察类构造函数的构造顺序。

　　虽然说虚拟继承与虚函数有一定相似的地方，但读者务必要记住，他们之间是绝对没有任何联系的！