Pouvez-vous supprimer des éléments d'une liste std :: tout en parcourant celle-ci?

J'ai un 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 souhaite supprimer les éléments inactifs immédiatement après leur mise à jour, afin d'éviter de parcourir à nouveau la liste. Mais si j'ajoute les lignes commentées, j'obtiens une erreur lorsque j'arrive à i++: "L'itérateur de liste n'est pas incrémentable". J'ai essayé des suppléants qui n'ont pas augmenté dans l'instruction for, mais je n'ai rien pu faire.

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

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 changer le code en 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;
    }
}

Vous voulez faire:

i= items.erase(i);

Cela mettra correctement à jour l'itérateur pour pointer vers l'emplacement après l'itérateur que vous avez supprimé.

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

// 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 != 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, la chose la plus efficace et la plus efficace de SuperCool® STL 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)));

Utilisez l'algorithme std :: remove_if.

Edit: Le travail avec les collections devrait ressembler à: 1. préparer la collection. 2. collecte de processus.

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

1. std :: remove_if. ou list :: remove_if (si vous savez que vous travaillez avec list et non avec TCollection)
2. std :: for_each

Voici un exemple utilisant une forboucle qui itère la liste et incrémente ou revalide l'itérateur en cas de suppression d'un élément 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);

L'alternative pour la version en boucle à la réponse de Kristo.

Vous perdez de l'efficacité, vous revenez en arrière puis recommencez lors de la suppression, mais en échange de l'incrément d'itérateur supplémentaire, vous pouvez faire déclarer l'itérateur dans la portée de la boucle et le code un peu plus propre. Que choisir dépend des priorités du moment.

La réponse était totalement hors du temps, 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);
    }
}

Je l'ai résumé, voici les trois méthodes avec exemple:

1. en utilisant la whileboucle

list<int> lst{4, 1, 2, 3, 5};

auto it = lst.begin();
while (it != lst.end()){
    if((*it % 2) == 1){
        it = lst.erase(it);// erase and go to next
    } else{
        ++it;  // go to next
    }
}

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

2. en utilisant la fonction remove_ifmembre dans la liste:

list<int> lst{4, 1, 2, 3, 5};

lst.remove_if([](int a){return a % 2 == 1;});

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

3. en utilisant la fonction std::remove_ifcombinée avec la erasefonction membre:

list<int> lst{4, 1, 2, 3, 5};

lst.erase(std::remove_if(lst.begin(), lst.end(), [](int a){
    return a % 2 == 1;
}), lst.end());

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

4. en utilisant la forboucle, notez la mise à jour de l'itérateur:

list<int> lst{4, 1, 2, 3, 5};

for(auto it = lst.begin(); it != lst.end();++it){
    if ((*it % 2) == 1){
        it = lst.erase(it);  erase and go to next(erase will return the next iterator)
        --it;  // as it will be add again in for, so we go back one step
    }
}

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2 

La suppression invalide uniquement 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 l'incrémenter.

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

Si vous pensez std::listà une file d'attente, vous pouvez retirer et mettre en file d'attente tous les éléments que vous souhaitez conserver, mais uniquement retirer (et non mettre en file d'attente) l'élément que vous souhaitez supprimer. Voici un exemple où je veux supprimer 5 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 aura désormais uniquement les numéros 1-4 et 6-10.

L'itération vers l'arrière évite d'effacer un élément sur les autres éléments à parcourir:

typedef list<item*> list_t;
for ( list_t::iterator it = items.end() ; it != items.begin() ; ) {
    --it;
    bool remove = <determine whether to remove>
    if ( remove ) {
        items.erase( it );
    }
}

PS: voyez ceci , par exemple, concernant l'itération en arrière.

PS2: Je n'ai pas testé à fond s'il gère bien les éléments effaçables aux extrémités.

Tu peux é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 du code équivalent avec std::list::remove_if, qui est moins détaillé et plus explicite

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

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

le std::vector::erase std::remove_if idiome doit être utilisé lorsque les éléments sont un vecteur au lieu d'une liste pour conserver la compexité à O (n) - ou si vous écrivez du code générique et que les éléments peuvent être un conteneur sans moyen efficace d'effacer des éléments uniques (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;
}));

Je pense que vous avez un bug, je code de cette façon:

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