折叠表达式(Fold Expressions) ​

什么是折叠表达式 ​

折叠表达式是 C++17 引入的模板特性,允许你对参数包(parameter pack)施加一个二元运算符,把包中的所有元素"折叠"成一个值。用更直白的话说:以前想对可变参数模板的所有参数做加法、逻辑与、打印等操作,需要写递归模板(基础情况 + 递归展开),代码又长又绕;折叠表达式把这件事压缩成了一行。

折叠表达式的名字来自函数式编程中的 fold(也叫 reduce)操作——把一个序列通过某个运算符逐步合并成一个结果。

基本语法 ​

折叠表达式有四种形式,区别在于有没有初始值(一元 vs 二元)以及运算的结合方向(左折叠 vs 右折叠):

cpp
// 一元右折叠:从右往左折叠
(pack op ...)
// 展开为:(E1 op (E2 op (... op (EN-1 op EN))))

// 一元左折叠:从左往右折叠
(... op pack)
// 展开为:((((E1 op E2) op E3) op ...) op EN)

// 二元右折叠:带初始值,从右往左
(pack op ... op init)
// 展开为:(E1 op (E2 op (... op (EN op init))))

// 二元左折叠:带初始值,从左往右
(init op ... op pack)
// 展开为:((((init op E1) op E2) op ...) op EN)

其中:

  • pack 是包含未展开参数包的表达式
  • op 是 32 种二元运算符中的任意一种(+, -, , /, %, ^, &, |, =, <, >, <<, >>, +=, -=, =, /=, %=, ^=, &=, |=, <<=, >>=, ==, !=, <=, >=, &&, ||, 逗号, ., ->)
  • init 是不包含参数包的初始值表达式
  • 整个折叠表达式必须用圆括号括起来

编译期行为解释 ​

折叠表达式在编译期被展开。编译器看到折叠表达式后,会根据参数包中的元素数量,把它机械地展开成一连串的二元运算。这个展开过程发生在编译期,运行时执行的就是展开后的普通表达式,没有任何额外开销。

cpp
// 假设调用 sum(1, 2, 3, 4)
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 一元右折叠
}

// 编译器展开后等价于:
// return (1 + (2 + (3 + 4)));
// 最终计算结果:10

对于空参数包(零个参数),一元折叠有特殊规定:

  • && 运算符的空包值是 true
  • || 运算符的空包值是 false
  • , 运算符的空包值是 void()
  • 其他运算符对空包使用一元折叠会编译报错

如果需要处理空包的情况,用二元折叠并提供一个合理的初始值。

基本示例 ​

cpp
#include <iostream>
#include <string>
#include <vector>
#include <type_traits>

// ============================
// 示例1:求和——最基础的折叠表达式
// ============================

// 一元左折叠:(... + args) 展开为 ((arg1 + arg2) + arg3) + ...
template<typename... Args>
auto sum(Args... args) {
    return (... + args);
}

// 二元左折叠:带初始值 0,可以处理空参数包的情况
template<typename... Args>
auto safe_sum(Args... args) {
    return (0 + ... + args);  // 即使 args 为空,结果也是 0
}

// ============================
// 示例2:逻辑运算
// ============================

// 所有参数都为 true 才返回 true
template<typename... Args>
bool all_true(Args... args) {
    return (... && args);
    // all_true(true, true, false)
    // 展开为:((true && true) && false) = false
}

// 任意一个参数为 true 就返回 true
template<typename... Args>
bool any_true(Args... args) {
    return (... || args);
    // any_true(false, false, true)
    // 展开为:((false || false) || true) = true
}

// ============================
// 示例3:打印所有参数(用 << 运算符折叠)
// ============================

// 二元左折叠:(std::cout << ... << args)
// 展开为:((std::cout << arg1) << arg2) << arg3 ...
template<typename... Args>
void print_all(Args&&... args) {
    (std::cout << ... << args) << std::endl;
}

