std::ranges::find_last, std::ranges::find_last_if, std::ranges::find_last_if_not

Défini dans l'en-tête `<algorithm>`
Signature d'appel
template< std::forward_iterator I, std::sentinel_for<I> S, class T, class Proj = std::identity > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr ranges::subrange<I> find_last( I first, S last, const T& value, Proj proj = {} );	(1)	(depuis C++23) (jusqu'à C++26)
template< std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr ranges::subrange<I> find_last( I first, S last, const T& value, Proj proj = {} );	(1)		(depuis C++26)
template< ranges::forward_range R, class T, class Proj = std::identity > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr ranges::borrowed_subrange_t<R> find_last( R&& r, const T& value, Proj proj = {} );	(2)	(depuis C++23) (jusqu'à C++26)
template< ranges::forward_range R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr ranges::borrowed_subrange_t<R> find_last( R&& r, const T& value, Proj proj = {} );	(2)		(depuis C++26)
template< std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > constexpr ranges::subrange<I> find_last_if( I first, S last, Pred pred, Proj proj = {} );	(3)	(depuis C++23)
template< ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred > constexpr ranges::borrowed_subrange_t<R> find_last_if( R&& r, Pred pred, Proj proj = {} );	(4)	(depuis C++23)
template< std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > constexpr ranges::subrange<I> find_last_if_not( I first, S last, Pred pred, Proj proj = {} );	(5)	(depuis C++23)
template< ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred > constexpr ranges::borrowed_subrange_t<R> find_last_if_not( R&& r, Pred pred, Proj proj = {} );	(6)	(depuis C++23)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> ranges::subrange<I> find_last( Ep&& policy, I first, S last, const T& value, Proj proj = {} );	(7)	(depuis C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj> > requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> ranges::borrowed_subrange_t<R> find_last( Ep&& policy, R&& r, const T& value, Proj proj = {} );	(8)	(depuis C++26)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > ranges::subrange<I> find_last_if( Ep&& policy, I first, S last, Pred pred, Proj proj = {} );	(9)	(depuis C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred > ranges::borrowed_subrange_t<R> find_last_if( Ep&& policy, R&& r, Pred pred, Proj proj = {} );	(10)	(depuis C++26)
template< /execution-policy/ Ep, std::random_access_iterator I, std::sized_sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > ranges::subrange<I> find_last_if_not( Ep&& policy, I first, S last, Pred pred, Proj proj = {} );	(11)	(depuis C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred > ranges::borrowed_subrange_t<R> find_last_if_not( Ep&& policy, R&& r, Pred pred, Proj proj = {} );	(12)	(depuis C++26)

Pour la définition de /*execution-policy*/, voir cette page; pour la définition de /*sized-random-access-range*/, voir cette page.

Renvoie le dernier élément (projeté par proj) dans la plage source [first, last) ou r qui satisfait des critères spécifiques :

1,2) find_last recherche le dernier élément égal à value.

3,4) find_last_if recherche le dernier élément pour lequel le prédicat pred renvoie true.

5,6) find_last_if_not recherche le dernier élément pour lequel le prédicat pred renvoie false.

7-12) Identique à (1-6), mais exécuté selon policy.

Les entités de type fonction décrites sur cette page sont des objets fonctions d'algorithmes (informellement appelés niebloids), c'est-à-dire :

Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'eux.
Aucun d'eux n'est visible par recherche dépendante des arguments.
Lorsque l'un d'eux est trouvé par 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.

Paramètres

first, last	-	la paire itérateur-sentinelle définissant la plage
r	-	la plage source
value	-	la valeur cible
pred	-	le prédicat à appliquer aux éléments (projetés)
proj	-	la projection à appliquer aux éléments
policy	-	la politique d'exécution à utiliser

Valeur de retour

Une sous-plage allant du dernier élément satisfaisant la condition jusqu'à la fin de la plage source, ou une plage vide si aucun élément de ce type n'est trouvé.

Complexité

Soit $\scriptsize N$ $N$ comme ranges::distance(first, last) ou ranges::distance(r) :

1,2) Au plus

N

comparaisons et applications de proj.

3-6) Au plus

N

applications de pred et proj.

7,8)

𝓞(N)

comparaisons et applications de proj.

9-12)

𝓞(N)

applications de pred et proj.

Exceptions

7-12) Pendant l'exécution :

Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est levée.
Si une exception non capturée est levée lors de l'accès aux objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour les politiques standard, std::terminate est invoqué).

Notes

