Operatoren i=i++; Was passiert hier?

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
 
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:
Java:
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.
 
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:
Java:
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
 
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:
Java:
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).
 
Frage: Was wird warum hier ausgegeben oder hier nicht ausgegeben werden?
Java:
		int i = 0;
		i = (i = i++);
		++i;
		i = (i = ++i);
		System.out.println(i);
Andere Konstrukte sind leider nicht korrekt. ;)
 
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:
Java:
int i = 1;
i = 1 + i++;
i bekommt eine eigene Adresse im Speicher.
Java:
int tmp = i;
Jetzt erfolgt die Addition dann die Zuweisung
Java:
int i = 1+i
Dann
Code:
tmp++;
Ergebnis = 2
 
Am besten sieht man die Reihenfolge am Beispiel:
Java:
int i = 1;
i = 1 + i++;
i bekommt eine eigene Adresse im Speicher.
Java:
int tmp = i;
Jetzt erfolgt die Addition dann die Zuweisung
Java:
int i = 1+i
Dann
Code:
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.
 
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;

:)
 
Dieses Programm:
Java:
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):
Code:
// 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
}
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben