template OutputIterator transformInputIterator first, InputIterator last, OutputIterator result, UnaryOperation op; This version of transform applies the unary function object op to each
Trang 1remove_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
Trang 2template<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 +
Trang 3(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>
Trang 4OutputIterator 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,
Trang 5meaning 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
Trang 6copies 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
Trang 7template<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
Trang 8expression 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
Trang 9Table G.11 Sorting and Related Operations
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
Trang 10set_symmetric_difference() Constructs a set consisting of elements found in one set
or the other, but not both
push_heap() Adds an element to a heap
pop_heap() Removes the largest element from a heap
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