United States    
PRODUCTS SUPPORT SOLUTIONS SERVICES
COMPAQ SOFTWARE
cxxlstd$help.HLP

accumulate

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

accumulate - Accumulate all elements within a range into a single value.

SYNOPSIS

#include <numeric> template <class InputIterator, class T> T accumulate (InputIterator first, InputIterator last, T init);

template <class InputIterator, class T, class BinaryOperation> T accumulate (InputIterator first, InputIterator last, T init, BinaryOperation binary_op);

DESCRIPTION

accumulate applies a binary operation to init and each value in the range [first,last). The result of each operation is returned in init. This process aggregates the result of performing the operation on every element of the sequence into a single value.

Accumulation is done by initializing the accumulator acc with the initial value init and then modifying it with acc = acc + *i or acc = binary_op(acc, *i) for every iterator i in the range [first, last) in order. If the sequence is empty, accumulate returns init.

COMPLEXITY

accumulate performs exactly last-first applications of the binary operation (operator+ by default).

EXAMPLE

// // accum.cpp // #include <numeric> //for accumulate #include <vector> //for vector #include <functional> //for times #include <iostream.h>

int main() { // //Typedef for vector iterators // typedef vector<int>::iterator iterator; // //Initialize a vector using an array of ints // int d1[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v1(d1, d1+10); // //Accumulate sums and products // int sum = accumulate(v1.begin(), v1.end(), 0); int prod = accumulate(v1.begin(), v1.end(), 1, times<int>()); // //Output the results // cout << "For the series: "; for(iterator i = v1.begin(); i != v1.end(); i++) cout << *i << " ";

cout << " where N = 10." << endl; cout << "The sum = (N*N + N)/2 = " << sum << endl; cout << "The product = N! = " << prod << endl; return 0; } Output : For the series: 1 2 3 4 5 6 7 8 9 10 where N = 10. The sum = (N*N + N)/2 = 55 The product = N! = 3628800

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


adjacent_difference

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

adjacent_difference - Outputs a sequence of the differences between each adjacent pair of elements in a range.

SYNOPSIS

#include <numeric>

template <class InputIterator, class OutputIterator> OutputIterator adjacent_difference (InputIterator first, InputIterator last, OutputIterator result); template <class InputIterator, class OutputIterator, class BinaryOperation> OutputIterator adjacent_difference (InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bin_op);

DESCRIPTION

Informally, adjacent_difference fills a sequence with the differences between successive elements in a container. The result is a sequence in which the first element is equal to the first element of the sequence being processed, and the remaining elements are equal to the calculated differences between adjacent elements. For instance, applying adjacent_difference to {1,2,3,5} will produce a result of {1,1,1,2}.

By default, subtraction is used to compute the difference, but you can supply any binary operator. The binary operator is then applied to adjacent elements. For example, by supplying the plus (+) operator, the result of applying adjacent_difference to {1,2,3,5} is the sequence {1,3,5,8}.

Formally, adjacent_difference assigns to every element referred to by iterator i in the range [result + 1, result + (last - first)) a value equal to the appropriate one of the following:

*(first + (i - result)) - *(first + (i - result) - 1)

or

binary_op (*(first + (i - result)), *(first + (i - result) - 1))

result is assigned the value of *first.

adjacent_difference returns result + (last - first).

result can be equal to first. This allows you to place the results of applying adjacent_difference into the original sequence.

COMPLEXITY

This algorithm performs exactly (last-first) - 1 applications of the default operation (-) or binary_op.

EXAMPLE

// // adj_diff.cpp // #include<numeric> //For adjacent_difference #include<vector> //For vector #include<functional> //For times #include <iostream.h> int main() { // //Initialize a vector of ints from an array // int arr[10] = {1,1,2,3,5,8,13,21,34,55}; vector<int> v(arr,arr+10); // //Two uninitialized vectors for storing results // vector<int> diffs(10), prods(10); // //Calculate difference(s) using default operator (minus) // adjacent_difference(v.begin(),v.end(),diffs.begin()); // //Calculate difference(s) using the times operator // adjacent_difference(v.begin(), v.end(), prods.begin(), times<int>()); // //Output the results // cout << "For the vector: " << endl << " "; copy(v.begin(),v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; cout << "The differences between adjacent elements are: " << endl << " "; copy(diffs.begin(),diffs.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; cout << "The products of adjacent elements are: " << endl << " "; copy(prods.begin(),prods.end(), ostream_iterator<int,char>(cout," ")); cout << endl; return 0;

Output : For the vector: 1 1 2 3 5 8 13 21 34 55 The differences between adjacent elements are: 1 0 1 1 2 3 5 8 13 21 The products of adjacent elements are: 1 1 2 6 15 40 104 273 714 1870

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


adjacent_find

Standard C++ Library Copyright 1996, 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 adjacent_find(ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate> ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, 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 pointing to the first of the equal elements. The second version lets you specify your own binary function to test for a condition. 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.h>

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

// Try both adjacent_find variants iterator it3 = adjacent_find(v1.begin(),v1.end());

iterator it4 = adjacent_find(v1.begin(),v1.end(),equal_to<int>());

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

return 0; }

Output : 3 3 2 2

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> > instead of:

vector<int>

SEE ALSO

find

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


advance

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

advance - Move an iterator forward or backward (if available) by a certain distance.

SYNOPSIS

#include <iterator>

template <class InputIterator, class Distance> void advance (InputIterator& i, Distance n);

DESCRIPTION

The advance template function allows an iterator to be advanced through a container by some arbitrary distance. For bidirectional and random access iterators, this distance may be negative. This function uses operator+ and operator- for random access iterators, which provides a constant time implementation. For input, forward, and bidirectional iterators, advance uses operator++ to provide linear time implementations. advance also uses operator-- with bidirectional iterators to provide linear time implementations of negative distances.

If n is positive, advance increments iterator reference i by n. For negative n, advance decrements reference i. Remember that advance accepts a negative argument n for random access and bidirectional iterators only.

EXAMPLE

// // advance.cpp // #include<iterator> #include<list> #include<iostream.h>

int main() {

// //Initialize a list using an array // int arr[6] = {3,4,5,6,7,8}; list<int> l(arr,arr+6); // //Declare a list iterator, s.b. a ForwardIterator // list<int>::iterator itr = l.begin(); // //Output the original list // cout << "For the list: "; copy(l.begin(),l.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; cout << "When the iterator is initialized to l.begin()," << endl << "it points to " << *itr << endl << endl; // // operator+ is not available for a ForwardIterator, // so use advance. //

advance(itr, 4); cout << "After advance(itr,4), the iterator points to " << *itr << endl; return 0; }

Output : For the list: 3 4 5 6 7 8 When the iterator is initialized to l.begin(), it points to 3 After advance(itr,4), the iterator points to 7

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

sequence, random_iterator, distance

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


binary_search

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

binary_search - Performs a binary search for a value on a container.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class T> bool binary_search(ForwardIterator first, ForwardIterator last, const T& value);

template <class ForwardIterator, class T, class Compare> bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

DESCRIPTION

The binary_search algorithm, like other related algorithms (equal_range, lower_bound and upper_bound) performs a binary search on ordered containers. All binary search algorithms have two versions. The first version uses the less than operator (operator<) to perform the comparison, and assumes that the sequence has been sorted using that operator. The second version allows you to include a function object of type Compare, which it assumes was the function used to sort the sequence. The function object must be a binary predicate.

The binary_search algorithm returns true if a sequence contains an element equivalent to the argument value. The first version of binary_search returns true if the sequence contains at least one element that is equal to the search value. The second version of the binary_search algorithm returns true if the sequence contains at least one element that satisfies the conditions of the comparison function. Formally, binary_search returns true if there is an iterator i in the range [first, last) that satisfies the corresponding conditions:

!(*i < value) && !(value < *i)

or

comp(*i, value) == false && comp(value, *i) == false

COMPLEXITY

binary_search performs at most log(last - first) + 2 comparisons.

EXAMPLE

// // b_search.cpp // #include <vector> #include <algorithm> #include <iostream.h>

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 binary_search variants // sort(v1.begin(),v1.end()); bool b1 = binary_search(v1.begin(),v1.end(),3); bool b2 = binary_search(v1.begin(),v1.end(),11,less<int>()); // // Output results // cout << "In the vector: "; copy(v1.begin(),v1.end(), ostream_iterator<int,char>(cout," "));

cout << endl << "The number 3 was " << (b1 ? "FOUND" : "NOT FOUND"); cout << endl << "The number 11 was " << (b2 ? "FOUND" : "NOT FOUND") << endl; return 0; }

Output : In the vector: 0 1 2 2 2 2 3 4 6 7 The number 3 was FOUND The number 11 was NOT FOUND

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

equal_range, lower_bound, upper_bound

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

copy, copy_backward - Copies a range of elements

SYNOPSIS

#include <algorithm>

template <class InputIterator, class OutputIterator> OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

template <class BidirectionalIterator1, class BidirectionalIterator2> BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result);

DESCRIPTION

The copy algorithm copies values from the range specified by [first , last) to the range that specified by [result, result + (last - first)). copy can be used to copy values from one container to another, or to copy values from one location in a container to another location in the same container, as long as result is not within the range [first-last). copy returns result + (last - first). For each non-negative integer n < (last - first), copy assigns *(first + n) to *(result + n). The result of copy is undefined if result is in the range [first, last).

Unless result is an insert iterator, copy assumes that at least as many elements follow result as are in the range [first, last).

The copy_backward algorithm copies elements in the range specified by [first, last) into the range specified by [result - (last - first), result), starting from the end of the sequence (last-1) and progressing to the front (first). Note that copy_backward does not reverse the order of the elements, it simply reverses the order of transfer. copy_backward returns result - (last - first). You should use copy_backward instead of copy when last is in the range [result - (last - first), result). For each positive integer n <= (last - first), copy_backward assigns *(last - n) to *(result - n). The result of copy_backward is undefined if result is in the range [first, last).

Unless result is an insert iterator, copy_backward assumes that there are at least as many elements ahead of result as are in the range [first, last).

COMPLEXITY

Both copy and copy_backward perform exactly last - first assignments.

EXAMPLE

// // stdlib/examples/manual.copyex.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; int d2[4] = {5,6,7,8};

// Set up three vectors // vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4), v3(d2,d2 + 4); // // Set up one empty vector // vector<int> v4; // // Copy v1 to v2 // copy(v1.begin(),v1.end(),v2.begin()); // // Copy backwards v1 to v3 // copy_backward(v1.begin(),v1.end(),v3.end()); // // Use insert iterator to copy into empty vector // copy(v1.begin(),v1.end(),back_inserter(v4)); // // Copy all four to cout // ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl; copy(v4.begin(),v4.end(),out); cout << endl;

return 0; }

Output : 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector <int, allocator<int> >

instead of:

vector <int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


copy_backward

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

copy, copy_backward - Copies a range of elements

SYNOPSIS

#include <algorithm>

template <class InputIterator, class OutputIterator> OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

template <class BidirectionalIterator1, class BidirectionalIterator2> BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result);

DESCRIPTION

The copy algorithm copies values from the range specified by [first , last) to the range that specified by [result, result + (last - first)). copy can be used to copy values from one container to another, or to copy values from one location in a container to another location in the same container, as long as result is not within the range [first-last). copy returns result + (last - first). For each non-negative integer n < (last - first), copy assigns *(first + n) to *(result + n). The result of copy is undefined if result is in the range [first, last).

Unless result is an insert iterator, copy assumes that at least as many elements follow result as are in the range [first, last).

The copy_backward algorithm copies elements in the range specified by [first, last) into the range specified by [result - (last - first), result), starting from the end of the sequence (last-1) and progressing to the front (first). Note that copy_backward does not reverse the order of the elements, it simply reverses the order of transfer. copy_backward returns result - (last - first). You should use copy_backward instead of copy when last is in the range [result - (last - first), result). For each positive integer n <= (last - first), copy_backward assigns *(last - n) to *(result - n). The result of copy_backward is undefined if result is in the range [first, last).

Unless result is an insert iterator, copy_backward assumes that there are at least as many elements ahead of result as are in the range [first,last).

COMPLEXITY

Both copy and copy_backward perform exactly last - first assignments.

//

EXAMPLE

// stdlib/examples/manual.copyex.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; int d2[4] = {5,6,7,8};

// Set up three vectors // vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4), v3(d2,d2 + 4); // // Set up one empty vector // vector<int> v4; // // Copy v1 to v2 // copy(v1.begin(),v1.end(),v2.begin()); // // Copy backwards v1 to v3 // copy_backward(v1.begin(),v1.end(),v3.end()); // // Use insert iterator to copy into empty vector // copy(v1.begin(),v1.end(),back_inserter(v4)); // // Copy all four to cout // ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl; copy(v4.begin(),v4.end(),out); cout << endl;

return 0; }

Output : 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector <int, allocator<int> >

instead of:

vector <int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


count

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

count, count_if - Count the number of elements in a container that satisfy a given condition.

SYNOPSIS

#include <algorithm> template<class InputIterator, class T> iterator_trait<InputIterator>::distance_type count(InputIterator first, InputIterator last, const T& value);

template <class InputIterator, class T, class Size> void count(InputIterator first, InputIterator last, const T& value, Size& n);

template<class InputIterator, class Predicate> iterator_trait<InputIterator>::distance_type count_if(InputIterator first, InputIterator last, Predicate pred);

template <class InputIterator, class Predicate, class Size> void count_if(InputIterator first, InputIterator last, Predicate pred, Size& n);

DESCRIPTION

The count algorithm compares value to elements in the sequence defined by iterators first and last. The first version of count return the number of matches. The second version increments a counting value n each time it finds a match. i.e., count returns (or adds to n) the number of iterators i in the range [first, last) for which the following condition holds:

*i == value

COMPLEXITY

The count_if algorithm lets you specify a predicate, and returns the number of times an element in the sequence satisfies the predicate (or increments n that number of times). That is, count_if returns (or adds to n) the number of iterators i in the range [first, last) for which the following condition holds:

pred(*i) == true. Both count and count_if perform exactly last-first applications of the corresponding predicate.

EXAMPLE

// // count.cpp // // Does not demonstrate the partial specialization versions // of count and count_if // #include <vector> #include <algorithm> #include <iostream.h>

int main() { int sequence[10] = {1,2,3,4,5,5,7,8,9,10}; int i=0,j=0,k=0; // // Set up a vector // vector<int> v(sequence,sequence + 10);

count(v.begin(),v.end(),5,i); // Count fives count(v.begin(),v.end(),6,j); // Count sixes // // Count all less than 8 // I=2, j=0 // count_if(v.begin(),v.end(),bind2nd(less<int>(),8),k); // k = 7

cout << i << " " << j << " " << k << endl; return 0; }

Output : 2 0 7

WARNINGS

If your compiler does not support partial specialization then the first version of both count and count_if (the one that returns the count) will not be available.

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance, you'll have to write:

vector <int, allocator<int> >

instead of:

vector <int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


count_if

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

count, count_if - Count the number of elements in a container that satisfy a given condition.

SYNOPSIS

#include <algorithm> template<class InputIterator, class T> iterator_trait<InputIterator>::distance_type count(InputIterator first, InputIterator last, const T& value);

template <class InputIterator, class T, class Size> void count(InputIterator first, InputIterator last, const T& value, Size& n);

template<class InputIterator, class Predicate> iterator_trait<InputIterator>::distance_type count_if(InputIterator first, InputIterator last, Predicate pred);

template <class InputIterator, class Predicate, class Size> void count_if(InputIterator first, InputIterator last, Predicate pred, Size& n);

DESCRIPTION

The count algorithm compares value to elements in the sequence defined by iterators first and last. The first version of count return the number of matches. The second version increments a counting value n each time it finds a match. i.e., count returns (or adds to n) the number of iterators i in the range [first, last) for which the following condition holds:

*i == value

COMPLEXITY

The count_if algorithm lets you specify a predicate, and returns the number of times an element in the sequence satisfies the predicate (or increments n that number of times). That is, count_if returns (or adds to n) the number of iterators i in the range [first, last) for which the following condition holds:

pred(*i) == true. Both count and count_if perform exactly last-first applications of the corresponding predicate.

EXAMPLE

// // count.cpp // // Does not demonstrate the partial specialization versions // of count and count_if // #include <vector> #include <algorithm> #include <iostream.h>

int main() { int sequence[10] = {1,2,3,4,5,5,7,8,9,10}; int i=0,j=0,k=0; // // Set up a vector // vector<int> v(sequence,sequence + 10);

count(v.begin(),v.end(),5,i); // Count fives count(v.begin(),v.end(),6,j); // Count sixes // // Count all less than 8 // I=2, j=0 // count_if(v.begin(),v.end(),bind2nd(less<int>(),8),k); // k = 7

cout << i << " " << j << " " << k << endl; return 0; }

Output : 2 0 7

WARNINGS

If your compiler does not support partial specialization then the first version of both count and count_if (the one that returns the count) will not be available.

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance, you'll have to write:

vector <int, allocator<int> >

instead of:

vector <int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


compare

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

compare - A binary function or a function object that returns true or false. compare objects are typically passed as template parameters, and used for ordering elements within a container.

SEE ALSO

binary_function, function object

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


distance

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

distance - Computes the distance between two iterators

SYNOPSIS

#include <iterator>

