7 Expressions [expr]

7.2 Properties of expressions [expr.prop]

7.2.1 Value category [basic.lval]

Expressions are categorized according to the taxonomy in Figure 1 .

Figure 1: Expression category taxonomy [fig:basic.lval]

(1.1)
A glvalue is an expression whose evaluation determines the identity of an object, bit-field, or function.
(1.2)
A prvalue is an expression whose evaluation initializes an object or a bit-field, 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.
(1.3)
An xvalue is a glvalue that denotes an object or bit-field whose resources can be reused (usually because it is near the end of its lifetime).
(1.4)
An lvalue is a glvalue that is not an xvalue.
(1.5)
An rvalue is a prvalue or an xvalue.

Every expression belongs to exactly one of the fundamental classifications in this taxonomy: lvalue, xvalue, or prvalue.

This property of an expression is called its value category.

[ Note

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

Historically, lvalues and rvalues were so-called because they could appear on the left- and right-hand side of an assignment (although this is no longer generally true); glvalues are “generalized” lvalues, prvalues are “pure” rvalues, and xvalues are “eXpiring” lvalues.

Despite their names, these terms classify expressions, not values.

— end note

]

[ Note

An expression is an xvalue if it is:

(4.1)
the result of calling a function, whether implicitly or explicitly, whose return type is an rvalue reference to object type ([expr.call]),
(4.2)
a cast to an rvalue reference to object type ([expr.type.conv], [expr.dynamic.cast], [expr.static.cast] [expr.reinterpret.cast], [expr.const.cast], [expr.cast]),
(4.3)
a subscripting operation with an xvalue array operand ([expr.sub]),
(4.4)
a class member access expression designating a non-static data member of non-reference type in which the object expression is an xvalue ([expr.ref]), or
(4.5)
a .* pointer-to-member expression in which the first operand is an xvalue and the second operand is a pointer to data member ([expr.mptr.oper]).

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

struct A {
int m;
};
A&& operator+(A, A);
A&& f();

A a;
A&& ar = static_cast<A&&>(a);

The expressions f(), f().m, static_cast<A&&>(a), and a + a are xvalues.

The expression ar is an lvalue.

— end example

]

The result of a glvalue is the entity denoted by the expression.

The result of a prvalue is the value that the expression stores into its context; a prvalue that has type cv void has no result.

A prvalue whose result is the value V is sometimes said to have or name the value V.

The result object of a prvalue is the object initialized by the prvalue; a non-discarded prvalue that is used to compute the value of an operand of a built-in operator or a prvalue that has type cv void has no result object.

[ Note

Except when the prvalue is the operand of a decltype-specifier, a prvalue of class or array 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

]

Whenever a glvalue appears as an operand of an operator that expects a prvalue for that operand, the lvalue-to-rvalue, array-to-pointer, or function-to-pointer standard conversions are applied to convert the expression to a prvalue.

[ Note

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

— end note

]

[ Note

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

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

]

Whenever a prvalue appears as an operand of an operator that expects a glvalue for that operand, the temporary materialization conversion is applied to convert the expression to an xvalue.

The discussion of reference initialization in [dcl.init.ref] and of temporaries in [class.temporary] indicates the behavior of lvalues and rvalues in other significant contexts.

Unless otherwise indicated ([dcl.type.simple]), a prvalue shall always have complete type or the void type; if it has a class type or (possibly multi-dimensional) array of class type, that class shall not be an abstract class ([class.abstract]).

A glvalue shall not have type cv void.

[ Note

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

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

See [expr.type].

— end note

]

An lvalue is modifiable unless its type is const-qualified or is a function type.

[ Note

A program that attempts to modify an object through a nonmodifiable lvalue or through an rvalue is ill-formed ([expr.ass], [expr.post.incr], [expr.pre.incr]).

— end note

]

If a program attempts to access ([defns.access]) the stored value of an object through a glvalue whose type is not similar ([conv.qual]) to one of the following types the behavior is undefined:51

(11.1)
the dynamic type of the object,
(11.2)
a type that is the signed or unsigned type corresponding to the dynamic type of the object, or
(11.3)
a char, unsigned char, or std::byte type.

If a program invokes a defaulted copy/move constructor or copy/move assignment operator for a union of type U with a glvalue argument that does not denote an object of type cv U within its lifetime, the behavior is undefined.

[ Note

Unlike in C, C++ has no accesses of class type.

— end note

]

51)

The intent of this list is to specify those circumstances in which an object may or may not be aliased.

⮥