一、本章知识地图

二、必须记住的十个结论

1. RTTI 的前提是"多态类型" ——类里至少有一个虚函数（信息挂在 vtable 上）。基类没有虚函数时，typeid 悄悄给你静态类型，不报错 ——这是最会骗人的一条。
2. 判断类型用 typeid(a) == typeid(b)，永远不要用 name() ——name() 的输出是"实现定义"的（g++/MinGW 给 7Printer 这种修饰名，MSVC 给 class Printer）。
3. dynamic_cast 的两种失败方式：指针版给 nullptr（就地判断），引用版抛 bad_cast（必须 try/catch）。 用哪个看"转不过去算不算错"。
4. 多重继承下"一个对象好几个地址"：(void *)pa == (void *)pb 会说"不相等" → 判断"是不是同一个对象"要用 dynamic_cast<void *>；而"交叉转换"（Flyer * → Swimmer *）只有 dynamic_cast 能做。
5. 四把转换扳手各管一件事，C 风格强转必须淘汰：static_cast（数值/继承，不检查）、dynamic_cast（安全继承，要检查）、const_cast（只动 const）、reinterpret_cast（按比特，最危险）。 能隐式转换就别写转换。
6. 异常最值钱的不是"能报错"，而是"栈展开" ——异常往上飞时，沿途每层的局部对象都会被正确析构（后构造先析构） ——这就是"把资源交给对象管"能成立的地基。
7. 异常不当控制流用：不抛时几乎零开销（零成本异常模型），抛出并处理非常贵。 判据："这件事多久发生一次 + 本层能不能处理"。 用户输错密码不是异常，内存不够才是。
8. 两个雷区：① 析构函数里别抛异常（栈展开途中再抛 → 两个异常同时在飞 → terminate；C++11 起析构默认 noexcept）；② 构造函数抛异常时，这个对象的析构函数不会被调用（所以要么把资源交给成员对象管，要么自己在 throw 前先释放）。
9. catch 的三条铁律：一律 const T & 捕获（按值切片）；顺序"从最具体到最笼统"（先到先得，基类写在前面会截胡）；catch (...) 只能放最后。 外加一条分寸：捕不了就别捕，空 catch 是"错误黑洞"。
10. 异常匹配比"能隐式转换"严得多：只允许 精确 / cv 限定 / 派生→基类 / 指针标准转换。throw 3 接不进 catch(double)（算术转换）、throw "abc" 接不进 catch(string)（用户定义转换） ——这类错编译期不报，运行期直接 terminate。

三、动手 Demo：两关自测

第一关（写代码）：一个"形状仓库"

要求：只用本章（＋前面课程）的东西，做出一个能跑的小系统。

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

#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
#include <typeinfo>
using namespace std;

// ── 异常家族：从 runtime_error 派生，带错误码 ──
class ShapeError : public runtime_error {
public:
    ShapeError(const string &msg, int code) : runtime_error(msg), code_(code) {}
    int code() const { return code_; }
private:
    int code_;
};

// ── 形状家族 ──────────────────────────────────
class Shape {
public:
    virtual ~Shape() {}
    virtual double area() const = 0;             // 抽象类（11.5）
    virtual string name() const = 0;
};

class Rect : public Shape {
public:
    Rect(double w, double h) : w_(w), h_(h) {
        if (w <= 0 || h <= 0) throw ShapeError("矩形的边长必须为正", 1001);
    }
    double area() const { return w_ * h_; }
    string name() const { return "矩形"; }
    void stretch(double f) { w_ *= f; }          // 矩形独有
private:
    double w_, h_;
};

class Circle : public Shape {
public:
    Circle(double r) : r_(r) {
        if (r <= 0) throw ShapeError("半径必须为正", 1002);
    }
    double area() const { return 3.14159265 * r_ * r_; }
    string name() const { return "圆"; }
private:
    double r_;
};