// 带分隔符的打印(用逗号运算符折叠)
template<typename... Args>
void print_with_separator(const std::string& sep, Args&&... args) {
    bool first = true;
    // 逗号运算符折叠:(表达式, ...) 对每个参数执行一次 lambda
    ((std::cout << (first ? "" : sep) << args, first = false), ...);
    std::cout << std::endl;
}

// ============================
// 示例4:对容器批量 push_back
// ============================

template<typename T, typename... Args>
void push_back_all(std::vector<T>& vec, Args&&... args) {
    // 逗号运算符折叠:对每个 arg 执行 vec.push_back(arg)
    (vec.push_back(std::forward<Args>(args)), ...);
}

// ============================
// 示例5:编译期类型检查
// ============================

// 检查所有类型是否都是整数类型
template<typename... Ts>
constexpr bool all_integral() {
    return (... && std::is_integral_v<Ts>);
    // all_integral<int, long, char>() = true
    // all_integral<int, double>() = false
}

// 检查所有类型的大小之和
template<typename... Ts>
constexpr std::size_t total_size() {
    return (... + sizeof(Ts));
    // total_size<int, double, char>() = 4 + 8 + 1 = 13
}

int main() {
    // 求和
    std::cout << "sum(1,2,3,4,5) = " << sum(1, 2, 3, 4, 5) << std::endl;       // 15
    std::cout << "safe_sum() = " << safe_sum() << std::endl;                      // 0
    std::cout << "safe_sum(10,20) = " << safe_sum(10, 20) << std::endl;          // 30

    // 逻辑运算
    std::cout << "all_true(true,true,true) = " << std::boolalpha
              << all_true(true, true, true) << std::endl;                          // true
    std::cout << "all_true(true,false) = " << all_true(true, false) << std::endl; // false
    std::cout << "any_true(false,false,true) = " << any_true(false, false, true) << std::endl; // true

    // 打印
    print_all("hello", " ", "world", "!");          // hello world!
    print_with_separator(", ", 1, 2, 3, "four", 5); // 1, 2, 3, four, 5

    // 批量 push_back
    std::vector<int> v;
    push_back_all(v, 10, 20, 30, 40, 50);
    std::cout << "vector 大小: " << v.size() << std::endl;  // 5

    // 编译期类型检查
    static_assert(all_integral<int, long, char>());
    static_assert(!all_integral<int, double>());
    std::cout << "total_size<int,double,char> = " << total_size<int, double, char>() << std::endl;

    return 0;
}

与传统递归模板方案的对比 ​

对比项C++17 之前(递归模板)C++17 折叠表达式
代码量至少两个函数(基础情况 + 递归展开)一行表达式
可读性需要理解递归展开过程直观,一眼看出意图
编译速度递归实例化较多模板直接展开,实例化更少
空包处理基础情况函数自然处理只有 &&, ||, 逗号支持空包
运行时开销无(编译期展开)无(编译期展开)
灵活性可以在每一步做任意操作限于单个二元运算符

传统递归写法的对比示例:

cpp
// C++17 之前:递归模板实现求和
// 基础情况:零个参数
int sum_old() { return 0; }

// 递归展开:取出第一个参数,加上其余参数的和
template<typename T, typename... Rest>
auto sum_old(T first, Rest... rest) {
    return first + sum_old(rest...);
}

// C++17 折叠表达式:一行搞定
template<typename... Args>
auto sum_new(Args... args) {
    return (0 + ... + args);
}

进阶用法 ​

cpp
#include <iostream>
#include <tuple>
#include <functional>

// ============================
// 进阶1:用折叠表达式实现管道操作
// ============================

// 将一个值依次通过多个函数处理
// pipe(x, f1, f2, f3) 等价于 f3(f2(f1(x)))
template<typename T, typename... Funcs>
auto pipe(T value, Funcs... funcs) {
    // 逗号运算符折叠,每一步用函数的返回值更新 value
    ((value = funcs(value)), ...);
    return value;
}

// ============================
// 进阶2:检查一个值是否等于参数包中的任意一个
// ============================

