C++fold_expressions折叠表达式

2026-04-11 21:30:32 884阅读 0评论

C++17里的“连珠炮”：fold expressions到底怎么用才不翻车？

你有没有写过这样的函数模板？

template<typename... Args>
auto sum(Args&&... args) {
    return (args + ...); // 看起来很酷？但编译报错！
}

别急，不是你手抖漏了括号——C++17之前，这行代码根本没法编译。直到 fold expressions（折叠表达式）登场，才让变参模板真正“松了口气”。

它不是语法糖，也不是炫技工具；它是 C++ 在类型安全前提下，对“多个参数做同一操作”这件事的一次精准收口。

折叠表达式不是魔法，是模式匹配

很多人初看 (... + args) 和 (args + ...) 觉得像绕口令。其实就两件事：

一元右折叠：(E op ...) → E1 op (E2 op (... op EN))
一元左折叠：(... op E) → ((E1 op E2) op ...) op EN

注意：op 必须是 17 个支持折叠的运算符之一（+ - * / % ^ & | = < > += -= *= /= %= ^= &= |= << >> <<= >>= == != <= >= && || ,），且必须和参数类型兼容。

举个实在的例子：
你想把一串布尔值全“与”起来，写成 all_true(a, b, c, d)。以前得递归或特化，现在一行搞定：

template<typename... Bools>
bool all_true(Bools... bs) {
    return (true && ... && bs); // 左折叠：((true && a) && b) && c ...
}

这里 true 是“种子值”，避免空参数包时报错（all_true() 调用会返回 true）。没它？(... && bs) 遇到零参数直接编译失败。

别只盯着 `+` 和 `&&`，试试这些“冷门但实用”的组合

字符串拼接（C++20前）：

template<typename... S>
std::string join(S&&... ss) {
  std::string res;
  (res += ... += std::string{std::forward<S>(ss)}); // 注意：+= 是右结合，所以用右折叠
  return res;
}

关键点：+= 折叠必须用 (... += E) 形式，因为 E += ... 不合法（左操作数不能是包展开）。

检查所有参数是否同类型（调试时意外好用）：

template<typename T, typename... Args>
constexpr bool all_same_type() {
  return (std::is_same_v<T, Args> && ...);
}

构造多个对象并放入容器（无需完美转发陷阱）：

template<typename Container, typename... Ts>
void emplace_all(Container& c, Ts&&... ts) {
  (c.emplace_back(std::forward<Ts>(ts)), ...); // 逗号折叠，顺序求值
}

看到没？逗号 , 折叠是唯一能保证严格从左到右执行的折叠形式。它不返回值，但能串起副作用——比如日志、插入、状态更新。

常见翻车现场，和怎么绕开

❌ 错误：(args * ... * 1) —— 1 是字面量，类型推导可能崩（比如 args 里有 double 和 int）
✅ 改成 (static_cast<decltype((args * ...))>(1) * ... * args) 太啰嗦？不如直接用 args 中第一个类型做种子：
```
template<typename T, typename... Rest>
auto product(T&& t, Rest&&... rest) {
  return (std::forward<T>(t) * ... * std::forward<Rest>(rest));
}
```
❌ 错误：在 lambda 内直接折叠捕获的参数包（[&](auto&&... xs) { (xs + ...); }）
✅ C++20 才支持 lambda 参数包折叠，C++17 必须把折叠写在 lambda 外层，或用辅助函数。
❌ 错误：以为 (... < args) 能做“升序检查”（a < b < c < d）
✅ 实际上 (a < b < c) 在 C++ 里是 (a < b) < c，即 bool < T，大概率编译不过。真要升序，得写成：
```
template<typename... Ts>
bool is_strictly_increasing(Ts&&... ts) {
  return ((std::forward<Ts>(ts) < std::forward<Ts>(ts)) && ...); // 错！
}
```
正确解法：用索引序列 + 比较相邻项，折叠不适用此处——折叠解决的是“同构操作”，不是“关系链”。