C++ 继承机制详解：从单继承到多继承菱形问题

1.2 继承定义

1.2.1 定义格式

语法结构很简单：子类名 : 继承方式 基类名。

继承方式决定了基类成员在派生类中的访问权限，分为公有（public）、保护（protected）、私有（private）。使用 class 关键字时默认继承方式是 private，而 struct 默认为 public，建议显式写出继承方式以增强可读性。

1.2.2 访问权限变化

基类成员在派生类中的可见性遵循以下规则：

1. private 成员：无论何种继承方式，基类的 private 成员在派生类中都是不可见的（虽然物理上存在于对象内存中，但语法禁止访问）。
2. protected 成员：专为继承设计。基类 private 成员不想在类外直接访问，但希望在派生类中使用，应定义为 protected。
3. 权限计算：基类其他成员在派生类的访问方式等于 Min(成员在基类的访问限定符，继承方式)。权限大小顺序为：public > protected > private。
4. 实际建议：虽然理论上存在 9 种组合，但实际开发中几乎只使用 public 继承。protected/private 继承会导致成员只能在派生类内部使用，扩展性和维护性较差。

class Person {
public:
    void Print() { cout << _name << endl; }
protected:
    string _name;
private:
    int _age;
};

// 推荐写法
class Student : public Person {
protected:
    int _stunum;
};

1.3 继承类模板

当基类是类模板时，需要注意实例化机制。由于模板是按需实例化的，如果子类未显式调用基类模板成员，编译器可能找不到标识符。

// 简化示例：Stack 基于 Vector 实现
template<class T>
class Stack : public std::vector<T> {
public:
    void push(const T& x) {
        // 必须显式指定作用域，否则编译报错
        vector<T>::push_back(x);
    }
    
    const T& top() {
        return vector<T>::back();
    }
};

对于构造与析构函数等特殊情况，编译器会自动处理，通常无需手动干预。

2. 基类和派生类间的转换

• 向上转型（Upcasting）：public 继承的派生类对象可以赋值给基类的指针或引用。这被称为切片（Slicing），即只保留派生类中属于基类的那部分数据。
• 向下转型（Downcasting）：基类对象不能直接赋值给派生类对象。基类指针/引用可以通过强制类型转换指向派生类，但必须确保该指针实际指向的是派生类对象，否则不安全。若涉及多态，推荐使用 dynamic_cast 进行运行时类型检查。

class Person {
public:
    string _name;
};

class Student : public Person {
public:
    int _No;
};

int main() {
    Student sobj;
    Person pobj = sobj; // 合法：切片
    
    Person* pp = &sobj;
    Student* ps = dynamic_cast<Student*>(pp); // 安全转换
    
    // Person p; Student* ps2 = dynamic_cast<Student*>(&p); // 返回 nullptr，不安全
    return 0;
}

3. 继承中的作用域

3.1 隐藏规则

在继承体系中，基类和派生类拥有独立的作用域。如果两者存在同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种现象称为隐藏。

• 如果是成员函数隐藏，只要函数名相同即可构成隐藏（参数列表不同也不重载）。
• 在派生类中，可以使用 基类::成员名 显式访问被隐藏的基类成员。
• 最佳实践：尽量避免在继承体系内定义同名成员，以免混淆。

class Person {
protected:
    int _num = 111; // 身份证号
};

class Student : public Person {
public:
    void Print() {
        cout << "身份证号:" << Person::_num << endl; // 显式访问
        cout << "学号:" << _num << endl;             // 访问自己的
    }
protected:
    int _num = 999; // 学号
};

3.2 常见误区

很多开发者容易误以为父子类同名函数是重载，实际上它们是隐藏关系。例如：

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

class B : public A {
public:
    void fun(int i) { cout << "B::fun(int)" << i << endl; }
};

int main() {
    B b;
    b.fun(10);      // 调用 B::fun(int)
    b.fun();        // 编译报错！因为 B::fun 隐藏了 A::fun
    b.A::fun();     // 正确：显式调用基类版本
    return 0;
}

4. 派生类的默认成员函数

4.1 生命周期管理

派生类的构造函数、拷贝构造、赋值运算符和析构函数都有特定的执行顺序：

1. 构造：先调用基类构造函数初始化基类部分，再调用派生类构造函数。
2. 析构：先调用派生类析构函数清理自身资源，再自动调用基类析构函数。
3. 拷贝与赋值：派生类的拷贝构造和赋值运算符必须显式或隐式调用基类的对应函数。

