怎样使用C++17的折叠表达式 可变参数模板的简化写法

c++++17的折叠表达式通过简化对参数包的操作，解决了可变参数模板中聚合操作复杂、代码冗长的问题。它支持四种形式：一元左折叠（如(... + args)，从左到右累积，无初始值）、一元右折叠（如(args + ...)，从右到左累积，无初始值）、二元左折叠（如(init + ... + args)，从左到右累积，含初始值）、二元右折叠（如(args + ... + init)，从右到左累积，含初始值）。常见应用场景包括聚合计算（如逻辑与、或、求和）、参数打印与日志、函数调用转发与链式调用、构建数据结构或初始化、类型特征与元编程（如编译期类型检查）等。

C++17的折叠表达式（Fold Expressions）是可变参数模板（Variadic Templates）的一大福音，它极大地简化了对参数包（parameter pack）进行操作的语法，让原本需要递归模板或一些巧妙但晦涩的技巧才能完成的任务，变得一行代码就能搞定。简单来说，它提供了一种简洁、直接的方式，将二元运算符应用于参数包中的所有元素。

解决方案

折叠表达式的核心在于它能直接对参数包应用二元运算符，省去了手动展开或递归的麻烦。它有四种基本形式，分别对应不同的操作方向和是否包含初始值：

1. 一元左折叠 (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

   登录后复制

2. 一元右折叠 (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 << &quot; &quot;), ...); // 左折叠，每个参数后加空格
       std::cout << std::endl;
   }
   // 调用：print_all_comma(1, &quot;hello&quot;, 3.14);

   登录后复制

