概述
在 C++ 编程中，我们经常会遇到这样的场景：需要实现功能完全相同，但处理数据类型不同的函数。比如交换两个整数、交换两个浮点数、交换两个字符的函数。最直接的想法是用函数重载，但这种方式的弊端显而易见 —— 代码复用率低、可维护性差。而模板（Template）作为泛型编程的核心，恰好解决了这个问题，让我们能编写与类型无关的通用代码。
一、泛型编程：模板的设计思想
1. 函数重载的痛点
先看一个熟悉的场景：实现不同类型的交换函数。用函数重载的写法如下：
// 交换 int 类型 void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } // 交换 double 类型 void Swap(double& left, double& right) { double temp = left; left = right; right = temp; } // 交换 char 类型 void Swap(char& left, char& right) { char temp = left; left = right; right = temp; }
这种写法有两个致命问题：
- 代码复用率低：新增类型（如
long、string）时，必须手动添加对应的重载函数； - 可维护性差：如果逻辑需要修改（比如优化交换逻辑），所有重载函数都要同步修改，一个出错可能全量报错。
2. 泛型编程的核心思路
我们需要一个'模具'：告诉编译器一个通用逻辑，让编译器根据不同的类型自动生成对应的代码。这就是泛型编程—— 编写与类型无关的通用代码，而模板是泛型编程的基础。
模板分为两类：
- 函数模板：针对函数的通用模板；
- 类模板：针对类的通用模板。
二、函数模板：通用函数的'模具'
1. 函数模板的概念
函数模板代表一个函数家族，与类型无关，在使用时通过参数化（指定类型），由编译器生成对应类型的具体函数。
2. 函数模板的格式
template<typename T1, typename T2, ..., typename Tn> 返回值类型 函数名 (参数列表) {
// 函数体（通用逻辑）
}
template：声明模板的关键字；typename：定义模板参数的关键字，也可以用class代替（注意：不能用struct）；T1、T2...：模板参数（类型占位符），可以理解为'待确定的类型'。
用函数模板重构上面的 Swap 函数：
// 通用交换函数模板 template<typename T> // 声明模板参数 T void Swap(T& left, T& right) { T temp = left; left = right; right = temp; }
这一段代码就能替代所有类型的 Swap 重载函数，编译器会根据传入的实参类型自动生成对应版本。
3. 函数模板的原理
很多人会误以为函数模板是'万能函数'，能直接处理所有类型 —— 这是错误的！
函数模板本身不是函数，而是编译器生成具体函数的'模具'。其核心原理是：在编译阶段，编译器根据传入的实参类型，推演模板参数 T 的具体类型，然后生成一份专门处理该类型的函数代码。
举个例子，当我们调用：
int a = 10, b = 20; double c = 2.0, d = 5.0; char e = 'a', f = 'b'; Swap(a, b); // 实参为 int，编译器生成 int 版本的 Swap Swap(c, d); // 实参为 double，生成 double 版本的 Swap Swap(e, f); // 实参为 char，生成 char 版本的 Swap
编译器会自动生成 3 个不同的函数：
// 编译器生成的 int 版本 void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } // 编译器生成的 double 版本 void Swap(double& left, double& right) { double temp = left; left = right; right = temp; } // 编译器生成的 char 版本 void Swap(char& left, char& right) { char temp = left; left = right; right = temp; }
简单说：模板把重复写代码的工作，交给了编译器来完成。
4. 函数模板的实例化
用不同类型的参数使用函数模板，称为函数模板的实例化。根据是否显式指定类型，分为两种：
（1）隐式实例化：编译器自动推演类型
编译器根据传入的实参，自动推导模板参数 T 的类型。
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，生成 int 版本 Add
Add(d1, d2); // 隐式推演 T 为 double，生成 double 版本 Add
// Add(a1, d1); // 编译报错！
// 原因：a1 推 T 为 int，d1 推 T 为 double，模板只有一个 T，编译器无法确定用哪种类型
return 0;
}
注意：编译器不会自动进行类型转换（怕出问题背锅），所以 Add(a1, d1)（int 和 double 混合）会直接报错。
解决方法有两种：
- 手动强制类型转换：
Add(a1, (int)d1)或Add((double)a1, d1)； - 显式实例化（推荐）。
（2）显式实例化：手动指定类型
在函数名后加 <类型>，直接告诉编译器模板参数的类型，无需推演。
int main() {
int a = 10;
double b = 20.0;
// 显式指定 T 为 int，编译器尝试将 b 隐式转换为 int
Add<int>(a, b);
// 显式指定 T 为 double，编译器尝试将 a 隐式转换为 double
Add<double>(a, b);
return 0;
}
如果类型无法转换（比如 int 转 string），编译器会报错。
5. 模板参数的匹配原则
当非模板函数和同名函数模板同时存在时，编译器的调用规则如下：
原则 1：非模板函数与模板函数可共存
// 非模板函数（专门处理 int）
int Add(int left, int right) { cout << "非模板函数：int Add(int, int)" << endl; return left + right; }
// 函数模板（通用版本）
template<class T> T Add(T left, T right) { cout << "模板函数：T Add(T, T)" << endl; return left + right; }
void Test() {
Add(1, 2); // 调用非模板函数（完全匹配，无需实例化模板）
Add<int>(1, 2); // 调用模板实例化的 int 版本（显式指定模板）
}
原则 2：优先调用非模板函数，模板可生成更匹配的版本时例外
// 非模板函数（int 专用）
int Add(int left, int right) { cout << "非模板函数：int Add(int, int)" << endl; return left + right; }
// 函数模板（支持两种不同类型）
template<class T1, class T2> T1 Add(T1 left, T2 right) { cout << "模板函数：T1 Add(T1, T2)" << endl; return left + right; }
void Test() {
Add(1, 2); // 调用非模板函数（完全匹配）
Add(1, 2.0); // 调用模板函数（生成 int+double 的匹配版本，比非模板更合适）
}
原则 3：模板函数不支持自动类型转换，普通函数可以
void Test() {
Add(1, 2.0); // 普通函数：int Add(int, int) 可将 2.0 自动转为 int，调用成功
// Add<int>(1, 2.0); // 模板函数：显式指定 T 为 int，2.0 需手动转 int，否则报错
}
三、类模板：通用类的'模具'
类模板与函数模板类似，用于创建与类型无关的通用类（比如容器类：栈、队列、数组等）。
1. 类模板的定义格式
template<class T1, class T2, ..., class Tn> class 类模板名 {
// 类内成员定义（可使用模板参数 T1、T2...）
};
举个常用的例子：通用栈类 Stack
#include<iostream>
using namespace std;
// 类模板：通用栈
template<typename T> // 模板参数 T：栈中元素的类型
class Stack {
public:
// 构造函数：默认容量 4
Stack(size_t capacity = 4) {
_array = new T[capacity]; // 动态开辟 T 类型数组
_capacity = capacity;
_size = 0;
}
// 入栈操作（成员函数声明）
void Push(const T& data);
private:
T* _array; // 指向 T 类型数组的指针
size_t _capacity; // 栈的容量
size_t _size; // 栈的当前元素个数
};
// 类模板成员函数的类外定义（必须加模板声明）
template<class T> // 注意：这里的 T 要和类模板的 T 一致
void Stack<T>::Push(const T& data) {
// 扩容逻辑（简化版，实际需判断是否满容）
_array[_size] = data;
++_size;
}
2. 类模板的实例化
类模板的实例化与函数模板不同：必须显式指定类型（无法通过实参推演），且类模板名不是真正的类，实例化后的结果才是真正的类。
格式：类模板名<类型> 对象名;
int main() {
// 实例化 int 类型的栈：Stack<int>是真正的类，st1 是该类的对象
Stack<int> st1;
st1.Push(10);
st1.Push(20);
// 实例化 double 类型的栈：Stack<double>是另一个独立的类
Stack<double> st2;
st2.Push(3.14);
st2.Push(6.28);
// Stack st3; // 编译报错！类模板必须显式指定类型
return 0;
}
注意：Stack<int> 和 Stack<double> 是两个完全不同的类，占用的内存大小可能不同（比如 int 占 4 字节，double 占 8 字节）。
3. 类模板的注意事项
禁止将类模板的声明和定义分离到.h 和.cpp 文件！
比如：
Stack.h：声明类模板和成员函数；Stack.cpp：定义成员函数。
这会导致链接错误 —— 编译器在编译 .cpp 时，无法确定模板参数 T 的具体类型，不会生成真正的函数代码；而编译主文件时，只看到声明，链接时找不到实现，最终报错。
解决方案：将类模板的声明和定义都写在 .h 文件中（或 .hpp 文件，专门用于模板）。
四、总结
模板是 C++ 泛型编程的基础，核心价值是代码复用和类型无关性：
- 函数模板：解决'同逻辑不同类型'的函数重复编写问题；
- 类模板：解决'通用容器 / 数据结构'的类型适配问题（比如 STL 中的
vector、list都是类模板）。
通过本文，你应该掌握：
- 函数模板的格式、原理、实例化和匹配原则；
- 类模板的定义、实例化和使用注意事项；
- 模板与函数重载的区别与联系。