template <class ForwardIterator> iterator_traits<ForwardIterator>::distance_type distance (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class Distance> void distance (ForwardIterator first, ForwardIterator last, Distance& n);

DESCRIPTION

The distance template function computes the distance between two iterator. The first version returns that value, while the second version increments n by that value. The last iterator must be reachable from the first iterator.

Note that the second version of this function is obsolete. It is provided for backward compatibility and to support compilers that do not provide partial specialization. As you may have already deduced, the first version of the function is not available with compilers that do not support partial specialization since it depends on iterator_traits, which itself depends on that particular language feature.

EXAMPLE

// // distance.cpp //

#include <iterator> #include <vector> #include <iostream.h> int main() { // //Initialize a vector using an array // int arr[6] = {3,4,5,6,7,8}; vector<int> v(arr,arr+6); // //Declare a list iterator, s.b. a ForwardIterator // vector<int>::iterator itr = v.begin()+3; // //Output the original vector // cout << "For the vector: "; copy(v.begin(),v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl;

cout << "When the iterator is initialized to point to " << *itr << endl; // // Use of distance // vector<int>::difference_type dist = 0; distance(v.begin(), itr, dist); cout << "The distance between the beginning and itr is " << dist << endl; return 0; }

Output : For the vector: 3 4 5 6 7 8 When the iterator is initialized to point to 6 The distance between the beginning and itr is 3

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector <int, allocator,int> > instead of:

vector <int>

Also, if your compiler does not support partial specialization then you will not be able to use the version of distance that returns the distance. Instead you'll have to use the version that increments a reference parameter.

SEE ALSO

sequence, random_iterator

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


distance_type

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

distance_type - Determine the type of distance used by an iterator. This function is now obsolete. It is retained in order to provide backward compatibility and support compilers that do not provide partial specialization.

SYNOPSIS

#include <iterator>

template <class T, class Distance> inline Distance* distance_type (const input_iterator<T, Distance>&)

template <class T, class Distance> inline Distance* distance_type (const forward_iterator<T, Distance>&)

template <class T, class Distance> inline Distance* distance_type (const bidirectional_iterator<T, Distance>&)

template <class T, class Distance> inline Distance* distance_type (const random_access_iterator<T, Distance>&)

template <class T> inline ptrdiff_t* distance_type (const T*)

DESCRIPTION

The distance_type family of function templates return a pointer to a value that is of the same type as that used to represent a distance between two iterators. The first four of these take an iterator of a particular type and return a pointer to a default value of the distance_type for that iterator. The T* form of the function returns ptrdiff_t*.

Generic algorithms use this function to create local variables of the correct type. The distance_type functions are typically used like this:

template <class Iterator> void foo(Iterator first, Iterator last) { __foo(begin,end,distance_type(first)); }

template <class Iterator, class Distance> void __foo(Iterator first,Iterator last, Distance*> { Distance d = Distance(); distance(first,last,d); }

The auxiliary function template allows the algorithm to extract a distance type from the first iterator and then use that type to perform some useful work.

SEE ALSO

Other iterator primitives: value_type, iterator_category, distance, advance

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


equal

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

equal - Compares two ranges for equality.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2> bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template <class InputIterator1, class InputIterator2, class BinaryPredicate> bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred);

DESCRIPTION

The equal algorithm does a pairwise comparison of all of the elements in one range with all of the elements in another range to see if they match. The first version of equal uses the equal operator (==) as the comparison function, and the second version allows you to specify a binary predicate as the comparison function. The first version returns true if all of the corresponding elements are equal to each other. The second version of equal returns true if for each pair of elements in the two ranges, the result of applying the binary predicate is true. In other words, equal returns true if both of the following are true:

1. There are at least as many elements in the second range as in the first;

2. For every iterator i in the range [first1, last1) the following corresponding conditions hold:

*i == *(first2 + (i - first1))

or

binary_pred(*i, *(first2 + (i - first1))) == true

Otherwise, equal returns false.

This algorithm assumes that there are at least as many elements available after first2 as there are in the range [first1, last1).

COMPLEXITY

equal performs at most last1-first1 comparisons or applications of the predicate.

EXAMPLE

// // equal.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; int d2[4] = {1,2,4,3}; // // Set up two vectors // vector<int> v1(d1+0, d1 + 4), v2(d2+0, d2 + 4);

// Check for equality bool b1 = equal(v1.begin(),v1.end(),v2.begin()); bool b2 = equal(v1.begin(),v1.end(), v2.begin(),equal_to<int>());

// Both b1 and b2 are false cout << (b1 ? "TRUE" : "FALSE") << " " << (b2 ? "TRUE" : "FALSE") << endl; return 0; }

Output : FALSE FALSE

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


equal_range

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

equal_range - Find the largest subrange in a collection into which a given value can be inserted without violating the ordering of the collection.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class T> pair<ForwardIterator, ForwardIterator> equal_range(ForwardIterator first, ForwardIterator last, const T& value);

template <class ForwardIterator, class T, class Compare> pair<ForwardIterator, ForwardIterator> equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

DESCRIPTION

The equal_range algorithm performs a binary search on an ordered container to determine where the element value can be inserted without violating the container's ordering. The library provides two versions of the algorithm. The first version uses the less than operator (operator <) to search for the valid insertion range, and assumes that the sequence was sorted using the less than operator. The second version allows you to specify a function object of type Compare, and assumes that Compare was the function used to sort the sequence. The function object must be a binary predicate.

equal_range returns a pair of iterators, i and j that define a range containing elements equivalent to value, i.e., the first and last valid insertion points for value. If value is not an element in the container, i and j are equal. Otherwise, i will point to the first element not "less" than value, and j will point to the first element greater than value. In the second version, "less" is defined by the comparison object. Formally, equal_range returns a subrange [i, j) such that value can be inserted at any iterator k within the range. Depending upon the version of the algorithm used, k must satisfy one of the following conditions:

!(*k < value) && !(value < *k)

or

comp(*k,value) == false && comp(value, *k) == false

The range [first,last) is assumed to be sorted.

COMPLEXITY

equal_range performs at most 2 * log(last - first) + 1 comparisons.

EXAMPLE

// // eqlrange.cpp // #include <vector> #include <algorithm> #include <iostream.h> int main() { typedef vector<int>::iterator iterator; int d1[11] = {0,1,2,2,3,4,2,2,2,6,7}; // // Set up a vector // vector<int> v1(d1+0, d1 + 11); // // Try equal_range variants // pair<iterator,iterator> p1 = equal_range(v1.begin(),v1.end(),3); // p1 = (v1.begin() + 4,v1.begin() + 5) pair<iterator,iterator> p2 = equal_range(v1.begin(),v1.end(),2,less<int>()); // p2 = (v1.begin() + 4,v1.begin() + 5) // Output results cout << endl << "The equal range for 3 is: " << "( " << *p1.first << " , " << *p1.second << " ) " << endl << endl; cout << endl << "The equal range for 2 is: " << "( " << *p2.first << " , " << *p2.second << " ) " << endl; return 0; } Output : The equal range for 3 is: ( 3 , 4 ) The equal range for 2 is: ( 2 , 3 )

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

SEE ALSO

instead of:

vector<int> binary_function, lower_bound, upper_bound

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


equal_to

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

equal_to - Binary function object that returns true if its first argument equals its second

SYNOPSIS

#include <functional>

template <class T> struct equal_to;

DESCRIPTION

equal_to is a binary function object. Its operator() returns true if x is equal to y. You can pass an equal_to object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. equal_to would be used in that algorithm in the following manner:

vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), equal_to<int>());

After this call to transform, vecResult(n) will contain a "1" if vec1(n) was equal to vec2(n) or a "0" if vec1(n) was not equal to vec2(n).

INTERFACE

template <class T> struct equal_to : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type;

SEE ALSO

bool operator() (const T&, const T&) const; }; binary_function, function objects

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


fill

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

fill, fill_n - Initializes a range with a given value.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class T> void fill(ForwardIterator first, ForwardIterator last, const T& value);

template <class OutputIterator, class Size, class T> void fill_n(OutputIterator first, Size n, const T& value);

DESCRIPTION

The fill and fill_n algorithms are used to assign a value to the elements in a sequence. fill assigns the value to all the elements designated by iterators in the range [first, last).

The fill_n algorithm assigns the value to all the elements designated by iterators in the range [first, first + n). fill_n assumes that there are at least n elements following first, unless first is an insert iterator.

COMPLEXITY

fill makes exactly last - first assignments, and fill_n makes exactly n assignments.

EXAMPLE

// // fill.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; // // Set up two vectors // vector<int> v1(d1,d1 + 4), v2(d1,d1 + 4); // // Set up one empty vector // vector<int> v3; // // Fill all of v1 with 9 // fill(v1.begin(),v1.end(),9);

// // Fill first 3 of v2 with 7 // fill_n(v2.begin(),3,7);

// // Use insert iterator to fill v3 with 5 11's // fill_n(back_inserter(v3),5,11); // // Copy all three to cout // ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl; // // Fill cout with 3 5's // fill_n(ostream_iterator<int,char>(cout," "),3,5); cout << endl;

return 0; }

Output : 9 9 9 9 7 7 7 4 11 11 11 11 11 5 5 5

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


fill_n

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

fill, fill_n - Initializes a range with a given value.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class T> void fill(ForwardIterator first, ForwardIterator last, const T& value);

template <class OutputIterator, class Size, class T> void fill_n(OutputIterator first, Size n, const T& value);

DESCRIPTION

The fill and fill_n algorithms are used to assign a value to the elements in a sequence. fill assigns the value to all the elements designated by iterators in the range [first, last).

The fill_n algorithm assigns the value to all the elements designated by iterators in the range [first, first + n). fill_n assumes that there are at least n elements following first, unless first is an insert iterator.

COMPLEXITY

fill makes exactly last - first assignments, and fill_n makes exactly n assignments.

EXAMPLE

// // fill.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; // // Set up two vectors // vector<int> v1(d1,d1 + 4), v2(d1,d1 + 4); // // Set up one empty vector // vector<int> v3; // // Fill all of v1 with 9 // fill(v1.begin(),v1.end(),9);

// // Fill first 3 of v2 with 7 // fill_n(v2.begin(),3,7);

// // Use insert iterator to fill v3 with 5 11's // fill_n(back_inserter(v3),5,11); // // Copy all three to cout // ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl; // // Fill cout with 3 5's // fill_n(ostream_iterator<int,char>(cout," "),3,5); cout << endl;

return 0; }

Output : 9 9 9 9 7 7 7 4 11 11 11 11 11 5 5 5

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


find

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

find - Find an occurrence of value in a sequence

SYNOPSIS

#include <algorithm>

template <class InputIterator, class T> InputIterator find(InputIterator first, InputIterator last, const T& value);

DESCRIPTION

The find algorithm lets you search for the first occurrence of a particular value in a sequence. find returns the first iterator i in the range [first, last) for which the following condition holds:

*i == value.

If find does not find a match for value, it returns the iterator last.

COMPLEXITY

find performs at most last-first comparisons.

EXAMPLE

// // find.cpp // #include <vector> #include <algorithm>

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); // it1 = v1.begin() + 4;

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

// Try both adjacent_find variants iterator it3 = adjacent_find(v1.begin(),v1.end()); // it3 = v1.begin() +2

iterator it4 = adjacent_find(v1.begin(),v1.end(),equal_to<int>()); // v4 = v1.begin() + 2

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

return 0; }

Output : 3 3 2 2

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

adjacent_find, find_first_of, find_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


find_end

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

find_end - Finds the last occurrence of a sub-sequence in a sequence.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2); template <class Forward Iterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

DESCRIPTION

The find_end algorithm finds the last occurrence of a sub-sequence, indicated by [first2, last2), in a sequence, [first1,last1). The algorithm returns an iterator pointing to the first element of the found subsequence, or last1 if no match is found.

More precisely, the find_end algorithm returns the last iterator i in the range [first1, last1 - (last2-first2)) such that for any non-negative integer n < (last2-first2), the following corresponding conditions hold:

*(i+n) == *(first2+n), pred(*(i+n),*(first2+n)) == true.

Or returns last1 if no such iterator is found.

Two versions of the algorithm exist. The first uses the equality operator as the default binary predicate, and the second allows you to specify a binary predicate.

COMPLEXITY

At most (last2-first2)*(last1-first1-(last2-first2)+1) applications of the corresponding predicate are done.

EXAMPLE

// // find_end.cpp // #include<vector> #include<iterator> #include<algorithm> #include<iostream.h>

int main() { typedef vector<int>::iterator iterator; int d1[10] = {0,1,6,5,3,2,2,6,5,7}; int d2[4] = {6,5,0,0} // // Set up two vectors. // vector<int> v1(d1+0, d1+10), v2(d2+0, d2+2); // // Try both find_first_of variants. // iterator it1 = find_first_of (v1.begin(), v1.end(), v2.begin(), v2.end()); iterator it2 = find_first_of (v1.begin(), v1.end(), v2.begin(), v2.end(), equal_to<int>()); // // Try both find_end variants. // iterator it3 = find_end (v1.begin(), v1.end(), v2.begin(), v2.end()); iterator it4 = find_end (v1.begin(), v1.end(), v2.begin(), v2.end(), equal_to<int>()); // // Output results of find_first_of. // Iterator now points to the first element that matches one of // a set of values // cout << "For the vectors: "; copy (v1.begin(), v1.end(), ostream_iterator<int>(cout," ")); cout << " and "; copy (v2.begin(), v2.end(), ostream_iterator<int>(cout," ")); cout<< endl ,, endl << "both versions of find_first_of point to: " << *it1 << endl << "with first_of address = " << it1 << endl ; // //Output results of find_end. // Iterator now points to the first element of the last find //sub-sequence. // cout << endl << endl << "both versions of find_end point to: " << *it3 << endl << "with find_end address = " << it3 << endl ;

return 0; }

Output : For the vectors: 0 1 6 5 3 2 2 6 5 7 and 6 5 both versions of find_first_of point to: 6 with first_of address = 0x100005c0 both versions of find_end point to: 6 with find_end address = 0x100005d4

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int, allocator<int> >

instead of:

vector<int>

SEE ALSO

Algorithms, find, find_if, adjacent_find

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


find_first_of

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

find_first_of - Finds the first occurrence of any value from one sequence in another sequence.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

DESCRIPTION

The find_first_of algorithm finds a the first occurrence of a value from a sequence, specified by first2, last2, in a sequence specified by first1, last1. The algorithm returns an iterator in the range [first1, last1) that points to the first matching element. If the first sequence [first1, last1) does not contain any of the values in the second sequence, find_first_of returns last1.

In other words, find_first_of returns the first iterator i in the [first1, last1)such that for some integer j in the range [first2, last2):the following conditions hold:

*i == *j, pred(*i,*j) == true.

Or find_first_of returns last1 if no such iterator is found.

COMPLEXITY

Two versions of the algorithm exist. The first uses the equality operator as the default binary predicate, and the second allows you to specify a binary predicate.

At most (last1 - first1)*(last2 - first2) applications of the corresponding predicate are done.

EXAMPLE

// // find_f_o.cpp // #include <vector> #include <iterator> #include <algorithm> #include <iostream.h>

int main() { typedef vector<int>::iterator iterator; int d1[10] = {0,1,2,2,3,4,2,2,6,7}; int d2[2] = {6,4}; // // Set up two vectors // vector<int> v1(d1,d1 + 10), v2(d2,d2 + 2); // // Try both find_first_of variants // iterator it1 = find_first_of(v1.begin(),v1.end(),v2.begin(),v2.end()); find_first_of(v1.begin(),v1.end(),v2.begin(),v2.end(), equal_to<int>()); // // Output results // cout << "For the vectors: "; copy(v1.begin(),v1.end(), ostream_iterator<int,char>(cout," " )); cout << " and "; copy(v2.begin(),v2.end(), ostream_iterator<int,char>(cout," " )); cout << endl << endl << "both versions of find_first_of point to: " << *it1;

return 0; }

Output : For the vectors: 0 1 2 2 3 4 2 2 6 7 and 6 4 both versions of find_first_of point to: 4

WARNINGS

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int, allocator<int> >

instead of:

vector<int>

SEE ALSO

Algorithms, adjacent_find, find, find_if, find_next, find_end

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


find_if

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

find_if - Find an occurrence of value in a sequence that satisfies a specifed predicate.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class Predicate> InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);

DESCRIPTION

The find_if algorithm allows you to search for the first element in a sequence that satisfies a particular condition. The sequence is defined by iterators first and last, while the condition is defined by the third argument: a predicate function that returns a boolean value. find_if returns the first iterator i in the range [first, last) for which the following condition holds:

pred(*i) == true.

If no such iterator is found, find_if returns last.

COMPLEXITY

find_if performs at most last-first applications of the corresponding predicate.

EXAMPLE

// // find.cpp // #include <vector> #include <algorithm> #include <iostream.h>

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); // it1 = v1.begin() + 4;

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

// Try both adjacent_find variants iterator it3 = adjacent_find(v1.begin(),v1.end()); // it3 = v1.begin() +2

iterator it4 = adjacent_find(v1.begin(),v1.end(),equal_to<int>()); // v4 = v1.begin() + 2

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

return 0; }

Output : 3 3 2 2

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int, allocator<int> >

instead of:

vector<int>

SEE ALSO

adjacent_find, Algorithms, find, find_end, find_first_of

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


for_each

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

for_each - Applies a function to each element in a range.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class Function> void for_each(InputIterator first, InputIterator last, Function f);

DESCRIPTION

The for_each algorithm applies function f to all members of the sequence in the range [first, last), where first and last are iterators that define the sequence. Since this a non-mutating algorithm, the function f cannot make any modifications to the sequence, but it can achieve results through side effects (such as copying or printing). If f returns a result, the result is ignored.

COMPLEXITY

The function f is applied exactly last - first times.

EXAMPLE

// // for_each.cpp // #include <vector> #include <algorithm> #include <iostream.h>

// Function class that outputs its argument times x template <class Arg> class out_times_x : private unary_function<Arg,void> { private: Arg multiplier;

public: out_times_x(const Arg& x) : multiplier(x) { } void operator()(const Arg& x) { cout << x * multiplier << " " << endl; } };

int main() { int sequence[5] = {1,2,3,4,5};

// Set up a vector vector<int> v(sequence,sequence + 5);

// Setup a function object out_times_x<int> f2(2);

for_each(v.begin(),v.end(),f2); // Apply function

return 0; }

Output : 2 4 6 8 10

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int, allocator<int> >

instead of:

vector<int>

SEE ALSO

Algorithms, function object

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


generate

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

generate, generate_n - Initialize a container with values produced by a value-generator class.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class Generator> void generate(ForwardIterator first, ForwardIterator last, Generator gen);

template <class OutputIterator, class Size, class Generator> void generate_n(OutputIterator first, Size n, Generator gen);

DESCRIPTION

A value-generator function returns a value each time it is invoked. The algorithms generate and generate_n initialize (or reinitialize) a sequence by assigning the return value of the generator function gen to all the elements designated by iterators in the range [first, last) or [first, first + n). The function gen takes no arguments. (gen can be a function or a class with an operator () defined that takes no arguments.)

generate_n assumes that there are at least n elements following first, unless first is an insert iterator.

COMPLEXITY

The generate and generate_n algorithms invoke gen and assign its return value exactly last - first (or n) times.

EXAMPLE

