C++_继承

面向对象编程 (OOP) 的三大支柱

在讨论继承之前，先回顾一下OOP的三大核心特性：

**封装 **(Encapsulation)：将数据（属性）和操作数据的方法（行为）捆绑在一起，并隐藏内部实现细节。我们已经讨论过，主要通过 class 和访问修饰符（private, public, protected）实现。
**继承 **(Inheritance)：一个类（子类/派生类）可以基于另一个类（父类/基类）来创建，自动获得其属性和方法，并可以扩展或修改它们。这是代码复用和建立类层次结构的关键。
**多态 **(Polymorphism)：同一个接口可以表现出多种形态。通常通过继承和虚函数实现，允许使用基类指针或引用来调用派生类的特定实现。

继承是连接封装和多态的桥梁。
什么是继承？

继承允许我们定义一个新类（称为派生类或子类），它基于一个已有的类（称为基类或父类）。派生类会自动继承基类的成员（数据和函数），并且可以：

复用基类的代码。
添加新的成员（数据或函数）。
**重写 **(Override) 基类的虚函数，以提供不同的实现。

目的：实现代码复用、建立类的层次结构、为多态打下基础。
C++中继承的语法

// 基类 (Base Class)
class Animal {
protected: // 使用 protected，允许派生类访问，但外部不能直接访问
    std::string name;
    int age;

public:
    Animal(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Animal 构造函数: " << name << std::endl;
    }

    // 虚函数 - 为多态做准备
    virtual void makeSound() const {
        std::cout << name << " 发出动物的声音。" << std::endl;
    }

    void eat() const {
        std::cout << name << " 正在吃东西。" << std::endl;
    }

    virtual ~Animal() { // 虚析构函数很重要！
        std::cout << "Animal 析构函数" << std::endl;
    }
};

// 派生类 (Derived Class)
// 语法: class 派生类名 : [继承方式] 基类名
class Dog : public Animal { // public 继承
private:
    std::string breed; // 新增成员

public:
    // 构造函数需要初始化基类部分
    Dog(const std::string& n, int a, const std::string& b)
        : Animal(n, a), breed(b) { // 调用基类构造函数
        std::cout << "Dog 构造函数: " << name << std::endl;
    }

    // 重写 (Override) 基类的虚函数
    void makeSound() const override { // override 关键字可选，但推荐使用
        std::cout << name << " 汪汪汪！" << std::endl;
    }

    // 新增方法
    void fetch() const {
        std::cout << name << " 正在捡球。" << std::endl;
    }

    ~Dog() {
        std::cout << "Dog 析构函数" << std::endl;
    }
};

class Cat : public Animal {
public:
    Cat(const std::string& n, int a) : Animal(n, a) {}

    void makeSound() const override {
        std::cout << name << " 喵喵喵！" << std::endl;
    }
};

继承方式 (Inheritance Modes)

派生类继承基类时，可以指定三种访问权限：

public 继承：
    基类的 public 成员在派生类中仍然是 public。
    基类的 protected 成员在派生类中仍然是 protected。
    基类的 private 成员不可访问（但已被继承，只是无法直接访问）。
    这是最常用、最推荐的方式，表示“是一个”（is-a）关系。例如，Dog 是一个 Animal。

protected 继承：
    基类的 public 和 protected 成员在派生类中都变为 protected。
    基类的 private 成员不可访问。
    很少使用。

private 继承：
    基类的所有成员（public 和 protected）在派生类中都变为 private。
    基类的 private 成员不可访问。
    表示“由...实现”（is-implemented-in-terms-of），通常可以用组合（Composition）代替，更推荐组合。

记住：基类的 private 成员永远不能被派生类直接访问，无论继承方式如何。但派生类可以通过基类的 public 或 protected 成员函数来间接访问。

继承中的关键概念

构造函数和析构函数：
    创建派生类对象时，先调用基类构造函数，再调用派生类构造函数。
    销毁派生类对象时，先调用派生类析构函数，再调用基类析构函数。
    派生类构造函数必须通过初始化列表调用基类构造函数（除非基类有默认构造函数）。

protected 访问修饰符：
    介于 private 和 public 之间。
    可以被本类和派生类访问，但不能被外部代码访问。
    用于让派生类能够访问基类的关键数据或方法，同时对外部隐藏。

**函数重写 **(Function Overriding)
    在派生类中定义一个与基类虚函数同名、同参数列表的函数。
    必须在基类中将函数声明为 virtual。
    使用 override 关键字（C++11起）可以显式表明意图，并在编译时检查是否真的重写了基类函数。

**虚析构函数 **(Virtual Destructor)
    如果一个类设计为基类（有派生类），其析构函数必须声明为 virtual。
    这样才能确保通过基类指针删除派生类对象时，能正确调用派生类的析构函数，避免资源泄漏。
    这是一个极其重要的规则！

多态 (Polymorphism) 的体现

继承为多态提供了基础。看这个例子：

int main() {
    // 普通调用
    Dog dog("旺财", 3, "金毛");
    dog.makeSound(); // 输出: 旺财 汪汪汪！
    dog.eat();       // 输出: 旺财 正在吃东西。

    Cat cat("咪咪", 2);
    cat.makeSound(); // 输出: 咪咪 喵喵喵！

    // 多态的关键：基类指针/引用指向派生类对象
    Animal* animal1 = &dog;
    Animal* animal2 = &cat;

    // 调用 makeSound()，实际执行哪个版本？
    animal1->makeSound(); // 输出: 旺财 汪汪汪！ (调用 Dog::makeSound)
    animal2->makeSound(); // 输出: 咪咪 喵喵喵！ (调用 Cat::makeSound)

    // 调用非虚函数 eat()
    animal1->eat(); // 输出: 旺财 正在吃东西。 (总是调用 Animal::eat)

    return 0;
}

animal1->makeSound() 和 animal2->makeSound() 调用的是不同的函数！
虽然指针类型是 Animal*，但由于 makeSound() 是虚函数，C++会在运行时根据指针实际指向的对象类型（Dog 或 Cat）来决定调用哪个版本。这就是动态多态（Dynamic Polymorphism）或运行时多态（Runtime Polymorphism）。
而 eat() 不是虚函数，所以总是调用基类 Animal 的版本。

继承的类型

单继承：一个派生类只有一个直接基类（如上面的例子）。
多继承：一个派生类有多个直接基类。

    深色版本

    class A {};
    class B {};
    class C : public A, public B {}; // C 同时继承 A 和 B

多继承功能强大但也更复杂，容易引发“菱形继承”等问题，需谨慎使用。

总结

继承是C++ OOP的核心机制，实现了代码复用和类层次结构。
通过 class Derived : [access] Base 语法实现。
public 继承最常用，表示“是一个”（is-a）关系。
派生类会继承基类的成员（除 private 外），可以添加新成员，也可以重写基类的虚函数。
构造/析构顺序：构造从基类到派生类，析构从派生类到基类。
protected 修饰符用于在继承链中共享访问。
虚函数和虚析构函数是实现多态的关键。
多态允许基类指针/引用调用派生类的特定实现，极大地提高了代码的灵活性和可扩展性。

继承、封装和多态共同构成了C++面向对象编程的基石，使我们能够构建模块化、可复用、易于维护的复杂软件系统。