Namespaces
Variants

Fold expressions (since C++17)

From cppreference.net
C++
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous
Expressions
General
Literals
Operators
Conversions
Templates

Réduit ( plie ) un pack à l'aide d'un opérateur binaire.

Table des matières

Syntaxe

( pack op ... ) (1)
( ... op pack ) (2)
( pack op ... op init ) (3)
( init op ... op pack ) (4)
1) Pliage unaire à droite.
2) Pliage unaire à gauche.
3) Pliage binaire à droite.
4) Pliage binaire à gauche.
op - l'un des 32 opérateurs binaires suivants : + - * / % ^ & | = < > << >> + = - = * = / = % = ^ = & = | = <<= >>= == ! = <= >= && || , . * - > * . Dans un pli binaire, les deux op doivent être identiques.
pack - une expression qui contient un pack non développé et ne contient pas d'opérateur avec une précédence inférieure au cast au niveau supérieur (formellement, une cast-expression )
init - une expression qui ne contient pas de pack non développé et ne contient pas d'opérateur avec une précédence inférieure au cast au niveau supérieur (formellement, une cast-expression )

Notez que les parenthèses ouvrantes et fermantes font partie intégrante de l'expression de repliement.

Explication

L'instanciation d'une expression de repli développe l'expression e comme suit :

1) Pliage unaire à droite (E op ...) devient (E 1 op ( ... op (E N-1 op E N )))
2) Pliage unaire à gauche (... op E) devient (((E 1 op E 2 ) op ... ) op E N )
3) Pliage binaire à droite (E op ... op I) devient (E 1 op ( ... op (E N−1 op (E N op I))))
4) Pliage binaire à gauche (I op ... op E) devient ((((I op E 1 ) op E 2 ) op ... ) op E N )

(où N est le nombre d'éléments dans l'expansion du pack)

Par exemple, 

template<typename... Args>
bool all(Args... args) { return (... && args); }
bool b = all(true, true, true, false);
// dans all(), le pliage unaire gauche se développe comme
//  return ((true && true) && true) && false;
// b est false

Lorsqu'un repliement unaire est utilisé avec une expansion de paquet de longueur zéro, seuls les opérateurs suivants sont autorisés :

1) ET logique ( && ). La valeur pour le pack vide est true .
2) OU logique ( || ). La valeur pour le pack vide est false .
3) L'opérateur virgule ( , ). La valeur pour le pack vide est void ( ) .

Notes

Si l'expression utilisée comme init ou comme pack a un opérateur avec une priorité inférieure au cast au niveau supérieur, elle doit être mise entre parenthèses : 

template<typename... Args>
int sum(Args&&... args)
{
//  return (args + ... + 1 * 2);   // Erreur : opérateur avec précédence inférieure au cast
    return (args + ... + (1 * 2)); // OK
}
Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_fold_expressions 201603L (C++17) Expressions de repli

Exemple

Exécuter ce code 
#include <climits>
#include <concepts>
#include <cstdint>
#include <iostream>
#include <limits>
#include <type_traits>
#include <utility>
#include <vector>
// Utilisation basique, pliage des arguments variadiques sur operator<<
template<typename... Args>
void printer(Args&&... args)
{
    (std::cout << ... << args) << '\n';
}
// Pliage d'une expression utilisant directement le pack sur operator,
template<typename... Ts>
void print_limits()
{
    ((std::cout << +std::numeric_limits<Ts>::max() << ' '), ...) << '\n';
}
// Pliage sur operator&& utilisant le pack
// et sur operator, utilisant les arguments variadiques
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)), ...);
}
// Utilisation d'une séquence d'entiers pour exécuter une expression
// N fois en pliant un lambda sur operator,
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);
}

Sortie : 

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

Références

  • Norme C++23 (ISO/IEC 14882:2024) :
  • 7.5.6 Expressions de repli [expr.prim.fold]
  • Norme C++20 (ISO/CEI 14882:2020) :
  • 7.5.6 Expressions de repli [expr.prim.fold]
  • Norme C++17 (ISO/CEI 14882:2017) :
  • 8.1.6 Expressions de repli [expr.prim.fold]

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
CWG 2611 C++17 les résultats d'expansion des expressions de repli n'étaient pas entourés de parenthèses entourés de parenthèses