// // generate.cpp // #include <algorithm> #include <vector> #include <iostream.h>

// Value generator simply doubles the current value // and returns it template <class T> class generate_val { private: T val_; public: generate_val(const T& val) : val_(val) {} T& operator()() { val_ += val_; return val_; } };

int main() { int d1[4] = {1,2,3,4}; generate_val<int> gen(1);

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d1,d1 + 4); // Set up one empty vector vector<int> v3;

// Generate values for all of v1 generate(v1.begin(),v1.end(),gen);

// Generate values for first 3 of v2 generate_n(v2.begin(),3,gen);

// Use insert iterator to generate 5 values for v3 generate_n(back_inserter(v3),5,gen);

// Copy all three to cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl;

// Generate 3 values for cout generate_n(ostream_iterator<int>(cout," "),3,gen); cout << endl;

return 0; }

Output : 2 4 8 16 2 4 8 4 2 4 8 16 32 2 4 8

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write:

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

function objects

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


generate_n

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

generate, generate_n - Initialize a container with values produced by a value-generator class.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class Generator> void generate(ForwardIterator first, ForwardIterator last, Generator gen);

template <class OutputIterator, class Size, class Generator> void generate_n(OutputIterator first, Size n, Generator gen);

DESCRIPTION

A value-generator function returns a value each time it is invoked. The algorithms generate and generate_n initialize (or reinitialize) a sequence by assigning the return value of the generator function gen to all the elements designated by iterators in the range [first, last) or [first, first + n). The function gen takes no arguments. (gen can be a function or a class with an operator () defined that takes no arguments.)

generate_n assumes that there are at least n elements following first, unless first is an insert iterator.

COMPLEXITY

The generate and generate_n algorithms invoke gen and assign its return value exactly last - first (or n) times.

EXAMPLE

// // generate.cpp // #include <algorithm> #include <vector> #include <iostream.h>

// Value generator simply doubles the current value // and returns it template <class T> class generate_val { private: T val_; public: generate_val(const T& val) : val_(val) {} T& operator()() { val_ += val_; return val_; } };

int main() { int d1[4] = {1,2,3,4}; generate_val<int> gen(1);

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d1,d1 + 4); // Set up one empty vector vector<int> v3;

// Generate values for all of v1 generate(v1.begin(),v1.end(),gen);

// Generate values for first 3 of v2 generate_n(v2.begin(),3,gen);

// Use insert iterator to generate 5 values for v3 generate_n(back_inserter(v3),5,gen);

// Copy all three to cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl;

// Generate 3 values for cout generate_n(ostream_iterator<int>(cout," "),3,gen); cout << endl;

return 0; }

Output : 2 4 8 16 2 4 8 4 2 4 8 16 32 2 4 8

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write:

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

function objects

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


greater

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

greater - Binary function object that returns true if its first argument is greater than its second.

SYNOPSIS

#include <functional>

template <class T> struct greater : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };

DESCRIPTION

greater is a binary function object. Its operator() returns true if x is greater than y. You can pass a greater object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result of the function. greater would be used in that algorithm in the following manner:

vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), greater<int>());

WARNINGS

After this call to transform, vecResult(n) will contain a "1" if vec1(n) was greater than vec2(n) or a "0" if vec1(n) was less than or equal to vec2(n).

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :

vector<int, allocator<int> >

instead of

vector<int>

SEE ALSO

function objects

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


greater_equal

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

greater_equal - Binary function object that returns true if its first argument is greater than or equal to its second

SYNOPSIS

#include <functional>

template <class T> struct greater_equal ; : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };

DESCRIPTION

greater_equal is a binary function object. Its operator() returns true if x is greater than or equal to y. You can pass a greater_equal object to any algorithm that requires a binary function. For example, the sort algorithm can accept a binary function as an alternate comparison object to sort a sequence. greater_equal would be used in that algorithm in the following manner:

vector<int> vec1; sort(vec1.begin(), vec1.end(),greater_equal<int>());

After this call to sort, vec1 will be sorted in descending order.

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :

vector<int, allocator<int> >

instead of

vector<int>

SEE ALSO

function objects

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


Heap_Operations

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

Heap_Operations

See the entries for make_heap, pop_heap, push_heap and sort_heap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


includes

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

includes - Basic set operation for sorted sequences.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2> bool includes (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);

template <class InputIterator1, class InputIterator2, class Compare> bool includes (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);

DESCRIPTION

The includes algorithm compares two sorted sequences and returns true if every element in the range [first2, last2) is contained in the range [first1, last1). It returns false otherwise. include assumes that the sequences are sorted using the default comparison operator less than (<), unless an alternative comparison operator (comp) is provided.

COMPLEXITY

At most ((last1 - first1) + (last2 - first2)) * 2 -1 comparisons are performed.

EXAMPLE

// // includes.cpp // #include <algorithm> #include <set> #include <iostream.h>

int main() {

//Initialize some sets int a1[10] = {1,2,3,4,5,6,7,8,9,10}; int a2[6] = {2,4,6,8,10,12}; int a3[4] = {3,5,7,8}; set<int, less<int> > all(a1, a1+10), even(a2, a2+6), small(a3,a3+4);

//Demonstrate includes cout << "The set: "; copy(all.begin(),all.end(), ostream_iterator<int,char>(cout," ")); bool answer = includes(all.begin(), all.end(), small.begin(), small.end()); cout << endl << (answer ? "INCLUDES " : "DOES NOT INCLUDE "); copy(small.begin(),small.end(), ostream_iterator<int,char>(cout," ")); answer = includes(all.begin(), all.end(), even.begin(), even.end()); cout << ", and" << endl << (answer ? "INCLUDES" : "DOES NOT INCLUDE "); copy(even.begin(),even.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl;

return 0; }

Output : The set: 1 2 3 4 5 6 7 8 9 10 INCLUDES 3 5 7 8 , and DOES NOT INCLUDE 2 4 6 8 10 12

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :

set<int, less<int>, allocator<int> >

instead of

set<int>

SEE ALSO

set, set_union, set_intersection, set_difference, set_symmetric_difference

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


inner_product

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

inner_product - Computes the inner product A X B of two ranges A and B.

SYNOPSIS

#include <numeric> template <class InputIterator1, class InputIterator2, class T> T inner_product (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2> T inner_product (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);

DESCRIPTION

There are two versions of inner_product. The first computes an inner product using the default multiplication and addition operators, while the second allows you to specify binary operations to use in place of the default operations.

The first version of the function computes its result by initializing the accumulator acc with the initial value init and then modifying it with:

acc = acc + ((*i1) * (*i2))

for every iterator i1 in the range [first1, last1) and iterator i2 in the range [first2, first2 + (last1 - first1)). The algorithm returns acc.

The second version of the function initializes acc with init, then computes the result:

acc = binary_op1(acc, binary_op2(*i1, *i2))

for every iterator i1 in the range [first1, last1) and iterator i2 in the range [first2, first2 + (last1 - first1)).

COMPLEXITY

The inner_product algorithm computes exactly (last1 - first1) applications of either:

acc + (*i1) * (*i2) or

binary_op1(acc, binary_op2(*i1, *i2)).

EXAMPLE

// // inr_prod.cpp // #include <numeric> //For inner_product #include <list> //For list #include <vector> //For vectors #include <functional> //For plus and minus #include <iostream.h> int main() { //Initialize a list and an int using arrays of ints int a1[3] = {6, -3, -2}; int a2[3] = {-2, -3, -2}; list<int> l(a1, a1+3); vector<int> v(a2, a2+3); //Calculate the inner product of the two sets of values int inner_prod = inner_product(l.begin(), l.end(), v.begin(), 0); //Calculate a wacky inner product using the same values int wacky = inner_product(l.begin(), l.end(), v.begin(), 0, plus<int>(), minus<int>()); //Print the output cout << "For the two sets of numbers: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << " and "; copy(l.begin(),l.end(),ostream_iterator<int,char>(cout," ")); cout << "," << endl << endl; cout << "The inner product is: " << inner_prod << endl; cout << "The wacky result is: " << wacky << endl; return 0; } Output : For the two sets of numbers: -2 -3 -2 and 6 -3 -2 , The inner product is: 1 The wacky result is: 8

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :

list<int, allocator<int> > and vector<int, allocator<int> >

instead of

list<int> and vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


inplace_merge

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

inplace_merge - Merge two sorted sequences into one.

SYNOPSIS

#include <algorithm> template <class BidirectionalIterator> void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);

template <class BidirectionalIterator, class Compare> void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);

DESCRIPTION

The inplace_merge algorithm merges two sorted consecutive ranges [first, middle) and [middle, last), and puts the result of the merge into the range [first, last). The merge is stable, that is, if the two ranges contain equivalent elements, the elements from the first range always precede the elements from the second.

There are two versions of the inplace_merge algorithm. The first version uses the less than operator (operator<) as the default for comparison, and the second version accepts a third argument that specifies a comparison operator.

COMPLEXITY

When enough additional memory is available, inplace_merge does at most (last - first) - 1 comparisons. If no additional memory is available, an algorithm with O(NlogN) complexity (where N is equal to last-first) may be used.

EXAMPLE

// // merge.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; int d2[8] = {11,13,15,17,12,14,16,18};

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d1,d1 + 4);

// Set up four destination vectors vector<int> v3(d2,d2 + 8),v4(d2,d2 + 8), v5(d2,d2 + 8),v6(d2,d2 + 8); // Set up one empty vector vector<int> v7; // Merge v1 with v2 merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin()); // Now use comparator merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v4.begin(), less<int>()); // In place merge v5 vector<int>::iterator mid = v5.begin(); advance(mid,4); inplace_merge(v5.begin(),mid,v5.end()); // Now use a comparator on v6 mid = v6.begin(); advance(mid,4); inplace_merge(v6.begin(),mid,v6.end(),less<int>()); // Merge v1 and v2 to empty vector using insert iterator merge(v1.begin(),v1.end(),v2.begin(),v2.end(), back_inserter(v7)); // Copy all cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl; copy(v4.begin(),v4.end(),out); cout << endl; copy(v5.begin(),v5.end(),out); cout << endl; copy(v6.begin(),v6.end(),out); cout << endl; copy(v7.begin(),v7.end(),out); cout << endl;

// Merge v1 and v2 to cout merge(v1.begin(),v1.end(),v2.begin(),v2.end(), ostream_iterator<int,char>(cout," ")); cout << endl; return 0; }

Output: 1 2 3 4 1 2 3 4 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 11 12 13 14 15 16 17 18 11 12 13 14 15 16 17 18 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4

WARNINGS

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :

vector<int, allocator,int> >

instead of

vector<int>

SEE ALSO

merge

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


iter_swap

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

iter_swap - Exchange values pointed at in two locations

SYNOPSIS

#include <algorithm>

template <class ForwardIterator1, class ForwardIterator2> void iter_swap (ForwardIterator1, ForwardIterator2);

DESCRIPTION

The iter_swap algorithm exchanges the values pointed at by the two iterators a and b.

EXAMPLE

#include <vector> #include <algorithm> #include <iostream.h>

int main () { int d1[] = {6, 7, 8, 9, 10, 1, 2, 3, 4, 5}; // // Set up a vector. // vector<int> v(d1+0, d1+10); // // Output original vector. // cout << "For the vector: "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); // // Swap the first five elements with the last five elements. // swap_ranges(v.begin(), v.begin()+5, v.begin()+5); // // Output result. // cout << endl << endl << "Swapping the first 5 elements with the last 5 gives: " << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); // // Now an example of iter_swap -- swap first and last elements. // iter_swap(v.begin(), v.end()-1); // // Output result. // cout << endl << endl << "Swapping the first and last elements gives: " << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : For the vector: 6 7 8 9 10 1 2 3 4 5 Swapping the first five elements with the last five gives: 1 2 3 4 5 6 7 8 9 10 Swapping the first and last elements gives: 10 2 3 4 5 6 7 8 9 1

WARNING

If your compiler does not support default template parameters, then you will need to always supply the Allocator template argument. For instance, you'll have to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

Iterators, swap, swap_ranges

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


lexicographical_compare

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

lexicographical_compare - Compares two ranges lexicographically.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2> bool lexicographical_compare(InputIterator1 first, InputIterator2 last1, InputIterator2 first2, InputIterator last2);

template <class InputIterator1, class InputIterator2, class Compare> bool lexicographical_compare(InputIterator1 first, InputIterator2 last1, InputIterator2 first2, InputIterator last2, Compare comp);

DESCRIPTION

The lexicographical_compare functions compare each element in the range [first1, last1) to the corresponding element in the range [first2, last2) using iterators i and j.

The first version of the algorithm uses operator< as the default comparison operator. It immediately returns true if it encounters any pair in which *i is less than *j, and immediately returns false if *j is less than *i. If the algorithm reaches the end of the first sequence before reaching the end of the second sequence, it also returns true.

The second version of the function takes an argument comp that defines a comparison function that is used in place of the default operator<.

The lexicographical_compare functions can be used with all the datatypes provided by the standard library.

COMPLEXITY

lexicographical_compare performs at most min((last1 - first1), (last2 - first2)) applications of the comparison function.

EXAMPLE

// // lex_comp.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { int d1[5] = {1,3,5,32,64}; int d2[5] = {1,3,2,43,56};

// set up vector vector<int> v1(d1,d1 + 5), v2(d2,d2 + 5);

// Is v1 less than v2 (I think not) bool b1 = lexicographical_compare(v1.begin(), v1.end(), v2.begin(), v2.end());

// Is v2 less than v1 (yup, sure is) bool b2 = lexicographical_compare(v2.begin(), v2.end(), v1.begin(), v1.end(), less<int>()); cout << (b1 ? "TRUE" : "FALSE") << " " << (b2 ? "TRUE" : "FALSE") << endl;

return 0; }

Output: FALSE TRUE

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :

vector<int, allocator<int> >

instead of :

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


lower_bound

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

lower_bound - Determine the first valid position for an element in a sorted container.

SYNOPSIS

template <class ForwardIterator, class T> ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value);

template <class ForwardIterator, class T, class Compare> ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

DESCRIPTION

The lower_bound algorithm compares a supplied value to elements in a sorted container and returns the first position in the container that value can occupy without violating the container's ordering. There are two versions of the algorithm. The first uses the less than operator (operator<) to perform the comparison, and assumes that the sequence has been sorted using that operator. The second version lets you include a function object of type Compare, and assumes that Compare is the function used to sort the sequence. The function object must be a binary predicate.

lower_bound's return value is the iterator for the first element in the container that is greater than or equal to value, or, when the comparison operator is used, the first element that does not satisfy the comparison function. Formally, the algorithm returns an iterator i in the range [first, last) such that for any iterator j in the range [first, i) the following corresponding conditions hold:

*j < value

or

comp(*j, value) == true

COMPLEXITY

lower_bound performs at most log(last - first) + 1 comparisons.

EXAMPLE

// // ul_bound.cpp // #include <vector> #include <algorithm> #include <iostream.h>

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

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

// Try lower_bound variants iterator it1 = lower_bound(v1.begin(),v1.end(),3); // it1 = v1.begin() + 4

iterator it2 = lower_bound(v1.begin(),v1.end(),2,less<int>()); // it2 = v1.begin() + 4

// Try upper_bound variants iterator it3 = upper_bound(v1.begin(),v1.end(),3); // it3 = vector + 5

iterator it4 = upper_bound(v1.begin(),v1.end(),2,less<int>()); // it4 = v1.begin() + 5

cout << endl << endl << "The upper and lower bounds of 3: ( " << *it1 << " , " << *it3 << " ]" << endl;

cout << endl << endl << "The upper and lower bounds of 2: ( " << *it2 << " , " << *it4 << " ]" << endl;

return 0; }

Output : The upper and lower bounds of 3: ( 3 , 4 ] The upper and lower bounds of 2: ( 2 , 3 ]

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

upper_bound, equal_range

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


make_heap

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

make_heap - Creates a heap.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void make_heap(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

DESCRIPTION

A heap is a particular organization of elements in a range between two random access iterators [a, b). Its two key properties are:

1. *a is the largest element in the range.

2. *a may be removed by the pop_heap algorithm, or a new element can be added by the push_heap algorithm, in O(logN) time.

These properties make heaps useful as priority queues.

The heap algorithms use less than (operator<) as the default comparison. In all of the algorithms, an alternate comparison operator can be specified.

The first version of the make_heap algorithm arranges the elements in the range [first, last) into a heap using less than (operator<) to perform comparisons. The second version uses the comparison operator comp to perform the comparisons. Since the only requirements for a heap are the two listed above, make_heap is not required to do anything within the range (first, last - 1).

COMPLEXITY

This algorithm makes at most 3 * (last - first) comparisons.

EXAMPLE

// // heap_ops.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { int d1[4] = {1,2,3,4}; int d2[4] = {1,3,2,4};

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4);

// Make heaps make_heap(v1.begin(),v1.end()); make_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z) // Note that x, y and z represent the remaining // values in the container (other than 4). // The definition of the heap and heap operations // does not require any particular ordering // of these values.

// Copy both vectors to cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now let's pop pop_heap(v1.begin(),v1.end()); pop_heap(v2.begin(),v2.end(),less<int>()); // v1 = (3,x,y,4) and v2 = (3,x,y,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// And push push_heap(v1.begin(),v1.end()); push_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now sort those heaps sort_heap(v1.begin(),v1.end()); sort_heap(v2.begin(),v2.end(),less<int>()); // v1 = v2 = (1,2,3,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

return 0; } Output : 4 2 3 1 4 3 2 1 3 2 1 4 3 1 2 4 4 3 1 2 4 3 2 1 1 2 3 4 1 2 3 4

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

pop_heap, push_heap and sort_heap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


max

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

max - Find and return the maximum of a pair of values

SYNOPSIS

#include <algorithm>

template <class T> const T& max(const T&, const T&);

template <class T, class Compare> const T& max(const T&, const T&, Compare);

DESCRIPTION

The max algorithm determines and returns the maximum of a pair of values. The optional argument Compare defines a comparison function that can be used in place of the default operator<. This function can be used with all the datatypes provided by the standard library.

max returns the first argument when the arguments are equal.

EXAMPLE

// // max.cpp // #include <algorithm> #include <iostream.h> #include <iostream.h>

