折叠表达式：C++17 的变参模板利器

折叠表达式是 C++17 引入的一个小特性，但它的威力可不小。说白了，它让我们处理变参模板时，能写出更简洁、更直观的代码。我记得刚学模板那会儿，处理参数包还得写递归模板，代码又长又绕。现在有了折叠表达式，很多场景一行代码就搞定了。

一、什么是折叠表达式？

折叠表达式（Fold Expression）是对参数包中的参数应用二元运算符的语法糖。它有两种形式：一元折叠和二元折叠。我个人习惯把折叠表达式理解为「把参数包里的元素用某个运算符串起来」。

举个例子，你想计算一堆数的和。传统做法是写递归模板：

// 传统递归方式
template<typename T>
T sum(T t) { return t; }

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

用折叠表达式呢？一行搞定：

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

简洁多了吧？这就是折叠表达式的魅力。

二、一元折叠：左折与右折

一元折叠有两种方向：左折和右折。它们的区别在于运算符的结合顺序。

一元左折：( ... op pack )，展开为 ((arg1 op arg2) op arg3) ...

一元右折：( pack op ... )，展开为 arg1 op (arg2 op (arg3 op ...))

对于加法这种满足结合律的运算，左右折结果一样。但对于减法、除法这种不满足结合律的运算，结果就不同了。

#include <iostream>

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

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

int main() {
    std::cout << leftFold(10, 3, 2) << "\n";   // ((10-3)-2) = 5
    std::cout << rightFold(10, 3, 2) << "\n";  // 10-(3-2) = 9
}

三、二元折叠：带初始值的折叠

二元折叠比一元折叠多了一个初始值。它的形式是：

• 二元左折：( init op ... op pack )，展开为 (((init op arg1) op arg2) op arg3) ...
• 二元右折：( pack op ... op init )，展开为 arg1 op (arg2 op (... op (argN op init)))

二元折叠的好处是：即使参数包为空，也能返回一个有意义的值（初始值）。

template<typename... Args>
auto sumWithInit(Args... args) {
    return (0 + ... + args);  // 空包时返回 0
}

template<typename... Args>
auto productWithInit(Args... args) {
    return (1 * ... * args);  // 空包时返回 1
}

int main() {
    std::cout << sumWithInit() << "\n";      // 0
    std::cout << sumWithInit(1, 2, 3) << "\n"; // 6
    std::cout << productWithInit() << "\n";   // 1
}

四、逗号表达式的妙用

逗号表达式在折叠中特别有用。你想想看，有时候我们不是要计算一个值，而是要执行一系列操作。比如打印所有参数：

template<typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << "\n";
}

// 或者每个参数单独打印，中间加空格
template<typename... Args>
void printWithSpace(Args... args) {
    ((std::cout << args << " "), ...);
    std::cout << "\n";
}

逗号折叠的典型应用是「对每个参数执行某个操作」。比如把参数全部存入一个容器：

#include <vector>

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

int main() {
    std::vector<int> v;
    pushAll(v, 1, 2, 3, 4, 5);
    // v 现在包含 1,2,3,4,5
}

为什么会这样？因为逗号表达式会从左到右依次求值，最终结果是最后一个表达式的值。但我们这里不关心结果，只关心副作用——也就是每次调用 push_back。

五、实际项目中的应用

我在项目中遇到过几个典型的折叠表达式应用场景，分享给你：

1. 检查所有参数是否满足某个条件

template<typename... Args>
bool allPositive(Args... args) {
    return ((args > 0) && ...);
}

// 使用
if (allPositive(1, 5, 3, 8)) {
    // 所有数都为正
}

2. 哈希组合

template<typename... Args>
size_t hashCombine(Args... args) {
    size_t seed = 0;
    ((seed ^= std::hash<Args>{}(args) + 0x9e3779b9 + (seed << 6) + (seed >> 2)), ...);
    return seed;
}

3. 类型安全的最小值

template<typename T, typename... Args>
T min(T first, Args... args) {
    T result = first;
    ((result = (args < result ? args : result)), ...);
    return result;
}

六、知识体系图

下面这张图总结了折叠表达式的核心知识结构：

七、总结

折叠表达式是 C++17 中一个「小而美」的特性。它让变参模板的代码更简洁、更易读。我个人觉得，掌握折叠表达式的关键是理解三点：

• 方向：左折还是右折，影响不满足结合律的运算结果
• 初始值：二元折叠需要选对初始值，空包时才有意义
• 逗号表达式：遍历执行操作时，逗号折叠是最优雅的写法

嗯，这里要注意一点：折叠表达式虽然好用，但别滥用。如果你的参数包可能很大，或者运算逻辑特别复杂，传统的递归模板可能更合适。毕竟代码的可读性和编译效率之间需要平衡。

好了，关于折叠表达式就聊这么多。希望你在实际项目中能用上这些技巧，写出更简洁、更健壮的 C++ 代码。

---

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