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

Определено в заголовке `<algorithm>`
Подпись вызова
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)	(с C++23)
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)	(с 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( I first, S last, Pred pred, Proj proj = {} );	(3)	(с 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)	(с 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)	(с 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)	(с C++23)

Возвращает последний элемент в диапазоне [first, last) , удовлетворяющий определённым критериям:

1) find_last ищет элемент, равный value.

3) find_last_if ищет последний элемент в диапазоне [first, last) , для которого предикат pred возвращает true.

5) find_last_if_not ищет последний элемент в диапазоне [first, last) , для которого предикат pred возвращает false.

2,4,6) То же, что (1,3,5), но в качестве исходного диапазона используется r, как если бы ranges::begin(r) было first, а ranges::end(r) было last.

Функциональные сущности, описанные на этой странице, являются niebloids, то есть:

Явные списки шаблонов аргументов не могут быть указаны при вызове ни одной из них.
Ни одна из них не видна для поиска аргументов по зависимости.
Когда любая из них обнаружена обычным поиском без квалификаторов в качестве имени слева от оператора вызова функции, поиск аргументов по зависимости запрещён.

На практике они могут быть реализованы в виде объектов-функций или с помощью специальных расширений компилятора.

Параметры

first, last	-	диапазон элементов для проверки
r	-	диапазон элементов для проверки
value	-	значение для сравнения с элементами
pred	-	предикат для применения к спроецированным элементам
proj	-	проекция для применения к элементам

Возвращаемое значение

1,2,3) Пусть i — последний итератор в диапазоне [first, last) , для которого E является true. Возвращает ranges::subrange<I>{i, last}, или ranges::subrange<I>{last, last} , если такой итератор не найден.

2,4,6) То же, что (1,2,3), но возвращаемый тип — ranges::borrowed_subrange_t<I>.

Сложность

Максимум last - first применений предиката и проекции.

Примечания

ranges::find_last, ranges::find_last_if, ranges::find_last_if_not обладают лучшей эффективностью на общих реализациях, если I моделирует bidirectional_iterator или (лучше) random_access_iterator.

Макрос проверки наличия функции	Значение	Стандарт	Функция
`__cpp_lib_ranges_find_last`	202207L	(C++23)	`ranges::find_last`, `ranges::find_last_if`, `ranges::find_last_if_not`

Возможная реализация

Эти реализации показывают только более медленный алгоритм, используемый, когда I моделирует forward_iterator.

find_last (1-2)
struct find_last_fn { 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> 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. I found {}; for (; first != last; ++first) if (std::invoke(proj, first) == value) found = first; if (found == I {}) return {first, first}; return {found, std::ranges::next(found, last)}; } 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> operator()(R&& r, const T &value, Proj proj = {}) const { return this->operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj)); } }; inline constexpr find_last_fn find_last;
find_last_if (3-4)
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. I found {}; for (; first != last; ++first) if (std::invoke(pred, std::invoke(proj, *first))) found = first; if (found == I {}) return {first, first}; return {found, std::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->operator()(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 (5-6)
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. I found {}; for (; first != last; ++first) if (!std::invoke(pred, std::invoke(proj, *first))) found = first; if (found == I {}) return {first, first}; return {found, std::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->operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } }; inline constexpr find_last_if_not_fn find_last_if_not;

Пример

#include <algorithm>
#include <forward_list>
#include <iomanip>
#include <iostream>
#include <string_view>
 
int main()
{
    constexpr static auto v = {1, 2, 3, 1, 2, 3, 1, 2};
 
    {
        constexpr auto i1 = std::ranges::find_last(v.begin(), v.end(), 3);
        constexpr auto i2 = std::ranges::find_last(v, 3);
        static_assert(std::ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(std::ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        constexpr auto i1 = std::ranges::find_last(v.begin(), v.end(), -3);
        constexpr auto i2 = std::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 = std::ranges::find_last_if(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = std::ranges::find_last_if(v, pred, abs);
        static_assert(std::ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(std::ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        auto pred = [](int x) { return x == -3; };
        constexpr auto i1 = std::ranges::find_last_if(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = std::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 = std::ranges::find_last_if_not(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = std::ranges::find_last_if_not(v, pred, abs);
        static_assert(std::ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(std::ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        auto pred = [](int x) { return x == 1 or x == 2 or x == 3; };
        constexpr auto i1 = std::ranges::find_last_if_not(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = std::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
    {
        {"one", 1}, {"two", 2}, {"three", 3},
        {"one", 4}, {"two", 5}, {"three", 6},
    };
    auto cmp_one = [](const std::string_view &s) { return s == "one"; };
 
    // find latest element that satisfy the comparator, and projecting pair::first
    const auto subrange = std::ranges::find_last_if(list, cmp_one, &P::first);
 
    // print the found element and the "tail" after it
    for (P const& e : subrange)
        std::cout << '{' << std::quoted(e.first) << ", " << e.second << "} ";
    std::cout << '\n';
}

Вывод:

{"one", 4} {"two", 5} {"three", 6}

См. также

ranges::find_end (C++20)	находит последнюю последовательность элементов в определённом диапазоне (niebloid)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	находит первый элемент, удовлетворяющий определённым критериям (niebloid)
ranges::search (C++20)	производит поиск диапазона элементов (niebloid)
ranges::includes (C++20)	возвращает `true` , если одна последовательность является подпоследовательностью другой (niebloid)
ranges::binary_search (C++20)	определяет, существует ли элемент в частично упорядоченном диапазоне (niebloid)
ranges::containsranges::contains_subrange (C++23)(C++23)	проверяет, содержит ли диапазон заданный элемент или поддиапазон (niebloid)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/ranges/find_last