折叠表达式(C++17 起)

来自cppreference.com
See More


 
C++
 
C++ 语言
 
模板
 

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

语法

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

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

解释

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

1) 一元右折叠 (E 运算符 ...) 成为 (E1 运算符 (... 运算符 (EN-1 运算符 EN)))
2) 一元左折叠 (... 运算符 E) 成为 (((E1 运算符 E2) 运算符 ...) 运算符 EN)
3) 二元右折叠 (E 运算符 ... 运算符 I) 成为 (E1 运算符 (... 运算符 (EN−1 运算符 (EN 运算符 I))))
4) 二元左折叠 (I 运算符 ... 运算符 E) 成为 ((((I 运算符 E1) 运算符 E2) 运算符 ...) 运算符 EN)

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

例如， 

template<typename... Args>
bool all(Args... args) { return (... && args); }

bool b = all(true, true, true, false);
// 在 all() 中，一元左折叠展开成
//  return ((true && true) && true) && false;
// b 是 false

将一元折叠用于长度为零的包展开时，只能使用下列运算符：

1) 逻辑与（&&）。空包的值是 true
2) 逻辑或（||）。空包的值是 false
3) 逗号运算符（,）。空包的值是 void()

注解

如果用作初值 或包 的表达式在顶层具有优先级低于转换的运算符，那么它可以加括号： 

template<typename... Args>
int sum(Args&&... args)
{
//  return (args + ... + 1 * 2);   // 错误：优先级低于转换的运算符
    return (args + ... + (1 * 2)); // OK
}
功能特性测试宏 值 标准 功能特性
__cpp_fold_expressions 201603L (C++17) 折叠表达式

示例

运行此代码
#include <climits>
#include <concepts>
#include <cstdint>
#include <iostream>
#include <limits>
#include <type_traits>
#include <utility>
#include <vector>

// 基本用法，在 operator<< 上折叠可变实参
template<typename... Args>
void printer(Args&&... args)
{
    (std::cout << ... << args) << '\n';
}

// 在 operator, 上折叠直接使用包的表达式
template<typename... Ts>
void print_limits()
{
    ((std::cout << +std::numeric_limits<Ts>::max() << ' '), ...) << '\n';
}

// 同时使用包在 operator&& 上折叠并使用可变形参在 operator, 上折叠
template<typename T, typename... Args>
void push_back_vec(std::vector<T>& v, Args&&... args)
{
    static_assert((std::is_constructible_v<T, Args&&> && ...));
    (v.push_back(std::forward<Args>(args)), ...);
}

// 通过在 operator, 上折叠一个 lambda，使用整数序列来 N 次执行某个表达式
template<class T, std::size_t... dummy_pack>
constexpr T bswap_impl(T i, std::index_sequence<dummy_pack...>)
{
    T low_byte_mask = static_cast<unsigned char>(-1);
    T ret{};
    ([&]
    {
        (void)dummy_pack;
        ret <<= CHAR_BIT;
        ret |= i & low_byte_mask;
        i >>= CHAR_BIT;
    }(), ...);
    return ret;
}
 
constexpr auto bswap(std::unsigned_integral auto i)
{
    return bswap_impl(i, std::make_index_sequence<sizeof(i)>{});
}

int main()
{
    printer(1, 2, 3, "abc");
    print_limits<uint8_t, uint16_t, uint32_t>();

    std::vector<int> v;
    push_back_vec(v, 6, 2, 45, 12);
    push_back_vec(v, 1, 2, 9);
    for (int i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    static_assert(bswap<std::uint16_t>(0x1234u) == 0x3412u);
    static_assert(bswap<std::uint64_t>(0x0123456789abcdefull) == 0xefcdab8967452301ULL);
}

输出： 

123abc
255 65535 4294967295 
6 2 45 12 1 2 9

引用

  • C++23 标准（ISO/IEC 14882:2024）：
  • 7.5.6 Fold expressions [expr.prim.fold]
  • C++20 标准（ISO/IEC 14882:2020）：
  • 7.5.6 Fold expressions [expr.prim.fold]
  • C++17 标准（ISO/IEC 14882:2017）：
  • 8.1.6 Fold expressions [expr.prim.fold]

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
CWG 2611 C++17 折叠表达式的展开结果没有用圆括号包围 用圆括号包围