lvalue and rvalue assignment error [duplicate]

Question

This question already has an answer here:

Weird behaviour of prefix and postfix operators (1 answer)

Closed 8 years ago.

int x = 3;
int y = 5;
x++ = y;
cout << x << endl;

Why is the above code giving me an error, the specific error I get is

lvalue required as left operand of assignment.

I am trying to review up on my C and C++. From my understanding the above code should theoretically copy over the value of y into x, then finally increment the value of x after the copy has finished. So it would print out "6".

Answer 1

x++ results in a temporary object that has x value before the increment. And you cannot assign a temp object.

Examples for clarification:

int a=1; 
a=5; // Lvalue = Rvalue, Ok 
a=a; // Lvalue = Lvalue, Ok 
5=a; // Rvalue = Lvalue Comp. error
5=5; // Rvalue = Rvalue Comp. error 

Answer 2

x++ ==> x=x+1

x++ = y ==> (x+1)=y

now x+1=y will throw lvalue required which means left hand side of = should be a variable not a constant

Answer 3

The result of the postincrement operator is a temporary object that has the value before incrementing. You may not assign a temporary object. So this statement is invalid.

x++ = y;

You could rewrite it the following way

( x += 1 ) = y;

The statement above is correct.

Answer 4

x++ cannot be use as left operand because it returns a value, not an address.

Answer 5

In this line:

x++ = y;

x++ is r-value, and you cannot assign to it, you can rewrite it as follows: 3 = 5; which makes no sense, you cannot assign 5 to 3.

Answer 6

In your expression: x++ = y, x++ is just a result of an evaluated expression so you can't assigne a value to a result.

Another think is that this expression has no meaning since the variable x will be updated with the value of y.

Answer 7

The result of x++ is the value of x, but not the object x. The expression is a prvalue, which means you can't then assign to it (you need an lvalue).

The value of a postfix ++ expression is the value of its operand. [ Note: the value obtained is a copy of the original value — end note ] ... The result is a prvalue.

To achieve what you want, you need to do:

x = y;
x++;

In C++11, with its new sequencing rules, you could also do:

(x = y)++;

This would be undefined behaviour in C++03 because there is no sequence point between two modifications of x.

Answer 8

From my understanding the above code should theoretically copy over the value of y into x, then finally increment the value of x after the copy has finished.

x++ evaluates to an r-value (constant). Assignment operator = needs an l-value (variable) as its left operand.

x++ = y ==> (3 + 1) = 5 ==> 4 = 5  

you can't assign a constant to a constant. x++ = y is not a valid statement in either of C or C++.

Answer 9

The core issue is this:

From my understanding the above code should theoretically copy over the value of y into x, then finally increment the value of x after the copy has finished. So it would print out "6".

In fact, the sequencing of the increment is undefined. As in, it is completely undefined as to when x is incremented, except that it must occur before some specific times. Reading or writing x during this period of undefined value is undefined behaviour. That's why x++ does not return x (an lvalue you can write to) but an rvalue you cannot write to- because there's simply nothing useful you can do with x until the time it's guaranteed to be incremented (except take the address, maybe).

You can still break this rule by referring to x twice- for example, consider:

void f(int, int);
int main() {
    int x = 0;
    f(x++, x++);
}

This is also undefined behaviour.