int main(void) { double d1 = 10.0, d2 = 20.0;

// Find minimum double val1 = min(d1, d2); // val1 = 10.0

// the greater comparator returns the greater of the // two values. double val2 = min(d1, d2, greater<double>()); // val2 = 20.0;

// Find maximum double val3 = max(d1, d2); // val3 = 20.0;

// the less comparator returns the smaller of the two values. // Note that, like every comparison in the STL, max is // defined in terms of the < operator, so using less here // is the same as using the max algorithm with a default // comparator. double val4 = max(d1, d2, less<double>()); // val4 = 20

cout << val1 << " " << val2 << " " << val3 << " " << val4 << endl;

return 0; }

Output : 10 20 20 20

SEE ALSO

max_element, min, min_element

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


max_element

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

max_element - Finds maximum value in a range.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator> ForwardIterator max_element(ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class Compare> ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare comp);

DESCRIPTION

The max_element algorithm returns an iterator that denotes the maximum element in a sequence. If the sequence contains more than one copy of the element, the iterator points to its first occurrence. The optional argument comp defines a comparison function that can be used in place of the default operator<. This function can be used with all the datatypes provided by the standard library.

Algorithm max_element returns the first iterator i in the range [first, last) such that for any iterator j in the same range the following corresponding conditions hold:

!(*i < *j)

or

comp(*i, *j) == false.

COMPLEXITY

Exactly max((last - first) - 1, 0) applications of the corresponding comparisons are done for max_element.

EXAMPLE

// // max_elem.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { typedef vector<int>::iterator iterator; int d1[5] = {1,3,5,32,64};

// set up vector vector<int> v1(d1,d1 + 5);

// find the largest element in the vector iterator it1 = max_element(v1.begin(), v1.end()); // it1 = v1.begin() + 4

// find the largest element in the range from // the beginning of the vector to the 2nd to last iterator it2 = max_element(v1.begin(), v1.end()-1, less<int>()); // it2 = v1.begin() + 3

// find the smallest element iterator it3 = min_element(v1.begin(), v1.end()); // it3 = v1.begin()

// find the smallest value in the range from // the beginning of the vector plus 1 to the end iterator it4 = min_element(v1.begin()+1, v1.end(), less<int>()); // it4 = v1.begin() + 1

cout << *it1 << " " << *it2 << " " << *it3 << " " << *it4 << endl;

return 0; }

Output : 64 32 1 3

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

max, min, min_element

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


merge

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

merge - Merge two sorted sequences into a third sequence.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator merge(InputIterator first1, InputIterator1 last1, InputIterator2 first2, InputIterator last2, OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator last2, OutputIterator result, Compare comp);

DESCRIPTION

The merge algorithm merges two sorted sequences, specified by [first1, last1) and [first2, last2), into the sequence specified by [result, result + (last1 - first1) + (last2 - first2)). The first version of the merge algorithm uses the less than operator (<) to compare elements in the two sequences. The second version uses the comparison function provided by the function call. If a comparison function is provided, merge assumes that both sequences were sorted using that comparison function.

The merge is stable. This means that if the two original sequences contain equivalent elements, the elements from the first sequence will always precede the matching elements from the second in the resulting sequence. The size of the result of a merge is equal to the sum of the sizes of the two argument sequences. merge returns an iterator that points to the end of the resulting sequence, i.e., result + (last1 - first1) + (last2 -first2). The result of merge is undefined if the resulting range overlaps with either of the original ranges.

merge assumes that there are at least (last1 - first1) + (last2 - first2) elements following result, unless result has been adapted by an insert iterator.

COMPLEXITY

For merge at most (last - first1) + (last2 - first2) - 1 comparisons are performed.

EXAMPLE

// // merge.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main() { int d1[4] = {1,2,3,4}; int d2[8] = {11,13,15,17,12,14,16,18};

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d1,d1 + 4); // Set up four destination vectors vector<int> v3(d2,d2 + 8),v4(d2,d2 + 8), v5(d2,d2 + 8),v6(d2,d2 + 8); // Set up one empty vector vector<int> v7;

// Merge v1 with v2 merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin()); // Now use comparator merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v4.begin(), less<int>());

// In place merge v5 vector<int>::iterator mid = v5.begin(); advance(mid,4); inplace_merge(v5.begin(),mid,v5.end()); // Now use a comparator on v6 mid = v6.begin(); advance(mid,4); inplace_merge(v6.begin(),mid,v6.end(),less<int>());

// Merge v1 and v2 to empty vector using insert iterator merge(v1.begin(),v1.end(),v2.begin(),v2.end(), back_inserter(v7));

// Copy all cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl; copy(v3.begin(),v3.end(),out); cout << endl; copy(v4.begin(),v4.end(),out); cout << endl; copy(v5.begin(),v5.end(),out); cout << endl; copy(v6.begin(),v6.end(),out); cout << endl; copy(v7.begin(),v7.end(),out); cout << endl;

// Merge v1 and v2 to cout merge(v1.begin(),v1.end(),v2.begin(),v2.end(), ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : 1 2 3 4 1 2 3 4 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 11 12 13 14 15 16 17 18 11 12 13 14 15 16 17 18 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

Containers, inplace_merge

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


min

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

min - Find and return the minimum of a pair of values

SYNOPSIS

#include <algorithm>

template <class T> const T& min(const T&, const T&);

template <class T, class Compare> const T& min(const T& a, const T&, Compare);

DESCRIPTION

The min algorithm determines and returns the minimum of a pair of values. In the second version of the algorithm, the optional argument Compare defines a comparison function that can be used in place of the default operator<. This function can be used with all the datatypes provided by the standard library.

min returns the first argument when the two arguments are equal.

EXAMPLE

// // max.cpp // #include <algorithm> #include <iostream.h>

int main(void) { double d1 = 10.0, d2 = 20.0;

// Find minimum double val1 = min(d1, d2); // val1 = 10.0

// the greater comparator returns the greater of the // two values. double val2 = min(d1, d2, greater<double>()); // val2 = 20.0;

// Find maximum double val3 = max(d1, d2); // val3 = 20.0;

// the less comparator returns the smaller of the // two values. // Note that, like every comparison in the STL, max is // defined in terms of the < operator, so using less here // is the same as using the max algorithm with a default // comparator. double val4 = max(d1, d2, less<double>()); // val4 = 20

cout << val1 << " " << val2 << " " << val3 << " " << val4 << endl;

return 0; }

Output : 10 20 20 20

SEE ALSO

max, max_element, min_element

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


min_element

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

min_element - Finds the minimum value in a range.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator> ForwardIterator min_element(ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class Compare> InputIterator min_element(ForwardIterator first, ForwardIterator last, Compare comp);

DESCRIPTION

The min_element algorithm returns an iterator that denotes the minimum element in a sequence. If the sequence contains more than one copy of the minimum element, the iterator points to the first occurrence of the element. In the second version of the function, the optional argument comp defines a comparison function that can be used in place of the default operator<. This function can be used with all the datatypes provided by the standard library.

Algorithm min_element returns the first iterator i in the range [first, last) such that for any iterator j in the range same range, the following corresponding conditions hold:

!(*j < *i)

or

comp(*j, *i) == false.

COMPLEXITY

min_element performs exactly max((last - first) - 1, 0) applications of the corresponding comparisons.

EXAMPLE

// // max_elem.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { typedef vector<int>::iterator iterator; int d1[5] = {1,3,5,32,64};

// set up vector vector<int> v1(d1,d1 + 5);

// find the largest element in the vector iterator it1 = max_element(v1.begin(), v1.end()); // it1 = v1.begin() + 4

// find the largest element in the range from // the beginning of the vector to the 2nd to last iterator it2 = max_element(v1.begin(), v1.end()-1, less<int>()); // it2 = v1.begin() + 3

// find the smallest element iterator it3 = min_element(v1.begin(), v1.end()); // it3 = v1.begin()

// find the smallest value in the range from // the beginning of the vector plus 1 to the end iterator it4 = min_element(v1.begin()+1, v1.end(), less<int>()); // it4 = v1.begin() + 1

cout << *it1 << " " << *it2 << " " << *it3 << " " << *it4 << endl;

return 0; }

Output : 64 32 1 3

WARNING

If your compiler does not support default template parameters then you need to always supply the Allocator template argument. For instance you'll have to write:

vector<int,allocator<int> >

instead of:

vector<int>

SEE ALSO

max, max_element, min

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


mismatch

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

mismatch - Compares elements from two sequences and returns the first two elements that don't match each other.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2> pair<InputIterator1,InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template <class InputIterator1, class InputIterator2, class BinaryPredicate> pair<InputIterator1, Inputiterator2> mismatch(InputIterator first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred);

DESCRIPTION

The mismatch algorithm compares members of two sequences and returns two iterators (i and j) that point to the first location in each sequence where the sequences differ from each other. Notice that the algorithm denotes both a starting position and an ending position for the first sequence, but denotes only a starting position for the second sequence. mismatch assumes that the second sequence has at least as many members as the first sequence. If the two sequences are identical, mismatch returns a pair of iterators that point to the end of the first sequence and the corresponding location at which the comparison stopped in the second sequence.

The first version of mismatch checks members of a sequence for equality, while the second version lets you specify a comparison function. The comparison function must be a binary predicate.

The iterators i and j returned by mismatch are defined as follows:

j == first2 + (i - first1)

and i is the first iterator in the range [first1, last1) for which the appropriate one of the following conditions hold:

!(*i == *(first2 + (i - first1)))

or

binary_pred(*i, *(first2 + (i - first1))) == false

If all of the members in the two sequences match, mismatch returns a pair of last1 and first2 + (last1 - first1).

COMPLEXITY

At most last1 - first1 applications of the corresponding predicate are done.

EXAMPLE

// // mismatch.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { typedef vector<int>::iterator iterator; int d1[4] = {1,2,3,4}; int d2[4] = {1,3,2,4};

// Set up two vectors vector<int> vi1(d1,d1 + 4), vi2(d2,d2 + 4);

// p1 will contain two iterators that point to the // first pair of elements that are different between // the two vectors pair<iterator, iterator> p1 = mismatch(vi1.begin(), vi1.end(), vi2.begin());

// find the first two elements such that an element in the // first vector is greater than the element in the second // vector. pair<iterator, iterator> p2 = mismatch(vi1.begin(), vi1.end(), vi2.begin(), less_equal<int>());

// Output results cout << *p1.first << ", " << *p1.second << endl; cout << *p2.first << ", " << *p2.second << endl;

return 0; } Output : 2, 3 3, 2

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


next_permutation

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

next_permutation - Generate successive permutations of a sequence based on an ordering function.

SYNOPSIS

#include <algorithm>

template <class BidirectionalIterator> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last);

template <class BidirectionalIterator, class Compare> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp);

DESCRIPTION

The permutation-generating algorithms (next_permutation and prev_permutation) assume that the set of all permutations of the elements in a sequence is lexicographically sorted with respect to operator< or comp. So, for example, if a sequence includes the integers 1 2 3, that sequence has six permutations, which, in order from first to last are: 1 2 3 , 1 3 2, 2 1 3, 2 3 1, 3 1 2, and 3 2 1.

The next_permutation algorithm takes a sequence defined by the range [first, last) and transforms it into its next permutation, if possible. If such a permutation does exist, the algorithm completes the transformation and returns true. If the permutation does not exist, next_permutation returns false, and transforms the permutation into its "first" permutation (according to the lexicographical ordering defined by either operator<, the default used in the first version of the algorithm, or comp, which is user-supplied in the second version of the algorithm.)

For example, if the sequence defined by [first, last) contains the integers 3 2 1 (in that order), there is not a "next permutation." Therefore, the algorithm transforms the sequence into its first permutation (1 2 3) and returns false.

COMPLEXITY

At most (last - first)/2 swaps are performed.

EXAMPLE

// // permute.cpp // #include <numeric> //for accumulate #include <vector> //for vector #include <functional> //for less #include <iostream.h>

int main() { //Initialize a vector using an array of ints int a1[] = {0,0,0,0,1,0,0,0,0,0}; char a2[] = "abcdefghji"; //Create the initial set and copies for permuting vector<int> m1(a1, a1+10); vector<int> prev_m1((size_t)10), next_m1((size_t)10); vector<char> m2(a2, a2+10); vector<char> prev_m2((size_t)10), next_m2((size_t)10); copy(m1.begin(), m1.end(), prev_m1.begin()); copy(m1.begin(), m1.end(), next_m1.begin()); copy(m2.begin(), m2.end(), prev_m2.begin()); copy(m2.begin(), m2.end(), next_m2.begin()); //Create permutations prev_permutation(prev_m1.begin(), prev_m1.end(),less<int>()); next_permutation(next_m1.begin(), next_m1.end(),less<int>()); prev_permutation(prev_m2.begin(), prev_m2.end(),less<int>()); next_permutation(next_m2.begin(), next_m2.end(),less<int>()); //Output results cout << "Example 1: " << endl << " "; cout << "Original values: "; copy(m1.begin(),m1.end(), ostream_iterator<int,char>(cout," ")); cout << endl << " "; cout << "Previous permutation: "; copy(prev_m1.begin(),prev_m1.end(), ostream_iterator<int,char>(cout," ")); cout << endl<< " "; cout << "Next Permutation: "; copy(next_m1.begin(),next_m1.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; cout << "Example 2: " << endl << " "; cout << "Original values: "; copy(m2.begin(),m2.end(), ostream_iterator<char,char>(cout," ")); cout << endl << " "; cout << "Previous Permutation: "; copy(prev_m2.begin(),prev_m2.end(), ostream_iterator<char,char>(cout," ")); cout << endl << " "; cout << "Next Permutation: "; copy(next_m2.begin(),next_m2.end(), ostream_iterator<char,char>(cout," ")); cout << endl << endl;

return 0; }

Output : Example 1: Original values: 0 0 0 0 1 0 0 0 0 0 Previous permutation: 0 0 0 0 0 1 0 0 0 0 Next Permutation: 0 0 0 1 0 0 0 0 0 0 Example 2: Original values: a b c d e f g h j i Previous Permutation: a b c d e f g h i j Next Permutation: a b c d e f g i h j

WARNING

If your compiler does not support default template parameters, the you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

prev_permutation

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


nth_element

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