int main() {
    vector<Shape *> shapes;

    // ① 建造：成功的留下，失败的记一笔（异常安全的写法）
    const string kinds[5]   = {"rect", "circle", "rect", "circle", "rect"};
    double       params[5][2] = {{3, 4}, {2, 0}, {-1, 5}, {-2, 0}, {5, 5}};

    for (int i = 0; i < 5; i++) {
        try {
            if (kinds[i] == "rect") shapes.push_back(new Rect(params[i][0], params[i][1]));
            else                    shapes.push_back(new Circle(params[i][0]));
        } catch (const ShapeError &e) {
            cout << "第 " << i << " 个建不出来：" << e.what()
                 << "（错误码 " << e.code() << "）" << endl;
        }
    }

    // ② 统一报告（虚函数：多态的正路）
    cout << "-- 已有 " << shapes.size() << " 个形状 --" << endl;
    double total = 0;
    for (size_t i = 0; i < shapes.size(); i++) {
        double a = shapes[i]->area();
        cout << "  " << shapes[i]->name() << " 面积 " << a << endl;
        total += a;
    }
    cout << "总面积 " << total << endl;

    // ③ RTTI：把矩形挑出来单独"拉长"（探测能力）
    for (size_t i = 0; i < shapes.size(); i++) {
        if (Rect *r = dynamic_cast<Rect *>(shapes[i])) {
            r->stretch(2);
            cout << "第 " << i << " 个是矩形，拉长后面积 " << r->area() << endl;
        }
    }

    // ④ 分类统计（typeid 只读，不改任何东西）
    int nRect = 0, nCircle = 0;
    for (size_t i = 0; i < shapes.size(); i++) {
        if      (typeid(*shapes[i]) == typeid(Rect))   nRect++;
        else if (typeid(*shapes[i]) == typeid(Circle)) nCircle++;
    }
    cout << "统计：矩形 " << nRect << " 个，圆 " << nCircle << " 个" << endl;

    // ⑤ 统一兜底 + 用 dynamic_cast 取回具体信息
    try {
        throw ShapeError("测试用的错误", 9999);
    } catch (const exception &e) {
        cout << "兜底：" << e.what();
        if (const ShapeError *se = dynamic_cast<const ShapeError *>(&e))
            cout << "（码 " << se->code() << "）";
        cout << endl;
    }

    for (size_t i = 0; i < shapes.size(); i++) delete shapes[i];
    return 0;
}

看到什么算成功：

第 2 个建不出来：矩形的边长必须为正（错误码 1001）
第 3 个建不出来：半径必须为正（错误码 1002）
-- 已有 3 个形状 --
  矩形 面积 12
  圆 面积 12.5664
  矩形 面积 25
总面积 49.5664
第 0 个是矩形，拉长后面积 24
第 2 个是矩形，拉长后面积 50
统计：矩形 2 个，圆 1 个
兜底：测试用的错误（码 9999）

这一关把整章串成了一条线：构造失败用异常报（14.2.1）→ 统一行为用虚函数（11.4）→ 个别类型特殊处理用 dynamic_cast（14.1.1）→ 统计用 typeid（14.1.1）→ 兜底 + 取回信息用 catch(exception&) + dynamic_cast（14.2.4 / 14.1.4）。

加分实验：

1. 把 ④ 的 typeid 判断改成一个"虚函数 isRect()" → 发现代码变干净了。这就是"能用虚函数就别用 RTTI"。
2. 把 ① 里的 new 换成"先建局部对象再 push_back 副本" → 要重新考虑 vector<Shape> 的切片问题（11.4.2：多态必须走指针/引用）。
3. 让 Rect 的构造函数"先 new 一块内存，再抛异常"，并且故意不释放 → 看不出任何异常（安静的泄漏）。再加一个"用 vector<int> 成员管这块内存"的版本对照 ——去看 14.2.1 的第①条出路。
4. 把 main 整个包一层 catch (const exception &e) { cerr << e.what(); } → 体会"最外层兜底"的写法（防止程序裸死）。

第二关（找错）：十个判断，逐个说明对错与原因

