一、本章知识地图

二、必须记住的八个结论

1. 模板是"图纸"，不是"房子"。写一份 template <typename T> T f(T, T)，用了 int、double、char 三种类型，最终会编出三个真函数。这个"照图纸造东西"的动作叫实例化，发生在编译期——所以模板是编译期多态（和 11.4 的运行期多态并列）。
2. typename 和 class 在模板参数里完全等价；T 的作用域只到紧跟的那个定义为止（所以每个类外成员函数都要重写模板头）。模板推导阶段不做类型转换 → f(3, 4.5) 报 deduced conflicting types，要显式写 f<double>(3, 4.5)。
3. 模板的定义（含类模板的全部成员函数）必须写在头文件里。拆成 .h 声明 + .cpp 实现 → 链接期 undefined reference to 'int f<int>(int, int)'。原因：编译器在实例化点必须看到定义。（这也是 10.4.2 内联成员函数 的同款例外。）
4. 类模板不是类型：Stack s; ✗，必须 Stack<int> s;（即使所有模板参数都有默认值，也要写 Stack<> s;——那对尖括号省不掉）。Stack<int> 与 Stack<double> 是两个毫不相干的类：静态成员各一份、不能互相赋值、函数重载算两个。
5. 类模板的成员函数在类外定义时，三处不能漏：① 前面写 template <typename T>；② 类名写 Point<T>::；③ 返回类型要在模板头之后。构造函数记成":: 前带 <T>、:: 后不带"。
6. 默认模板参数从右往左连续给，同一作用域只给一次。类模板写 Box<> 可以省实参，但省不掉尖括号。函数模板的默认模板参数不能用于推导（f() 是错的），所以这个特性主要是给类模板用的。
7. 通用模板只保证"能编译"，不保证"结果对"。它在指针 / const char * / 需要深拷贝的类型上都会办错事。解法是定制（特化）：整个类都换 → 全特化（template <> class Stack<X> { ... };）；只换一个成员 → 成员特化（template <> void Stack<X>::push(...) { }）。两者都要求"具体类型一字不差"（const char * ≠ char *，写错会悄悄退回通用版）。
8. 能"用"就别"写"。现实里 90% 的模板是拿来用的（vector<int>、sort、string）；自己写模板是"造工具箱"的活；特化是"工具箱某处不合适"的应急补丁。学习顺序：会用 → 会定制 → 会写。

三、动手 Demo：两关自测

第一关（写代码）：一个"通用小工具箱"

要求：用本章的东西，做一个能统计任意类型、任意长度数据的工具。

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

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

// ① 函数模板
template <typename T>
T myMax(T a, T b) { return a > b ? a : b; }

// ② 类模板（带默认模板参数）
template <typename T = int, int size = 10>
class Stats {
private:
    T   data[size];
    int n;

public:
    Stats() : n(0) {
        for (int i = 0; i < size; i++) data[i] = T();     // ★ T 的零值
    }

    // ★ 带边界保护的写入
    bool add(T v) {
        if (n >= size) {
            cout << "！已满（" << size << " 个），" << v << " 没能进来" << endl;
            return false;
        }
        data[n++] = v;
        return true;
    }

    int count() const { return n; }
    int capacity() const { return size; }

    T maxValue() const {
        T m = data[0];
        for (int i = 1; i < n; i++) if (data[i] > m) m = data[i];
        return m;
    }

    T minValue() const {
        T m = data[0];
        for (int i = 1; i < n; i++) if (data[i] < m) m = data[i];
        return m;
    }

    T sum() const {
        T s = T();
        for (int i = 0; i < n; i++) s += data[i];
        return s;
    }

    // ★ 平均值要转 double —— 否则 int 数据会做整数除法
    double average() const { return n > 0 ? (double)sum() / n : 0.0; }

    void show() const {
        cout << "[" << n << "/" << size << "] ";
        for (int i = 0; i < n; i++) cout << data[i] << " ";
        cout << endl;
    }
};

int main() {
    Stats<>         s;                       // int[10]（全默认）
    int a[] = { 7, 2, 9, 4, 5 };
    for (int i = 0; i < 5; i++) s.add(a[i]);

    s.show();
    cout << "最大 " << s.maxValue() << "，最小 " << s.minValue()
         << "，和 "   << s.sum()      << "，平均 " << s.average() << endl;

    Stats<double, 3> d;                      // 只给类型和长度
    d.add(1.5);
    d.add(2.7);
    d.add(0.3);
    d.add(9.9);                              // ★ 满了，会被拒绝
    d.show();
    cout << "最大 " << d.maxValue() << "，平均 " << d.average() << endl;

    Stats<string, 3> t;                      // ★ T 换成 string 也能装
    t.add("pear");
    t.add("apple");
    t.add("orange");
    t.show();
    cout << "最大 " << t.maxValue() << "，最小 " << t.minValue() << endl;

    cout << myMax(3, 7) << " " << myMax(2.5, 1.5) << endl;
    return 0;
}

