C++模板编程是泛型编程的核心实现方式，它允许开发者编写与类型无关的代码逻辑，让同一套代码可以适配多种不同的数据类型，大幅减少重复代码的编写量。模板的核心思想是将类型作为参数传递给编译器，由编译器在编译阶段根据实际使用的类型生成对应的具体代码，这个过程称为模板实例化。
模板的基础分类与语法
C++模板主要分为函数模板和类模板两类，两者的基础语法结构相似，都是使用template关键字声明模板参数列表。
函数模板
函数模板用于定义通用的函数逻辑，编译器会根据调用时传入的参数类型自动推导模板参数，或者由开发者显式指定模板参数。下面是一个简单的交换函数模板示例：
#include <iostream>
using namespace std;
// 定义函数模板，T为类型参数
template <typename T>
void swap_value(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
int main() {
int x = 10, y = 20;
// 编译器自动推导T为int
swap_value(x, y);
cout << "x: " << x << ", y: " << y << endl;
double m = 1.5, n = 2.5;
// 也可以显式指定T为double
swap_value<double>(m, n);
cout << "m: " << m << ", n: " << n << endl;
return 0;
}
类模板
类模板用于定义通用的类结构，类中的成员变量、成员函数的参数或返回值可以使用模板参数作为类型。类模板的实例化需要显式指定模板参数，编译器不会自动推导类模板的参数类型。下面是一个简单的容器类模板示例：
#include <iostream>
using namespace std;
// 定义类模板，T为类型参数
template <typename T>
class MyContainer {
private:
T value;
public:
MyContainer(T v) : value(v) {}
T get_value() const {
return value;
}
void set_value(T v) {
value = v;
}
};
int main() {
// 显式指定T为int
MyContainer<int> int_container(100);
cout << "int value: " << int_container.get_value() << endl;
// 显式指定T为string
MyContainer<string> str_container("hello");
cout << "string value: " << str_container.get_value() << endl;
return 0;
}
模板的实例化与编译原理
模板本身并不是可以直接执行的代码，它只是一个代码生成规则。只有当模板被实际使用时，编译器才会根据具体的模板参数生成对应的具体代码，这个过程就是模板实例化。模板的实例化发生在编译阶段，因此模板的声明和定义通常需要放在同一个头文件中，否则可能导致链接错误。
模板实例化分为隐式实例化和显式实例化两种：
- 隐式实例化：编译器在编译时根据实际使用的模板参数自动生成对应的代码，比如前面示例中调用
swap_value(x, y)时，编译器自动生成void swap_value(int&, int&)的函数版本。 - 显式实例化：开发者通过
template关键字显式告诉编译器生成特定参数类型的模板实例，比如template void swap_value(double&, double&);，这种方式可以避免多个编译单元重复实例化相同的模板版本，减少编译时间。
模板特化与偏特化
模板特化是指针对特定的模板参数类型，提供专门的实现逻辑，覆盖通用的模板实现。模板特化分为全特化和偏特化两种。
全特化
全特化是对模板的所有参数都指定具体类型，提供完全定制的实现。下面是一个函数模板全特化的示例：
#include <iostream>
#include <cstring>
using namespace std;
// 通用函数模板
template <typename T>
bool is_equal(T a, T b) {
return a == b;
}
// 针对const char*类型的全特化版本
template <>
bool is_equal<const char*>(const char* a, const char* b) {
return strcmp(a, b) == 0;
}
int main() {
int x = 10, y = 10;
cout << "int equal: " << is_equal(x, y) << endl;
const char* s1 = "test";
const char* s2 = "test";
cout << "string equal: " << is_equal(s1, s2) << endl;
return 0;
}
偏特化
偏特化主要针对类模板，是指指定部分模板参数的具体类型，或者对模板参数添加额外的约束，不需要指定所有参数的类型。比如我们可以针对指针类型的模板参数提供偏特化实现：
#include <iostream>
using namespace std;
// 通用类模板
template <typename T>
class TypeInfo {
public:
static void print() {
cout << "通用类型" << endl;
}
};
// 针对指针类型的偏特化
template <typename T>
class TypeInfo<T*> {
public:
static void print() {
cout << "指针类型" << endl;
}
};
int main() {
TypeInfo<int>::print(); // 输出通用类型
TypeInfo<int*>::print(); // 输出指针类型
return 0;
}
模板元编程基础
模板元编程是利用模板在编译阶段进行计算的编程方式，通过模板的递归实例化实现编译期的逻辑判断、循环和数值计算，计算结果会直接作为常量嵌入到最终的程序中，不会占用运行时的性能。最常见的模板元编程应用是计算编译期常量，比如计算阶乘：
#include <iostream>
using namespace std;
// 模板元编程计算阶乘，递归终止条件
template <int N>
struct Factorial {
// 递归实例化，N的阶乘等于N乘以N-1的阶乘
static const int value = N * Factorial<N-1>::value;
};
// 全特化，0的阶乘为1
template <>
struct Factorial<0> {
static const int value = 1;
};
int main() {
// 编译期计算5的阶乘，结果为120
cout << "5的阶乘: " << Factorial<5>::value << endl;
return 0;
}
模板元编程的计算发生在编译阶段，因此可以减少运行时的计算开销，但过度使用模板元编程会导致编译时间变长，生成的代码体积增大，实际开发中需要权衡使用场景。
模板编程的常见注意事项
- 模板代码通常需要放在头文件中，因为编译器需要在实例化模板时看到完整的模板定义，否则会出现链接错误。
- 模板参数推导时，值传递的参数会发生退化，比如数组作为参数传递时会退化为指针，需要注意类型匹配问题。
- 模板的嵌套使用可能会导致代码可读性下降，复杂的模板逻辑建议添加清晰的注释，或者封装为更易用的接口。
- 模板元编程的递归深度受编译器限制，过深的递归可能导致编译错误，需要控制递归的层数。