Apache C++ Standard Library Reference Guide

## adjacent_find()

Library: Algorithms

    Function

- Local Index
- Summary
- Synopsis
- Description
- Complexity
- Example
- See Also
- Standards Conformance

### Local Index

No Entries

### Summary

An algorithm that finds the first adjacent pair of equivalent elements in a sequence

### Synopsis

    #include <algorithm>

    namespace std {
      template <class ForwardIterator>
        ForwardIterator
        adjacent_find(ForwardIterator start,
                      ForwardIterator finish);

      template <class ForwardIterator, class BinaryPredicate>
        ForwardIterator
        adjacent_find(ForwardIterator start,
                      ForwardIterator finish,
                      BinaryPredicate binary_pred);
    }

### Description

There are two variations of the `adjacent_find()` algorithm. The first finds equal adjacent elements in the sequence defined by iterators `start` and `finish` and returns an iterator `i` pointing to the first of the equal elements. The second variation lets you specify a binary function object to test for a condition. The algorithm 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` where both `i` and `i + 1` are in the range `[start, finish)` that meets one of the following conditions:

`*i == *(i + 1)`

or

`binary_pred(*i,*(i + 1)) == true`

If `adjacent_find()` does not find a match, it returns `finish`.

### Complexity

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

### Example

    //
    //  find.cpp
    //

    #include <vector>      // for vector
    #include <algorithm>   // for adjacent_find, find
    #include <functional>  // for bind1st, equal_to
    #include <iostream>    // for cout, endl

    int main ()
    {
        // Typedef for convenience.
        typedef std::vector<int, std::allocator<int> > Vector;

        const Vector::value_type arr[] = { 0, 1, 2, 2, 3,
                                           4, 2, 2, 6, 7 };

        // Set up a vector.
        const Vector v1 (arr, arr + sizeof arr / sizeof *arr);

        // Try find.
        Vector::const_iterator it = std::find (v1.begin (),
                                               v1.end (), 3);

        std::cout << *it << ' ';

        // Try find_if.
        it = std::find_if (v1.begin (), v1.end (),
                 std::bind1st (std::equal_to<Vector::value_type>(),
                 3));

        std::cout << *it << ' ';

        // Try both adjacent_find variants.
        it = std::adjacent_find (v1.begin (), v1.end ());

        std::cout << *it << ' ';

        it = std::adjacent_find (v1.begin (), v1.end (),
                              std::equal_to<Vector::value_type>());

        std::cout << *it << std::endl;

        return 0;
    }

    Program Output:

    3 3 2 2

### See Also

`find()`

### Standards Conformance

ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 25.1.5