C++折叠表达式变参模板简化技巧

P粉602998670

发布时间：2025-08-26 12:19:01

498人浏览过

来源于php中文网

原创

C++17引入的折叠表达式简化了变参模板的使用，通过一元或二元操作符直接作用于参数包，避免了传统递归写法的冗长与复杂，支持求和、打印、逻辑判断等场景，显著提升了代码可读性和编写效率。

c++折叠表达式变参模板简化技巧

C++17引入的折叠表达式（Fold Expressions）无疑是变参模板（Variadic Templates）的一大福音，它让处理参数包变得异常简洁和直观，彻底告别了过去那些冗长且容易出错的递归模板写法。说白了，它就是一种把二元操作符“折叠”到参数包所有元素上的语法糖，让代码更易读、更紧凑。

解决方案

折叠表达式的核心思想，在于提供了一种直接对参数包（parameter pack）应用二元操作符的方式，而无需手动编写递归基和递归步。这简直是变参模板的“救星”。

举个最简单的例子，如果你想计算一堆数字的和：

template
auto sum(Args... args) {
    // 传统方式可能需要递归函数或者借助辅助类
    // 但有了折叠表达式，一切都变了
    return (args + ...); // 一元右折叠，等价于arg1 + (arg2 + (arg3 + ...))
}

// 调用：sum(1, 2, 3, 4) -> 10

再比如，你想把所有参数打印出来：

立即学习“C++免费学习笔记（深入）”；

#include 

template
void print_all(T first_arg, Args... rest_args) {
    // 以前可能得写：
    // std::cout << first_arg << " ";
    // if constexpr (sizeof...(rest_args) > 0) {
    //     print_all(rest_args...);
    // }

    // 现在：
    std::cout << first_arg;
    ((std::cout << " " << rest_args), ...); // 二元左折叠，逗号操作符
    std::cout << std::endl;
}

// 调用：print_all(1, "hello", 3.14, true);
// 输出：1 hello 3.14 1

这里的

((std::cout << " " << rest_args), ...)

是一个二元左折叠。它的展开形式大概是

(std::cout << " " << rest_args_1, (std::cout << " " << rest_args_2, (...)))

，利用逗号操作符的顺序执行特性，依次打印出所有参数。这种写法，是不是比递归清晰多了？我个人觉得，它让变参模板从一个“高级技巧”变得更像一个“日常工具”。

折叠表达式有四种形式：

一元右折叠 (Unary Right Fold):

(pack op ...)

例如

(args + ...)

展开为

arg1 + (arg2 + (... + argN))

一元左折叠 (Unary Left Fold):
```
(... op pack)
```
- 例如
```
(... + args)
```
  展开为
```
((arg1 + arg2) + ...) + argN
```
  (注意，这里的例子有点误导，实际应用中一元左折叠并不常见，因为它需要操作符是左结合的，且通常与一个初始值结合使用)

二元右折叠 (Binary Right Fold):

(init op ... op pack)

例如

(0 + ... + args)

展开为

0 + (arg1 + (arg2 + ... + argN))

二元左折叠 (Binary Left Fold):

(pack op ... op init)

例如

(args + ... + 0)

展开为

((arg1 + arg2) + ...) + argN + 0

实际使用中，二元折叠（带初始值）和一元右折叠（对于某些操作符）是最常见的。

为什么折叠表达式是C++17的“及时雨”？它解决了什么痛点？

说实话，在C++17之前，处理变参模板简直是件体力活。每当你需要对参数包里的每个元素执行一个操作，比如求和、打印、调用成员函数，你都得写一个递归模板函数。这意味着你不仅要有一个处理单个元素的“递归基”，还要有一个处理剩余参数的“递归步”。代码量大不说，逻辑也显得有点绕，特别是对于初学者来说，理解起来更是费劲。

// 以前的递归求和
template
T sum_old(T t) {
    return t;
}

template
T sum_old(T t, Args... args) {
    return t + sum_old(args...);
}

这种模式虽然强大，但重复性太高，而且在编译错误时，模板展开的错误信息往往让人头大。折叠表达式的引入，就像是把这些重复的递归模式抽象成了一个语言层面的特性。它解决了最核心的痛点：简化了变参模板的写法，减少了模板元编程的认知负担和代码量。 它让那些原本需要多行甚至多个函数才能完成的任务，现在只需一行代码就能搞定。这不仅仅是语法上的简洁，更是思维上的解放，让开发者可以更专注于业务逻辑，而不是模板展开的细节。它让C++在处理可变参数列表时，有了Python、JavaScript等语言的简洁性，同时保留了C++的性能优势。

Detect GPT

一个Chrome插件，检测您浏览的页面是否包含人工智能生成的内容

下载

折叠表达式：那些你可能用得上的操作符与场景

