1，本文分析另一个多重继承问题及其工程中的解决方案，单继承加多接口实现的开发方式；
2，多重继承的问题三：
1，多重继承可能产生多个虚函数表：
1，实际工程中可能造成不可思议的问题，并且这些问题很难以查找和排除；
3，多重继承问题三编程实验：
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class BaseA 7 { 8 public: 9 virtual void funcA() 10 { 11 cout << "BaseA::funcA()" << endl; 12 } 13 }; 14 15 class BaseB 16 { 17 public: 18 virtual void funcB() 19 { 20 cout << "BaseB::funcB()" << endl; 21 } 22 }; 23 24 class Derived : public BaseA, public BaseB 25 { 26 27 }; 28 29 int main() 30 { 31 Derived d; 32 BaseA* pa = &d; 33 BaseB* pb = &d; 34 BaseB* pbe = (BaseB*)pa; // 忘记这种转换方式 35 BaseB* pbc = dynamic_cast<BaseB*>(pa); // 用这种转换方式 36 37 cout << "sizeof(d) = " << sizeof(d) << endl; // 这是虚函数表指针定义的； 38 39 cout << "Using pa to call funcA()..." << endl; 40 41 pa->funcA(); // BaseA::funcA() 42 43 cout << "Using pb to call funcB()..." << endl; 44 45 pb->funcB(); // BaseB::funcB() 46 47 cout << "Using pbe to call funcB()..." << endl; 48 49 pbe->funcB(); // BaseB::funcA() pa 和 pb 都指向同一个对象，但是保存的值不一样，具体见 4 中分析； 50 51 cout << "Using pbc to call funcB()..." << endl; 52 53 pbc->funcB(); // BaseB::funcb() // 使用了 dynamic_cast，编译器就会检查 pa 指向的指针是 d 对象，进而检查d 对象有 BaseA 和 BaseB，进而认为这里转换合法，并且对指针有个修正，使得pbb 指向 pb 的位置，则调用正确； 54 55 cout << endl; 56 57 cout << "pa = " << pa << endl; // 0xbfd11238 58 cout << "pb = " << pb << endl; // 0xbfd1123c 59 cout << "pbe = " << pbe << endl; // 0xbfd11238 没有修正 60 cout << "pbc = " << pbc << endl; // 0xbfd1123c；做了修正 61 62 return 0; 63 }
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，正确的多继承方式编程实验：
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Base 7 { 8 protected: 9 int mi; 10 11 public: 12 Base(int i) 13 { 14 mi = i; 15 } 16 17 int getI() 18 { 19 return mi; 20 } 21 22 /* 在顶层父类中，定义函数判断参数指针指向的是不是当前对象（用法见 main() 函数），解决多重继承的问题一 */ 23 bool equal(Base* obj) // 传递的指针要加上 dynamic_cast 强制类型转换； 24 { 25 return (this == obj); 26 } 27 }; 28 29 /* 加减接口 */ 30 class Interface1 31 { 32 public: 33 virtual void add(int i) = 0; 34 virtual void minus(int i) = 0; 35 }; 36 37 /* 乘除接口 */ 38 class Interface2 39 { 40 public: 41 virtual void multiply(int i) = 0; 42 virtual void divide(int i) = 0; 43 }; 44 45 /* 单继承、实现多个接口 */ 46 class Derived : public Base, public Interface1, public Interface2 // 表象上依然是 C++ 中的多继承，但是整个程序的语义上来看是单继承加上实现多个接口； 47 { 48 public: 49 Derived(int i) : Base(i) 50 { 51 } 52 53 void add(int i) // 实现接口中的加法 54 { 55 mi += i; 56 } 57 58 void minus(int i) // 实现接口中的加法 59 { 60 mi -= i; 61 } 62 63 void multiply(int i) // 实现接口中的加法 64 { 65 mi *= i; 66 } 67 68 void divide(int i) // 实现接口中的加法 69 { 70 if( i != 0 ) 71 { 72 mi /= i; 73 } 74 } 75 }; 76 77 int main() 78 { 79 Derived d(100); 80 Derived* p = &d; 81 Interface1* pInt1 = &d; 82 Interface2* pInt2 = &d; 83 84 cout << "p->getI() = " << p->getI() << endl; // 100 85 86 pInt1->add(10); 87 pInt2->divide(11); 88 pInt1->minus(5); 89 pInt2->multiply(8); 90 91 cout << "p->getI() = " << p->getI() << endl; // 40 92 93 cout << endl; 94 95 cout << "pInt1 == p : " << p->equal(dynamic_cast<Base*>(pInt1)) << endl; // 打印 1，不转换则报错，没有这样的函数可以调用 96 cout << "pInt2 == p : " << p->equal(dynamic_cast<Base*>(pInt2)) << endl; // 打印 1，不转换则报错，没有这样的函数可以调用 97 98 return 0; 99 }
7，正确的使用多重继承：
1，一些有用的工程建议：
1，先继承自一个父类，然后实现多个接口；
1，接口不是一个完整类实现，仅仅定义了公有函数原型而已；
2，父类中提供 equal() 成员函数；
3，equal() 成员函数用于判断指针是否指向当前对象；
4，与多重继承相关的强制类型转换用 dynamic_cast 完成；
8，小结：
1，多继承中可能出现多个虚函数表指针；
2，与多重继承相关的强制类型转换用 dynamic_cast 完成；
1，对指针的值进行一定的修正；
3，工程开发中采用“单继承多接口”的方式使用多继承；
1，仅仅在表象上是多继承，面向对象语义上不是多继承，因为仅仅继承了一个类，其它的类都是接口；
4，父类提供成员函数用于判断指针是否指向当前对象；