```
Standard C++ Library
Copyright 1998, Rogue Wave Software, Inc.

```

## NAME

```     adjacent_find

- Find the first adjacent pair of elements  in  a  sequence
that are equivalent.

```

## SYNOPSIS

```     #include <algorithm>
template <class ForwardIterator>
ForwardIterator
ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate>
ForwardIterator
BinaryPredicate pred);

```

## DESCRIPTION

```     There are two versions of the adjacent_find  algorithm.  The
first  finds equal adjacent elements in the sequence defined
by iterators first and last and returns an iterator i point-
ing  to  the first of the equal elements. The second version
lets you specify your own binary function to test for a con-
dition.  It  returns  an iterator i pointing to the first of
the pair of elements that meet the conditions of the  binary
function.  In  other  words, adjacent_find returns the first
iterator i such that both i and i  +  1  are  in  the  range
[first,  last)  for  which  one  of the following conditions
holds:

*i == *(i + 1)

or

pred(*i,*(i + 1)) == true

If adjacent_find does not find a match, it returns last.

```

## COMPLEXITY

```     adjacent_find  performs  exactly  find(first,last,value)   -
first applications of the corresponding predicate.

```

## EXAMPLE

```     //
// find.cpp
//
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main()
{
typedef vector<int>::iterator iterator;
int d1[10] = {0,1,2,2,3,4,2,2,6,7};

// Set up a vector
vector<int> v1(d1,d1 + 10);

// Try find
iterator it1 = find(v1.begin(),v1.end(),3);

// Try find_if
iterator it2 =
find_if(v1.begin(),v1.end(),bind1st(equal_to<int>(),3));

iterator it4 =

// Output results
cout << *it1 << " " << *it2 << " " << *it3 << " "
<< *it4 << endl;

return 0;
}

Program Output :

3 3 2 2

```

## WARNINGS

```     If your compiler does not support default  template  parame-
ters,  then you always need to supply the Allocator template
argument. For instance, you have to write:

vector<int,allocator<int> >

vector<int>

If your compiler does not support namespaces,  then  you  do
not need the using declaration for std.

```

```     find

```