增量和减量运算符

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

鉴于operator =（）和operator ++（）都可以重载，如果不了解运算符所应用的类型，就不可能说出代码的作用。

Answer 3

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 4

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

The first two are well-formed , ie 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 5

++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

Answer 6

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 7

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.