一、本章知识地图

二、必须记住的十个结论

1. 默认用 vector。90% 的场合它都是最好的选择（连续内存、缓存友好、能随机访问）。只有明确知道"瓶颈在中间插删"或"两头进出"时才换。
2. 选容器问一句话："我的数据主要在哪一端动？" —— 尾 → vector；两头 → deque；中间 → list；按值找 → set / map。
3. erase-remove 惯用法必须背下来：v.erase(remove(v.begin(), v.end(), x), v.end()); —— 因为 remove 不删元素，只把要留的挪到前面，返回新的逻辑末尾。 unique 也是同一个脾气（还要先 sort）。
4. map 的 m[k] 会"偷偷插入"。只想查询必须用 find（或 at，它会抛异常）。写 if (m[k] != 0) 是错的——每次判断都会往容器里塞一个。
5. set / map 的元素"键"不能改（是排序依据，const）。要改就 erase + insert。
6. 算法的调用姿势是"一对迭代器 + 额外参数"，区间左闭右开 [first, last)。算法不认识容器 —— 所以 sort(arr, arr+n) 对裸数组也能用。代价：算法改不了容器大小（要扩容就用插入迭代器）。
7. "迭代器等级"决定"能用的算法"：sort / binary_search / random_shuffle 要随机访问（list / set / map 用不了）；reverse 要双向；find / count 只要输入迭代器（哪都能用）。
8. accumulate 的初值类型就是结果类型（在 <numeric>）。要浮点结果，初值写 0.0（初值 0 会让每一步都截断）。
9. sort 的比较规则必须"严格弱序"：写 < 或 >，绝不能写 <= / >=（会造成越界、崩溃或结果错乱）。同样适用于 set 的比较器和所有 _if 条件。
10. "会用"占 90%，"会写"占 10%。现实里写代码：vector + sort + find + map 就能解决绝大多数问题。 自己写容器/算法是"造工具箱"的活（第十二章说的"学习顺序：会用 → 会定制 → 会写"）。

三、动手 Demo：两关自测

第一关（写代码）：一个"班级成绩管理"

要求：只用本章的东西，做出一个能跑的小系统。

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

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <numeric>
using namespace std;

struct Student {
    string name;
    int    score;
    Student(const string &n, int s) : name(n), score(s) {}
};

void line(const char *t) { cout << "── " << t << " ──" << endl; }

int main() {
    vector<Student> cls = {
        Student("小明", 88), Student("小红", 95), Student("小刚", 71),
        Student("小丽", 88), Student("小强", 100), Student("小敏", 55)
    };

    // ① 原始名单
    line("原始名单");
    for (const Student &s : cls) cout << s.name << "(" << s.score << ") ";
    cout << endl;

    // ② 排名（分数降序，同分按名字）
    vector<Student> rank = cls;
    sort(rank.begin(), rank.end(), [](const Student &a, const Student &b) {
        if (a.score != b.score) return a.score > b.score;
        return a.name < b.name;
    });
    line("排行榜");
    int no = 1;
    for (const Student &s : rank) cout << no++ << ". " << s.name << "(" << s.score << ") ";
    cout << endl;

    // ③ 总分 / 平均（★ 初值 0.0）
    double total = accumulate(cls.begin(), cls.end(), 0.0,
                              [](double acc, const Student &s) { return acc + s.score; });
    cout << "总分 " << total << "，平均 " << total / cls.size() << endl;

    // ④ 最高最低
    auto hi = max_element(cls.begin(), cls.end(),
                          [](const Student &a, const Student &b) { return a.score < b.score; });
    auto lo = min_element(cls.begin(), cls.end(),
                          [](const Student &a, const Student &b) { return a.score < b.score; });
    cout << "最高 " << hi->name << "(" << hi->score << ")，"
         << "最低 " << lo->name << "(" << lo->score << ")" << endl;

    // ⑤ 分数档次（set 自动去重排序）
    set<int> levels;
    for (const Student &s : cls) levels.insert(s.score);
    cout << "出现过的分数档次（去重+排序）：";
    for (int x : levels) cout << x << " ";
    cout << endl;

    // ⑥ 分数段人数（count_if）
    line("分数段");
    int seg[5] = {0};
    const char *names[] = {"90+", "80-89", "70-79", "60-69", "<60"};
    for (const Student &s : cls) {
        if (s.score >= 90) seg[0]++;
        else if (s.score >= 80) seg[1]++;
        else if (s.score >= 70) seg[2]++;
        else if (s.score >= 60) seg[3]++;
        else seg[4]++;
    }
    for (int i = 0; i < 5; i++) cout << names[i] << ": " << seg[i] << " 人  ";
    cout << endl;

    // ⑦ 按名字查成绩（map：O(log n)）
    map<string, int> lookup;
    for (const Student &s : cls) lookup[s.name] = s.score;
    line("按名字查");
    for (const string &who : {"小红", "小强", "不存在"}) {
        auto it = lookup.find(who);                    // ★ 必须用 find（不能用 []）
        if (it != lookup.end()) cout << who << " 的成绩是 " << it->second << endl;
        else                    cout << who << "：查无此人" << endl;
    }

    // ⑧ 删掉不及格的（erase-remove 惯用法）
    cls.erase(remove_if(cls.begin(), cls.end(),
                        [](const Student &s) { return s.score < 60; }), cls.end());
    line("删掉不及格后");
    for (const Student &s : cls) cout << s.name << "(" << s.score << ") ";
    cout << "  共 " << cls.size() << " 人" << endl;
    return 0;
}

看到什么算成功：

