Standard Template Library Programmer's Guide

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

• InputIterator is a model of Input Iterator

• UnaryFunction is a model of Unary Function

• UnaryFunction does not apply any non-constant operation through its argument.

• InputIterator 's value type is convertible to UnaryFunction 's argument type.

• [first, last) is a valid range.

Linear. Exactly last – first applications of UnaryFunction .

template struct print : public unary_function {

print(ostream& out) : os(out), count(0) {}

void operator() (T x) { os << x << ' '; ++count; }

ostream& os;

int count;

};

int main() {

int A[] = {1, 4, 2, 8, 5, 7};

const int N = sizeof(A) / sizeof(int);

print P = for_each(A, A + N, print(cout));

cout << endl << P.count << " objects printed." << endl;

}

[1] This return value is sometimes useful, since a function object may have local state. It might, for example, count the number of times that it is called, or it might have a status flag to indicate whether or not a call succeeded.

The function object overview, count , copy

Category: algorithms

Component type: function

template

InputIterator find(InputIterator first, InputIterator last, const EqualityComparable& value);

Returns the first iterator i in the range [first, last) such that *i == value . Returns last if no such iterator exists.

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

• EqualityComparable is a model of EqualityComparable.

• InputIterator is a model of InputIterator.

• Equality is defined between objects of type EqualityComparable and objects of InputIterator's value type.

• [first, last) is a valid range.

Linear: at most last – first comparisons for equality.

list L;

L.push_back(3);

L.push_back(1);

L.push_back(7);

list::iterator result = find(L.begin(), L.end(), 7);

assert(result == L.end() || *result == 7);

find_if.

Category: algorithms

Component type: function

template

InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);

Returns the first iterator i in the range [first, last) such that pred(*i) is true. Returns last if no such iterator exists.

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

• Predicate is a model of Predicate.

• InputIterator is a model of InputIterator.

• The value type of InputIterator is convertible to the argument type of Predicate.

• [first, last) is a valid range.

• For each iterator i in the range [first, last) , *i is in the domain of Predicate.

Linear: at most last – first applications of Pred .

list L;

L.push_back(-3);

L.push_back(0);

L.push_back(3); L.push_back(-2);

list::iterator result = find_if(L.begin(), L.end(), bind2nd(greater(), 0));

assert(result == L.end() || *result > 0);

find.

Category: algorithms

Component type: function

Adjacent_find is an overloaded name; there are actually two adjacent_find functions.

template

ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);

template

ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

The first version of adjacent_find returns the first iterator i such that i and i+1 are both valid iterators in [first, last) , and such that *i == *(i+1) . It returns last if no such iterator exists.

The second version of adjacent_find returns the first iterator i such that i and i+1 are both valid iterators in [first, last) , and such that binary_pred(*i, *(i+1)) is true . It returns last if no such iterator exists.

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

For the first version:

• ForwardIterator is a model of Forward Iterator.

• ForwardIterator 's value type is Equality Comparable.

For the second version:

• ForwardIterator is a model of Forward Iterator.

• ForwardIterator 's value type is convertible to BinaryPredicate 's first argument type and to its second argument type.

• [first, last) is a valid range.

Linear. If first == last then no comparison are performed; otherwise, at most (last – first) – 1 comparisons.

Find the first element that is greater than its successor.

int A[] = {1, 2, 3, 4, 6, 5, 7, 8};

const int N = sizeof(A) / sizeof(int);

const int* p = adjacent_find(A, A + N, greater ());

cout << "Element " << p – A << " is out of order: " << *p << " > " << *(p + 1) << "." << endl;