Operatoren i=i++; Was passiert hier?

[SafeDebagger]

Grüzi an die Informatik Community!
Laut Schulbuch führt i = i++; zu keiner Veränderung von i. Das würde ich akzeptieren, wenn ich es verstehen kann. Bitte um Aufklärung

LG

der hohe SafeDebagger

 

[Blender3D]

Das würde ich akzeptieren, wenn ich es verstehen kann.

Bei der Zuweisung bekommt i eine neue Adresse im Speicher.
Der Post Increment Operator erhöht erst nach der Zuweisung das i in der ursprünglichen Adresse von i um 1.
Diese Speicher wird später aber verworfen. Übrig bleibt i = 1;

 

[mrBrown]

Laut Schulbuch führt i = i++; zu keiner Veränderung von i. Das würde ich akzeptieren, wenn ich es verstehen kann. Bitte um Aufklärung

i++ erhöht erst i um 1, und gibt dann den alten Wert von i zurück, und i wird danach auf diesen Wert gesetzt.

Wenn man das etwas aufdröselt, ist's leichter versändlich:

int tmp = i;
i = i + 1; // i wird um 1 erhöht
i = tmp; // i wird auf den alten Wert gesetzt

Bei der Zuweisung bekommt i eine neue Adresse im Speicher.
Der Post Increment Operator erhöht erst nach der Zuweisung das i in der ursprünglichen Adresse von i um 1.
Diese Speicher wird später aber verworfen. Übrig bleibt i = 1;

Ich bin mir nicht sicher, ob das irgendwie das richtige meinen könnte, aber das klingt einfach völlig falsch.

 

[SafeDebagger]

i++ erhöht erst i um 1, und gibt dann den alten Wert von i zurück, und i wird danach auf diesen Wert gesetzt.

Wenn man das etwas aufdröselt, ist's leichter versändlich:

int tmp = i;
i = i + 1; // i wird um 1 erhöht
i = tmp; // i wird auf den alten Wert gesetzt

Ich bin mir nicht sicher, ob das irgendwie das richtige meinen könnte, aber das klingt einfach völlig falsch.

Macht für mich keinen Sinn

 

[httpdigest]

Macht für mich keinen Sinn

Ist aber dennoch die richtige Antwort. Der Ausdruck `i++` bedeutet: "Lese den Wert von i und 'merke' ihn dir. Anschließend inkrementiere die Variable `i`. Das 'Merken' findet in der Praxis in einem Prozessor-Register statt. Das Ergebnis des Ausdrucks `i++`, also der Wert, den dieser Ausdruck "generiert" für weitere nachfolgende Operatoren in dem Gesamtausdruck, ist aber der aktuelle Wert von `i` vor der Inkrementierung. Danach wird `i` inkrementiert, das beeinflusst aber nicht mehr, welcher Wert für weitere Operatoren verwendet wird.

Der "Pseudo-Code" von mrBrown:

int tmp = i;
i = i + 1; // i wird um 1 erhöht
i = tmp; // i wird auf den alten Wert gesetzt

ist exakt, was tatsächlich passiert. Nur dass eben die künstliche Variable `tmp` einfach ein Register ist (also keine lokale Variable im Sinne der JVM).

 

[Xyz1]

Oder ganz platt: i wird erst nach der (Bearbeitung: Setzung) von i inkrementiert. Infolgedessen passiert nix.

 

[httpdigest]

Oder ganz platt: i wird erst nach der Änderung von i inkrementiert. Infolgedessen passiert nix.

Das ist zu knapp formuliert und auch falsch, weil unklar ist, was du genau mit "Änderung von i" meinst. `i` wird eben nicht nach, sondern vor der Zuweisung an `i` inkrementiert.

 

[mrBrown]

Oder ganz Platt: i wird erst nach der Änderung von i inkrementiert. Infolgedessen passiert nix.

Eigentlich wird i vor der Änderungen inkrementiert (angenommen i ist zu Beginn 1, dann wird erst i auf 2 erhöht, und danach (zurück-) geändert auf 1).

 

[Xyz1]

Das ist zu knapp formuliert und auch falsch, weil unklar ist, was du genau mit "Änderung von i" meinst. `i` wird eben nicht nach, sondern vor der Zuweisung an `i` inkrementiert.

Habe ein Edit eingefügt. Mit Änderung meinte ich Setzung/Zuweisung.

 

[mrBrown]

Habe ein Edit eingefügt. Mit Änderung meinte ich Setzung/Zuweisung.

Sowohl in der Antwort von @httpdigest als auch meiner könnte man jetzt Änderung genauso durch "Setzung/Zuweisung" ersetzen...

 

[Xyz1]

Ist ja schon gut.

 

[Xyz1]

Frage: Was wird warum hier ausgegeben oder hier nicht ausgegeben werden?

		int i = 0;
		i = (i = i++);
		++i;
		i = (i = ++i);
		System.out.println(i);

Andere Konstrukte sind leider nicht korrekt. 😉

 

[mihe7]

Macht für mich keinen Sinn

LOL. Das liegt evtl. daran, dass Du damit nichts anzufangen weißt 🙂

Überleg mal, was hier

int pos = 0;
arr[pos++] = wert;
arr[pos++] = wert;

und was hier

int pos = 0;
arr[++pos] = wert;
arr[++pos] = wert;

passiert.

 

