std::ranges::fold_right_last

Défini dans l'en-tête `<algorithm>`
Signature d'appel
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)	(depuis 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)	(depuis C++23)
Concepts auxiliaires
template< class F, class T, class I > concept /indirectly-binary-left-foldable/ = /* see description */;	(3)	(exposé uniquement*)
template< class F, class T, class I > concept /indirectly-binary-right-foldable/ = /* see description */;	(4)	(exposé uniquement*)

Plie à droite les éléments de l'intervalle donné, c'est-à-dire retourne le résultat de l'évaluation de l'expression en chaîne :, où
f(x₁, f(x₂, ...f(x_n-1, x_n))), x₁, ..., x₂ sont les éléments de l'intervalle. x_nInformellement,

se comporte comme ranges::fold_right_last (en supposant que l'intervalle n'est pas vide). ranges::fold_left(views::reverse(r), *--last, /*flipped*/(f))Le comportement est indéfini si

n'est pas un intervalle valide. [first, last)1)

L'intervalle est . Étant donné [first, last) comme U, équivaut à : decltype(ranges::fold_right(first, last, std::iter_value_t<I>(*first), f))2)

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)));

Identique à (1), sauf qu'il utilise comme intervalle, comme si en utilisant r comme ranges::begin(r) et first comme ranges::end(r).last3)

Équivaut à : Concepts auxiliaires

(3A)
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>>>;	(	exposé uniquement*) (3B)
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>>>>;	(	exposé uniquement*)4)

Équivaut à : Concepts auxiliaires

(4A)
template< class F, class T, class I > concept /indirectly-binary-right-foldable/ = /indirectly-binary-left-foldable/</flipped/<F>, T, I>;	(	exposé uniquement*)Classes auxiliaires de modèles
(4B)
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&& ); };	(	exposé uniquement*)Les entités de type fonction décrites sur cette page sont des

objets fonctions d'algorithme (informellement appelés niebloids), c'est-à-dire : Les listes d'arguments de template explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'entre eux.

Aucun d'entre eux n'est visible par la
recherche dépendante des arguments.Lorsque l'un d'entre eux est trouvé par une
recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.Contenu

first, last

-	la paire itérateur-sentinelle définissant l'	intervalle d'éléments à plier r
-	l'intervalle d'éléments à plier	f
-	l'objet fonction binaire	Valeur de retour

Un objet de type

qui contient le résultat du std::optional<U>pliage à droite de l'intervalle donné sur . fSi l'intervalle est vide,

est retourné. std::optional<U>()Implémentations possibles

Complexité

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;

Exactement

applications de l'objet fonction ranges::distance(first, last). fNotes

Le tableau suivant compare tous les algorithmes de pliage contraints :

Fonction template de pliage

Commence par	Valeur initiale	Type de retour	gauche
`ranges::fold_left`	gauche	`init`	`U`
`ranges::fold_left_first`	premier élément	droite	`std::optional<U>`
`ranges::fold_right`	droite	`init`	`U`
`ranges::fold_right_last`	dernier élément	gauche	`std::optional<U>`
`ranges::fold_left_with_iter`	(1)	`init`	(2) `ranges::in_value_result<I, U>` , `ranges::in_value_result<BR, U>`où est `BR`gauche`ranges::borrowed_iterator_t<R>`
`ranges::fold_left_first_with_iter`	premier élément	(1)	(2) `ranges::in_value_result<I, std::optional<U>>` où `ranges::in_value_result<BR, std::optional<U>>` est `BR`Macro de test`ranges::borrowed_iterator_t<R>`

de fonctionnalitéValeur	Std	Fonctionnalité	(C++23)
`__cpp_lib_ranges_fold`	`202207L`	algorithmes de pliage	`std::ranges` Exemple

Exécuter ce code

Sortie :

#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';
}

Références

*r1: 36
*r2: ABCD
*r3: 729
*r4: 42

Norme C++23 (ISO/IEC 14882:2024) :

27.6.18 Pliage

alg.fold[Voir aussi]

ranges::fold_right

(C++23) plie à droite un intervalle d'éléments	(objet fonction d'algorithme) ranges::fold_left
(C++23) plie à gauche un intervalle d'éléments	(objet fonction d'algorithme) ranges::fold_left_first
(C++23) plie à gauche un intervalle d'éléments en utilisant le premier élément comme valeur initiale	(objet fonction d'algorithme) ranges::fold_left_with_iter
(C++23) plie à gauche un intervalle d'éléments et retourne une	paire (itérateur, valeur)(objet fonction d'algorithme) ranges::fold_left_first_with_iter
(C++23) plie à gauche un intervalle d'éléments en utilisant le premier élément comme valeur initiale et retourne une	paire (itérateur, optionnel)(objet fonction d'algorithme) accumulate
additionne ou plie un intervalle d'éléments	(fonction template) reduce
(C++17) similaire à	std::accumulate, sauf en désordre (fonction template)

Support du compilateur
Indépendant et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants