| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
Finally, here are some basic tools that are used with the
other algorithms; you may or may not use them directly yourself.
(Templates in the <utility>
header)
template<class T1, class T2> struct pair;
template<class T1, class T2> pair<T1, T2>
make_pair(const T1&, const T2&);
These were described and used earlier in this chapter. A pair
is simply a way to package two objects (which may be of different types) into a
single object. This is typically used when you need to return more than one
object from a function, but it can also be used to create a container that
holds pair objects or to pass more than one object as a single argument.
You access the elements by saying p.first and p.second, where p
is the pair object. The function equal_range( ), described
in this chapter, returns its result as a pair of iterators, for example.
You can insert( ) a pair directly into a map or multimap;
a pair is the value_type for those containers.
If you want to create a pair on the fly, you
typically use the template function make_pair( ) rather than
explicitly constructing a pair object. make_pair( ) deduces
the types of the arguments it receives, relieving you of the typing as well as
increasing robustness.
(From <iterator>)
difference_type distance(InputIterator first, InputIterator last);
Tells you the number of elements between first and last.
More precisely, it returns an integral value that tells you the number of times
first must be incremented before it is equal to last. No
dereferencing of the iterators occurs during this process.
(From <iterator>)
Moves the iterator i forward by the value of n. (It can also be
moved backward for negative values of n if the iterator is
bidirectional.) This algorithm is aware of the different types of iterators and
will use the most efficient approach. For example, random iterators can be
incremented directly using ordinary arithmetic (i+=n), whereas a
bidirectional iterator must be incremented n times.
(From <iterator>)
back_insert_iterator<Container>
back_inserter(Container& x);
front_insert_iterator<Container>
front_inserter(Container& x);
insert_iterator<Container>
inserter(Container& x, Iterator i);
These functions are used to create iterators for the given
containers that will insert elements into the container, rather than overwrite
the existing elements in the container using operator= (which is the
default behavior). Each type of iterator uses a different operation for
insertion: back_insert_iterator uses push_back( ), front_insert_iterator
uses push_front( ), and insert_iterator uses insert( )
(and thus it can be used with the associative containers, while the other two
can be used with sequence containers). These will be shown in some detail in
the next chapter.
const
LessThanComparable& min(const LessThanComparable& a,
const LessThanComparable& b);
const T& min(const T& a, const T& b,
BinaryPredicate binary_pred);
Returns the lesser of its two arguments, or returns the
first argument if the two are equivalent. The first version performs comparisons
using operator<, and the second passes both arguments to binary_pred
to perform the comparison.
const
LessThanComparable& max(const LessThanComparable& a,
const LessThanComparable& b);
const T& max(const T& a, const T& b,
BinaryPredicate binary_pred);
Exactly like min( ), but returns the greater of
its two arguments.
void swap(Assignable& a, Assignable& b);
void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
Exchanges
the values of a and b using assignment. Note that all container
classes use specialized versions of swap( ) that are typically more
efficient than this general version.
The
iter_swap( ) function swaps the values that its two arguments
reference.
| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
