Use un iterador regular para iterar hacia atrás, o luchar con reverse_iterator?

Question

Recientemente aprendí sobre la forma correcta de trabajar con iteradores inversos en C++ (específicamente cuando necesitas borrar uno). (Ver this question y this one.)

Ésta es la forma en que se supone que hacerlo:

typedef std::vector<int> IV; 
for (IV::reverse_iterator rit = iv.rbegin(), rend = iv.rend(); 
    rit != rend; ++rit) 
{ 
    // Use 'rit' if a reverse_iterator is good enough, e.g., 
    *rit += 10; 
    // Use (rit + 1).base() if you need a regular iterator e.g., 
    iv.erase((rit + 1).base()); 
} 

Pero yo creo pensaron que esto es mucho mejor (No haga esto, no estándares compatibles, como señala MooingDuck out):

for (IV::iterator it = iv.end(), begin = iv.begin(); 
    it-- != begin;) 
{ 
    // Use 'it' for anything you want 
    *it += 10; 
    iv.erase(it); 
} 

Contras:

• Dígame. ¿Qué tiene de malo?
• No cumple con los estándares, como señala MooingDuck. Eso prácticamente anula cualquiera de las posibles ventajas a continuación.

Pros:

• Utiliza un lenguaje familiar para inversa para bucles
• no tiene que recordar (o explicar) la +1
• Menos escribir
• Obras para std: : list too too: it = il.erase(it);
• Si borra un elemento, no tiene que ajustar el iterador
• Si borra, usted no tiene que volver a calcular el iterador comenzar

Answer 1

El motivo de los iteradores inversos es que el standard algorithms no sabe cómo iterar en una colección hacia atrás. Por ejemplo:

#include <string> 
#include <algorithm> 
std::wstring foo(L"This is a test, with two letter a's involved."); 
std::find(foo.begin(), foo.end(), L'a'); // Returns an iterator pointing 
             // to the first a character. 
std::find(foo.rbegin(), foo.rend(), L'a').base()-1; //Returns an iterator 
               // pointing to the last A. 
std::find(foo.end(), foo.begin(), L'a'); //WRONG!! (Buffer overrun) 

Utilice el iterador que resulte en un código más claro.

Answer 2

Por lo que vale la pena, Scott Meyers STL eficaz recomienda que sólo se adhieren con un ol regular' iterator (punto 26).