3. 二元左折叠 (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

   登录后复制

4. 二元右折叠 (Binary Right Fold): (pack op ... op init) 例如：( E1 op ( ... (En op init) ) ) 从右到左累积操作，并包含一个初始值 init。

   template<typename T, typename... Args>
   void chain_calls(T&amp;&amp; initial_obj, Args&amp;&amp;... 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&amp;&amp;... 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 << &quot; &quot;;
    print_recursive(rest...);
}
// 看起来很优雅，对吧？但当你写多了，会发现它有点冗长，而且每次调用都会生成新的函数实例，
// 虽然编译器通常能优化得很好，但在阅读和理解上，总感觉多了一层间接。

然后是利用逗号运算符和初始化列表的技巧。这招在C++11/14时代非常流行，因为它能避免递归，代码看起来也比较紧凑：

template<typename... Args>
void print_initializer_list(Args... args) {
    // 这是一个巧妙的技巧，利用了初始化列表的副作用和逗号运算符
    int dummy[] = { ( (std::cout << args << &quot; &quot;), 0)... };
    (void)dummy; // 避免未使用的变量警告
    std::cout << std::endl;
}
// 这段代码第一次看到的时候，我个人觉得有点“魔幻”。
// `( (std::cout << args << &quot; &quot;), 0)` 这部分，利用了逗号运算符会从左到右依次计算，
// 并返回最后一个表达式的值（这里是0）。然后这些0被用来初始化一个整型数组。
// 效果是达到了，但可读性嘛……嗯，仁者见仁智者见智。
// 而且，这种方式有个限制，它只能用于那些能被逗号运算符串联起来的操作，
// 对于一些纯粹的数学运算，比如求和，它就不那么直接了。

折叠表达式的出现，就是为了解决这些问题。它让对参数包的操作变得极其简洁和直观。你可以直接写 (... + args) 来求和，或者 ((std::cout << args << &quot; &quot;), ...) 来打印。代码量大幅减少，可读性也得到了质的提升。对于我这种追求代码“一目了然”的人来说，这简直是福音。它不再需要那些“绕弯子”的技巧，而是直接表达了“对所有参数进行某种操作”的意图。

折叠表达式支持哪些运算符？它们的工作原理是怎样的？

折叠表达式支持的二元运算符相当广泛，几乎涵盖了C++中所有的二元运算符。这包括：

如此AI员工

国内首个全链路营销获客AI Agent

172

查看详情

• 算术运算符: +, -, *, /, %
• 位运算符: ^, &, |, <<, >>
• 逻辑运算符: &&, ||
• 比较运算符: ==, !=, <, >, <=, >=
• 赋值运算符: +=, -=, *=, /=, %=, ^=, &=, |=, <<=, >>= (注意：赋值运算符通常需要左值作为操作数，所以实际使用时要小心)
• 其他: , (逗号运算符), .* (成员指针访问), ->* (成员指针间接访问)

理解它们的工作原理，关键在于“折叠”这个词。你可以想象成一个递归或迭代的过程，但这个过程被编译器内部完成了。

我们以最常见的求和为例来解释其工作原理：

假设我们有一个参数包 pack 包含 E1, E2, E3, ..., En 这些元素。

1. 一元左折叠 (... + pack): 它会从左到右，依次将参数包中的元素与累积的结果相加。 展开形式是：(((E1 + E2) + E3) + ... + En) 如果 pack 是空的，它会导致编译错误，因为没有初始值来开始累积。

   template<typename... T>
   auto sum(T... args) {
       return (... + args); // 如果 args 为空，这里会编译失败
   }
   // sum(1, 2, 3) -> ((1 + 2) + 3) -> 6

   登录后复制

2. 一元右折叠 (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
   // 对于加法这类满足结合律的运算，左右折叠结果相同。
   // 但对于不满足结合律的，比如减法或流操作，顺序就至关重要了。

   登录后复制

3. 二元左折叠 (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

   登录后复制

4. 二元右折叠 (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++项目开发中，折叠表达式的应用场景远比我们想象的要广泛，它能让很多原本需要复杂模板技巧才能实现的功能变得简洁优雅。我个人在工作中，遇到以下几种情况时，折叠表达式总能派上大用场：

1. 聚合计算 (Aggregation): 这是最直观的用法，比如计算参数包中所有数字的和、积、逻辑与、逻辑或等。 一个常见的例子是检查所有条件是否都为真：

   template<typename... Bools>
   bool all_true(Bools... conditions) {
       return (... &amp;&amp; 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

   登录后复制

2. 参数打印与日志 (Printing and Logging): 在调试或日志系统中，经常需要打印可变数量的参数。折叠表达式配合逗号运算符 (expression, expression) 是完美的解决方案。

   template<typename... Args>
   void log_message(Args&amp;&amp;... args) {
       // 使用左折叠和逗号运算符，依次打印所有参数，并用空格分隔
       ((std::cout << std::forward<Args>(args) << &quot; &quot;), ...);
       std::cout << std::endl;
   }
   // log_message(&quot;User&quot;, 123, &quot;logged in from&quot;, &quot;192.168.1.1&quot;);
   // 输出: User 123 logged in from 192.168.1.1

   登录后复制

   这种写法比递归版本更紧凑，也比初始化列表技巧更易读。

3. 函数调用转发与链式调用 (Function Call Forwarding & Chaining): 当你需要将一系列参数转发给另一个函数，或者模拟一系列成员函数的链式调用时，折叠表达式能大显身手。

   // 假设我们有一个通用的事件分发器
   class EventDispatcher {
   public:
       template<typename EventType, typename... Args>
       void dispatch(Args&amp;&amp;... args) {
           // 这里只是一个简化示例，实际可能更复杂
           // 假设 EventType 有一个静态方法 handle(Args...)
           // 或者我们想把所有参数传递给一个回调列表
           // 这里用一个简单的打印来模拟处理
           log_message(&quot;Dispatching event:&quot;, EventType::name(), &quot;with args:&quot;);
           log_message(std::forward<Args>(args)...);
       }
   };
   
   // 更直接的链式调用例子 (使用成员指针)
   struct MyObject {
       MyObject&amp; f1() { std::cout << &quot;f1 &quot;; return *this; }
       MyObject&amp; f2() { std::cout << &quot;f2 &quot;; return *this; }
       MyObject&amp; f3() { std::cout << &quot;f3 &quot;; return *this; }
   };
   
   template<typename T, typename... Funcs>
   void call_chained(T&amp; 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&amp; obj, Funcs... funcs) {
       // 依次对obj应用每个函数，通常这些函数是lambda或仿函数
       // 假设每个func接受obj作为参数并返回obj
       // ((obj = funcs(obj)), ...); // 如果funcs是函数对象
       // 或者简单地调用，如果函数不修改obj
       (funcs(obj), ...);
   }

   登录后复制

4. 构建数据结构或初始化 (Construction/Initialization): 例如，将参数包中的所有元素插入到一个容器中。

   template<typename T, typename... Args>
   std::vector<T> make_vector(Args&amp;&amp;... 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);

   登录后复制

5. 类型特征与元编程 (Type Traits and Metaprogramming): 在编译期进行类型检查或计算时，折叠表达式也能提供极大的便利。

   template<typename... T>
   struct are_all_integral {
       // 检查所有类型是否都是整型
       static constexpr bool value = (... &amp;&amp; std::is_integral_v<T>);
   };
   // are_all_integral<int, long, char>::value -> true
   // are_all_integral<int, double>::value -> false

   登录后复制

折叠表达式的强大之处在于它将模板元编程中的一些常见模式“语言化”了，让代码不再需要复杂的递归结构或晦涩的初始化列表技巧，直接用清晰的语法表达意图。这不仅提升了开发效率，也大大降低了代码的维护成本。在我看来，这是C++17最实用的特性之一。

以上就是怎样使用C++17的折叠表达式 可变参数模板的简化写法的详细内容，更多请关注php中文网其它相关文章！