Namespaces
Variants
Views
Actions

Value categories

From cppreference.com
< cpp‎ | language
 
 
 
 

Each C++ expression (an operator with its arguments, a literal, a variable name, etc.) is characterized by two independent properties: a type and a value category. Each expression has some non-reference type, and each expression belongs to exactly one of the three primary value categories.

Contents

[edit] Primary categories

The primary value categories correspond to two properties of expressions:

  • has identity: it's possible to determine whether the expression refers to the same entity as another expression, such as by comparing addresses of the objects or functions they identify (obtained directly or indirectly);
  • can be moved from: move constructor, move assignment operator, or another function overload that implements move semantics can bind to the expression.

Expressions that:

  • have identity and cannot be moved from are called lvalue expressions;
  • have identity and can be moved from are called xvalue expressions;
  • do not have identity and can be moved from are called prvalue expressions;
  • do not have identity and cannot be moved from are not used.

[edit] lvalue

An lvalue ("left value") expression is an expression that has identity and cannot be moved from. The naming is historic and reflects the use of lvalue expressions on the left hand side of assignment in the CPL programming language.

The following expressions are lvalue expressions:

  • a cast expression to an rvalue reference to function type, such as static_cast<void (&&)(int)>(x);
  • a function call or overloaded operator expression with an rvalue reference to function return type.
(since C++11)

Properties:

  • Same as glvalue (below).
  • Address of an lvalue may be taken: &++i[1] and &std::endl are valid expressions.
  • A modifiable lvalue may be used as the left-hand operand of the built-in assignment operator.
  • An lvalue may be used to initialize an lvalue reference; this associates a new name with the object identified by the expression.

[edit] rvalue (until C++11)prvalue (since C++11)

A prvalue ("pure rvalue") expression is an expression that does not have identity and can be moved from.

The following expressions are prvalue expressions:

(since C++11)

Properties:

xvalue

An xvalue ("expiring value") expression is an expression that has identity and can be moved from.

The following expressions are xvalue expressions:

Properties:

  • Same as rvalue (below).
  • Same as glvalue (below).

Like prvalues, xvalues bind to rvalue references, but unlike prvalues, an xvalue may be polymorphic, and a non-class xvalue may be cv-qualified.

(since C++11)

[edit] Mixed categories

[edit] glvalue

A glvalue ("generalized lvalue") expression is an expression that is either an lvalue or an xvalue. It has identity. It may or may not be moved from.

Properties (note: these apply to pre-C++11 lvalues as well):

  • A glvalue may be implicitly converted to prvalue with lvalue-to-rvalue, array-to-pointer, or function-to-pointer implicit conversion.
  • A glvalue may be polymorphic: the dynamic type of the object it identifies is not necessarily the static type of the expression.
  • A glvalue can have incomplete type, where permitted by the expression.

[edit] rvalue

An rvalue ("right value") expression is an expression that is either a prvalue or an xvalue. It can be moved from. It may or may not have identity. The naming is historic and reflects the use of rvalue expressions on the right hand side of assignment in the CPL programming language.

Properties (note: these apply to pre-C++11 rvalues as well):

  • Address of an rvalue may not be taken: &int(), &i++[2], &42, and &std::move(val) are invalid.
  • Rvalues can't be used as the left-hand operand of the built-in assignment or compound assignment operator.
  • An rvalue may be used to initialize a const lvalue reference, in which case the lifetime of the object identified by the rvalue is extended until the scope of the reference ends.
  • An rvalue may be used to initialize an rvalue reference, in which case the lifetime of the object identified by the rvalue is extended until the scope of the reference ends.
  • When used as a function argument and when two overloads of the function are available, one taking rvalue reference parameter and the other taking lvalue reference to const parameter, rvalues bind to the rvalue reference overload (thus, if both copy and move constructors are available, rvalue arguments invoke the move constructor, and likewise with copy and move assignment operators).
(since C++11)

[edit] Special categories

[edit] Pending member function call

The expressions obj.func and ptr->func, where func is a non-static member function, and the expressions obj.*mfp and ptr->*mfp where mfp is a pointer to member function, are classified as prvalue expressions, but they cannot be used to initialize references, as function arguments, or for any purpose at all, except as the left-hand argument of a function call expression, e.g. (obj_ptr->*ptr)(args).

[edit] Void expressions

Function call expressions returning void, cast expressions to void, and throw-expressions are classified as prvalue expressions, but they cannot be used to initialize references or as function arguments. They can be used in some contexts (e.g. on a line of its own, as the left argument of the comma operator, etc) and in the return statement in a function returning void. In addition, throw-expressions may be used as the second and the third operands of the conditional operator ?: (other void prvalues can only be used if appearing as both 2nd and 3rd operands).

[edit] Bit fields

An expression that designates a bit field (e.g. s.x where s is an object of type struct S { int x: 3; };) is an lvalue expression (or xvalue if s is one): it may be used on the left hand side of the assignment operator, but its address cannot be taken and a non-const lvalue reference cannot be bound to it. A const lvalue reference can be initialized from a bit-field lvalue, but a temporary copy of the bit-field will be made: it won't bind to the bit field directly.

[edit] footnotes

  1. Assuming i has built-in type or the pre-increment operator is overloaded to return by lvalue reference
  2. Assuming i has built-in type or the postincrement operator is not overloaded to return by lvalue reference

[edit] External references

"New" Value Terminology by Bjarne Stroustrup, 2010

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
CWG 616 C++11 member access and member access through pointer to member of an rvalue resulted in prvalue reclassified as xvalue
CWG 1213 C++11 subscripting an array rvalue resulted in lvalue reclassified as xvalue

[edit] See also

C documentation for value categories