可变参数模板与折叠

当函数需要接受「任意数量、任意类型」的参数时,C++11 的可变参数模板(Variadic Templates)提供了类型安全的解决方案;而 C++17 的折叠表达式(Fold Expressions)则让参数包的处理从递归走向了一行搞定。本节将带你从基础语法到实用模式,全面掌握这两项关键技术。

1. 可变参数模板 (Variadic Templates)

可变参数模板允许模板接受零个或多个参数。语法核心是省略号 ...,它出现在不同位置有不同含义:

// 类型参数包:零个或多个类型
template<typename... Ts>
void foo(Ts... args);  // args 是函数参数包

// 非类型参数包 (C++17):零个或多个值
template<auto... Vs>
struct ValueList {};

// 混合使用
template<typename T, typename... Rest>
void bar(T first, Rest... rest);
命名惯例:Ts(或 Args)表示类型参数包,args(或 values)表示函数参数包。省略号在声明侧紧跟类型名,在使用侧紧跟参数名。

一个最简单的可变参数函数模板:

#include <iostream>

// 接受任意数量、任意类型的参数
template<typename... Args>
void ignore_all(Args... args) {
    // 目前什么都不做——我们稍后学习如何展开 args
    std::cout << "收到 " << sizeof...(args) << " 个参数\n";
}

int main() {
    ignore_all();              // 收到 0 个参数
    ignore_all(1, 2.5, "hi"); // 收到 3 个参数
}

2. 参数包展开

2.1 sizeof... 运算符

sizeof...(pack) 在编译期返回参数包中的元素个数,结果类型为 std::size_t:

template<typename... Ts>
constexpr std::size_t count() {
    return sizeof...(Ts);  // 对类型包求大小
}

template<typename... Ts>
void f(Ts... args) {
    constexpr auto n = sizeof...(args);  // 对函数参数包求大小
    static_assert(n >= 1, "至少需要一个参数");
}

static_assert(count<int, double, char>() == 3);

2.2 递归展开模式(C++11 风格)

在 C++17 折叠表达式出现之前,展开参数包的经典方式是递归:一个基准情况(base case)处理零或一个参数,递归情况剥离第一个参数并继续处理剩余部分。

#include <iostream>

// 基准情况:无参数时结束递归
void print() {
    std::cout << '\n';
}

// 递归情况:处理第一个参数,递归剩余
template<typename T, typename... Rest>
void print(T first, Rest... rest) {
    std::cout << first;
    if constexpr (sizeof...(rest) > 0) {
        std::cout << ", ";
    }
    print(rest...);  // 包展开:rest... 展开为剩余参数列表
}

int main() {
    print(1, 2.5, "hello", 'X');
    // 输出:1, 2.5, hello, X
}
注意:递归模式中,每次递归都会实例化一个新的函数模板。print(1, 2.5, "hello", 'X') 会生成 4 个不同的 print 实例加上一个基准重载,共 5 个函数。参数越多,编译时间越长。

2.3 展开上下文

参数包可以在多种上下文中展开,不仅限于函数调用:

template<typename... Ts>
void expand_demo(Ts... args) {
    // 1) 函数调用参数列表
    auto t = std::make_tuple(args...);

    // 2) 初始化列表(利用逗号展开技巧,C++11)
    int dummy[] = { (std::cout << args << ' ', 0)... };
    (void)dummy;

    // 3) 对每个参数施加变换后展开
    auto t2 = std::make_tuple((args * 2)...);  // 每个 arg 乘以 2
}

// 4) 基类列表展开
template<typename... Bases>
struct Derived : Bases... {
    using Bases::operator()...;  // C++17: using 声明展开
};

3. 折叠表达式 (Fold Expressions, C++17)

折叠表达式让我们对参数包直接执行二元运算符归约,无需递归。有四种形式:

形式 语法 展开结果
一元左折叠 (... op args) ((a op b) op c)
一元右折叠 (args op ...) (a op (b op c))
二元左折叠 (init op ... op args) ((init op a) op b) op c
二元右折叠 (args op ... op init) a op (b op (c op init))
助记:省略号靠左 → 左折叠(从左往右结合);省略号靠右 → 右折叠(从右往左结合)。有初始值 → 二元折叠。

3.1 求和示例

// 一元左折叠:(... + args) → ((a + b) + c)
template<typename... Args>
auto sum(Args... args) {
    return (... + args);
}

// 二元左折叠:带初始值,空包安全
template<typename... Args>
auto safe_sum(Args... args) {
    return (0 + ... + args);  // 空包时返回 0
}

int main() {
    auto s1 = sum(1, 2, 3, 4, 5);        // 15
    auto s2 = safe_sum();                  // 0(空包)
    auto s3 = sum(1.5, 2.5, 3.0);         // 7.0
}

