std::ranges::fold_left_first_with_iter, std::ranges::fold_left_first_with_iter_result
| Definiert in Header <algorithm> |
||
| Aufruf-Signatur |
||
| template< std::input_iterator I, std::sentinel_for<I> S, /*indirectly-binary-left-foldable*/<std::iter_value_t<I>, I> F > |
(1) | (seit C++23) |
| template< ranges::input_range R, /*indirectly-binary-left-foldable*/< |
(2) | (seit C++23) |
| Hilfskonzepte |
||
| template< class F, class T, class I > concept /*indirekt-links-faltbar*/ = /* siehe Beschreibung */; |
(3) | (nur Exposition*) |
| Hilfsklassen-Template |
||
| template< class I, class T > using fold_left_first_with_iter_result = ranges::in_value_result<I, T>; |
(4) | (seit C++23) |
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_with_iter wie die Überladung von std::accumulate, die ein binäres Prädikat akzeptiert, außer dass *first intern als initiales Element verwendet wird.
Das Verhalten ist undefiniert, wenn [first, last) kein gültiger Bereich ist.
[first, last).| 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 |
[bearbeiten] 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 |
[bearbeiten] Rückgabewert
Sei U decltype(ranges::fold_left(std::move(first), last, std::iter_value_t<I>(*first), f)).
- Das Mitglied ranges::in_value_result::in enthält einen Iterator zum Ende des Bereichs.
- Das Mitglied ranges::in_value_result::value enthält das Ergebnis des Links-Faltens (fold) des gegebenen Bereichs über f.
[bearbeiten] Mögliche Implementierungen
class fold_left_first_with_iter_fn { template<class O, class I, class S, class F> constexpr auto impl(I&& first, S&& last, F f) const { using U = decltype( ranges::fold_left(std::move(first), last, std::iter_value_t<I>(*first), f) ); using Ret = ranges::fold_left_first_with_iter_result<O, std::optional<U>>; if (first == last) return Ret{std::move(first), 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 Ret{std::move(first), std::move(init)}; } public: 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 { return impl<I>(std::move(first), std::move(last), std::ref(f)); } 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 impl<ranges::borrowed_iterator_t<R>>( ranges::begin(r), ranges::end(r), std::ref(f) ); } }; inline constexpr fold_left_first_with_iter_fn fold_left_first_with_iter; |
[bearbeiten] Komplexität
Genau ranges::distance(first, last) - 1 (vorausgesetzt, der Bereich ist nicht leer) Anwendungen des Funktionsobjekts f.
[bearbeiten] Hinweise
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 |
[bearbeiten] Beispiel
#include <algorithm> #include <cassert> #include <functional> #include <iostream> #include <ranges> #include <utility> #include <vector> int main() { std::vector v{1, 2, 3, 4, 5, 6, 7, 8}; auto sum = std::ranges::fold_left_first_with_iter ( v.begin(), v.end(), std::plus<int>() ); std::cout << "sum: " << sum.value.value() << '\n'; assert(sum.in == v.end()); auto mul = std::ranges::fold_left_first_with_iter(v, std::multiplies<int>()); std::cout << "mul: " << mul.value.value() << '\n'; assert(mul.in == v.end()); // get the product of the std::pair::second of all pairs in the vector: std::vector<std::pair<char, float>> data {{'A', 2.f}, {'B', 3.f}, {'C', 7.f}}; auto sec = std::ranges::fold_left_first_with_iter ( data | std::ranges::views::values, std::multiplies<>() ); std::cout << "sec: " << sec.value.value() << '\n'; // use a program defined function object (lambda-expression): auto lambda = [](int x, int y) { return x + y + 2; }; auto val = std::ranges::fold_left_first_with_iter(v, lambda); std::cout << "val: " << val.value.value() << '\n'; assert(val.in == v.end()); }
Ausgabe
sum: 36 mul: 40320 sec: 42 val: 50
[bearbeiten] Referenzen
- C++23 Standard (ISO/IEC 14882:2024)
- 27.6.18 Fold [alg.fold]
[bearbeiten] Siehe auch
| (C++23) |
Faltet einen Elementbereich von links (Algorithmus-Funktionsobjekt) |
| (C++23) |
Faltet einen Elementbereich von links unter Verwendung des ersten Elements als Anfangswert (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) |
| summiert oder faltet eine Reihe von Elementen (Funktionstemplate) | |
| (C++17) |
ähnlich wie std::accumulate, aber nicht-sequenziell (Funktionstemplate) |
