C++模板参数包展开递归与折叠表达式-C++-PHP中文网

C++17的折叠表达式革新了模板参数包处理，相比C++17前依赖递归展开的繁琐方式，折叠表达式以更简洁、高效的语法直接对参数包进行聚合操作，显著提升代码可读性和编译效率。

c++模板参数包展开递归与折叠表达式

C++模板参数包展开，说白了，就是让你能写出接受任意数量、任意类型参数的函数或类。这在泛型编程里简直是利器。在C++17之前，我们处理这种“可变参数”的模板时，基本都得靠递归。你得写一个处理单个参数的“基线”模板，再写一个处理参数包的递归模板，每次剥离一个参数，直到只剩一个。而C++17引入的折叠表达式（Fold Expressions），则像一道闪电，直接把很多原本需要递归才能完成的操作，用一行简洁的代码就搞定了，效率和可读性都提升了一大截。

解决方案

处理C++模板参数包的核心在于如何“遍历”或“应用”包里的每一个元素。

传统递归展开： 在C++17之前，这是最常见的做法。基本思路是定义一个处理“空”参数包或者单个参数的基线函数（或类模板），然后定义一个处理非空参数包的递归函数。每次递归调用时，剥离参数包的第一个元素，将剩余的参数包传递给下一次递归。

#include <iostream>
#include <string>

// 基线函数：处理空参数包，终止递归
void print_args() {
    std::cout << "--- End of args ---" << std::endl;
}

// 递归函数：处理参数包
template<typename T, typename... Args>
void print_args(T head, Args... rest) {
    std::cout << head << " "; // 处理当前参数
    print_args(rest...);      // 递归调用处理剩余参数
}

// 另一个例子：计算和
long long sum_all() {
    return 0;
}

template<typename T, typename... Args>
long long sum_all(T head, Args... rest) {
    return static_cast<long long>(head) + sum_all(rest...);
}

登录后复制

这种模式虽然有效，但写起来有点啰嗦，尤其是一些简单的操作，比如求和、打印，都需要写一个基线和一个递归函数。

C++17 折叠表达式： C++17引入的折叠表达式极大地简化了参数包的处理。它允许你直接在表达式中使用省略号

...

登录后复制

，将二元运算符（或一元运算符）应用于参数包中的所有元素。

折叠表达式有四种形式：

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

一元左折叠:
```
(... op pack)
```
登录后复制
，例如
```
(pack + ...)
```
登录后复制
一元右折叠:
```
(pack op ...)
```
登录后复制
，例如
```
(pack + ...)
```
登录后复制
二元左折叠:
```
(init op ... op pack)
```
登录后复制
，例如
```
(0 + ... + pack)
```
登录后复制
二元右折叠:
```
(pack op ... op init)
```
登录后复制
，例如
```
(pack + ... + 0)
```
登录后复制

我们用折叠表达式来重写上面的例子：

#include <iostream>
#include <string>
#include <numeric> // for std::accumulate if needed, but fold expressions are more direct

// 打印所有参数 (使用逗号运算符)
template<typename... Args>
void print_args_fold(Args... args) {
    // 逗号运算符的妙用，确保每个表达式都被求值
    // (std::cout << args << " ", ...) 这是一个二元左折叠，但这里其实是展开了一系列独立的表达式
    // 真正的折叠表达式，需要一个关联操作符
    // 比如：((std::cout << args << " "), ...) 这种写法会编译错误
    // 正确的打印方式通常是结合初始化列表或Lambda
    // 更好的打印方式：
    (void)((std::cout << args << " "), ...); // 确保每个表达式都被求值，且避免警告
    std::cout << std::endl;
}

// 计算所有参数的和
template<typename... Args>
auto sum_all_fold(Args... args) {
    // 这是一个二元左折叠 (0 + arg1 + arg2 + ...)
    return (0 + ... + args);
}

