Expressions are categorized according to the taxonomy in Figure 2.

Figure 2 — Expression category taxonomy  [fig:basic.lval]

• A glvalue is an expression whose evaluation determines the identity of an object, function, non-static data member, or a direct base class relationship.

• A prvalue is an expression whose evaluation initializes an object or computes the value of an operand of an operator, as specified by the context in which it appears, or an expression that has type cv void.

• An xvalue is a glvalue that denotes an object whose resources can be reused (usually because it is near the end of its lifetime).

• An lvalue is a glvalue that is not an xvalue.

• An rvalue is a prvalue or an xvalue.

[Note 1:

The discussion of each built-in operator in [expr.compound] indicates the category of the value it yields and the value categories of the operands it expects.

For example, the built-in assignment operators expect that the left operand is an lvalue and that the right operand is a prvalue and yield an lvalue as the result.

User-defined operators are functions, and the categories of values they expect and yield are determined by their parameter and return types.

— end note]

[Note 3:

In general, the effect of this rule is that named rvalue references are treated as lvalues and unnamed rvalue references to objects are treated as xvalues; rvalue references to functions are treated as lvalues whether named or not.

— end note]

[Example 1: struct A { int m; }; A&& operator+(A, A); A&& f(); A a; A&& ar = static_cast<A&&>(a);

[Note 4:

Except when the prvalue is the operand of a decltype-specifier, a prvalue of object type always has a result object.

For a discarded prvalue that has type other than cv void, a temporary object is materialized; see [expr.context].

— end note]

[Note 5:

An attempt to bind an rvalue reference to an lvalue is not such a context; see [dcl.init.ref].

— end note]

[Note 6:

Because cv-qualifiers are removed from the type of an expression of non-class type when the expression is converted to a prvalue, an lvalue of type const int can, for example, be used where a prvalue of type int is required.

— end note]

[Note 7:

There are no prvalue bit-fields; if a bit-field is converted to a prvalue ([conv.lval]), a prvalue of the type of the bit-field is created, which might then be promoted ([conv.prom]).

— end note]

[Note 9:

A glvalue can have complete or incomplete non-void type.

Class and array prvalues can have cv-qualified types; other prvalues always have cv-unqualified types.

— end note]

An object of dynamic type is type-accessible through a glvalue of type if is similar ([conv.qual]) to:

• ,
• a type that is the signed or unsigned type corresponding to , or
• a char, unsigned char, or std​::​byte type.

[Note 11:

In C, an entire object of structure type can be accessed, e.g., using assignment.

By contrast, C++ has no notion of accessing an object of class type through an lvalue of class type.

— end note]