In article <29ec5925-cef7-46e1-a336-a2dd74d56da0
@v23g2000pro.googlegroups.com>, amrollahi.sa...@gmail.com says...
[ ... ]
There are a lot of typedefs in standard library containers. For
example:
template<class T, class A = allocator<T> >
class vector {
typedef T value_type;
typedef A allocator_type;
typedef typename A::pointer pointer; //=
typedef typename A::const_reference const_reference;
// ...
};
There are similar declarations in other containers like valarray,
list, map, ...
What are they? What are the benfits of such declarations?
They're used primarily by algorithms that manipulate (data in) the
containers. For example, let's consider adding together the elements
in a container. For non-generic code, that's pretty easy:
int sum(int *x, size_t size) {
int sum=0;
for (size_t i=0; i<size; i++)
sum += x[i];
return sum;
}
Now consider generalizing that to sum a collection of objects of any
type instead:
template <class collection>
T sum(collection const &c) {
T sum = T();
for (size_t i=0; i<c.size(); i++)
sum +=c[i];
return sum;
}
Right now, I've used "T" as the type of object, but the question is:
"How do we get T?" In a general sense, that doesn't have an answer.
The collection itself will be have a template parameter that
specifies the type:
std::vector<int> ints;
We're being passed a vector, but what we want is the type over which
the vector has been instantiated. C++ doesn't provide a way to
retrieve that as part of the language, so instead the standard
containers include a typedef to tell you what it is.
Needless to say, that's not the only type we might be interested in
about a container -- so the container has typedef's for other types
that might become interesting as well.
As a sidenote, most algorithms operate on containers via iterators=