注意：如果基类没有默认构造函数，派生类必须在初始化列表中显式调用基类构造函数。

class Person {
public:
    Person(const char* name) : _name(name) { cout << "Person()" << endl; }
    ~Person() { cout << "~Person()" << endl; }
protected:
    string _name;
};

class Student : public Person {
public:
    // 必须在初始化列表中调用基类构造
    Student(const char* name, int num) : Person(name), _num(num) {}
    
    // 析构函数不需要显式调用基类析构，编译器会自动处理
    ~Student() { cout << "~Student()" << endl; }
protected:
    int _num;
};

4.2 防止被继承

C++11 引入了 final 关键字，用于禁止类被进一步继承：

class Base final {
public:
    void func() { cout << "Base::func" << endl; }
};

class Derive : public Base { // 编译错误：无法继承 final 类
    // ...
};

5. 继承与友元

友元关系不能继承。基类的友元只能访问基类的私有和保护成员，无权访问派生类的私有和保护成员。如果需要访问派生类成员，需将友元声明也添加到派生类中。

6. 继承与静态成员

静态成员在整个继承体系中是共享的。无论派生出多少个子类，静态成员只有一个实例，所有类共用同一份内存。

class Person {
public:
    static int _count;
};
int Person::_count = 0;

class Student : public Person {
    // ...
};

// 地址相同，说明是同一个实例
cout << &Person::_count << endl;

7. 多继承及其菱形继承问题

7.1 模型与风险

• 单继承：一个派生类只有一个直接基类。
• 多继承：一个派生类有两个或以上直接基类。内存布局通常是先放置第一个基类成员，再放第二个，最后是派生类成员。
• 菱形继承：多继承的特殊情况。例如 Assistant 同时继承 Student 和 Teacher，而这两者都继承自 Person。这会导致 Person 的成员在 Assistant 中出现两份副本，引发数据冗余和二义性问题。

class Person {
public:
    string _name;
};

class Student : public Person {
    int _num;
};

class Teacher : public Person {
    int _id;
};

class Assistant : public Student, public Teacher {
    string _majorCourse;
};

int main() {
    Assistant a;
    // a._name = "..."; // 编译报错：二义性
    a.Student::_name = "xxx"; // 解决二义性，但数据冗余仍在
    return 0;
}

7.2 虚继承解决方案

C++ 提供了 virtual 关键字来解决菱形继承问题。在中间层继承时使用 virtual public，确保最终派生类中只存在一份基类成员。

class Student : virtual public Person { /* ... */ };
class Teacher : virtual public Person { /* ... */ };
class Assistant : public Student, public Teacher { /* ... */ };

int main() {
    Assistant a;
    a._name = "Peter"; // 正常访问，无冗余
    return 0;
}

性能提示：虚继承会增加底层实现的复杂度（通常通过虚表指针），带来轻微的性能开销。因此，除非必要，尽量设计避免菱形继承结构。

7.3 指针偏移

在多继承中，基类子对象的起始地址可能与派生类对象整体地址不同。这是因为编译器需要调整指针偏移量，使其指向正确的基类部分。

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

int main() {
    Derive d;
    Base1* p1 = &d; // 指向 Base1 部分
    Base2* p2 = &d; // 指向 Base2 部分（有偏移）
    Derive* p3 = &d; // 指向 Derive 整体
    // p1 == p3 != p2
    return 0;
}

8. 继承和组合

8.1 设计原则

• 继承（Inheritance）：is-a 关系。子类是基类的一种。耦合度高，破坏封装性，适合实现多态或严格分类。
• 组合（Composition）：has-a 关系。对象包含另一个对象。耦合度低，黑箱复用，代码维护性好。

黄金法则：优先使用组合，而非继承。 只有当关系明确为 is-a 且需要多态支持时，才考虑继承。如果既适合继承又适合组合，组合通常是更安全的选择。

// 组合示例：Car 包含 Tire
class Tire { /* ... */ };
class Car {
    Tire _t1, _t2, _t3, _t4;
};

// 继承示例：BMW 是 Car 的一种
class BMW : public Car {
    void Drive() { /* ... */ }
};

在实际工程中，像 std::stack 基于 std::vector 实现，既符合 has-a（组合）也符合 is-a（公开继承接口），这种混合模式在标准库中很常见，但理解其背后的权衡至关重要。