Namespaces
Variants

std::ranges:: fold_right_last

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
(C++23)
fold_right_last
(C++23)
Operations on uninitialized storage
Return types
Definiert im Header <algorithm>
Aufrufsignatur
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

fold_right_last ( I first, S last, F f ) ;
(1) (seit C++23)
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

fold_right_last ( R && r, F f ) ;
(2) (seit C++23)
Hilfskonzepte
template < class F, class T, class I >
concept /*indirectly-binary-left-foldable*/ = /* siehe Beschreibung */ ;
(3) ( nur zur Darstellung* )
template < class F, class T, class I >
concept /*indirectly-binary-right-foldable*/ = /* siehe Beschreibung */ ;
(4) ( nur zur Darstellung* )

Faltet die Elemente des gegebenen Bereichs von rechts nach rechts , das heißt, gibt das Ergebnis der Auswertung des Kettenausdrucks zurück:
f(x 1 , f(x 2 , ...f(x n-1 , x n ))) , wobei x 1 , x 2 , ..., x n die Elemente des Bereichs sind.

Informell verhält sich ranges::fold_right_last wie ranges:: fold_left ( views:: reverse ( r ) , *-- last, /*flipped*/ ( f ) ) (unter der Annahme, dass der Bereich nicht leer ist).

Das Verhalten ist undefiniert, falls [ first , last ) kein gültiger Bereich ist.

1) Der Bereich ist [ first , last ) . Mit U als decltype ( ranges:: fold_right ( first, last, std:: iter_value_t < I > ( * first ) , f ) ) , entspricht dies: 
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)));
2) Gleich wie (1) , außer dass r als Bereich verwendet wird, als würde man ranges:: begin ( r ) als first und ranges:: end ( r ) als last verwenden.
3) Entspricht:
Hilfskonzepte
template < class F, class T, class I, class U >

concept /*indirectly-binary-left-foldable-impl*/ =
std:: movable < T > &&
std:: movable < U > &&
std:: convertible_to < T, U > &&
std:: invocable < F & , U, std:: iter_reference_t < I >> &&
std:: assignable_from < U & ,

std:: invoke_result_t < F & , U, std:: iter_reference_t < I >>> ;
(3A) ( Nur zur Darstellung* )
template < class F, class T, class I >

concept /*indirectly-binary-left-foldable*/ =
std:: copy_constructible < F > &&
std:: indirectly_readable < I > &&
std:: invocable < F & , T, std:: iter_reference_t < I >> &&
std:: convertible_to < std:: invoke_result_t < F & , T, std:: iter_reference_t < I >> ,
std:: decay_t < std:: invoke_result_t < F & , T, std:: iter_reference_t < I >>>> &&
/*indirectly-binary-left-foldable-impl*/ < F, T, I,

std:: decay_t < std:: invoke_result_t < F & , T, std:: iter_reference_t < I >>>> ;
(3B) ( Nur zur Darstellung* )
4) Entspricht:
Hilfskonzepte
template < class F, class T, class I >

concept /*indirectly-binary-right-foldable*/ =

/*indirectly-binary-left-foldable*/ < /*flipped*/ < F > , T, I > ;
(4A) ( Nur zur Darstellung* )
Hilfsklassen-Templates
template < class F >

class /*flipped*/
{
F f ; // exposition only
public :
template < class T, class U >
requires std:: invocable < F & , U, T >
std:: invoke_result_t < F & , U, T > operator ( ) ( T && , U && ) ;

} ;
(4B) ( Nur zur Darstellung* )

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

Inhaltsverzeichnis

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 Funktionsobjekt

Rückgabewert

Ein Objekt vom Typ std:: optional < U > , das das Ergebnis der Rechts- Faltung des gegebenen Bereichs über f enthält.

Wenn der Bereich leer ist, std:: optional < U > ( ) wird zurückgegeben.

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;

Komplexität

Genau ranges:: distance ( first, last ) Anwendungen des Funktionsobjekts f .

Hinweise

Die folgende Tabelle vergleicht alle Algorithmen für beschränktes Falten:

Fold-Funktionsvorlage Startet von Anfangswert Rückgabetyp
ranges:: fold_left links init U
ranges:: fold_left_first links erstes Element std:: optional < U >
ranges:: fold_right rechts init U
ranges :: fold_right_last rechts letztes Element std:: optional < U >
ranges:: fold_left_with_iter links init

(1) ranges:: in_value_result < I, U >

(2) ranges:: in_value_result < BR, U > ,

wobei BR ist ranges:: borrowed_iterator_t < R >

ranges:: fold_left_first_with_iter links erstes Element

(1) ranges:: in_value_result < I, std:: optional < U >>

(2) ranges:: in_value_result < BR, std:: optional < U >>

wobei BR ist ranges:: borrowed_iterator_t < R >

Feature-Test Makro Wert Std Feature
__cpp_lib_ranges_fold 202207L (C++23) std::ranges Fold-Algorithmen

Beispiel

Diesen Code ausführen 
#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';
    // Verwenden eines programmdefinierten Funktionsobjekts (Lambda-Ausdruck):
    auto r3 = std::ranges::fold_right_last(v, [](int x, int y) { return x + y + 99; });
    std::cout << "*r3: " << *r3 << '\n';
    // Produkt der std::pair::second aller Paare im Vektor ermitteln:
    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

Referenzen

  • C++23-Standard (ISO/IEC 14882:2024):
  • 27.6.18 Fold [alg.fold]

Siehe auch

(C++23)
rechts-faltet eine Reihe von Elementen
(Algorithmus-Funktionsobjekt)
(C++23)
links-faltet eine Reihe von Elementen
(Algorithmus-Funktionsobjekt)
(C++23)
links-faltet eine Reihe von Elementen unter Verwendung des ersten Elements als Anfangswert
(Algorithmus-Funktionsobjekt)
(C++23)
links-faltet eine Reihe von Elementen und gibt ein Paar (Iterator, Wert) zurück
(Algorithmus-Funktionsobjekt)
(C++23)
links-faltet eine Reihe von Elementen unter Verwendung des ersten Elements als Anfangswert und gibt ein Paar (Iterator, optional ) zurück
(Algorithmus-Funktionsobjekt)
summiert oder faltet eine Reihe von Elementen
(Funktions-Template)
(C++17)
ähnlich wie std::accumulate , jedoch außerhalb der Reihenfolge
(Funktions-Template)