虚拟继承

   
    从意义上来看，一个SleeperSofa没有沙发和床两种重量， 如此的继承不是真实的现实世界描述。进一步分析可得，床和沙发都是家具的一种，凡家具都有重量，所以通过分解来考察其关系，如图1所示。

图1 床和沙发的分解

1. //**   Sample1.cpp 　**//
   
2. #include<iostream.h>
4. class Furniture
5. {
6. public:
7.     Furniture(){};
8.     void SetWeight(int i)
9.     {
10.         weight =i;
11.     }
12.     
13.     int GetWeight()
14.     {
15.         return weight;
16.     } 　　　　　
17. protected:
18.     int weight;
19. };
20. 
    
23. class Bed : public Furniture
24. {
25. public:
26.     Bed(){};
27.     void Sleep()
28.     {
29.         cout << "Sleeping...//n";
30.     }
31. };
33. class Sofa : public Furniture
34. {
35. public :
36.     Sofa(){};
37.     void WatchTV()
38.     { 
39.         cout << "Watching TV.//n";
40.     }
41. };
43. class SleeperSofa : public Bed, public Sofa
44. {
45. public:
46.     SleeperSofa() : Sofa(), Bed(){};
47. 　　void FoldOut()
48.     {
49.         cout << "Fold out the sofa.//n";
50.     }
51. };
53. void main()
54. {
55.     SleeperSofa ss;
56.     ss.SetWeight(20);     //编译出错！模糊的SetWeight成员
57. 
    
58.     Furniture* pF;
59.     pF =(Furniture*)&ss;      //编译出错！模糊的Furniture*
    
60. 
    
61.     cout << pF->GetWeight() << endl;
62. }
63. 
    

    因为SleeperSofa不是直接继承Furniture，而是从Bed和Sofa组合继承，Bed和Sofa又是各继承自Furniture，所以完整的SleeperSofa对象内存布局如图2所示：

图2 完整SleeperSofa对象内存布局

   

    这里一个Sleepersofa包括一个完整的Bed，随后还有一个完整的Sofa，后面还有一个 Sleepersofa特有的东西。SleeperSofa中的每一个子对象都有它自己的Furniture部分。因为每个子对象继承自Furniture，所以一个SleeperSofa包含两个Furniture对象，实际上的继承层次如图3所示：

图3 SleeperSofa的实际继承关系

　　编译Sample1.cpp时，不知道SetWeight()属于哪一个Furniture成员，指向Furniture的指针也不知道究竟指哪一个Furniture。这就是为什么Sample1.cpp编译通不过的原因。SleeperSofa只需一个Furniture，所以我们希望它只含一个Furniture拷贝，同时又要共享Bed和Sofa的成员函数与数据成员，C++实现这种继承结构的方法称为虚拟继承(virtual inheritance)。

    下面是虚拟继承的代码：

1. //** 　　Sample2.cpp 　**
   
2. #include<iostream.h>
4. class Furniture
5. {
6. public:
7.     Furniture(){};
8.     void SetWeight(int i)
9.     {
10.         weight =i;
11.     }
12.     
13.     int GetWeight()
14.     {
15.         return weight;
16.     } 　　　　　
17. protected:
18.     int weight;
19. };
22. class Bed : virtual public Furniture
23. {
24. public:
25.     Bed(){};
26.     void Sleep()
27.     {
28.         cout <<"Sleeping...//n";
29.     }
30. };
32. class Sofa : virtual public Furniture
33. {
34. public :
35.     Sofa(){};
36.     void WatchTV()
37.     { 
38.         cout <<"Watching TV.//n";
39.     }
40. };
42. class SleeperSofa : public Bed, public Sofa
43. {
44. public:
45.     SleeperSofa() : Sofa(), Bed(){};
46. 　　void FoldOut()
47.     {
48.         cout <<"Fold out the sofa.//n";
49.     }
50. };
52. void main()
53. {
54.     SleeperSofa ss;
55.     ss.SetWeight(20);
56.     Furniture* pF;
57.     pF =(Furniture*)&ss;
58.     cout <<pF->GetWeight() <<endl;
59. }

    运行结果为：20

　　在Bed和Sofa继承Furniture中加上virtual关键字，这相当于说，“如果还没有Furniture类，则加入一个Furniture拷贝，否则就用有的那一个”。此时一个Sleepersofa在内存中的布局见图4:

图4 虚拟继承的SleepeiSofa内存布局

　　在虚拟继承的情况下，应用程序main()中引用GetWeight()不再模糊，我们得到了真正的图1所示的继承关系。

    虚拟继承的虚拟和虚拟函数的虚拟没有任何关系。