一、本章知识地图

二、必须记住的八个结论

1. class 子 : 父（不写继承方式）就是 private 继承——父类的 public 成员在子类里全被降级成 private，外界访问不到，而代码看起来"明明写了继承"。每次写继承，第一件事就是把 public 补上（11.1.1、11.1.2）。
2. 构造"先父后子"，析构"先子后父"；完整顺序：父类 → 成员（按声明顺序）→ 自己的函数体；决定顺序的是"声明顺序"，不是初始化列表的书写顺序（11.1.3、11.3.3）。
3. 初始化列表是"给父类和成员传参"的唯一场所——因为它们在函数体开始之前就构造完了。函数体里写 Base(n); 只是造了个临时对象（11.1.4）。
4. 子类同名函数"隐藏"父类的全部同名版本（跟参数是否相同无关）。解药：using Base::f;（一次引入全部）或 Base::f(参数)（指名调用）。隐藏是编译期的事，和 virtual 无关（11.1.5）。
5. 运算符重载买的是"可读性"：a * b + c 而不是 add(mul(a,b),c)。规则三条：不能发明新符号、不能改优先级/结合性、至少一个操作数是自定义类型。返回值：改自己 → T&；产生新值 → T（11.2 组）。
6. virtual + 指针/引用 + 签名一致 = 动态绑定（多态）。差一个 const 就退化成隐藏 → 写 override 让编译器帮你抓错；基类析构必须 virtual，否则父类指针 delete 时子类析构不执行（内存泄漏）（11.4.1）。
7. 多态必须走"指针或引用"。用父类对象去接子类对象会发生对象切片——多出来的成员被切掉，多态也随之消失（11.4.2）。
8. 菱形继承（A→B/C→D）会产生两份祖先数据，且"只改一份"会造成静默的错误。正规解药是虚继承，但最好的解药是重新设计——能不改结构就不改，多重继承要慎用（11.3.2、11.4.3）。

三、动手 Demo：两关自测

第一关（写代码）：一个能扩展的"形状库"

要求：用本章的东西搭一套形状体系。

参考实现（自己先写，写不出来再看）：

#include <iostream>
using namespace std;

// ───────── 抽象基类：只定契约 ─────────
class Shape {
public:
    virtual double      area() const = 0;      // 纯虚：子类必须实现
    virtual const char *name() const = 0;      // 纯虚
    virtual void        show() const {         // 普通虚函数：框架写在父类
        cout << name() << " 的面积 = " << area() << endl;
    }
    virtual ~Shape() { }                       // ★ 铁律：有虚函数就要虚析构
};

// ───────── 圆 ─────────
class Circle : public Shape {
private:
    double r;
public:
    Circle(double radius) : r(radius) { }
    double      area() const { return 3.14159 * r * r; }
    const char *name() const { return "圆"; }
};

// ───────── 矩形（正方形会继承它） ─────────
class Rect : public Shape {
protected:
    double w, h;                               // 留给子类用（11.1.2）
public:
    Rect(double width, double height) : w(width), h(height) { }
    double      area() const { return w * h; }
    const char *name() const { return "矩形"; }
};

// ───────── 正方形：借 Rect 的实现，只改名字 ─────────
class Square : public Rect {
public:
    Square(double s) : Rect(s, s) { }          // ★ 显式调用父类构造（11.1.4）
    const char *name() const { return "正方形"; }   // ★ 只需要重写 name
};

int main() {
    Shape *list[3];                            // 父类指针数组（11.4.2）
    list[0] = new Circle(1);
    list[1] = new Rect(3, 4);
    list[2] = new Square(2);

    double total = 0;
    for (int i = 0; i < 3; i++) {
        list[i]->show();                       // 同一句话，各显神通
        total += list[i]->area();
    }
    cout << "总面积 = " << total << endl;

    for (int i = 0; i < 3; i++) delete list[i];   // 虚析构保证正确释放
    return 0;
}

看到什么算成功：

圆 的面积 = 3.14159
矩形 的面积 = 12
正方形 的面积 = 4
总面积 = 19.1416

读结果：

• Square 只写了 3 行（构造函数 + 一个 name）——面积、show 全部白拿。这就是继承（11.1）+ 多态（11.4）+ 抽象类（11.5）三合一的效果。
• main 里的循环完全不认识"正方形"这个类型——它只认 Shape*。这就是"可扩展"。

如果这一关你能独立写出来：说明本章五大块（继承语法、权限、构造顺序、虚函数、抽象类）你已经能连起来用了。

加分实验（两个小实验，各验证一条规则）：

实验一：抽象类连"切片"都不让你做

Shape sliced = *(list[1]);     // ★ 试图用父类对象去接

→ 编译错：cannot declare variable 'sliced' to be of abstract type 'Shape'。

有意思的地方在这里：11.4.2 里那个 Shape（area 有"保底实现"、返回 0）能编译出切片，只是结果不对；改成纯虚之后，编译器直接把这条路堵死了。"抽象类不能创建对象"这条规则，顺手帮你挡掉了一类错误。