30 秒实验：把 ① ② ⑦ ⑧ ⑨ ⑪ 逐个在编译器里敲一遍，认一下每种报错（或崩溃、或 terminate）的样子。

• 重点看 ① 和 ⑪：它们"不报错、安静地错" ——① 输出错的类型，⑪ 直接 terminate。 "跑一遍看结果"比"记住规则"更重要。
• 重点看 ⑧：它连提示都没有（泄漏是看不见的）。所以"资源交给对象管"不是风格问题，是正确性问题。

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

1. "有了 RTTI，就可以到处用 typeid 分支了" ——那是在用"运行期开关"替代"多态"，加一个子类就要回来改调度代码（违背 9.2.3 的判据）。RTTI 的正当用途：调试打印、接口探测、无法修改第三方类时的分类处理。
2. "异常是现代 C++ 的标配，什么都该抛" ——异常是给"罕见且本层处理不了"的事用的。 用户输错密码、查到末尾、查找失败都是正常分支（用返回值/状态位）。"什么都抛"和"什么都不抛"一样糟。
3. "到处 try/catch 显得稳妥" ——捕不了就别捕；空 catch 是把 bug 藏起来。 正确的分层是：能在哪儿处理，才在哪儿捕。
4. "noexcept 只是个优化提示，写了没坏处" ——它是"承诺"：异常一旦逃出去就 terminate（外层 catch 都救不了）。拿不准就别写。
5. "what() 的字符串可以拿来判断错误类型" ——它是给人看的、实现定义的。要分类就 catch 类型；要字段就自己写异常类加成员。
6. "RTTI 和异常开销大，所以都别用" ——都在小得可以忽略的量级上（正常路径上异常几乎零开销；RTTI 只是一次查表）。它们真正的代价在"设计"上：用得不当会让代码越来越难改。 该用时不用，是另一种损失。
7. "dynamic_cast 慢，能不用就不用" ——回一句：那你是打算用 static_cast 撞运气，还是用 reinterpret_cast 撞大运？ 在"探测"场合，dynamic_cast 是唯一"错了有兜底"的方案。 性能焦虑要花在热点路径上，不是花在"初次写对"上。
8. "教材学到异常了，说明异常很重要，我要在项目里大量用" ——恰恰相反：在真正的工程代码里，异常的正确用法是"少而准" ——在少数几个地方抛，在少数几个地方接，中间层完全不管。 "异常用得越少越清楚"，这是老手的经验。

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

这一章之后，你的代码"敢出错"了：

• 不再写"每个调用点都检查返回值"的样板代码（异常会自己找到该处理它的地方）；
• 能设计"带信息的错误类型"（从 runtime_error 派生 + 自己的字段）；
• 知道"资源该交给谁管"（析构函数 + 栈展开）；
• 能安全地在继承体系里"探明身份"（dynamic_cast 而不是硬转）；
• 知道四种转换各该用在哪（不再写 (Dog *)p）；
• 能一眼看出"这个 catch 永远不会执行"（顺序问题）；
• 知道"哪些地方根本不抛异常"（v[i]、atoi、流），不会想当然。

同时拿到三张能一直用的"判断表"：

• ☑ 第十五章 文件操作 —— 已完结：小结（流 ＋ 文件：五步走 / 打开方式 / 文本与二进制 / 随机访问）

相关笔记

• RTTI —— 本章起点：运行期问类型
• RTTI转换语法（四种扳手） —— 转换的总收
• 异常处理 —— 本章另一半：try / throw / catch 与栈展开
• 抛出异常（两个雷区） —— 构造与析构的旧账在此结清
• 异常匹配（匹配规则） —— 最容易被忽略的一张表
• 标准异常 —— std::exception 家族与自定义异常
• 虚函数概述 —— 多态（本章"首选"的那条路）
• 析构函数 —— 栈展开要调的就是它
• 小结 —— 上一章知识地图（STL 三件套）
• 流简介 —— 下一章起点：文件只是一条流
• 小结 —— 下一章知识地图（流 ＋ 文件）
• 🔷 C++基础 · 索引 —— 全课路线图