3.2 打印所有参数

#include <iostream>

// 用逗号运算符 + 左折叠,一行搞定!
template<typename... Args>
void print(Args... args) {
    ((std::cout << args << ' '), ...);
    std::cout << '\n';
}

// 等价展开:(std::cout << a << ' '), (std::cout << b << ' '), ...

int main() {
    print(1, 2.5, "hello", 'X');
    // 输出:1 2.5 hello X
}

3.3 逻辑折叠

// 所有条件都为真?
template<typename... Bools>
constexpr bool all_of(Bools... bs) {
    return (... && bs);  // 空包时返回 true(&& 的单位元)
}

// 任一条件为真?
template<typename... Bools>
constexpr bool any_of(Bools... bs) {
    return (... || bs);  // 空包时返回 false(|| 的单位元)
}

static_assert(all_of(true, true, true));
static_assert(!all_of(true, false, true));
static_assert(any_of(false, false, true));
static_assert(!any_of());  // 空包:false
空包规则:对于一元折叠,当参数包为空时,只有 &&(→true)、||(→false)和逗号运算符(→void())有合法的默认值。其他运算符的空包折叠是编译错误,请使用二元折叠提供初始值。

4. 实用折叠模式

4.1 求和与求积

template<typename... Args>
auto sum(Args... args) { return (... + args); }

template<typename... Args>
auto product(Args... args) { return (... * args); }

auto s = sum(1, 2, 3, 4, 5);      // 15
auto p = product(1, 2, 3, 4, 5);  // 120

4.2 带分隔符打印

#include <iostream>

template<typename T, typename... Rest>
void print_sep(T first, Rest... rest) {
    std::cout << first;
    // 逗号折叠:先输出分隔符,再输出参数
    ((std::cout << ", " << rest), ...);
    std::cout << '\n';
}

int main() {
    print_sep("apple", "banana", "cherry");
    // 输出:apple, banana, cherry
}

4.3 Push all — 批量插入容器

#include <vector>

template<typename T, typename... Args>
void push_all(std::vector<T>& vec, Args&&... args) {
    (vec.push_back(std::forward<Args>(args)), ...);
}

int main() {
    std::vector<int> v;
    push_all(v, 1, 2, 3, 4, 5);
    // v = {1, 2, 3, 4, 5}
}

4.4 类型检查 — 所有参数是否为同一类型

#include <type_traits>

template<typename T, typename... Rest>
constexpr bool all_same = (std::is_same_v<T, Rest> && ...);

static_assert(all_same<int, int, int>);
static_assert(!all_same<int, int, double>);

5. sizeof... 运算符详解

sizeof... 是在编译期求值的运算符,可用于 static_assert、if constexpr 和模板参数等场景:

#include <type_traits>

// 限制参数个数
template<typename... Args>
void at_least_two(Args... args) {
    static_assert(sizeof...(Args) >= 2, "需要至少两个参数");
    // ...
}

// 用于 if constexpr 分支
template<typename T, typename... Rest>
auto first_or_default(T val, Rest... rest) {
    if constexpr (sizeof...(rest) == 0) {
        return val;  // 只有一个参数时直接返回
    } else {
        return val;  // 有多个参数时也返回第一个
    }
}

// 用于数组大小
template<typename... Args>
void store(Args... args) {
    // 创建与参数包等大的数组
    int results[sizeof...(args)] = { static_cast<int>(args)... };
}

6. if constexpr 与参数包

C++17 的 if constexpr 允许在编译期丢弃无关分支,与可变参数模板结合时,可以替代传统的递归终止重载:

#include <iostream>

// 传统方式需要两个重载(基准 + 递归)
// C++17 方式:只需一个函数模板
template<typename T, typename... Rest>
void print(T first, Rest... rest) {
    std::cout << first;
    if constexpr (sizeof...(rest) > 0) {
        std::cout << ", ";
        print(rest...);  // 仅在包非空时实例化
    } else {
        std::cout << '\n';
    }
}

int main() {
    print(42, 3.14, "hello");
    // 输出:42, 3.14, hello
}
if constexpr 的优势:不需要额外的基准情况重载函数,代码更集中、更易读。丢弃的分支中即使有语法错误(只要不依赖于模板参数),也不会引发编译错误。

更复杂的例子——根据参数类型执行不同操作:

#include <iostream>
#include <string>
#include <type_traits>

template<typename T, typename... Rest>
void describe(T val, Rest... rest) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << val << " (整数)";
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << val << " (浮点数)";
    } else {
        std::cout << val << " (其他)";
    }

    if constexpr (sizeof...(rest) > 0) {
        std::cout << ", ";
        describe(rest...);
    } else {
        std::cout << '\n';
    }
}

