I've got a question of similiar nature like this one posted 5 years ago: Why are rvalues references variables not rvalue?
My major concern is why can I do this:
int&& k = 3; k++; but I cannot do this:
(static_cast<int&&>(3))++; I've always interpreted rvalue references as lvalues since rvalue reference variables are lvalues. But apparently that is not the case. Can someone explain to me why the (static_cast<int&&>(3))++; results in using rvalue as lvalue ?
The confusion is probably arising from the difference between r-value and r-value reference. The former is a value-category which only applies to expressions, while the latter is a type which applies to variables (technically it would need to be an r-value reference of some type, e.g. r-value reference to int).
So the difference between the snippets you've shown is not actually related to the type of the variable, but the value-category of the expression. Postfix operator++ requires the value-category of the operand to be an l-value, regardless of the type of the operand.
In k++, the expression k is an l-value (roughly speaking, it has a name), which is its value-category. The type of the variable k is an r-value reference, but that's fine.
In (static_cast<int&&>(3))++, the expression static_cast<int&&>(3) is an r-value (it doesn't have a name), which is its value-category. Regardless of the type of static_cast<int&&> (which is int), the value-category is wrong, and so you get an error.
Note that the error message using rvalue as lvalue is referring to the value-category of the expression being used. It has nothing to do with the types of the variables.
k is int &&, but the type of the expression k is just int (and that expression is an lvalue). This also means that the type of static_cast<int&&>(3) is int rather than int &&.
(static_cast<int&>(k))++ work where k is some int variable ? I get that that expression returns reference to k and reference is defined as another name for an object, but then what is the difference between static_cast<int&> and static_cast<int&&> ? Both return reference, right ? To sum up, why does expression static_cast<int&> have a name ?
(static_cast<int&&>(k))++; returns a r-value reference, which is not modifiable, whereas (static_cast<int&>(k))++; returns an l-value reference, which is modifiable. static_cast<int&> casts to an l-value reference.Because rvalue reference variable is lvalue
According to cppreference
lvalue Even if the variable's type is rvalue reference, the expression consisting of its name is an lvalue expression (but see Move-eligible expressions);