[SafeDebagger]

im ersten 0 und 1 als pos und im zweiten 1 und 2 (weil präfix-notation)

 

[mihe7]

Jo, dann hast Du doch den Sinn 🙂

 

[Xyz1]

ja, jedenfalls verschluckt die fiese Zuweisung das inc...

 

[Blender3D]

int tmp = i; i = i + 1; // i wird um 1 erhöht i = tmp; // i wird auf den alten Wert gesetzt

Am besten sieht man die Reihenfolge am Beispiel:

int i = 1;
i = 1 + i++;

i bekommt eine eigene Adresse im Speicher.

int tmp = i;

Jetzt erfolgt die Addition dann die Zuweisung

int i = 1+i

Dann

tmp++;

Ergebnis = 2

 

[mrBrown]

Am besten sieht man die Reihenfolge am Beispiel:

int i = 1;
i = 1 + i++;

i bekommt eine eigene Adresse im Speicher.

int tmp = i;

Jetzt erfolgt die Addition dann die Zuweisung

int i = 1+i

Dann

tmp++;

Ergebnis = 2

Ich habe ganz ehrlich keine Ahnung, was du damit sagen willst. Weder passen deine einzelnen Zeilen zu dem Block, noch gibt es da irgendwo eine inkrementierung von tmp.
Das Ergebnis von i=i++ hat nichts mit irgendwelchen Speicheradressen zu tun, sondern ist einfach nur das definierte Verhalten und völlig ohne irgendeinen Speicher erklärbar.

 

[mihe7]

Ich bin mir nicht sicher, ob das irgendwie das richtige meinen könnte, aber das klingt einfach völlig falsch.

Bei der Zuweisung bekommt i eine neue Adresse im Speicher.

int tmp = i;

Der Post Increment Operator erhöht erst nach der Zuweisung das i in der ursprünglichen Adresse von i um 1.

i=i+1;

Diese Speicher wird später aber verworfen. Übrig bleibt i = 1;

i=tmp;

🙂

 

[Meniskusschaden]

Dieses Programm:

package increment;

public class Increment {

    public static void main(String[] args) {
        int i;
        i=8;
        i=i++;
    }

}

führt zu folgendem Bytecode (siehe kommentierte Zeilen):

// Compiled from Increment.java (version 10 : 54.0, super bit)
public class increment.Increment {
 
  // Method descriptor #6 ()V
  // Stack: 1, Locals: 1
  public Increment();
    0  aload_0 [this]
    1  invokespecial java.lang.Object() [8]
    4  return
      Line numbers:
        [pc: 0, line: 3]
      Local variable table:
        [pc: 0, pc: 5] local: this index: 0 type: increment.Increment
 
  // Method descriptor #15 ([Ljava/lang/String;)V
  // Stack: 1, Locals: 2
  public static void main(java.lang.String[] args);
    0  bipush 8       // 8 wird auf den Stack gelegt
    2  istore_1 [i]   // 8 wird vom Stack entfernt und in Variable i gespeichert
    3  iload_1 [i]    // 8 wird aus Variable i gelesen und auf Stack gelegt
    4  iinc 1 1 [i]   // Variable i wird inkrementiert und enthält jetzt 9
    7  istore_1 [i]   // 8 wird vom Stack entfernt und in Variable i gespeichert. i enthält wieder 8.
    8  return
      Line numbers:
        [pc: 0, line: 7]
        [pc: 3, line: 8]
        [pc: 8, line: 9]
      Local variable table:
        [pc: 0, pc: 9] local: args index: 0 type: java.lang.String[]
        [pc: 3, pc: 9] local: i index: 1 type: int
}

 

[Blender3D]

Weder passen deine einzelnen Zeilen zu dem Block, noch gibt es da irgendwo eine inkrementierung von tmp

Die Variable tmp habe ich nur von Dir übernommen, um den Zwischenspeicher zu verdeutlichen. (War Deine Idee)
Genauer erklärt wird das ganze von @Meniskusschaden

3 iload_1 // 8 wird aus Variable i gelesen und auf Stack gelegt: : tmp = i;
4 iinc 1 1 // Variable i wird inkrementiert und enthält jetzt 9 : i++;
7 istore_1 // 8 wird vom Stack entfernt und in Variable i gespeichert. i enthält wieder 8. i = tmp;

 

[mrBrown]

Die Variable tmp habe ich nur von Dir übernommen, um den Zwischenspeicher zu verdeutlichen. (War Deine Idee)
Genauer erklärt wird das ganze von @Meniskusschaden

3 iload_1 // 8 wird aus Variable i gelesen und auf Stack gelegt: : tmp = i;
4 iinc 1 1 // Variable i wird inkrementiert und enthält jetzt 9 : i++;
7 istore_1 // 8 wird vom Stack entfernt und in Variable i gespeichert. i enthält wieder 8. i = tmp;

Ich bezog mich ja auch auf das Inkrementieren von tmp, nicht auf nur tmp 🙂

Mit tmp (bzw Stack/Register) wird halt nichts gemacht, da landet kurz der Wert von i um danach wieder zurückgeschrieben zu werden.


Edit: Um bei deinem Beispiel zu bleiben:

int i = 1;
i = 1 + i++;

Ist äquivalent zu:

int i = 1;
int tmp = i;
i++;
i = 1 + tmp;

Da gibts einfach kein tmp++