geeksforgeeks - list iterator c++

Iterar Múltiple std:: vector

Question

He leído aquí y en otros lugares que cuando itera un std :: vector usando índices debe:

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

Pero, ¿qué sucede si itera dos vectores de diferentes tipos?

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;
}

¿Es seguro asumir que

std::vector<int>::size_type

es del mismo tipo que

std::vector<double>::size_type

?

¿Sería seguro usar std :: size_t?

Gracias.

Answer 1

Bueno, creo que:

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

es algo así como un consejo de perfección: ¿esperas que tus vectores sean realmente gigantescos? Personalmente, uso unsigned int , sin problemas.

Y ahora, supongo que comenzarán los downvotes ...

Answer 2

Creo que puede suponer con seguridad que size_type es un entero no negativo sin signo. No puedes confiar mucho más que eso. Claro, la mayoría de los contenedores tienen un size_type que es lo mismo que size_t pero no hay garantías.

La documentación de SGI y esta fuente http://www.cplusplus.com/reference/stl/vector/ parecen estar de acuerdo en el punto.

También puede consultar esta solución para su problema: http://rosettacode.org/wiki/Loop_over_multiple_arrays_simultaneously#C.2B.2B

Espero que esto ayude.

Answer 3

Deberías usar iteradores en su lugar

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;
}

Porque no hay garantía de que u size_type sea del mismo tipo interno, de todos modos, para std::vector podría iterar usando unsigned int

Answer 4

En general, el estándar C ++ no ofrece tales garantías: ni la igualdad de size_types para contenedores con parámetros diferentes, ni igualdad con size_t.

Answer 5

Sí, para casi cualquier propósito práctico, puedes usar std :: size_t. Aunque había (más o menos) una intención de que los diferentes contenedores pudieran usar diferentes tipos para sus tamaños, aún así se garantiza que (al menos para los contenedores estándar) size_type sea lo mismo que size_t.

Alternativamente, podrías considerar usar un algoritmo, algo así como:

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));