nth_element - Rearranges a collection so that all elements lower in sorted order than the nth element come before it and all elements higher in sorter order than the nth element come after it.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void nth_element (RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void nth_element (RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);

DESCRIPTION

The nth_element algorithm rearranges a collection according to either the default comparison operator (>) or the provided comparison operator. After the algorithm applies, three things are true:

+ The element that would be in the nth position if the collection were completely sorted is in the nth position

+ All elements prior to the nth position would precede that position in an ordered collection

+ All elements following the nth position would follow that position in an ordered collection

That is, for any iterator i in the range [first, nth) and any iterator j in the range [nth, last) it holds that !(*i > *j) or comp(*i, *j) == false.

Note that the elements that precede or follow the nth position are not necessarily sorted relative to each other. The nth_element algorithm does not sort the entire collection.

COMPLEXITY

The algorithm is linear, on average, where N is the size of the range [first, last).

EXAMPLE

// // nthelem.cpp // #include <algorithm> #include <vector> #include <iostream.h>

template<class RandomAccessIterator> void quik_sort(RandomAccessIterator start, RandomAccessIterator end) { size_t dist = 0; distance(start, end, dist);

//Stop condition for recursion if(dist > 2) { //Use nth_element to do all the work for quik_sort nth_element(start, start+(dist/2), end);

//Recursive calls to each remaining unsorted portion quik_sort(start, start+(dist/2-1)); quik_sort(start+(dist/2+1), end); }

if(dist == 2 && *end < *start) swap(start, end); }

int main() { //Initialize a vector using an array of ints int arr[10] = {37, 12, 2, -5, 14, 1, 0, -1, 14, 32}; vector<int> v(arr, arr+10);

//Print the initial vector cout << "The unsorted values are: " << endl << " "; vector<int>::iterator i; for(i = v.begin(); i != v.end(); i++) cout << *i << ", "; cout << endl << endl;

//Use the new sort algorithm quik_sort(v.begin(), v.end());

//Output the sorted vector cout << "The sorted values are: " << endl << " "; for(i = v.begin(); i != v.end(); i++) cout << *i << ", "; cout << endl << endl;

return 0; }

Output : The unsorted values are: 37, 12, 2, -5, 14, 1, 0, -1, 14, 32, The sorted values are: -5, -1, 0, 1, 2, 12, 14, 14, 32, 37,

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

Algorithms

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


partial_sort

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

partial_sort - Templated algorithm for sorting collections of entities.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void partial_sort (RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void partial_sort (RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);

DESCRIPTION

The partial_sort algorithm takes the range [first,last) and places the first middle - first values into sorted order. The result is that the range [first, middle)is sorted like it would be if the entire range [first,last) were sorted. The remaining elements in the range (those in [middle, last)) are not in any defined order. The first version of the algorithm uses less than (operator<) as the comparison operator for the sort. The second version uses the comparison function comp.

COMPLEXITY

partial_sort does approximately (last - first) * log(middle-first) comparisons.

EXAMPLE

// // partsort.cpp // #include <vector> #include <algorithm> #include <iostream.h>

int main() { int d1[20] = {17, 3, 5, -4, 1, 12, -10, -1, 14, 7, -6, 8, 15, -11, 2, -2, 18, 4, -3, 0}; // // Set up a vector. // vector<int> v1(d1+0, d1+20); // // Output original vector. // cout << "For the vector: "; copy(v1.begin(), v1.end(), ostream_iterator<int,char>(cout," ")); // // Partial sort the first seven elements. // partial_sort(v1.begin(), v1.begin()+7, v1.end()); // // Output result. // cout << endl << endl << "A partial_sort of seven elements gives: " << endl << " "; copy(v1.begin(), v1.end(), ostream_iterator<int,char>(cout," ")); cout << endl; // // A vector of ten elements. // vector<int> v2(10, 0); // // Sort the last ten elements in v1 into v2. // partial_sort_copy(v1.begin()+10, v1.end(), v2.begin(), v2.end()); // // Output result. // cout << endl << "A partial_sort_copy of the last ten elements gives: " << endl << " "; copy(v2.begin(), v2.end(), ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : For the vector: 17 3 5 -4 1 12 -10 -1 14 7 -6 8 15 -11 2 -2 18 4 -3 0 A partial_sort of seven elements gives: -11 -10 -6 -4 -3 -2 -1 17 14 12 7 8 15 5 3 2 18 4 1 0 A partial_sort_copy of the last ten elements gives: 0 1 2 3 4 5 7 8 15 18

WARNING

If your compiler does not support default template parameters, then you need to always provide the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

sort, stable_sort, partial_sort_copy

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


partial_sort_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

partial_sort_copy - Templated algorithm for sorting collections of entities.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class RandomAccessIterator> void partial_sort_copy (InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last); template <class InputIterator, class RandomAccessIterator, class Compare> void partial_sort_copy (InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);

DESCRIPTION

The partial_sort_copy algorithm places the smaller of last - first and result_last - result_first sorted elements from the range [first, last) into the range beginning at result_first. (i.e., the range: [result_first, result_first+min(last - first, result_last - result_first)). Basically, the effect is as if the range [first,last) were placed in a temporary buffer, sorted and then as many elements as possible were copied into the range [result_first, result_last).

The first version of the algorithm uses less than (operator<) as the comparison operator for the sort. The second version uses the comparison function comp.

COMPLEXITY

partial_sort_copy does approximately (last-first) * log(min(last-first, result_last-result_first)) comparisons.

EXAMPLE

// // partsort.cpp // #include <vector> #include <algorithm> #include <iostream.h> int main() { int d1[20] = {17, 3, 5, -4, 1, 12, -10, -1, 14, 7, -6, 8, 15, -11, 2, -2, 18, 4, -3, 0}; // // Set up a vector. // vector<int> v1(d1+0, d1+20); // // Output original vector. // cout << "For the vector: "; copy(v1.begin(), v1.end(), ostream_iterator<int>(cout," ")); // // Partial sort the first seven elements. // partial_sort(v1.begin(), v1.begin()+7, v1.end()); // // Output result. // cout << endl << endl << "A partial_sort of 7 elements gives: " << endl << " "; copy(v1.begin(), v1.end(), ostream_iterator<int,char>(cout," ")); cout << endl; // // A vector of ten elements. // vector<int> v2(10, 0); // // Sort the last ten elements in v1 into v2. // partial_sort_copy(v1.begin()+10, v1.end(), v2.begin(), v2.end()); // // Output result. // cout << endl << "A partial_sort_copy of the last ten elements gives: " << endl << " "; copy(v2.begin(), v2.end(), ostream_iterator<int,char>(cout," ")); cout << endl; return 0; } Output : For the vector: 17 3 5 -4 1 12 -10 -1 14 7 -6 8 15 -11 2 -2 18 4 -3 0 A partial_sort of seven elements gives: -11 -10 -6 -4 -3 -2 -1 17 14 12 7 8 15 5 3 2 18 4 1 0 A partial_sort_copy of the last ten elements gives: 0 1 2 3 4 5 7 8 15 18

WARNING

If your compiler does not support default template parameters, then you need to always provide the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

sort_ stable_sort, partial_sort

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


partial_sum

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

partial_sum - Calculates successive partial sums of a range of values.

SYNOPSIS

#include <numeric>

template <class InputIterator, class OutputIterator> OutputIterator partial_sum (InputIterator first, InputIterator last, OutputIterator result);

template <class InputIterator, class OutputIterator, class BinaryOperation> OutputIterator partial_sum (InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);

DESCRIPTION

The partial_sum algorithm creates a new sequence in which every element is formed by adding all the values of the previous elements, or, in the second form of the algorithm, applying the operation binary_op successively on every previous element. That is, partial_sum assigns to every iterator i in the range [result, result + (last - first)) a value equal to:

((...(*first + *(first + 1)) + ... ) + *(first + (i - result)))

or, in the second version of the algorithm:

binary_op(binary_op(..., binary_op (*first, *(first + 1)),...),*(first + (i - result)))

For instance, applying partial_sum to (1,2,3,4,) will yield (1,3,6,10).

The partial_sum algorithm returns result + (last - first).

If result is equal to first, the elements of the new sequence successively replace the elements in the original sequence, effectively turning partial_sum into an inplace transformation.

COMPLEXITY

Exactly (last - first) - 1 applications of the default + operator or binary_op are performed.

EXAMPLE

// // partsum.cpp // #include <numeric> //for accumulate #include <vector> //for vector #include <functional> //for times #include <iostream.h>

int main() { //Initialize a vector using an array of ints int d1[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(d1, d1+10);

//Create an empty vectors to store results vector<int> sums((size_t)10), prods((size_t)10);

//Compute partial_sums and partial_products partial_sum(v.begin(), v.end(), sums.begin()); partial_sum(v.begin(), v.end(), prods.begin(), times<int>());

//Output the results cout << "For the series: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

cout << "The partial sums: " << endl << " " ; copy(sums.begin(),sums.end(), ostream_iterator<int,char>(cout," ")); cout <<" should each equal (N*N + N)/2" << endl << endl;

cout << "The partial products: " << endl << " "; copy(prods.begin(),prods.end(), ostream_iterator<int,char>(cout," ")); cout << " should each equal N!" << endl;

return 0; }

Output : For the series: 1 2 3 4 5 6 7 8 9 10

The partial sums: 1 3 6 10 15 21 28 36 45 55 should each equal (N*N + N)/2 The partial products: 1 2 6 24 120 720 5040 40320 362880 3628800 should each equal N!

WARNING

If your compiler does not support default template parameters, then you need to always provide the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


partition

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

partition - Places all of the entities that satisfy the given predicate before all of the entities that do not.

SYNOPSIS

#include <algorithm>

template <class BidirectionalIterator, class Predicate> BidirectionalIterator partition (BidirectionalIterator first, BidirectionalIterator last, Predicate pred);

DESCRIPTION

The partition algorithm places all the elements in the range [first, last) that satisfy pred before all the elements that do not satisfy pred. It returns an iterator that is one past the end of the group of elements that satisfy pred. In other words, partition returns i such that for any itera- tor j in the range[first, i), pred(*j) == true, and, for any iterator k in the range [i, last), pred(*j) == false.

Note that partition does not necessarily maintain the relative order of the elements that match and elements that do not match the predicate. Use the algorithm stable_partition if relative order is important.

COMPLEXITY

The partition algorithm does at most (last - first)/2 swaps, and applies the predicate exactly last - first times.

EXAMPLE

// // prtition.cpp // #include <functional> #include <deque> #include <algorithm> #include <iostream.h>

// // Create a new predicate from unary_function. // template<class Arg> class is_even : public unary_function<Arg, bool> { public: bool operator()(const Arg& arg1) { return (arg1 % 2) == 0; } };

int main () { // // Initialize a deque with an array of integers. // int init[10] = { 1,2,3,4,5,6,7,8,9,10 }; deque<int> d1(init+0, init+10); deque<int> d2(init+0, init+10); // // Print out the original values. // cout << "Unpartitioned values: " << ""; copy(d1.begin(), d1.end(), ostream_iterator<int,char>(cout," ")); cout << endl; // // A partition of the deque according to even/oddness. // partition(d2.begin(), d2.end(), is_even<int>()); // // Output result of partition. // cout << "Partitioned values: " << ""; copy(d2.begin(), d2.end(), ostream_iterator<int,char>(cout," ")); cout << endl; // // A stable partition of the deque according to even/oddness. // stable_partition(d1.begin(), d1.end(), is_even<int>()); // // Output result of partition. // cout << "Stable partitioned values: " << ""; copy(d1.begin(), d1.end(), ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : Unpartitioned values: 1 2 3 4 5 6 7 8 9 10 Partitioned values: 10 2 8 4 6 5 7 3 9 1 Stable partitioned values: 2 4 6 8 10 1 3 5 7 9

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you need to write :

deque<int, allocator<int> >

instead of :

deque<int>

SEE ALSO

stable_partition

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


permutation

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

permutation - Generate successive permutations of a sequence based on an ordering function.

See the entries for next_permutation and prev_permutation.

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


pop_heap

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

pop_heap - Moves the largest element off the heap.

SYNOPSIS

template <class RandomAccessIterator> void pop_heap(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

DESCRIPTION

A heap is a particular organization of elements in a range between two random access iterators [a, b). Its two key properties are:

1. *a is the largest element in the range.

2. *a may be removed by the pop_heap algorithm or a new element added by the push_heap algorithm, in O(logN) time.

These properties make heaps useful as priority queues.

The pop_heap algorithm uses the less than (<) operator as the default comparison. An alternate comparison operator can be specified.

The pop_heap algorithm can be used as part of an operation to remove the largest element from a heap. It assumes that the range [first, last) is a valid heap (i.e., that first is the largest element in the heap or the first element based on the alternate comparison operator). It then swaps the value in the location first with the value in the location last - 1 and makes [first, last -1)back into a heap. You can then access the element in last using the vector or deque back() member function, or remove the element using the pop_back member function. Note that pop_heap does not actually remove the element from the data structure, you must use another function to do that.

COMPLEXITY

pop_heap performs at most 2 * log(last - first) comparisons.

EXAMPLE

// // heap_ops.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { int d1[4] = {1,2,3,4}; int d2[4] = {1,3,2,4};

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4);

// Make heaps make_heap(v1.begin(),v1.end()); make_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z) // Note that x, y and z represent the remaining // values in the container (other than 4). // The definition of the heap and heap operations // does not require any particular ordering // of these values.

// Copy both vectors to cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now let's pop pop_heap(v1.begin(),v1.end()); pop_heap(v2.begin(),v2.end(),less<int>()); // v1 = (3,x,y,4) and v2 = (3,x,y,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// And push push_heap(v1.begin(),v1.end()); push_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now sort those heaps sort_heap(v1.begin(),v1.end()); sort_heap(v2.begin(),v2.end(),less<int>()); // v1 = v2 = (1,2,3,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

return 0; }

Output : 4 2 3 1 4 3 2 1 3 2 1 4 3 1 2 4 4 3 1 2 4 3 2 1 1 2 3 4 1 2 3 4

WARNING

If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

make_heap, push_heap, sort_heap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


prev_permutation

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

prev_permutation - Generate successive permutations of a sequence based on an ordering function.

SYNOPSIS

#include <algorithm>

template <class BidirectionalIterator> bool prev_permutation (BidirectionalIterator first, BidirectionalIterator last);

template <class BidirectionalIterator, class Compare> bool prev_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp);

DESCRIPTION

The permutation-generating algorithms (next_permutation and prev_permutation) assume that the set of all permutations of the elements in a sequence is lexicographically sorted with respect to operator< or comp. So, for example, if a sequence includes the integers 1 2 3, that sequence has six permutations, which, in order from first to last, are: 1 2 3 , 1 3 2, 2 1 3, 2 3 1, 3 1 2, and 3 2 1.

The prev_permutation algorithm takes a sequence defined by the range [first, last) and transforms it into its previous permutation, if possible. If such a permutation does exist, the algorithm completes the transformation and returns true. If the permutation does not exist, prev_permutation returns false, and transforms the permutation into its "last" permutation (according to the lexicographical ordering defined by either operator <, the default used in the first version of the algorithm, or comp, which is user-supplied in the second version of the algorithm.)

For example, if the sequence defined by [first, last) contains the integers 1 2 3 (in that order), there is not a "previous permutation." Therefore, the algorithm transforms the sequence into its last permutation (3 2 1) and returns false.

COMPLEXITY

At most (last - first)/2 swaps are performed.

EXAMPLE

// // permute.cpp // #include <numeric> //for accumulate #include <vector> //for vector #include <functional> //for less #include <iostream.h>

int main() { //Initialize a vector using an array of ints int a1[] = {0,0,0,0,1,0,0,0,0,0}; char a2[] = "abcdefghji";

//Create the initial set and copies for permuting vector<int> m1(a1, a1+10); vector<int> prev_m1((size_t)10), next_m1((size_t)10); vector<char> m2(a2, a2+10); vector<char> prev_m2((size_t)10), next_m2((size_t)10);

copy(m1.begin(), m1.end(), prev_m1.begin()); copy(m1.begin(), m1.end(), next_m1.begin()); copy(m2.begin(), m2.end(), prev_m2.begin()); copy(m2.begin(), m2.end(), next_m2.begin());

//Create permutations prev_permutation(prev_m1.begin(), prev_m1.end(),less<int>()); next_permutation(next_m1.begin(), next_m1.end(),less<int>()); prev_permutation(prev_m2.begin(), prev_m2.end(),less<int>()); next_permutation(next_m2.begin(), next_m2.end(),less<int>()); //Output results cout << "Example 1: " << endl << " "; cout << "Original values: "; copy(m1.begin(),m1.end(), ostream_iterator<int,char>(cout," ")); cout << endl << " "; cout << "Previous permutation: "; copy(prev_m1.begin(),prev_m1.end(), ostream_iterator<int,char>(cout," "));

cout << endl<< " "; cout << "Next Permutation: "; copy(next_m1.begin(),next_m1.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl;

cout << "Example 2: " << endl << " "; cout << "Original values: "; copy(m2.begin(),m2.end(), ostream_iterator<char,char>(cout," ")); cout << endl << " "; cout << "Previous Permutation: "; copy(prev_m2.begin(),prev_m2.end(), ostream_iterator<char,char>(cout," ")); cout << endl << " ";

cout << "Next Permutation: "; copy(next_m2.begin(),next_m2.end(), ostream_iterator<char,char>(cout," ")); cout << endl << endl;

return 0; }

Output : Example 1: Original values: 0 0 0 0 1 0 0 0 0 0 Previous permutation: 0 0 0 0 0 1 0 0 0 0 Next Permutation: 0 0 0 1 0 0 0 0 0 0 Example 2: Original values: a b c d e f g h j i Previous Permutation: a b c d e f g h i j Next Permutation: a b c d e f g i h j

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

next_permutation

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


push_heap

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

push_heap - Places a new element into a heap.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void push_heap(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

DESCRIPTION

A heap is a particular organization of elements in a range between two random access iterators [a, b). Its two key properties are:

1. *a is the largest element in the range.

2. *a may be removed by the pop_heap algorithm, or a new element added by the push_heap algorithm, in O(logN) time.

These properties make heaps useful as priority queues.

The push_heap algorithms uses the less than (<) operator as the default comparison. As with all of the heap manipulation algorithms, an alternate comparison function can be specified.

The push_heap algorithm is used to add a new element to the heap. First, a new element for the heap is added to the end of a range. (For example, you can use the vector or deque member function push_back()to add the element to the end of either of those containers.) The push_heap algorithm assumes that the range [first, last - 1) is a valid heap. It then properly posi- tions the element in the location last - 1 into its proper position in the heap, resulting in a heap over the range [first, last).

Note that the push_heap algorithm does not place an element into the heap's underlying container. You must user another function to add the element to the end of the container before applying push_heap.

COMPLEXITY

For push_heap at most log(last - first) comparisons are performed.

EXAMPLE

// // heap_ops.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { int d1[4] = {1,2,3,4}; int d2[4] = {1,3,2,4};

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4);

// Make heaps make_heap(v1.begin(),v1.end()); make_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z) // Note that x, y and z represent the remaining // values in the container (other than 4). // The definition of the heap and heap operations // does not require any particular ordering // of these values.

// Copy both vectors to cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now let's pop pop_heap(v1.begin(),v1.end()); pop_heap(v2.begin(),v2.end(),less<int>()); // v1 = (3,x,y,4) and v2 = (3,x,y,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// And push push_heap(v1.begin(),v1.end()); push_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now sort those heaps sort_heap(v1.begin(),v1.end()); sort_heap(v2.begin(),v2.end(),less<int>()); // v1 = v2 = (1,2,3,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

return 0; }

Output : 4 2 3 1 4 3 2 1 3 2 1 4 3 1 2 4 4 3 1 2 4 3 2 1 1 2 3 4 1 2 3 4

WARNING

If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

make_heap, pop_heap, sort_heap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


random_shuffle

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

random_shuffle - Randomly shuffles elements of a collection.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void random_shuffle (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class RandomNumberGenerator> void random_shuffle (RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand);

DESCRIPTION

The random_shuffle algorithm shuffles the elements in the range [first, last) with uniform distribution. random_shuffle can take a particular random number generating function object rand , where rand takes a positive argument n of distance type of the RandomAccessIterator and returns a randomly chosen value between 0 and n - 1.

COMPLEXITY

In the random_shuffle algorithm, (last - first) -1 swaps are done.

EXAMPLE

// // rndshufl.cpp // #include <algorithm> #include <vector> #include <iostream.h> int main() { //Initialize a vector with an array of ints int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10); //Print out elements in original (sorted) order cout << "Elements before random_shuffle: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; //Mix them up with random_shuffle random_shuffle(v.begin(), v.end()); //Print out the mixed up elements cout << "Elements after random_shuffle: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : Elements before random_shuffle: 1 2 3 4 5 6 7 8 9 10 Elements after random_shuffle: 7 9 10 3 2 5 4 8 1 6

WARNING

If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


remove

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

remove - Move desired elements to the front of a container, and return an iterator that describes where the sequence of desired elements ends.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class T> ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& value);

DESCRIPTION

The remove algorithm eliminates all the elements referred to by iterator i in the range [first, last) for which the following condition holds: *i == value. remove returns an iterator that designates the end of the resulting range. remove is stable, that is, the relative order of the elements that are not removed is the same as their relative order in the original range.

remove does not actually reduce the size of the sequence. It actually operates by: 1) copying the values that are to be retained to the front of the sequence, and 2) returning an iterator that describes where the sequence of retained values ends. Elements that are after this iterator are simply the original sequence values, left unchanged. Here's a simple example:

Say we want to remove all values of "2" from the following sequence:

354621271

Applying the remove algorithm results in the following sequence:

3546171|XX

The vertical bar represents the position of the iterator returned by remove. Note that the elements to the left of the vertical bar are the original sequence with the "2's" removed.

If you want to actually delete items from the container, use the following technique:

container.erase(remove(first,last,value),container.end());

COMPLEXITY

Exactly last1 - first1 applications of the corresponding predicate are done.

EXAMPLE

// // remove.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h> template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator()(const Arg& x){ return 1; } }; int main () { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10); copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // remove the 7 vector<int>::iterator result = remove(v.begin(), v.end(), 7); // delete dangling elements from the vector v.erase(result, v.end()); copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // remove everything beyond the fourth element result = remove_if(v.begin()+4, v.begin()+8, all_true<int>()); // delete dangling elements v.erase(result, v.end()); copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; return 0; } Output : 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 8 9 10 1 2 3 4 1 2 4

WARNING

If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

remove_if, remove_copy, remove_copy_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


remove_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

remove_copy - Move desired elements to the front of a container, and return an iterator that describes where the sequence of desired elements ends.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class OutputIterator, class T> OutputIterator remove_copy (InputIterator first, InputIterator last, OutputIterator result, const T& value);

DESCRIPTION

The remove_copy algorithm copies all the elements referred to by the iterator i in the range [first, last) for which the following corresponding condition does not hold: *i == value. remove_copy returns the end of the resulting range. remove_copy is stable, that is, the relative order of the elements in the resulting range is the same as their relative order in the original range. The elements in the original sequence are not altered by remove_copy.

COMPLEXITY

Exactly last1 - first1 applications of the corresponding predicate are done.

EXAMPLE

// // remove.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h>

template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator() (const Arg&) { return 1; } };