// 逻辑与
template<typename... Bools>
bool all_true(Bools... b) {
    return (true && ... && b); // 二元右折叠
}

// 逻辑或
template<typename... Bools>
bool any_true(Bools... b) {
    return (false || ... || b); // 二元右折叠
}

登录后复制

折叠表达式明显更简洁，也更符合现代C++的风格。编译器在处理折叠表达式时，通常也能生成更优化的代码，因为它不需要像递归那样层层实例化模板。

为什么在C++17之前，递归是处理参数包的“必经之路”？

说实话，在C++17之前，如果你想让一个函数或者一个类模板能处理不定数量的参数，递归几乎是唯一的、也是最直接的办法。这其实跟参数包的本质有关：它不是一个容器，你不能像遍历

std::vector

登录后复制

那样用

for

登录后复制

循环去迭代它。参数包本质上是一系列独立的、类型可能各异的参数的集合。

想象一下，编译器在处理模板时，它需要知道每个参数的具体类型和值（如果能确定的话）。当它遇到一个参数包

Args...

登录后复制

时，它并不知道这个包里有多少个参数，也不知道它们的类型。递归展开提供了一种机制，让编译器可以“逐步”地处理这些参数。

举个例子，你有一个

print_args(arg1, arg2, arg3)

登录后复制

的调用。当编译器看到

template<typename T, typename... Args> void print_args(T head, Args... rest)

登录后复制

这个模板定义时，它会：

把
```
arg1
```
登录后复制
匹配到
```
T head
```
登录后复制
。
把
```
arg2, arg3
```
登录后复制
匹配到
```
Args... rest
```
登录后复制
。
在函数体内部，
```
print_args(rest...)
```
登录后复制
又会触发一次新的模板实例化，这次
```
arg2
```
登录后复制
是
```
head
```
登录后复制
，
```
arg3
```
登录后复制
是
```
rest
```
登录后复制
。
这个过程一直持续，直到
```
rest
```
登录后复制
为空，这时会匹配到
```
void print_args()
```
登录后复制
这个基线函数，从而终止递归。

这种“剥洋葱”式的处理方式，是C++模板元编程处理可变参数的经典模式。它虽然能解决问题，但缺点也很明显：

AiPPT模板广场

AiPPT模板广场-PPT模板-word文档模板-excel表格模板

147

查看详情

冗余代码： 总是需要一个基线函数来终止递归，这增加了代码量。
可读性： 对于不熟悉模板元编程的人来说，递归模板的理解门槛较高。
编译时间： 每次递归调用都会导致一次新的模板实例化，层数深了，编译时间可能会显著增加。而且，每次实例化都会在符号表中留下痕迹，可能导致最终可执行文件体积增大（尽管现代编译器在这方面做了很多优化）。

所以，在折叠表达式出现之前，尽管有这些不便，递归仍然是处理参数包的“唯一王道”，因为它提供了一种在编译时动态“解包”参数的有效机制。

C++17的折叠表达式如何革新了参数包处理？

C++17的折叠表达式，在我看来，简直是参数包处理领域的一次“语法糖革命”，但它的影响力远超简单的语法糖。它通过引入一种全新的、更直接的语法，让编译器能够以更高效的方式处理参数包。

核心在于，折叠表达式允许你直接在表达式内部对参数包进行“聚合”操作。不再需要显式的递归调用和基线函数。编译器知道如何将

(init op ... op pack)

登录后复制

或

(pack op ... op init)

登录后复制

这样的表达式直接展开成一系列连续的操作。

比如，

sum_all_fold(1, 2, 3)

登录后复制

调用

(0 + ... + args)

登录后复制

，编译器会直接将其展开为

(0 + 1 + 2 + 3)

登录后复制

。这与递归展开的

0 + (1 + (2 + 3))

登录后复制

逻辑上等价，但编译器的处理路径可能完全不同，通常会更扁平、更高效。

折叠表达式的优势体现在：

