以二元运算符对形参包进行规约（折叠)）。

语法

( 形参包 op … ) (1)
( … op 形参包 ) (2)
( 形参包 op … op 初值 ) (3)
( 初值 op … op 形参包 ) (4)

1) 一元右折叠

2) 一元左折叠

3) 二元右折叠

4) 二元左折叠

op - 任何下列 32 个二元运算符之一：+ - / % ^ & | = < > << >> += -= = /= %= ^= &= |= <<= >>= == != <= >= && || , . ->。在二元折叠中，两个 op 必须相同。
形参包 - 含未展开的形参包且其顶层不含有优先级低于转型（正式而言，是 转型表达式）的运算符的表达式
初值 - 不含未展开的形参包且其顶层不含有优先级低于转型（正式而言，是 转型表达式）的运算符的表达式

注意开与闭括号是折叠表达式的一部分。

解释

折叠表达式的实例化按如下方式展开成表达式 e：

1) 一元右折叠 (E op …) 成为 (E1 op (… op (EN-1 op EN)))

2) 一元左折叠 (… op E) 成为 (((E1 op E2) op …) op EN)

3) 二元右折叠 (E op … op I) 成为 (E1 op (… op (EN−1 op (EN op I))))

4) 二元左折叠 (I op … op E) 成为 ((((I op E1) op E2) op …) op EN)

（其中 N 是包展开中的元素数）

例如， 

  1. template<typename... Args>
  2. bool all(Args... args) { return (... && args); }
  3.  
  4. bool b = all(true, true, true, false);
  5.  // 在 all() 中，一元左折叠展开成
  6.  //  return ((true && true) && true) && false;
  7.  // b 为 false

将一元折叠用于零长包展开时，仅允许下列运算符：

1) 逻辑与（&&）。空包的值为 true

2) 逻辑或（||）。空包的值为 false

3) 逗号运算符（,）。空包的值为 void()

注解

若用作 初值 或 形参包 的表达式在顶层具有优先级低于转型的运算符，则它可以加括号：

  1. template<typename ...Args>
  2. int sum(Args&&... args) {
  3. //    return (args + ... + 1 * 2); // 错误：优先级低于转型的运算符
  4.     return (args + ... + (1 * 2)); // OK
  5. }

示例

运行此代码

  1. #include <iostream>
  2. #include <vector>
  3. #include <climits>
  4. #include <cstdint>
  5. #include <type_traits>
  6. #include <utility>
  7.  
  8. template<class ...Args>
  9. void printer(Args&&... args) {
  10.     (std::cout << ... << args) << '\n';
  11. }
  12.  
  13. template<class T, class... Args>
  14. void push_back_vec(std::vector<T>& v, Args&&... args)
  15. {
  16.     static_assert((std::is_constructible_v<T, Args&> && ...));
  17.     (v.push_back(args), ...);
  18. }
  19.  
  20. // 基于 http://stackoverflow.com/a/36937049 的编译时端序交换 
  21. template<class T, std::size_t... N>
  22. constexpr T bswap_impl(T i, std::index_sequence<N...>) {
  23.   return (((i >> N*CHAR_BIT & std::uint8_t(-1)) << (sizeof(T)-1-N)*CHAR_BIT) | ...);
  24. }
  25. template<class T, class U = std::make_unsigned_t<T>>
  26. constexpr U bswap(T i) {
  27.   return bswap_impl<U>(i, std::make_index_sequence<sizeof(T)>{});
  28. }
  29.  
  30. int main()
  31. {
  32.     printer(1, 2, 3, "abc");
  33.  
  34.     std::vector<int> v;
  35.     push_back_vec(v, 6, 2, 45, 12);
  36.     push_back_vec(v, 1, 2, 9);
  37.     for (int i : v) std::cout << i << ' ';
  38.  
  39.     static_assert(bswap<std::uint16_t>(0x1234u)==0x3412u);
  40.     static_assert(bswap<std::uint64_t>(0x0123456789abcdefULL)==0xefcdab8967452301ULL);
  41. }

输出：

  1. 123abc
  2. 6 2 45 12 1 2 9