折叠表达式：让可变参数模板的展开变得优雅

说实话，我第一次看到可变参数模板的时候，心里是有点发怵的。递归展开、辅助函数、重载……写起来总觉得不够痛快。直到 C++17 带来了折叠表达式，我才真正觉得「嗯，这才对嘛」。

折叠表达式，说白了就是让参数包（parameter pack）的展开变得像普通表达式一样自然。你不需要再写那些递归终止函数，也不需要搞什么 SFINAE 技巧。一行代码，搞定所有参数的运算。

折叠表达式的四种形态

折叠表达式有四种基本形态，我习惯把它们分成两类：一元折叠和二元折叠。每种又分左折叠和右折叠。别被这些术语吓到，其实很好理解。

形态	语法	展开结果（以 args 为例）
一元右折叠	(args op ...)	(arg1 op (arg2 op (arg3 op ...)))
一元左折叠	(... op args)	(((arg1 op arg2) op arg3) op ...)
二元右折叠	(args op ... op init)	(arg1 op (arg2 op (... op init)))
二元左折叠	(init op ... op args)	(((init op arg1) op arg2) op ...)

你可能会问：「左和右有什么区别？」其实关键就在于结合顺序。左折叠从左往右结合，右折叠从右往左结合。对于加法这种可交换运算，结果一样。但对于减法、除法，差别就大了。

实战：求和函数的进化史

先看一个最简单的例子——求和。我记得以前用 C++11 写可变参数模板求和，得写两个函数：一个递归终止函数，一个递归展开函数。代码量翻倍不说，可读性也差。

// C++11 风格：递归展开
template<typename T>
T sum(T t) { return t; }

template<typename T, typename... Args>
T sum(T first, Args... rest) {
    return first + sum(rest...);
}

// C++17 风格：折叠表达式
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 一元右折叠
}

看到了吗？一行代码，搞定所有。我个人习惯用一元右折叠，因为大多数场景下结合顺序不重要。但如果你需要控制顺序，那就得小心了。

避坑指南：减法与顺序

我曾经在写一个计算器模块时，用折叠表达式实现减法。结果发现结果总是不对。你猜怎么着？我用了右折叠，但减法需要左折叠。

// 减法：左折叠 vs 右折叠
template<typename... Args>
auto subtract_left(Args... args) {
    return (... - args);  // (((a - b) - c) - d)
}

template<typename... Args>
auto subtract_right(Args... args) {
    return (args - ...);  // (a - (b - (c - d)))
}

// 调用
subtract_left(10, 3, 2);   // 结果: ((10-3)-2) = 5
subtract_right(10, 3, 2);  // 结果: (10-(3-2)) = 9

嗯，这里要注意：对于非可交换运算，一定要想清楚结合顺序。我建议在代码里加个注释，明确说明你用的是左还是右折叠。不然三个月后你自己都忘了。

折叠表达式与逗号运算符

折叠表达式最强大的用法之一，是和逗号运算符配合。逗号运算符会依次执行每个表达式，返回最后一个的值。这在「对每个参数执行某个操作」的场景下特别好用。

// 打印所有参数
template<typename... Args>
void print_all(Args... args) {
    (std::cout << ... << args) << '\n';  // 注意：这是二元左折叠
}

// 对每个参数调用函数
template<typename Func, typename... Args>
void for_each(Func f, Args... args) {
    (f(args), ...);  // 逗号表达式的一元右折叠
}

// 使用
for_each([](auto x) { std::cout << x << ' '; }, 1, 2.5, "hello");
// 输出: 1 2.5 hello

我在项目中经常用这种模式来做参数校验。比如检查所有参数是否都大于零：

template<typename... Args>
bool all_positive(Args... args) {
    return ((args > 0) && ...);  // 逻辑与折叠
}

// 或者检查是否有任何一个满足条件
template<typename... Args>
bool any_negative(Args... args) {
    return ((args < 0) || ...);  // 逻辑或折叠
}

知识体系：折叠表达式的核心逻辑

下面这张图帮你理清折叠表达式的整体脉络。从参数包到展开结果，每一步都很清晰。

高级用法：与类型萃取结合

折叠表达式不只是用来处理值的。它和类型萃取（type traits）结合，能写出非常优雅的编译期判断代码。

// 检查所有类型是否都是整数类型
template<typename... Args>
struct all_integral : std::conjunction<std::is_integral<Args>...> {};

// C++17 折叠表达式版本
template<typename... Args>
constexpr bool all_integral_v = (std::is_integral_v<Args> && ...);

// 使用
static_assert(all_integral_v<int, short, long>);  // true
static_assert(!all_integral_v<int, float, long>); // false

你想想看，以前要实现这种功能，得写递归模板特化。现在一行折叠表达式就搞定了。我在做泛型库的时候，这种模式用得特别多。

性能考量

折叠表达式在编译期展开，运行时没有任何额外开销。它和手写的递归展开生成的代码是一样的。所以不用担心性能问题。

不过有一点要注意：如果参数包特别大（比如上百个参数），编译时间可能会增加。我在一个配置解析模块里遇到过这种情况，参数包展开后生成了大量模板实例化代码，编译时间从 5 秒涨到了 30 秒。后来我改用运行时循环，才把编译时间降下来。

总结

折叠表达式是 C++17 里我最喜欢的特性之一。它让可变参数模板从「能写但不好看」变成了「既简洁又优雅」。核心要点就三个：

• 分清左右：非可交换运算一定要明确结合顺序
• 善用逗号：对每个参数执行操作时，逗号折叠是最佳选择
• 注意空包：一元折叠要求参数包非空，二元折叠可以处理空包

说实话，自从用了折叠表达式，我写可变参数模板的频率高了不少。以前觉得麻烦的场景，现在一行代码就解决了。如果你还在用 C++11/14 的方式写递归展开，我建议你试试折叠表达式——写完之后你会觉得，嗯，这才是我想要的 C++。

---