Wie kann ich Elemente einer std :: map mit einem Iterator löschen?

Ich würde gerne eine Schleife über std::map und löschen von Elementen basierend auf deren Inhalt. Wie am besten würde diese durchgeführt werden?

InformationsquelleAutor der Frage | 2011-01-05

c++iterator map stdmap

85

Wenn Sie eine C++11-kompatiblen compiler, hier ist eine einfache Möglichkeit, dies zu tun:
```
std::map<K, V>::iterator itr = myMap.begin();
while (itr != myMap.end()) {
    if (ShouldDelete(*itr)) {
       itr = myMap.erase(itr);
    } else {
       ++itr;
    }
}
```
Die Idee ist es, zu Fuß den iterator vorwärts vom Beginn der container an das Ende, die überprüfung bei jedem Schritt, ob der aktuelle Schlüssel/Wert-paar gelöscht werden sollen. Wenn ja, entfernen wir das element der Iteration mit der erase member-Funktion, die liefert dann einen iterator auf das nächste element in der Karte. Ansonsten werden wir vorher die iterator-forward-Regel.

Wenn Sie nicht über eine C++11-kompatiblen compiler, oder Sie arbeiten mit einer älteren Codebasis, die Dinge ein bisschen schwieriger. Vor C++11, die erase member-Funktion würde nicht zurück einen iterator auf das nächste element in der Karte. Dies bedeutete, dass, um zu entfernen Sie ein element solange Durchlaufen, würden Sie brauchen, um eine drei-Teil Tanz:
1. Kopie der aktuellen iterator.
2. Voraus den aktuellen iterator auf das nächste element.
3. Nennen erase auf der Kopie der alten iterator.
Dies ist hier gezeigt:
```
std::map<K, V>::iterator itr = myMap.begin();
while (itr != myMap.end()) {
    if (ShouldDelete(*itr)) {
       std::map<K, V>::iterator toErase = itr;
       ++itr;
       myMap.erase(toErase);
    } else {
       ++itr;
    }
}
```
Dieser Prozess war notwendig, weil, wenn Sie gerade angerufen erase auf der iterator, Sie würde ungültigwas bedeutet, dass Operationen wie Inkrementieren und Dekrementieren würde führen zu undefiniertem Verhalten. Der obige code bekommt um diese durch eine Kopie der iterator, der fortschreitenden itr so, dass es auf das nächste element, dann das löschen der temporären Kopie der iterator.

Mit einigen Cleveren Trickiness, ist es möglich, verkleinern Sie diesen code unten auf Kosten der Lesbarkeit. Das folgende Muster ist Häufig in älteren C++ - code, aber nicht notwendig in C++11:
```
std::map<K, V>::iterator itr = myMap.begin();
while (itr != myMap.end()) {
    if (ShouldDelete(*itr)) {
       myMap.erase(itr++);  //<--- Note the post-increment!
    } else {
       ++itr;
    }
}
```
Den Einsatz der post-Inkrement-operator hier ist eine intelligente Möglichkeit, eine Kopie der alten iterator (denken Sie daran, dass eine postfix - ++ - operator gibt eine Kopie des original-iterator-Wert), während auch die Weiterentwicklung der älteren iterator.

InformationsquelleAutor der Antwort templatetypedef

Dies ist ein einfacher Weg:

    int value_to_delete( 2 );
    for( std::map<int, int>::iterator i = mm.begin(); i != mm.end(); ) {
        if( i->second != value_to_delete ) {
            mm.erase( i++ ); //advance before iterator become invalid
        }
        else {
            ++i;
        }
    }

InformationsquelleAutor der Antwort Chan

for(MyMap::iterator it = mymap.begin(); it!=mymap.end(); ) {
  if(mycondition(it))
    it = mymap.erase(it);
  else
    it++;
}