Namespaces
Variants

std:: adjacent_find

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Определено в заголовке <algorithm>
template < class ForwardIt >
ForwardIt adjacent_find ( ForwardIt first, ForwardIt last ) ;
(1) (constexpr начиная с C++20)
template < class ExecutionPolicy, class ForwardIt >

ForwardIt adjacent_find ( ExecutionPolicy && policy,

ForwardIt first, ForwardIt last ) ;
(2) (начиная с C++17)
template < class ForwardIt, class BinaryPred >

ForwardIt adjacent_find ( ForwardIt first, ForwardIt last,

BinaryPred p ) ;
(3) (constexpr начиная с C++20)
template < class ExecutionPolicy, class ForwardIt, class BinaryPred >

ForwardIt adjacent_find ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

BinaryPred p ) ;
(4) (начиная с C++17)

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

1) Элементы сравниваются с помощью operator == .
3) Элементы сравниваются с использованием заданного бинарного предиката p .
2,4) То же, что и (1,3) , но выполняется в соответствии с policy .
Эти перегрузки участвуют в разрешении перегрузки только при выполнении всех следующих условий:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> равно true .

(до C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> равно true .

(начиная с C++20)

Содержание

Параметры

first, last - пара итераторов, определяющих диапазон элементов для проверки
policy - политика выполнения для использования
p - бинарный предикат, который возвращает ​ true если элементы должны рассматриваться как равные.

Сигнатура функции-предиката должна быть эквивалентна следующей:

bool pred ( const Type1 & a, const Type2 & b ) ;

Хотя сигнатура не обязана иметь const & , функция не должна модифицировать передаваемые ей объекты и должна быть способна принимать все значения типа (возможно const) Type1 и Type2 независимо от категории значения (следовательно, Type1 & не допускается , как и Type1 , если для Type1 перемещение не эквивалентно копированию (since C++11) ).
Типы Type1 и Type2 должны быть такими, чтобы объект типа ForwardIt мог быть разыменован и затем неявно преобразован к обоим из них. ​

Требования к типам
-
ForwardIt должен удовлетворять требованиям LegacyForwardIterator .
-
BinaryPred должен удовлетворять требованиям BinaryPredicate .

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

Итератор на первый элемент первой пары одинаковых элементов, то есть первый итератор it такой, что * it == * ( it + 1 ) для (1,2) или p ( * it, * ( it + 1 ) ) ! = false для (3,4) .

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

Сложность

Пусть result будет возвращаемым значением adjacent_find , M как std:: distance ( first, result ) и N как std:: distance ( first, last ) :

1) Ровно min(M+1,N-1) сравнений с использованием operator == .
2) O(N) сравнений с использованием operator == .
3) Ровно min(M+1,N-1) применений предиката p .
4) O(N) применений предиката p .

Исключения

Перегрузки с параметром шаблона с именем ExecutionPolicy сообщают об ошибках следующим образом:

  • Если выполнение функции, вызванной как часть алгоритма, выбрасывает исключение и ExecutionPolicy является одним из стандартных политик , std::terminate вызывается. Для любой другой ExecutionPolicy поведение определяется реализацией.
  • Если алгоритму не удается выделить память, std::bad_alloc выбрасывается.

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

adjacent_find (1)
template<class ForwardIt>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first)
        if (*first == *next)
            return first;
    return last;
}
adjacent_find (3)
template<class ForwardIt, class BinaryPred>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPred p)
{
    if (first == last)
        return last;
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first)
        if (p(*first, *next))
            return first;
    return last;
}
**Примечание:** Весь код C++ внутри тегов `
` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Пример

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v1{0, 1, 2, 3, 40, 40, 41, 41, 5};
    auto i1 = std::adjacent_find(v1.begin(), v1.end());
    if (i1 == v1.end())
        std::cout << "No matching adjacent elements\n";
    else
        std::cout << "The first adjacent pair of equal elements is at "
                  << std::distance(v1.begin(), i1) << ", *i1 = "
                  << *i1 << '\n';
    auto i2 = std::adjacent_find(v1.begin(), v1.end(), std::greater<int>());
    if (i2 == v1.end())
        std::cout << "The entire vector is sorted in ascending order\n";
    else
        std::cout << "The last element in the non-decreasing subsequence is at "
                  << std::distance(v1.begin(), i2) << ", *i2 = " << *i2 << '\n';
}

Вывод:

The first adjacent pair of equal elements is at 4, *i1 = 40
The last element in the non-decreasing subsequence is at 7, *i2 = 41

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Применяется к Поведение в опубликованной версии Корректное поведение
LWG 240 C++98 предикат применялся std:: find
( first, last, value ) - first раз
для (1,3) , где value никогда не был определён
применяется std:: min (
( result - first ) + 1 ,
( last - first ) - 1 ) раз

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

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