Is x=x++; Undefined Behavior?

The output of the following code:

Code:

---

x = 10;
x = x++;
printf("%d\n",x);

---

is 11.

What is not clear to me is: does the increment on x happen before or after the attribution? And is this considered undefined behavior?

What about "x=++x;", is it legal C or undefined behavior?

Update: Yep, looks like this is undefined behavior.

Question 3.3

[snip]

Apparently it's undefined so my comments about it also being pointless are...pointless.

Ops. Sorry about that.

Just to help other people coming to this thread, yeah it seems that what I asked is indeed undefined behavior.

first off, a lot of things that are undefined behavior are legal C code. this seems to be one of those cases. testing this exact code on linux with gcc produces the result of 11 as you observe.

when I turn on lots of warnings (-Wall -Wextra -pedantic) I get

Code:

---

warning: operation on 'x' may be undefined [-Wsequence-point]

---

so you're probably experiencing one implementation's behavior when fed this particular bit of nonsense :)

Quote:

---

Originally Posted by Elkvis

first off, a lot of things that are undefined behavior are legal C code.

---

Sorry, that is not true.

Firstly, undefined behaviour is not C code. It is a description of the effects that code might have have.

Undefined (as the standard defines "undefined") behaviour means that the standard defines no constraints on what effects the code produces.

Once we get past that, we get to the question of what do you mean by "legal C code"?

If you mean code that is guaranteed, by the standard, to produce consistent results when ported between compilers or operating systems, then any code that invokes undefined behaviour is not legal C code. Because, by definition, consistent results are not guaranteed between implementations.

If you mean code that can be compiled without errors or warnings, then undefined behaviour is also not legal. One acceptable response by any compiler with code exhibiting undefined behaviour is issuing a diagnostic and failing to compile the code. Another compiler might not complain about the code, but that does not make the code legal by this definition.

The only thing that is "legal" about undefined behaviour is that the compiler still conforms with the standard, no matter what it does. It can issue warnings, or not. It can successfully compile the code, or not. The code, when executed, can produce results you expect .... or not.

If you define "legal" to mean "compiler X accepts the code without issuing diagnostics" then your definition is too narrow. The code can still fail to compile when you update the compiler.