C++深度解析(44)—被遗弃的多重继承（下）

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/qq_22847457/article/details/97102183

1.多重继承的问题三 

• 多重继承可能产生多个虚函数表

• 需要进行强制类型转换时，C++中推荐使用新式类型转换关键字！！ 
• 解决方案：dynamic_cast

• 其中由于两个虚函数表内容几乎完全相同，所以强制类型转换后仍指向pa地址。
• 而使用dynamic_cast关键字时，编译器会自动进行调整，判断是否存在父类，并根据父类地址进行查找，从而避免了指针问题。

 2.编程实验

• 多重继承问题三 

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include <iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     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
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Derived()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Derived d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	BaseA *pa = &d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	BaseB *pb = &d; 
     
     // 虽然都是将d地址赋给一个指针，但是，因为二者类不同，所以地址不同。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		            
     
     // 暴力强转会出现奇怪的现象。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 暴力强转，BaseB*指针的原意是期望指向d对象中的BaseB子对
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 但是暴力的强制转化会导致ppb指向对象的BaseA子对象，而不是期望的那样。
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	BaseB *ppb = (BaseB *)pa; 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 使用dynamic_cast关键字来转换，编译器会先从d的地址找到这个对象，
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 然后从其继承树上找到该d对象中BaseB子对象的部分，从而能正确的进行指针间的转换。（这是编译器自动为我们做的）
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // dynamic_cast关键字的使用；需要有继承关系，只能转换指针和引用，且需要虚函数的支持。
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	BaseB *pbb = 
     
     dynamic_cast<BaseB *>(pa);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "sizeof(d) = " << 
     
     sizeof(d) << 
     
     endl;  
     
     // 因为子类继承两个父类，有两个虚函数表指针！！！！。
    
    
   
   

   
   

    
    

   
   
   
   

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

   
   

    
    

   
   
   
   

    
    

     
     	pa->funcA(); 
     
     // 父类的指针
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

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

   
   

    
    

   
   
   
   

    
    

     
     	pb->funcB(); 
     
     //父类的指针
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     // 因为pa这个地址实质上是指向BaseA，调用被virtual修饰的函数时，
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 内部有一个vptr虚函数表指针具体指向的函数，会确定具体是哪个对象的函数。
    
    
   
   

   
   

    
    

   
   
   
   

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

   
   

    
    

   
   
   
   

    
    

     
     	ppb->funcB(); 
     
     // 期望调用BaseB::funcB，实际上调用的是BaseA::funcA！
    
    
   
   

   
   

    
    

   
   
   
   

    
    
			     
     
     // 因为暴力强转使ppb指向了BaseA的对象，多态的缘故
    
    
   
   

   
   

    
    

   
   
   
   

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

   
   

    
    

   
   
   
   

    
    

     
     	pbb->funcB();
     
     //实际与期望一样。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pa = " <<pa<< 
     
     endl; 
     
     // BaseA*
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pb = " <<pb<< 
     
     endl; 
     
     // BaseB*
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "ppb = " <<ppb<< 
     
     endl; 
     
     // BaseA*  暴力转换导致
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pbb = " <<pbb<< 
     
     endl; 
     
     //BaseB*
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "pause");
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

• 运行结果：

3.正确的使用多重继承

• 工程开发中的“多重继承”方式：单继承某个类＋实现（多个）接口

• Derived单继承至Base类，实现多个接口

4.编程实验

• 正确的多继承方式     

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include <iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     using 
     
     namespace 
     
     std;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class Base
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     protected:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int mi;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Base(
     
     int i)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     cout << 
     
     "父类被调用了" << 
     
     endl;  
     
     // 父类
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		mi = i;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int getI()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return mi;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 以下是个技巧，用来判断指针是否指向同一个对象，只要有对象调用函数，则会隐式的传入对象的指针this。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     bool equal(Base *obj)   // 类的指针
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return (
     
     this == obj);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     //接口1 :无成员变量，不能用来创建对象，只能被实现。
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class Interface1
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     virtual void add(int i) = 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     virtual void minus(int i) = 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     // 接口2 :无成员变量，不能用来创建对象，只能被实现。
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class Interface2
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     virtual void multiply(int i) = 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     virtual void divide(int i) = 
     
     0; 
     
     // 纯虚函数
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     // 单继承+多接口
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class Derived : 
     
     public Base, 
     
     public Interface1, 
     
     public Interface2
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     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 != 
     
     0)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		{
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			mi /= i;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Base *o;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     Derived d(100);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Derived *p = &d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Interface1 *pInt1 = &d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Interface2 *pInt2 = &d;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "p->getI() = " << p->getI() << 
     
     endl; 
     
     // 返回基类base的mi成员
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	pInt1->add(
     
     10);   
     
     // i == 110
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	pInt2->divide(
     
     11); 
     
     // i = 110 / 11
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	pInt1->minus(
     
     5);    
     
     // i = 10 - 5
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	pInt2->multiply(
     
     8); 
     
     // i = 40 
    
    
   
   

   
   

    
    

   
   
   
   

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

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // 可以连续操作说明这两个接口指向同一个对象。但实际的地址值不同
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "&d = " << &d << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "p = " << p << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pInt1 = " << pInt1 << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pInt2 = " << pInt2 << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     // p->equal(pInt1);   // 类型不匹配，这是接口类型，实际的是Base基类类型
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int a = p->equal(
     
     dynamic_cast<Base *>(pInt1));  
     
     // 动态的将这个地址指向的对象中Base那部分转换出来。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int b = p->equal(
     
     dynamic_cast<Base *>(pInt2));
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pInt1 == p: " << a << 
     
     endl; 
     
     // 说明接口类的地址，与子类的地址相等。
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << 
     
     "pInt2 == p: " << b << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "pause");
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

• 运行结果：
• 一些有用的工程建议 
  • 先继承自—个父类，然后实现多个接口 
  • 父类中提供equal()成员函数 
  • equal()成员函数用于判断指针是否指向当前对象 
  • 与多重继承相关的强制类型转换用dynamic_cast完成 

5.小结

• C++支持多重继承的编程方式
• 多重继承容易带来问题，如“同一个对象的地址不同”、“数据冗余”问题等。
• 多继承中可能出现多个虚函数表指针
• 与多重继承相关的强制类型转换用dynamic_cast完成
• 工程开发中采用“单继承+多接口”的方式使用多继承
• 父类提供成员函数用于判断指针是否指向当前对象