折叠表达式支持C++中的所有二元操作符，包括算术运算符 (

)、位运算符 (

<<

>>

)、逻辑运算符 (

&&

||

)、比较运算符 (

==

!=

<=

>=

)、赋值运算符（虽然不常用）、逗号运算符 (

)，以及成员指针运算符 (

.*

->*

)。这种广泛的支持意味着它能覆盖绝大多数对参数包的操作需求。

常见的应用场景真的很多：

聚合操作：

求和/求积：
```
(args + ...)
```
或
```
(1 * ... * args)
```

逻辑与/或：

(args && ...)

(判断所有参数是否都为真) 或

(args || ...)

(判断是否有参数为真)。这在进行类型检查或条件判断时非常有用。

template
bool all_true(Bools... b) {
return (b && ...); // 只有当所有b都为true时才返回true
}
// all_true(true, false, true) -> false

函数调用/方法链：
- 你可以对参数包中的每个对象调用一个方法：
```
struct Worker {
void do_work() { std::cout << "Working...\n"; }
};
```
template void make_them_work(Workers&... ws) { (ws.do_work(), ...); // 依次调用每个Worker的do_work方法 } // Worker w1, w2; make_them_work(w1, w2); // 输出：Working... Working...

容器初始化/构造函数转发：

在构造函数中，你可以用折叠表达式完美转发所有参数给基类或成员：

template
struct MyVector : std::vector {
MyVector(Args... args) : std::vector({args...}) { // C++11列表初始化
    // 或者，如果需要更复杂的处理，例如将参数逐个添加到容器
    // (this->push_back(args), ...); // 这在构造函数体里可能更常见
}
};
// MyVector v(1, 2, 3, 4);

自定义流操作：

就像前面

print_all

例子一样，将多个参数插入到流中。

template
std::ostream& operator<<(std::ostream& os, const std::tuple& t) {
os << "(";
std::apply([&os](const Args&... args) {
    ((os << args << " "), ...); // 打印每个元素，后面跟空格
}, t);
os << ")";
return os;
}
// std::tuple my_tuple = {1, 2.5, "hello"};
// std::cout << my_tuple; // 输出：(1 2.5 hello )

这里结合了

std::apply

，进一步展示了变参模板的强大。

别踩坑！折叠表达式使用中的那些小秘密

虽然折叠表达式强大且简洁，但它也不是完全没有“脾气”。有些细节，第一次用的时候可能就会让你摸不着头脑。

C++17标准要求： 这是最基本的一点，你的编译器必须支持C++17或更高标准。否则，你会得到一个编译错误。
空参数包的处理： 这是个大坑！
- 对于二元折叠 (
```
(init op ... op pack)
```
  或
```
(pack op ... op init)
```
  )，如果
```
pack
```
  是空的，那么表达式的结果就是
```
init
```
  的值。例如
```
(0 + ... + args)
```
  ，如果
```
args
```
  为空，结果就是
```
0
```
  。这是非常安全的。
- 对于一元折叠 (
```
(pack op ...)
```
  或
```
(... op pack)
```
  )，如果
```
pack
```
  是空的，行为就取决于操作符了：
  - ```
  &&
```
  (逻辑与) 在空包上折叠结果为
```
  true
```
  。
- ```
||
```
    (逻辑或) 在空包上折叠结果为
```
false
```
    。
  - ```
  ,
```
  (逗号) 在空包上折叠结果为
```
  void()
```
  。
- 其他所有操作符 (如
```
  +
```
  ,
```
  *
```
  ,
```
  /
```
  等) 在空包上进行一元折叠是编译错误。因为它们无法确定一个合理的初始值。所以，当你使用一元折叠时，一定要确保你的参数包不会为空，或者，如果可能为空，就使用二元折叠并提供一个合适的初始值。
操作符优先级与结合性： 折叠表达式中的操作符仍然遵循C++标准的操作符优先级和结合性规则。如果你有复杂的表达式，或者操作符的优先级不如预期，可能需要使用括号来强制执行你想要的求值顺序。比如
```
(f(args) + ...)
```
和
```
(f(args) ... +)
```
可能会有不同的含义（尽管后者不是有效的折叠表达式）。确保你的意图和语法是匹配的。
副作用： 像逗号操作符 (
```
,
```
) 和逻辑与/或 (
```
&&
```
,
```
||
```
) 这样的操作符，它们是有短路求值和顺序点语义的。在折叠表达式中，这些语义依然有效。这意味着，如果你在表达式中包含了有副作用的操作（比如函数调用），你需要清楚它们的执行顺序和条件。
类型推导和隐式转换： 和所有模板一样，类型推导在这里也扮演着关键角色。确保参数包中的所有类型在操作符下是兼容的，或者能够进行隐式转换。否则，你会遇到编译错误。有时候，为了避免歧义或强制特定行为，你可能需要显式地进行类型转换。