第四节 · 遗产分配 · 访问控制与派生类作用域

C++ 支持多重继承：一个类可以从多个基类继承。这是强大但复杂的特性。

---

基本多重继承

class Flyable
{
public:
    void fly()
    {
        cout << "Flying in the sky" << endl;
    }
};

class Swimmable
{
public:
    void swim()
    {
        cout << "Swimming in water" << endl;
    }
};

// 鸭子既能飞又能游
class Duck : public Flyable, public Swimmable
{
public:
    void quack()
    {
        cout << "Quack quack!" << endl;
    }
};

int main()
{
    Duck d;
    d.fly();    // 继承自 Flyable
    d.swim();   // 继承自 Swimmable
    d.quack();  // 自己的方法
    
    return 0;
}

---

名称冲突

class A
{
public:
    void foo() { cout << "A::foo" << endl; }
};

class B
{
public:
    void foo() { cout << "B::foo" << endl; }
};

class C : public A, public B
{
public:
    void bar()
    {
        // foo();  // 错误：歧义
        A::foo();  // OK：指定基类
        B::foo();  // OK
    }
    
    // 或者重写来解决歧义
    void foo()
    {
        A::foo();  // 委托给 A 的版本
    }
};

int main()
{
    C c;
    // c.foo();  // 歧义
    c.A::foo();  // A::foo
    c.B::foo();  // B::foo
    
    return 0;
}

---

菱形继承问题

class Animal
{
public:
    int age;
    Animal() : age(0) { cout << "Animal()" << endl; }
};

class Mammal : public Animal
{
public:
    Mammal() { cout << "Mammal()" << endl; }
};

class Bird : public Animal
{
public:
    Bird() { cout << "Bird()" << endl; }
};

// 蝙蝠：既是哺乳动物又像鸟
class Bat : public Mammal, public Bird
{
public:
    Bat() { cout << "Bat()" << endl; }
};

int main()
{
    Bat b;
    // b.age = 5;  // 错误：歧义！有两个 age
    b.Mammal::age = 5;  // OK
    b.Bird::age = 3;    // OK，但这是另一个 age！
    
    return 0;
}
// 输出：Animal() Animal() Mammal() Bird() Bat()
// Animal 构造了两次！

---

虚继承解决菱形问题

class Animal
{
public:
    int age;
    Animal() : age(0) { cout << "Animal()" << endl; }
};

// 虚继承
class Mammal : virtual public Animal
{
public:
    Mammal() { cout << "Mammal()" << endl; }
};

class Bird : virtual public Animal
{
public:
    Bird() { cout << "Bird()" << endl; }
};

class Bat : public Mammal, public Bird
{
public:
    Bat() { cout << "Bat()" << endl; }
};

int main()
{
    Bat b;
    b.age = 5;  // OK：只有一个 age
    
    return 0;
}
// 输出：Animal() Mammal() Bird() Bat()
// Animal 只构造一次！

---

虚继承的构造函数

class Base
{
public:
    Base(int x) { cout << "Base(" << x << ")" << endl; }
};

class D1 : virtual public Base
{
public:
    D1() : Base(1) { cout << "D1()" << endl; }
};

class D2 : virtual public Base
{
public:
    D2() : Base(2) { cout << "D2()" << endl; }
};

class Derived : public D1, public D2
{
public:
    // 最派生类必须调用虚基类的构造函数
    Derived() : Base(0), D1(), D2()
    {
        cout << "Derived()" << endl;
    }
};

int main()
{
    Derived d;
    return 0;
}
// 输出：Base(0) D1() D2() Derived()
// 注意：Base 用的是 Derived 指定的 0，不是 D1 或 D2 的

---

接口继承模式

多重继承最常用于实现多个接口：

// 纯接口
class ISerializable
{
public:
    virtual string serialize() const = 0;
    virtual void deserialize(const string& data) = 0;
    virtual ~ISerializable() = default;
};

class IComparable
{
public:
    virtual int compareTo(const IComparable& other) const = 0;
    virtual ~IComparable() = default;
};

// 实现类
class Person : public ISerializable, public IComparable
{
    string name;
    int age;
    
public:
    Person(string n, int a) : name(n), age(a) {}
    
    string serialize() const override
    {
        return name + "," + to_string(age);
    }
    
    void deserialize(const string& data) override
    {
        // 解析 data
    }
    
    int compareTo(const IComparable& other) const override
    {
        auto& p = dynamic_cast<const Person&>(other);
        return age - p.age;
    }
};

---

混入（Mixin）模式

// 混入类：提供可复用的功能
template<typename T>
class Printable
{
public:
    void print() const
    {
        cout << static_cast<const T&>(*this).toString() << endl;
    }
};

template<typename T>
class Comparable
{
public:
    bool operator<(const T& other) const
    {
        return static_cast<const T&>(*this).compare(other) < 0;
    }
    
    bool operator==(const T& other) const
    {
        return static_cast<const T&>(*this).compare(other) == 0;
    }
};

// 使用混入
class MyClass : public Printable<MyClass>, public Comparable<MyClass>
{
    int value;
public:
    MyClass(int v) : value(v) {}
    
    string toString() const { return to_string(value); }
    int compare(const MyClass& other) const { return value - other.value; }
};

---

何时使用多重继承

推荐使用：

• 实现多个接口

• Mixin 模式

• 组合不相关的功能

避免使用：

• 继承多个有状态的类

• 存在方法名冲突

• 导致复杂的菱形继承

---

替代方案：组合

// 不用多重继承
class Duck
{
private:
    FlyBehavior* flyBehavior;
    SwimBehavior* swimBehavior;
    
public:
    void fly() { flyBehavior->fly(); }
    void swim() { swimBehavior->swim(); }
};

---

习题

• 解释虚继承是如何解决菱形问题的。

• 实现一个使用多重继承的游戏角色系统。

• 比较多重继承和组合的优缺点。