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 trueContents |
[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 | ||
-ForwardIt must meet the requirements of ForwardIterator.
| ||
[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) |