函数模板

函数模板是 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 替代