C++ 第二阶段：模板编程 - 第一节：函数模板与类模板
目录
一、模板编程的核心概念
1.1 什么是模板编程？
二、函数模板详解
2.1 函数模板的定义与使用
2.1.1 基本语法
2.1.2 示例：通用交换函数
2.1.3 类型推导规则
2.2 函数模板的注意事项
2.2.1 普通函数与函数模板的调用规则
2.2.2 隐式类型转换问题
2.2.3 函数模板的重载
三、类模板详解
3.1 类模板的定义与使用
3.1.1 基本语法
3.1.2 示例：通用 Pair 类
3.1.3 显式指定类型
3.2 类模板的注意事项
3.2.1 成员函数的实例化
3.2.2 分文件编写问题
3.2.3 特化与部分特化
四、函数模板与类模板的对比
五、模板编程的常见错误与解决方案
5.1 错误：类型推导失败
5.2 错误：类模板未显式指定类型
5.3 错误：分文件编写时未包含实现
六、总结
6.1 核心要点
6.2 最佳实践
一、模板编程的核心概念
1.1 什么是模板编程？
- 定义：模板编程是 C++ 中实现泛型编程的核心机制，通过将类型参数化，编写与具体数据类型无关的通用代码。
- 核心思想：
- 函数模板：通过类型参数化，定义可适用于多种数据类型的通用函数。
- 类模板：通过类型参数化，定义可适用于多种数据类型的通用类。
- 优势：
- 代码复用：避免为每种数据类型重复编写相同逻辑的代码。
- 类型安全：在编译时检查类型兼容性，减少运行时错误。
- 灵活性：支持对任意数据类型的通用操作（如排序、查找等）。
二、函数模板详解
2.1 函数模板的定义与使用
2.1.1 基本语法
template <typename T> // 或 template <class T>
返回类型 函数名(参数列表) {// 函数体
}2.1.2 示例：通用交换函数
// 函数模板定义
template <typename T>
void mySwap(T& a, T& b) {T temp = a;a = b;b = temp;
}int main() {int x = 10, y = 20;mySwap(x, y); // 自动类型推导：T = intstd::cout << "x = " << x << ", y = " << y << std::endl;double a = 3.14, b = 2.71;mySwap<double>(a, b); // 显式指定类型：T = doublestd::cout << "a = " << a << ", b = " << b << std::endl;return 0;
}2.1.3 类型推导规则
- 自动类型推导（隐式实例化）：
- 编译器根据传入参数的类型自动推导
T的具体类型。 - 要求：所有参数必须推导出一致的类型。
- 编译器根据传入参数的类型自动推导
- 显式类型指定（显式实例化）：
- 通过
<类型>显式指定模板参数的类型。 - 适用于类型不一致或需要强制指定类型的情况。
- 通过
2.2 函数模板的注意事项
2.2.1 普通函数与函数模板的调用规则
- 优先调用普通函数：
void myAdd(int a, int b) { /* 普通函数 */ } template <typename T> T myAdd(T a, T b) { return a + b; }int main() {int x = 10, y = 20;myAdd(x, y); // 优先调用普通函数myAdd<>(x, y); // 强制调用函数模板 }
2.2.2 隐式类型转换问题
- 自动类型推导不支持隐式类型转换：
char c = 'a'; int a = 10; mySwap(a, c); // 错误：无法自动推导 T 的类型 mySwap<int>(a, c); // 正确：显式指定类型后允许隐式转换
2.2.3 函数模板的重载
- 支持重载：
template <typename T> void print(T a) {std::cout << "Generic print: " << a << std::endl; }template <> void print<int>(int a) {std::cout << "Specialized print for int: " << a << std::endl; }int main() {print(3.14); // 调用通用模板print(10); // 调用特化版本 }
三、类模板详解
3.1 类模板的定义与使用
3.1.1 基本语法
template <typename T1, typename T2, ...>
class 类名 {// 类定义
};3.1.2 示例：通用 Pair 类
// 类模板定义
template <typename T>
class Pair {
public:T first;T second;Pair(T a, T b) : first(a), second(b) {}void print() const {std::cout << "(" << first << ", " << second << ")" << std::endl;}
};int main() {Pair<int> p1(10, 20); // T = intp1.print(); // 输出: (10, 20)Pair<std::string> p2("Hello", "World"); // T = std::stringp2.print(); // 输出: (Hello, World)return 0;
}3.1.3 显式指定类型
- 必须显式指定类型：
Pair<int, std::string> p3(100, "C++"); // 支持多个模板参数
3.2 类模板的注意事项
3.2.1 成员函数的实例化
- 延迟实例化：
- 类模板的成员函数只有在被调用时才会实例化。
- 例如：
p1.print()会实例化print()函数。
3.2.2 分文件编写问题
- 头文件中定义全部实现：
- 类模板的声明和定义通常放在头文件中，因为编译器需要在实例化时看到完整的定义。
- 如果分文件编写，需使用
#include "Pair.cpp"或使用export template（C++11 已弃用）。
3.2.3 特化与部分特化
-
完全特化：
template <> // 完全特化：T = int class Pair<int> { public:int first, second;void print() const { std::cout << "Specialized Pair<int>: (" << first << ", " << second << ")" << std::endl; } }; -
部分特化：
template <typename T> class Pair<T, T> { // 部分特化：当两个类型相同时 public:T first, second;void print() const { std::cout << "Partial specialization for Pair<T, T>" << std::endl; } };
四、函数模板与类模板的对比
| 特性 | 函数模板 | 类模板 |
|---|---|---|
| 类型参数化 | 函数的返回值和参数类型可参数化 | 类的数据成员和成员函数类型可参数化 |
| 实例化方式 | 自动类型推导或显式指定 | 必须显式指定类型 |
| 成员函数实例化时机 | 在函数调用时实例化 | 在成员函数被调用时实例化 |
| 分文件编写 | 可分文件编写（需包含实现文件） | 通常需将定义放在头文件中 |
| 特化支持 | 支持完全特化 | 支持完全特化和部分特化 |
五、模板编程的常见错误与解决方案
5.1 错误：类型推导失败
mySwap(10, 3.14); // 错误：无法推导出一致的 T解决方案：显式指定类型：
mySwap<double>(10, 3.14);5.2 错误：类模板未显式指定类型
Pair p(10, 20); // 错误：未指定模板参数解决方案：显式指定类型：
Pair<int> p(10, 20);5.3 错误：分文件编写时未包含实现
解决方案：将类模板的实现放在头文件中，或在源文件中显式实例化：
// Pair.cpp
template <typename T>
void Pair<T>::print() const {std::cout << "(" << first << ", " << second << ")" << std::endl;
}// 显式实例化
template class Pair<int>;
template class Pair<std::string>;六、总结
6.1 核心要点
- 函数模板：通过类型参数化实现通用函数，支持自动类型推导和显式指定类型。
- 类模板：通过类型参数化实现通用类，必须显式指定类型，成员函数延迟实例化。
- 模板编程的优势：代码复用、类型安全、灵活适应多种数据类型。
- 注意事项：处理隐式类型转换、分文件编写问题、特化需求。
6.2 最佳实践
- 优先使用函数模板：适用于通用算法（如排序、查找）。
- 使用类模板设计通用数据结构：如
std::vector、std::map。 - 避免过度特化：除非有特殊需求，否则保持通用性。
- 合理使用显式实例化：减少编译时间并避免链接错误。