C++ 继承机制详解：从概念到多继承模型

class Person {
public:
    void identity() { /* ... */ }
protected:
    string _name = "peter";
    string _address;
    int _age = 18;
};

class Student : public Person {
public:
    void study() { /* ... */ }
protected:
    int _stuid;
};

class Teacher : public Person {
public:
    void teaching() { /* ... */ }
protected:
    string _title;
};

将公共部分提取为 Person 基类，派生类只需关注自身特性。

2. 继承的定义与访问控制

继承方式有三种：public 继承、protected 继承、private 继承。这与成员访问限定符类似，但会影响派生类中成员的最终访问权限。

2.1 继承对访问权限的影响

核心规则：

1. 基类 private 成员：无论以什么方式继承，在派生类中都是不可见的。这意味着语法上限制派生类对象不能直接访问它，但可以通过基类的公有函数间接访问。
2. 其他成员：派生类中的访问权限等于 Min(基类成员访问限定符，继承方式)。
3. 默认继承方式：使用 class 关键字时默认为 private 继承；使用 struct 时默认为 public 继承。建议显式写出继承方式。
4. 实践建议：实际开发中一般使用 public 继承。protected/private 继承下来的成员只能在派生类内部使用，扩展性和维护性较差，不提倡使用。

2.2 示例代码

class Person {
public:
    void identity() { /* ... */ }
    void func() { ++_age; } // 提供公有接口访问私有成员
protected:
    string _name = "peter";
private:
    int _age = 18;
};

class Student : public Person {
public:
    void study() {
        _name = "张三"; // 可以访问 protected 成员
        // _age++; // 错误：无法直接访问 private 成员
        func(); // 通过公有接口访问
    }
};

3. 派生类与基类的转换（切片）

在基类和派生类对象之间的赋值转换不会像普通类型转换那样产生临时变量，这被称为赋值兼容规则，通俗称为切片（Slicing）。

3.1 派生类转基类

派生类对象可以赋值给基类的指针或引用，中间不产生临时变量。这相当于把派生类中属于基类的那部分'切'出来。

class Person {
protected:
    string _name;
    int _age;
};

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

int main() {
    Student sobj;
    // 派生类对象赋值给基类指针/引用，不产生临时变量
    Person* pp = &sobj;
    Person& rp = sobj;
    
    // 注意：这里发生了切片，pp 和 rp 只能访问 Person 部分的成员
    return 0;
}

3.2 基类转派生类

基类对象不能直接赋值给派生类对象。基类指针/引用可以通过强制类型转换赋值给派生类指针/引用，但必须确保基类指针实际指向的是派生类对象，否则不安全。若涉及多态，建议使用 dynamic_cast 进行运行时类型检查。

4. 继承中的作用域与隐藏

在继承体系中，基类和派生类拥有独立的作用域。如果派生类中有与基类同名的成员，派生类成员将屏蔽基类同名成员，这叫隐藏。

4.1 隐藏规则

1. 成员变量隐藏：派生类成员屏蔽基类同名成员。在派生类成员函数中，可使用 Base::member 显式访问基类成员。
2. 成员函数隐藏：只要函数名相同即构成隐藏，与参数无关（这与重载不同，重载要求同一作用域且参数不同）。基类和派生类属于不同作用域，因此不构成重载。

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

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

int main() {
    B b;
    b.fun(1);      // 调用 B::fun(int)
    b.A::fun();    // 显式调用 A::fun()
    // b.fun();     // 编译报错：A::fun 被隐藏
    return 0;
}

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

编译器会自动生成默认构造函数、拷贝构造、赋值重载和析构函数。在继承关系中，这些函数的行为遵循以下规则：

1. 构造函数：派生类构造函数必须调用基类构造函数初始化基类部分。如果基类没有默认构造函数，必须在初始化列表中显式调用。
2. 拷贝构造：派生类拷贝构造需调用基类拷贝构造完成基类部分的复制。
3. 赋值重载：派生类 operator= 会隐藏基类的 operator=。如需调用基类版本，需指定作用域 Base::operator=。
4. 析构函数：派生类析构函数执行完毕后，自动调用基类析构函数。顺序是先子后父，保证资源清理安全。

