C++ 继承（长文解析）

C++ 继承：让代码更优雅的基石

在 C++ 的面向对象编程世界里，C++ 继承 是构建可复用、可扩展程序结构的核心机制之一。它就像一栋建筑的楼层设计——底层是稳固的地基（基类），上层可以基于地基自由扩展功能（派生类）。这种设计不仅避免了重复代码，还让程序结构更清晰、维护更轻松。

如果你正在学习 C++，那么理解 C++ 继承 就如同掌握了“模块化开发”的钥匙。它让你从“写一遍又一遍”变成“定义一次，用无数次”。接下来，我们就一步步揭开它的面纱。

什么是 C++ 继承？

简单来说，C++ 继承是一种让一个类（派生类）“继承”另一个类（基类）的特性。被继承的类叫基类（Base Class），继承它的类叫派生类（Derived Class）。

想象一下：你有一个“动物”类，它有“吃”和“叫”两个行为。现在你想定义“狗”和“猫”，它们都属于动物，也都会“吃”和“叫”。如果每个类都重复写这些功能，代码就会变得冗长。而通过 C++ 继承，你只需要在“动物”类中定义一次，然后让“狗”和“猫”去继承它，就能自动拥有这些功能。

#include <iostream>
using namespace std;

// 基类：动物
class Animal {
public:
    // 公有成员函数：动物会吃
    void eat() {
        cout << "动物在吃东西..." << endl;
    }

    // 公有成员函数：动物会叫
    void speak() {
        cout << "动物在发出声音..." << endl;
    }
};

// 派生类：狗，继承自 Animal
class Dog : public Animal {
public:
    // 狗特有的行为：汪汪叫
    void bark() {
        cout << "汪汪！" << endl;
    }
};

// 派生类：猫，继承自 Animal
class Cat : public Animal {
public:
    // 猫特有的行为：喵喵叫
    void meow() {
        cout << "喵喵～" << endl;
    }
};

int main() {
    Dog myDog;
    Cat myCat;

    // 调用继承来的 eat() 和 speak()
    myDog.eat();     // 输出：动物在吃东西...
    myDog.speak();   // 输出：动物在发出声音...

    // 调用派生类特有的 bark()
    myDog.bark();    // 输出：汪汪！

    myCat.eat();     // 输出：动物在吃东西...
    myCat.speak();   // 输出：动物在发出声音...
    myCat.meow();    // 输出：喵喵～

    return 0;
}

代码说明：

• class Dog : public Animal 表示 Dog 类从 Animal 类继承，public 关键字表示继承方式为公有继承。
• 派生类自动拥有基类的所有公有成员（public members），包括函数和变量。
• myDog.bark() 是 Dog 类独有的方法，不能通过 Animal 调用。

继承的三种访问控制方式

在 C++ 中，继承有三种访问控制方式：public、protected 和 private。它们决定了基类成员在派生类中的可见性。

重要提示：默认继承方式是 private，所以建议显式写出 public，避免意外。

举个例子：

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

// 公有继承：保持访问权限
class DerivedPublic : public Base {
public:
    void show() {
        publicVar = 10;      // ✅ 可以访问
        protectedVar = 20;   // ✅ 可以访问
        // privateVar = 30;   // ❌ 编译错误，不可访问
    }
};

// 私有继承：基类所有成员都变为私有
class DerivedPrivate : private Base {
public:
    void show() {
        publicVar = 10;      // ❌ 编译错误，变成 private
        protectedVar = 20;   // ❌ 编译错误，变成 private
    }
};

理解比喻：

• public 继承就像“开放图书馆”——你继承了所有公开书籍，还能继续借阅。
• private 继承就像“内部档案室”——你虽然能用，但不能对外公开。

构造函数与析构函数的调用顺序

在 C++ 继承 中，构造函数和析构函数的调用顺序非常关键。

• 构造顺序：基类 → 派生类
• 析构顺序：派生类 → 基类

这是因为派生类的构造函数需要依赖基类的初始化完成才能继续。同样，析构时必须先清理派生类，再释放基类资源。

#include <iostream>
using namespace std;

class Parent {
public:
    Parent() {
        cout << "Parent 构造函数被调用" << endl;
    }

    ~Parent() {
        cout << "Parent 析构函数被调用" << endl;
    }
};

class Child : public Parent {
public:
    Child() {
        cout << "Child 构造函数被调用" << endl;
    }

    ~Child() {
        cout << "Child 析构函数被调用" << endl;
    }
};

int main() {
    Child c;
    return 0;
}

输出结果：

Parent 构造函数被调用
Child 构造函数被调用
Child 析构函数被调用
Parent 析构函数被调用

关键点：
即使你没在派生类中显式调用基类构造函数，编译器也会自动调用默认构造函数。如果基类没有默认构造函数，你必须在派生类构造函数中显式调用。

