C++ 继承机制详解：从基础到多继承与组合

代码演示

场景 1：派生类对象赋值给基类

class Base { public: int age; };
class Derived : public Base { public: int id; };

int main() {
    Derived d;
    d.age = 10;
    d.id = 1;
    
    // 切片发生：只复制了 Base 部分
    Base b = d; 
    // b.age 为 10，b 没有 id 成员
}

场景 2：基类对象不能赋值给派生类

// 编译错误：Base 对象无法转换为 Derived 对象
Derived d = b; 

场景 3：强制类型转换（风险点）

Base* p_obj = new Base();
p_obj->age = 10;

// 情况①：基类指针指向派生类对象（安全）
Derived d;
Base* p_d = &d;
Derived* ps1 = static_cast<Derived*>(p_d);
ps1->id = 1; // 正确识别了对象的完整类型

// 情况②：基类指针指向基类对象（危险）
Base* p_base = new Base();
Derived* ps2 = static_cast<Derived*>(p_base);
ps2->id = 1; // 未定义行为！访问了非法内存区域

三、重定义（隐藏）

在继承体系中基类和派生类都有独立的作用域。子类和父类中如果存在同名成员，子类成员将屏蔽对父类同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 父类::父类成员 显式访问父类成员）

注：

1. 成员函数只需要函数名相同就构成隐藏。
2. 在实际中继承体系里面最好不要定义同名的成员。

示例①（成员变量同名）

class Base {
public:
    int num;
};
class Derived : public Base {
public:
    int num;
};

int main() {
    Derived d;
    d.num = 10; // 优先打印的是子类中的 _num
    std::cout << d.num << std::endl;
    std::cout << d.Base::num << std::endl; // 显式访问基类
}

这里打印 num 时，优先到局部域中找，找不到再依次到子类域、父类域、全局域找，一处找到后就不再向后查询。

示例②（成员函数同名）

class Base {
public:
    void fun() { std::cout << "Base" << std::endl; }
};
class Derived : public Base {
public:
    void fun(int x) { std::cout << "Derived" << std::endl; }
};

int main() {
    Derived d;
    d.fun(1); // 调用 Derived::fun
    d.fun();  // 报错！Base::fun 被隐藏了
}

可以看到此处调用 fun() 函数如果不传参数，就报错，因为父类中的 fun() 被隐藏了，调用到的是子类中的 fun() 函数，传参后报错消失。

隐藏，通俗点理解就是当父类和子类出现同名成员时，默认先访问子类的同名成员，就好像父类中的同名成员被隐藏起来了一样。

四、派生类的默认成员函数

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。派生类对象初始化先调用基类构造再调派生类构造。派生类对象析构清理先调用派生类析构再调基类的析构。

总结：

1. 派生类继承自基类的那部分，其构造、拷贝构造、赋值重载以及析构都需要通过派生类调用基类的来完成。
2. 先构造基类，再构造派生类。
3. 先析构派生类，再析构基类。

关于父类中默认成员函数是否需要显式调用

1. 父类的普通构造函数

• 必须显式调用的情况： 如果父类没有默认构造函数（即没有无参构造函数，或默认构造函数被删除 / 不可访问），子类必须在初始化列表中显式调用父类的某个有参构造函数。
• 可隐式调用的情况： 如果父类有默认构造函数（无参构造函数），子类初始化列表中若不显式调用父类构造函数，编译器会自动隐式调用父类的默认构造函数。

2. 父类的拷贝构造函数

• 必须显式调用： 子类的拷贝构造函数不会自动调用父类的拷贝构造函数，而是默认调用父类的默认构造函数。因此，若需要用父类对象的成员初始化子类中继承的父类部分，必须在子类拷贝构造函数的初始化列表中显式调用父类的拷贝构造函数。
• 若不显式调用 Parent(other)，则父类部分会被 Parent()（默认构造函数）初始化，导致父类成员未正确拷贝。

3. 父类的赋值运算符重载

• 必须显式调用： 子类的赋值运算符重载不会自动调用父类的赋值运算符，需要在子类赋值运算符的函数体内部显式调用父类的赋值运算符（不能在初始化列表中调用，因为赋值运算发生在对象构造之后）。
• 若不显式调用 Parent::operator=(other)，父类部分的成员不会被赋值，导致赋值不完整。

五、继承与友元

友元关系不能继承，即父类的友元不能访问子类的私有和保护成员（即使是子类继承的成员也不行），因为父类的友元不是子类的友元。

class Base {
    friend void func(Base&); // 友元只能访问 Base
};
class Derived : public Base {};

void func(Derived& d) {
    // 无法访问 Derived 的私有成员，即使它是 Base 的子类
}

六、继承与静态成员

1. 基类静态成员变量：派生类共享同一实例

基类的静态成员变量在内存中仅存在一份实例，所有派生类（及基类自身的对象）共享这一份数据，不会因继承而产生新的副本。

• 内存唯一：基类静态成员变量仅在全局区分配一次内存，派生类不会为其额外分配内存。
• 共享修改：无论是基类对象还是派生类对象，修改的都是同一份 static_val，修改后所有访问者都会看到最新值。
• 访问方式：静态成员变量可通过'类名::静态成员'（推荐，无需创建对象）或'对象。静态成员'访问，派生类也可通过自身类名访问。

2. 基类静态成员函数：派生类可继承且共享实现

基类的静态成员函数同样属于类本身，派生类会继承该函数的实现，且所有派生类共享同一函数实例（不会因继承产生新的函数副本）。

