C++中的多重继承（二）

1，本文分析另一个多重继承问题及其工程中的解决方案，单继承加多接口实现的开发方式；

2，多重继承的问题三：

1，多重继承可能产生多个虚函数表：

1，实际工程中可能造成不可思议的问题，并且这些问题很难以查找和排除；

3，多重继承问题三编程实验：

 #include <iostream>
 #include <string>

 using namespace std;

 class BaseA
 {
 public:
     virtual void funcA()
     {
         cout << "BaseA::funcA()" << endl;
     }
 };

 class BaseB
 {
 public:
     virtual void funcB()
     {
         cout << "BaseB::funcB()" << endl;
     }
 };

 class Derived : public BaseA, public BaseB
 {

 };

 int main()
 {
     Derived d;
     BaseA* pa = &d;
     BaseB* pb = &d;
     BaseB* pbe = (BaseB*)pa;    // 忘记这种转换方式
     BaseB* pbc = dynamic_cast<BaseB*>(pa);    // 用这种转换方式

     cout << "sizeof(d) = " << sizeof(d) << endl;  // 这是虚函数表指针定义的；

     cout << "Using pa to call funcA()..." << endl;

     pa->funcA();  // BaseA::funcA()

     cout << "Using pb to call funcB()..." << endl;

     pb->funcB();  // BaseB::funcB()

     cout << "Using pbe to call funcB()..." << endl;

     pbe->funcB(); // BaseB::funcA()  pa 和 pb 都指向同一个对象，但是保存的值不一样，具体见 4 中分析；

     cout << "Using pbc to call funcB()..." << endl;

     pbc->funcB();  // BaseB::funcb()  // 使用了 dynamic_cast，编译器就会检查 pa 指向的指针是 d 对象，进而检查d 对象有 BaseA 和 BaseB，进而认为这里转换合法，并且对指针有个修正，使得pbb 指向 pb 的位置，则调用正确；

     cout << endl;

     cout << "pa = " << pa << endl;  // 0xbfd11238
     cout << "pb = " << pb << endl;  // 0xbfd1123c
     cout << "pbe = " << pbe << endl;  // 0xbfd11238  没有修正
     cout << "pbc = " << pbc << endl;  // 0xbfd1123c；做了修正

     return ;
 }

1，如果说碰上需要强制类型转换的场合，并且需要强制类型转换的是类，然后类里面又定义了虚函数，然后就是推荐使用 dynamic_cast；

4，需要进行强制类型转换时，C++ 中推荐使用新式类型转换关键字；

1，解决方案：dynamic_cast；

2，示意图：

1，pa 和 pb 都指向同一个对象，但是保存的值不一样；

2，pbb 指针指向了 pa 的虚函数表指针，所以调用了 pa 中的函数 funcB()；

3，在与继承、虚函数相关的强制类型转换时，用 danamic_cast；

5，工程开发中的“多重继承”方式：

1，单继承某个类 + 实现（多个）接口；

2，示意图：

1，这是面向对象理论中所推荐的方式，实际工程开发过程中，只使用单继承；

2，单继承不可能描述生活中所有的情形，因此可以使用单继承+多接口；

3，Derived 直接继承 Base 类，然后自身实现多个接口；

6，正确的多继承方式编程实验：

 #include <iostream>
 #include <string>

 using namespace std;

 class Base
 {
 protected:
     int mi;

 public:
     Base(int i)
     {
         mi = i;
     }

     int getI()
     {
         return mi;
     }

     /* 在顶层父类中，定义函数判断参数指针指向的是不是当前对象（用法见 main() 函数），解决多重继承的问题一 */
     bool equal(Base* obj)  // 传递的指针要加上 dynamic_cast 强制类型转换；
     {
         return (this == obj);
     }
 };

 /* 加减接口 */
 class Interface1
 {
 public:
     virtual void add(int i) = ;
     virtual void minus(int i) = ;
 };

 /* 乘除接口 */
 class Interface2
 {
 public:
     virtual void multiply(int i) = ;
     virtual void divide(int i) = ;
 };

 /* 单继承、实现多个接口 */
 class Derived : public Base, public Interface1, public Interface2  // 表象上依然是 C++ 中的多继承，但是整个程序的语义上来看是单继承加上实现多个接口；
 {
 public:
     Derived(int i) : Base(i)
     {
     }

     void add(int i)  // 实现接口中的加法
     {
         mi += i;
     }

     void minus(int i)  // 实现接口中的加法
     {
         mi -= i;
     }

     void multiply(int i)  // 实现接口中的加法
     {
         mi *= i;
     }

     void divide(int i)  // 实现接口中的加法
     {
         if( i !=  )
         {
             mi /= i;
         }
     }
 };

 int main()
 {
     Derived d();
     Derived* p = &d;
     Interface1* pInt1 = &d;
     Interface2* pInt2 = &d;

     cout << "p->getI() = " << p->getI() << endl;    //

     pInt1->add();
     pInt2->divide();
     pInt1->minus();
     pInt2->multiply();

     cout << "p->getI() = " << p->getI() << endl;    //

     cout << endl;

     cout << "pInt1 == p : " << p->equal(dynamic_cast<Base*>(pInt1)) <<     endl;  // 打印 1，不转换则报错，没有这样的函数可以调用
     cout << "pInt2 == p : " << p->equal(dynamic_cast<Base*>(pInt2)) <<     endl;  // 打印 1，不转换则报错，没有这样的函数可以调用

     return ;
 }

7，正确的使用多重继承：

1，一些有用的工程建议：

1，先继承自一个父类，然后实现多个接口；

1，接口不是一个完整类实现，仅仅定义了公有函数原型而已；

2，父类中提供 equal() 成员函数；

3，equal() 成员函数用于判断指针是否指向当前对象；

4，与多重继承相关的强制类型转换用 dynamic_cast 完成；

8，小结：

1，多继承中可能出现多个虚函数表指针；

2，与多重继承相关的强制类型转换用 dynamic_cast 完成；

1，对指针的值进行一定的修正；

3，工程开发中采用“单继承多接口”的方式使用多继承；

1，仅仅在表象上是多继承，面向对象语义上不是多继承，因为仅仅继承了一个类，其它的类都是接口；

4，父类提供成员函数用于判断指针是否指向当前对象；