折叠表达式(Fold Expressions)
什么是折叠表达式
折叠表达式是 C++17 引入的模板特性,允许你对参数包(parameter pack)施加一个二元运算符,把包中的所有元素"折叠"成一个值。用更直白的话说:以前想对可变参数模板的所有参数做加法、逻辑与、打印等操作,需要写递归模板(基础情况 + 递归展开),代码又长又绕;折叠表达式把这件事压缩成了一行。
折叠表达式的名字来自函数式编程中的 fold(也叫 reduce)操作——把一个序列通过某个运算符逐步合并成一个结果。
基本语法
折叠表达式有四种形式,区别在于有没有初始值(一元 vs 二元)以及运算的结合方向(左折叠 vs 右折叠):
// 一元右折叠:从右往左折叠
(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是不包含参数包的初始值表达式- 整个折叠表达式必须用圆括号括起来
编译期行为解释
折叠表达式在编译期被展开。编译器看到折叠表达式后,会根据参数包中的元素数量,把它机械地展开成一连串的二元运算。这个展开过程发生在编译期,运行时执行的就是展开后的普通表达式,没有任何额外开销。
// 假设调用 sum(1, 2, 3, 4)
template<typename... Args>
auto sum(Args... args) {
return (args + ...); // 一元右折叠
}
// 编译器展开后等价于:
// return (1 + (2 + (3 + 4)));
// 最终计算结果:10对于空参数包(零个参数),一元折叠有特殊规定:
&&运算符的空包值是true||运算符的空包值是false,运算符的空包值是void()- 其他运算符对空包使用一元折叠会编译报错
如果需要处理空包的情况,用二元折叠并提供一个合理的初始值。
基本示例
#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 折叠表达式 |
|---|---|---|
| 代码量 | 至少两个函数(基础情况 + 递归展开) | 一行表达式 |
| 可读性 | 需要理解递归展开过程 | 直观,一眼看出意图 |
| 编译速度 | 递归实例化较多模板 | 直接展开,实例化更少 |
| 空包处理 | 基础情况函数自然处理 | 只有 &&, ||, 逗号支持空包 |
| 运行时开销 | 无(编译期展开) | 无(编译期展开) |
| 灵活性 | 可以在每一步做任意操作 | 限于单个二元运算符 |
传统递归写法的对比示例:
// 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);
}进阶用法
#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, ...)是一种常见的技巧,用来对每个参数执行一个有副作用的操作 - 折叠表达式的展开发生在编译期,不会有运行时递归的开销
- 如果运算涉及不同类型的参数,注意隐式转换的顺序(左折叠从左边开始转换,右折叠从右边开始)
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 6.0 |
| Clang | 3.6 |
| MSVC | 19.12 (VS 2017 15.5) |
总结
折叠表达式是 C++17 对可变参数模板编程的重大简化。以前需要递归模板基础情况 + 递归展开两个函数才能实现的参数包运算,现在一行折叠表达式就能搞定。四种形式(一元/二元 x 左/右)覆盖了大多数参数包操作场景。最常用的是一元左折叠((... op args))和配合逗号运算符的折叠((expr, ...))。使用时注意空包的处理——如果可能接收零个参数,用二元折叠提供初始值。折叠表达式在编译期展开,零运行时开销,是现代 C++ 可变参数编程的标配工具。