Quel est le moyen le plus propre de marcher et de désenvoyer un vecteur std :: en utilisant des itérateurs?

Question

J'ai une situation où je marche par un vecteur, de faire les choses:

 
std::vector::iterator iter = my_list.begin(); 

for (; iter != my_list.end(); ++iter) 
{ 
    if (iter->doStuff()) // returns true if successful, false o/w 
    { 
    // Keep going... 
    } 
    else 
    { 
    for (; iter != m_list.begin(); --iter) // ...This won't work... 
    { 
     iter->undoStuff(); 
    } 
    } 
} 

Dans des conditions normales - en supposant que tout se passe bien - je marche tout le chemin à my_list.end() et terminer la boucle avec succès.

Cependant, si quelque chose ne va pas pendant que je fais des choses, je veux pouvoir tout annuler - revenez essentiellement au tout début du vecteur, en défaisant tout un à la fois dans l'ordre inverse.

Mon problème est que lorsque j'arrive à my_list.begin() - comme le montre la boucle for imbriquée - je n'ai vraiment pas encore terminé car j'ai encore besoin d'appeler undoStuff() sur mon premier élément de la liste. Maintenant, je pourrais juste faire l'appel final en dehors de la boucle, mais cela semble un peu sale.

La façon dont je le vois, je n'ai terminé que lorsque j'arrive à my_list.rend(). Cependant, je ne peux pas comparer un std :: vector :: iterator à un std :: vector :: reverse_iterator. Étant donné ce que j'essaie de faire, quel est le meilleur choix de combinaison de type itérateur/boucle?

Answer 1

Lors de l'utilisation itérateurs inverse via rbegin() et rend() fonctionne bien, malheureusement, je trouve que la conversion entre reverse et non-reverse iterarotrs a tendance à être assez déroutant. Je ne peux jamais me souvenir sans avoir à passer par un exercice de logique-puzzle si j'ai besoin d'incrémenter ou de décrémenter avant ou après la conversion. Par conséquent, j'évite généralement la conversion.

Voici comment je coderais probablement votre boucle de gestion des erreurs. Notez que je pense que vous n'auriez pas besoin d'appeler undoStuff() pour l'itérateur qui a échoué - après tout, doStuff() a déclaré qu'il n'a pas réussi.

// handle the situation where `doStuff() failed... 

// presumably you don't need to `undoStuff()` for the iterator that failed 
// if you do, I'd just add it right here before the loop: 
// 
//  iter->undoStuff(); 

while (iter != m_list.begin()) { 
    --iter; 
    iter->undoStuff(); 
} 

Answer 2

Je suis un peu rouillé quand il s'agit de vecteurs STL, mais serait-il possible de créer un std::vector::reverse_iterator à partir de votre itérateur initial? Ensuite, vous n'auriez besoin de commencer au dernier article que vous étiez à l'avenir, et serait en mesure de le comparer à my_list.rend() pour s'assurer que le premier article est traité.

Answer 3

Il n'y a bien sûr aucune raison de ne pas utiliser les vecteurs operator[]() si cela rend votre code plus clair, plus simple et/ou plus efficace.

Answer 4

Vous devez utiliser rbegin() pour obtenir un itérateur réversible.

Personnellement, je préfère encore

for (int i=0;i<vecter.size();i++) { } 

Answer 5

Sans l'aide d'un reverse_iterator, vous pouvez marcher à reculons cette façon:

while(iter-- != m_list.begin()) 
{ 
    iter->undoStuff(); 
} 

Bien que cela crée une copie de iter, le coût ne doit pas être trop grande . Vous pouvez factoriser pour une meilleure vitesse:

while(iter != m_list.begin()) 
{ 
    --iter; 
    iter->undoStuff(); 
} 

Answer 6

Ok, je vais aller sur une branche ici ..

std::vector iterator iter = my_list.begin(); 
bool error = false; 

while(iter != my_list.end()) 
{ 
    error = !iter->doStuff(); 
    if(error) 
    break 
    else 
    iter++; 
} 

if(error) 
do 
{ 
    iter->undoStuff(); 
    iter--; 
} 
while(iter != my_list.begin()) 

Answer 7

Ce que j'appelle l'ingénierie sur, mais il est tellement amusant

// This also can be done with adaptators I think 
// Run DoStuff until it failed or the container is empty 
template <typename Iterator> 
Iterator DoMuchStuff(Iterator begin, Iterator end) { 
    Iterator it = begin; 
    for(; it != end; ++it) { 
    if(!*it->DoStuff()) { 
     return it; 
    } 
    } 
    return it; 
} 

// This can be replaced by adaptators 
template <typename Iterator> 
void UndoMuchStuff(Iterator begin, Iterator end) { 
    for(Iterator it = begin; it != end; ++it) { 
    it->UndoStuff(); 
    } 
} 

// Now it is so much easier to read what we really want to do 
typedef std::vector<MyObject*> MyList; 
typedef MyList::iterator Iterator; 
typedef MyList::reverse_iterator ReverseIterator; 
Iterator it = DoMuchStuff(my_list.begin(), my_list.end()); 
if(it != my_list.end()) { 
    // we need to unprocess [begin,it], ie including it 
    UndoMuchStuff(ReverseIterator(1+it), ReverseIterator(my_list.begin())); 
} 

Answer 8

Cela dépend de ce que votre fonction doStuff() fait, et l'importance de la performance est dans votre contexte. Si possible, il serait probablement plus clair (c'est-à-dire - plus facile pour le lecteur) de travailler sur une copie de votre vecteur, et seulement si tout va bien, permutez les vecteurs.

std::vector<Foo> workingCopy; 
workingCopy.assign(myVector.begin(), myVector.end()); 

bool success = true; 
auto iter = workingCopy.begin(); 
for(; iter != workingCopy.end() && success == true; ++iter) 
    success = iter->doStuff(); 

if(success) 
    myVector.swap(workingCopy); 

Answer 9

Cela peut être fait avec un reverse_iterator:

bool shouldUndo(false); 
std::vector::iterator iter(my_list.begin()), end(my_list.end()); 
for (; iter != end && !shouldUndo; ++iter) 
{ 
    shouldUndo = iter->doStuff(); // returns true if successful, false o/w 
} 
if (shouldUndo) { 
    reverse_iterator<std::vector::iterator> riter(iter), rend(my_list.rend()); 
    //Does not call `undoStuff` on the object that failed to `doStuff` 
    for (; riter != rend; ++riter) 
    { 
    iter->undoStuff(); 
    } 
}