极简的代码： 大幅减少了模板元编程的样板代码。一个简单的求和、逻辑运算或者打印，现在只需要一行代码就能搞定，而不再需要一个基线函数和递归函数对。
增强可读性： 代码意图更加清晰。
```
(... + args)
```
登录后复制
比起一堆递归模板看起来更直观，一眼就能看出是在对参数包进行求和操作。
潜在的编译优化： 由于编译器可以直接理解折叠表达式的意图，它有机会生成更优化的代码，减少模板实例化的深度和数量。这有助于缩短编译时间，并可能生成更紧凑的二进制代码。
语义的丰富性： 它不仅仅是简单的数学运算，还可以结合逗号运算符实现序列操作（如打印），结合位运算符实现位掩码等。这让参数包的应用场景变得更加灵活和强大。

折叠表达式的引入，让C++的泛型编程能力更上一层楼，它让原本复杂、晦涩的模板元编程变得更加平易近人，也更高效。对于日常开发中需要处理可变参数的场景，折叠表达式几乎成了首选。

在实际项目中，何时选择递归，何时偏爱折叠表达式？

在实际项目中，选择递归还是折叠表达式，其实是个挺有意思的权衡问题。C++17之后，我的个人偏好是：能用折叠表达式解决的问题，就绝不考虑递归。但总有些情况，折叠表达式力所不及，或者递归能提供更清晰的解决方案。

优先选择折叠表达式的场景：

简单的聚合操作： 当你需要对参数包中的所有元素执行一个单一的、关联性的操作时，比如求和、求积、逻辑与/或、最大/最小值等。
```
template<typename... Args>
auto add_all(Args... args) {
    return (args + ...); // 自动推断返回类型，非常方便
}
```
登录后复制

序列化或打印： 结合逗号运算符，折叠表达式可以很方便地实现参数包的逐个处理，例如打印到流中。

template<typename... Args>
void print_to_console(Args... args) {
    // (void) 是为了避免某些编译器对未使用表达式的警告
    ((std::cout << args << " "), ...);
    std::cout << std::endl;
}

登录后复制

类型检查或断言： 比如检查所有参数是否都满足某个条件。

template<typename... Args>
constexpr bool all_integers() {
    return (std::is_integral_v<Args> && ...);
}

登录后复制

现代C++项目： 如果你的项目基于C++17或更高标准，并且团队成员都熟悉新特性，那么折叠表达式无疑是更现代、更简洁的选择。

仍然需要考虑递归的场景：

C++17之前的项目： 这点是硬性限制，如果项目编译器不支持C++17，那你就只能老老实实写递归了。
非关联性或复杂逻辑： 有些操作不是简单的“两两合并”就能完成的。例如，你需要根据每个参数的类型或值，执行完全不同的逻辑，或者在处理过程中需要维护某种状态，而这种状态又不能简单地通过折叠表达式的初始化值来传递。
- 例子： 假设你要实现一个自定义的
```
variant
```
  登录后复制
  访问器，根据每个参数的类型，决定调用不同的重载函数，并且可能在处理完一个参数后，根据其结果影响下一个参数的处理方式。这种情况下，递归通常能提供更精细的控制。
- 例子： 模拟一个栈操作，每次处理一个参数，并将其“压入”或“弹出”一个结构。这种操作可能需要递归的上下文来传递中间状态。
编译时调试： 有时候，递归模板的错误信息可能比折叠表达式更“直白”（虽然都挺吓人的），因为编译器会列出每次模板实例化的详细信息。这在某些极端复杂的模板元编程错误排查时，可能会提供一些额外的线索。当然，这只是很小的一个点，通常不足以成为选择递归的主要理由。
某些特定场景下的可读性： 极少数情况下，如果一个递归模式已经非常成熟和被广泛理解，并且折叠表达式的等价写法会显得过于“聪明”或难以理解，那么坚持递归也未尝不可。但这很罕见，通常折叠表达式会更清晰。