Pouvez-vous supprimer des éléments d'une liste std :: en l'itérant?

Question

J'ai le code qui ressemble à ceci:

for (std::list<item*>::iterator i=items.begin();i!=items.end();i++) 
{ 
    bool isActive = (*i)->update(); 
    //if (!isActive) 
    // items.remove(*i); 
    //else 
     other_code_involving(*i); 
} 
items.remove_if(CheckItemNotActive); 

Je voudrais supprimer des éléments inactifs immédiatement après leur mise à jour, afinde pour éviter de marcher à nouveau la liste. Mais si j'ajoute les lignes commentées, j'obtiens une erreur quand j'arrive à i++: "Liste l'itérateur non incrémentable". J'ai essayé quelques alternatives qui n'ont pas été incrémentées dans la déclaration for, mais je n'ai rien pu faire.

Quelle est la meilleure façon de supprimer des éléments lorsque vous marchez dans une liste std :: list?

Answer 1

Vous devez d'abord incrémenter l'itérateur (avec i ++), puis supprimer l'élément précédent (par exemple, en utilisant la valeur renvoyée par i ++). Vous pouvez modifier le code à une boucle while comme ceci:

std::list<item*>::iterator i = items.begin(); 
while (i != items.end()) 
{ 
    bool isActive = (*i)->update(); 
    if (!isActive) 
    { 
     items.erase(i++); // alternatively, i = items.erase(i); 
    } 
    else 
    { 
     other_code_involving(*i); 
     ++i; 
    } 
} 

Answer 2

Vous voulez faire:

i= items.erase(i); 

Ce sera correctement mise à jour du iterator pour pointer vers l'emplacement après l'itérateur que vous avez retiré.

Answer 3

Utilisez l'algorithme std :: remove_if.

Edit: Travailler avec des collections devrait être comme: 1. préparer collection. 2. collection de processus.

La vie sera plus facile si vous ne mélangez pas ces étapes.

1. std :: remove_if. ou d'une liste :: remove_if (si vous savez que vous travaillez avec la liste et non avec le TCollection)
2. std :: for_each

Answer 4

Suppression Invalide seulement les itérateurs qui pointent vers les éléments qui sont supprimés.

Donc, dans ce cas, après avoir supprimé * i, i est invalidé et vous ne pouvez pas incrémenter.

Ce que vous pouvez faire est d'enregistrer d'abord l'itérateur de l'élément à supprimer, puis d'incrémenter l'itérateur, puis de supprimer celui qui a été enregistré.

Answer 5

Vous devez faire la combinaison de la réponse de Kristo et MSN de:

// Note: Using the pre-increment operator is preferred for iterators because 
//  there can be a performance gain. 
// 
// Note: As long as you are iterating from beginning to end, without inserting 
//  along the way you can safely save end once; otherwise get it at the 
//  top of each loop. 

std::list< item * >::iterator iter = items.begin(); 
std::list< item * >::iterator end = items.end(); 

while (iter != items.end()) 
{ 
    item * pItem = *iter; 

    if (pItem->update() == true) 
    { 
     other_code_involving(pItem); 
     ++iter; 
    } 
    else 
    { 
     // BTW, who is deleting pItem, a.k.a. (*iter)? 
     iter = items.erase(iter); 
    } 
} 

Bien sûr, le plus efficace et SuperCool ® chose STL savy serait quelque chose comme ceci:

// This implementation of update executes other_code_involving(Item *) if 
// this instance needs updating. 
// 
// This method returns true if this still needs future updates. 
// 
bool Item::update(void) 
{ 
    if (m_needsUpdates == true) 
    { 
     m_needsUpdates = other_code_involving(this); 
    } 

    return (m_needsUpdates); 
} 

// This call does everything the previous loop did!!! (Including the fact 
// that it isn't deleting the items that are erased!) 
items.remove_if(std::not1(std::mem_fun(&Item::update))); 

Answer 6

L'alternative pour la version en boucle à la réponse de Kristo. Vous perdez un peu d'efficacité, vous revenez en arrière puis vous réacheminez lors de la suppression, mais en échange de l'incrément supplémentaire de l'itérateur, vous pouvez faire déclarer l'itérateur dans la portée de la boucle et le code un peu plus propre. Ce qu'il faut choisir dépend des priorités du moment.

La réponse était totalement hors délai, je sais ...

typedef std::list<item*>::iterator item_iterator; 

for(item_iterator i = items.begin(); i != items.end(); ++i) 
{ 
    bool isActive = (*i)->update(); 

    if (!isActive) 
    { 
     items.erase(i--); 
    } 
    else 
    { 
     other_code_involving(*i); 
    } 
} 

Answer 7

Je pense que vous avez un bug là, je code ainsi:

for (std::list<CAudioChannel *>::iterator itAudioChannel = audioChannels.begin(); 
      itAudioChannel != audioChannels.end();) 
{ 
    CAudioChannel *audioChannel = *itAudioChannel; 
    std::list<CAudioChannel *>::iterator itCurrentAudioChannel = itAudioChannel; 
    itAudioChannel++; 

    if (audioChannel->destroyMe) 
    { 
     audioChannels.erase(itCurrentAudioChannel); 
     delete audioChannel; 
     continue; 
    } 
    audioChannel->Mix(outBuffer, numSamples); 
} 

Answer 8

Voici un exemple en utilisant une boucle for qui parcourt la liste et incréments ou revalide l'itérateur en cas d'un élément étant retiré pendant la traversée de la liste.

for(auto i = items.begin(); i != items.end();) 
{ 
    if(bool isActive = (*i)->update()) 
    { 
     other_code_involving(*i); 
     ++i; 

    } 
    else 
    { 
     i = items.erase(i); 

    } 

} 

items.remove_if(CheckItemNotActive); 

Answer 9

Si vous pensez de la std::list comme une file d'attente, vous pouvez dequeue et enqueue tous les éléments que vous souhaitez conserver, mais seulement dequeue (et non enqueue) l'élément que vous souhaitez supprimer. Voici un exemple où je veux supprimer 5 à partir d'une liste contenant les numéros 1-10 ...

std::list<int> myList; 

int size = myList.size(); // The size needs to be saved to iterate through the whole thing 

for (int i = 0; i < size; ++i) 
{ 
    int val = myList.back() 
    myList.pop_back() // dequeue 
    if (val != 5) 
    { 
     myList.push_front(val) // enqueue if not 5 
    } 
} 

myList auront maintenant que des chiffres 1-4 et 6-10.

Answer 10

Vous pouvez écrire

std::list<item*>::iterator i = items.begin(); 
while (i != items.end()) 
{ 
    bool isActive = (*i)->update(); 
    if (!isActive) { 
     i = items.erase(i); 
    } else { 
     other_code_involving(*i); 
     i++; 
    } 
} 

Vous pouvez écrire un code équivalent std::list::remove_if, moins bavard et plus explicite

items.remove_if([] (item*i) { 
    bool isActive = (*i)->update(); 
    if (!isActive) 
     return true; 

    other_code_involving(*i); 
    return false; 
}); 

L'idiome std::vector::erasestd::remove_if doit être utilisé lorsque des éléments est un vecteur au lieu de une liste pour garder compexity à O (n) - ou dans le cas où vous écrivez du code générique et des éléments peuvent être un conteneur sans moyen efficace d'effacer des éléments simples (comme un vecteur)

items.erase(std::remove_if(begin(items), end(items), [] (item*i) { 
    bool isActive = (*i)->update(); 
    if (!isActive) 
     return true; 

    other_code_involving(*i); 
    return false; 
}));