一、概述

1.1 函数模板的定义

函数模板是 C++ 泛型编程的核心，它允许定义带类型参数的函数原型，经编译器实例化后生成不同数据类型的函数，本质上是编译期指令。

1.2 函数模板的优势

函数模板的核心优势体现在：

  • 代码复用：类型参数化使一套模板适配多种数据类型，减少重复代码

  • 类型安全：利用静态类型检查，规避编译阶段类型转换错误

  • 高效执行：实例化函数直接嵌入，无运行时额外开销

1.3 应用场景

函数模板常用于 STL 容器与算法设计、链表 / 栈等数据结构的类型无关实现，以及排序、查找等通用算法的多态封装。

二、基础语法

2.1 模板声明

函数模板的语法结构遵循以下范式：

1
2
3
4
template <typename T>
返回类型 函数名 (参数列表) {
    // 函数体实现
}

其中，typename关键字用于声明类型参数，class关键字在此语境下具备完全等价语义；T作为类型参数占位符，可根据实际需求替换为任意合法标识符。

2.2 简单示例：交换函数

以数据交换操作为例，其模板实现如下：

1
2
3
4
5
6
template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

编译器通过参数类型推导机制完成模板实例化：

1
2
3
4
int x = 5, y = 10;
swap(x, y);  // 实例化为int类型交换函数
double a = 3.14, b = 2.71;
swap(a, b);  // 实例化为double类型交换函数

2.3 显式指定模板参数

当类型推导存在歧义时，需采用显式模板参数指定方式：

1
2
3
4
5
6
template <typename T>
T add(T a, T b) {
    return a + b;
}
// 显式指定模板参数类型
auto result = add<double>(2, 3.5);  // 生成double类型add函数实例

2.4 多参数模板

支持多类型参数的模板定义语法如下：

1
2
3
4
template <typename T1, typename T2>
void printPair(T1 first, T2 second) {
    std::cout << "(" << first << ", " << second << ")" << std::endl;
}

示例调用：

1
2
printPair<int, const char*>(10, "hello"); 
printPair<double, bool>(3.14, true);

三、高级特性

3.1 模板特化

模板特化机制允许针对特定类型提供定制化实现，其优先级高于通用模板版本。特化语法结构为：

1
2
3
4
template <>
返回类型 函数名 <特化类型>(参数列表) {
    // 特化实现逻辑
}

以字符串类型交换函数特化为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 通用模板定义
template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}
// const char*类型特化实现
template <>
void swap<const char*>(const char*& a, const char*& b) {
    const char* temp = a;
    a = b;
    b = temp;
}

3.2 模板重载

函数模板支持基于参数列表的重载机制：

1
2
3
4
5
6
7
8
9
10
// 双参数模板
template <typename T>
T max(T a, T b) {
    return a > b ? a : b;
}
// 三参数重载模板
template <typename T>
T max(T a, T b, T c) {
    return max(max(a, b), c);
}

3.3 可变参数模板

C++11 引入的可变参数模板技术支持参数数量可变的模板定义：

1
2
3
4
5
6
7
8
9
10
// 递归终止函数
void print() {
    std::cout << std::endl;
}
// 可变参数模板函数
template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...);
}

调用示例：

1
print(1, 2.5, "hello", true);

3.4 类型约束与 SFINAE

SFINAE（Substitution Failure Is Not An Error）机制通过模板替换过程中的类型推导规则，实现类型约束功能。以算术类型约束为例：

1
2
3
4
5
6
#include <type_traits>
template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
add(T a, T b) {
    return a + b;
}

上述代码利用std::enable_if元函数，在模板实例化阶段进行类型合法性检查，仅当T为算术类型时才生成有效函数实例。

四、注意事项

4.1 模板定义位置

由于模板实例化依赖完整定义，其声明与实现必须共存于同一编译单元。常规做法是将模板代码封装于头文件中，避免因分离编译导致的链接错误。

4.2 类型推断限制

C++ 类型推导机制仅支持基于函数参数的类型推断，无法依据返回值进行推导。例如：

1
2
3
4
5
6
7
8
template <typename T>
T create() {
    return T();
}
// 错误：无法推导类型
auto obj = create(); 
// 正确：显式指定类型
auto obj = create<int>();

4.3 模板实例化

模板实例化分为隐式实例化（调用时自动生成）与显式实例化（编译期预先定义）：

1
2
3
4
5
6
template <typename T>
T square(T x) {
    return x * x;
}
// 显式实例化int类型版本
template int square(int x);

4.4 常见错误：未定义的引用

当模板操作涉及类型不支持的操作符时，将在实例化阶段触发编译错误：

1
2
3
4
5
6
template <typename T>
T divide(T a, T b) {
    return a / b;  // 非数值类型将引发编译错误
}
std::string s1 = "hello", s2 = "world";
divide(s1, s2);  // 编译期类型检查失败