std::ranges::fold_left_first
| Definiert in Header <algorithm> |
||
| Aufruf-Signatur |
||
| template< std::input_iterator I, std::sentinel_for<I> S, /*indirekt-links-faltbar*/<std::iter_value_t<I>, I> F > |
(1) | (seit C++23) |
| template< ranges::input_range R, /*indirekt-links-faltbar*/< |
(2) | (seit C++23) |
| Hilfskonzepte |
||
| template< class F, class T, class I > concept /*indirekt-links-faltbar*/ = /* siehe Beschreibung */; |
(3) | (nur Exposition*) |
Links (higher-order function) [Fold (higher-order function)] die Elemente des gegebenen Bereichs, d. h. gibt das Ergebnis der Auswertung des Kettenausdrucks zurückf(f(f(f(x1, x2), x3), ...), xn), wobei x1, x2, ..., xn Elemente des Bereichs sind.
Informell verhält sich ranges::fold_left_first wie die Überladung von std::accumulate, die ein binäres Prädikat akzeptiert, mit dem Unterschied, dass *first intern als anfängliches Element verwendet wird.
Das Verhalten ist undefiniert, wenn [first, last) kein gültiger Bereich ist.
[first, last). Entspricht return ranges::fold_left_first_with_iter(std::move(first), last, f).value.| Hilfskonzepte |
||
| template< class F, class T, class I, class U > concept /*indirectly-binary-left-foldable-impl*/ = |
(3A) | (nur Exposition*) |
| template< class F, class T, class I > concept /*indirectly-binary-left-foldable*/ = |
(3B) | (nur Exposition*) |
Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.
- Können explizite Template-Argumentlisten bei keinem von ihnen angegeben werden.
- Keiner von ihnen ist für Argument-abhängige Suche sichtbar.
- Wenn einer von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die Argument-abhängige Suche unterdrückt.
Inhalt |
[edit] Parameter
| first, last | - | das Iterator-Sentinel-Paar, das den Bereich der zu faltenden Elemente definiert |
| r | - | der Bereich der zu faltenden Elemente |
| f | - | das binäre Funktions-Objekt |
[edit] Rückgabewert
Ein Objekt vom Typ std::optional<U>, das das Ergebnis des linken Faltens des gegebenen Bereichs über f enthält, wobei U äquivalent zu decltype(ranges::fold_left(std::move(first), last, std::iter_value_t<I>(*first), f)) ist.
Wenn der Bereich leer ist, wird std::optional<U>() zurückgegeben.
[edit] Mögliche Implementierungen
struct fold_left_first_fn { template<std::input_iterator I, std::sentinel_for<I> S, /*indirectly-binary-left-foldable*/<std::iter_value_t<I>, I> F> requires std::constructible_from<std::iter_value_t<I>, std::iter_reference_t<I>> constexpr auto operator()(I first, S last, F f) const { using U = decltype( ranges::fold_left(std::move(first), last, std::iter_value_t<I>(*first), f) ); if (first == last) return std::optional<U>(); std::optional<U> init(std::in_place, *first); for (++first; first != last; ++first) *init = std::invoke(f, std::move(*init), *first); return std::move(init); } template<ranges::input_range R, /*indirectly-binary-left-foldable*/< ranges::range_value_t<R>, ranges::iterator_t<R>> F> requires std::constructible_from<ranges::range_value_t<R>, ranges::range_reference_t<R>> constexpr auto operator()(R&& r, F f) const { return (*this)(ranges::begin(r), ranges::end(r), std::ref(f)); } }; inline constexpr fold_left_first_fn fold_left_first; |
[edit] Komplexität
Genau ranges::distance(first, last) - 1 (vorausgesetzt, der Bereich ist nicht leer) Anwendungen des Funktionsobjekts f.
[edit] Anmerkungen
Die folgende Tabelle vergleicht alle eingeschränkten Faltungsalgorithmen
| Faltungs-Funktionstemplate | Beginnt von | Anfangswert | Rückgabetyp |
|---|---|---|---|
| ranges::fold_left | left | init | U |
| ranges::fold_left_first | left | erstes Element | std::optional<U> |
| ranges::fold_right | right | init | U |
| ranges::fold_right_last | right | letztes Element | std::optional<U> |
| ranges::fold_left_with_iter | left | init |
(1) ranges::in_value_result<I, U> (2) ranges::in_value_result<BR, U>, wobei BR ranges::borrowed_iterator_t<R> ist |
| ranges::fold_left_first_with_iter | left | erstes Element |
(1) ranges::in_value_result<I, std::optional<U>> (2) ranges::in_value_result<BR, std::optional<U>> wobei BR ranges::borrowed_iterator_t<R> ist |
| Feature-Test-Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_ranges_fold |
202207L |
(C++23) | std::ranges Fold-Algorithmen |
[edit] Beispiel
#include <algorithm> #include <array> #include <functional> #include <ranges> #include <utility> int main() { constexpr std::array v{1, 2, 3, 4, 5, 6, 7, 8}; static_assert ( *std::ranges::fold_left_first(v.begin(), v.end(), std::plus{}) == 36 && *std::ranges::fold_left_first(v, std::multiplies{}) == 40320 ); constexpr std::array w { 1, 2, 3, 4, 13, 1, 2, 3, 4, 13, 1, 2, 3, 4, 13, 1, 2, 3, 4, }; static_assert ( "Find the only value that (by precondition) occurs odd number of times:" && *std::ranges::fold_left_first(w, [](int p, int q){ return p ^ q; }) == 13 ); constexpr auto pairs = std::to_array<std::pair<char, float>> ({ {'A', 3.0f}, {'B', 3.5f}, {'C', 4.0f} }); static_assert ( "Get the product of all pair::second in pairs:" && *std::ranges::fold_left_first ( pairs | std::ranges::views::values, std::multiplies{} ) == 42 ); }
[edit] Referenzen
- C++23 Standard (ISO/IEC 14882:2024)
- 27.6.18 Fold [alg.fold]
[edit] Siehe auch
| (C++23) |
Faltet einen Elementbereich von links (Algorithmus-Funktionsobjekt) |
| (C++23) |
Faltet einen Elementbereich von rechts (Algorithmus-Funktionsobjekt) |
| (C++23) |
Faltet einen Elementbereich von rechts unter Verwendung des letzten Elements als Anfangswert (Algorithmus-Funktionsobjekt) |
| (C++23) |
Faltet einen Elementbereich von links und gibt ein Paar (Iterator, Wert) zurück (Algorithmus-Funktionsobjekt) |
| Faltet einen Elementbereich von links unter Verwendung des ersten Elements als Anfangswert und gibt ein Paar (Iterator, optional) zurück (Algorithmus-Funktionsobjekt) | |
| summiert oder faltet eine Reihe von Elementen (Funktionstemplate) | |
| (C++17) |
ähnlich wie std::accumulate, aber nicht-sequenziell (Funktionstemplate) |
