std::adjacent_find
Defined in header
<algorithm>
|
||
template< class ForwardIt >
ForwardIt adjacent_find( ForwardIt first, ForwardIt last ); |
(1) | |
template< class ForwardIt, class BinaryPredicate>
ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p ); |
(2) | |
Searches the range [first, last)
for two consecutive identical elements. The first version uses operator==
to compare the elements, the second version uses the given binary predicate p
.
Contents |
[edit] Parameters
first, last | - | the range of elements to examine |
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
Exactly the smaller of std::distance(first, result) + 1 and std::distance(first, last) - 1 applications of the predicate where result
is the return value.
[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) |
|
(parallelism TS)
|
parallelized version of std::ajacent_find (function template) |