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, ForwardIt first, ForwardIt last ); | (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, ForwardIt first, ForwardIt last, BinaryPredicate p ); | (4) | (since C++17) |

Searches the range `[first, last)`

for two consecutive identical elements.

1) Elements are compared using

`operator==`

.
3) Elements are compared using the given binary predicate

`p`

.
2,4) Same as (1,3), but executed according to

`policy`

. These overloads do not participate in overload resolution unless `std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`

is truefirst, 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:
The signature does not need to have |

Type requirements | ||

-`ForwardIt` must meet the requirements of `ForwardIterator` . |

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.

1,3) Exactly

`min((result-first)+1, (last-first)-1)`

applications of the predicate where `result`

is the return value.
2,4)

`O(last-first)`

applications of the corresponding predicate.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
`ExecutionPolicy`

is one of the three standard policies,`std::terminate`

is called. For any other`ExecutionPolicy`

, the behavior is implementation-defined. - If the algorithm fails to allocate memory,
`std::bad_alloc`

is thrown.

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; } |

#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

removes consecutive duplicate elements in a range (function template) |

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/algorithm/adjacent_find