class Parent {
public:
    Parent(int x) {
        cout << "Parent 构造函数，参数 x = " << x << endl;
    }
};

class Child : public Parent {
public:
    Child() : Parent(100) {  // 显式调用基类构造函数
        cout << "Child 构造函数" << endl;
    }
};

虚函数与多态：C++ 继承的高级玩法

C++ 继承 最强大的地方，是它能和虚函数（virtual function）结合，实现“多态”——同一个接口，不同行为。

比如，你有一个 Shape 基类，它有一个虚函数 draw()。每个派生类（如 Circle、Rectangle）都可以重写这个函数，实现不同的绘图逻辑。

#include <iostream>
using namespace std;

// 抽象基类：形状
class Shape {
public:
    // 声明虚函数，支持多态
    virtual void draw() {
        cout << "绘制一个形状..." << endl;
    }

    // 虚析构函数，防止内存泄漏
    virtual ~Shape() {
        cout << "Shape 析构函数" << endl;
    }
};

// 派生类：圆形
class Circle : public Shape {
public:
    void draw() override {  // 重写基类虚函数
        cout << "绘制一个圆形" << endl;
    }

    ~Circle() {
        cout << "Circle 析构函数" << endl;
    }
};

// 派生类：矩形
class Rectangle : public Shape {
public:
    void draw() override {
        cout << "绘制一个矩形" << endl;
    }

    ~Rectangle() {
        cout << "Rectangle 析构函数" << endl;
    }
};

int main() {
    Shape* shapes[2];

    shapes[0] = new Circle();
    shapes[1] = new Rectangle();

    // 多态：通过基类指针调用不同派生类的 draw()
    for (int i = 0; i < 2; i++) {
        shapes[i]->draw();  // 实际调用的是 Circle::draw() 或 Rectangle::draw()
    }

    // 释放内存
    for (int i = 0; i < 2; i++) {
        delete shapes[i];
    }

    return 0;
}

输出结果：

绘制一个圆形
绘制一个矩形
Circle 析构函数
Rectangle 析构函数
Shape 析构函数
Shape 析构函数

代码说明：

• virtual 关键字让函数支持动态绑定。
• override 是 C++11 新特性，用于显式声明重写，提高代码可读性。
• 虚析构函数确保派生类的析构函数能被正确调用，防止资源泄漏。

实际应用场景：用户管理系统

我们来做一个真实的小项目：用户管理系统。使用 C++ 继承 实现不同类型的用户。

#include <iostream>
#include <string>
using namespace std;

// 基类：用户
class User {
protected:
    string name;
    int age;

public:
    User(string n, int a) : name(n), age(a) {}

    // 虚函数：显示用户信息
    virtual void display() {
        cout << "用户姓名：" << name << "，年龄：" << age << endl;
    }

    virtual ~User() {
        cout << "User 析构函数" << endl;
    }
};

// 派生类：普通用户
class NormalUser : public User {
public:
    NormalUser(string n, int a) : User(n, a) {}

    void display() override {
        cout << "普通用户：" << name << "，年龄：" << age << endl;
    }
};

// 派生类：管理员
class AdminUser : public User {
private:
    string level;

public:
    AdminUser(string n, int a, string l) : User(n, a), level(l) {}

    void display() override {
        cout << "管理员：" << name << "，年龄：" << age << "，权限等级：" << level << endl;
    }
};

int main() {
    User* users[] = {
        new NormalUser("小李", 25),
        new AdminUser("小王", 30, "高级")
    };

    for (int i = 0; i < 2; i++) {
        users[i]->display();  // 多态调用
    }

    for (int i = 0; i < 2; i++) {
        delete users[i];
    }

    return 0;
}

输出结果：

普通用户：小李，年龄：25
管理员：小王，年龄：30，权限等级：高级
User 析构函数
User 析构函数

设计价值：
你只需要维护一个 User* 数组，就可以统一处理所有用户类型。新增用户类型（如 VIPUser）时，只需继承 User 并重写 display()，无需修改原有逻辑。

总结：C++ 继承的核心优势

• 代码复用：避免重复定义相同功能。
• 扩展性强：新增功能只需在派生类中实现。
• 支持多态：实现“一个接口，多种行为”，是面向对象设计的精髓。
• 结构清晰：类与类之间的关系更符合现实世界建模。

掌握 C++ 继承，你不仅是在学语法，更是在培养一种“模块化思维”。它让你的代码从“能跑”变成“好维护、易扩展”。

记住：继承不是万能的。过度使用继承会导致类层次过深、耦合度高。建议优先使用“组合优于继承”原则。但当你要表达“是-一种”关系时（如“狗是动物”），C++ 继承 就是你的最佳选择。

现在，拿起你的编译器，动手写一个属于自己的继承结构吧！