看到什么算成功：

[5/10] 7 2 9 4 5 
最大 9，最小 2，和 27，平均 5.4
！已满（3 个），9.9 没能进来
[3/3] 1.5 2.7 0.3 
最大 2.7，平均 1.5
[3/3] pear apple orange 
最大 pear，最小 apple
7 2.5

读结果：

如果这一关你能独立写出来：说明本章三组（函数模板、类模板、默认参数 + 边界保护）你已经能连起来用了。

加分实验：

1. 把 average() 里的 (double) 去掉，重新运行 → 平均 变成 5（整数除法）。这条坑在模板里特别隐蔽，因为类型是 T，你看不出到底是不是整数。
2. 把 Stats<string, 3> t; 改成 Stats<string> t; → 容量变成 10（默认值生效）。
3. 给 Stats 加一个 Stats<const char *> 的全特化版本（12.3.1）→ 让字符串也用"复制内容"的方式存。这就是标准的"定制"练习。

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

30 秒实验：把 ①②③④⑤⑥⑦ 逐个在编译器里敲一遍，认一下每种报错的样子。

• 重点看 ② 和 ⑦：这两种报错最常出现，也最容易让人"卡住".
• 第 ⑧ 条要单独记：它不报错。所以"定制之后一定要真的跑一遍、看一眼结果"——编译器不会替你确认"你定制的那个类型是不是实际用的那个"。

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

1. "模板会拖慢程序"——运行时不会（实例化出来的就是普通函数/类）。代价在编译期：用几种类型就编几份代码，编译更慢、可执行文件更大。
2. "模板什么类型都能塞"——它不是"运行时橡皮泥"。模板参数一确定，生成的类/函数就是严格类型检查的普通类（Pair<int,string> 的 setSecond(1) 会报错）。
3. "模板和虚函数是竞争关系，哪个新用哪个"——两者解决不同问题。类型在编译时能确定 → 模板（零开销）；编时确定不了（用户输入、插件、容器里的异构对象）→ 虚函数。判断标准只有一句话：类型什么时候才能确定？
4. "通用模板已经够通用了，不用特化"——通用 ≠ 正确。指针要深拷贝、字符串要比内容、bool 可以按位存——这些"例外"正是标准库大量使用特化的原因。
5. "自己写模板才是本事"——顺序反了。先用熟现成的（string、vector、sort）、再看懂模板怎么写的、最后才会自己写。现实工作里，会用 + 会定制占 90%。
6. "模板编过了就没问题"——成员函数"用到才实例化"，没被调用的成员即使写错也不会被发现。所以模板代码一定要"每种用法都真跑一遍"。
7. "特化写完就对上了"——不检查类型是否一字不差 → 悄悄退回通用版（第 ⑧ 条）。跑一遍看结果，是唯一的保险。
8. "模板是纯语法技巧，和工程没关系"——恰恰相反：标准库、编译器、你能想到的所有高性能库，都是模板搭的。它也是 C++ 编译慢的头号原因——这门语言用"编译时间"换来了"运行效率"。

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

这一章之后，你不再只会"用手边的类型"，而是能"和类型无关地写代码"。 具体来说：

• 能消灭"只换类型"的重复代码（12.1）——而且比 #define 安全。
• 能写出跟类型无关的函数：maxOf、sumOf、printAll（12.1.2）。
• 能让模板处理"数组长度"这类编译期常量（12.1.2 实例01、12.2.5）。
• 能写自己的容器类模板：Pair、Stack、BoundedArray（12.2 组）。
• 能配默认值，让常用配置少写几个字（12.2.3 / 12.2.4）。
• 能在通用模板不合适时，用全特化 / 成员特化"精准打补丁"（12.3 组）。
• 能看懂标准库里那些吓人的类型名：basic_string<char, char_traits<char>, allocator<char>> —— 知道多出来的都是默认参数。

同时拿到两条能一直用的判断力：

• ☑ 第十三章 STL（标准模板库） —— 已完结：小结（容器 ＋ 算法 ＋ 迭代器：vector / map / sort / erase-remove 惯用法）

相关笔记

• 函数模板 —— 本章起点：把类型变成参数
• 重载函数模板（含实例02） —— 通用模板的第一个"办不到"
• 类模板的定义与声明 —— 语法最容易翻车的地方
• 有界数组模板 —— 本章的结业作品
• 定制类模板 —— 通用模板的第二个"办不到"
• 定制类模板成员函数 —— 代价最小的定制手段
• 小结 —— 上一章知识地图："让类互相接替"
• 虚函数概述 —— 运行期多态（与本章的编译期多态配成一对）
• 序列容器 —— 下一章起点：本章的模板终于变成"可以拿来用的成品"
• 小结 —— 下一章知识地图：容器 ＋ 算法 ＋ 迭代器
• 🔷 C++基础 · 索引 —— 全课路线图