Question

Perhaps this question is trivial, but thinking a second time about it I wonder how to do the following really the right way:

std::vector<K> v = ...;
for(T i=0; i<v.size(); ++i) {
  const K& t = v[i];
  // use t *and i*
}

What type should T be? int, unsigned int, int32_t, size_t (which would be the type of v.size()) or any other suggestions? Please try to consider portability, error-proneness and performance and be objective in your answer.

Edit: I did not choose iterators, because it would also like to use the index number i explicitly.

Answer 1

The type of i should be the same as the return value of size(), which is std::vector<K>::size_type. However, in practice, size_t will do just fine. If you use a signed integer type, then your compiler will probably warn about a signed/unsigned mismatch in the less-than comparison.

Normally you would use an iterator for this anyway:

std::vector<K> v = ...;
for (std::vector<K>::iterator i = v.begin(); i != v.end(); ++i) {
  const K& t = *i;
  // use t
}

Or, in C++0x:

std::vector<K> v = ...;
for (auto i = v.begin(); i != v.end(); ++i) {
  const K& t = *i;
  // use t
}

In response to your comment about using the vector index with iterators, consider the std::distance() function which is constant time operation for vector iterators:

std::vector<K> v = ...;
for (auto i = v.begin(); i != v.end(); ++i) {
  const K& t = *i;
  size_t index = std::distance(v.begin(), i);
  // use t and index
}