第15章 继承与派生

想象一下你要设计一个车辆管理系统。与其为卡车、轿车、摩托车各自从头编写所有“车辆”相关的代码（如品牌、颜色、启动），不如先定义一个通用的“车辆”蓝图，然后让具体车型去继承它，并添加自己独有的特性（如卡车的载重量）。这就是继承的核心思想：基于已有的类创建新类，实现代码复用和层次化建模。

继承方式决定了基类成员在派生类中的“可见性”

看一个具体例子。假设我们有一个基类 Vehicle，现在用公有继承派生出 Car 类。

// 基类定义
class Vehicle {
public:
    void start() { cout << "Vehicle started." << endl; }
protected:
    string brand = "Unknown";
private:
    int serialNumber = 0;
};

// 派生类定义：公有继承
class Car : public Vehicle { // 使用 public 继承
public:
    void showBrand() {
        cout << "Brand: " << brand << endl; // 正确：可以访问基类的protected成员
        // cout << serialNumber << endl; // 错误：不能访问基类的private成员
    }
    int doorCount = 4; // 派生类新增成员
};

// 使用
main() {
    Car myCar;
    myCar.start(); // 正确：继承了基类的public方法
    myCar.showBrand();
    // myCar.brand = "Toyota"; // 错误：外部不能访问protected成员
}

15.2 派生类的构造与析构：严格的顺序

创建一个派生类对象时，构造和析构函数的调用顺序是固定的，理解这个顺序对管理资源（如动态内存、文件句柄）至关重要。

顺序可以概括为：构造由内而外（先基类，再成员，最后自己），析构由外而内（先自己，再成员，最后基类）。这个顺序是自动的，但你需要用初始化列表来正确地向基类构造函数传递参数。

class Engine {
public:
    Engine(int hp) : horsepower(hp) { cout << "Engine constructed: " << hp << "HP" << endl; }
    ~Engine() { cout << "Engine destructed" << endl; }
private:
    int horsepower;
};

class BaseVehicle {
public:
    BaseVehicle(const string& id) : vehicleId(id) { cout << "BaseVehicle constructed: " << id << endl; }
    ~BaseVehicle() { cout << "BaseVehicle destructed" << endl; }
private:
    string vehicleId;
};

class Motorcycle : public BaseVehicle {
public:
    // 初始化列表：先调用基类构造函数，再初始化成员对象
    Motorcycle(const string& id, int engineHP)
        : BaseVehicle(id), // 必须在这里调用基类构造函数
          engine(engineHP),    // 初始化成员对象
          type("Sport") {     // 初始化自身成员
        cout << "Motorcycle constructed" << endl;
    }
    ~Motorcycle() { cout << "Motorcycle destructed" << endl; }
private:
    Engine engine; // 成员对象
    string type;
};

// 测试代码
int main() {
    Motorcycle bike("M001", 150);
    return 0;
}
/* 输出顺序：
BaseVehicle constructed: M001
Engine constructed: 150HP
Motorcycle constructed
Motorcycle destructed
Engine destructed
BaseVehicle destructed
*/

15.3 名字隐藏与作用域解析

如果派生类定义了一个与基类同名的成员函数（即使参数列表不同），基类的同名函数在派生类作用域内会被隐藏，而不是重载。这常常是新手困惑的来源。

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

class Derived : public Base {
public:
    // 定义了同名函数，隐藏了基类的所有func版本
    void func(double x) { cout << "Derived::func(double)" << endl; }
};

main() {
    Derived d;
    d.func(5.0); // 正确：调用 Derived::func(double)
    d.func(5);   // 也调用 Derived::func(double)，发生int到double的隐式转换
    // d.func(5); 本意想调用 Base::func(int)，但被隐藏了，导致编译错误或非预期行为

    // 解决方案：使用作用域解析运算符 ::
    d.Base::func(5); // 正确：显式调用基类版本
}

要解决这个问题，如果你希望在派生类中重载基类函数而不是隐藏它，可以使用 using 声明将基类函数引入派生类作用域。

class Derived2 : public Base {
public:
    using Base::func; // 引入Base::func到当前作用域
    void func(double x) { cout << "Derived2::func(double)" << endl; }
    // 现在 func(int) 和 func(double) 在Derived2中形成重载
};

main() {
    Derived2 d2;
    d2.func(5);   // 正确：调用从Base引入的 func(int)
    d2.func(5.0); // 正确：调用 Derived2::func(double)
}

实际开发中，大部分团队会严格遵循一个准则：仅当需要表现“是一个”关系，且需要利用多态性（下一章内容）时，才使用公有继承。其他情况，优先考虑组合（包含对象成员）。这能有效降低类之间的耦合度。