C++中的多继承（附带实例）

除了单继承，即派生类只从一个基类继承公有和受保护的成员，C++ 中还允许派生类从多个基类继承公有和受保护的成员，这种继承方式称为多重继承。

C++多重继承的定义

多重继承中存在多个基类名标识符，其声明形式如下：

class 派生类名 : [继承方式1] 基类名1 , [继承方式n] 基类名n 
{ 
    [访问控制修饰符:] 
    [成员声明列表] 
}; 

其中，由不同继承方式和基类名组成，用多个逗号分隔的列表称为派生表。

例如，鸟能够在天空飞翔，鱼能够在水里游，而水鸟既能够在天空飞翔，又能够在水里游，那么在定义水鸟类时，可以将鸟和鱼同时作为其基类。

class CBird                // 定义 CBird 类
{
public:
    void FlyInSky()        // 定义成员函数 FlyInSky
    {
        cout << "鸟能够在天空飞翔" << endl;
    }
    void Breath()          // 定义成员函数 Breath
    {
        cout << "鸟能够呼吸" << endl;
    }
};

class CFish                // 定义 CFish 类
{
public:
    void SwimInWater()     // 定义成员函数 SwimInWater
    {
        cout << "鱼能够在水里游" << endl;
    }
    void Breath()          // 定义成员函数 Breath
    {
        cout << "鱼能够呼吸" << endl;
    }
};

class CWaterBird : public CBird, public CFish   // 多重继承
{
public:
    void Action()
    {
        cout << "水鸟既能飞又能游" << endl;
    }
};

int main(int argc, char *argv[])
{
    CWaterBird waterbird;          // 定义 CWaterBird 类的对象
    waterbird.FlyInSky();          // 调用 CBird 的 FlyInSky
    waterbird.SwimInWater();       // 调用 CFish 的 SwimInWater
    return 0;
}

程序的运行结果为：

鸟能够在天空飞翔
鱼能够在水里游

CWaterBird 类继承了 CBird 类和 Cfish 类所有的公有成员和受保护成员，因此 waterbird 对象能够调用 FlyInSky() 和 SwimInWater() 成员函数。

CBird 类和 CFish 类中都有一个 Breath() 函数，如果 CWaterBird 类对象调用 Breath()，就会出现编译错误，因为编译器不知道该调用哪个类的 Breath() 函数。

要解决该二义性问题也简单，在 Breath() 成员函数前使用域限定符清晰指定类名即可。例如：

waterbird.CFish::Breath();   // 调用 CFish 的 Breath 
waterbird.CBird::Breath();   // 调用 CBird 的 Breath 

C++多重继承的构造顺序

单一继承方式中，先调用基类的构造函数，再调用派生类的构造函数。多重继承方式中，基类构造函数的调用顺序就是类声明中派生表给出的顺序。

【实例】多重继承谁先输出。本实例主要查看多重继承的构造顺序，具体代码如下：

#include <iostream>
using namespace std;

class CBicycle                // 定义 CBicycle
{
public:
    CBicycle()                // 默认构造函数
    {
        cout << "Bicycle Construct" << endl;
    }
    CBicycle(int iWeight)     // 带参构造函数
    {
        m_iWeight = iWeight;
    }
    void Run()
    {
        cout << "Bicycle Run" << endl;
    }
protected:
    int m_iWeight;
};

class CAirplane               // 定义 CAirplane
{
public:
    CAirplane()               // 构造函数
    {
        cout << "Airplane Construct" << endl;
    }
    CAirplane(int iWeight)    // 带参构造函数
    {
        m_iWeight = iWeight;
    }
    void Fly()
    {
        cout << "Airplane Fly" << endl;
    }
protected:
    int m_iWeight;
};

class CAirBicycle : public CBicycle, public CAirplane   // 多重继承
{
public:
    CAirBicycle()
    {
        cout << "CAirBicycle Construct" << endl;
    }
    void RunFly()
    {
        cout << "Run and Fly" << endl;
    }
};

int main()
{
    CAirBicycle ab;   // 定义 CAirBicycle 类对象 ab
    ab.RunFly();      // 调用 RunFly()
    return 0;
}

程序的运行结果为:

Bicycle Construct 
Airplane Construct 
CAirBicycle Construct 
Run and Fly 

基类的声明顺序是 CBicycle 类、CAirplane 类，所以对象的构造顺序是先 CBicycle 类、CAirplane 类、CAirBicycle 类。