Utilizzare un iteratore normale per iterare all'indietro o lottare con reverse_iterator?

Question

Recentemente ho imparato a conoscere il modo giusto di lavorare con gli iteratori inversi in C++ (in particolare quando è necessario cancellarne uno). (Vedere this question e this one.)

Questo è come si suppone di farlo:

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

Ma io penso pensato che questo è molto meglio (non fare questo, non standard compliant, come fa notare MooingDuck):

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

Contro:

• Dimmi. Cosa c'è di sbagliato in questo?
• Non è conforme agli standard, come sottolinea MooingDuck. Di seguito si annulla praticamente uno dei possibili vantaggi.

Pro:

• Utilizza un linguaggio familiare per inversione per-loop
• non c'è bisogno di ricordare (o spiegare) il +1
• Meno digitando
• Works for std: : lista anche: it = il.erase(it);
• Se si cancella un elemento, non è necessario regolare l'iteratore
• Se si cancella, non c'è bisogno di ricalcolare l'iteratore

Answer 1

Il motivo per gli iteratori inversi è che lo standard algorithms non sa come eseguire iterazioni su una raccolta al contrario. Ad esempio:

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

Utilizzare qualsiasi iteratore per ottenere un codice più chiaro.

Answer 2

iniziare Per quel che vale, Scott Meyers' Efficace STL raccomanda che hai appena bastone con un ol normale' iterator (punto 26).