Kurze Frage zur Gültigkeit vom Increment von Iteratoren

Hallo, ich hab ne schnelle frage, ob das eine gültige Operation ist, oder ob das undefiniertes Verhalten nach sich führt:

std::map<int, int> m;
m[0]=0; //m.size() == 1

std::map<int, int> iterator it = m.begin();
++it;++it; //Erlaubt und definiert?
if(m.size() > 2) std::cout<<it->second;

"it" zeigt ja erst auf m.end() und dann hinter m.end(), wird aber niemals dereferenziert. Ist es dann erlaubt/definiert, den iterator über end() hinaus zu inkrementieren?

Ich denke, dass das Verhalten undefiniert ist, sobald du end() überschreitest. Da sich das aber gut duch entsprechende Abfragen vermeiden lässt, solltest du nie in eine solche Situation geraten.

Nexus

IncIt schrieb:

Ist es dann erlaubt/definiert, den iterator über end() hinaus zu inkrementieren?

Nein. Gibt es eine Situation, in der du das tun müsstest?

Ich habe hier so einen Code (m hat mind. 1 Element):

std::map<tile, int>::iterator it = m.begin();
std::map<tile, int>::iterator it1=it; ++it1;
std::map<tile, int>::iterator it2=it1; ++it2;
std::map<tile, int>::iterator it3=it2; ++it3;
return (
        (it->second==2 && s==4)  ||
        (it->second==2 && s==2)  ||
        (it->second==3 && s==3)  ||
        (it->second==3 && s==2)  ||
        (s==3 && it1->second==3) ||
        (s==3 && it2->second==3) ||
        (s==4 && it3->second==2)
);

Wäre es also besser, ich würde it1 zB so zuweisen?

std::map<tile, int>::iterator it = m.begin();
std::map<tile, int>::iterator it1 = it;
if(s > 1)
    ++it1;

edit: s == unsigned s = m.size()

Wenn, dann sowas:

std::map<tile, int>::iterator it = m.begin();
return ((it->second==2 && s==4)          ||
        (it->second==2 && s==2)          ||
        (it->second==3 && s==3)          ||
        (it->second==3 && s==2)          ||
        ++it == m.end() || it->second==3 || // sobald eine Bedingung zutrifft,
        ++it == m.end() || it->second==3 || // wird die Orgie beendet.  Alles
        ++it == m.end() || it->second==2  ) // wird schön der Reihe nach behandelt
);

Denn: Bei einem map-Iterator wird das hinausnavigieren über die Grenzen nicht funktionieren. Der braucht einen Zeiger um das nächste Element zu finden.
Bei einem std::vector<> ist es (in der Praxis) definiert, weil der Iterator nichts anderes als ein Pointer ist.

Dein Block aus hardgecodeten Zahlen gefällt mir ganz und gar nicht, das löst man besser allgemeiner.

BTW: Wenn du einen Iterator it um n Elemente verschieben willst, nimmt man std::advance(it, n) .

Tachyon

IncIt schrieb:

"it" zeigt ja erst auf m.end() und dann hinter m.end(), wird aber niemals dereferenziert. Ist es dann erlaubt/definiert, den iterator über end() hinaus zu inkrementieren?

Ganz einfach: Jedes mal, wenn ein Iterator vor c.begin() oder hinter c.end() zeigt, hast Du UB. Wenn man Pech hat, geht z.B. das Inkrementieren/Dekrementieren in die Hose.