示例：手动实现四大函数

class Person {
public:
    Person(const char* name = "peter") : _name(name) {}
    Person(const Person& p) : _name(p._name) {}
    Person& operator=(const Person& p) { if (this != &p) _name = p._name; return *this; }
    ~Person() {}
protected:
    string _name;
};

class Student : public Person {
public:
    // 1. 构造函数：显式调用基类构造函数
    Student(const char* name, const char* addr) : Person(name), _address(addr) {}

    // 2. 拷贝构造：利用切片传递基类部分
    Student(const Student& s) : Person(s), _address(s._address) {}

    // 3. 赋值重载：显式调用基类 operator=
    Student& operator=(const Student& s) {
        if (this != &s) {
            Person::operator=(s); // 处理基类部分
            _address = s._address;
        }
        return *this;
    }

    // 4. 析构函数：无需显式调用基类析构，编译器自动处理
    ~Student() {}

protected:
    string _address;
};

6. 实现不能被继承的类

有两种常见方法阻止类被继承：

1. 构造函数私有化：派生类实例化需要调用基类构造函数，若基类构造函数私有，派生类无法访问，从而无法实例化。（C++98 风格）
2. 使用 final 关键字：C++11 引入 final，修饰基类后，任何类都不能再继承它。（推荐）

class Base final {
public:
    void func() { cout << "Base::func" << endl; }
};
// class Derived : public Base {}; // 编译错误：无法继承 final 类

7. 友元与静态成员

7.1 友元关系不可继承

友元关系具有特殊性，不能继承。基类的友元不能访问派生类的私有或保护成员。如果需要在派生类中也成为友元，必须在派生类中重新声明。

7.2 静态成员共享

基类定义的 static 静态成员在整个继承体系中只有一个实例。无论派生出多少个派生类，都共用同一份静态成员变量，不会生成副本。

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

class Student : public Person {};

int main() {
    Person p; Student s;
    cout << &p._count << endl; // 地址相同
    cout << &s._count << endl; // 地址相同
    return 0;
}

8. 多继承与菱形继承

8.1 继承模型

• 单继承：一个派生类只有一个直接基类。
• 多继承：一个派生类有两个或以上直接基类。内存布局通常是先继承的基类在前，后继承的在后，派生类成员在最后。
• 菱形继承：多继承的特殊情况，导致数据冗余和二义性问题。

8.2 菱形继承问题

当两个派生类同时继承同一个基类，而另一个类又同时继承这两个派生类时，会出现菱形继承。此时，最底层的对象中会包含两份基类成员，导致数据冗余和访问二义性。

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; };

8.3 解决方案

1. 指定作用域：解决二义性，但无法解决数据冗余。

   a.Student::_name = "wzy";
   a.Teacher::_name = "wzz";
   

2. 虚继承：在中间层继承时使用 virtual 关键字，确保基类成员在内存中只有一份。

   class Student : virtual public Person { int _num; };
   class Teacher : virtual public Person { int _id; };
   // Assistant 继承时无需修改，Person 部分已合并
   

注意：虚继承会增加底层实现的复杂度和性能损耗，除非必要，不建议随意使用。Java 不支持多继承就是为了规避此类问题。

9. 继承与组合

• 继承（Is-a）：是一种白箱复用，基类细节对派生类可见。耦合度高，基类改变影响派生类。
• 组合（Has-a）：是一种黑箱复用，对象组装获得功能。耦合度低，封装性好。

设计原则：优先使用组合，而不是继承。只有当类之间确实是 is-a 关系（如 BMW 是 Car）时才考虑继承。如果既适合继承也适合组合，通常选择组合以保持低耦合。

// 组合示例：Tire 和 Car 是 has-a 关系
class Tire { string _brand; };
class Car {
    Tire _t1, _t2, _t3, _t4;
};

// 继承示例：BMW 是 Car 的一种
class BMW : public Car {
    void Drive() { cout << "好开" << endl; }
};

本文涵盖了 C++ 继承的核心机制，从基础定义到复杂的菱形继承处理。理解这些概念对于编写高质量、可维护的 C++ 代码至关重要。在实际开发中，请根据具体场景权衡继承与组合的使用。