int main () { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr+0, arr+10);

copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Remove the 7. // vector<int>::iterator result = remove(v.begin(), v.end(), 7); // // Delete dangling elements from the vector. // v.erase(result, v.end());

copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Remove everything beyond the fourth element. // result = remove_if(v.begin()+4, v.begin()+8, all_true<int>()); // // Delete dangling elements. // v.erase(result, v.end());

copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Now remove all 3s on output. // remove_copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," "), 3); cout << endl << endl; // // Now remove everything satisfying predicate on output. // Should yield a NULL vector. // remove_copy_if(v.begin(), v.end(), ostream_iterator<int,char>(cout," "), all_true<int>());

return 0; }

Output : 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 8 9 10 1 2 3 4 1 2 4

WARNING

If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

remove, remove_if, remove_copy_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


remove_copy_if

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

remove_copy_if - Move desired elements to the front of a container, and return an iterator that describes where the sequence of desired elements ends.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class OutputIterator, class Predicate> OutputIterator remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred);

DESCRIPTION

The remove_copy_if algorithm copies all the elements referred to by the iterator i in the range [first, last) for which the following condition does not hold: pred(*i) == true. remove_copy_if returns the end of the resulting range. remove_copy_if is stable, that is, the relative order of the elements in the resulting range is the same as their relative order in the original range.

COMPLEXITY

Exactly last1 - first1 applications of the corresponding predicate are done.

EXAMPLE

// // remove.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h>

template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator() (const Arg&) { return 1; } };

int main () { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr+0, arr+10);

copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Remove the 7. // vector<int>::iterator result = remove(v.begin(), v.end(), 7); // // Delete dangling elements from the vector. // v.erase(result, v.end());

copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Remove everything beyond the fourth element. // result = remove_if(v.begin()+4, v.begin()+8, all_true<int>()); // // Delete dangling elements. // v.erase(result, v.end());

copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Now remove all 3s on output. // remove_copy(v.begin(), v.end(), ostream_iterator<int>(cout," "), 3); cout << endl << endl; // // Now remove everything satisfying predicate on output. // Should yield a NULL vector. // remove_copy_if(v.begin(), v.end(), ostream_iterator<int,char>(cout," "), all_true<int>());

return 0; } Output : 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 8 9 10 1 2 3 4 1 2 4

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

remove, remove_if, remove_copy

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


remove_if

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

remove_if - Move desired elements to the front of a container, and return an iterator that describes where the sequence of desired elements ends.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class Predicate> ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, Predicate pred);

DESCRIPTION

The remove_if algorithm eliminates all the elements referred to by iterator i in the range [first, last) for which the following corresponding condition holds: pred(*i) == true. remove_if returns the end of the resulting range. remove_if is stable, that is, the relative order of the elements that are not removed is the same as their relative order in the original range.

remove_if does not actually reduce the size of the sequence. It actually operates by: 1) copying the values that are to be retained to the front of the sequence, and 2) returning an iterator that describes where the sequence of retained values ends. Elements that are after this iterator are simply the original sequence values, left unchanged. Here's a simple example:

Say we want to remove all even numbers from the following sequence:

123456789

Applying the remove_if algorithm results in the following sequence:

13579|XXXX

The vertical bar represents the position of the iterator returned by remove_if. Note that the elements to the left of the vertical bar are the original sequence with the even numbers removed. The elements to the right of the bar are simply the untouched original members of the original sequence.

If you want to actually delete items from the container, use the following technique:

container.erase(remove(first,last,value),container.end());

COMPLEXITY

Exactly last1 - first1 applications of the corresponding predicate are done.

EXAMPLE

// // remove.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h> template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator()(const Arg& x){ return 1; } }; int main () { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10); copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // remove the 7 vector<int>::iterator result = remove(v.begin(), v.end(), 7); // delete dangling elements from the vector v.erase(result, v.end()); copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; // remove everything beyond the fourth element result = remove_if(v.begin()+4, v.begin()+8, all_true<int>()); // delete dangling elements v.erase(result, v.end()); copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl; return 0; } Output : 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 8 9 10 1 2 3 4 1 2 4

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

remove, remove_copy, remove_copy_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


replace

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

replace - Substitutes elements stored in a collection with new values.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class T> void replace (ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);

DESCRIPTION

The replace algorithm replaces elements referred to by iterator i in the range [first, last) with new_value when the following condition holds: *i == old_value

COMPLEXITY

Exactly last - first comparisons or applications of the corresponding predicate are done.

EXAMPLE

// // replace.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h>

template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator()(const Arg&){ return 1; } };

int main() {

//Initialize a vector with an array of integers int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10);

//Print out original vector cout << "The original list: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Replace the number 7 with 11 replace(v.begin(), v.end(), 7, 11);

// Print out vector with 7 replaced, // s.b. 1 2 3 4 5 6 11 8 9 10 cout << "List after replace " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Replace 1 2 3 with 13 13 13 replace_if(v.begin(), v.begin()+3, all_true<int>(), 13);

// Print out the remaining vector, // s.b. 13 13 13 4 5 6 11 8 9 10 cout << "List after replace_if " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

return 0; }

Output : The original list: 1 2 3 4 5 6 7 8 9 10 List after replace: 1 2 3 4 5 6 11 8 9 10 List after replace_if: 13 13 13 4 5 6 11 8 9 10 List using replace_copy to cout: 17 17 17 4 5 6 11 8 9 10 List with all elements output as 19s: 19 19 19 19 19 19 19 19 19 19

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

replace_if, replace_copy, replace_copy_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


replace_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

replace_copy - Substitutes elements stored in a collection with new values.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class OutputIterator, class T> OutputIterator replace_copy (InputIterator first, InputIterator last, OutputIterator result, const T& old_value, const T& new_value);

DESCRIPTION

The replace_copy algorithm leaves the original sequence intact and places the revised sequence into result. The algorithm compares elements referred to by iterator i in the range [first, last) with old_value. If *i does not equal old_value, then the replace_copy copies *i to result+(first-i). If *i==old_value, then replace_copy copies new_value to result+(first-i). replace_copy returns result+(last-first).

COMPLEXITY

Exactly last - first comparisons between values are done.

EXAMPLE

// // replace.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h>

template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator() (const Arg&) { return 1; } };

int main () { // // Initialize a vector with an array of integers. // int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; vector<int> v(arr+0, arr+10); // // Print out original vector. // cout << "The original list: " << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Replace the number 7 with 11. // replace(v.begin(), v.end(), 7, 11); // // Print out vector with 7 replaced. // cout << "List after replace:" << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Replace 1 2 3 with 13 13 13. // replace_if(v.begin(), v.begin()+3, all_true<int>(), 13); // // Print out the remaining vector. // cout << "List after replace_if:" << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Replace those 13s with 17s on output. // cout << "List using replace_copy to cout:" << endl << " "; replace_copy(v.begin(), v.end(), ostream_iterator<int,char>(cout, " "), 13, 17); cout << endl << endl; // // A simple example of replace_copy_if. // cout << "List w/ all elements output as 19s:" << endl << " "; replace_copy_if(v.begin(), v.end(), ostream_iterator<int,char>(cout, " "), all_true<int>(), 19); cout << endl;

return 0; } Output : The original list: 1 2 3 4 5 6 7 8 9 10 List after replace: 1 2 3 4 5 6 11 8 9 10 List after replace_if: 13 13 13 4 5 6 11 8 9 10 List using replace_copy to cout: 17 17 17 4 5 6 11 8 9 10 List with all elements output as 19s: 19 19 19 19 19 19 19 19 19 19

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

replace, replace_if, replace_copy_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


replace_copy_if

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

replace_copy_if - Substitutes elements stored in a collection with new values.

SYNOPSIS

#include <algorithm> template <class InputIterator, class OutputIterator, class Predicate, class T> OutputIterator replace_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);

DESCRIPTION

The replace_copy_if algorithm leaves the original sequence intact and places a revised sequence into result. The algorithm compares each element *i in the range [first,last) with the conditions specified by pred. If pred(*i)==false, replace_copy_if copies *i to result+(first-i). If pred(*i)==true, then replace_copy copies new_value to result+(first-i). replace_copy_if returns result+(last-first).

COMPLEXITY

Exactly last - first applications of the predicate are performed.

EXAMPLE

// // replace.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h>

template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator() (const Arg&) { return 1; } };

int main () { // // Initialize a vector with an array of integers. // int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; vector<int> v(arr+0, arr+10); // // Print out original vector. // cout << "The original list: " << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Replace the number 7 with 11. // replace(v.begin(), v.end(), 7, 11); // // Print out vector with 7 replaced. // cout << "List after replace:" << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Replace 1 2 3 with 13 13 13. // replace_if(v.begin(), v.begin()+3, all_true<int>(), 13); // // Print out the remaining vector. // cout << "List after replace_if:" << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Replace those 13s with 17s on output. // cout << "List using replace_copy to cout:" << endl << " "; replace_copy(v.begin(), v.end(), ostream_iterator<int,char>(cout, " "), 13, 17); cout << endl << endl; // // A simple example of replace_copy_if. // cout << "List w/ all elements output as 19s:" << endl << " "; replace_copy_if(v.begin(), v.end(), ostream_iterator<int,char>(cout, " "), all_true<int>(), 19); cout << endl;

return 0; } Output : The original list: 1 2 3 4 5 6 7 8 9 10 List after replace: 1 2 3 4 5 6 11 8 9 10 List after replace_if: 13 13 13 4 5 6 11 8 9 10 List using replace_copy to cout: 17 17 17 4 5 6 11 8 9 10 List with all elements output as 19s: 19 19 19 19 19 19 19 19 19 19

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

replace, replace_if, replace_copy

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


replace_if

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

replace_if - Substitutes elements stored in a collection with new values.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator, class Predicate, class T> void replace_if (ForwardIterator first, ForwardIterator last, Predicate pred const T& new_value);

DESCRIPTION

The replace_if algorithm replaces element referred to by iterator i in the range [first, last) with new_value when the following condition holds: pred(*i) == true.

COMPLEXITY

Exactly last - first applications of the predicate are done.

EXAMPLE

// // replace.cpp // #include <algorithm> #include <vector> #include <iterator> #include <iostream.h>

template<class Arg> struct all_true : public unary_function<Arg, bool> { bool operator()(const Arg&){ return 1; } };

int main() {

//Initialize a vector with an array of integers int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10);

//Print out original vector cout << "The original list: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Replace the number 7 with 11 replace(v.begin(), v.end(), 7, 11);

// Print out vector with 7 replaced, // s.b. 1 2 3 4 5 6 11 8 9 10 cout << "List after replace " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Replace 1 2 3 with 13 13 13 replace_if(v.begin(), v.begin()+3, all_true<int>(), 13);

// Print out the remaining vector, // s.b. 13 13 13 4 5 6 11 8 9 10 cout << "List after replace_if " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

return 0; }

Output : The original list: 1 2 3 4 5 6 7 8 9 10 List after replace: 1 2 3 4 5 6 11 8 9 10 List after replace_if: 13 13 13 4 5 6 11 8 9 10 List using replace_copy to cout: 17 17 17 4 5 6 11 8 9 10 List with all elements output as 19s: 19 19 19 19 19 19 19 19 19 19

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

replace, replace_copy, replace_copy_if

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


reverse

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

reverse - Reverse the order of elements in a collection.

SYNOPSIS

#include <algorithm>

template <class BidirectionalIterator> void reverse (BidirectionalIterator first, BidirectionalIterator last);

DESCRIPTION

The algorithm reverse reverses the elements in a sequence so that the last element becomes the new first element, and the first element becomes the new last. For each non-negative integer i <= (last - first)/2 , reverse applies swap to all pairs of iterators first + I, (last - I) - 1.

Because the iterators are assumed to be bidirectional, reverse does not return anything.

COMPLEXITY

reverse performs exactly (last - first)/2 swaps.

EXAMPLE

// // reverse.cpp // #include <algorithm> #include <vector> #include <iostream.h> int main() { //Initialize a vector with an array of ints int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10);

//Print out elements in original (sorted) order cout << "Elements before reverse: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Reverse the ordering reverse(v.begin(), v.end());

//Print out the reversed elements cout << "Elements after reverse: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : Elements before reverse: 1 2 3 4 5 6 7 8 9 10 Elements after reverse: 10 9 8 7 6 5 4 3 2 1 A reverse_copy to cout: 1 2 3 4 5 6 7 8 9 10

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

reverse_copy, swap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


reverse_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

reverse_copy - Reverse the order of elements in a collection while copying them to a new collecton.

SYNOPSIS

#include <algorithm>

template <class BidirectionalIterator, class OutputIterator> OutputIterator reverse_copy (BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);

DESCRIPTION

The reverse_copy algorithm copies the range [first, last) to the range [result, result + (last - first)) such that for any non-negative integer i < (last - first), the following assignment takes place:

*(result + (last - first) -i) = *(first + i)

reverse_copy returns result + (last - first). The ranges [first, last) and [result, result + (last - first)) must not overlap.

COMPLEXITY

reverse_copy performs exactly (last - first) assignments.

EXAMPLE

// // reverse.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main () { // // Initialize a vector with an array of integers. // int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; vector<int> v(arr+0, arr+10); // // Print out elements in original (sorted) order. // cout << "Elements before reverse: " << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl; // // Reverse the ordering. // reverse(v.begin(), v.end()); // // Print out the reversed elements. // cout << "Elements after reverse: " << endl << " "; copy(v.begin(), v.end(), ostream_iterator<int,char>(cout," ")); cout << endl << endl;

cout << "A reverse_copy to cout: " << endl << " "; reverse_copy(v.begin(), v.end(), ostream_iterator<int,char>(cout, " ")); cout << endl;

return 0; }

Output : Elements before reverse: 1 2 3 4 5 6 7 8 9 10 Elements after reverse: 10 9 8 7 6 5 4 3 2 1 A reverse_copy to cout: 1 2 3 4 5 6 7 8 9 10

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

reverse

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


rotate

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

rotate, rotate_copy - Left rotates the order of items in a collection, placing the first item at the end, second item first, etc., until the item pointed to by a specified iterator is the first item in the collection.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator> void rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last);

template <class ForwardIterator, class OutputIterator> OutputIterator rotate_copy (ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);

DESCRIPTION

The rotate algorithm takes three iterator arguments, first, which defines the start of a sequence, last, which defines the end of the sequence, and middle which defines a point within the sequence. rotate "swaps" the segment that contains elements from first through middle-1 with the segment that contains the elements from middle through last. After rotate has been applied, the element that was in position middle, is in position first, and the other elements in that segment are in the same order relative to each other. Similarly, the element that was in position first is now in position last-middle +1. An example will illustrate how rotate works:

Say that we have the sequence:

2 4 6 8 1 3 5

If we call rotate with middle = 5, the two segments are

2 4 6 8 and 1 3 5

After we apply rotate, the new sequence will be:

1 3 5 2 4 6 8

Note that the element that was in the fifth position is now in the first position, and the element that was in the first position is in position 4 (last - first + 1, or 8 - 5 +1 =4).

The formal description of this algorithms is: for each non-negative integer i < (last - first), rotate places the element from the position first + i into position first + (i + (last - middle)) % (last - first). [first, middle) and [middle, last) are valid ranges.

rotate_copy rotates the elements as described above, but instead of swapping elements within the same sequence, it copies the result of the rotation to a container specified by result. rotate_copy copies the range [first, last) to the range [result, result + (last - first)) such that for each non-negative integer i < (last - first) the following assignment takes place:

*(result + (i + (last - middle)) % (last -first)) = *(first + i).

The ranges [first, last) and [result, result, + (last - first)) may not overlap.

COMPLEXITY

For rotate at most last - first swaps are performed.

For rotate_copy last - first assignments are performed.

EXAMPLE

// // rotate // #include <algorithm> #include <vector> #include <iostream.h>

int main() { //Initialize a vector with an array of ints int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10);

//Print out elements in original (sorted) order cout << "Elements before rotate: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Rotate the elements rotate(v.begin(), v.begin()+4, v.end());

//Print out the rotated elements cout << "Elements after rotate: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : Elements before rotate: 1 2 3 4 5 6 7 8 9 10 Elements after rotate: 5 6 7 8 9 10 1 2 3 4

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


rotate_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

rotate, rotate_copy - Left rotates the order of items in a collection, placing the first item at the end, second item first, etc., until the item pointed to by a specified iterator is the first item in the collection.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator> void rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last);

template <class ForwardIterator, class OutputIterator> OutputIterator rotate_copy (ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);

DESCRIPTION

The rotate algorithm takes three iterator arguments, first, which defines the start of a sequence, last, which defines the end of the sequence, and middle which defines a point within the sequence. rotate "swaps" the segment that contains elements from first through middle-1 with the segment that contains the elements from middle through last. After rotate has been applied, the element that was in position middle, is in position first, and the other elements in that segment are in the same order relative to each other. Similarly, the element that was in position first is now in position last-middle +1. An example will illustrate how rotate works:

Say that we have the sequence:

2 4 6 8 1 3 5

If we call rotate with middle = 5, the two segments are

2 4 6 8 and 1 3 5

After we apply rotate, the new sequence will be:

1 3 5 2 4 6 8

Note that the element that was in the fifth position is now in the first position, and the element that was in the first position is in position 4 (last - first + 1, or 8 - 5 +1 =4).

The formal description of this algorithms is: for each non-negative integer i < (last - first), rotate places the element from the position first + i into position first + (i + (last - middle)) % (last - first). [first, middle) and [middle, last) are valid ranges.

