Können Sie Elemente aus einer std :: -Liste entfernen, während Sie sie durchlaufen?

Ich habe Code, der so aussieht:

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

Ich möchte inaktive Elemente sofort nach dem Aktualisieren entfernen, um ein erneutes Durchlaufen der Liste zu vermeiden. Wenn ich jedoch die auskommentierten Zeilen hinzufüge, wird folgende Fehlermeldung i++angezeigt: "Listeniterator nicht inkrementierbar". Ich habe einige Alternativen ausprobiert, die die for-Anweisung nicht erhöht haben, aber ich konnte nichts zum Laufen bringen.

Was ist der beste Weg, um Elemente zu entfernen, während Sie eine std :: -Liste durchlaufen?

Sie müssen zuerst den Iterator inkrementieren (mit i ++) und dann das vorherige Element entfernen (z. B. indem Sie den von i ++ zurückgegebenen Wert verwenden). Sie können den Code wie folgt in eine while-Schleife ändern:

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

Du willst machen:

i= items.erase(i);

Dadurch wird der Iterator korrekt aktualisiert und zeigt auf den Speicherort nach dem entfernten Iterator.

Sie müssen die Kombination aus Kristos Antwort und MSNs ausführen:

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

Das effizienteste und SuperCool® STL-versierte Ding wäre natürlich ungefähr so:

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

Verwenden Sie den Algorithmus std :: remove_if.

Bearbeiten: Die Arbeit mit Sammlungen sollte wie folgt aussehen: 1. Sammlung vorbereiten. 2. Prozesssammlung.

Das Leben wird einfacher, wenn Sie diese Schritte nicht mischen.

1. std :: remove_if. oder list :: remove_if (wenn Sie wissen, dass Sie mit list und nicht mit der TCollection arbeiten)
2. std :: for_each

Hier ist ein Beispiel mit einer forSchleife, die die Liste iteriert und den Iterator erhöht oder erneut validiert, falls ein Element während des Durchlaufs der Liste entfernt wird.

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

Die Alternative zur Loop-Version zu Kristos Antwort.

Sie verlieren etwas an Effizienz, gehen beim Löschen vorwärts und dann wieder vorwärts, aber im Austausch für das zusätzliche Iteratorinkrement können Sie den Iterator im Schleifenbereich deklarieren lassen und den Code etwas sauberer aussehen lassen. Was zu wählen ist, hängt von den Prioritäten des Augenblicks ab.

Die Antwort war völlig verspätet, ich weiß ...

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

Ich habe es zusammengefasst, hier sind die drei Methoden mit Beispiel:

1. mit whileSchleife

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. Verwenden der remove_ifMitgliederfunktion in der 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. Verwenden der std::remove_ifFunktion in Kombination mit der Elementfunktion erase:

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. Verwenden Sie die forSchleife, und beachten Sie, dass der Iterator aktualisiert wird:

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 

Durch das Entfernen werden nur die Iteratoren ungültig, die auf die entfernten Elemente verweisen.

In diesem Fall ist i nach dem Entfernen von * i ungültig und Sie können es nicht inkrementieren.

Sie können zuerst den Iterator des Elements speichern, das entfernt werden soll, dann den Iterator erhöhen und dann den gespeicherten entfernen.

Wenn Sie sich std::listeine Warteschlange vorstellen, können Sie alle Elemente, die Sie behalten möchten, aus der Warteschlange entfernen und in die Warteschlange stellen, aber nur das Element, das Sie entfernen möchten, aus der Warteschlange entfernen (und nicht in die Warteschlange stellen). Hier ist ein Beispiel, in dem ich 5 aus einer Liste mit den Nummern 1-10 entfernen möchte ...

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 wird jetzt nur die Nummern 1-4 und 6-10 haben.

Durch das Rückwärtslaufen wird vermieden, dass ein Element auf die verbleibenden zu durchlaufenden Elemente gelöscht wird:

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: Siehe dies z. B. in Bezug auf die Rückwärtsiteration.

PS2: Ich habe nicht gründlich getestet, ob es gut löschende Elemente an den Enden handhabt.

Du kannst schreiben

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

Sie können äquivalenten Code mit schreiben std::list::remove_if, der weniger ausführlich und expliziter ist

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

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

Das std::vector::erase std::remove_ifIdiom sollte verwendet werden, wenn Elemente ein Vektor anstelle einer Liste sind, um die Komplexität bei O (n) zu halten - oder wenn Sie generischen Code schreiben und Elemente möglicherweise ein Container sind, in dem einzelne Elemente (wie ein Vektor) nicht effektiv gelöscht werden können.

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

Ich denke du hast dort einen Fehler, ich codiere so:

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