std::adjacent_find
| Defined in header  <algorithm> | ||
| template< class ForwardIt > ForwardIt adjacent_find( ForwardIt first, ForwardIt last ); | (1) | |
| template< class ExecutionPolicy, class ForwardIt > ForwardIt adjacent_find( ExecutionPolicy&& policy, | (2) | (since C++17) | 
| template< class ForwardIt, class BinaryPredicate> ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p ); | (3) | |
| template< class ExecutionPolicy, class ForwardIt, class BinaryPredicate> ForwardIt adjacent_find( ExecutionPolicy&& policy, | (4) | (since C++17) | 
Searches the range [first, last) for two consecutive identical elements. 
operator==.p.policy. These overloads do not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true| Contents | 
[edit] Parameters
| first, last | - | the range of elements to examine | 
| policy | - | the execution policy to use. See execution policy for details. | 
| p | - | binary predicate which returns true  if the elements should be treated as equal. The signature of the predicate function should be equivalent to the following: bool pred(const Type1 &a, const Type2 &b); The signature does not need to have const &, but the function must not modify the objects passed to it.  | 
| Type requirements | ||
| - ForwardItmust meet the requirements ofForwardIterator. | ||
[edit] Return value
an iterator to the first of the first pair of identical elements, that is, the first iterator it such that *it == *(it+1) for the first version or p(*it, *(it + 1)) != false for the second version.
If no such elements are found, last is returned
[edit] Complexity
min((result-first)+1, (last-first)-1) applications of the predicate where result is the return value.O(last-first) applications of the corresponding predicate.[edit] Exceptions
The overloads with a template parameter named ExecutionPolicy report errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicyis one of the three standard policies, std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
- If the algorithm fails to allocate memory, std::bad_alloc is thrown.
[edit] Possible implementation
| First version | 
|---|
| 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; } | 
| Second version | 
| template<class ForwardIt, class BinaryPredicate> ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPredicate p) { if (first == last) { return last; } ForwardIt next = first; ++next; for (; next != last; ++next, ++first) { if (p(*first, *next)) { return first; } } return last; } | 
[edit] Example
#include <algorithm> #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 at: " << std::distance(v1.begin(), 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) << '\n'; } }
Output:
The first adjacent pair of equal elements at: 4 The last element in the non-decreasing subsequence is at: 7
[edit] See also
| removes consecutive duplicate elements in a range (function template) | 


