Increment and Decrement operators

Question

How are the below valid and invalid as shown and what do they mean. When would such a situation arise to write this piece of code.

++x = 5;     // legal
--x = 5;     // legal
x++ = 5;     // illegal
x-- = 5;     // illegal

Answer 1

The postfix (x++/x--) operators do not return an lvalue (a value you can assign into).

They return a temporary value which is a copy of the value of the variable before the change

The value is an rvalue, so you could write:

y = x++ and get the old value of x

Answer 2

Those all modify the value of x more than once between sequence points, and are therefore undefined behavior, which you should carefully avoid. I don't see where the distinction between "legal" and "illegal" comes in - since the behavior is legal, any behavior (including sending assorted email to the Secretary of State) is perfectly in accordance with the Standard.

Answer 3

Assuming that the question is about built-in ++ and -- operators, none of these statements are strictly legal.

The first two are well-formed, i.e. they merely compilable because the result of prefix increment is lvalue. The last two are ill-formed, since the result of postfix increment is not a rvalue, which is why you can't assign to it.

However, even the first two are not legal in a sense that they produce undefined behavior. It is illegal to modify the same object more than once without an intervening sequence point. (Note also, that compilers are allowed to refuse to compile well-formed code that produces undefined behavior, meaning that even the first pair might prove to be non-compilable).

Answer 4

Given that both operator=() and operator++() can be overloaded, it is impossible to say what the code does without knowing more about the type of thing the operators are being applied to.

Answer 5

Frankly, you should never write that. Postincrement and pre-increment (and decrements) should only ever be used on their own. They're just recipes for confusion.

Answer 6

The only place I can think of where such a situation would occur is with an operator overload of operator++ and operator=. Even then, the definition isn't clear. What you code is saying basically is add one to x, then assign 5 to it. A question would arise such as why would you need to increment x before assigning 5 to it? The only possible explanation is if you have some sort of class where the ++ operator somehow increment an internal counter, then the assignment. No idea why such a thing is needed though.

Answer 7

++x and --x both give you back x (after it's been incremented/decremented). At that point you can do what you want with it, including assign it a new value.

x++ and x-- both give you back what x was (just before it was incremented/decremented). Altering this value makes no more sense than changing any ordinary function's return value:

obj->getValue() += 3; // pointless