C++多繼承中重寫不同基類中相同原型的虛函數

     在C++多繼承體系當中，在衍生類別中可以重寫不同基類中的虛函數。下面就是一個例子：

1. class CBaseA
2. {
3. public:
4.     virtual void TestA();
5. };
7. class CBaseB
8. {
9. public:
10.     virtual void TestB();
11. };
13. class CDerived : public CBaseA, public CBaseB
14. {
15. public:
16.     virtual void TestA(); // 重寫基類CBaseA中的虛函數TestA()
17.     virtual void TestB(); // 重寫基類CBaseB中的虛函數TestB()
18. };
20. void Test()
21. {
22.     CDerived D;
23.     CBaseA *pA = &D;
24.     CBaseB *pB = &D;
26.     pA->TestA(); // 調用類CDerived的TestA()函數
27.     pB->TestB(); // 調用類CDerived的TestB()函數
28. }

    可是，如果兩個基類中有一個相同原型的虛函數，例如下面這樣：

1. class CBaseA
2. {
3. public:
4.     virtual void Test();
5. };
7. class CBaseB
8. {
9. public:
10.     virtual void Test();
11. };

    怎樣在衍生類別中重寫這兩個相同原型的虛函數呢？
    也許這種情況並不常見，可是這種情況卻確實存在。比如說開發的時候使用的兩個類庫是不同的廠商提供的，或者說這兩個類庫是由公司的不同開發小組開發的。對前者來說，修改基類的介面是不可能的；對後者來說，修改介面的代價很大。
    如果在衍生類別中直接重寫這個虛函數，那麼2個基類的Test()虛函數都將被覆蓋。這樣的話就只能有一個Test()的實現，而不是像前面的例子那樣有不同的實現。

1. class CDerived : public CBaseA, public CBaseB
2. {
3. public:
4.     virtual void Test();
5. };
7. void Test()
8. {
9.     CDerived D;
10.     CBaseA *pA = &D;
11.     CBaseB *pB = &D;
13.     // 下面2行代碼都將調用類CDerived的Test()函數
14.     pA->Test();
15.     pB->Test(); 
16. }

    為了實現第一個例子中的那樣，在衍生類別CDerived中重寫不同基類中相同原型的虛函數Test()，可以使用下面的方法。
    首先，不需要對2個基類進行任何修改(在實際的開發當中，修改基類的可能性非常小)。

1. class CBaseA
2. {
3. public:
4.     virtual void Test();
5. };
7. class CBaseB
8. {
9. public:
10.     virtual void Test();
11. };

    現在，為這個繼承體系添加2個中間類，分別從2個基類派生。

1. class CMiddleBaseA : public CBaseA
2. {
3. private:
4.     // 真正的實現函數
5.     // 設定為純虛函數，在衍生類別裡必須實現
6.     virtual void CBaseA_Test() = 0;
8.     // 改寫繼承下來的虛函數
9.     // 僅僅直接調用真正的實現函數
10.     virtual void Test() 
11.     { 
12.         CBaseA_Test(); 
13.     }
14. };
16. // 與類CMiddleBaseA採用相同的方法
17. class CMiddleBaseB : public CBaseB
18. {
19. private:
20.     virtual void CBaseB_Test() = 0;
22.     virtual void Test() 
23.     { 
24.         CBaseB_Test(); 
25.     }
26. };

    然後，類CDerived以上面2個中間類作為基類來派生。分別重寫上面2個基類中原型不同的純虛函數，添加不同的實現代碼。

1. class CDerived : public CMiddleBaseA, public CMiddleBaseB
2. {
3. private:
4.     // 重寫從中間類繼承下來的虛函數
5.     virtual void CBaseA_Test(); // 這裡實際上是重寫CBaseA的Test()
6.     virtual void CBaseB_Test(); // 這裡實際上是重寫CBaseB的Test()
7. };
9. void Test()
10. {
11.     CDerived D;
12.     CBaseA *pA = &D;
13.     CBaseB *pB = &D;
15.     // 調用類CBaseA的Test()函數
16.     // 由於C++多態的特性，實際上調用的是類CDervied中的CBaseA_Test()函數
17.     pA->Test(); 
19.     // 調用類CBaseB的Test()函數
20.     // 由於C++多態的特性，實際上調用的是類CDervied中的CBaseB_Test()函數
21.     pB->Test();
22. }

    現在以上面代碼中的pA->Test();這行代碼來說明上面的方案是怎麼實現的。
    首先，由於虛函數Test()在類CBaseA的衍生類別CMiddleBaseA中被重寫，所以這行代碼會去調用類CMiddleBaseA的Test()函數；
    然後，類CMiddleBaseA的Test()函數會去調用實現函數CBaseA_Test()；
    最後，由於虛函數CBaseA_Test()在類CMiddleBaseA的衍生類別CDerived中被重寫，所以真正調用的是類CDerived中的CBaseA_Test()函數。
    同樣的道理，代碼pB->Test();實際上調用的是類CDervied中的CBaseB_Test()函數。
    通過上面的方法就可以在C++多繼承中重寫不同基類中相同原型的虛函數。