ich beschäftige mich seit einiger Zeit mit C++, bin aber gerade auf etwas gestossen, das ich nicht ganz verstehe.

Ich habe folgendes Minimalprogramm:

include<iostream>
unsing namespace std;

int main()
{
  int x=2;
  cout << (++x)*(++x) << endl; // liefert als Ausgabe : 4*4=16
  x=2;
  cout << (++x)*(++x)*(++x) << endl; // liefert als Ausgabe: 4*4*5=80
}

Mir ist nicht verständlich, warum bei der ersten Ausgabe nicht (2+1)(3+1)=12 und bei der 2ten Ausgabe nicht (2+1)(3+1)*(4+1)=60 geliefert wird.
Ich vermute, das hängt mit der Hierarchie der Inkrement- und Multiplikationsoperatoren zusammen. Hat jemand hierfür eine Erklärung ?
Vielen Dank im Voraus.

Ich vermute, das hängt mit der Hierarchie der Inkrement- und Multiplikationsoperatoren zusammen. Hat jemand hierfür eine Erklärung ?

Es gibt keine Erklärung. Was passiert ist undefiniert.

Das erste Beispiel kann jede Kombination von [3|4][3|4]=[9|12|16] ausgeben, kann jede Kombination aus [3|4|5][3|4|5]*[3|4|5] sein, die Spannweite reicht von 27 bis hin zu 125.

erstmal vielen Dank für die Antwort. Warum ist das Ergebnis undefiniert ? Es wird doch eine int Variable x mit 2 initialisiert und eine Operation mit (++x) (hier ist also ++x eindeutig der Wert 3 zugeweisen, oder ?) an den cout Ausgabestrom übergeben.
Der gcc Compiler rechnet in jedem Falle die angegebenen Ergebnisse aus. Diese variieren nicht, insofern kann ich deine Antwort noch nicht ganz nachvollziehen und würde mich freuen, wenn du mit noch einen kleinen Tipp zum Verständnis geben könntest.
Besten Dank im Voraus !

also das hier ist undefiniert:

int x = 2;
x = ++x + --x;
x = ++x * ++x + --x;
// und alles andere darusfolgende

steht jedoch ein logischer operator dazwischen (also && oder ||), ist es wiederum erlaubt

da gabs ein fachausdruck für wie das heisst, aber der fällt mir nicht mehr ein

erstmal vielen Dank für die Antwort. Warum ist das Ergebnis undefiniert ? Es wird doch eine int Variable x mit 2 initialisiert und eine Operation mit (++x) (hier ist also ++x eindeutig der Wert 3 zugeweisen, oder ?) an den cout Ausgabestrom übergeben.

Der C++ Standard definiert nicht wann genau die Seiteneffekte von ++ eintreten. Das einzige was sicher ist ist dass x nach dem ganzen Ausdruck um 2 inkrementiert wurde. Aber wann genau die einzelnen Inkrements passieren ist undefiniert, d.h. der Compiler kann machen was er will.

Jochen911 schrieb:

Der gcc Compiler rechnet in jedem Falle die angegebenen Ergebnisse aus. Diese variieren nicht, insofern kann ich deine Antwort noch nicht ganz nachvollziehen und würde mich freuen, wenn du mit noch einen kleinen Tipp zum Verständnis geben könntest.

Dann ist das eben was der gcc in dem Fall macht. Ein anderer Compiler macht was andres...

Skym0sh0 schrieb:

da gabs ein fachausdruck für wie das heisst, aber der fällt mir nicht mehr ein

Du meinst wohl Sequence Point.

vielen Dank für die Antwort !!

Warum ist das Ergebnis undefiniert ? Es wird doch eine int Variable x mit 2 initialisiert und eine Operation mit (++x) (hier ist also ++x eindeutig der Wert 3 zugeweisen, oder ?)

nein, weil nicht definiert ist, welche der Operation zuerst vollständig(!) ausgeführt wird. Im C++-Standard ist diese Operation ausdrücklich als undefiniert spezifiziert:

Kapitel 5 Expressions; Absatz 4

Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression.
[Example:
i = v[i++]; // the behavior is unspecified
i = 7, i++, i++; // i becomes 9
i = ++i + 1; // the behavior is unspecified
i = i + 1; // the value of i is incremented
—end example]

