Fold-Ausdrücke (seit C++17)
Von cppreference.com
Reduziert (faltet) ein Pack über einen binären Operator.
Inhalt |
[bearbeiten] Syntax
( pack op ... ) |
(1) | ||||||||
( ... op pack ) |
(2) | ||||||||
( pack op ... op init ) |
(3) | ||||||||
( init op ... op pack ) |
(4) | ||||||||
1) Unärer Rechts-Fold.
2) Unärer Links-Fold.
3) Binärer Rechts-Fold.
4) Binärer Links-Fold.
| op | - | einer der folgenden 32 binären Operatoren: + - * / % ^ & | = < > << >> += -= *= /= %= ^= &= |= <<= >>= == != <= >= && || , .* ->*. In einem binären Fold müssen beide ops gleich sein. |
| pack | - | ein Ausdruck, der ein nicht expandiertes Pack enthält und keinen Operator mit einer Präzedenz unterhalb von `cast` auf oberster Ebene enthält (formal ein cast-expression) |
| init | - | ein Ausdruck, der kein nicht expandiertes Pack enthält und keinen Operator mit einer Präzedenz unterhalb von `cast` auf oberster Ebene enthält (formal ein cast-expression) |
Beachten Sie, dass die öffnenden und schließenden Klammern ein erforderlicher Teil des Fold-Ausdrucks sind.
[bearbeiten] Erklärung
Die Instanziierung eines Fold-Ausdrucks erweitert den Ausdruck e wie folgt:
1) Unärer Rechts-Fold
(E op ...) wird zu (E1 op (... op (EN-1 op EN)))2) Unärer Links-Fold
(... op E) wird zu (((E1 op E2) op ...) op EN)3) Binärer Rechts-Fold
(E op ... op I) wird zu (E1 op (... op (EN-1 op (EN op I))))4) Binärer Links-Fold
(I op ... op E) wird zu ((((I op E1) op E2) op ...) op EN)(wobei N die Anzahl der Elemente in der Pack-Expansion ist)
Zum Beispiel,
template<typename... Args> bool all(Args... args) { return (... && args); } bool b = all(true, true, true, false); // within all(), the unary left fold expands as // return ((true && true) && true) && false; // b is false
Wenn ein unärer Fold mit einer Pack-Expansion der Länge Null verwendet wird, sind nur die folgenden Operatoren erlaubt:
1) Logisches UND (&&). Der Wert für das leere Pack ist true.
2) Logisches ODER (||). Der Wert für das leere Pack ist false.
3) Der Komma-Operator (,). Der Wert für das leere Pack ist void().
[bearbeiten] Hinweise
Wenn der als init oder als pack verwendete Ausdruck einen Operator mit einer Präzedenz unterhalb von `cast` auf oberster Ebene hat, muss er in Klammern gesetzt werden.
template<typename... Args> int sum(Args&&... args) { // return (args + ... + 1 * 2); // Error: operator with precedence below cast return (args + ... + (1 * 2)); // OK }
| Feature-Testmakro | Wert | Std | Feature |
|---|---|---|---|
__cpp_fold_expressions |
201603L |
(C++17) | Falt-Ausdrücke |
[bearbeiten] Beispiel
Führen Sie diesen Code aus
#include <climits> #include <concepts> #include <cstdint> #include <iostream> #include <limits> #include <type_traits> #include <utility> #include <vector> // Basic usage, folding variadic arguments over operator<< template<typename... Args> void printer(Args&&... args) { (std::cout << ... << args) << '\n'; } // Folding an expression that uses the pack directly over operator, template<typename... Ts> void print_limits() { ((std::cout << +std::numeric_limits<Ts>::max() << ' '), ...) << '\n'; } // Both a fold over operator&& using the pack // and over operator, using the variadic arguments 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)), ...); } // Using an integer sequence to execute an expression // N times by folding a lambda over 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); }
Ausgabe
123abc 255 65535 4294967295 6 2 45 12 1 2 9
[bearbeiten] Referenzen
- C++23 Standard (ISO/IEC 14882:2024)
- 7.5.6 Fold expressions [expr.prim.fold]
- C++20 Standard (ISO/IEC 14882:2020)
- 7.5.6 Fold expressions [expr.prim.fold]
- C++17 Standard (ISO/IEC 14882:2017)
- 8.1.6 Fold expressions [expr.prim.fold]
[bearbeiten] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| CWG 2611 | C++17 | die Erweiterungsergebnisse von Fold-Ausdrücken waren nicht in Klammern gesetzt | in Klammern gesetzt |
