wann postinkrementieren?

[samsara]

Einfuehrende Buecher scheinen zu dem Thema post vs. preincrement bzw. decrement nicht viel zu sagen zu haben. Jetzt habe ich gelesen, dass pre-inkrementieren schneller geht. Macht ja auch Sinn, wenn man mal drueber nachdenkt.
Wann also kann man ohne Effizienzeinbusse postinkrementieren benutzen?

Danke,

Samsara

[peschmae]

Ich hab auch schon darüber nachgedacht. Wieso macht das Sinn?

Ich benutz aber eigentlich immer Post-increment - schliesslich sieht i++ einfach besser aus als ++i. Ausnahme natürlich da, wos drauf an kommt - aber das ist ja nur selten der Fall.

MfG Peschmä

[wraith]

Original geschrieben von samsara
Jetzt habe ich gelesen, dass pre-inkrementieren schneller geht.

Das kommt drauf an.

Wann also kann man ohne Effizienzeinbusse postinkrementieren benutzen?

Wenn es sich im einen eingebauten Datentyp handelt,oder um einen Pointer darauf,und der Ausdruck keine Seiteneffekte hat,dann ist es egal,ob Post- oder Preincrement.Es wird vom Compiler in äquivalenten Code umgesetzt.
Bsp

for(int i = 0;i < 10;i++) 
{....
oder 
i++;
++i;

In den Beipielen ist es egal.

Wichtig ist es bei komplexen Datentypen,zb. Iteratoren,weil hier muß ein vielleicht komplexes Objekt erzeugt werden beim Postincrement.
Problem hierbei ist,daß der Compiler nicht sagen kann,dann mach ich ebend die Preincrement-Variante,wegen Seiteneffekten.
Bsp

class KomplexeKlasse {
...
    KomplexeKlasse& operator++() {  //Preincrement
         //incrementieren und zurückgeben
    }

    KomplexeKlasse operator++(int) {  //Postincrement
         //Temporäres Objekt erzeugen,this erhöhen,3.Weltkrieg auslösen,Temp zurückgeben
    }

[SeeksTheMoon]

es geht darum:
Beim Post Incr wird der Wert erst ausgelesen und dann erhöht, beim Pre Incr wird er direkt erhöht.

Allerdings bezweifle ich, dass man dies in irgendeinem Programm bemerkt, außer man schreibt vielleicht einen Atombombensimulator...

[samsara]

Wenn ich mir mal anmasse, die bisherigen Antworten zusammenzufassen:

Postinkrement ist immer langsamer, aber in der grossen Mehrzahl der Faelle ist dieser Unterschied zu vernachlaessigen.

Was ich in naeherer Zukunft vorhabe, ist an Komplexitaet dem Atombombensimulator aehnlich, also schon gut, vorher zu wissen, wie man ein paar Tage Rechenzeit sparen kann

Dank an alle,

Samsara

[wraith]

Original geschrieben von samsara
Wenn ich mir mal anmasse, die bisherigen Antworten zusammenzufassen:

Postinkrement ist immer langsamer, aber in der grossen Mehrzahl der Faelle ist dieser Unterschied zu vernachlaessigen.

Das war nicht die Lehre,die du daraus ziehen solltest .

Nochmal kurz,nur für C (ohne ++),da brauch' ich nicht auf komplexe Datentypen eingehen (siehe oben):
Diese Anweisungen erzeugen alle 100% identischen Code (Optimierungen eingeschaltet)

//i sei ein int
++i;
i++;
i += 1;
i = i + 1;

Warum?Weil der Kontext so ist,daß man von außen keinen Unterschied feststellen kann.
Alle Seiteneffekte müßen beim ; abgeschlossen sein.

Post und Preincrement erlangen erst im zusammenhängenden Kontext ihre Bedeutung,wie in diesen Beispielen:

array[++i] = a;
a = ++i;

Hier hast du keine Wahl zwischen Post- und Preincrement,du willst das Verhalten von Preincrement (bzw. Postinc.),ansonsten wäre das Ergebniss ein völlig anderes.
Hier läßt sich also kein Unterschied in der Performance feststellen,denn die Semantik ist eine völlig andere (Äpfel-Birnen-Vergleich).

Moral von der Geschichte:
Benutze Postincrement,wenn du Postincrement brauchst.
Benutze Preincrement,wenn du Preincrement brauchst.
Ansonsten wirst du eh keinen Unterschied feststellen.

[samsara]

Original geschrieben von wraith

array[++i] = a;
a = ++i;

Hier hast du keine Wahl zwischen Post- und Preincrement,du willst das Verhalten von Preincrement (bzw. Postinc.),ansonsten wäre das Ergebniss ein völlig anderes.
Hier läßt sich also kein Unterschied in der Performance feststellen,denn die Semantik ist eine völlig andere (Äpfel-Birnen-Vergleich).

Okay, die Beispiele oben sind natuerlich voellig aus dem Kontext gegriffen. Wenn man den Kontext entsprechend umgestaltet, kommt man wieder vor die Entscheidung:

for (array_index = 0; array_index <= length_of_array;) {
   array[i++] = a;
}

oder

for (array_index = -1; array_index < length_of_array;) {
   array[++i] = a;
}

Darf ich Deine Erklaerung so verstehen, dass die beiden obenstehenden Implementierungen auch gleich schnell laufen wuerden?

Danke,

Samsara

[wraith]

Original geschrieben von samsara
Wenn man den Kontext entsprechend umgestaltet, kommt man wieder vor die Entscheidung:

for (array_index = 0; array_index <= length_of_array;) {
   array[i++] = a;
}

oder

for (array_index = -1; array_index < length_of_array;) {
   array[++i] = a;
}

Darf ich Deine Erklaerung so verstehen, dass die beiden obenstehenden Implementierungen auch gleich schnell laufen wuerden?

Das ist so ein Grenzfall ,würde ich mir mal den ASM Output vom generierten Code anschauen.
Eigentlich erwarte ich das mein Compiler daraus optimalen Code erstellt,ohne das ein Tempory von i erzeugt wird.
IMO wird daraus sowas erzeugt

for (array_index = 0; array_index <= length_of_array;) {
   array[i] = a;
    ++i;
}

[kehj]

@ samsara:

Darf man fragen, was du vorhast?
Oder muß ich dann erschossen werden?

[peschmae]

Muss er denn was vorhaben?

Ich denke er kann auch so Fragen stellen

MfG Peschmä

[kehj]

Er sagte weiter oben:

Was ich in naeherer Zukunft vorhabe, ist an Komplexitaet dem Atombombensimulator aehnlich, also schon gut, vorher zu wissen, wie man ein paar Tage Rechenzeit sparen kann

Da bin ich neugierig geworden...

Aber man muß natürlich nichts vorhaben, um Fragen zu stellen. Fragen aus reinem Interesse sind oft die besten...

MfG

[peschmae]

stimmt, das war mir gar nicht aufgefallen

MfG Peschmä