rotate_copy rotates the elements as described above, but instead of swapping elements within the same sequence, it copies the result of the rotation to a container specified by result. rotate_copy copies the range [first, last) to the range [result, result + (last - first)) such that for each non-negative integer i < (last - first) the following assignment takes place:

*(result + (i + (last - middle)) % (last -first)) = *(first + i).

The ranges [first, last) and [result, result, + (last - first)) may not overlap.

COMPLEXITY

For rotate at most last - first swaps are performed.

For rotate_copy last - first assignments are performed.

EXAMPLE

// // rotate // #include <algorithm> #include <vector> #include <iostream.h>

int main() { //Initialize a vector with an array of ints int arr[10] = {1,2,3,4,5,6,7,8,9,10}; vector<int> v(arr, arr+10);

//Print out elements in original (sorted) order cout << "Elements before rotate: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Rotate the elements rotate(v.begin(), v.begin()+4, v.end());

//Print out the rotated elements cout << "Elements after rotate: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); cout << endl;

return 0; }

Output : Elements before rotate: 1 2 3 4 5 6 7 8 9 10 Elements after rotate: 5 6 7 8 9 10 1 2 3 4

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


search

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

search, search_n - Finds a sub-sequence within a sequence of values that is element-wise equal to the values in an indicated range.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator1, class ForwardIterator2> ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate binary_pred);

template <class ForwardIterator, class Size, class T> ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& value);

template <class ForwardIterator, class Size, class T, class BinaryPredicate> ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred)

DESCRIPTION

The search and search_n are used for searching for a sub-sequence within a sequence. The search algorithm searches for a sub-sequence [first2, last2) within a sequence [first1, last1), and returns the beginning location of the sub-sequence. If it does not find the sub-sequence, search returns last1. The first version of search uses the equality (==) operator as a default, and the second version allows you to specify a binary predicate to perform the comparison.

The search_n algorithm searches for the sub-sequence composed of count occurrences of value within a sequence [first, last), and returns first if this sub-sequence is found. If it does not find the sub-sequence, search_n returns last. The first version of search_n uses the equality (==) operator as a default, and the second version allows you to specify a binary predicate to perform the comparison.

COMPLEXITY

search performs at most (last1 - first1)*(last2-first2) applications of the corresponding predicate.

search_n performs at most (last - first) applications of the corresponding predicate.

EXAMPLE

// // search.cpp // #include <algorithm> #include <list> #include <iostream.h>

int main() { // Initialize a list sequence and // sub-sequence with characters char seq[40] = "Here's a string with a substring in it"; char subseq[10] = "substring"; list<char> sequence(seq, seq+39); list<char> subseqnc(subseq, subseq+9);

//Print out the original sequence cout << endl << "The sub-sequence, " << subseq << ", was found at the "; cout << endl << "location identified by a '*'" << endl << " ";

// Create an iterator to identify the location of // sub-sequence within sequence list<char>::iterator place;

//Do search place = search(sequence.begin(), sequence.end(), subseqnc.begin(), subseqnc.end());

//Identify result by marking first character with a '*' *place = '*';

//Output sequence to display result for(list<char>::iterator i = sequence.begin(); i != sequence.end(); i++) cout << *i; cout << endl;

return 0; }

Output : The sub-sequence, substring, was found at the location identified by a '*' Here's a string with a *substring in it

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

list<char, allocator<char> >

instead of :

list<char>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


search_n

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

search, search_n - Finds a sub-sequence within a sequence of values that is element-wise equal to the values in an indicated range.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator1, class ForwardIterator2> ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate binary_pred);

template <class ForwardIterator, class Size, class T> ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& value);

template <class ForwardIterator, class Size, class T, class BinaryPredicate> ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred)

DESCRIPTION

The search and search_n are used for searching for a sub-sequence within a sequence. The search algorithm searches for a sub-sequence [first2, last2) within a sequence [first1, last1), and returns the beginning location of the sub-sequence. If it does not find the sub-sequence, search returns last1. The first version of search uses the equality (==) operator as a default, and the second version allows you to specify a binary predicate to perform the comparison.

The search_n algorithm searches for the sub-sequence composed of count occurrences of value within a sequence [first, last), and returns first if this sub-sequence is found. If it does not find the sub-sequence, search_n returns last. The first version of search_n uses the equality (==) operator as a default, and the second version allows you to specify a binary predicate to perform the comparison.

COMPLEXITY

search performs at most (last1 - first1)*(last2-first2) applications of the corresponding predicate.

search_n performs at most (last - first) applications of the corresponding predicate.

EXAMPLE

// // search.cpp // #include <algorithm> #include <list> #include <iostream.h>

int main() { // Initialize a list sequence and // sub-sequence with characters char seq[40] = "Here's a string with a substring in it"; char subseq[10] = "substring"; list<char> sequence(seq, seq+39); list<char> subseqnc(subseq, subseq+9);

//Print out the original sequence cout << endl << "The sub-sequence, " << subseq << ", was found at the "; cout << endl << "location identified by a '*'" << endl << " ";

// Create an iterator to identify the location of // sub-sequence within sequence list<char>::iterator place;

//Do search place = search(sequence.begin(), sequence.end(), subseqnc.begin(), subseqnc.end());

//Identify result by marking first character with a '*' *place = '*';

//Output sequence to display result for(list<char>::iterator i = sequence.begin(); i != sequence.end(); i++) cout << *i; cout << endl;

return 0; }

Output : The sub-sequence, substring, was found at the location identified by a '*' Here's a string with a *substring in it

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

list<char, allocator<char> >

instead of :

list<char>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


set_difference

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

set_difference - Basic set operation for sorted sequences.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

DESCRIPTION

The set_difference algorithm constructs a sorted difference that includes copies of the elements that are present in the range [first1, last1) but are not present in the range [first2, last2). It returns the end of the constructed range.

As an example, assume we have the following two sets:

1 2 3 4 5

and

3 4 5 6 7

The result of applying set_difference is the set:

1 2

The result of set_difference is undefined if the result range overlaps with either of the original ranges.

set_difference assumes that the ranges are sorted using the default comparison operator less than (<), unless an alternative comparison operator (comp) is provided.

Use the set_symetric_difference algorithm to return a result that contains all elements that are not in common between the two sets.

COMPLEXITY

At most ((last1 - first1) + (last2 - first2)) * 2 -1 comparisons are performed.

EXAMPLE

// // set_diff.cpp // #include <algorithm> #include <set> #include <iostream.h> int main() { //Initialize some sets int a1[10] = {1,2,3,4,5,6,7,8,9,10}; int a2[6] = {2,4,6,8,10,12}; set<int, less<int> > all(a1, a1+10), even(a2, a2+6), odd; //Create an insert_iterator for odd insert_iterator<set<int, less<int> > > odd_ins(odd, odd.begin());

//Demonstrate set_difference cout << "The result of:" << endl << "{"; copy(all.begin(),all.end(), ostream_iterator<int,char>(cout," ")); cout << "} - {"; copy(even.begin(),even.end(), ostream_iterator<int,char>(cout," ")); cout << "} =" << endl << "{"; set_difference(all.begin(), all.end(), even.begin(), even.end(), odd_ins); copy(odd.begin(),odd.end(), ostream_iterator<int,char>(cout," ")); cout << "}" << endl << endl; return 0; } Output : The result of: {1 2 3 4 5 6 7 8 9 10 } - {2 4 6 8 10 12 } = {1 3 5 7 9 }

WARNING

If your compiler does not support default template parameters, then you need to always supply the Compare template argument and the Allocator template argument. For instance, you will need to write :

set<int, less<int> allocator<int> >

instead of :

set<int>

SEE ALSO

includes, set, set_union, set_intersection, set_symmetric_difference

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


set_intersection

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

set_intersection - Basic set operation for sorted sequences.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator last2, OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

DESCRIPTION

The set_intersection algorithm constructs a sorted intersection of elements from the two ranges. It returns the end of the constructed range. When it finds an element present in both ranges, set_intersection always copies the element from the first range into result. This means that the result of set_intersection is guaranteed to be stable. The result of set_intersection is undefined if the result range overlaps with either of the original ranges.

set_intersection assumes that the ranges are sorted using the default comparison operator less than (<), unless an alternative comparison operator (comp) is provided.

COMPLEXITY

At most ((last1 - first1) + (last2 - first2)) * 2 -1 comparisons are per- formed.

EXAMPLE

// // set_intr.cpp // #include <algorithm> #include <set> #include <iostream.h> int main() {

//Initialize some sets int a1[10] = {1,3,5,7,9,11}; int a3[4] = {3,5,7,8}; set<int, less<int> > odd(a1, a1+6), result, small(a3,a3+4);

//Create an insert_iterator for result insert_iterator<set<int, less<int> > > res_ins(result, result.begin());

//Demonstrate set_intersection cout << "The result of:" << endl << "{"; copy(small.begin(),small.end(), ostream_iterator<int,char>(cout," ")); cout << "} intersection {"; copy(odd.begin(),odd.end(), ostream_iterator<int,char>(cout," ")); cout << "} =" << endl << "{"; set_intersection(small.begin(), small.end(), odd.begin(), odd.end(), res_ins); copy(result.begin(),result.end(), ostream_iterator<int,char>(cout," ")); cout << "}" << endl << endl;

return 0; }

Output : The result of: {3 5 7 8 } intersection {1 3 5 7 9 11 } = {3 5 7 }

WARNING

If your compiler does not support default template parameters, then you need to always supply the Compare template argument and the Allocator template argument. For instance, you will need to write :

set<int, less<int> allocator<int> >

instead of :

set<int>

SEE ALSO

includes, set, set_union, set_difference, set_symmetric_difference

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


set_symmetric_difference

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

set_symmetric_difference - Basic set operation for sorted sequences.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

DESCRIPTION

set_symmetric_difference constructs a sorted symmetric difference of the elements from the two ranges. This means that the constructed range includes copies of the elements that are present in the range [first1, last1) but not present in the range [first2, last2)and copies of the elements that are present in the range [first2, last2) but not in the range [first1, last1). It returns the end of the constructed range.

For example, suppose we have two sets:

1 2 3 4 5

and

3 4 5 6 7

The set_symmetric_difference of these two sets is:

1 2 6 7

The result of set_symmetric_difference is undefined if the result range overlaps with either of the original ranges.

set_symmetric_difference assumes that the ranges are sorted using the default comparison operator less than (<), unless an alternative comparison operator (comp) is provided.

Use the set_symmetric_difference algorithm to return a result that includes elements that are present in the first set and not in the second.

COMPLEXITY

At most ((last1 - first1) + (last2 - first2)) * 2 -1 comparisons are performed.

EXAMPLE

// // set_s_di.cpp // #include<algorithm> #include<set> #include <istream.h>

int main() {

//Initialize some sets int a1[] = {1,3,5,7,9,11}; int a3[] = {3,5,7,8}; set<int, less<int> > odd(a1,a1+6), result, small(a3,a3+4);

//Create an insert_iterator for result insert_iterator<set<int, less<int> > > res_ins(result, result.begin());

//Demonstrate set_symmetric_difference cout << "The symmetric difference of:" << endl << "{"; copy(small.begin(),small.end(), ostream_iterator<int,char>(cout," ")); cout << "} with {"; copy(odd.begin(),odd.end(), ostream_iterator<int,char>(cout," ")); cout << "} =" << endl << "{"; set_symmetric_difference(small.begin(), small.end(), odd.begin(), odd.end(), res_ins); copy(result.begin(),result.end(), ostream_iterator<int,char>(cout," ")); cout << "}" << endl << endl;

return 0; }

Output : The symmetric difference of: {3 5 7 8 } with {1 3 5 7 9 11 } = {1 8 9 11 }

WARNING

If your compiler does not support default template parameters, then you need to always supply the Compare template argument and the Allocator template argument. For instance, you will need to write :

set<int, less<int>, allocator<int> >

instead of :

set<int>

SEE ALSO

includes, set, set_union, set_intersection, set_difference

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


set_union

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

set_union - Basic set operation for sorted sequences.

SYNOPSIS

#include <algorithm>

template <class InputIterator1, class InputIterator2, class OutputIterator> OutputIterator set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);

template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare> OutputIterator set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

DESCRIPTION

The set_union algorithm constructs a sorted union of the elements from the two ranges. It returns the end of the constructed range. set_union is stable, that is, if an element is present in both ranges, the one from the first range is copied. The result of set_union is undefined if the result range overlaps with either of the original ranges. Note that set_union does not merge the two sorted sequences. If an element is present in both sequences, only the element from the first sequence is copied to result. (Use the merge algorithm to create an ordered merge of two sorted sequences that contains all the elements from both sequences.)

set_union assumes that the sequences are sorted using the default comparison operator less than (<), unless an alternative comparison operator (comp) is provided.

COMPLEXITY

At most ((last1 - first1) + (last2 - first2)) * 2 -1 comparisons are performed.

EXAMPLE

// // set_unin.cpp // #include <algorithm> #include <set> #include <iostream.h>

int main() {

//Initialize some sets int a2[6] = {2,4,6,8,10,12}; int a3[4] = {3,5,7,8}; set<int, less<int> > even(a2, a2+6), result, small(a3,a3+4);

//Create an insert_iterator for result insert_iterator<set<int, less<int> > > res_ins(result, result.begin());

//Demonstrate set_union cout << "The result of:" << endl << "{"; copy(small.begin(),small.end(), ostream_iterator<int,char>(cout," ")); cout << "} union {"; copy(even.begin(),even.end(), ostream_iterator<int,char>(cout," ")); cout << "} =" << endl << "{"; set_union(small.begin(), small.end(), even.begin(), even.end(), res_ins); copy(result.begin(),result.end(), ostream_iterator<int,char>(cout," ")); cout << "}" << endl << endl;

return 0; }

Output : The result of: {3 5 7 8 } union {2 4 6 8 10 12 } = {2 3 4 5 6 7 8 10 12 }

WARNING

If your compiler does not support default template parameters, then you need to always supply the Compare template argument and the Allocator template argument. For instance, you will need to write :

set<int, less<int>, allocator<int> >

instead of :

set<int>

SEE ALSO

includes, set, set_intersection, set_difference, set_symmetric_difference

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


sort

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

