Iteración sobre un vector en dirección inversa

Question

Necesito iterar sobre un vector desde el final hasta el principio. La forma "correcta" es

for(std::vector<SomeT>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) 
{ 
    //do Something 
} 

Cuando doSomething implica conocer el índice real, entonces algunos cálculos se deben hacer con rit para obtenerlo, como index = v.size() - 1 - (rit - v.rbegin)

Si se necesita el índice de todos modos, entonces fuertemente cree que es mejor para iterar usando ese índice

for(int i = v.size() - 1; i >= 0; --i) 
{ 
    //do something with v[i] and i; 
} 

Esto da una advertencia de que está firmado y iv.size() no tiene signo. Cambiar a

for(unsigned i = v.size() - 1; i >= 0; --i) es sólo funcionalmente mal, porque este es esencialmente un bucle sin fin :)

¿Qué es un estéticamente buena manera de hacer lo que quiero hacer, que

• está advirtiendo de libre
• no implica arroja
• no es excesivamente prolijo

espero no estoy buscando algo que no existe :)

Answer 1

Como habrás notado, el problema con una condición de i >= 0 cuando no está firmado es que la condición siempre es verdadera. En lugar de restar 1 al inicializar i y luego otra vez después de cada iteración, se resta 1 después de comprobar la condición del bucle:

for (unsigned i = v.size(); i-- > 0;) 

me gusta este estilo por varias razones:

• Aunque i se ajustará alrededor de UINT_MAX al final del ciclo, no hace referencia a en ese comportamiento; funcionaría igual si los tipos se firmaran. Depender de un envolvente sin firma me parece un poco complicado.
• Llama a size() exactamente una vez.
• No usa >=. Cada vez que veo ese operador en un bucle for, tengo que volver a leerlo para asegurarme de que no haya un error "uno por uno".
• Si cambia el espaciado en el condicional, puede hacer que use el "goes to" operator.

Answer 2

creo que:

for(unsigned i = v.size() - 1; i >= 0; --i) 

está bien si marca

!v.empty() 

anterior.

Answer 3

Preferiría la variante del iterador inverso, porque aún es fácil de interpretar y permite evitar los errores relacionados con el índice.

A veces se puede simplemente utilizar el BOOST_REVERSE_FOREACH, lo que haría que su código de mirar la siguiente manera:

reverse_foreach (int value, vector) { 
    do_something_with_the_value; 
} 

---

En realidad hablando, siempre se puede utilizar foreach declaraciones para este tipo de bucles, pero luego se convierten en un poco no obvia:

size_t i = 0; 

foreach (int value, vector) { 
    do_something; 
    ++i; 
} 

Answer 4

probar un Do While:

std::vector<Type> v; 
// Some code 
if(v.size() > 0) 
{ 
    unsigned int i = v.size() - 1; 
    do 
    { 
     // Your stuff 
    } 
    while(i-- > 0); 
} 

Answer 5

Hola creo que un mejor uso iterador manera como se utiliza en la primera muestra, y si necesita obtener el índice iterador puede utilizar std :: distancia para calcular que, si entiendo su pregunta

Answer 6

condición de bucle i != std::numeric_limits<unsigned>::max() ... o usa UINT_MAX si crees que es verboso. o de otra manera:
for(unsigned j=0, end=v.size(), i=end-1; j<end; --i, ++j)
o
for(unsigned end=v.size(), i=end-1; (end-i)<end; --i)

Answer 7

para ser estéticamente agradable! ;)

for(unsigned i = v.size() - 1; v.size() > i; --i) 

Answer 8

No hay nada para detener el bucle reverse_iterator también utilizando el índice como se describe en varias otras respuestas. De esta forma, puede usar el iterador o el índice según sea necesario en la parte // do the work, por un costo adicional mínimo.

size_t index = v.size() - 1; 
for(std::vector<SomeT>::reverse_iterator rit = v.rbegin(); 
    rit != v.rend(); ++rit, --index) 
{ 
    // do the work 
} 

Aunque tengo curiosidad por saber para qué necesita el índice. Acceder al v[index] es lo mismo que acceder al *rit.

Answer 9

for (it = v.end()-1; it != v.begin()-1; --it) 
{ 
} 

El "goes to" operator definitivamente se mete con la cabeza.