set<etwas> sc;
/* ...	*/
for (set<etwas>::iterator i = sc.begin(), ie = sc.end(); i != ie; ++i)
	if ((*i)->irgendwas()) {
		set<etwas>::iterator temp = i;
                ++temp;
		sc.erase(i);
                i = temp;
	}

Hi!
Das bedeutet, dass der iterator nach dem Löschen invalidiert wird.

Du hast das ein bisschen falsch verstanden ;). Nicht der Wert des Iterators wird ungültig (geht auch gar nicht, da nur eine Kopie an erase() übergeben wird), sondern das Objekt, auf das der Iterator verweist. Das bedeutet, dass das Dereferenzieren dieses Iterators nach dem Löschen zu undefiniertem Verhalten führt. Du darfst den Iterator danach gerne Inkrementieren, um zum nächsten (gültigen) Element zu kommen .

set<etwas> sc;
/* ...    */
for (set<etwas>::iterator i = sc.begin(), ie = sc.end(); i != ie; ++i)
{
    if ((*i)->irgendwas()) 
        sc.erase(i);
}

Grüße

Martin

map/set iterator not incrementable

Du hast das ein bisschen falsch verstanden ;). Nicht der Wert des Iterators wird ungültig (geht auch gar nicht, da nur eine Kopie an erase() übergeben wird), sondern das Objekt, auf das der Iterator verweist.

Öhm. Nein!

http://www.velocityreviews.com/forums/t277880-setltgteraseiterator-question.html

schöner schrieb:

if((*i)->irgendwas())
{
    m.erase(i++);
}
else
{
    ++i;
}

i++ macht eine Kopie des Iterators die zurückgegeben wird. Danach aber wird i intern inkrementiert und so zeigt er zu dem nächsten Element

Dinkumware Compleat Reference schrieb:

set::erase
iterator erase(iterator where);

The [...] member function removes the element of the controlled sequence pointed to by where. [...] It returns an iterator that designates the first element remaining beyond any elements removed, or end() if no such element exists.

Dann sieht das ganze ungefähr so aus:

set<etwas> sc;
//...
for (set<etwas>::iterator it = sc.begin(), ie = sc.end(); it != ie;)
    if ((*i)->irgendwas())
    {
        it = sc.erase(it); //it wird auf das nächste Element gesetzt
    }
    else
    {
        ++it; //it wird so auch auf das nächste Element gesetzt
    }

Felix

Wieso benutzt du nicht einfach den Rückgabewert von erase()?

Weil bei Set erase keinen Rückgabewert hat. Das ist laut Standard nicht vorgeschrieben.

http://www.cppreference.com/cppset/erase.html

set<etwas> sc;
/*...*/
struct testetwas {
  bool operator()(etwas const& e) {return e.irgendwas();}
};
std::remove_if(sc.begin(), sc.end(), testetwas());

Da es ein etwas unbekannteres Feature von C++ ist hier eine kurze Erklärung: testetwas ist eine lokale Klasse, die direkt vor dem Aufruf von remove_if definiert werden kann, also innerhalb der Funktion, in der sie benutzt wird.

Um meinen etwas knappen Beitrag zum Them Nutze die Standardbibliothek zu vervollständigen hier etwas Code:

set<etwas> sc;
/*...*/
struct testetwas {
  bool operator()(etwas const& e) {return e.irgendwas();}
};
std::remove_if(sc.begin(), sc.end(), testetwas());

Da es ein etwas unbekannteres Feature von C++ ist hier eine kurze Erklärung: testetwas ist eine lokale Klasse, die direkt vor dem Aufruf von remove_if definiert werden kann, also innerhalb der Funktion, in der sie benutzt wird.

Für mich ist das nicht unbekannt. Meinst du so:
sc.erase(remove_if(sc.begin(), sc.end(), predikat), sc.end());?
Bist du dir sicher, dass die remove_if Funktion mit set Iteratoren arbeiten kann?

Meinst du so:
sc.erase(remove_if(sc.begin(), sc.end(), predikat), sc.end());?

Natürlich. Unachtsamkeit meinerseits.

Bist du dir sicher, dass die remove_if Funktion mit set Iteratoren arbeiten kann?

Wäre schon blöd, wenn STL-Algorithmen nicht mit STL-Iteratoren arbeiten könnten oder? Dafür sind sie ja gemacht, würde mich also mehr als verwundern wenns das nicht tut.

remove_if arbeitet nicht mit set iteratoren. Punkt.

Richtig, weil remove_if die Reihenfolge in der Sequenz ändert. Da im set die Reihenfolge festgelegt ist, klappt das nicht.