std::adjacent_find (3) - Linux Man Pages

std::adjacent_find: std::adjacent_find

NAME

std::adjacent_find - std::adjacent_find

Synopsis


Defined in header <algorithm>
template< class ForwardIt > (until C++20)
ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
template< class ForwardIt > (since C++20)
constexpr ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
template< class ExecutionPolicy, class ForwardIt >
ForwardIt adjacent_find( ExecutionPolicy&& policy, (2) (since C++17)
ForwardIt first, ForwardIt last ); (1)
template< class ForwardIt, class BinaryPredicate> (until C++20)
ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p );
template< class ForwardIt, class BinaryPredicate> (since C++20)
constexpr 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)
ForwardIt first, ForwardIt last, BinaryPredicate p );


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 true

Parameters


first, last - the range of elements to examine
policy - the execution policy to use. See execution_policy for details.
              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);
p - While the signature does not need to have const &, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const) Type1 and Type2 regardless of value_category (thus, Type1 & is not allowed
              , nor is Type1 unless for Type1 a move is equivalent to a copy
              (since C++11)).
              The types Type1 and Type2 must be such that an object of type ForwardIt can be dereferenced and then implicitly converted to both of them.

Type requirements


-
ForwardIt must meet the requirements of LegacyForwardIterator.

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

Complexity


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.

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 ExecutionPolicy is one of the 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.

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

Example


// Run this code


  #include <algorithm>
  #include <iostream>
  #include <vector>
  #include <functional>


  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

See also


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