++cnt oder cnt++

[Corcovado]

Leidiges Thema: gibt es einen Unterschied zwischen cnt++ und ++cnt in Java im Bezug auf Performanz?

 

[thE_29]

Nö, wieso sollte es auch?

Glaub kaum das ein ++ überhaupt die Performanz verschlechtert......

Das wird so schnell gemacht das kriegt man sowieso nima mit!

 

[Sky]

cnt++ bzw. ++cnt hat weniger was mit Performanz zu tun! Solltest dazu mal in der FAQ nachschauen.

Um den Unterschied zu verdeutlichen, hier ein kleines Beispiel:

int cnt;
cnt = 5;
System.out.println( cnt++ ); // gibt 5 aus

cnt = 5;
System.out.println( ++cnt ); // gibt 6 aus

 

[Corcovado]

hm ok,
Ich bin grad am Java einsteigen und kenne das nur von C/C++, dass es da einen kleinen Performance Unterschied gibt. Nun hatten wir hier letztlich ne Diskussion (eher so Klugscheisserei, geb ich zu ), weil in C/C++ der Postfix operator ( cnt++) eben mit "const TypeObjectVonCnt operator++(int)" und der Praefix-Operator ( ++cnt) mit "TypeObjectVonCnt& operator++()" definiert ist.

Dabei dient das int (i.d.R. wird einfach 0 implizit zurueckgegeben, man selber bekommt davon nix mit) zur Unterscheidung, dieses wurde afaik wegen C Programmierern in den 80ern eingefuehrt, weil sie sonst keine Moeglichkeit hatten die beiden zu unterscheiden. Das etwas zurueckgegeben werden muss ist klar, da man ja ein Ergebnis haben will Es ist jedoch deswegen ein const Obj notwendig, da sonst zB cnt++++ moeglich waere (cnt.operator++(0).operator++(0)). Das ist deshalb aber problematisch weil es erstens nicht konsistent ist mit anderen Operatoren (man will die Konsistenz weil man, in C++ zumindest, Operatoren ueberladen will und auch muss - in Java is das nicht noetig, dafuer gibts Methoden, hehehe) und zweitens weil das nicht unbedingt das tut, was man will. Da der erste Aufruf von operator++() sich noch direkt auf cnt bezieht, aber der zweite auf das was von operator++() zurueckgegeben wird, da kann einiges schiefgehn. Warum aber da ein Unterschied in den Returnwerten ist, weiss ich auch nicht genau, aber es ist in C und C++ so (weil es wahrscheinlich auch sinnvoll ist).

Tja zur Performance last sich nun folgendes sagen, wenn ein "const Obj" zurueckgegeben wird, muss dieses erzeugt und wieder zerstoert werden. So etwas nennt man "temporaeres Objekt" und das laeuft alles komplet im Hintergrund. Jedes Erzeugen von temporaeren Obj. allokiert Speicher (Kosten) und das Zerstoeren gibt ihn wieder frei (Kosten). Hinzu kommt, dass die Implementierung eines "temporaeren Obj's" auch kostet, weil sie ein zusaetzliches Objekt erzeugt (das "old value" Problem), das hat mit einer impliziten Typumwandlung (afaik hier von int nach const int) des temporaeren Objs, zu tun, wofuer eben der sog "old value" auch zerstoert werden muss (Kosten). Es ist also bei diesen Sprachen auch teurer - und das ist allgemein so ein Unterschied zwischen Postfix und Praefix - den Postfix-Operator zu benutzen, da obiges bei diesen unaeren Operatoren eben auch allg. gilt.

Wenn man das eben nun in for-loops oder dergleichen verwendet, wird es in jedem Schleifendurchlauf gemacht. Naja und glauben heisst schliesslich nicht wissen, sondern messen waere aufschlussreicher. Das hab ich aber auch noch nich gemacht, hehehe, ich dachte vielleicht kennt sich da jemand von Euch etwas aus, da ich auch schon oft gesehn habe, dass Java einen zu Konzepten zwingt, die man unbedingt in C++ machen sollte, aber man es auch komplett anders (vermurksen) machen kann. Daher waere es schon interessant zu wissen wie sie das bei Java geloest haben, dachte ich.

 

[thE_29]

Das mit den Objekten ist aber auch nur deswegen, wegen dem & Operator (es kommt ja drauf an ob der Term links oder rechts steht, so wie beim +=)

Aber ob es soviel Zeit kostet (es ist ein int, im normalfalls bei einer schleife) ist ne andere Frage.

Jedenfalls ist das Ergebnis gleich wie in Java

x = 3
printf("%d",x++); //Ausgabe: 3
x = 3
printf("%d",++x); //Ausgabe: 4

Aber das wirst eh wissen

 

[Bleiglanz]

a) der unterschied dürfte unmessbar sein

b) selbst wenn er messbar ist dürte er in 99,9% aller Fälle irrelevant sein

c) wenn du mal ein guter Programmierer werden willst, dann musst du dich ZWINGEN, über solche Sachen NICHT nachzudenken

d) hier mal bytecode, in java dürften die beiden befehle genau gleich schnell sein

    public int pre(int i)
    {
            return i++;
    }
                                                                                
    public int post(int i)
    {
            return ++i;
     }





public int pre(int);
  Code:
   0:   iload_1
   1:   iinc    1, 1
   4:   ireturn
 