man beachte insbesondere die Zeile 'i = ++i + 1;' - natürlich muss der Wert (aber nicht der Speicher!) von i zuerst um 1 erhöht werden, bevor zusätzlich 1 addiert wird, aber es ist nicht definiert, wann der inkrementierte Wert an den Speicher von i zugewiesen wird. Vor oder nach der Zuweisung an das i durch den operator=. Also das Ergebnis darf sowohl i+1 als auch i+2 sein - beides wäre denkbar.

Kapitel 5 Expressions; Absatz 4

Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression.
[Example:
i = v[i++]; // the behavior is unspecified
i = 7, i++, i++; // i becomes 9
i = ++i + 1; // the behavior is unspecified
i = i + 1; // the value of i is incremented
—end example]

man beachte insbesondere die Zeile 'i = ++i + 1;' - natürlich muss der Wert (aber nicht der Speicher!) von i zuerst um 1 erhöht werden, bevor zusätzlich 1 addiert wird, aber es ist nicht definiert, wann der inkrementierte Wert an den Speicher von i zugewiesen wird. Vor oder nach der Zuweisung an das i durch den operator=. Also das Ergebnis darf sowohl i+1 als auch i+2 sein - beides wäre denkbar.

Nach dem ersten Satz müsste das Verhalten undefiniert sein, da i zweimal modifiziert wird. Wieso ist es nur unspezifiziert?

Im vorliegenden Fall ist die Auswertereihenfolge aber grundsätzlich durch die Implementierung festgelegt. Darauf kann man sich zwar nicht verlassen, es steht nicht in der Doku, es kann bei verschiedenen Compilern, Compilerversionen und sogar verschiedenen Ausdrücken unterschiedlich sein, aber theoretisch könnte es mir der Compilerhersteller für einen bestimmten Ausdruck in einem bestimmten Kontext sagen. Es ist also "nur" unspezifiziert.

Edit: ach so, du beziehst dich wohl auf Werners Antwort. Ich dachte du meinst den Standard.

Werner_logoff schrieb:

Kapitel 5 Expressions; Absatz 4

Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression.
[Example:
i = v[i++]; // the behavior is unspecified
i = 7, i++, i++; // i becomes 9
i = ++i + 1; // the behavior is unspecified
i = i + 1; // the value of i is incremented
—end example]

man beachte insbesondere die Zeile 'i = ++i + 1;' - natürlich muss der Wert (aber nicht der Speicher!) von i zuerst um 1 erhöht werden, bevor zusätzlich 1 addiert wird, aber es ist nicht definiert, wann der inkrementierte Wert an den Speicher von i zugewiesen wird. Vor oder nach der Zuweisung an das i durch den operator=. Also das Ergebnis darf sowohl i+1 als auch i+2 sein - beides wäre denkbar.

Nach dem ersten Satz müsste das Verhalten undefiniert sein, da i zweimal modifiziert wird. Wieso ist es nur unspezifiziert?

Weil das Beispiel fehlerhaft kommentiert ist, das trifft ja noch auf ein paar andere Beispiele im Standard zu, also mit Vorsicht genießen. Beispiele sind sowieso nicht normativ.

undefined behavior
behavior for which this International Standard imposes no requirements

unspecified behavior
behavior, for a well-formed program construct and correct data, that depends on the implementation

Naja whatever. Im Prinzip ist es ja auch egal, in beiden Fällen sollte man es in keinem Programm haben.

Weil das Beispiel fehlerhaft kommentiert ist, das trifft ja noch auf ein paar andere Beispiele im Standard zu, also mit Vorsicht genießen.

Danke für die Bestätigung.

@Jochen911
Ich hoffe, dass die Frage aus reinem Interesse ist und dass du nicht vor hast, jemals etwas derartiges in deinem Code zu verwenden.

Hallo icarus2,

ja, du hast recht, die Frage war nur interessehalber (bin zufällig darauf gestossen, als ich mich mit Makros beschäftigt habe):

z.B. ist so etwas gefährlich :

#define QUAD(x) (x*x)

Nutzt man nämlich irgendwo im Source Code

QUAD(++x)

kommt genau die besprochene Undefiniertheit ins Spiel.

Nutzt man dagegen eine inline Funktionsdefinition wie folgt

inline int quad( int x) 
{
return (x*x);
}

tritt beim Aufruf

int x = 2;
cout << quad (++x);

keine Undefiniertheit auf.

Selbstverständlich würde ich so etwas nicht programmieren, war reines Interesse.
Danke nochmal an alle, die sich an der Diskussion beteiligt haben.