Lvalues and rvalues

Expressions can be categorized into one of the following value categories:

Lvalue: An expression can appear on the left side of an assignment expression if the expression is not const qualified.

Xvalue: An rvalue reference that is to expire.

(Prvalue) rvalue: A non-xvalue expression that appears only on the right side of an assignment expression.

Rvalues include both xvalues and prvalues. Lvalues and xvalues can be referred as glvalues. C++0x

Notes:

Class (prvalue) rvalues can be cv-qualified, but non-class (prvalue) rvalues cannot be cv-qualified.
Lvalues and xvalues can be of incomplete types, but (prvalue) rvalues must be of complete types or void types.

An object is a region of storage that can be examined and stored into. An lvalue C++0x

or xvalue

is an expression that refers to such an object. An lvalue does not necessarily permit modification of the object it designates. For example, a const object is an lvalue that cannot be modified. The term modifiable lvalue is used to emphasize that the lvalue allows the designated object to be changed as well as examined. Lvalues of the following object types are not modifiable lvalues:

An array type
An incomplete type
A const-qualified type
A structure or union type with one of its members qualified as a const type

Because these lvalues are not modifiable, they cannot appear on the left side of an assignment statement, C++ only

except where a suitable assignment operator exists C++ only

C only C defines a function designator as an expression that has function type. A function designator is distinct from an object type or an lvalue. It can be the name of a function or the result of dereferencing a function pointer. The C language also differentiates between its treatment of a function pointer and an object pointer. C only

C++ only A function call that returns an lvalue reference is an lvalue. Expressions can produce an lvalue, C++0x an xvalue C++0x , a C++0x (prvalue) C++0x rvalue, or no value.

Certain

built-in

operators require lvalues for some of their operands. The following table lists these operators and additional constraints on their usage.

Operator	Requirement
& (unary)	Operand must be an lvalue.
++ --	Operand must be a modifiable lvalue. This applies to both prefix and postfix forms.
= += -= *= %= <<= >>= &= ‸= \|=	Left operand must be a modifiable lvalue.

For example, all assignment operators evaluate their right operand and assign that value to their left operand. The left operand must be a modifiable lvalue.

The address operator (&) requires an lvalue as an operand while the increment (++) and the decrement (--) operators require a modifiable lvalue as an operand. The following example shows expressions and their corresponding lvalues.

Expression	Lvalue
`x = 42`	`x`
`*ptr = newvalue`	`*ptr`
`a++`	`a`
`int& f()`	The function call to `f()`

The following expressions are xvalues:

The result of calling a function whose return type is of an rvalue reference type
A cast to an rvalue reference
A nonstatic data member of a non-reference type accessed through an xvalue expression
A pointer to member access expression in which the first operand is an xvalue expression and the second operand is of a pointer to member type

See the following example:

int a;
int&& b= static_cast<int&&>(a);

struct str{
   int c;
};

int&& f(){
   int&& var =1;
   return var;
}

str&& g();
int&& rc = g().c;

In this example, The initializer for rvalue reference b is an xvalue because it is a result of a cast to an rvalue reference. A call to the function f() produces an xvalue because the return type of this function is of the int&& type. The initializer for rvalue reference rc is an xvalue because it is an expression that accesses a nonstatic non-reference data member c through an xvalue expression.

C only IBM extension When compiled with the GNU C language extensions enabled, compound expressions, conditional expressions, and casts are allowed as lvalues, if their operands are lvalues. The use of this language extension is deprecated for C++ code.

A compound expression can be assigned if the last expression in the sequence is an lvalue. The following expressions are equivalent:

(x + 1, y) *= 42;
x + 1, (y *=42);

The address operator can be applied to a compound expression, provided the last expression in the sequence is an lvalue. The following expressions are equivalent:

&(x + 1, y);
x + 1, &y;

A conditional expression can be a valid lvalue if its type is not void and both of its branches for true and false are valid lvalues. Casts are valid lvalues if the operand is an lvalue. The primary restriction is that you cannot take the address of an lvalue cast. End IBM extension C only