Element aus Map löschen

pumuckl schrieb:

Ist halt künftig Standard und bietet einige Vorteile

Du meinst die eh schon komplizierte C++ Syntax noch komplizieter machen? Ja, das haben sie geschafft;)

Nexus

pumuckl schrieb:

Deshalb im Normalfall lieber dekrementieren. Der Inkrement für den nächsten Schleifendurchlauf setzt den Iterator dann wieder genau richtig. Da hier aber direkt danach break aufgerufen wird, ist it++ richtig.

Dekrementieren finde ich nicht gut. Einerseits kanns beim begin() -Iterator ganz schön krachen, andererseits ist nichts tun besser als dekrementieren und wieder inkrementieren. Der Code ist klarer, wenn man einen else -Block und somit schön alle Fälle untereinander hat, als wenn man immer an das automatische ++it im Schleifenkopf denken muss.

Und drittens kann man nicht immer dekrementieren, was vor allem bei std::forward_list aus C++0x relevant werden dürfte.

pumuckl

OP schrieb:

Du meinst die eh schon komplizierte C++ Syntax noch komplizieter machen? Ja, das haben sie geschafft;)

Ich meine lokal neue Funktionen definieren können, on the fly neue Funktoren einbauen können, sämtliche algorithmen endlich kurz und knackig anwenden können, sattt vorher erst noch ungefüge Functor-structs einbauen zu müssen.
Das Einzige, was man dafür an neuer Syntax lernen muss, ist die Closure-Syntax (das, was zwischen den eckigen Klammern steht), der Rest ist altbekannt.
Und SO kompliziert ist es nun auch wieder nicht. Im Gegenteil, einiges an kompliziertem Wust hat der neue Standard schon entfernt.
Dein [c]FooMap::iterator it[c] & Co kommt künftig sogar selbst ohne typedef für die Map viel kürzer daher:

bool gefunden = false;
    auto itEnd = mFoos.end();
    for(auto it = mFoos.begin(); it != itEnd; ++it) {
        if(it->second == param) {
            mFoos.erase(it);
            gefunden = true;
            break;
        }
    }

    assert( gefunden );

pumuckl

Nexus schrieb:

Dekrementieren finde ich nicht gut.

Stimmt, war ne blöde Idee...

ipsec

Warum nicht so?

Foo::iterator it       = mFoos.begin();
	FooMap::iterator itEnd = mFoos.end();
	for(; it != itEnd; ++it) {
		if(it->second == param) {
			break;
		}
	}

	assert( (it != itEnd)  );
	mFoos.erase(it);

Ohne bool und ohne Lambda.

pumuckl

ipsec schrieb:

Warum nicht so?

Foo::iterator it       = mFoos.begin();
	FooMap::iterator itEnd = mFoos.end();
	for(; it != itEnd; ++it) {
		if(it->second == param) {
			break;
		}
	}

	assert( (it != itEnd)  );
	mFoos.erase(it);

Ohne bool und ohne Lambda.

Auch gut. Oder noch kürzer:

FooMap::iterator it       = mFoos.begin();
    FooMap::iterator itEnd = mFoos.end();
    while(it != itEnd && it->second != param) 
        ++it;

    assert( (it != itEnd)  );
    mFoos.erase(it);