ranges::find_last , ranges::find_last_if , ranges::find_last_if_not offrent une meilleure efficacité sur les implémentations courantes si I modélise bidirectional_iterator ou (encore mieux) random_access_iterator .

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_ranges_find_last`	`202207L`	(C++23)	`ranges::find_last` , `ranges::find_last_if` , `ranges::find_last_if_not`
`__cpp_lib_algorithm_default_value_type`	`202403L`	(C++26)	Initialisation par liste pour les algorithmes ( 1,2 )

Implémentation possible

Ces implémentations ne montrent que l'algorithme le plus lent utilisé lorsque I modélise forward_iterator.

find_last
struct find_last_fn { template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj>> requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T> constexpr ranges::subrange<I> operator()(I first, S last, const T &value, Proj proj = {}) const { // Note: if I is mere forward_iterator, we may only go from begin to end. std::optional<I> found; for (; first != last; ++first) if (std::invoke(proj, first) == value) found = first; if (!found) return {first, first}; return {found, ranges::next(found, last)}; } template<ranges::forward_range R, class Proj = std::identity, class T = std::projected_value_t<iterator_t<R>, Proj>> requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T> constexpr ranges::borrowed_subrange_t<R> operator()(R&& r, const T &value, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::next(ranges::begin(r), ranges::end(r)), value, std::ref(proj)); } }; inline constexpr find_last_fn find_last;
find_last_if
struct find_last_if_fn { template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> constexpr ranges::subrange<I> operator()(I first, S last, Pred pred, Proj proj = {}) const { // Note: if I is mere forward_iterator, we may only go from begin to end. std::optional<I> found; for (; first != last; ++first) if (std::invoke(pred, std::invoke(proj, first))) found = first; if (!found) return {first, first}; return {found, ranges::next(found, last)}; } template<ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred> constexpr ranges::borrowed_subrange_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::next(ranges::begin(r), ranges::end(r)), std::ref(pred), std::ref(proj)); } }; inline constexpr find_last_if_fn find_last_if;
find_last_if_not
struct find_last_if_not_fn { template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> constexpr ranges::subrange<I> operator()(I first, S last, Pred pred, Proj proj = {}) const { // Note: if I is mere forward_iterator, we may only go from begin to end. std::optional<I> found; for (; first != last; ++first) if (!std::invoke(pred, std::invoke(proj, first))) found = first; if (!found) return {first, first}; return {found, ranges::next(found, last)}; } template<ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred> constexpr ranges::borrowed_subrange_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::next(ranges::begin(r), ranges::end(r)), std::ref(pred), std::ref(proj)); } }; inline constexpr find_last_if_not_fn find_last_if_not;

Exemple

Exécuter ce code

#include <algorithm>
#include <cassert>
#include <forward_list>
#include <iomanip>
#include <iostream>
#include <string_view>
int main()
{
    namespace ranges = std::ranges;
    constexpr static auto v = {1, 2, 3, 1, 2, 3, 1, 2};
    {
        constexpr auto i1 = ranges::find_last(v.begin(), v.end(), 3);
        constexpr auto i2 = ranges::find_last(v, 3);
        static_assert(ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        constexpr auto i1 = ranges::find_last(v.begin(), v.end(), -3);
        constexpr auto i2 = ranges::find_last(v, -3);
        static_assert(i1.begin() == v.end());
        static_assert(i2.begin() == v.end());
    }
    auto abs = [](int x) { return x < 0 ? -x : x; };
    {
        auto pred = [](int x) { return x == 3; };
        constexpr auto i1 = ranges::find_last_if(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if(v, pred, abs);
        static_assert(ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        auto pred = [](int x) { return x == -3; };
        constexpr auto i1 = ranges::find_last_if(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if(v, pred, abs);
        static_assert(i1.begin() == v.end());
        static_assert(i2.begin() == v.end());
    }
    {
        auto pred = [](int x) { return x == 1 or x == 2; };
        constexpr auto i1 = ranges::find_last_if_not(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if_not(v, pred, abs);
        static_assert(ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        auto pred = [](int x) { return x == 1 or x == 2 or x == 3; };
        constexpr auto i1 = ranges::find_last_if_not(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if_not(v, pred, abs);
        static_assert(i1.begin() == v.end());
        static_assert(i2.begin() == v.end());
    }
    using P = std::pair<std::string_view, int>;
    std::forward_list<P> list
    {
        {"un", 1}, {"deux", 2}, {"trois", 3},
        {"un", 4}, {"deux", 5}, {"trois", 6},
    };
    auto cmp_one = [](const std::string_view &s) { return s == "un"; };
    // trouver le dernier élément qui satisfait le comparateur, en projetant pair::first
    const auto subrange = ranges::find_last_if(list, cmp_one, &P::premier);
    std::cout << "L'élément trouvé et la suite qui le suit sont :\n";
    for (P const& e : subrange)
        std::cout << '{' << std::quoted(e.premier) << ", " << e.second << "} ";
    std::cout << '\n';
#if __cpp_lib_algorithm_default_value_type
    const auto i3 = ranges::find_last(list, {"trois", 3}); // (2) C++26
#else
    const auto i3 = ranges::find_last(list, P{"trois", 3}); // (2) C++23
#endif
    assert(i3.begin()->first == "trois" && i3.begin()->second == 3);
}

Sortie :

L'élément trouvé et la suite après celui-ci sont :
{"one", 4} {"two", 5} {"three", 6}

Voir aussi

ranges::find_end (C++20)	trouve la dernière séquence d'éléments dans une certaine plage (objet fonction d'algorithme)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	trouve le premier élément satisfaisant des critères spécifiques (objet fonction d'algorithme)
ranges::search (C++20)	recherche la première occurrence d'une plage d'éléments (objet fonction d'algorithme)
ranges::includes (C++20)	détermine si une séquence est une sous-séquence d'une autre (objet fonction d'algorithme)
ranges::binary_search (C++20)	détermine si un élément existe dans une plage en utilisant la recherche binaire (objet fonction d'algorithme)
ranges::containsranges::contains_subrange (C++23)(C++23)	vérifie si la plage contient l'élément ou la sous-plage donnée (objet fonction d'algorithme)

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 du langage
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 la 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