一、为什么需要继承：重复代码的痛

先看没有继承时的现场。要写一个"学生"和一个"研究生"：

class Student {
private:
    char name[20];
    int  score;
public:
    void set(const char *n, int s) { /* ... */ }
    void show() const              { /* ... */ }
};

class GraduateStudent {              // 研究生也是学生
private:
    char name[20];                   // ← 抄了一遍
    int  score;                      // ← 抄了一遍
    char tutor[20];                  // 只有这一行是新的
public:
    void set(const char *n, int s) { /* ... */ }   // ← 又抄一遍
    void show() const              { /* ... */ }   // ← 又抄一遍
};

问题不在"多打了几行字"，而在于"改一处要改多处"：

继承要做的事：把 name、score、set、show 只写在"学生"里，然后说一句"研究生是一种学生，只是多了导师"。

二、语法：一行就够了

class 子类名 : 继承方式 父类名 {
    // 只写"自己特有的"成员
};

把上面的例子改写成继承：

class Student {                      // 父类：写"共同的"
protected:                           // ★ 不是 private，是为了让子类能用
    char name[20];
    int  score;
public:
    void set(const char *n, int s) { /* ... */ }
    void show() const              { /* ... */ }
};

class GraduateStudent : public Student {     // 子类：只写"不同的"
private:
    char tutor[20];                  // 研究生特有的：导师
public:
    void setTutor(const char *t) { /* ... */ }
};

注意 GraduateStudent 里没有 name、没有 score、没有 set()、没有 show()——但它全都有，都是从 Student 那里继承来的。

三、父子的三种叫法

报错信息里出现 base class、derived class，说的就是这两个角色。

这层关系的本质是一个"是"字（is-a）：

• 研究生 是 学生 ✅（所以可以继承）
• 汽车 是 交通工具 ✅
• 发动机 是 汽车 ❌（发动机是汽车的零件，不是"一种汽车"——那应该用"包含一个成员"，也就是 8.1.4 的嵌套搞法）

判据一句话：能不能说"子类 是 父类"？说得通就继承，说不通就别硬继承。这条判据能挡住一大半滥用继承的设计。

四、这一章的路线图

第十一章要过六道关，这是全书逻辑最密的一章：

五、动手 Demo：学生 → 研究生

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

class Student {
protected:                           // 10.1.1 的伏笔：留给子类用
    char name[20];
    int  score;

public:
    void set(const char *n, int s) {
        strcpy(name, n);
        score = s;
    }
    void show() const {
        cout << name << " 成绩 " << score;
    }
};

// ★ 关键一行：GraduateStudent 继承 Student
class GraduateStudent : public Student {
private:
    char tutor[20];                  // 研究生特有的

public:
    void setTutor(const char *t) { strcpy(tutor, t); }

    void showAll() const {
        show();                      // ← 直接调父类的 show()，不用写 Student::
        cout << "，导师 " << tutor << endl;
    }
};

int main() {
    Student s;
    s.set("小明", 90);
    s.show();
    cout << endl;

    GraduateStudent g;
    g.set("小红", 95);                // ← 用的是父类的 set()
    g.setTutor("王教授");
    g.showAll();

    cout << "sizeof(Student)         = " << sizeof(Student) << endl;
    cout << "sizeof(GraduateStudent) = " << sizeof(GraduateStudent) << endl;
    return 0;
}

看到什么算成功：

小明 成绩 90
小红 成绩 95，导师 王教授
sizeof(Student)         = 24
sizeof(GraduateStudent) = 44

读结果：

• g.set("小红", 95) 能跑——说明父类的公有函数被完整继承了。
• showAll() 里直接写 show() 能跑——说明子类内部调用父类函数不用加 Student::（加了也行，见 11.1.5）。
• 44 = 24 + 20——子类对象里先放父类那一份（24 字节），再放自己的（导师，20 字节）。这条规律很重要："子类对象里，父类那一部分永远排在最前面"。

30 秒实验：把父类的 protected: 改成 private:，重新编译。 - 结果：strcpy(name, n); 那一行报错 'char Student::name' is private within this context。 - 这说明了 protected 存在的唯一理由：它是"给子类留的门"（11.1.2 会把三档权限在继承下的变化讲成一张表）。

六、常见误区

1. "继承就是抄一份代码过来"——不是抄，是"真的拥有一份"。子类对象里确实存在父类的那部分数据（自成一个子对象），这也是为什么 sizeof 会相加、为什么构造/析构要按顺序跑（11.1.3）。
2. "只要两个类有相似点就该继承"——要看是不是"是"的关系。有相似点但说不成"是一种"的，应该用成员（把对方当零件装进来），而不是继承。继承是全书最强的一种耦合：改了父类，所有子类都受影响。
3. "子类能访问父类的一切"——不能。父类的 private 成员，子类永远碰不到（不论用哪种继承方式）。子类只能通过父类留下的 public / protected 接口去用它。
4. "父类和子类的成员函数重名就是重载"——不是。那是隐藏（11.1.5），规则和后果跟重载完全不同，是本章最容易翻车的地方之一。

• ☐ 11.1.1 类的继承（下一节）

相关笔记

• 类的继承 —— 下一节：语法细节与对象布局
• 面向对象的特点 —— 三大特点：继承是第二个
• 类概述 —— protected 当初就是为继承留的
• 结构体的嵌套 —— "装进来"和"是它"的区别
• 小结 —— 上一章知识地图
• 🔷 C++基础 · 索引 —— 全课路线图