Fold expressions (since C++17)
Reduziert ( faltet ) ein Pack über einen binären Operator.
Inhaltsverzeichnis |
Syntax
(
Packung op
... )
|
(1) | ||||||||
( ...
op Packung
)
|
(2) | ||||||||
(
Packung op
...
op Initialisierung
)
|
(3) | ||||||||
(
Initialisierung op
...
op Packung
)
|
(4) | ||||||||
| op | - | einer der folgenden 32 binären Operatoren: + - * / % ^ & | = < > << >> + = - = * = / = % = ^ = & = | = <<= >>= == ! = <= >= && || , . * - > * . In einer binären Faltung müssen beide op s identisch sein. |
| pack | - | ein Ausdruck, der ein unentfaltetes Pack enthält und keinen Operator mit Präzedenz niedriger als Cast auf oberster Ebene enthält (formal ein cast-expression ) |
| init | - | ein Ausdruck, der kein unentfaltetes Pack enthält und keinen Operator mit Präzedenz niedriger als Cast auf oberster Ebene enthält (formal ein cast-expression ) |
Beachten Sie, dass die öffnende und schließende Klammer ein erforderlicher Teil des Fold-Ausdrucks sind.
Erklärung
Die Instanziierung eines fold expression erweitert den Ausdruck e wie folgt:
(E
op
...)
wird zu
(E
1
op
(
...
op
(E
N-1
op
E
N
)))
(...
op
E)
wird zu
(((E
1
op
E
2
)
op
...
)
op
E
N
)
(E
op
...
op
I)
wird zu
(E
1
op
(
...
op
(E
N−1
op
(E
N
op
I))))
(I
op
...
op
E)
wird zu
((((I
op
E
1
)
op
E
2
)
op
...
)
op
E
N
)
(wobei
N
die Anzahl der Elemente in der Paketentwicklung ist)
Zum Beispiel,
template<typename... Args> bool all(Args... args) { return (... && args); } bool b = all(true, true, true, false); // innerhalb von all() expandiert die unäre Linksfaltung als // return ((true && true) && true) && false; // b ist false
Wenn ein unärer Fold mit einer Pack-Erweiterung der Länge null verwendet wird, sind nur die folgenden Operatoren erlaubt:
Hinweise
Wenn der Ausdruck, der als init oder als pack verwendet wird, einen Operator mit precedence unterhalb von cast auf oberster Ebene hat, muss er in Klammern gesetzt werden:
template<typename... Args> int sum(Args&&... args) { // return (args + ... + 1 * 2); // Fehler: Operator mit niedrigerer Priorität als Cast return (args + ... + (1 * 2)); // OK }
| Feature-Test-Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_fold_expressions
|
201603L
|
(C++17) | Fold-Ausdrücke |
Beispiel
#include <climits> #include <concepts> #include <cstdint> #include <iostream> #include <limits> #include <type_traits> #include <utility> #include <vector> // Grundlegende Verwendung, Faltung variadischer Argumente über operator<< template<typename... Args> void printer(Args&&... args) { (std::cout << ... << args) << '\n'; } // Faltung eines Ausdrucks, der das Pack direkt über operator, verwendet template<typename... Ts> void print_limits() { ((std::cout << +std::numeric_limits<Ts>::max() << ' '), ...) << '\n'; } // Sowohl eine Faltung über operator&& unter Verwendung des Packs // als auch über operator, unter Verwendung der variadischen Argumente 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)), ...); } // Verwendung einer Integer-Sequenz zur Ausführung eines Ausdrucks // N-mal durch Faltung eines Lambda über 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
Referenzen
- C++23-Standard (ISO/IEC 14882:2024):
-
- 7.5.6 Fold-Ausdrücke [expr.prim.fold]
- C++20-Standard (ISO/IEC 14882:2020):
-
- 7.5.6 Fold-Ausdrücke [expr.prim.fold]
- C++17-Standard (ISO/IEC 14882:2017):
-
- 8.1.6 Fold-Ausdrücke [expr.prim.fold]
Fehlerberichte
Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | Angewendet auf | Verhalten wie veröffentlicht | Korrektes Verhalten |
|---|---|---|---|
| CWG 2611 | C++17 | die Expansionsergebnisse von Fold-Ausdrücken waren nicht in Klammern eingeschlossen | in Klammern eingeschlossen |