¿Cómo se itera hacia atrás a través de una lista STL?

Question

Estoy escribiendo algunos códigos multiplataforma entre Windows y Mac.

If list :: end() "devuelve un iterador que dirige la ubicación que sucede al último elemento en una lista" y se puede verificar al atravesar una lista, ¿cuál es la mejor forma de retroceder?

Este código workson el Mac, pero no en Windows (no se puede decrementar allá primer elemento):

list<DVFGfxObj*>::iterator iter = m_Objs.end(); 
for (iter--; iter!=m_Objs.end(); iter--)// By accident discovered that the iterator is circular ? 
{ 
} 

esto funciona en Windows:

list<DVFGfxObj*>::iterator iter = m_Objs.end(); 
    do{ 
     iter--; 
    } while (*iter != *m_Objs.begin()); 

¿Existe otra forma de recorrer hacia atrás que podría implementarse en un bucle for?

Answer 1

Uso reverse_iterator en lugar de iterador. Uso rbegin() & rend() en lugar de begin() & final().

Otra posibilidad, si te gusta usar la macro BOOST_FOREACH es utilizar la macro BOOST_REVERSE_FOREACH introducida en Boost 1.36.0.

Answer 2

Probablemente quieren que los iteradores inversa. De memoria:

list<DVFGfxObj*>::reverse_iterator iter = m_Objs.rbegin(); 
for(; iter != m_Objs.rend(); ++iter) 
{ 
} 

Answer 3

Como ya se ha mencionado por Ferruccio, el uso reverse_iterator:

for (std::list<int>::reverse_iterator i = s.rbegin(); i != s.rend(); ++i) 

Answer 4

esto debería funcionar:

list<DVFGfxObj*>::reverse_iterator iter = m_Objs.rbegin(); 
for (; iter!= m_Objs.rend(); iter++) 
{ 
} 

Answer 5

La forma mejor/más fácil de revertir iterar una lista es (como ya indicado) para usar los iteradores inversos rbegin/rend.

Sin embargo, quería mencionar que los iteradores inversos se implementan almacenando la posición del iterador "actual" de a-uno (al menos en la implementación de GNU de la biblioteca estándar).

Esto se hace para simplificar la implementación, para que el rango en sentido inverso para tener la misma semántica que un rango de avance [comenzar, terminar) y [rbegin, rend)

Lo que esto significa es que dereferenciar una iterador implica la creación de un nuevo temporal, y luego disminuyendo ella, cada vez:

reference 
    operator*() const 
    { 
_Iterator __tmp = current; 
return *--__tmp; 
    } 

Por lo tanto, la eliminación de referencias un reverse_iterator es más lento que un iterador normal.

Sin embargo, su lugar, puede utilizar los iteradores bidireccionales regulares para simular revertir iteración a sí mismo, evitando esta sobrecarga:

for (iterator current = end() ; current != begin() ; /* Do nothing */) 
{ 
    --current; // Unfortunately, you now need this here 
    /* Do work */ 
    cout << *current << endl; 
} 

pruebas mostraron que esta solución sea ~ 5 veces más rápido para cada desreferenciar utilizado en el cuerpo del bucle

Nota: Las pruebas no se hizo con el código anterior, como el std :: cout habría sido el cuello de botella.

También Nota: la diferencia de "tiempo de reloj de pared" fue ~ 5 segundos con un tamaño de lista estándar de 10 millones de elementos. Entonces, de manera realista, a menos que el tamaño de tus datos sea tan grande, solo mantente en rbegin() rend()!