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

Definido en el encabezado `<algorithm>`
Firma de llamada
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)	(desde C++23) (hasta 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)		(desde 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)	(desde C++23) (hasta 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)		(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde 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)	(desde C++26)

Para la definición de /*execution-policy*/, véase esta página; para la definición de /*sized-random-access-range*/, véase esta página.

Devuelve el último elemento (proyectado por proj) en el rango fuente [first, last) o r que satisface criterios específicos:

1,2) find_last busca el último elemento igual a value.

3,4) find_last_if busca el último elemento para el cual el predicado pred devuelve true.

5,6) find_last_if_not busca el último elemento para el cual el predicado pred devuelve false.

7-12) Igual que (1-6), pero ejecutado según policy.

Las entidades similares a funciones descritas en esta página son objetos función de algoritmo (conocidos informalmente como niebloids), es decir:

No se pueden especificar listas explícitas de argumentos de plantilla al llamar a cualquiera de ellos.
Ninguno de ellos es visible mediante búsqueda dependiente de argumentos.
Cuando cualquiera de ellos se encuentra mediante búsqueda no calificada normal como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumentos se inhibe.

Parámetros

first, last	-	el par iterador-centinela que define el rango de origenrango
r	-	el rango de origen
value	-	el valor objetivo
pred	-	el predicado que se aplicará a los elementos (proyectados)
proj	-	la proyección que se aplicará a los elementos
policy	-	la política de ejecución a utilizar

Valor de retorno

Un subrango desde el último elemento que satisface la condición hasta el final del rango de origen, o un rango vacío si no se encuentra dicho elemento.

Complejidad

Dado $\scriptsize N$ $N$ como ranges::distance(first, last) o ranges::distance(r):

1,2) A lo sumo

N

comparaciones y aplicaciones de proj.

3-6) A lo sumo

N

aplicaciones de pred y proj.

7,8)

𝓞(N)

comparaciones y aplicaciones de proj.

9-12)

𝓞(N)

aplicaciones de pred y proj.

Excepciones

7-12) Durante el proceso de ejecución:

Si los recursos de memoria temporal necesarios para la paralelización no están disponibles, std::bad_alloc se lanza.
Si se lanza una excepción no capturada al acceder a objetos a través de un argumento de algoritmo, el comportamiento está determinado por la política de ejecución (para políticas estándar, std::terminate se invoca).

Notas

ranges::find_last , ranges::find_last_if , ranges::find_last_if_not tienen mejor eficiencia en implementaciones comunes si I modela bidirectional_iterator o (mejor) random_access_iterator .

Macro de prueba de características	Valor	Std	Característica
`__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)	Inicialización de lista para algoritmos ( 1,2 )

Posible implementación

Estas implementaciones solo muestran el algoritmo más lento utilizado cuando I modela 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;

Ejemplo

Ejecutar este código

#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
    {
        {"uno", 1}, {"dos", 2}, {"tres", 3},
        {"uno", 4}, {"dos", 5}, {"tres", 6},
    };
    auto cmp_one = [](const std::string_view &s) { return s == "uno"; };
    // encontrar el último elemento que satisface el comparador, proyectando pair::first
    const auto subrange = ranges::find_last_if(list, cmp_one, &P::primero);
    std::cout << "El elemento encontrado y la cola después de él son:\n";
    for (P const& e : subrange)
        std::cout << '{' << std::quoted(e.primero) << ", " << e.second << "} ";
    std::cout << '\n';
#if __cpp_lib_algorithm_default_value_type
    const auto i3 = ranges::find_last(list, {"tres", 3}); // (2) C++26
#else
    const auto i3 = ranges::find_last(list, P{"tres", 3}); // (2) C++23
#endif
    assert(i3.begin()->first == "tres" && i3.begin()->second == 3);
}

Salida:

El elemento encontrado y la cola después de él son:
{"one", 4} {"two", 5} {"three", 6}

Véase también

ranges::find_end (C++20)	encuentra la última secuencia de elementos en un rango dado (objeto de función de algoritmo)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	encuentra el primer elemento que satisface criterios específicos (objeto de función de algoritmo)
ranges::search (C++20)	busca la primera aparición de un rango de elementos (objeto de función de algoritmo)
ranges::includes (C++20)	determina si una secuencia es subsecuencia de otra (objeto de función de algoritmo)
ranges::binary_search (C++20)	determina si un elemento existe en un rango usando búsqueda binaria (objeto de función de algoritmo)
ranges::containsranges::contains_subrange (C++23)(C++23)	comprueba si el rango contiene el elemento o subrango dado (objeto de función de algoritmo)

Soporte del compilador
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos nombrados
Macros de prueba de características (C++20)
Biblioteca de soporte del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnóstico
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca de sistema de archivos (C++17)
Biblioteca de soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

es.cppreference.net

Namespaces

Variants