int main() {
    describe(42, 3.14, std::string("hello"));
    // 输出:42 (整数), 3.14 (浮点数), hello (其他)
}

7. 综合实例

7.1 类型安全的 print 函数

实现类似 Python 的 print("name: {}, age: {}", name, age),使用折叠+递归替换占位符:

#include <iostream>
#include <string_view>
#include <sstream>
#include <stdexcept>

// 在格式串中找到第一个 {} 并替换为 val
template<typename T>
std::string replace_first(std::string_view fmt, T const& val) {
    auto pos = fmt.find("{}");
    if (pos == std::string_view::npos) {
        throw std::runtime_error("多余的参数,没有对应的 {} 占位符");
    }
    std::ostringstream oss;
    oss << fmt.substr(0, pos) << val << fmt.substr(pos + 2);
    return oss.str();
}

// 无参数版本:直接输出格式串
void print(std::string_view fmt) {
    std::cout << fmt << '\n';
}

// 可变参数版本:逐个替换 {}
template<typename T, typename... Rest>
void print(std::string_view fmt, T const& first, Rest const&... rest) {
    auto result = replace_first(fmt, first);
    print(std::string_view(result), rest...);
}

int main() {
    std::string name = "张三";
    int age = 25;
    double score = 95.5;

    print("姓名: {}, 年龄: {}, 分数: {}", name, age, score);
    // 输出:姓名: 张三, 年龄: 25, 分数: 95.5
}

7.2 Tuple-like make 函数

#include <tuple>
#include <utility>
#include <iostream>

// 完美转发所有参数到 tuple
template<typename... Args>
auto make_stuff(Args&&... args) {
    return std::tuple{std::forward<Args>(args)...};
}

// 使用 C++17 结构化绑定解包
int main() {
    auto [name, age, score] = make_stuff("Alice", 30, 99.5);
    std::cout << name << " is " << age
              << " years old, score: " << score << '\n';
}

7.3 可变参数 max/min

#include <type_traits>

// 两个参数的基础版本
template<typename T>
constexpr T max_of(T a, T b) {
    return a > b ? a : b;
}

// 可变参数版本:折叠无法直接用于自定义二元函数
// 使用 if constexpr + 递归
template<typename T, typename... Rest>
constexpr auto max_of(T first, Rest... rest) {
    if constexpr (sizeof...(rest) == 0) {
        return first;
    } else {
        auto rest_max = max_of(rest...);
        using Common = std::common_type_t<T, decltype(rest_max)>;
        return static_cast<Common>(first) > static_cast<Common>(rest_max)
             ? static_cast<Common>(first)
             : static_cast<Common>(rest_max);
    }
}

// 编译期求值
static_assert(max_of(3, 1, 4, 1, 5, 9, 2, 6) == 9);
static_assert(max_of(1.5, 2.7, 0.3) == 2.7);

7.4 事件分发器(多继承 + 折叠)

#include <iostream>

// 多个 handler 的聚合
template<typename... Handlers>
struct Dispatcher : Handlers... {
    using Handlers::operator()...;  // C++17 using 展开
};

// CTAD 推导指引
template<typename... Handlers>
Dispatcher(Handlers...) -> Dispatcher<Handlers...>;

int main() {
    auto dispatch = Dispatcher{
        [](int i)    { std::cout << "int: " << i << '\n'; },
        [](double d) { std::cout << "double: " << d << '\n'; },
        [](auto s)   { std::cout << "other: " << s << '\n'; }
    };

    dispatch(42);       // int: 42
    dispatch(3.14);     // double: 3.14
    dispatch("hello");  // other: hello
}
常见错误:
  • 忘记省略号位置:args...(展开)vs ...args(声明)是不同的。
  • 一元折叠空包:除 &&、||、逗号外,空包折叠是编译错误。务必使用二元折叠或 static_assert 保证非空。
  • 递归无终止:忘记写基准情况会导致无限递归实例化。
  • 展开位置错误:f(args)... 表示展开为多个 f(arg) 调用,而 f(args...) 是将所有参数传入一次调用。

本章小结

  • template<typename... Ts> 声明类型参数包,template<auto... Vs> 声明非类型参数包。
  • sizeof...(pack) 在编译期获取包大小,可用于 static_assert 和 if constexpr。
  • C++11 风格:递归 + 基准情况展开参数包。C++17 风格:折叠表达式一行搞定。
  • 四种折叠形式:一元左/右折叠、二元左/右折叠。省略号方向决定结合方向。
  • 实用模式:求和、逻辑判断、批量操作(push_back)、带分隔符输出。
  • if constexpr + sizeof... 取代基准重载,让递归代码更简洁。
  • 多继承 + using...展开 实现 overloaded lambda 分发器。