std::ranges:: adjacent_find

Выполняет поиск в диапазоне [ first , last ) первых двух последовательных одинаковых элементов.

Функциональные сущности, описанные на этой странице, являются алгоритмическими функциональными объектами (неформально известными как niebloids ), то есть:

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

Параметры

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

Итератор на первый элемент первой пары идентичных элементов, то есть первый итератор it такой, что bool ( std:: invoke ( pred, std:: invoke ( proj1, * it ) , std:: invoke ( proj, * ( it + 1 ) ) ) ) равен true .

Если такие элементы не найдены, возвращается итератор, равный last .

Сложность

Ровно min ( ( result - first ) + 1 , ( last - first ) - 1 ) применений предиката и проекции, где result является возвращаемым значением.

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

struct adjacent_find_fn
{
    template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_binary_predicate<
                 std::projected<I, Proj>,
                 std::projected<I, Proj>> Pred = ranges::equal_to>
    constexpr I operator()(I first, S last, Pred pred = {}, Proj proj = {}) const
    {
        if (first == last)
            return first;
        auto next = ranges::next(first);
        for (; next != last; ++next, ++first)
            if (std::invoke(pred, std::invoke(proj, *first), std::invoke(proj, *next)))
                return first;
        return next;
    }
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_binary_predicate<
                 std::projected<ranges::iterator_t<R>, Proj>,
                 std::projected<ranges::iterator_t<R>, Proj>> Pred = ranges::equal_to>
    constexpr ranges::borrowed_iterator_t<R>
        operator()(R&& r, Pred pred = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
    }
};
inline constexpr adjacent_find_fn adjacent_find;

Пример

#include <algorithm>
#include <functional>
#include <iostream>
#include <ranges>
constexpr bool some_of(auto&& r, auto&& pred) // некоторые, но не все
{
    return std::ranges::cend(r) != std::ranges::adjacent_find(r,
        [&pred](auto const& x, auto const& y)
        {
            return pred(x) != pred(y);
        });
}
// тестирование some_of
constexpr auto a = {0, 0, 0, 0}, b = {1, 1, 1, 0}, c = {1, 1, 1, 1};
auto is_one = [](auto x){ return x == 1; };
static_assert(!some_of(a, is_one) && some_of(b, is_one) && !some_of(c, is_one));
int main()
{
    const auto v = {0, 1, 2, 3, 40, 40, 41, 41, 5}; /*
                                ^^          ^^       */
    namespace ranges = std::ranges;
    if (auto it = ranges::adjacent_find(v.begin(), v.end()); it == v.end())
        std::cout << "Нет совпадающих соседних элементов\n";
    else
        std::cout << "Первая пара равных соседних элементов находится в позиции ["
                  << ranges::distance(v.begin(), it) << "] == " << *it << '\n';
    if (auto it = ranges::adjacent_find(v, ranges::greater()); it == v.end())
        std::cout << "Весь вектор отсортирован в порядке возрастания\n";
    else
        std::cout << "Последний элемент в невозрастающей подпоследовательности находится в позиции ["
                  << ranges::distance(v.begin(), it) << "] == " << *it << '\n';
}

Первая пара равных соседних элементов находится в позиции [4] == 40
Последний элемент в невозрастающей подпоследовательности находится в позиции [7] == 41

Смотрите также