Zuweisungen - Reihenfolge

[UdoKessler]

Hallo zusammen,

habe eine kleine Frage zu Zuweisungen:

int x = 10; y = 10;
x+= y+= x+= y;

Bei dieser Zuweisung wird ja von rechts nach links gelöst, da alle
Operatoren die gleiche Rangordnung haben (nur "+").

Als Ergebnis hätte ich x=50 und y = 30 erwartet, weil ich die Berechnung so vermutet
hab: (v.r.n.l.) x10+y10 (x=20, y=10); y10+x20 (x=20, y=30); x20+y30 (x=50, y=30)

Als Endergebnis also x=50, y=30.
Es kommt aber für x 40 raus.
Wieso?

Gruß
Udo

 

[SvenK]

Na auf die Antwort bin ich jetzt auch gespannt :rtfm:???:L

 

[andre111]

ähm ja also ka:shock::bahnhof:???:L

 

[fjord]

[highlight=java]public static void main(String[] args) {
int x = 10;
int y = 10;
x+= y+= x+= y;
}[/highlight]

sieht nach dem compilieren so aus:

public static void main(java.lang.String[]);
  Code:
   0:   bipush  10
   2:   istore_1
   3:   bipush  10
   5:   istore_2
   6:   iload_1
   7:   iload_2
   8:   iload_1
   9:   iload_2
   10:  iadd
   11:  dup
   12:  istore_1
   13:  iadd
   14:  dup
   15:  istore_2
   16:  iadd
   17:  istore_1
   18:  return

Das heißt die Werte werden von links nach rechts auf den Stack gepushed und dann von rechts nach links ausgewertet.
Reicht das schon als Erklärung, oder willst du genauer wissen was die JVM da macht?

 

[FatFire]

Puh, also, ohne mir ganz sicher zu sein, schätze ich mal, dass da irgendwas im Cache gehalten wird, und ansonsten einfach aus dem Speicher nachgeladen wird...also, es darf nur eine Version von x und y gleichzeitig im Cache sein, und nur was am Ende im Cache liegt, wird auch in den normalen Speicher zurückgeschrieben. Stelle mir das ungefähr so vor:

X und Y werden jeweils mit 10 in den Cache geholt.
Y wird auf X addiert, also X mit 20 im Cache. Da die nächste Operation auch mit X, bleibt 20 im Cache und Y wird mit 10 aus dem Speicher geholt. Dort werden die 20 aufaddiert.
Nächste Operation werden die 30 von Y im Cache gehalten, das X wird aber aus dem Speicher geholt, da die Operation immer noch nicht beendet und zugewiesen wurde. Deshalb werden nur 10 bei X mitgenommen und die 30 aufaddiert. Wenn man also jetzt das Spiel noch einmal treiben würde, hätten wir die 40 von X im Cache, Y wird nachgeladen (immer noch nur 10), demzufolge im nächsten Schritt 50 für Y. Erst wenn die Operation komplett beendet ist, werden die Werte für X und Y in den Speicher geschrieben und die Änderung somit dauerhaft festgelegt.

Einer der Gründe warum Zuweisungsoperationen immer molekular sein sollten.

Edit: @fjord: Streber :bae:

 

[SlaterB]

> Erst wenn die Operation komplett beendet ist, werden die Werte für X und Y in den Speicher geschrieben und die Änderung somit dauerhaft festgelegt.

nicht ganz, siehe auch Beispiel

int x = 0;
int y = 10;
x = (y += 5) + (y * 1000);
System.out.println("x " + x + ", " + y);

Auswertung von links nach rechts ist der Schlüssel, je linker eine Variable steht, desto älter ist ihr Wert

und bei
x +=
kann man sich
x = x + ..
denken, das erste x rechts wird dann der ursprüngliche Wert sein

 

[FatFire]

Naja, aber für einen Schuss ins Blaue schon ein guter Erklärungsversuch. Ich hatte meinen Beitrag ja zeitgleich zu Fjord verfasst, hab mir aber noch nie die Mühe gemacht, mal wirklich in den Bytecode zu schauen. Hätte ich bei der Fragestellung aber vielleicht doch gleich mal tun sollen, jetzt ist es natürlich viel klarer

 

[UdoKessler]

Danke für eure Antworten!
Hab verstanden und mein Verdacht (nach etwas grübelei) ging auch
in die Richtung.

@fjord
Deine Auflistung hast Du aus dem Bytecode, oder wie lässt Du Dir
das anzeigen?
Nein, eine genauere Erklärung ist nicht nötig, danke!


Gruß
Udo

 

[Illuvatar]

@fjord
Deine Auflistung hast Du aus dem Bytecode, oder wie lässt Du Dir
das anzeigen?
Nein, eine genauere Erklärung ist nicht nötig, danke!

javap -c <Klasse>

 

[UdoKessler]

Cool danke