实验二：加一种新形状，看要改多少代码

照着 Circle 的样子，自己加一个 Triangle（三条边 a、b、c，面积用海伦公式 √(s(s-a)(s-b)(s-c))，需要 #include <cmath>）。

加完之后回头数一数：你在 main 里改了几行？

• 只加了 list[3] = new Triangle(...); 和把数组大小从 3 改成 4。
• Shape 一行没改、show() 一行没改、Circle/Rect/Square 一行没改。
• 这就是虚函数买来的"可扩展"（11.4.2）——也是这一章最值钱的一句话。

第二关（找错）：下面这段代码有八处问题

class Base {
public:
    int  id;                                                  // ①
    Base(int i) : id(i) { }
    void show() { cout << "Base " << id << endl; }            // ②
    ~Base() { }                                               // ③
};

class Derived : private Base {                                // ④
public:
    int id;                                                   // ⑤
    Derived() { }                                             // ⑥
    void show() { cout << "Derived " << id << endl; }         // ⑦
};

int main() {
    Derived d;
    Base *p = &d;                                             // ⑧
    delete p;
    return 0;
}

答案：

30 秒实验：把这八处逐条改对，改一处、编一次。特别留意：

• 改 ④ 之前，⑧ 报的是 'Base' is an inaccessible base of 'Derived'——这个错和"访问权限"有关，不是"类型不匹配"，很多人第一眼看不懂。
• 改 ⑥ 的时候，你会看到 candidate expects 1 argument, 0 provided——编译器直接告诉你父类需要几个参数。
• 改 ② 之后，把 Derived::show 加上 override：编译通过；再把它的 const 加一个上去 → 立刻报错 does not override——这就是 override 的价值（11.4.1）。

四、常见误区（本章汇总）

1. "继承就是把父类的代码抄一份"——不是抄，是"真的拥有一份"：子类对象里存在父类的子对象、sizeof 相加、构造/析构按顺序跑、private 成员也在里面（只是碰不到）（11.1、11.1.1）。
2. "不写继承方式就是 public"——class 默认 private、struct 默认 public。这是"代码看起来对、却报 inaccessible"的头号原因（11.1.1、11.1.2）。
3. "子类写同名函数就是重载/重写"——父子之间叫"隐藏"（编译期按类型找名字）。参数不同也照藏。加了 virtual 且签名一致，才是"重写"（运行期按对象身份）（11.1.5、11.4.1）。
4. "运算符重载越多越好"——只重载"符号含义天然贴切"的那些。Person + Person 这种"说不清语义"的，写注释解释的时候就已经错了（11.2.1）。
5. "多重继承很强大，能多用就多用"——恰恰相反：每一次多重继承都要问"会不会形成菱形"。能改成"组合（把对象作为成员）"就别继承；必须用时，优先保证多个父类毫无关系（11.3）。
6. "virtual 只要写在子类上就行"——必须从父类这一层开始虚。父类不虚、子类写 virtual，多态不成立（11.4 的实验）。反过来（父类虚、子类不写）是没问题的——虚性会遗传。
7. "用父类对象接子类对象也能多态"——会切片。多态必须走指针或引用（11.4.2）。
8. "抽象类只是'不能创建对象'的类，没什么用"——它的用处正是"不能创建对象"：它保证"凡是这个类型的对象，都一定会 area()"——这是用父类指针统一处理一批对象的底气（11.5）。

五、写完这一章，你会什么了

这一章之后，你的"类"不再是孤立的零件，而是一族可以互相替换的零件。 具体来说，你已经能：

• 把重复代码提到父类，子类只写"不一样的地方"（11.1）。
• 说清"哪些成员能被谁看见"——三档权限 × 三种继承方式，一张表全通（11.1.2）。
• 预测对象的一生：什么时候调谁的构造、什么时候析构、按什么顺序（11.1.3、11.3.3）。
• 让自己造的类型写起来像内置类型（11.2 组）。
• 写出"加新类型不用改老代码"的结构（11.4.2——这是本章最有价值的一项能力）。
• 用抽象类把"必须有什么"和"怎么做"分开（11.5）。

同时拿到三条能一直用的工程习惯：

• ☑ 第十二章 模板 —— 已完结：小结（把类型也变成参数：函数模板、类模板、默认模板参数、有界数组、特化定制）

相关笔记

• 继承 —— 本章起点：为什么要继承
• 重载运算符 —— 让自定义类型也能用符号
• 二义性 —— 本章最容易翻车的地方之一
• 虚函数概述 —— 本章的核心：virtual 与虚析构
• 虚继承（含实例07） —— virtual 的第二个用途
• 抽象类（含实例08） —— 纯虚函数与接口
• 小结 —— 上一章知识地图："怎么造一个类"
• 小结 —— 三大特点的第一次亮相
• 函数模板 —— 下一章起点：把类型变成参数
• 小结 —— 下一章知识地图：编译期多态与"通用模板也会办错事"
• 🔷 C++基础 · 索引 —— 全课路线图