一、作用一：消灭重复（代码复用）

这是最直接的作用。要求"每段逻辑只写一遍"：

这不只是"少写几个字"。真正值钱的是后面那条：逻辑只有一份 → 不可能出现"四个函数里有一个忘了改"的事故。

判断标准：当你发现自己在写第二份"只换了类型名"的代码时，就该动手抽模板了。

二、作用二：比宏安全

在模板之前，C 语言是这么解决这个问题的：

#define MAX(a, b)  ((a) > (b) ? (a) : (b))

它能用，但埋着两个雷。

雷一：参数可能被求值两次

宏是纯文本替换。MAX(i++, 3) 展开后变成：

((i++) > (3) ? (i++) : (3))

如果 i++ > 3 成立，i++ 会被执行两次——i 凭空多加了一次。这类 bug 极难查，因为代码看起来完全正常。

模板不会：maxOf(i++, 3) 的参数是传值，i++ 只算一次。

雷二：没有类型检查

MAX("apple", 3)        // 展开后是 (("apple") > (3) ? ...) —— 拿字符串和整数比

在 C++ 里这甚至可能编过（指针和整数的比较），跑起来结果荒唐。模板会直接报错——T 推不出唯一答案。

对照表

所以：宏能干的"类型无关的运算"，今天都应该用模板或 constexpr 函数。（宏还剩两个正经用途：条件编译 #ifdef 和 字符串拼接 # / ##——那些是模板做不到的。）

回收旧账：这就是为什么 C++ 里那些"看起来像函数"的东西（std::max、std::swap）都是模板而不是宏。

三、作用三：它是标准库的地基

你在前面十一章里其实一直在用模板的产物（只是没点破）：

标准库的写法就是"模板 + 默认参数"（12.2.4 会讲后半截）。不会看模板，等于读不懂标准库的头文件。

四、实例01：使用数组作为模板参数

现在讲本节的重头戏。

问题：写一个"打印数组"的函数。难点不在打印，在"知道数组有几个元素"。

void showArray(int arr[], int n) {         // 老办法：长度要"手动传"
    for (int i = 0; i < n; i++) cout << arr[i] << " ";
}

每次调用都要自己记住长度，而且传错一个数就悄悄读越界（7.5.1 讲过"数组作参数会退化成指针"）：

int a[] = {1, 2, 3, 4, 5};
showArray(a, 5);      // 对
showArray(a, 4);      // 不报错，只是少打一个 —— 没人提醒你
showArray(a, 50);     // 不报错，只是读到越界 —— 灾难

模板的解法：把长度也变成模板参数。

template <typename T, int N>
void showArray(const T (&arr)[N]) {        // ★ 参数是"数组的引用"，长度写在类型里
    for (int i = 0; i < N; i++) cout << arr[i] << " ";
}

关键在于 T (&arr)[N] 这个写法：

int N 是什么？ 它是非类型模板参数——参数不是类型，而是一个值。所以：

• N 是编译期常量（不是变量，不能改）
• 每种长度都是"不同的类型实例"：showArray< int, 5 > 和 showArray< int, 3 > 是两个独立的函数
• 调用时什么都不用写——N 从数组本身推出来

于是：

int    a[] = {1, 2, 3, 4, 5};      // N = 5
double b[] = {1.5, 2.5, 3.0};      // N = 3
char   c[] = {'A', 'B', 'C'};      // N = 3

showArray(a);      // 不用写 5
showArray(b);      // 不用写 3
showArray(c);

"忘了传长度"这件事，从此不可能发生——因为它不再需要人传。

五、动手 Demo：实例01 完整代码

#include <iostream>
using namespace std;

// ① 打印任意类型、任意长度的数组
template <typename T, int N>
void showArray(const T (&arr)[N]) {
    cout << "共 " << N << " 个元素：";
    for (int i = 0; i < N; i++) cout << arr[i] << " ";
    cout << endl;
}

// ② 求任意类型、任意长度数组的和
//    ★ T s = T();  —— 用 T 的"零值"初始化：int→0、double→0.0、string→""
template <typename T, int N>
T sumOf(const T (&arr)[N]) {
    T s = T();
    for (int i = 0; i < N; i++) s += arr[i];
    return s;
}

// ③ 求数组里最大的元素
template <typename T, int N>
T maxOfArray(const T (&arr)[N]) {
    T m = arr[0];
    for (int i = 1; i < N; i++) if (arr[i] > m) m = arr[i];
    return m;
}

int main() {
    int    a[] = { 7, 2, 9, 4, 5 };        // N = 5
    double b[] = { 1.5, 2.5, 3.0 };        // N = 3
    char   c[] = { 'A', 'B', 'C' };        // N = 3

    showArray(a);
    showArray(b);
    showArray(c);

    cout << "整数和 = " << sumOf(a) << endl;
    cout << "小数和 = " << sumOf(b) << endl;
    cout << "最大整数 = " << maxOfArray(a) << endl;
    cout << "最大字符 = " << maxOfArray(c) << endl;
    return 0;
}

看到什么算成功：

共 5 个元素：7 2 9 4 5 
共 3 个元素：1.5 2.5 3 
共 3 个元素：A B C 
整数和 = 27
小数和 = 7
最大整数 = 9
最大字符 = C

读结果：

30 秒实验：

1. 给 char 那个数组改成 char c[] = "ABC";（用字符串字面量）。
2. 重新编译运行，看第一行输出："共 4 个元素"——不是 3！
3. 因为字符串字面量的真实长度包含结尾的 '\0'（7.3 的老知识）："ABC" 的类型是 char[4]。
4. 这个实验同时说明两件事：① N 确实是从类型里推出来的；② 字符串数组的长度永远比"看到的字符数"多 1。

六、常见误区

1. "#define 和模板差不多，用哪个都行"——差别很大：宏没有类型检查、参数可能被求值两次、没法调试。只有"条件编译"和"字符串拼接"这两件事才非宏不可。
2. "template <int N> 里的 N 是个变量"——不是。它是编译期常量（不能 N++）。不同的 N 会生成不同的函数。
3. "数组做参数时写 T arr[] 就行"——不行，那会退化成指针（7.5.1），长度信息丢掉，N 推不出来。必须写 const T (&arr)[N]（引用）。
4. "sumOf 里写 T s = 0; 更简单"——不行。T 换成 string 时，string s = 0; 编译错。要写 T s = T();——这句话的意思是"用 T 的默认值初始化"。
5. "模板一定比手写快"——不一定，但通常至少一样快。实例化出来的代码和手写没有区别；真正的代价在编译期（每多一种类型/长度就多编一份代码）。别拿模板去套 20 种不同长度的小数组，那会让可执行文件白白变大。
6. "有了模板，宏就彻底没用了"——还剩两件事：#ifdef 条件编译（按平台编不同代码）和 # / ## 字符串化/拼接。别的场合，能用模板就用模板。

• ☐ 12.1.3 重载函数模板（下一节）

相关笔记

• 函数模板的定义 —— 上一节：template 这行的语法
• 重载函数模板（含实例02） —— 下一节：模板办不到的地方怎么办
• 指针与一维数组 —— 数组作参数为什么会退化成指针
• 字符数组 —— 字符串结尾那个 '\0'
• 有界数组模板 —— int N 这种"非类型模板参数"的正式用法
• 🔷 C++基础 · 索引 —— 全课路线图