sort - Templated algorithm for sorting collections of entities.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void sort (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

DESCRIPTION

The sort algorithm sorts the elements in the range [first, last) using either the less than (<) operator or the comparison operator comp. If the worst case behavior is important stable_sort or partial_sort should be used.

COMPLEXITY

sort performs approximately NlogN, where N equals last - first, comparis- ons on the average.

EXAMPLE

// // sort.cpp // #include <vector> #include <algorithm> #include <functional> #include <iostream.h>

struct associate { int num; char chr;

associate(int n, char c) : num(n), chr(c){}; associate() : num(0), chr(' '){}; };

bool operator<(const associate &x, const associate &y) { return x.num < y.num; }

ostream& operator<<(ostream &s, const associate &x) { return s << "<" << x.num << ";" << x.chr << ">"; }

int main () { vector<associate>::iterator i, j, k;

associate arr[20] = {associate(-4, ' '), associate(16, ' '), associate(17, ' '), associate(-3, 's'), associate(14, ' '), associate(-6, ' '), associate(-1, ' '), associate(-3, 't'), associate(23, ' '), associate(-3, 'a'), associate(-2, ' '), associate(-7, ' '), associate(-3, 'b'), associate(-8, ' '), associate(11, ' '), associate(-3, 'l'), associate(15, ' '), associate(-5, ' '), associate(-3, 'e'), associate(15, ' ')};

// Set up vectors vector<associate> v(arr, arr+20), v1((size_t)20), v2((size_t)20);

// Copy original vector to vectors #1 and #2 copy(v.begin(), v.end(), v1.begin()); copy(v.begin(), v.end(), v2.begin());

// Sort vector #1 sort(v1.begin(), v1.end());

// Stable sort vector #2 stable_sort(v2.begin(), v2.end());

// Display the results cout << "Original sort stable_sort" << endl; for(i = v.begin(), j = v1.begin(), k = v2.begin(); i != v.end(); i++, j++, k++) cout << *i << " " << *j << " " << *k << endl;

return 0; }

Output : Original sort stable_sort <-4; > <-8; > <-8; > <16; > <-7; > <-7; > <17; > <-6; > <-6; > <-3;s> <-5; > <-5; > <14; > <-4; > <-4; > <-6; > <-3;e> <-3;s> <-1; > <-3;s> <-3;t> <-3;t> <-3;l> <-3;a> <23; > <-3;t> <-3;b> <-3;a> <-3;b> <-3;l> <-2; > <-3;a> <-3;e> <-7; > <-2; > <-2; > <-3;b> <-1; > <-1; > <-8; > <11; > <11; > <11; > <14; > <14; > <-3;l> <15; > <15; > <15; > <15; > <15; > <-5; > <16; > <16; > <-3;e> <17; > <17; > <15; > <23; > <23; >

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

stable_sort, partial_sort, partial_sort_copy

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


sort_heap

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

sort_heap - Converts a heap into a sorted collection.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void sort_heap(RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

DESCRIPTION

A heap is a particular organization of elements in a range between two random access iterators [a, b). Its two key properties are:

1. *a is the largest element in the range.

2. *a may be removed by pop_heap(), or a new element added by push_heap(), in O(logN) time.

These properties make heaps useful as priority queues.

The sort_heap algorithm converts a heap into a sorted collection over the range [first, last) using either the default operator (<) or the comparison function supplied with the algorithm. Note that sort_heap is not stable, i.e., the elements may not be in the same relative order after sort_heap is applied.

COMPLEXITY

sort_heap performs at most NlogN comparisons where N is equal to last - first.

EXAMPLE

// // heap_ops.cpp // #include <algorithm> #include <vector> #include <iostream.h>

int main(void) { int d1[4] = {1,2,3,4}; int d2[4] = {1,3,2,4};

// Set up two vectors vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4);

// Make heaps make_heap(v1.begin(),v1.end()); make_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z) // Note that x, y and z represent the remaining // values in the container (other than 4). // The definition of the heap and heap operations // does not require any particular ordering // of these values.

// Copy both vectors to cout ostream_iterator<int,char> out(cout," "); copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now let's pop pop_heap(v1.begin(),v1.end()); pop_heap(v2.begin(),v2.end(),less<int>()); // v1 = (3,x,y,4) and v2 = (3,x,y,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// And push push_heap(v1.begin(),v1.end()); push_heap(v2.begin(),v2.end(),less<int>()); // v1 = (4,x,y,z) and v2 = (4,x,y,z)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

// Now sort those heaps sort_heap(v1.begin(),v1.end()); sort_heap(v2.begin(),v2.end(),less<int>()); // v1 = v2 = (1,2,3,4)

// Copy both vectors to cout copy(v1.begin(),v1.end(),out); cout << endl; copy(v2.begin(),v2.end(),out); cout << endl;

return 0; }

Output : 4 2 3 1 4 3 2 1 3 2 1 4 3 1 2 4 4 3 1 2 4 3 2 1 1 2 3 4 1 2 3 4

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

make_heap, pop_heap, push_heap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


stable_partition

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

stable_partition - Places all of the entities that satisfy the given predicate before all of the entities that do not, while maintaining the relative order of elements in each group.

SYNOPSIS

#include <algorithm>

template <class BidirectionalIterator, class Predicate> BidirectionalIterator stable_partition (BidirectionalIterator first, BidirectionalIterator last, Predicate pred);

DESCRIPTION

The stable_partition algorithm places all the elements in the range [first, last) that satisfy pred before all the elements that do not satisfy it. It returns an iterator i that is one past the end of the group of elements that satisfy pred. In other words stable_partition returns i such that for any iterator j in the range [first, i), pred(*j) == true, and for any iterator k in the range [i, last), pred(*j) == false. The relative order of the elements in both groups is preserved.

The partition algorithm can be used when it is not necessary to maintain the relative order of elements within the groups that do and do not match the predicate.

COMPLEXITY

The stable_partition algorithm does at most (last - first) * log(last - first) swaps. and applies the predicate exactly last - first times.

EXAMPLE

// // prtition.cpp // #include <functional> #include <deque> #include <algorithm> #include <iostream.h>

//Create a new predicate from unary_function template<class Arg> class is_even : public unary_function<Arg, bool> { public: bool operator()(const Arg& arg1) { return (arg1 % 2) == 0; } };

int main() { //Initialize a deque with an array of ints int init[10] = {1,2,3,4,5,6,7,8,9,10}; deque<int> d(init, init+10);

//Print out the original values cout << "Unpartitioned values: " << endl << " "; copy(d.begin(),d.end(),ostream_iterator<int,char>(cout," ")); cout << endl << endl;

//Partition the deque according to even/oddness stable_partition(d.begin(), d.end(), is_even<int>());

//Output result of partition cout << "Partitioned values: " << endl << " "; copy(d.begin(),d.end(),ostream_iterator<int,char>(cout," "));

return 0; }

Output : Unpartitioned values: 1 2 3 4 5 6 7 8 9 10 Partitioned values: 10 2 8 4 6 5 7 3 9 1 Stable partitioned values: 2 4 6 8 10 1 3 5 7 9

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

deque<int, allocator<int> >

instead of :

deque<int>

SEE ALSO

partition

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


stable_sort

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

stable_sort - Templated algorithm for sorting collections of entities.

SYNOPSIS

#include <algorithm>

template <class RandomAccessIterator> void stable_sort (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare> void stable_sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

DESCRIPTION

The stable_sort algorithm sorts the elements in the range [first, last). The first version of the algorithm uses less than (<) as the comparison operator for the sort. The second version uses the comparison function comp.

The stable_sort algorithm is considered stable because the relative order of the equal elements is preserved.

COMPLEXITY

stable_sort does at most N(logN) **2, where N equals last -first, comparisons; if enough extra memory is available, it is NlogN.

EXAMPLE

// // sort.cpp // #include <vector> #include <algorithm> #include <functional> #include <iostream.h>

struct associate { int num; char chr;

associate(int n, char c) : num(n), chr(c){}; associate() : num(0), chr(' '){}; };

bool operator<(const associate &x, const associate &y) { return x.num < y.num; }

ostream& operator<<(ostream &s, const associate &x) { return s << "<" << x.num << ";" << x.chr << ">"; }

int main () { vector<associate>::iterator i, j, k;

associate arr[20] = {associate(-4, ' '), associate(16, ' '), associate(17, ' '), associate(-3, 's'), associate(14, ' '), associate(-6, ' '), associate(-1, ' '), associate(-3, 't'), associate(23, ' '), associate(-3, 'a'), associate(-2, ' '), associate(-7, ' '), associate(-3, 'b'), associate(-8, ' '), associate(11, ' '), associate(-3, 'l'), associate(15, ' '), associate(-5, ' '), associate(-3, 'e'), associate(15, ' ')};

// Set up vectors vector<associate> v(arr, arr+20), v1((size_t)20), v2((size_t)20);

// Copy original vector to vectors #1 and #2 copy(v.begin(), v.end(), v1.begin()); copy(v.begin(), v.end(), v2.begin());

// Sort vector #1 sort(v1.begin(), v1.end());

// Stable sort vector #2 stable_sort(v2.begin(), v2.end());

// Display the results cout << "Original sort stable_sort" << endl; for(i = v.begin(), j = v1.begin(), k = v2.begin(); i != v.end(); i++, j++, k++) cout << *i << " " << *j << " " << *k << endl;

return 0; }

Output : Original sort stable_sort <-4; > <-8; > <-8; > <16; > <-7; > <-7; > <17; > <-6; > <-6; > <-3;s> <-5; > <-5; > <14; > <-4; > <-4; > <-6; > <-3;e> <-3;s> <-1; > <-3;s> <-3;t> <-3;t> <-3;l> <-3;a> <23; > <-3;t> <-3;b> <-3;a> <-3;b> <-3;l> <-2; > <-3;a> <-3;e> <-7; > <-2; > <-2; > <-3;b> <-1; > <-1; > <-8; > <11; > <11; > <11; > <14; > <14; > <-3;l> <15; > <15; > <15; > <15; > <15; > <-5; > <16; > <16; > <-3;e> <17; > <17; > <15; > <23; > <23; >

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator>

instead of :

vector<int>

SEE ALSO

sort, partial_sort, partial_sort_copy

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


swap

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

swap - Exchange values.

SYNOPSIS

#include <algorithm>

template <class T> void swap (T& a, T& b);

DESCRIPTION

The swap algorithm exchanges the values of a and b. The effect is:

T tmp = a a = b b = tmp

SEE ALSO

iter_swap, swap_ranges

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


swap_ranges

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

swap_ranges - Exchange a range of values in one location with those in another

SYNOPSIS

#include <algorithm>

template <class ForwardIterator1, class ForwardIterator2> ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);

DESCRIPTION

The swap_ranges algorithm exchanges corresponding values in two ranges, in the following manner:

For each non-negative integer n < (last - first) the function exchanges *(first1 + n) with *(first2 + n)). After completing all exchanges, swap_ranges returns an iterator that points to the end of the second container, i.e., first2 + (last1 -first1). The result of swap_ranges is undefined if the two ranges [first, last) and [first2, first2 + (last1 - first1)) overlap.

EXAMPLE

// // swap.cpp // #include <vector> #include <algorithm>

int main() { int d1[] = {6, 7, 8, 9, 10, 1, 2, 3, 4, 5};

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

// Output original vector cout << "For the vector: "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," "));

// Swap the first five elements with the last five elements swap_ranges(v.begin(),v.begin()+5, v.begin()+5);

// Output result cout << endl << endl << "Swapping the first five elements " << "with the last five gives: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," "));

return 0; }

Output : For the vector: 6 7 8 9 10 1 2 3 4 5 Swapping the first five elements with the last five gives: 1 2 3 4 5 6 7 8 9 10 Swapping the first and last elements gives: 10 2 3 4 5 6 7 8 9 1

WARNING

If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

iter_swap, swap

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


transform

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

transform - Applies an operation to a range of values in a collection and stores the result.

SYNOPSIS

#include <algorithm>

template <class InputIterator, class OutputIterator, class UnaryOperation> OutputIterator transform (InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);

template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> OutputIterator transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op);

DESCRIPTION

The transform algorithm has two forms. The first form applies unary operation op to each element of the range [first, last), and sends the result to the output iterator result. For example, this version of transform, could be used to square each element in a vector. If the output iterator (result) is the same as the input iterator used to traverse the range, transform, performs its transformation in place.

The second form of transform applies a binary operation, binary_op, to corresponding elements in the range [first1, last1) and the range that begins at first2, and sends the result to result. For example, transform can be used to add corresponding elements in two sequences, and store the set of sums in a third. The algorithm assumes, but does not check, that the second sequence has at least as many elements as the first sequence. Note that the output iterator result can be a third sequence, or either of the two input sequences.

Formally, transform assigns through every iterator i in the range [result, result + (last1 - first1)) a new corresponding value equal to:

op(*(first1 + (i - result))

or

binary_op(*(first1 + (i - result), *(first2 + (i - result)))

transform returns result + (last1 - first1). op and binary_op must not have any side effects. result may be equal to first in case of unary transform, or to first1 or first2 in case of binary transform.

COMPLEXITY

Exactly last1 - first1 applications of op or binary_op are performed.

EXAMPLE

// // trnsform.cpp // #include <functional> #include <deque> #include <algorithm> #include <iostream.h> #include <iomanip.h> int main() { //Initialize a deque with an array of ints int arr1[5] = {99, 264, 126, 330, 132}; int arr2[5] = {280, 105, 220, 84, 210}; deque<int> d1(arr1, arr1+5), d2(arr2, arr2+5); //Print the original values cout << "The following pairs of numbers: " << endl << " "; deque<int>::iterator i1; for(i1 = d1.begin(); i1 != d1.end(); i1++) cout << setw(6) << *i1 << " "; cout << endl << " "; for(i1 = d2.begin(); i1 != d2.end(); i1++) cout << setw(6) << *i1 << " "; // Transform the numbers in the deque to their // factorials and store in the vector transform(d1.begin(), d1.end(), d2.begin(), d1.begin(), multiplies<int>()); //Display the results cout << endl << endl; cout << "Have the products: " << endl << " "; for(i1 = d1.begin(); i1 != d1.end(); i1++) cout << setw(6) << *i1 << " "; return 0; }

Output : The following pairs of numbers: 99 264 126 330 132 280 105 220 84 210 Have the products: 27720 27720 27720 27720 27720

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

deque<int, allocator<int> >

instead of:

deque<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


uninitialized_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

uninitialized_copy - An algorithms that uses construct to copy values from one range to another location.

SYNOPSIS

#include <memory>

template <class InputIterator, class ForwardIterator> ForwardIterator uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator result);

DESCRIPTION

uninitialized_copy copies all items in the range [first, last) into the location beginning at result using the construct algorithm.

SEE ALSO

construct

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


uninitialized_fill

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

uninitialized_fill - Algorithm that uses the construct algorithm for setting values in a collection.

SYNOPSIS

#include <memory>

template <class ForwardIterator, class T> void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);

DESCRIPTION

uninitialized_fill initializes all of the items in the range [first, last) to the value x, using the construct algorithm.

SEE ALSO

construct, uninitialized_fill_n

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


uninitialized_fill_n

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

uninitialized_fill_n - Algorithm that uses the construct algorithm for setting values in a collection.

SYNOPSIS

#include <memory>

template <class ForwardIterator, class Size, class T> void uninitialized_fill_n (ForwardIterator first, Size n, const T& x);

DESCRIPTION

unitialized_fill_n starts at the iterator first and initializes the first n items to the value x, using the construct algorithm.

SEE ALSO

construct, uninitialized_fill

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


unique

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

unique, unique_copy - Removes consecutive duplicates from a range of values and places the resulting unique values into the result.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator> ForwardIterator unique (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate> ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

template <class InputIterator, class OutputIterator> OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result);

template <class InputIterator, class OutputIterator, class BinaryPredicate> OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate binary_pred);

DESCRIPTION

The unique algorithm moves through a sequence and eliminates all but the first element from every consecutive group of equal elements. There are two versions of the algorithm, one tests for equality, and the other tests whether a binary predicate applied to adjacent elements is true. An element is unique if it does not meet the corresponding condition listed here:

*i == *(i - 1)

or

binary_pred(*i, *(i - 1)) == true.

If an element is unique, it is copied to the front of the sequence, overwriting the existing elements. Once all unique elements have been identified. The remainder of the sequence is left unchanged, and unique returns the end of the resulting range.

The unique_copy algorithm copies the first element from every consecutive group of equal elements, to an OutputIterator. The unique_copy algorithm, also has two versions--one that tests for equality and a second that tests adjacent elements against a binary predicate.

unique_copy returns the end of the resulting range.

COMPLEXITY

Exactly (last - first) - 1 applications of the corresponding predicate are performed.

EXAMPLE

// // unique.cpp // #include <algorithm> #include <vector> #include <iostream.h> int main() { //Initialize two vectors int a1[20] = {4, 5, 5, 9, -1, -1, -1, 3, 7, 5, 5, 5, 6, 7, 7, 7, 4, 2, 1, 1}; vector<int> v(a1, a1+20), result; //Create an insert_iterator for results insert_iterator<vector<int> > ins(result, result.begin()); //Demonstrate includes cout << "The vector: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); //Find the unique elements unique_copy(v.begin(), v.end(), ins); //Display the results cout << endl << endl << "Has the following unique elements:" << endl << " "; copy(result.begin(),result.end(), ostream_iterator<int,char>(cout," ")); return 0; } Output : The vector: 4 5 5 9 -1 -1 -1 3 7 5 5 5 6 7 7 7 4 2 1 1 Has the following unique elements: 4 5 9 -1 3 7 5 6 7 4 2 1

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


unique_copy

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

unique, unique_copy - Removes consecutive duplicates from a range of values and places the resulting unique values into the result.

SYNOPSIS

#include <algorithm>

template <class ForwardIterator> ForwardIterator unique (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate> ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

template <class InputIterator, class OutputIterator> OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result);

template <class InputIterator, class OutputIterator, class BinaryPredicate> OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate binary_pred);

DESCRIPTION

The unique algorithm moves through a sequence and eliminates all but the first element from every consecutive group of equal elements. There are two versions of the algorithm, one tests for equality, and the other tests whether a binary predicate applied to adjacent elements is true. An element is unique if it does not meet the corresponding condition listed here:

*i == *(i - 1)

or

binary_pred(*i, *(i - 1)) == true.

If an element is unique, it is copied to the front of the sequence, overwriting the existing elements. Once all unique elements have been identified. The remainder of the sequence is left unchanged, and unique returns the end of the resulting range.

The unique_copy algorithm copies the first element from every consecutive group of equal elements, to an OutputIterator. The unique_copy algorithm, also has two versions--one that tests for equality and a second that tests adjacent elements against a binary predicate.

unique_copy returns the end of the resulting range.

COMPLEXITY

Exactly (last - first) - 1 applications of the corresponding predicate are performed.

EXAMPLE

// // unique.cpp // #include <algorithm> #include <vector> #include <iostream.h> int main() { //Initialize two vectors int a1[20] = {4, 5, 5, 9, -1, -1, -1, 3, 7, 5, 5, 5, 6, 7, 7, 7, 4, 2, 1, 1}; vector<int> v(a1, a1+20), result; //Create an insert_iterator for results insert_iterator<vector<int> > ins(result, result.begin()); //Demonstrate includes cout << "The vector: " << endl << " "; copy(v.begin(),v.end(),ostream_iterator<int,char>(cout," ")); //Find the unique elements unique_copy(v.begin(), v.end(), ins); //Display the results cout << endl << endl << "Has the following unique elements:" << endl << " "; copy(result.begin(),result.end(), ostream_iterator<int,char>(cout," ")); return 0; } Output : The vector: 4 5 5 9 -1 -1 -1 3 7 5 5 5 6 7 7 7 4 2 1 1 Has the following unique elements: 4 5 9 -1 3 7 5 6 7 4 2 1

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of:

vector<int>

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee


upper_bound

Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.

NAME

upper_bound - Determines the last valid position for a value in a sorted container.

SYNOPSIS

#include <algorithm> template <class ForwardIterator, class T> ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value); template <class ForwardIterator, class T, class Compare> ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

DESCRIPTION

The upper_bound algorithm is part of a set of binary search algorithms. All of these algorithms perform binary searches on ordered containers. Each algorithm has two versions. The first version uses the less than operator (operator<) to perform the comparison, and assumes that the sequence has been sorted using that operator. The second version allows you to include a function object of type Compare, and assumes that Compare is the function used to sort the sequence. The function object must be a binary predicate.

The upper_bound algorithm finds the last position in a container that value can occupy without violating the container's ordering. upper_bound's return value is the iterator for the first element in the container that is greater than value, or, when the comparison operator is used, the first element that does not satisfy the comparison function. Because the algorithm is restricted to using the less than operator or the user-defined function to perform the search, upper_bound returns an iterator i in the range [first, last) such that for any iterator j in the range [first, i) the appropriate version of the following conditions holds:

!(value < *j)

or

comp(value, *j) == false

COMPLEXITY

upper_bound performs at most log(last - first) + 1 comparisons.

EXAMPLE

// // ul_bound.cpp // #include <vector> #include <algorithm> #include <iostream.h>

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

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

// Try lower_bound variants iterator it1 = lower_bound(v1.begin(),v1.end(),3); // it1 = v1.begin() + 4

iterator it2 = lower_bound(v1.begin(),v1.end(),2,less<int>()); // it2 = v1.begin() + 4

// Try upper_bound variants iterator it3 = upper_bound(v1.begin(),v1.end(),3); // it3 = vector + 5

iterator it4 = upper_bound(v1.begin(),v1.end(),2,less<int>()); // it4 = v1.begin() + 5

cout << endl << endl << "The upper and lower bounds of 3: ( " << *it1 << " , " << *it3 << " ]" << endl;

cout << endl << endl << "The upper and lower bounds of 2: ( " << *it2 << " , " << *it4 << " ]" << endl;

return 0; }

Output : The upper and lower bounds of 3: ( 3 , 4 ] The upper and lower bounds of 2: ( 2 , 3 ]

WARNING

If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :

vector<int, allocator<int> >

instead of :

vector<int>

SEE ALSO

lower_bound, equal_range

STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee

Buy Online or Call 1.800.888.0220      privacy statement and legal notices 
STORES CONTACT US SEARCH PRODUCTS SOLUTIONS OPTIONS DEVELOPERS