Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::adjacent_find(3)	      C++ Standard Libary	 std::adjacent_find(3)

NAME
       std::adjacent_find - std::adjacent_find

Synopsis
	  Defined in header <algorithm>
	  template< class ForwardIt >
	  ForwardIt   adjacent_find(  ForwardIt	 first,			(until
       C++20)
	  ForwardIt last );
	  template< class ForwardIt >
	  constexpr  ForwardIt	adjacent_find(	ForwardIt		(since
       C++20)
	  first, ForwardIt last	);
	  template< class ExecutionPolicy, class ForwardIt
	  >

	  ForwardIt   adjacent_find(  ExecutionPolicy&&		   (2)	(since
       C++17)
	  policy,

	  ForwardIt first, ForwardIt last );
	  template< class ForwardIt, class
	  BinaryPredicate>						   (1)
       (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&&		   (4)
       (since C++17)
	  policy,

	  ForwardIt first, ForwardIt last, BinaryPredicate
	  p );

	  Searches the range [first, last) for two consecutive equal 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	 over-
       loads do	not
	  participate in overload resolution unless
	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	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 re-
       gardless	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 con-
       verted 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::termi-
       nate 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 is at
       "
			  << std::distance(v1.begin(), i1) << ", *i1 = "
			  << *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 or-
       der\n";
	    } else {
		std::cout << "The last element in  the	non-decreasing	subse-
       quence is at "
			  <<  std::distance(v1.begin(),	 i2)  << ", *i2	= " <<
       *i2 << '\n';
	    }
	}

Output:
	The first adjacent pair	of equal elements is at	4, *i1 = 40
	The last element in the	non-decreasing subsequence is at 7, *i2	= 41

See also
	  unique		removes	consecutive duplicate  elements	 in  a
       range
				(function template)
	  ranges::adjacent_find	 finds	the  first two adjacent	items that are
       equal (or satisfy
	  (C++20)		a given	predicate)
				(niebloid)

http://cppreference.com		  2022.07.31		 std::adjacent_find(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::adjacent_find&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help