Iterate Multiple std::vector

I've read here and other places that when iterating a std::vector using indexes you should:

std::vector <int> x(20,1);
for (std::vector<int>::size_type i = 0; i < x.size(); i++){
  x[i]+=3;
}

But what if you are iterating two vectors of different types:

std::vector <int> x(20,1);
std::vector <double> y(20,1.0);
for (std::vector<int>::size_type i = 0; i < x.size(); i++){
  x[i]+=3;
  y[i]+=3.0;
}

Is it safe to assume that

std::vector<int>::size_type

is of the same type as

开发者_JAVA百科std::vector<double>::size_type

?

Would it be safe just to use std::size_t?

Yes, for almost any practical purpose, you can just use std::size_t. Though there was (sort of) an intent that different containers could use different types for their sizes, it's still basically guaranteed that (at least for standard containers) size_type is the same as size_t.

Alternatively, you could consider using an algorithm, something like:

std::transform(x.begin(), x.end(), x.begin(), std::bind2nd(std::plus<int>(), 3));
std::transform(y.begin(), y.end(), y.begin(), std::bind2nd(std::plus<double>(), 3.0));

In general, C++ standard doesn't give such guarantees: neither equality of size_types for differently parametrized containers, nor equality to size_t.

I think you can safely assume that size_type is an unsigned nonegative integer. You can't rely on much beyond that. Sure, most containers have a size_type which is the same as size_t but there are no guarantees.

The SGI documentation and this source http://www.cplusplus.com/reference/stl/vector/ seem to agree on the point.

You may also want to take a look to this solution for your problem: http://rosettacode.org/wiki/Loop_over_multiple_arrays_simultaneously#C.2B.2B

I hope this helps.

Well, I think that:

 for (std::vector<int>::size_type i = 0; i < x.size(); i++){

is something of a council of perfection - are you expecting your vectors to be really gigantic? Personally, I use unsigned int, with zero problems.

And now I suppose the downvotes will begin...

You should use iterators instead

std::vector <int> x(20,1);
std::vector <double> y(20,1.0);
std::vector<double>::iterator j = y.begin();
for (std::vector<int>::iterator i = x.begin(); i != x.end(); ++i){
  *i +=3;
  *j +=3.0;
  ++j;
}

Cause there's no guarantee that u size_type would be the same internal type, anyway, for std::vector you could iterate using unsigned int