++iterator oder iterator++ bei for-Schleife
-
Guten Morgen,
was ist bitte der Unterschied (außer pre.. und post..)und was bedeutet er?
[cpp]
vector<int> box;
..
for(vector<int>::iterator it = box.begin(); it != box.end(); --it)
cout << *it << endl;
[/cpp][cpp]
vector<int> box;
..
for(vector<int>::iterator it = box.begin(); it != box.end(); ***it++***)
cout << *it << endl;
[/cpp]
-
AFAIK gibt es da nur den einen Unterschied -> pre- & postfix.
Das unterscheidet sich danach, wie operator++ und op-- implementiert sind, bei der stl ist es nicht mehr als das was man kennt
-
Der Postinkrementoperator muss eine Kopie des iterators erstellen. Wenn du den Rückgabewert nicht brauchst, nimm Preinkrement.
-
hehejo schrieb:
Guten Morgen,
was ist bitte der Unterschied (außer pre.. und post..)und was bedeutet er?
[cpp]
vector<int> box;
..
for(vector<int>::iterator it = box.begin(); it != box.end(); --it)
cout << *it << endl;
[/cpp][cpp]
vector<int> box;
..
for(vector<int>::iterator it = box.begin(); it != box.end(); ***it++***)
cout << *it << endl;
[/cpp]lustigerweise haben die inkrementoperatoren sogar einen rückgabewert.
wenn du schreibst
i=5;
++i;
x=i;
dann werden danach i und x den wert 6 haben.du kannst auch schreiben
i=5;
x=++i;
und es passiert das gleiche.also der ausdruck ++i bewirkt, daß i inkrementiert wird und daß danach der neue wert von i als wert des ganzen ausdrucks zurückgegebenm wird.
manchmal will man den alten wert haben.
i=5;
x=i++;
hier wird in x der alte wert landen!also der ausdruck i++ bewirkt, daß i inkrementiert wird und daß danach der *alte* wert von i als wert des ganzen ausdrucks zurückgegebenm wird.
besonders notwendig für spielchen wie void strcpy(char* dst,chat const* src){while(*dst++=*src++);}
dabei heißrt prä soviel woe vor und post soviel wie nach. siehe auch wirtbildungen wie prä-historisch und post-modern. die amis haben kein ä auf der tastatur und schreiben pre statt prä. präinkrement-operator meint, daß das inkrementieren vor dem berechnen des rückgabewertes passiert. und post entsprechend nach.
und was haben die in schleifen für ne unterschiedliche wirkung?
keine!!!schau her:
int i=5;
++i;
x=i;oder
int i=5;
i++;
x=i;beide code-sequenzen machen das gleiche. unterschiedlich sind diese operatoren nur, wenn man ihren wert irgendwie wieterverwendet.
und was soll man nehmen?
immer ++i!
denn beim schreiben von selbstgebauten operatoren kann man ja auch ++i und i++ implementieren. dabei ist ein ++i schnell gemacht. irgendwie das inkrementieren hinkriegen und return *this; als referenz. aber i++ ist schwer. man muss den alten wert erst speichern, dann muss man noch by value returnrn. uih, kosten über kosten. man mag bei selbergebauten typen ++i einfach so viel lieber, daß leute wie ich bereits dazu übergehen, nur ++i anzubieten und i++ wegzulassen.
bei eingebauten typen, also int, double oder so, gibt es keinen performance-unterschied. der compiler optimiert das schon fein. bei stl-iteratoren würde ich auch keinen unterschied vermuten. oder wenigstens keinen großen. aber da es immer doch passieren kann, daß i++ mal erheblich lahmer als ++i ist, sollte man sich angewöhnen, auch bei eingebauten typen immer ++i zu schreiben.
-
Vielen Dank für die ausführliche Antwort.
Etz weiß ich wieder ein Bisschen mehr.
-
volkard lässt einem aber auch garnichts mehr über
aber recht hat er.
solange i ein zeiger oder ein integer ist, wirst du in einer forschleife problemlos das benutzen können, was dir persönlich übersichtlicher ist. bei komplexen iteratoren dann aber doch lieber immer die richtige version, man weis ja nie
-
hehejo schrieb:
Vielen Dank für die ausführliche Antwort.
lol. Und ich dachte meine Antwort wär ausführlich.
-
Und was passiert bei:
int n=4; n=n+n++;Je nach Compiler ist n dann 8 oder auch 9.
Gruß - Xaron
-
Xaron schrieb:
Und was passiert bei:
int n=4; n=n+n++;Je nach Compiler ist n dann 8 oder auch 9.
Gruß - Xaron
ließ ma den standard, dann weiste wieso.