C++学习笔记--多重继承的问题

C++中允许一个类继承自多个类，所以可以编写多重继承的代码，一个子类可以拥有多个父类，继承关系和普通继承一样，子类拥有父类所有的成员变量和成员函数，并且子类可以当做任意的父类使用。多重继承的语法规则是：

class Derived : public BaseA, public BaseB
{
    
};

其本质还是和单继承是一样的，子类中的变量排布也是先父类再子类，父类的排布顺序由继承顺序决定。

哪怕多重继承本质和单继承是一样的，但是他还是存在不少的问题导致开发过程中的难度增大和效率降低。

问题一

通过多重继承得到的对象可能拥有不同的地址。

class BaseA
{
    int ma;
public:
    BaseA(int a){  ma = a;   }
    int getA(){   return ma; }
};

class BaseB
{
    int mb;
public:
    BaseB(int b){   mb = b;    }
    int getB(){   return mb;   }
};
//变量排布与继承顺序相同，先父类再子类
class Derived : public BaseA, public BaseB
{
    int mc;
public:
    Derived(int a, int b, int c) : BaseA(a), BaseB(b)
    {
        mc = c;
    }
    int getC(){   return mc;   }
    void print()
    {
        cout << "ma = " << getA() << ", " << "mb = " << getB() << ", " << "mc = " << mc << endl;
    }
};

定义两个父类，由子类继承下来。

首先看看子类的内存空间是多少？

cout << "sizeof(Derived) = " << sizeof(Derived) << endl;    // 12

输出结果：

sizeof(Derived) = 12

答案和我们预想的是一致的，因为子类继承了两个父类，当然两个父类的成员变量都会叠加在子类中，加上子类自身定义的变量所以子类占用内存大小就是12个字节。

定义两个父类指针，都指向子类对象。

    Derived d(1, 2, 3);

    BaseA* pa = &d;
    BaseB* pb = &d;

    cout << "pa->getA() = " << pa->getA() << endl;
    cout << "pb->getB() = " << pb->getB() << endl;

输出结果：

pa->getA() = 1
pb->getB() = 2
说明父类指针能够通过子类对象访问到父类的成员。

我们定义两个指针，分别指向pa、pb，打印地址：

    void* paa = pa;
    void* pbb = pb;

    cout << "pa = " << pa << endl;
    cout << "pb = " << pb << endl;
    cout << "paa = " << paa << endl;
    cout << "pbb = " << pbb << endl;

我猜想的是什么？由于pa、pb都指向的是对象d，所以paa和pbb地址应该是相等的，看结果：

pa = 0x68fed4
pb = 0x68fed8
paa = 0x68fed4
pbb = 0x68fed8
并非预期那样，这是为什么，这就是多重继承留下的问题，看一张图就能明白了:

l两个指针虽然指向的是同一个对象，但是指向的却是同一个对象的不同位置，而我们在开发中都是以对象的起始地址作为对象地址，那么出现这种指向同一个对象的不同位置的情况无疑增加了开发难度，而且也没有什么解决方案，所以我们摒弃这种操作。
问题二

多重继承可能产生数据冗余。

定义这么个场景，有一个父类people，teacher继承自people，student继承自people，doctor同时继承teacher和student。

class People
{
    string m_name;
    int m_age;
public:
    People(string name, int age)
    {
        m_name = name;
        m_age = age;
    }
    void print()
    {
        cout << "Name = " << m_name << ", "
             << "Age = " << m_age << endl;
    }
};

class Teacher : public People
{
public:
    Teacher(string name, int age) : People(name, age)
    {
    }
};

class Student : public People
{
public:
    Student(string name, int age) : People(name, age)
    {
    }
};

class Doctor : public Teacher, public Student
{
public:
    Doctor(string name, int age) : Teacher(name, age), Student(name, age)
    {
    }
};

子类都是通过初始化列表进行初始化的，这样就会产生问题，当调用print时就会出现二义性，通过作用域符能解决，但是产生了数据冗余，一个doctor对象有两个name和age，可以 利用虚继承解决数据冗余问题，就是将中间层的继承写成虚继承，即：

class Student : virtual public People
class Teacher : virtual public People

这样中间层父类将不再关心顶层父类的初始化，但是最终的子类必须调用顶层父类的构造函数来初始化，但是在开发中，无法确定是直接继承还是虚继承，增大了难度，降低了效率。

    Doctor(string name, int age) : Teacher(name, age), Student(name, age), People(name, age)
    {
    }

直接调用顶层父类构造函数。

问题三

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

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
{

};

子类derived继承自BaseA和BaseB，并且两个父类中都有虚函数，这样就导致创建一个子类对象时，对象内部包含两个我们看不见的指向虚函数表的虚函数指针。意思就是当你使用多重继承后，不同类型的父类指针指向同一个子类对象时会根据父类虚函数表的不同而导致在不同虚函数表中调用虚函数，我们也可以通过打印父类指针值来说明它们并没有指向同一个地址。

    Derived d;
    BaseA* pa = &d;
    BaseB* pb = &d;
    
    cout << "pa = " << pa << endl;
    cout << "pb = " << pb << endl;
    cout << "pbb = " << pbb << endl;

输出结果;

pa = 0x68fed8
pb = 0x68fedc

说明两个指针指向确实不一样。

看看下面的例子：

    BaseB* pbb = (BaseB*)pa;
    pbb->funcB();

会输出什么？会调用funcB()吗？不会，这种粗暴的强制类型转换并不能使pbb改变指向。pa是通过vptr1找到BaseA类的虚函数表，再找到对应虚函数进行调用，pb的调用过程一样，而pbb由于简单的强制类型转换并不能改变指向，所以它的调用过程和pa一样，那么该如何解决呢？

图中很好的说明了pbb并没有指向vptr2，这种行为不可行，只有使用C++中新式转换类型dynamic_cast关键字进行将pa转换成BaseB指针类型。与多重继承相关、与虚函数相关的强制类型转换就需要用到dynamic_cast关键字。

工程开发中的多继承方式

单继承某个类加上多个接口。

首先实现一个父类，然后实现多个接口，父类中要提供一个equal()成员函数，用于判断指针是否指向当前对象。

class Base//父类
{
protected:
    int mi;
public:
    Base(int i){  mi = i;  }
    int getI(){  return mi; }
    bool equal(Base* obj)
    {
        return (this == obj);
    }
};

class Interface1//接口1
{
public:
    virtual void add(int i) = 0;
};

class Interface2//接口2
{
public:
    virtual void multiply(int i) = 0;
};

class Derived : public Base, public Interface1, public Interface2
{
public:
    Derived(int i) : Base(i)
    {
    }
    void add(int i){  mi += i;  }
    void multiply(int i){  mi *= i;  }
};

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

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

    pInt1->add(10);
    pInt2->multiply(8);

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

    cout << endl;

    cout << "pInt1 == p : " << p->equal(dynamic_cast<Base*>(pInt1)) << endl;
    cout << "pInt2 == p : " << p->equal(dynamic_cast<Base*>(pInt2)) << endl;

    return 0;
}

虽然继承方式还是多继承，但是从意义上讲实现的是单继承加多接口。