── 原始名单 ──
小明(88) 小红(95) 小刚(71) 小丽(88) 小强(100) 小敏(55) 
── 排行榜 ──
1. 小强(100) 2. 小红(95) 3. 小明(88) 4. 小丽(88) 5. 小刚(71) 6. 小敏(55) 
总分 497，平均 82.8333
最高 小强(100)，最低 小敏(55)
出现过的分数档次（去重+排序）：55 71 88 95 100 
── 分数段 ──
90+: 2 人  80-89: 2 人  70-79: 1 人  60-69: 0 人  <60: 1 人  
── 按名字查 ──
小红 的成绩是 95
小强 的成绩是 100
不存在：查无此人
── 删掉不及格后 ──
小明(88) 小红(95) 小刚(71) 小丽(88) 小强(100)   共 5 人

这一关用到了整章的每一条主线。如果 ⑧ 那句 erase(remove_if(...), end()) 你能默写出来，说明这一章最"要命"的那个惯用法已经进肌肉了。

加分实验：

1. 把 ③ 的初值从 0.0 改成 0 → 平均变成 82（整数除法）。亲眼确认一次"初值类型"这件事。
2. 把 ⑦ 的 find 改成 lookup[who] → "不存在"那个会输出 0，而且 lookup.size() 多了一个。map::operator[] 的坑。
3. 把 ⑤ 的 set 改成 vector + sort + unique → 结果一样，体会"两种去重手段"（set 保持有序；sort+unique 一次性开销）。
4. 把 vector<Student> 换成 list<Student> → sort 那句编译不过，得改成 cls.sort(比较器)，而且 cls.erase(remove_if(...)) 那套也要换成 cls.remove_if(...)。这就是 13.4.5 讲的"等级"的真实代价。

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

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

• 重点看 ⑧：它不报错，只是结果错 —— 所以"数值计算一定要跑一遍看结果"，这一条比记住语法更重要。
• 第 ③ 条要单独记：它不是"编译错误"，而是"隐患"（空容器 + <= size()-1）。这一条在真实项目里制造过无数 bug。

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

1. "我自己写循环也行，何必用算法"——行，但更容易错。remove / unique / accumulate 这些"看起来简单"的循环里藏着不少坑（初值类型、越界、单遍）。算法是"被无数人检视过的循环"。
2. "STL 慢"——恰恰相反：sort 是精心调优的混合排序、vector 的扩容是摊还 O(1)、二分查找是 O(log n)。 慢通常是因为"选错了容器/算法"，而不是"用了 STL"。
3. "vector 一定要用，list 是过时的东西"——不是过时，是专用。"已知位置频繁插删"的场景 list 是不可替代的（还有 splice 这种独门技能）。只是这类场景比想象中少。
4. "关联式容器比序列容器高级"——只是用法不同：按位置操作 → 序列；按值查找 → 关联。 vector 按下标遍历比 map 快得多（缓存友好）。
5. "算法和成员函数哪个好，随便"——要看名字后面的东西：list::remove 真删、std::remove 不删；list::sort 能用、std::sort 不能用；set::find 是 O(log n)、std::find 是 O(n)。"同名不同行为"是 STL 里最需要小心的一类陷阱。
6. "迭代器就是指针，一样用"——接口像，能力差很远。能不能 --、能不能 +n、能不能比大小，决定了它能用哪些算法（这是本章最主要的一句话）。
7. "模板报错太难懂，STL 没法用"——报错长是因为模板层层展开。技巧：先看"你写的哪一行"，再看"报错里有没有 no match for / is not a member of"，最后看"最后一条 note"（12.4 小结说的）。本章那些"❌"的例子，报错脸都认一认，以后看到就知道是哪一类问题。
8. "学了 STL 就不用懂数据结构了"——反过来：不知道"链表不能随机访问"，就不明白 list 为什么没有 []；不知道"哈希 vs 树"，就选不出 map 还是 unordered_map。 STL 是"数据结构的成品"，但你得知道每个成品适合什么场合。

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

这一章之后，你的代码"上一档次"了 ——因为你不再写那些"和业务无关、却必须写对"的样板代码：

• 不用再写"数组够不够大"（vector / deque / list 自己长）；
• 不用再写"排序"（sort + lambda）；
• 不用再手写"找一个值"（find / map / set）；
• 不用再手写"删掉所有符合条件的"（erase + remove_if）；
• 不用再手写"求和求平均求最大"（accumulate / max_element）；
• 不用再手写"去重、分组、打乱"（set / partition / shuffle）；
• 不用再手写"读一串数据存起来"（istream_iterator）；
• 能看懂标准库里那些吓人的类型名：std::vector<int, std::allocator<int>> —— 知道多出来的都是默认参数（12.2.3）。

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

• ☑ 第十四章 RTTI与异常处理 —— 已完结：小结（RTTI 三件套 ＋ 四种转换运算符 ＋ 异常三关键字 ＋ 栈展开与 std::exception 家族）

相关笔记

• 序列容器 —— 本章起点：三个"按位置排队"的盒子
• 向量类模板（含实例01） —— 默认选择 vector
• 链表类模板 —— 三兄弟对比的收尾
• set类模板（含实例02） —— 去重 + 排序
• map类模板 —— 最常用的关联式容器
• 修正序列算法（含实例05、06） —— erase-remove 惯用法
• 排序算法（含实例07） —— sort 与二分查找
• 数值算法（含实例08） —— accumulate 初值的坑
• 随机访问迭代器 —— 五级阶梯的顶端（"能不能 sort"的答案）
• 小结 —— 上一章知识地图："把类型变成参数"
• RTTI —— 下一章起点：运行期问类型
• 小结 —— 下一章知识地图：RTTI 与异常处理
• 🔷 C++基础 · 索引 —— 全课路线图