remove_copy_if()Copies elements from one range to another, omitting elements for which a predicate function object returns true. unique()Reduces each sequence of two or more equivalent elements in a range to a single element. unique_copy()Copies elements from one range to another, reducing each sequence of two or more equivalent elements to one. reverse()Reverses the elements in a range. reverse_copy()Copies a range in reverse order to a second range. rotate()Treats a range as a circular ordering and rotates the elements left. rotate_copy()Copies one range to another in a rotated order. random_shuffle()Randomly rearranges the elements in a range. partition()Places all the elements that satisfy a predicate function object before all elements that don't. stable_partition()Places all the elements that satisfy a predicate function object before all elements that don't. The relative order of elements in each group is preserved. Now let's go to the prototypes. As you saw earlier, pairs of iterators indicate ranges, with the chosen template parameter name indicating the type of iterator. As usual a range of the form [first, last) goes from first up to, but not including last. Functions passed as arguments are function objects, which can be function pointers or objects for which the () operation is defined. As in Chapter 16, a predicate is a Boolean function with one argument, and a binary predicate is a Boolean function with two arguments. (The functions need not be type bool as long as they return a 0 value for false and a non-zero for true.) Also, as in Chapter 15, a unary function object is one taking a single argument, and a binary function object is one taking two arguments. template<class InputIterator, class OutputIterator> OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result); The copy() function copies the elements in the range [first, last) into the range [result, result + (last - first)). It returns result + (last - first), that is, an iterator pointing one past the last copied-to location. The function requires that result not be in the range [first, last), that is, the target can't overlap the source. This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. template<class BidirectionalIterator1, class BidirectionalIterator2> BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result); The copy_backward() function copies the elements in the range [first, last) into the range [result -(last - first), result). Copying begins with the element at last -1 being copied to location result - 1, and proceeds backwards from there to first. It returns result - (last - first), that is, an iterator pointing one past the last copied-to location. The function requires that result not be in the range [first, last). However, because copying is done backwards, it is possible for the target and source to overlap. template<class T> void swap(T& a, T& b); The swap() function exchanges values stored at two locations specified by references. template<class ForwardIterator1, class ForwardIterator2> ForwardIterator2 swap_ranges( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); The swap_ranges() function exchanges values in the range [first1, last1) with the corresponding values in the range beginning at first2. The two ranges should not overlap. template<class ForwardIterator1, class ForwardIterator2> void iter_swap(ForwardIterator1 a, ForwardIterator2 b); The iter_swap() function exchanges values stored at two locations specified by iterators. template<class InputIterator, class OutputIterator, class UnaryOperation> OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); This version of transform() applies the unary function object op to each element in the range [first, last) and assigns the return value to the corresponding element in the range beginning at result. So *result is set to op(*first), and so on. It returns result + This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. (last - first), that is, the past-the-end value for the target range. template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> OutputIterator transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op); This version of transform() applies the binary function object op to each element in the range [first1, last1) and to each element in the range [first2, last2) and assigns the return value to the corresponding element in the range beginning at result. So *result is set to op(*first1, *first2), and so on. It returns result + (last - first), the past-the-end value for the target range. template<class ForwardIterator, class T> void replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); The replace() function replaces each occurrence of the value old_value in the range [first, last) with the value new_value. template<class ForwardIterator, class Predicate, class T> void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); The replace()_if function replaces each value old in the range [first, last) for which pred(old) is true with the value new_value. template<class InputIterator, class OutputIterator, class T> OutputIterator replace_copy(InputIterator first, InputIterator last, OutputIterator result,const T& old_ value, const T& new_ value); The replace_copy() function copies the elements in the range [first, last) to a range beginning at result, but substituting new_value for each occurrence of old_value. It returns result + (last - first), the past-the-end value for the target range. template<class Iterator, class OutputIterator, class Predicate, class T> This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. OutputIterator replace_copy_if(Iterator first, Iterator last, OutputIterator result, Predicate pred, const T& new_ value); The replace_copy_if() function copies the elements in the range [first, last) to a range beginning at result, but substituting new_value for each value old for which pred(old) is true. It returns result + (last - first), the past-the-end value for the target range. template<class ForwardIterator, class T> void fill(ForwardIterator first, ForwardIterator last, const T& value); The fill() function sets each element in the range [first, last) to value. template<class OutputIterator, class Size, class T> void fill_n(OutputIterator first, Size n, const T& value); The fill_n() function sets each of the first n elements beginning at location first to value. template<class ForwardIterator, class Generator> void generate(ForwardIterator first, ForwardIterator last, Generator gen); The generator() function sets each element in the range [first, last) to gen(), where gen is a generator function object, that is, one that takes no arguments. For example, gen can be a pointer to rand(). template<class OutputIterator, class Size, class Generator> void generate_n(OutputIterator first, Size n, Generator gen); The generator_n() function sets each of the first n elements in the range beginning at first to gen(), where gen is a generator function object, that is, one that takes no arguments. For example, gen can be a pointer to rand(). template<class ForwardIterator, class T> ForwardIterator remove(ForwardIterator first, ForwardIterator last, const T& value); The remove() function removes all occurrences of value from the range [first, last) and returns a past-the-end iterator for the resulting range. The function is stable, This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. meaning the order of the unremoved elements is unaltered. Note Because the various remove() and unique() functions are not member functions, and also because they aren't restricted to STL containers, they can't reset the size of a container. Instead, they return an iterator indicating the new past-the-end location. Typically, the removed items simply are shifted to the end of the container. However, for STL containers you can use the returned iterator and one of the erase() methods to reset end(). template<class ForwardIterator, class Predicate> ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); The remove_if() function removes all occurrences of values val for which pred(val) is true from the range [first, last) and returns a past-the-end iterator for the resulting range. The function is stable, meaning the order of the unremoved elements is unaltered. template<class InputIterator, class OutputIterator, class T> OutputIterator remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); The remove_copy() function copies values from the range [first, last) to the range beginning at result, skipping instances of value as it copies. It returns a past-the-end iterator for the resulting range. The function is stable, meaning the order of the unremoved elements is unaltered. template<class InputIterator, class OutputIterator, class Predicate> OutputIterator remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); The remove_copy_if() function copies values from the range [first, last) to the range beginning at result, but skipping instances of val for which pred(val) is true as it This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. copies. It returns a past-the-end iterator for the resulting range. The function is stable, meaning the order of the unremoved elements is unaltered. template<class ForwardIterator> ForwardIterator unique(ForwardIterator first, ForwardIterator last); template<class ForwardIterator, class BinaryPredicate> ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); The unique() function reduces each sequence of two or more equivalent elements in a range [first, last) to a single element and returns a past-the-end iterator for the new range. The first version uses the == operator for the value type to compare elements. The second version uses the binary predicate function object pred to compare elements. That is, elements pointed to by it1 and it2 match if pred(*it1, *it2) is true. 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 pred); The unique_copy() function copies elements from a range [first, last) to the range beginning at result, reducing each sequence of two or more identical elements to a single element. It returns a past-the-end iterator for the new range. The first version uses the == operator for the value type to compare elements. The second version uses the binary predicate function object pred to compare elements. That is, elements pointed to by it1 and it2 match if pred(*it1, *it2) is true. template<class BidirectionalIterator> void reverse(BidirectionalIterator first, BidirectionalIterator last); The reverse() function reverses the elements in the range [first, last) by invoking swap(first, last - 1), and so on. This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. template<class BidirectionalIterator, class OutputIterator> OutputIterator reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); The reverse copy() function copies the elements in the range [first, last) to the range beginning at result in reverse order. The two ranges should not overlap. template<class ForwardIterator> void rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); The rotate() function performs a left-rotate on the elements in the range [first, last). The element at middle is moved to first, the element at middle + 1 to first + 1, and so on. The elements preceding middle are wrapped around to the end of the container so that the element at first follows that formerly at last - 1. template<class ForwardIterator, class OutputIterator> OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); The rotate_copy() function copies the elements in the range [first, last) to the range beginning at result using the rotated sequence described for rotate(). template<class RandomAccessIterator> void random_shuffle(RandomAccessIterator first, RandomAccessIterator last); This version of the random_shuffle() function shuffles the elements in the range [first, last). The distribution is uniform; that is, each possible permutation of the original order is equally likely. template<class RandomAccessIterator, class RandomNumberGenerator> void random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& random); This version of the random_shuffle() function shuffles the elements in the range [first, last). The function object random determines the distribution. Given n elements, the This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. expression random(n) should return a value in the range [0,n). template<class BidirectionalIterator, class Predicate> BidirectionalIterator partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred); The partition() function places each element whose value val is such that pred(val) is true before all elements that don't meet that test. It returns an iterator to the position following that last position holding a value for which the predicate object function was true. template<class BidirectionalIterator, class Predicate> BidirectionalIterator stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred); The stable_partition() function places each element whose value val is such that pred(val) is true before all elements that don't meet that test. The function preserves the relative ordering within each of the two groups. It returns an iterator to the position following that last position holding a value for which the predicate object function was true. Sorting and Related Operations Table G.11 summarizes the sorting and related operations. Arguments are not shown, and overloaded functions are listed just once. Each function has a version that uses < for ordering elements and a version that uses a comparison function object for ordering elements. A fuller description including the prototypes follows the table. Thus, you can scan the table to get an idea of what a function does, then look up the details if you find the function appealing. This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. Table G.11. Sorting and Related Operations Function Description sort()Sorts a range. stable_sort()Sorts a range, preserving the relative order of equivalent elements. partial_sort() Partially sorts a range, providing the first n elements of a full sort. partial_sort_copy()Copies a partially sorted range to another range. nth_element()Given an iterator into a range, finds the element that would be there if the range were sorted, and places that element there. lower_bound()Given a value, finds the first position in a sorted range before which the value can be inserted while maintaining the ordering. upper_bound()Given a value, finds the last position in a sorted range before which the value can be inserted while maintaining the ordering. equal_range()Given a value, finds the largest subrange of a sorted range such that the value can be inserted before any element in the subrange without violating the ordering. binary_search()Returns true if a sorted range contains a value equivalent to a given value, and false otherwise. merge()Merges two sorted ranges into a third range. inplace_merge()Merges two consecutive sorted ranges in place. includes()Returns true if every element in one set also is found in another set. set_union()Constructs the union of two sets, which is a set containing all elements present in either set. set_intersection()Constructs the intersection of two sets, which is a set containing only those elements found in both sets. set_difference()Constructs the difference of two sets, which is a set containing only those elements found in the first set but not the second. This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks. set_symmetric_difference()Constructs a set consisting of elements found in one set or the other, but not both. make_heapConverts a range to heap. push_heap()Adds an element to a heap. pop_heap()Removes the largest element from a heap. sort_heap()Sorts a heap. min()Returns the lesser of two values. max()Returns the greater of two values. min_element()Finds the first occurrence of the smallest value in a range. max_element()Finds the first occurrence of the largest value in a range. lexicographic_compare()Compares two sequences lexicographically, returning true if the first sequence is lexicographically less than the second, and false otherwise. next_permutation()Generates the next permutation in a sequence. previous_permutation()Generates the preceding permutation in a sequence. The functions in this section determine the order of two elements by using the < operator defined for the elements or by using a comparison object designated by the template type Compare. If comp is an object of type Compare, then comp(a,b) is a generalization of a < b and returns true if a precedes b in the ordering scheme. If a < b is false and b < a also is false, a and b are equivalent. A comparison object must provide at least strict weak ordering. This means the following: The expression comp(a,a) must be false, a generalization of the fact that a value can't be less than itself. (This is the strict part.) If comp(a,b) is true and comp(b,c) is true, then comp(a,c) is true (that is, comparison is a transitive relationship). If a is equivalent to b, and b is equivalent to c, then a is equivalent to c (that is, equivalency is a transitive relationship). If you think of applying < to integers, then equivalency implies equality, but this doesn't have to hold for more general cases. For example, you could define a structure with This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks.