Java vs. C-Ausgabe

Question

Das mag einfach erscheinen, aber ich und meine Freunde sind einfach gestolpert...

Nehmen wir den folgenden Codeabschnitt. in Java

//........

int a=10;
a= a-- + a--;
System.out.print("a="+a);
//........

in c

//........

int a=10;
a= a-- + a--;
printf("a= %d",a);
//.......

wobei im ersten Fall die Ausgabe 19 und in C die Ausgabe 18 lautet. Die Logik in C ist verständlich, aber in Java?

in java, wenn es wie

int a=10;
a=a++;

in diesem Fall ist die Ausgabe 10.

Was ist also die Logik?

Answer 1

a = a-- + a-- verursacht undefiniertes Verhalten in C. C definiert nicht, welches Dekrement zuerst ausgewertet werden soll.

a-- den Wert von a auswertet und danach a dekrementiert, also in Java a = a-- + a-- wird wie folgt ausgewertet:

a = (10, Dekrement a) + (9, Dekrement a)

Der zweite Operand ist 9, weil der erste Term a dekrementiert hat.

Zusammenfassend: Bei diesem Ausdruck legt C die Auswertungsreihenfolge nicht fest. Java definiert sie von links nach rechts.

Answer 2

Ich weiß nicht, wie es in Java ist, aber in C hat diese Codezeile keinen in der Norm definierten Rückgabewert. Den Compilern steht es frei, sie nach eigenem Gutdünken zu interpretieren.

Answer 3

In dem Ausdruck

a = a-- + a--;

Sie haben viele Unterausdrücke, die ausgewertet werden müssen, bevor der gesamte Ausdruck ausgewertet wird.

a = a-- + a--;
          ^^^ <= sub-expression 2
    ^^^       <= sub-expression 1

Was ist der Wert des Unterausdrucks 1? Es ist der aktuelle Wert des Objekts a .
Was ist der Wert des Objekts a ?

Wenn der Unterausdruck 2 bereits ausgewertet wurde, wird der Wert des Objekts a ist 9, sonst ist es 10.

Dasselbe gilt für den Unterausdruck 2. Sein Wert kann entweder 9 oder 10 sein, je nachdem, ob Unterausdruck 1 bereits ausgewertet wurde.

Der C-Compiler (weiß nicht, wie es mit Java aussieht) kann die Teilausdrücke in beliebiger Reihenfolge auswerten

Nehmen wir also an, der Compiler hat sich dafür entschieden, die -- s zum Schluss

a = 10 + 10;
a--; /* 19 */
a--; /* 18 */

aber bei der nächsten Kompilierung hat der Compiler die -- s im Vordergrund

/* value of sub-expression 1 is 10 */
/* value of sub-expression 2 is 9 */
a = 10 + 9; /* a = 9 + 10; */

oder es könnte sogar eine der a-- und verwenden Sie dies für den endgültigen Wert von a

/* sub-expression 1 yields 10 and sets the value of `a` to 9 */
/* so yield that 10, but save the value for the end */
a = 10 + ???;
a = 18???; a = 19???;
/* remember the saved value */
a = 9

Da Sie ein undefiniertes Verhalten aufgerufen haben, könnte es Ihre Anweisung einfach durch eine der folgenden ersetzen

• a = 42;
• /* */
• fprintf(stderr, "BANG!");
• system("Format C:");
• for (p=0; p<MEMORY_SIZE; p++) *p = 0;
• usw. ...

Answer 4

Sie befinden sich in der Nachdeklination. Für mich macht das Java-Ergebnis mehr Sinn.

Das erste a-- wird als 10 ausgewertet und auf 9 dekrementiert. 10 ist der Wert dieses Unterausdrucks.

Das zweite a-- wird ausgewertet. a ist jetzt 9 und wird auf 8 dekrementiert. Der Wert dieses Unterausdrucks ist 9.

Es wird also 10 + 9 = 19. Die beiden Dekremente werden durch die Zuweisung überschrieben.

Ich würde 18 erwarten, wenn der Ausdruck a= --a + --a wäre.

Haben Sie versucht, die C-Version mit verschiedenen Optimierungsflags zu kompilieren?

Answer 5

a = 10 + 9

Sie können es mit versuchen:

a = a-- + a-- + a--

es wird 27 ( 10 + 9 + 8) zurückgegeben...