c++++17的折叠表达式通过简化对参数包的操作，解决了可变参数模板中聚合操作复杂、代码冗长的问题。它支持四种形式：一元左折叠（如(… + args)，从左到右累积，无初始值）、一元右折叠（如(args + …)，从右到左累积，无初始值）、二元左折叠（如(init + … + args)，从左到右累积，含初始值）、二元右折叠（如(args + … + init)，从右到左累积，含初始值）。常见应用场景包括聚合计算（如逻辑与、或、求和）、参数打印与日志、函数调用转发与链式调用、构建数据结构或初始化、类型特征与元编程（如编译期类型检查）等。
C++17的折叠表达式（Fold Expressions）是可变参数模板（Variadic Templates）的一大福音，它极大地简化了对参数包（parameter pack）进行操作的语法，让原本需要递归模板或一些巧妙但晦涩的技巧才能完成的任务，变得一行代码就能搞定。简单来说，它提供了一种简洁、直接的方式，将二元运算符应用于参数包中的所有元素。
解决方案
折叠表达式的核心在于它能直接对参数包应用二元运算符，省去了手动展开或递归的麻烦。它有四种基本形式，分别对应不同的操作方向和是否包含初始值：
一元左折叠 (Unary Left Fold): (... op pack)例如：( ( (E1 op E2) op E3 ) ... op En )这通常用于从左到右累积操作，没有初始值。
template<typename... Args>auto sum_all(Args... args) { // 计算所有参数的和 return (... + args); // 等价于 (((arg1 + arg2) + arg3) ...)}// 调用：sum_all(1, 2, 3) -> ( (1 + 2) + 3 ) -> 6
一元右折叠 (Unary Right Fold): (pack op ...)例如：( E1 op ( ... (En-1 op En) ) )从右到左累积操作，也没有初始值。
template<typename... Args>void print_all(Args... args) { // 从右到左打印参数，逗号分隔 // 注意：逗号运算符的结合性，这里需要一点技巧来确保打印顺序 // 实际上，为了顺序打印，通常会用左折叠或带初始值的右折叠 // 这是一个更直接的例子，展示右折叠的语法 (std::cout << ... << args); // 看起来像 (arg1 << (arg2 << (arg3 << ...))) // 但实际上，对于流操作，通常需要更细致的控制}// 更实用的打印例子，通常用逗号运算符template<typename... Args>void print_all_comma(Args... args) { ( (std::cout << args << " "), ...); // 左折叠，每个参数后加空格 std::cout << std::endl;}// 调用：print_all_comma(1, "hello", 3.14);
二元左折叠 (Binary Left Fold): (init op ... op pack)例如：( ( (init op E1) op E2 ) ... op En )从左到右累积操作，并包含一个初始值 init。
template<typename... Args>auto product_with_initial(double initial_val, Args... args) { // 计算所有参数与初始值的乘积 return (initial_val * ... * args); // 等价于 (((initial_val * arg1) * arg2) ...)}// 调用：product_with_initial(10.0, 2, 3) -> ((10.0 * 2) * 3) -> 60.0
二元右折叠 (Binary Right Fold): (pack op ... op init)例如：( E1 op ( ... (En op init) ) )从右到左累积操作，并包含一个初始值 init。
template<typename T, typename... Args>void chain_calls(T&& initial_obj, Args&&... funcs) { // 模拟函数链式调用，从右到左应用函数 // 例如：obj.f3().f2().f1() (std::forward<T>(initial_obj) .* ... .* std::forward<Args>(funcs)); // 这里的 .* 运算符通常用于成员指针调用 // 这是一个相对高级的用法，用于展示右折叠和成员指针}// 一个更直观的例子，例如连接字符串template<typename Separator, typename... Args>std::string join_strings(Separator sep, Args&&... args) { // 从右到左连接字符串，用sep分隔 // 注意：这里需要确保第一个参数是字符串类型，或者可以隐式转换为字符串 return (std::string(std::forward<Args>(args)) + ... + std::string(sep)); // 这个例子可能需要更严谨的类型处理，但展示了右折叠的结构}
折叠表达式的引入，让可变参数模板的编写变得更加直观和简洁，尤其是在处理聚合操作时，比如求和、逻辑与/或、打印等。
立即学习“C++免费学习笔记（深入）”；
折叠表达式解决了哪些痛点？
在我看来，折叠表达式的出现，简直是给C++模板元编程注入了一股清流。在此之前，如果你想对一个参数包里的所有元素做点什么，比如求和或者依次打印，你通常得依赖两种方式，而这两种方式或多或少都带着点“痛点”：
首先是递归模板。这是最经典也最“C++”的写法，通过一个基线模板和一个递归模板来逐个处理参数。代码写出来是这样：
// 递归基线void print_recursive() { std::cout << std::endl;}// 递归模板template<typename T, typename... Args>void print_recursive(T first, Args... rest) { std::cout << first << " "; print_recursive(rest...);}// 看起来很优雅，对吧？但当你写多了，会发现它有点冗长，而且每次调用都会生成新的函数实例，// 虽然编译器通常能优化得很好，但在阅读和理解上，总感觉多了一层间接。
然后是利用逗号运算符和初始化列表的技巧。这招在C++11/14时代非常流行，因为它能避免递归，代码看起来也比较紧凑：
template<typename... Args>void print_initializer_list(Args... args) { // 这是一个巧妙的技巧，利用了初始化列表的副作用和逗号运算符 int dummy[] = { ( (std::cout << args << " "), 0)... }; (void)dummy; // 避免未使用的变量警告 std::cout << std::endl;}// 这段代码第一次看到的时候，我个人觉得有点“魔幻”。// `( (std::cout << args << " "), 0)` 这部分，利用了逗号运算符会从左到右依次计算，// 并返回最后一个表达式的值（这里是0）。然后这些0被用来初始化一个整型数组。// 效果是达到了，但可读性嘛……嗯，仁者见仁智者见智。// 而且，这种方式有个限制，它只能用于那些能被逗号运算符串联起来的操作，// 对于一些纯粹的数学运算，比如求和，它就不那么直接了。
折叠表达式的出现，就是为了解决这些问题。它让对参数包的操作变得极其简洁和直观。你可以直接写 (... + args) 来求和，或者 ((std::cout 来打印。代码量大幅减少，可读性也得到了质的提升。对于我这种追求代码“一目了然”的人来说，这简直是福音。它不再需要那些“绕弯子”的技巧，而是直接表达了“对所有参数进行某种操作”的意图。
折叠表达式支持哪些运算符？它们的工作原理是怎样的？
折叠表达式支持的二元运算符相当广泛，几乎涵盖了C++中所有的二元运算符。这包括：
算术运算符: +, -, *, /, %位运算符: ^, &, |, , 逻辑运算符: >>&&, ||比较运算符: ==, !=, , 赋值运算符: >, , >=+=, -=, *=, /=, %=, ^=, &=, |=, , 其他: >>= (注意：赋值运算符通常需要左值作为操作数，所以实际使用时要小心), (逗号运算符), .* (成员指针访问), ->* (成员指针间接访问)
理解它们的工作原理，关键在于“折叠”这个词。你可以想象成一个递归或迭代的过程，但这个过程被编译器内部完成了。
我们以最常见的求和为例来解释其工作原理：
假设我们有一个参数包 pack 包含 E1, E2, E3, ..., En 这些元素。
一元左折叠 (... + pack):它会从左到右，依次将参数包中的元素与累积的结果相加。展开形式是：(((E1 + E2) + E3) + ... + En)如果 pack 是空的，它会导致编译错误，因为没有初始值来开始累积。
template<typename... T>auto sum(T... args) { return (... + args); // 如果 args 为空，这里会编译失败}// sum(1, 2, 3) -> ((1 + 2) + 3) -> 6
一元右折叠 (pack + ...):它会从右到左，依次将参数包中的元素与累积的结果相加。展开形式是：(E1 + (... + (En-1 + En)))同样，如果 pack 是空的，它也会导致编译错误。
template<typename... T>auto sum_right(T... args) { return (args + ...); // 如果 args 为空，这里会编译失败}// sum_right(1, 2, 3) -> (1 + (2 + 3)) -> 6// 对于加法这类满足结合律的运算，左右折叠结果相同。// 但对于不满足结合律的，比如减法或流操作，顺序就至关重要了。
二元左折叠 (init + ... + pack):它从一个初始值 init 开始，然后从左到右，依次将参数包中的元素与当前的累积结果相加。展开形式是：(((init + E1) + E2) + ... + En)如果 pack 是空的，它会直接返回 init，因为 init 是唯一一个参与运算的值。
template<typename Initial, typename... T>auto sum_with_initial(Initial init, T... args) { return (init + ... + args); // 如果 args 为空，返回 init}// sum_with_initial(10, 1, 2, 3) -> (((10 + 1) + 2) + 3) -> 16// sum_with_initial(10) -> 10
二元右折叠 (pack + ... + init):它从一个初始值 init 开始，然后从右到左，依次将参数包中的元素与当前的累积结果相加。展开形式是：(E1 + (... + (En + init)))如果 pack 是空的，它也会直接返回 init。
template<typename Initial, typename... T>auto sum_with_initial_right(Initial init, T... args) { return (args + ... + init); // 如果 args 为空，返回 init}// sum_with_initial_right(10, 1, 2, 3) -> (1 + (2 + (3 + 10))) -> 16
理解这些展开规则，对于选择正确的折叠方式至关重要，特别是当操作符不满足结合律（如减法、流插入 ）或者操作顺序有特定要求时。
在实际项目中，折叠表达式有哪些常见应用场景？
在实际的C++项目开发中，折叠表达式的应用场景远比我们想象的要广泛，它能让很多原本需要复杂模板技巧才能实现的功能变得简洁优雅。我个人在工作中，遇到以下几种情况时，折叠表达式总能派上大用场：
聚合计算 (Aggregation):这是最直观的用法，比如计算参数包中所有数字的和、积、逻辑与、逻辑或等。一个常见的例子是检查所有条件是否都为真：
template<typename... Bools>bool all_true(Bools... conditions) { return (... && conditions); // 检查所有布尔值是否都为true}// all_true(true, false, true) -> false// all_true(true, true) -> true
或者判断是否有任何一个条件为真：
template<typename... Bools>bool any_true(Bools... conditions) { return (... || conditions); // 检查是否有任何布尔值为true}// any_true(false, false, true) -> true
参数打印与日志 (Printing and Logging):在调试或日志系统中，经常需要打印可变数量的参数。折叠表达式配合逗号运算符 (expression, expression) 是完美的解决方案。
template<typename... Args>void log_message(Args&&... args) { // 使用左折叠和逗号运算符，依次打印所有参数，并用空格分隔 ((std::cout << std::forward<Args>(args) << " "), ...); std::cout << std::endl;}// log_message("User", 123, "logged in from", "192.168.1.1");// 输出: User 123 logged in from 192.168.1.1
这种写法比递归版本更紧凑，也比初始化列表技巧更易读。
函数调用转发与链式调用 (Function Call Forwarding & Chaining):当你需要将一系列参数转发给另一个函数，或者模拟一系列成员函数的链式调用时，折叠表达式能大显身手。
// 假设我们有一个通用的事件分发器class EventDispatcher {public: template<typename EventType, typename... Args> void dispatch(Args&&... args) { // 这里只是一个简化示例，实际可能更复杂 // 假设 EventType 有一个静态方法 handle(Args...) // 或者我们想把所有参数传递给一个回调列表 // 这里用一个简单的打印来模拟处理 log_message("Dispatching event:", EventType::name(), "with args:"); log_message(std::forward<Args>(args)...); }};// 更直接的链式调用例子 (使用成员指针)struct MyObject { MyObject& f1() { std::cout << "f1 "; return *this; } MyObject& f2() { std::cout << "f2 "; return *this; } MyObject& f3() { std::cout << "f3 "; return *this; }};template<typename T, typename... Funcs>void call_chained(T& obj, Funcs... funcs) { // 使用 .* 运算符和右折叠，实现链式调用 // (obj .* funcs) 是一个表达式，然后它又作为下一个 .* 的左操作数 // 展开类似: (obj .* f1) .* f2 .* f3 // 对于链式调用，通常是 obj.f1().f2().f3() 这种顺序，所以需要注意折叠方向 // 实际上，为了实现 obj.f1().f2().f3() 这种，需要巧妙构造 // 更简单的模拟方法是： auto temp = obj; (temp.*funcs, ...); // 使用逗号运算符，依次调用成员函数指针 // 这需要 funcs 是成员函数指针类型}// 实际更常见的链式调用：template<typename Obj, typename... Funcs>void apply_functions(Obj& obj, Funcs... funcs) { // 依次对obj应用每个函数，通常这些函数是lambda或仿函数 // 假设每个func接受obj作为参数并返回obj // ((obj = funcs(obj)), ...); // 如果funcs是函数对象 // 或者简单地调用，如果函数不修改obj (funcs(obj), ...);}
构建数据结构或初始化 (Construction/Initialization):例如，将参数包中的所有元素插入到一个容器中。
template<typename T, typename... Args>std::vector<T> make_vector(Args&&... args) { std::vector<T> vec; // 使用逗号运算符和emplace_back，将所有参数添加到vector中 (vec.emplace_back(std::forward<Args>(args)), ...); return vec;}// auto my_vec = make_vector<int>(1, 2, 3, 4, 5);
类型特征与元编程 (Type Traits and Metaprogramming):在编译期进行类型检查或计算时，折叠表达式也能提供极大的便利。
template<typename... T>struct are_all_integral { // 检查所有类型是否都是整型 static constexpr bool value = (... && std::is_integral_v<T>);};// are_all_integral<int, long, char>::value -> true// are_all_integral<int, double>::value -> false
折叠表达式的强大之处在于它将模板元编程中的一些常见模式“语言化”了，让代码不再需要复杂的递归结构或晦涩的初始化列表技巧，直接用清晰的语法表达意图。这不仅提升了开发效率，也大大降低了代码的维护成本。在我看来，这是C++17最实用的特性之一。
以上就是怎样使用C++17的折叠表达式 可变参数模板的简化写法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1466888.html
微信扫一扫 
支付宝扫一扫 
