引言
C++ 模板是实现泛型编程的核心工具，它允许我们编写与具体类型无关的代码。这不仅提高了代码的复用性，还保持了类型安全。模板在编译阶段进行实例化，根据实际使用的类型生成具体的代码，因此通常不会带来额外的运行时开销。
一、为什么需要模板？
在开发过程中，我们经常遇到需要处理多种数据类型的场景。比如写一个求最大值的函数，如果只用传统的方法，我们需要为 int、double、string 等每种类型都写一遍重载函数。这会导致大量重复代码，且一旦算法逻辑变更（比如改为求最小值），所有重载都要修改，维护成本很高。
模板的出现解决了这个问题。它将类型作为参数，编译器会根据调用时传入的具体类型自动生成对应的代码版本。
1. 函数重载 vs 函数模板
传统方法：函数重载
#include <iostream>
#include <string>
using namespace std;
// 为 int 重载
int max(int a, int b) {
cout << "int version\n";
return a > b ? a : b;
}
// 为 double 重载
double max(double a, double b) {
cout << "double version\n";
return a > b ? a : b;
}
// 为 string 重载
string max(const string& a, const string& b) {
cout << "string version\n";
return a > b ? a : b;
}
int main() {
cout << max(3, 5) << "\n";
cout << max(3.14, 2.7) << "\n";
cout << max("hello", "world") << "\n";
return 0;
}
这种写法虽然可行，但缺点很明显：代码冗余严重，扩展性差，新类型支持困难。
模板方法：函数模板
#include <iostream>
#include <string>
using namespace std;
template <typename T>
T max(T a, T b) {
cout << "template version for " << typeid(T).name() << "\n";
return a > b ? a : b; // 要求 T 支持 operator>
}
int main() {
cout << max(3, 5) << "\n"; // T = int
cout << max(3.14, 2.7) << "\n"; // T = double
cout << max("hello", "world") << "\n"; // T = string
cout << max('a', 'b') << "\n"; // T = char
return 0;
}
使用模板后，一份代码即可适配所有支持比较运算符的类型。只要类型实现了 operator>，编译器就能自动处理。
二、函数模板详解
1. 定义与语法
函数模板代表了一个函数家族。定义时以 template 关键字开头，后跟模板参数列表，再是函数声明。
template<class T> // 或 template<typename T>
void Swap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
这里 T 是占位符类型名，可以是任意标识符。注意，class 和 typename 在这里作用相同，但习惯上推荐使用 typename。
2. 多模板参数
模板不仅可以接受一个类型参数，也可以接受多个。例如交换两个不同类型的变量：
template<class T1, class T2>
void func2(const T1& x, const T2& y) {
cout << x << " " << y << endl;
}
int main() {
int a = 10;
double b = 3.14;
func2(a, b); // T1=int, T2=double
return 0;
}
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
Add(d1, d2); // T 推导为 double
return 0;
}
注意：如果只有一个模板参数，传入不同类型会报错，因为编译器无法确定 T 到底是哪个类型。
int a1 = 10;
double d1 = 3.14;
Add(a1, d1); // 编译错误：无法推导 T
解决办法：
- 强制转换类型。
- 显式指定模板参数。
Add<int>(a1, d1); // 显式指定 T 为 int，d1 会被隐式转换为 int
显式实例化告诉编译器跳过推导过程，直接使用指定的类型。编译器会检查该类型是否合法，如果不合法则报错。
4. 匹配原则
当存在非模板函数和同名函数模板时，编译器遵循以下优先级：
- 优先调用非模板函数：如果非模板函数能完美匹配，优先选它。
- 选择更匹配的模板：如果模板能生成比非模板函数更好的匹配（例如不需要隐式转换），则选择模板。
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(1, 2.0); // 调用模板函数（非模板无法匹配 double）
}
三、类模板
类模板的概念与函数模板类似，但它描述的是类的蓝图。类模板中的成员变量、函数参数和返回值都可以是模板参数。
1. 定义与外部实现
类模板定义同样需要 template 关键字。如果在类外定义成员函数，必须再次声明模板参数，并使用完整的类名限定。
template <typename T>
class Stack {
public:
void push(const T& x);
T pop();
private:
T* _array;
size_t _capacity;
size_t _size;
};
// 类外定义成员函数
template <typename T>
void Stack<T>::push(const T& x) {
if (_size == _capacity) {
// 扩容逻辑...
}
_array[_size++] = x;
}
template <typename T>
T Stack<T>::pop() {
return _array[--_size];
}
2. 实例化
类模板不能像函数模板那样完全依赖隐式推导，通常需要显式指定类型来实例化。
Stack<int> st1; // 实例化为整型栈
Stack<double> st2; // 实例化为浮点型栈
Stack<double>* pst = new Stack<double>; // 指针形式
类模板名字本身不是类型，只有加上 <T> 后才成为真正的类型。
四、总结
模板是 C++ 泛型编程的基石。通过函数模板和类模板，我们可以编写出高度通用且高效的代码。理解模板的实例化机制和匹配原则，对于避免编译错误和优化性能至关重要。在实际开发中，合理使用模板可以大幅减少样板代码，提升系统的可维护性。
