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

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完成
• 工程开发中采用“单继承+多接口”的方式使用多继承
• 父类提供成员函数用于判断指针是否指向当前对象