Where can I look up the definition of size_type for vectors in the C++ STL?

Question

It seems safe to cast the result of my vector's size() function to an unsigned int. How can I tell for sure, though? My documentation isn't clear about how size_type is defined.

Answer 1

Do not assume the type of the container size (or anything else typed inside).

Today?

The best solution for now is to use:

std::vector<T>::size_type

Where T is your type. For example:

std::vector<std::string>::size_type i ;
std::vector<int>::size_type j ;
std::vector<std::vector<double> >::size_type k ;

(Using a typedef could help make this better to read)

The same goes for iterators, and all other types "inside" STL containers.

After C++0x?

When the compiler will be able to find the type of the variable, you'll be able to use the auto keyword. For example:

void doSomething(const std::vector<double> & p_aData)
{
    std::vector<double>::size_type i = p_aData.size() ; // Old/Current way

    auto j = p_aData.size() ;    // New C++0x way, definition
    decltype(p_aData.size()) k;  // New C++0x way, declaration
}

Edit: Question from JF

What if he needs to pass the size of the container to some existing code that uses, say, an unsigned int? – JF

This is a problem common to the use of the STL: You cannot do it without some work.

The first solution is to design the code to always use the STL type. For example:

typedef std::vector<int>::size_type VIntSize ;

VIntSize getIndexOfSomeItem(const std::vector<int> p_aInt)
{
   return /* the found value, or some kind of std::npos */
}

The second is to make the conversion yourself, using either a static_cast, using a function that will assert if the value goes out of bounds of the destination type (sometimes, I see code using "char" because, "you know, the index will never go beyond 256" [I quote from memory]).

I believe this could be a full question in itself.

Answer 2

According to the standard, you cannot be sure. The exact type depends on your machine. You can look at the definition in your compiler's header implementations, though.