1. 函数模板：泛型编程的基础工具
1.1 函数模板的概念与基本语法
函数模板是C++泛型编程的核心工具之一，它允许我们编写与数据类型无关的通用代码。想象一下，如果你需要为int、float、double等不同类型都编写功能相同但类型不同的函数，那将是多么繁琐的工作。函数模板就像是一个函数家族的蓝图，编译器可以根据实际需要自动生成特定类型的函数版本。
函数模板的基本语法如下：
cpp复制template<typename T1, typename T2,...,typename Tn>
返回值类型 函数名(参数列表){
// 函数体
}
这里有几个关键点需要注意：
template关键字表明这是一个模板声明typename（或等价的class）用于声明模板参数类型- 模板参数可以有多个，用逗号分隔
注意：虽然可以使用
class代替typename，但struct不能用于此目的。现代C++更推荐使用typename，因为它更准确地表达了意图。
1.2 函数模板的实例化过程
函数模板本身并不是真正的函数，而是编译器用来生成具体函数的模具。当我们在代码中调用函数模板时，编译器会根据传入的实参类型自动推导模板参数，并生成对应的函数实例。这个过程称为模板实例化。
让我们通过一个简单的加法函数模板来说明：
cpp复制template<typename T>
T Add(const T& left, const T& right) {
return left + right;
}
int main() {
int a = 10, b = 20;
double c = 10.5, d = 20.5;
Add(a, b); // 实例化出int版本的Add函数
Add(c, d); // 实例化出double版本的Add函数
return 0;
}
在这个例子中，编译器会生成两个不同的Add函数：一个处理int类型，一个处理double类型。这种机制既保持了代码的通用性，又不会损失类型安全性。
1.3 模板参数推导与显式指定
C++编译器非常智能，大多数情况下能够自动推导出模板参数的类型。但有时我们需要显式指定模板参数，特别是在以下几种情况：
- 模板参数无法从函数参数中推导出来时
- 我们希望强制使用特定类型时
- 函数没有参数，但需要模板实例化时
cpp复制template<typename T>
T GetMax() {
return std::numeric_limits<T>::max();
}
int main() {
auto maxInt = GetMax<int>(); // 必须显式指定类型
auto maxDouble = GetMax<double>();
return 0;
}
1.4 多参数函数模板
函数模板可以接受多个类型参数，这使得它们更加灵活。例如，我们可以创建一个打印多种类型值的函数模板：
cpp复制template<typename T1, typename T2, typename T3>
void PrintValues(const T1& a, const T2& b, const T3& c) {
std::cout << "Values: " << a << ", " << b << ", " << c << std::endl;
}
int main() {
PrintValues(42, 3.14, "Hello"); // int, double, const char*
return 0;
}
这种多参数模板在处理异构数据时特别有用，比如在实现各种容器或算法时。
2. 函数模板的高级特性
2.1 隐式实例化与显式实例化
函数模板的实例化可以分为隐式和显式两种方式：
隐式实例化是让编译器根据函数调用时的实参自动推导模板参数类型。这是最常用的方式，代码更简洁：
cpp复制template<typename T>
void Print(T value) {
std::cout << value << std::endl;
}
int main() {
Print(10); // 隐式实例化为Print<int>
Print(3.14); // 隐式实例化为Print<double>
return 0;
}
显式实例化则是在调用时明确指定模板参数类型，使用<>语法：
cpp复制int main() {
Print<int>(10); // 显式指定int类型
Print<double>(3.14); // 显式指定double类型
return 0;
}
显式实例化在以下情况下特别有用：
- 函数参数无法准确表达模板参数类型时
- 需要强制特定类型以避免歧义时
- 模板参数与函数参数不完全相关时
2.2 模板参数推导的局限性
虽然C++的模板参数推导非常强大，但它也有局限性。最常见的场景是当函数参数类型不一致时：
cpp复制template<typename T>
T Add(const T& a, const T& b) {
return a + b;
}
int main() {
int a = 10;
double b = 20.5;
// Add(a, b); // 错误：无法推导出T应该是int还是double
// 解决方案1：强制类型转换
Add(a, static_cast<int>(b));
// 解决方案2：显式指定模板参数
Add<int>(a, b);
Add<double>(a, b);
return 0;
}
2.3 函数模板重载与特化
函数模板可以与非模板函数重载，也可以进行特化。编译器在选择调用哪个版本时遵循以下规则：
- 优先选择普通函数（如果匹配）
- 其次选择模板函数（如果能生成更匹配的版本）
- 最后考虑类型转换后的普通函数
cpp复制// 普通函数
void Print(int value) {
std::cout << "Integer: " << value << std::endl;
}
// 函数模板
template<typename T>
void Print(T value) {
std::cout << "Generic: " << value << std::endl;
}
// 函数模板特化（针对const char*）
template<>
void Print<const char*>(const char* value) {
std::cout << "C-string: " << value << std::endl;
}
int main() {
Print(10); // 调用普通函数
Print(3.14); // 调用模板函数
Print("Hello"); // 调用特化版本
Print<int>(10); // 显式调用模板函数
return 0;
}
注意：函数模板特化在实际开发中应谨慎使用，通常更好的选择是重载或使用C++20的概念(concepts)。
2.4 模板参数的非类型参数
除了类型参数，模板还可以接受非类型参数（如整型常量、指针等）：
cpp复制template<typename T, int Size>
class FixedArray {
public:
T& operator[](int index) {
return data[index];
}
private:
T data[Size];
};
int main() {
FixedArray<int, 10> arr; // 10个int的数组
FixedArray<double, 5> smallArr; // 5个double的数组
return 0;
}
这种技术在编译期已知大小的数据结构中非常有用，如std::array就是基于这种技术实现的。
3. 类模板：构建通用数据结构
3.1 类模板的基本概念
类模板允许我们定义可以处理任意类型的数据结构。与函数模板类似，类模板也是泛型编程的重要工具。STL中的vector、list、map等都是类模板的典型应用。
类模板的基本语法：
cpp复制template<typename T1, typename T2, ..., typename Tn>
class ClassName {
// 类成员定义
};
3.2 实现一个简单的栈类模板
让我们通过实现一个栈类模板来理解类模板的工作原理：
cpp复制template<typename T>
class Stack {
public:
explicit Stack(size_t capacity = 4)
: _array(new T[capacity]), _capacity(capacity), _size(0) {}
~Stack() { delete[] _array; }
void Push(const T& value) {
if (_size == _capacity) {
Resize(_capacity * 2);
}
_array[_size++] = value;
}
T Pop() {
if (_size == 0) {
throw std::out_of_range("Stack is empty");
}
return _array[--_size];
}
size_t Size() const { return _size; }
bool Empty() const { return _size == 0; }
private:
void Resize(size_t new_capacity) {
T* new_array = new T[new_capacity];
for (size_t i = 0; i < _size; ++i) {
new_array[i] = _array[i];
}
delete[] _array;
_array = new_array;
_capacity = new_capacity;
}
T* _array;
size_t _capacity;
size_t _size;
};
这个栈类模板可以用于任何类型，从基本类型到自定义类都可以：
cpp复制int main() {
Stack<int> intStack; // int类型的栈
Stack<std::string> strStack; // string类型的栈
intStack.Push(42);
strStack.Push("Hello");
return 0;
}
3.3 类模板的成员函数定义
类模板的成员函数可以在类内部定义（隐式内联），也可以在外部定义。外部定义时需要特殊的语法：
cpp复制template<typename T>
class Stack {
// ... 其他成员 ...
void Push(const T& value);
};
template<typename T>
void Stack<T>::Push(const T& value) {
if (_size == _capacity) {
Resize(_capacity * 2);
}
_array[_size++] = value;
}
重要提示：类模板的成员函数定义通常应该放在头文件中，因为模板代码需要在编译时可见。如果将定义放在.cpp文件中，可能会导致链接错误。
3.4 类模板的实例化
与函数模板不同，类模板必须显式实例化。每次使用不同的模板参数时，编译器都会生成一个全新的类：
cpp复制int main() {
Stack<int> stack1; // 实例化出int版本的Stack
Stack<double> stack2; // 实例化出double版本的Stack
Stack<Stack<int>> stack3; // 甚至可以嵌套！
return 0;
}
每个实例化的类都是完全独立的类型，它们之间没有继承关系或其他关联。
4. 类模板的高级应用
4.1 模板参数默认值
类模板可以像函数参数一样为模板参数提供默认值：
cpp复制template<typename T = int, size_t Capacity = 10>
class FixedStack {
// ... 实现类似前面的Stack ...
};
int main() {
FixedStack<> stack1; // 使用默认的int和容量10
FixedStack<double> stack2; // 指定T=double，使用默认容量10
FixedStack<char, 100> stack3; // 指定T=char，容量=100
return 0;
}
这种技术在STL中很常见，比如std::vector的分配器参数就有默认值。
4.2 成员函数模板
类模板内部还可以定义成员函数模板，这使得类模板更加灵活：
cpp复制template<typename T>
class DataHolder {
public:
DataHolder(const T& value) : _value(value) {}
template<typename U>
void Assign(const U& new_value) {
_value = new_value; // 需要T能够从U构造或赋值
}
template<typename Converter>
auto ConvertWith(Converter conv) -> decltype(conv(_value)) {
return conv(_value);
}
private:
T _value;
};
int main() {
DataHolder<int> holder(42);
holder.Assign(3.14); // 使用成员函数模板，将double赋给int
auto str = holder.ConvertWith([](int x) {
return std::to_string(x);
});
return 0;
}
4.3 类模板特化与偏特化
类模板可以像函数模板一样进行特化，包括完全特化和部分特化：
完全特化：为特定类型提供特殊实现
cpp复制template<>
class Stack<bool> {
// 专门针对bool类型的优化实现
// 可以用一个字节存储8个bool值
};
部分特化：为特定模式提供特殊实现
cpp复制template<typename T>
class Stack<T*> {
// 针对指针类型的特殊实现
};
特化技术可以用来优化特定类型的性能或提供特殊行为，但在现代C++中，很多情况下可以用继承、组合或策略模式等替代。
4.4 模板与友元
类模板可以声明友元函数或友元类，语法有些特殊：
cpp复制template<typename T>
class Box {
T content;
// 声明一个友元函数模板
template<typename U>
friend void Peek(const Box<U>& box);
};
template<typename T>
void Peek(const Box<T>& box) {
std::cout << box.content << std::endl; // 可以访问私有成员
}
5. 模板编程的实践技巧与陷阱
5.1 模板代码的组织方式
模板代码有一个重要特性：它必须在编译时完全可见。这导致了模板代码组织的一些特殊要求：
- 定义必须可见：模板的定义（不仅仅是声明）必须在使用它的每个翻译单元中可见
- 头文件包含：通常将模板的实现直接放在头文件中
- 显式实例化：对于大型项目，可以在一个.cpp文件中显式实例化模板，以减少编译时间
cpp复制// stack.h
template<typename T>
class Stack {
// 类定义和内联成员函数
};
// 非内联成员函数的定义也放在头文件中
template<typename T>
void Stack<T>::SomeMethod() {
// 实现
}
// stack_instantiations.cpp
#include "stack.h"
// 显式实例化常用类型
template class Stack<int>;
template class Stack<double>;
template class Stack<std::string>;
5.2 模板元编程基础
模板不仅可以用于泛型编程，还可以在编译期进行计算和类型操作，这被称为模板元编程：
cpp复制// 编译期计算阶乘
template<int N>
struct Factorial {
static const int value = N * Factorial<N-1>::value;
};
template<>
struct Factorial<0> {
static const int value = 1;
};
int main() {
const int fact5 = Factorial<5>::value; // 120，在编译期计算
return 0;
}
现代C++引入了constexpr等特性，使得很多模板元编程场景可以用更简单的方式实现。
5.3 类型特征与SFINAE
类型特征(Type Traits)和SFINAE(Substitution Failure Is Not An Error)是模板编程中的高级技术：
cpp复制#include <type_traits>
template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
AddOne(T value) {
return value + 1;
}
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
AddOne(T value) {
return value + 1.0;
}
这些技术在编写库代码时非常有用，但在应用代码中应谨慎使用，因为它们会增加代码复杂度。
5.4 常见陷阱与解决方案
-
链接错误：模板实现不可见
- 解决方案：确保模板定义在使用它的每个翻译单元中都可见
-
代码膨胀：过多模板实例化导致可执行文件增大
- 解决方案：使用显式实例化，或重构代码减少不必要的实例化
-
编译时间过长：复杂模板导致编译缓慢
- 解决方案：使用预编译头文件，模块化设计，或C++20的模块
-
错误信息难以理解：模板错误信息通常冗长晦涩
- 解决方案：使用static_assert提供清晰错误信息，或使用C++20概念
cpp复制template<typename T>
void Process(T value) {
static_assert(std::is_arithmetic<T>::value,
"Process() requires arithmetic types");
// 实现
}
6. C++20中的模板增强
6.1 概念(Concepts)
C++20引入了概念(Concepts)，极大地改善了模板编程的体验：
cpp复制#include <concepts>
template<std::integral T>
T AddIntegral(T a, T b) {
return a + b;
}
template<typename T>
requires std::floating_point<T>
T AddFloating(T a, T b) {
return a + b;
}
int main() {
AddIntegral(5, 3); // OK
// AddIntegral(3.14, 2.0); // 错误：不满足std::integral约束
AddFloating(3.14, 2.0); // OK
return 0;
}
概念使得模板约束更加清晰，错误信息更友好，是模板编程的重大进步。
6.2 缩写函数模板
C++20还引入了缩写函数模板语法，简化了简单模板的编写：
cpp复制auto add(auto a, auto b) {
return a + b;
}
// 等价于
template<typename T, typename U>
auto add(T a, U b) {
return a + b;
}
6.3 模板lambda表达式
C++20允许lambda表达式使用模板参数：
cpp复制auto make_adder = []<typename T>(T x) {
return [x]<typename U>(U y) { return x + y; };
};
int main() {
auto add5 = make_adder(5);
std::cout << add5(3) << std::endl; // 8
std::cout << add5(3.14) << std::endl; // 8.14
return 0;
}
这些新特性使得模板编程更加直观和易于使用，特别是在泛型算法和函数式编程场景中。