本文是《模板初阶》《模板进阶》的复习整理，按"是什么 → 为什么 → 怎么用 → 踩坑点"的逻辑重新梳理，代码统一放在 namespace Jianyi 下方便测试。文末附高频面试问法，方便查漏补缺。
一、为什么需要模板：从函数重载说起
写一个通用的 Swap 函数，最朴素的做法是重载：
namespace Jianyi
{
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}
// 类型一多，写到崩溃……
}
这种写法有两个明显缺陷：
于是自然产生一个想法：能不能只给编译器一个"模子"，让编译器根据实际类型自动生成代码？ 这就是模板的意义。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段；模板是泛型编程的基础。C++ 模板分两大类：函数模板和类模板。
二、函数模板
2.1 概念与语法
函数模板代表一个"函数家族"，本身与具体类型无关，在被调用时才根据实参类型被参数化，从而产生某个类型的特定版本。
template<typename T1, typename T2, ……, typename Tn>
返回值类型 函数名(参数列表) { }
namespace Jianyi
{
template<typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
}
一行代码搞定所有类型的交换，不用再手写重载。
易错点（面试常问）：typename 是定义模板参数的关键字，也可以用 class 代替，但绝不能用 struct 代替。这是一个很多初学者会搞混的细节。
2.2 函数模板的原理
函数模板本身不是函数，只是编译器生成具体函数的"蓝图"。真正应该由程序员重复劳动的部分，被交给了编译器去做。
编译阶段，编译器会根据实参类型进行推演（type deduction），然后为该类型生成一份专属代码。比如传入 double 类型调用 Swap，编译器就会把 T 确定成 double，"实例化"出一份专门处理 double 的 Swap 代码；传 int、char 同理，各自生成一份。这个过程对程序员是透明的。
2.3 函数模板的实例化
用不同类型的参数使用函数模板，叫做函数模板的实例化，分为两种：
① 隐式实例化：让编译器自己根据实参推演模板参数类型。
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2); // T 推演为 int，OK
Add(d1, d2); // T 推演为 double，OK
// Add(a1, d1);
// ↑ 编译不过！a1 把 T 推成 int，d1 把 T 推成 double，
// 模板参数列表里只有一个 T，编译器无法确定该用哪个，直接报错。
// 注意：模板中编译器一般不会做隐式类型转换，
// 因为一旦转换出问题，编译器就要"背锅"，所以干脆不转。
// 解决方式有两种：
Add(a1, (int)d1); // 方式一：自己强转
return 0;
}
② 显式实例化：在函数名后用 <> 显式指定模板参数的实际类型。
int main()
{
int a = 10;
double b = 20.0;
Add<int>(a, b); // 显式告诉编译器 T = int，b 会被隐式转换成 int
return 0;
}
一旦用显式实例化指定了类型，如果实参类型不完全匹配，编译器会尝试隐式类型转换；转不成功才报错。这一点和隐式实例化"绝不转换"的行为是不同的。
2.4 模板参数的匹配原则（重点，面试高频）
① 非模板函数可以和同名函数模板共存，且该模板也可以被实例化生成一份和非模板函数"撞名"的版本：
// 专门处理 int 的加法函数（非模板）
int Add(int left, int right) { return left + right; }
// 通用加法函数（模板）
template<class T>
T Add(T left, T right) { return left + right; }
void Test()
{
Add(1, 2); // 与非模板函数完全匹配 → 优先调用非模板函数
Add<int>(1, 2); // 显式指定，强制走模板实例化版本
}
② 参数条件相同时，优先调用非模板函数；但如果模板能生成一个"更匹配"的版本，则优先选模板：
int Add(int left, int right) { return left + right; }
template<class T1, class T2>
T1 Add(T1 left, T2 right) { return left + right; }
void Test()
{
Add(1, 2); // 与非模板函数类型完全匹配，不需要实例化模板
Add(1, 2.0); // 非模板函数需要发生隐式转换才能匹配（int, int）
// 而模板可以精确生成 Add<int, double> 更加匹配 → 选模板
}
③ 模板函数不支持隐式类型转换，但普通函数支持。 这条本质上是①②的原因：模板追求"精确匹配、绝不背锅"，普通函数则更宽容。
三、类模板
3.1 定义格式
template<class T1, class T2, …, class Tn>
class 类模板名
{
// 类内成员定义
};
以一个简易的 Stack 为例：
namespace Jianyi
{
template<typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data);
private:
T* _array;
size_t _capacity;
size_t _size;
};
// 类模板成员函数在类外定义，类名后必须带上 <T>
// 注意：一般不建议把类模板的声明和定义分离到 .h / .cpp 两个文件，
// 否则会出现链接错误（原因见第五节"分离编译"）
template<class T>
void Stack<T>::Push(const T& data)
{
// 这里省略了扩容逻辑
_array[_size] = data;
++_size;
}
}
int main()
{
Jianyi::Stack<int> st1;
Jianyi::Stack<double> st2;
return 0;
}
3.2 类模板的实例化
类模板的实例化和函数模板不同：函数模板可以"隐式"实例化（编译器自动推），但类模板必须显式在类名后加 <>，把类型写进去，编译器不会替你猜。
// Stack 只是"类模板名"，不是真正的类；
// Stack<int> 才是真正的类型（真正的类）
Stack<int> st1; // 实例化出一个存 int 的 Stack
Stack<double> st2; // 实例化出一个存 double 的 Stack
这一点是初学者很容易混淆的地方：Stack 不能单独拿来定义对象，必须带上具体类型。
四、非类型模板参数
模板参数其实分两类：
- 类型形参：template<class T> 里那个 T，代表一种类型。
- 非类型形参：用一个常量作为模板参数，在模板内部可以把它当常量使用。
namespace Jianyi
{
// 定义一个"编译期定长"的静态数组模板，N 就是非类型模板参数
template<class T, size_t N = 10>
class array
{
public:
T& operator[](size_t index) { return _array[index]; }
const T& operator[](size_t index) const { return _array[index]; }
size_t size() const { return _size; }
bool empty() const { return 0 == _size; }
private:
T _array[N];
size_t _size;
};
}
这其实就是 STL 中 std::array<T, N> 的简化雏形，N 在编译期就要确定，数组大小才能在栈上分配。
注意（面试常考的两条规则）：
五、模板的特化
5.1 为什么需要特化
模板写出来是"通用"的，但通用不代表对所有类型都语义正确。经典例子：写一个比较大小的函数模板 Less：
template<class T>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
Less(1, 2); // 正常，比较数值，结果正确
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
Less(d1, d2); // 正常，Date 重载了 operator<，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
Less(p1, p2); // 能编译，但结果错误！
// 原因：T 被推演为 Date*，left < right 比较的是两个指针的地址大小，
// 而不是 d1、d2 这两个对象内容的大小，语义完全跑偏了。
}
也就是说，模板对绝大多数类型都正确，但对指针这种特殊类型得到了错误结果。这时就需要模板特化：在原模板的基础上，针对特殊类型单独给出一份"定制实现"。
模板特化分为函数模板特化和类模板特化。
5.2 函数模板特化
步骤：
template<class T>
bool Less(T left, T right)
{
return left < right;
}
// 针对 Date* 进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right; // 比较指针指向的内容，而不是地址
}
int main()
{
Date* p1 = &d1;
Date* p2 = &d2;
Less(p1, p2); // 现在会精确匹配特化版本，结果正确
}
实战经验（原文强调的一点）：函数模板一旦遇到某个类型处理不了或者处理有误，通常更简单直接的做法是直接重载一个同名的普通函数，而不是写特化版本——代码更直观、可读性更高。所以业界经验是：函数模板不太建议做特化，遇到问题直接重载即可。这条属于比较"实用主义"的经验，面试被问到时可以提一句体现工程思维。
5.3 类模板特化
全特化
把模板参数列表全部确定为具体类型：
template<class T1, class T2>
class Data
{
public:
Data() { cout << "Data<T1, T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
// 全特化：T1、T2 都确定为具体类型
template<>
class Data<int, char>
{
public:
Data() { cout << "Data<int, char>" << endl; }
private:
int _d1;
char _d2;
};
void TestVector()
{
Data<int, int> d1; // 走通用模板
Data<int, char> d2; // 走全特化版本
}
偏特化
偏特化不是"全部确定"，而是对模板参数做进一步的条件限制。有两种常见形式：
① 部分特化：只把一部分参数具体化。
// 把第二个参数特化为 int，第一个仍然保留通用
template<class T1>
class Data<T1, int>
{
public:
Data() { cout << "Data<T1, int>" << endl; }
private:
T1 _d1;
int _d2;
};
② 参数进一步限制：不局限于"确定具体类型"，而是针对某种"形态"（比如指针、引用）做特化。
// 两个参数都偏特化为指针类型
template<typename T1, typename T2>
class Data<T1*, T2*>
{
public:
Data() { cout << "Data<T1*, T2*>" << endl; }
private:
T1 _d1;
T2 _d2;
};
// 两个参数都偏特化为引用类型
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:
Data(const T1& d1, const T2& d2) : _d1(d1), _d2(d2)
{
cout << "Data<T1&, T2&>" << endl;
}
private:
const T1& _d1;
const T2& _d2;
};
void test2()
{
Data<double, int> d1; // 命中"第二参数特化为 int"版本
Data<int, double> d2; // 走通用模板
Data<int*, int*> d3; // 命中指针偏特化版本
Data<int&, int&> d4(1, 2); // 命中引用偏特化版本
}
类模板特化的实战应用
回到"比较大小"的问题，Less 也可以写成一个函数对象类模板，然后专门对指针类型做偏特化，这样 sort 就能对 vector<Date*> 正确排序：
template<class T>
struct Less
{
bool operator()(const T& x, const T& y) const { return x < y; }
};
// 通用版本会导致 vector<Date*> 按"地址"排序而非"日期"排序 —— 语义错误
// 所以做一份指针特化版本：
template<>
struct Less<Date*>
{
bool operator()(Date* x, Date* y) const { return *x < *y; }
};
int main()
{
vector<Date*> v2 = { &d1, &d2, &d3 };
sort(v2.begin(), v2.end(), Less<Date*>()); // 特化后结果才是真正按日期升序
}
这是一个非常典型的"标准库排序 + 自定义比较仿函数 + 特化"组合，STL 源码里到处都是这种手法，属于面试可以拿来举例的经典场景。
六、模板的分离编译
6.1 什么是分离编译
一个项目由多个源文件组成，每个源文件各自单独编译成目标文件（.obj/.o），最后把所有目标文件链接起来，形成一个可执行文件。这个过程就叫分离编译。
6.2 模板分离编译会出问题
如果把模板的声明放进 .h，把定义放进 .cpp，像普通函数那样分离：
// a.h
template<class T>
T Add(const T& left, const T& right);
// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
// main.cpp
#include "a.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}
这样写会链接报错（比如 VS 下会出现"无法解析的外部符号"）。原因是：
也就是说，模板必须在"看得到定义"的地方被实例化，才能真正生成代码；普通函数只需要声明就能先编译过，等链接时再找定义即可，但模板不行。
6.3 解决方法
为什么放到同一个文件就能解决"编译器不知道该实例化成什么类型"的问题？
关键在于：编译器根本不需要提前知道要实例化哪些类型，它只需要在"看到调用"的那一刻，同时也能看到模板的完整定义，两者凑齐了，就能当场生成代码。
回顾一下之前失败的例子：main.cpp 里的 Add(1, 2) 明明清清楚楚地告诉了编译器"这里要实例化一个 T = int 的版本"——问题不是编译器不知道类型，而是编译 main.cpp 这个源文件时，它手里只有 a.h 里的一条函数声明，没有函数体（定义），所以就算知道要哪个类型，也没有"模子"可以拿来生成代码；而定义虽然存在，但是在 a.cpp 里，a.cpp 是被单独编译的，编译到它的时候，它内部根本没有出现任何 Add(1, 2) 这样的调用，所以编译器也不会平白无故地去猜"我要不要顺手生成一个 int 版本"。于是两边各差一半，谁都没能把完整的代码生成出来，链接时自然就找不到。
把声明和定义合并进 xxx.hpp 之后，main.cpp 用 #include "a.hpp" 时，把模板的定义也一起"抄"进了自己这个源文件。这样一来，在编译 main.cpp 这一份源文件的时候，编译器眼前同时有了：①Add(1, 2) 这个调用点（知道要 T = int）；②Add 的完整函数体（知道该怎么生成代码）。类型和模子在同一个地方凑齐了，编译器就能就地把 Add<int> 的具体代码实例化出来，不需要等到链接阶段再去别处找。
一句话总结：普通函数是"声明先编译过，定义链接时再找"；模板必须"声明、定义、调用点三者同时可见"才能生成代码，所以模板的定义不能脱离调用它的源文件太远，最简单的办法就是把定义直接放进头文件里，让每个用到它的 .cpp 都能通过 #include 把定义也一起带过去。
扩展阅读：分离编译细节可参考 pongba 的这篇文章。
七、模板总结
优点
缺陷
八、复习自测 / 面试高频问法
写博客的一个好处就是能顺手把易考点提炼出来，方便自己后面刷面经时直接对照：