template<typename T, typename... Options>
bool is_one_of(const T& value, const Options&... options) {
    // 一元左折叠,用 || 运算符
    return ((value == options) || ...);
}

// ============================
// 进阶3:折叠表达式配合 lambda
// ============================

template<typename... Args>
void apply_to_each(Args&&... args) {
    // 对每个参数执行一个操作
    // 这里用逗号运算符折叠,lambda 立即调用
    ([](auto&& arg) {
        std::cout << "处理: " << arg << std::endl;
    }(std::forward<Args>(args)), ...);
}

int main() {
    // 管道操作
    auto result = pipe(3,
        [](int x) { return x * 2; },     // 3 * 2 = 6
        [](int x) { return x + 10; },    // 6 + 10 = 16
        [](int x) { return x * x; }      // 16 * 16 = 256
    );
    std::cout << "pipe 结果: " << result << std::endl;  // 256

    // 值匹配
    std::cout << "is_one_of(3, 1,2,3,4) = " << std::boolalpha
              << is_one_of(3, 1, 2, 3, 4) << std::endl;  // true
    std::cout << "is_one_of(5, 1,2,3,4) = "
              << is_one_of(5, 1, 2, 3, 4) << std::endl;  // false

    // 对每个参数执行操作
    apply_to_each(42, "hello", 3.14);

    return 0;
}

适用场景 ​

  • 对可变参数模板的所有参数做聚合运算(求和、求积、逻辑与/或等)
  • 将多个值批量插入容器(push_back、emplace_back)
  • 打印可变参数(通过 << 运算符折叠)
  • 编译期类型检查:检查参数包中的所有类型是否满足某个 trait
  • 实现简单的管道操作或函数组合
  • 检查一个值是否在一组候选值中

常见问题 ​

左折叠和右折叠的区别在实际中重要吗?

对于加法、乘法这类满足结合律的运算符来说,左折叠和右折叠的结果一样。但对于减法、除法、字符串拼接等不满足结合律的运算符,结合方向会影响结果。比如 (1 - (2 - 3)) = 2 而 ((1 - 2) - 3) = -4。一般建议用左折叠(和人的阅读习惯一致),除非有特殊需要。

折叠表达式能处理空参数包吗?

一元折叠只有 &&(空包值 true)、||(空包值 false)和逗号运算符(空包值 void())支持空包。其他运算符的一元折叠遇到空包会编译报错。如果你的函数可能接收零个参数,用二元折叠并提供一个合理的初始值(比如加法的初始值是 0,乘法是 1)。

折叠表达式能嵌套吗?

折叠表达式本身不能嵌套(不能在一个折叠表达式内部再写一个折叠表达式)。但可以通过 lambda 配合逗号运算符折叠来实现更复杂的逻辑。

注意事项 ​

  • 折叠表达式必须用圆括号括起来,(... + args) 是对的,... + args 是语法错误
  • 二元折叠中,... 两侧的运算符必须相同,不能写 (args + ... * init)
  • 折叠表达式只能用在模板中,因为参数包只存在于模板上下文中
  • 逗号运算符折叠 (expr, ...) 是一种常见的技巧,用来对每个参数执行一个有副作用的操作
  • 折叠表达式的展开发生在编译期,不会有运行时递归的开销
  • 如果运算涉及不同类型的参数,注意隐式转换的顺序(左折叠从左边开始转换,右折叠从右边开始)

编译器支持情况 ​

编译器最低支持版本
GCC6.0
Clang3.6
MSVC19.12 (VS 2017 15.5)

总结 ​

折叠表达式是 C++17 对可变参数模板编程的重大简化。以前需要递归模板基础情况 + 递归展开两个函数才能实现的参数包运算,现在一行折叠表达式就能搞定。四种形式(一元/二元 x 左/右)覆盖了大多数参数包操作场景。最常用的是一元左折叠((... op args))和配合逗号运算符的折叠((expr, ...))。使用时注意空包的处理——如果可能接收零个参数,用二元折叠提供初始值。折叠表达式在编译期展开,零运行时开销,是现代 C++ 可变参数编程的标配工具。