public int post(int);
  Code:
   0:   iinc    1, 1
   3:   iload_1
   4:   ireturn

 

[Sky]

Bleiglanz hat vollkommen recht: Denk über die Performance nach, wenn Du ein richtiges Problem damit hast...
(Natürlich darfst Du beim Proggen die "Grundlagen" nicht vergessen, z.B. StringA + StringB + StringC )

 

[stev.glasow]

Bleiglanz hat vollkommen recht: Denk über die Performance nach, wenn Du ein richtiges Problem damit hast...
(Natürlich darfst Du beim Proggen die "Grundlagen" nicht vergessen, z.B. StringA + StringB + StringC )

Ich denke man sollte sich schon über Performance gedanken machen, besonders in der Lernphase, denn wenn ich wirklich mal etwas schneller machen will , hab ich keine Ahung wie ich das anstellen soll, da ich mich nie drum gekümmert habe. Es macht nur halt bei solchen extremen sachen wie x++ ++x keine Sinn, vor allem macht man sich damit ja fertig denn es gibt ja ständig Sachen bei denen man überlegen könnte ob etwas Anderes nicht ein klein wenig schneller wäre.

 

[Corcovado]

Ja klar, wie gesagt, ging es hier eher um eine spitzfindige Diskussion, die ich selber hatte und nun mal die Profis in Sachen Java fragen wollte, was Ihr davon haltet. Ich weiss nur dass C/C++ Programmierer da teilweise Schweissausbrueche bekommen, wenn sie cnt++ sehen

Das mit den Objekten ist aber auch nur deswegen, wegen dem & Operator (es kommt ja drauf an ob der Term links oder rechts steht, so wie beim +=)

Naja, was ich hier meinte ist, folgendes:

const TypeObjectVonCnt operator++(int) // gibt in C++ eindeutig ein konstantes Objekt zurueck
// und
TypeObjectVonCnt& operator++() // gibt in C++ eindeutig eine Referenz(addresse) zurueck, und zwar die Adresse
// eben des Ergebnisses, afaik gibt es hier in C++ keine Alternative zur Syntax "TypeObjectVonCnt&"

Daher is es kein Problem der Schreibweise, da man diese Problem auch hat, wenn man eben die default Implementation von operator++ nimmt, ihn also nicht ueberlaed.


Vielleicht sollte ich mal "effektiv Java" lesen um die "wirklichen" Performance Fallen zu erkennen
Ich dachte nur, dass es bei Java als Hochsprache noch um einiges wichtiger ist auf Performance zu achten und
das man bei Java zwar weniger mit Zeigern kaempft aber dafuer sich mit der gleichen Muehe und Intensitaet um Performance kuemmern sollte.

 

[Bleiglanz]

... man sollte sich schon über Performance gedanken machen, besonders in der Lernphase

aber nicht, da sollte man versuchen "schöne" und "klare" Programme zu schreiben,

, wenn man wirklich mal etwas schneller machen will,

braucht man schon ein gewisses Fachwissen und Erfahrung, damit man überhaupt die richtigen "Optimierungen" findet

 

[KSG9|sebastian]

zeroptimieren ist angesagt ;D

 

[thE_29]

Also wenn man schweißausbrüche bei einem ++ bekommt ist man

1. ein byte zähler (hallo, wir leben im 21. jhdt, die meisten haben > 512 RAM und nima 32!)

2. die typischen Programmiernerds ;> (hey, das i++ ist um 2 millseks langsamer als das ++i, du kannst ja gar net proggen...)


Im int Bereich (sprich 2 Bytes in C/C++) ist es egal ob i++ oder ++i, da das so schnell gemacht wird (21. jhdt net vergessen... Prozis > 3 GHZ) das man da sowieso nix bemerkt!

Anders siehts aus wenn man Operatoren für riesige Klassen selbst überschreibt, sprich Planet++ oder ++Planet (da ist wahrscheinlich was zu messen).

Aber bei einer for/while/etc Schleife wird das net so tragisch sein!

 

[Akimor]

2 msec...
Nich wirklich, außer ich hab was falsch verstanden und ihr redet hier ueber µc's und nich ueber Microprozessoren...
20 Nanosec kommen wohl eher hin...

Zum Vergleich, ein Microcontroller mit 16MHz (8051 Serie) braucht fuer fuer den Befehl "inc A" also increment Akku etwa 1msec :meld:
(Atmels sind etwas schneller)

ein Microprozessor mit 3.2GHz hat eine 2*10² hoehere Taktung, und muesste somit (theoretisch) nur 10 nsec brauchen...
Allerdings verzoegern Programmiersprachen wie C++ und Java die Sache noch etwas, aber mit Assambler duerften 10 nsec wohl hinkommen

(Ja, ich beschaeftige mich auch sehr viel mit µc's. Genauer gesagt mit einem Atmel Mega16 TQFP44 8-Bit AVR-RISC Controller)

 

[Corcovado]

LOL
Tja meine Kiste hier hat grad mal 450 MHz - aber egal, es laeuft trotzdem und eigentlich brauch ich auch nich mehr zum schreiben, 2msec waeren aufm 3GHz allerdings schon fast ein Grund fuer mich Ich wuerd es auch eher im nsec Bereich vermuten

Danke - Euch fuer die Antworten