函数模板
函数模板是 C++ 泛型编程的基石。它让你编写一次代码,就能适用于多种类型——无需复制粘贴,无需牺牲类型安全。本章从"为什么需要模板"出发,逐步掌握模板声明、参数推导、C++20 简写语法、非类型参数和重载规则。
为什么需要模板
假设你需要一个返回两者中较大值的函数。没有模板时,你不得不为每种类型各写一个版本:
// 没有模板——每种类型写一遍
int max_val(int a, int b) { return a > b ? a : b; }
double max_val(double a, double b) { return a > b ? a : b; }
std::string max_val(std::string a, std::string b) { return a > b ? a : b; }
这三个函数的逻辑完全相同,唯一的差异是类型。如果日后要修改比较逻辑(例如改为 >=),你必须同步修改所有版本——这就是 代码重复 带来的维护噩梦。
函数模板的解决方案:写一次,编译器为你按需生成:
template<typename T>
T max_val(T a, T b) {
return a > b ? a : b;
}
// 使用时编译器自动生成对应类型的版本
int x = max_val(3, 7); // T = int
double y = max_val(3.14, 2.71); // T = double
为什么叫 max_val 而不是 max? 标准库已经提供了 std::max,为避免命名冲突,示例中使用 max_val。实际项目中请直接使用 std::max。
函数模板基础语法
函数模板的声明由 template 关键字加尖括号中的参数列表开头:
template<typename T> // 声明一个类型参数 T
T max_val(T a, T b) { // T 同时用于参数类型和返回类型
return a > b ? a : b;
}
typename 与 class 等价
在模板参数列表中,typename 和 class 完全等价:
template<typename T> // 推荐写法
template<class T> // 完全等价,老代码中常见
现代 C++ 社区普遍推荐使用 typename,因为它更准确地表达"这是一个类型参数"的含义——毕竟 T 可以是 int、double 这样的基本类型,而非只能是 class。
调用方式:显式指定 vs 隐式推导
// 显式指定模板参数
int a = max_val<int>(1, 2);
// 隐式推导——编译器从实参类型推断 T
int b = max_val(1, 2); // T 推导为 int
double c = max_val(3.0, 4.0); // T 推导为 double
大多数情况下编译器能自动推导,无需显式指定。但在某些特殊情况下(推导失败或需要类型转换),显式指定是必需的。
模板参数推导
编译器通过分析函数调用时传入的实参类型来推导模板参数。这个过程称为 模板参数推导(Template Argument Deduction)。
推导的基本规则
template<typename T>
T max_val(T a, T b);
max_val(1, 2); // OK: 两个实参都是 int,T = int
max_val(1.5, 2.5); // OK: 两个实参都是 double,T = double
推导失败的情况
当同一个模板参数 T 从不同实参推导出不同类型时,推导失败:
max_val(1, 2.5); // 错误!第一个参数推导 T=int,第二个推导 T=double
// 编译器不知道该选哪个,拒绝编译
解决方案
方案一:显式指定模板参数
max_val<double>(1, 2.5); // T=double,int 隐式转换为 double
方案二:使用多个模板参数
template<typename T, typename U>
auto max_val(T a, U b) {
return a > b ? a : b; // 返回类型由编译器推导
}
max_val(1, 2.5); // OK: T=int, U=double, 返回 double
方案三:使用 std::common_type
#include <type_traits>
template<typename T, typename U>
std::common_type_t<T, U> max_val(T a, U b) {
return a > b ? a : b;
}
// std::common_type_t<int, double> 就是 double
推导小贴士:模板参数推导不会进行隐式类型转换。如果你希望传入不同类型的参数,要么使用多个模板参数,要么显式指定类型。
auto 参数(C++20 简写函数模板)
C++20 引入了一种更简洁的写法:直接在函数参数中使用 auto,编译器会自动将其转化为模板:
// C++20 简写函数模板
auto add(auto a, auto b) {
return a + b;
}
// 等价于:
template<typename T, typename U>
auto add(T a, U b) {
return a + b;
}
每个 auto 参数各自引入一个独立的模板参数。也就是说 a 和 b 可以是不同类型。
使用场景
// 简单的工具函数——用 auto 参数非常合适
auto square(auto x) { return x * x; }
auto print_twice(const auto& val) {
std::cout << val << ", " << val << '\n';
}
// 使用
std::cout << square(5) << '\n'; // 25
std::cout << square(2.5) << '\n'; // 6.25
print_twice("hello"s); // hello, hello
何时使用简写语法:当函数体很短、逻辑简单、不需要在函数体内引用类型名时,auto 参数语法更简洁。如果需要在函数体中用到类型名(如声明同类型局部变量),仍需显式 template<typename T>。
多模板参数
当函数参数类型不同时,使用多个模板参数:
template<typename T, typename U>
auto add(T a, U b) {
return a + b; // 返回类型由 auto 推导
}
auto result = add(1, 2.5); // T=int, U=double, 返回 double
返回类型推导
C++14 起,auto 返回类型会让编译器从 return 语句推导实际类型。这对多模板参数函数尤为实用:
template<typename T, typename U>
auto multiply(T a, U b) {
return a * b; // int * double -> double
}
尾置返回类型(Trailing Return Type)
如果你需要更明确地控制返回类型,可以使用尾置返回类型:
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
return a + b;
}
decltype(a + b) 告诉编译器:返回类型就是 a + b 表达式的结果类型。这种写法在 C++11/14 中很常见,C++14 的 auto 推导使其在大多数场景下不再必需。
// 实际示例:安全除法
template<typename T, typename U>
auto safe_divide(T numerator, U denominator)
-> std::optional<decltype(numerator / denominator)>
{
if (denominator == 0) return std::nullopt;
return numerator / denominator;
}
auto result = safe_divide(10, 3); // optional<int>{3}
auto bad = safe_divide(1.0, 0.0); // optional<double>{nullopt}
非类型模板参数(NTTP)
模板参数不一定是类型——也可以是编译期已知的值。这就是 非类型模板参数(Non-Type Template Parameter):
template<int N>
std::array<int, N> make_iota_array() {
std::array<int, N> arr{};
for (int i = 0; i < N; ++i) {
arr[i] = i;
}
return arr;
}
auto arr = make_iota_array<5>(); // {0, 1, 2, 3, 4}
NTTP 的常见用途
// 编译期确定的缓冲区大小
template<std::size_t BufferSize>
class FixedBuffer {
std::array<char, BufferSize> data_{};
public:
constexpr std::size_t capacity() const { return BufferSize; }
};
// 编译期配置
template<int Precision>
double round_to(double value) {
constexpr double factor = []() {
double f = 1.0;
for (int i = 0; i < Precision; ++i) f *= 10.0;
return f;
}();
return std::round(value * factor) / factor;
}
double pi = round_to<3>(3.14159265); // 3.142
C++20 扩展:更多类型作为 NTTP
C++20 大幅扩展了 NTTP 的可用类型。现在浮点数和满足特定条件的类类型都可作为 NTTP:
// C++20: 浮点数作为 NTTP
template<double Factor>
double scale(double value) {
return value * Factor;
}
double result = scale<2.5>(10.0); // 25.0
// C++20: 字面量类类型作为 NTTP
struct Color {
int r, g, b;
};
template<Color C>
void set_background() {
// 编译期已知颜色值
std::cout << "RGB(" << C.r << "," << C.g << "," << C.b << ")\n";
}
set_background<Color{255, 128, 0}>(); // RGB(255,128,0)
注意:C++20 的浮点 NTTP 和类类型 NTTP 需要编译器支持。GCC 11+、Clang 13+、MSVC 19.29+ 均已支持浮点 NTTP。类类型 NTTP 要求该类型是字面量类型(literal type)且所有成员都是公开的。
函数模板重载
函数模板可以与其他函数模板或普通函数共存,形成重载集。编译器根据 最佳匹配 规则选择调用哪个版本。
普通函数优先于模板
// 函数模板
template<typename T>
T max_val(T a, T b) {
std::cout << "template version\n";
return a > b ? a : b;
}
// 普通函数重载(针对 const char*)
const char* max_val(const char* a, const char* b) {
std::cout << "const char* version\n";
return std::strcmp(a, b) > 0 ? a : b;
}
max_val(1, 2); // 调用模板版本,T=int
max_val("abc", "xyz"); // 调用普通函数版本(精确匹配优先)
当普通函数能完全匹配实参类型时,编译器优先选择普通函数而非模板实例化。这让你可以为特定类型提供优化或特殊逻辑的实现。
模板之间的重载
// 通用版本:一个参数
template<typename T>
T absolute(T value) {
return value < 0 ? -value : value;
}
// 重载:两个参数版本(返回较大的绝对值)
template<typename T>
T absolute(T a, T b) {
return absolute(a) > absolute(b) ? absolute(a) : absolute(b);
}
absolute(-5); // 调用单参数版本 -> 5
absolute(-3, 2); // 调用双参数版本 -> 3
重载的最佳实践
// 示例:print 的多种重载协同工作
#include <iostream>
#include <string_view>
#include <ranges>
// 通用版本
template<typename T>
void print(const T& value) {
std::cout << value << '\n';
}
// 特化:容器类型(使用 C++20 ranges)
template<std::ranges::range R>
void print(const R& container) {
std::cout << '[';
bool first = true;
for (const auto& elem : container) {
if (!first) std::cout << ", ";
std::cout << elem;
first = false;
}
std::cout << "]\n";
}
// 使用
print(42); // 42
print("hello"sv); // hello
print(std::vector{1, 2, 3, 4}); // [1, 2, 3, 4]
避免过度重载:函数模板重载决议的规则相当复杂。如果你发现自己需要仔细推敲哪个重载会被选中,考虑使用 Concepts(下一章)来约束模板——它们让重载意图更加清晰,编译错误信息也更友好。
本章小结
- 函数模板 消除类型重复:一份代码,多种类型自动实例化
template<typename T>声明类型参数;typename与class等价,推荐typename- 模板参数推导 从实参自动确定类型;同一参数推导出不同类型时失败
- C++20 auto 参数 是简写函数模板,每个
auto引入独立类型参数 - 多模板参数 配合
auto返回类型或尾置返回类型处理混合类型 - 非类型模板参数 允许传入编译期值(整数、C++20 浮点/类类型)
- 重载规则:普通函数精确匹配优先于模板;复杂场景用 Concepts 替代