wollte mal fragen was in schleifen eher angebracht ist, post oder präinkrementieren/dekrementieren? der unterschied zwischen beidem ist mir bewusst, aber ich bin mir eben nie sicher was wann dran kommt..

danke

Ich glaube das ist Gewöhnungssache, wobei meiner Erfahrung nach zu 99,99% die post-Methode gewählt wird (korregiert mich, falls das nicht stimmt).

Kommt drauf an, was man in/dekrementieren will. In ner Schleife ist es bei POD egal, aber ich mache eigentlich immer den pre, wenn der post keinen Sinn macht.

Ich glaube das ist Gewöhnungssache, wobei meiner Erfahrung nach zu 99,99% die post-Methode gewählt wird (korregiert mich, falls das nicht stimmt).

nein, das ist keine gewöhnungssache, sondern kommt auf die verwendung an. solange es ist unbedingt notwendig ist, sollte man immer den prä*krement-operator nehmen, damit man nicht an pods gebunden ist. falls ich nämlich plötzlich von size_t auf einen iterator umsteige, darf ich das nämlich überall umändern.

Wenn man sich anschaut wie Post/Präfix implementiert sind, zeigt sich auch wieso:

//Beispielklasse Integer:

//Präfix
Integer& operator++() {
  //*this erhöhen, Referenz auf *this zurückgeben -> schnell
}

//Postfix
const Integer operator++(int) {
   //Kopie anfertigen, *this erhöhen, jetzt Kopie zurückgeben -> langsamer
}

// 500 mal, also von 0 bis 499
for (int n=0; n<500; n++)

Dies ist schön lesbar und entspricht auch gleich der Zählweise in z.B. Arrays

auch mit Iteratoren geht das ziemlich gut

std::vector<int> intv;
std::vector<int>::iterator i;
for (i=intv.begin(); i!= intv.end(); i++)

Klärt mich mal bite auf

for(MapItor itr = c.begin(); itr != c.end(); ){
    if(itr->second == "bla") c.erase(itr++)
    else ++itr;
}

Is Beispiel aus "Spieleprogrammierung Gems 1", so wird sicherere Iteration gewährleistet.

Kommt auf die Situation an:

for(MapItor itr = c.begin(); itr != c.end(); ){
    if(itr->second == "bla") c.erase(itr++)
    else ++itr;
}

Is Beispiel aus "Spieleprogrammierung Gems 1", so wird sicherere Iteration gewährleistet.

Aha und was spricht gegen

for( MapItor itr = c.begin(); itr != c.end(); ++itr )
   if( itr->second == "bla" )
        c.erase( itr );

effe_eichelt schrieb:

Kommt auf die Situation an:

for(MapItor itr = c.begin(); itr != c.end(); ){
    if(itr->second == "bla") c.erase(itr++)
    else ++itr;
}

Is Beispiel aus "Spieleprogrammierung Gems 1", so wird sicherere Iteration gewährleistet.

Aha und was spricht gegen

for( MapItor itr = c.begin(); itr != c.end(); ++itr )
   if( itr->second == "bla" )
        c.erase( itr );

Alles falsch. Nach dem löschen sollte man den Iterator auf den Rückgabewert von erase setzen.

Return Value

A random-access iterator that designates the first element remaining beyond any elements removed, or a pointer to the end of the (container) if no such element exists.

Bye, TGGC (Demo or Die)

@TGGC
Der Name MapIterator sowie der Zugriff itr->second deuten stark darauf hin, dass es sich hier um einen Iterator in einen assoziativen Container wie z.B. std::map handelt. Schaust du dir nun aber std::erase an (hier kann google weiterhelfen), wirst du feststellen, dass die passende Methode void, also nichts, zurückliefert. Diese Tatsache macht es extrem schwer "den Iterator auf den Rückgabewert von erase" zu setzen. Die vorgestellte Variante ist also genau richtig, wenn es darum geht in einer Schleife nur bestimmte Elemente aus einer Map zu löschen.

