std::ranges::fold_right_last
| Definiert in Header <algorithm> |
||
| Aufruf-Signatur |
||
| template< std::bidirectional_iterator I, std::sentinel_for<I> S, /*indirekt-binär-rechts-faltbar*/<std::iter_value_t<I>, I> F > |
(1) | (seit C++23) |
| template< ranges::bidirectional_range R, /*indirekt-binär-rechts-faltbar*/< |
(2) | (seit C++23) |
| Hilfskonzepte |
||
| template< class F, class T, class I > concept /*indirekt-links-faltbar*/ = /* siehe Beschreibung */; |
(3) | (nur Exposition*) |
| template< class F, class T, class I > concept /*indirekt-binär-rechts-faltbar*/ = /* siehe Beschreibung */; |
(4) | (nur Exposition*) |
Faltet die Elemente des gegebenen Bereichs von rechts, d.h. gibt das Ergebnis der Auswertung des Kettenausdrucks zurückf(x1, f(x2, ...f(xn-1, xn))), wobei x1, x2, ..., xn Elemente des Bereichs sind.
Informell verhält sich ranges::fold_right_last wie ranges::fold_left(views::reverse(r), *--last, /*flipped*/(f)) (vorausgesetzt, der Bereich ist nicht leer).
Das Verhalten ist undefiniert, wenn [first, last) kein gültiger Bereich ist.
[first, last). Gegeben U als decltype(ranges::fold_right(first, last, std::iter_value_t<I>(*first), f)), äquivalent zuif (first == last) return std::optional<U>(); I tail = ranges::prev(ranges::next(first, std::move(last))); return std::optional<U>(std::in_place, ranges::fold_right(std::move(first), tail, std::iter_value_t<I>(*tail), std::move(f)));
| 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*) |
| Hilfskonzepte |
||
| template< class F, class T, class I > concept /*indirekt-binär-rechts-faltbar*/ = |
(4A) | (nur Exposition*) |
| Hilfsklassen-Templates |
||
| template< class F > class /*flipped*/ |
(4B) | (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
Ein Objekt vom Typ std::optional<U>, das das Ergebnis der Rechtsfaltung des gegebenen Bereichs über f enthält.
Wenn der Bereich leer ist, wird std::optional<U>() zurückgegeben.
[bearbeiten] Mögliche Implementierungen
struct fold_right_last_fn { template<std::bidirectional_iterator I, std::sentinel_for<I> S, /*indirectly-binary-right-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_right(first, last, std::iter_value_t<I>(*first), f)); if (first == last) return std::optional<U>(); I tail = ranges::prev(ranges::next(first, std::move(last))); return std::optional<U>(std::in_place, ranges::fold_right(std::move(first), tail, std::iter_value_t<I>(*tail), std::move(f))); } template<ranges::bidirectional_range R, /*indirectly_binary_right_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_right_last_fn fold_right_last; |
[bearbeiten] Komplexität
Genau ranges::distance(first, last) Anwendungen des Funktions-Objekts 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 <functional> #include <iostream> #include <ranges> #include <utility> #include <vector> int main() { auto v = {1, 2, 3, 4, 5, 6, 7, 8}; std::vector<std::string> vs {"A", "B", "C", "D"}; auto r1 = std::ranges::fold_right_last(v.begin(), v.end(), std::plus<>()); // (1) std::cout << "*r1: " << *r1 << '\n'; auto r2 = std::ranges::fold_right_last(vs, std::plus<>()); // (2) std::cout << "*r2: " << *r2 << '\n'; // Use a program defined function object (lambda-expression): auto r3 = std::ranges::fold_right_last(v, [](int x, int y) { return x + y + 99; }); std::cout << "*r3: " << *r3 << '\n'; // Get the product of the std::pair::second of all pairs in the vector: std::vector<std::pair<char, float>> data {{'A', 3.f}, {'B', 3.5f}, {'C', 4.f}}; auto r4 = std::ranges::fold_right_last ( data | std::ranges::views::values, std::multiplies<>() ); std::cout << "*r4: " << *r4 << '\n'; }
Ausgabe
*r1: 36 *r2: ABCD *r3: 729 *r4: 42
[bearbeiten] Referenzen
- C++23 Standard (ISO/IEC 14882:2024)
- 27.6.18 Fold [alg.fold]
[bearbeiten] Siehe auch
| (C++23) |
Faltet einen Elementbereich von rechts (Algorithmus-Funktionsobjekt) |
| (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 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) |
