# i++ vs ++i



## Hilefoks (25. Mai 2007)

Moin,

in C oder C++ benutze ich aus Gründen der Performance immer ++i anstelle von i++, wann immer das möglich ist. Allerdings finde ich i++ schöner anzusehen. Jetzt stellte sich mir die Frage nach der Performance dieser beiden in Java. Prinzipiell muss i++ langsamer als ++i sein, allerdings könnte der Compiler oder die JVM das auch entsprechend optimieren. Die Frage ist nur: tut Java das auch? Hat jemand entsprechende Quellen?

MfG,
Hilefoks


----------



## L-ectron-X (25. Mai 2007)

Hilefoks hat gesagt.:
			
		

> Prinzipiell muss i++ langsamer als ++i sein...


Warum das?


----------



## Hilefoks (25. Mai 2007)

In C und C++ bei Post-Increment muss der Compiler zuerst eine Kopie des Objektes erzeugen, dann die Methode des Objektes aufrufen, und schließlich die Kopie wieder verwerfen (oder verwenden wenn sie noch gebraucht wird). Daher soll man in C/C++ Code Pre-Increment verwenden.

MfG,
Hilefoks


----------



## Murray (26. Mai 2007)

Möglicherweise ist das in Java einfacher, weil es kein Operator-Overloading gibt - insofern sollte es nicht notwendig sein, aufgrund dieser Operatoren komplexe Objekte zu kopieren; diese Operatoren kann man ja nur für primitive Typen verwenden.


----------



## KSG9|sebastian (26. Mai 2007)

Wen mich nicht alles täuscht ist ++i minimal schneller. Wir haben mit der 1.4er Version mal diverse solcher Spielereien analysiert, u.a. auch diverse Spielerein mit for-Schleifen.

Wenn ich mich recht entsinne ist folgendes die non-plus-ultra Performance-Schleife:


```
List a = ...

for(int i=0, j=a.size(); i<j; ++i){
 ...
}
```


----------



## Hilefoks (26. Mai 2007)

Murray hat gesagt.:
			
		

> Möglicherweise ist das in Java einfacher, weil es kein Operator-Overloading gibt - insofern sollte es nicht notwendig sein, aufgrund dieser Operatoren komplexe Objekte zu kopieren; diese Operatoren kann man ja nur für primitive Typen verwenden.


i++ ist nicht nur durch Operator-Overloading in C/C++ langsamer (C kennt sowas auch nicht). Bei i++ muss der Compiler zunächst den alten Wert auf den Stack legen, dann alten Wert mit 1 addiert auf den Stack legen und dann kann er den weiteren Ausdruck verarbeiten. Bei einem i++; bedeutet dies eine unötige Stack-Operation die natürlich Zeit kostet. Bei ++i legt der Compiler aber gleich i+1 auf den Stack.

Grundsätzlich muss jeder Compiler (ausser der von Perl) dies machen. Allerdings könnte der Compiler erkennen das der ursprüngliche Wert nicht benötigt wird und hier optimierend eingreifen. Meine Frage ist jetzt ob es eine Spezifikation oder der gleichen gibt, die sagt das der Java-Compiler/die JVM dies optimiert?


----------



## Ark (26. Mai 2007)

KSG9|sebastian hat gesagt.:
			
		

> ```
> List a = ...
> 
> for(int i=0, j=a.size(); i<j; ++i){
> ...


Ich würde, ohne einen Test durchgeführt zu haben, behaupten, dass für denn Fall, dass die Abarbeitungsreihenfolge egal (oder eben genau wie folgend) ist, dies hier optimal sei:

```
for(int i=a.size()-1 ; i>=0 ; --i){
 ...
}
```
Ark


----------