Wenns "einfach" sein soll, was spricht gegen die Verwendung von remove() mit
anschliessendem erase() ??

@TGGC
Der Name MapIterator sowie der Zugriff itr->second deuten stark darauf hin, dass es sich hier um einen Iterator in einen assoziativen Container wie z.B. std::map handelt. Schaust du dir nun aber std::erase an (hier kann google weiterhelfen), wirst du feststellen, dass die passende Methode void, also nichts, zurückliefert. Diese Tatsache macht es extrem schwer "den Iterator auf den Rückgabewert von erase" zu setzen. Die vorgestellte Variante ist also genau richtig, wenn es darum geht in einer Schleife nur bestimmte Elemente aus einer Map zu löschen.

@umeSikkins
Der Name MapIterator sowie der Zugriff itr->second deuten stark darauf hin, dass es sich hier um einen Iterator in einen assoziativen Container wie z.B. std::map handelt. Schaust du dir nun aber std::erase an (hier kann google weiterhelfen), wirst du feststellen, dass die passende Methode iteraor, also einen iterator, zurückliefert. Diese Tatsache macht es extrem leicht "den Iterator auf den Rückgabewert von erase" zu setzen. Die vorgestellte Variante ist also genau richtig, wenn es darum geht in einer Schleife nur bestimmte Elemente aus einer Map zu löschen.

Bye, TGGC (Demo or Die)

void erase(iterator pos);
size_type erase(const key_type& x);
void  erase(iterator first, iterator last)

Und der Standard ist nun mal das Dokument, dass im *Standard*-C++ Forum die größte Relevanz hat. Weleche Doku hat dir denn was falsches suggeriert?

Wenns "einfach" sein soll, was spricht gegen die Verwendung von remove() mit anschliessendem erase() ??

Was meinst du? Meinst du das "erase-remove-idiom"? Falls ja, das funktioniert nicht bei assoziativen Containern.

Und der Standard ist nun mal das Dokument, dass im *Standard*-C++ Forum die größte Relevanz hat.

Stimmt, die Realität sollte man ignorieren, es gibt nur eine Wahrheit...

Bye, TGGC (Demo or Die)

HumeSikkins schrieb:

Und der Standard ist nun mal das Dokument, dass im *Standard*-C++ Forum die größte Relevanz hat.

Stimmt, die Realität sollte man ignorieren, es gibt nur eine Wahrheit...

Nö. Nur sollte man schon prüfen, was Realität ist.
Schauen wir mal:
Gnu-STL, STL-Port, SGI-STL, comolib: void erase
Dinkumware-STL: iterator erase.

Fazit: Wer ausschließlich mit dem Visual Studio arbeitet oder aber überall eine Dinkumware-STL installiert (erst kaufen), der kann auf einen Rückgabwert vom Typ iterator bauen.
Wer allerdings nebenbei mit einem gcc, einem sun-cc oder irgendeinem anderen Compiler arbeitet, der sollte in diesem Punkt wohl besser beim Standard bleiben.

for(MapIterator itr = c.begin(); itr != c.end(); ++itr)
{
   if(itr->second == "bla")
   {
       c.erase(itr);
   }
}

HumeSikkins ist das hier ok?

for(MapIterator itr = c.begin(); itr != c.end(); ++itr)
{
   if(itr->second == "bla")
   {
       c.erase(itr);
   }
}

Nein. Durch die erase-Operation wird der Iterator ungültig. Der nachfolgende Aufruf des Inkrement-Operators führt dann zu undefiniertem Verhalten.

Du mußt deinen Zähl-Iterator also schon weitergerechnet haben, bevor du eine Kopie davon an c.erase() übergeben kannst - und das schaffst du z.B. mit effe_eichelt's Code.

Bitte.

Bye, TGGC (Demo or Die)

TGGC schrieb:

Bitte.

Bye, TGGC (Demo or Die)