7、变参模板（Variadic Templates）：参数包、sizeof... 运算符、递归展开参数包

变参模板，说白了就是让模板能接受任意数量的参数。我刚开始学C++那会儿，要实现一个支持任意参数个数的函数，得写一堆重载，或者用C风格的va_list，那叫一个痛苦。后来C++11引入了变参模板，这个问题才算真正解决。

你想想看，如果没有变参模板，printf这种函数怎么实现？要么用宏，要么用C的可变参数，类型安全就别想了。变参模板的出现，让编译期处理任意数量的类型和值成为了可能。

7.1 参数包（Parameter Pack）

参数包是变参模板的核心概念。它分为两种：模板参数包和函数参数包。

// 模板参数包：可以接受任意数量的类型
template<typename... Types>
class Tuple {};

// 函数参数包：可以接受任意数量的参数
template<typename... Args>
void print(Args... args) {}

这里的 typename... Types 就是模板参数包，Args... args 是函数参数包。注意那个省略号，它是关键标记。

7.2 sizeof... 运算符

sizeof... 运算符用来获取参数包中元素的个数。注意，它是在编译期计算的，不会产生运行时开销。

template<typename... Args>
void count_args(Args... args) {
    // 编译期就能知道参数个数
    constexpr size_t num = sizeof...(Args);
    std::cout << "参数个数: " << num << std::endl;
    
    // 也可以对函数参数包使用
    size_t num2 = sizeof...(args);
    std::cout << "函数参数个数: " << num2 << std::endl;
}

// 使用
count_args(1, 2.0, "hello");  // 输出: 参数个数: 3

7.3 递归展开参数包

这是变参模板最核心的技术。参数包本身不能直接遍历，但我们可以通过递归的方式，每次取出第一个参数，然后递归处理剩下的参数包。

// 基础模板：处理零个参数的情况（递归终止条件）
void print_all() {
    std::cout << std::endl;
}

// 递归模板：每次取出第一个参数
template<typename T, typename... Rest>
void print_all(T first, Rest... rest) {
    std::cout << first << " ";
    print_all(rest...);  // 递归调用，参数包减少一个
}

// 使用
print_all(1, 2.5, "hello", 'c');  // 输出: 1 2.5 hello c

为什么会这样？每次调用 print_all(rest...) 时，编译器会生成一个新的函数实例，参数包少了一个元素。当参数包为空时，调用无参版本，递归终止。

7.4 更复杂的递归模式

在实际项目中，我们经常需要更复杂的递归模式。比如计算参数的和：

// 终止条件
template<typename T>
T sum(T value) {
    return value;
}

// 递归展开
template<typename T, typename... Rest>
auto sum(T first, Rest... rest) {
    return first + sum(rest...);
}

// 使用
auto result = sum(1, 2, 3, 4, 5);  // 结果是15

嗯，这里要注意，auto 返回类型推导在C++14中才支持。如果是C++11，你需要用 decltype 或者 std::common_type 来处理返回类型。

7.5 参数包的展开位置

参数包可以在多个位置展开，不仅仅是函数参数列表。我整理了一下常见的展开场景：

展开位置	示例	说明
函数参数	func(args...)	展开为多个函数参数
初始化列表	{args...}	展开为初始化列表元素
基类列表	public Bases...	展开为多个基类
模板参数	Tuple<Types...>	展开为模板参数
捕获列表	[args...]	展开为lambda捕获

// 初始化列表展开的妙用
template<typename... Args>
void print_all_v2(Args... args) {
    // 利用初始化列表保证展开顺序
    (void)std::initializer_list<int>{(std::cout << args << " ", 0)...};
    std::cout << std::endl;
}

这个技巧很有意思。初始化列表的求值顺序是确定的（从左到右），所以我们可以用它来保证参数包的展开顺序。这在C++17的折叠表达式出现之前，是处理参数包展开顺序的常用手法。

7.6 实战：类型安全的printf

说了这么多理论，来看个实际例子。我在项目中曾经需要实现一个类型安全的日志系统，变参模板是核心：

// 基础版本：处理格式化字符串和参数
template<typename... Args>
std::string format(const std::string& fmt, Args... args) {
    // 这里用到了C++17的折叠表达式
    std::ostringstream oss;
    size_t pos = 0;
    size_t arg_index = 0;
    
    // 实际实现会更复杂，这里展示核心思路
    ((oss << args), ...);
    
    return oss.str();
}

// 更实用的版本：带类型检查
template<typename T>
void log_value(std::ostream& os, const T& value) {
    if constexpr (std::is_arithmetic_v<T>) {
        os << value;
    } else if constexpr (std::is_same_v<T, std::string>) {
        os << "\"" << value << "\"";
    } else {
        os << "<unknown type>";
    }
}

template<typename... Args>
void log(const std::string& message, Args... args) {
    std::cout << "[LOG] " << message << ": ";
    (log_value(std::cout, args), ...);
    std::cout << std::endl;
}

7.7 知识体系总览

下面这张图展示了变参模板的核心知识结构，我把它画成了流程图，方便你理解各个概念之间的关系：

变参模板是C++模板元编程的基石之一。它让我们能够写出既灵活又类型安全的代码。我个人觉得，掌握了变参模板，你就掌握了现代C++泛型编程的钥匙。很多高级技术，比如类型列表、编译期算法、元函数，都离不开它。

---

公众号:蓝海资料掘金营，微信deep3321