C++ 继承：派生类构造、多继承与菱形虚拟继承详解

注意： 如果不在 Student 中声明 Display 为友元，编译会报错无法访问 protected 成员。因此需要给派生类也声明友元。

三、静态成员在继承中的特性

3.1 静态成员共享机制：父子共用同一份

基类定义了 static 静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个 static 成员实例。

3.2 静态与非静态成员对比

• 非静态成员：实例独立。父类和子类各一份，地址不一样。
• 静态成员：类间共享。父类和子类共用同一份，地址也一样。

3.3 实践案例

class Person {
public:
    string _name;
    static int _count; // 存放在静态区
};
int Person::_count = 0;

class Student : public Person {
protected:
    int _stuNum;
};

int main() {
    Person p;
    Student s;
    // 非静态成员_name 的地址是不一样的
    cout << &p._name << endl;
    cout << &s._name << endl;
    // 静态成员_count 的地址是一样的
    cout << &p._count << endl;
    cout << &s._count << endl;
    // 公有的情况下，父派生类指定类域都可以访问静态成员
    cout << Person::_count << endl;
    cout << Student::_count << endl;
    return 0;
}

四、单继承 vs 多继承（以及菱形继承问题详解）

事先说明：多继承是个大坑！！！

4.1 单继承 vs 多继承

概念上，单继承是一个类只继承一个基类，多继承是一个类继承多个基类。

4.2 菱形继承问题详解

4.2.1 菱形继承的概念

当一个类通过两个中间类间接继承同一个基类时，形成菱形结构。

4.2.2 菱形继承的数据冗余与二义性问题

• 数据冗余：基类数据在派生类中存在两份副本。
• 二义性：访问基类成员不明确，需指定类域解决，但无法解决冗余问题。

4.2.3 虚继承解决方案

多继承实现的菱形继承才是问题。设计了'菱形虚拟继承'来解决，使用 virtual 关键字。

4.2.4 虚继承机制与 virtual 关键字

virtual 加在腰部位置（中间层）。不要随意滥用，会影响底层空间模型。

4.2.5 实战

class Person {
public:
    Person(const char* name) :_name(name) {}
    string _name; // 姓名
};

class Student : virtual public Person {
public:
    Student(const char* name, int num) :Person(name), _num(num) {}
protected:
    int _num; // 学号
};

class Teacher : virtual public Person {
public:
    Teacher(const char* name, int id) :Person(name), _id(id) {}
protected:
    int _id; // 职工编号
};

class Assistant : public Student, public Teacher {
public:
    Assistant(const char* name1, const char* name2, const char* name3)
        :Person(name3), Student(name1, 1), Teacher(name2, 2) {}
protected:
    string _majorCourse; // 主修课程
};

int main() {
    Assistant a("张三", "李四", "王五");
    return 0;
}

结论： 可以设计出多继承，但不建议设计出菱形继承，因为菱形虚拟继承后使用及底层都会复杂很多。

4.3 多继承中的指针偏移问题

在多继承中，不同基类的指针地址可能不同。

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 {
public: int _d;
};

int main() {
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    // p1 == p3 != p2
}

五、继承与组合设计模式对比

5.1 基本概念：is-a vs has-a

• public 继承：是一种 is-a 的关系。每个派生类对象都是一个基类对象。
• 组合：是一种 has-a 的关系。B 对象中包含 A 对象。

5.2 继承与组合关系对比

• 白盒复用：继承方式，基类内部细节对派生类可见，耦合度高。
• 黑盒复用：组合方式，对象内部细节不可见，耦合度低。

5.3 实践

// Tire(轮胎) 和 Car(车) 更符合 has-a 的关系
class Tire {
protected:
    string _brand = "Michelin";
    size_t _size = 17;
};

class Car {
protected:
    string _colour = "白色";
    Tire _tires[4]; // 使用数组更合适
};

class BMW : public Car {
public:
    void Drive() { cout << "好开 - 操控" << endl; }
};

// 正确的 Stack 实现（组合）
template<class T>
class Stack {
private:
    vector<T> _v; // 组合关系
public:
    void push(const T& x) { _v.push_back(x); }
    void pop() { if (!_v.empty()) _v.pop_back(); }
    T& top() { if (!_v.empty()) return _v.back(); throw std::out_of_range("Stack is empty"); }
    bool empty() const { return _v.empty(); }
    size_t size() const { return _v.size(); }
};

总结： 优先使用组合；既符合继承也符合组合，我们使用组合；但是要注意：是'优先使用组合'，不是必须使用，像多态这些需要继承的地方还是要用继承。

结尾

继承作为 C++ 面向对象编程的三大特性之一，是连接'通用类'与'专用类'的桥梁。掌握继承的概念、关键要素与使用原则，能提升代码效率，构建逻辑清晰、易于维护的系统。