• 静态成员函数的核心限制：只能访问静态成员变量 / 静态成员函数，无法访问非静态成员（因为非静态成员依赖具体对象，而静态函数无 this 指针）。
• 继承实现：派生类无需重写即可直接调用基类的静态成员函数。
• 无多态性：静态成员函数不依赖 this 指针，也无法被声明为 virtual（虚函数），因此不支持多态。即使派生类重写了静态函数，也只是'隐藏'基类的静态函数，而非覆盖。

3. 派生类对基类静态成员的'隐藏'（而非覆盖）

若派生类定义了与基类同名的静态成员（变量或函数），会隐藏基类的静态成员（即派生类范围内优先访问自身的静态成员），但不会覆盖基类的静态成员（基类的静态成员仍存在且可访问）。

• 隐藏规则：派生类同名静态成员仅在自身作用域内隐藏基类成员，基类成员仍独立存在（如 Base::static_val 与 Derived::static_val 是两个不同的静态变量，各有一份内存）。
• 无多态：即使基类指针指向派生类对象，静态成员函数的调用仍由'指针的类类型'决定，而非'对象实际类型'，这与虚函数的多态性完全不同。

七、多继承

1. 单继承

前面举的例子基本都是单继承，这里就不展开了。

2. 多继承

一般不建议设计出多继承。

class Base1 { public: void f1() {} };
class Base2 { public: void f2() {} };
class Derived : public Base1, public Base2 {};

// Derived 同时拥有 Base1 和 Base2 的成员，可直接调用两个基类的函数

继承方式的作用与单继承相同（如 public 继承保持基类成员的访问权限）。

3. 菱形继承

首先声明：一定不要设计出菱形继承，否则在复杂度及性能上都可能有问题。

菱形继承结构，会导致派生类中出现数据冗余和访问歧义。

class Base { public: int x; };
class D1 : public Base {};
class D2 : public Base {};
class Final : public D1, public D2 {}; // 菱形继承

Final fd;
fd.x = 10; // 编译错误：x 有二义性

• 数据冗余：FinalDerived 继承了 D1 和 D2，而两者都包含 Base 的成员 x，因此 FinalDerived 中存在两份 x。
• 访问歧义：直接访问 fd.x 时，编译器无法确定要访问哪一份 x，导致编译错误。

4. 菱形继承的解决方法：虚继承

虚继承确保最终派生类中只保留共同基类的一份实例。

仅在菱形继承场景下使用虚继承，其它情况不要使用。

class Base { public: int x; };
class D1 : virtual public Base {};
class D2 : virtual public Base {};
class Final : public D1, public D2 {};

Final fd;
fd.x = 10; // 正常访问，只有一份 x

• 单一实例：虚继承确保共同基类（Base）在最终派生类（FinalDerived）中只存在一份实例，消除数据冗余。
• 初始化责任转移：虚基类（Base）的初始化不再由直接派生类（D1、D2）负责，而是由最终派生类（FinalDerived）在初始化列表中直接初始化。
• 避免歧义：由于只有一份共同基类成员，直接访问不会产生歧义。

底层原理：

• 虚继承基本内存布局：Base 实例被移到内存末尾，成为所有虚继承类的共享实例，即只有一份 Base 实例。
• 虚基类指针（vbptr）：虚继承的类（如 D1、D2）会在内存中增加一个隐藏的指针成员 vbptr，用于指向虚基类表（vbtable）。
• 虚基类表（vbtable）：存储偏移量的数组，记录当前类的成员与虚基类成员之间的内存距离。
• 访问过程：通过 vbptr 找到 vbtable，获取偏移量，计算出 Base::x 在内存中的实际地址。
• 初始化责任：虚基类（Base）的构造函数由最终派生类（FinalDerived）负责调用，而非中间派生类。这确保 Base 只被初始化一次。

注意：

• 若多个基类有同名成员（非来自共同基类），派生类访问时需用基类名限定以消除歧义。
• 若多个基类有同名虚函数，派生类重写时需确保函数签名一致，否则可能导致多态行为异常。
• 性能代价：增加内存开销（每个虚继承的类需存储 vbptr），访问效率降低（间接计算地址）。仅在菱形继承场景下使用虚继承。

八、对象组合

通过在一个类中声明另一个类的对象作为成员，实现功能组合。

示例： Car 类通过成员变量 engine 组合了 Engine 类的功能体现了 "has-a" 关系（汽车有一个引擎）。

• Car 可以直接使用 Engine 的 run() 方法，但无需继承 Engine。
• 成员对象 engine 的生命周期与 Car 对象一致。

对象组合的形式

1. 严格组合：成员对象完全依赖于所属对象存在（如'汽车和发动机'），成员对象不能被多个所属对象共享。
2. 聚合：成员对象可独立存在，只是被所属对象'引用'（如'公司和员工'）。通常通过指针或引用实现，成员对象的生命周期不受所属对象控制。
3. 关联：两个类通过指针/引用建立临时联系（如'客户和订单'），关联关系可动态建立或解除。

对象组合的优势

• 低耦合：组合类与成员对象之间仅通过接口交互，修改成员对象的内部实现不会影响组合类（符合'开闭原则'）。
• 高灵活性：可通过替换不同的成员对象（如不同型号的发动机），在不修改 Car 类的情况下改变其功能。
• 避免菱形继承问题：当需要复用多个类的功能时，组合不会像多继承那样导致歧义或数据冗余。

总结： 在实际开发中，应遵循'优先使用组合，而非继承'（Favor Composition Over Inheritance）的设计原则，以构建更健壮、易维护的代码。