Value categories

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

C++ language

General topics
Preprocessor Comments	Keywords Escape sequences
Flow control
Conditional execution statements
if	switch
Iteration statements (loops)
for range-for (C++11)	while do-while
Jump statements
continue - break	goto - return
Functions
Function declaration
Lambda function declaration
inline specifier
Exception specifications (until C++20)
noexcept specifier (C++11)
Exceptions
throw-expression	try-catch block
Namespaces
Namespace declaration	Namespace aliases
Types
Fundamental types Enumeration types Function types	Compound types Union types
Specifiers
decltype (C++11) auto (C++11) alignas (C++11)	const/volatile constexpr (C++11)
Storage duration specifiers
Initialization
Default initialization Value initialization Zero initialization Copy initialization Direct initialization	Aggregate initialization List initialization (C++11) Constant initialization Reference initialization

Expressions
Value categories Order of evaluation	Operators Operator precedence
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
new expression	delete expression
Classes
Class declaration Initializer lists this pointer	Access specifiers friend specifier
Class-specific function properties
Virtual function override specifier (C++11) final specifier (C++11)	explicit (C++11) static
Special member functions
Default constructor Copy constructor Move constructor (C++11)	Copy assignment Move assignment (C++11) Destructor
Templates
Class template Function template	Template specialization Parameter packs (C++11)
Miscellaneous
Inline assembly	History of C++

 

Expressions

General

value categories (lvalue, rvalue, xvalue)

order of evaluation (sequence points)

constant expressions

unevaluated expressions

primary expressions

lambda-expression(C++11)

Literals

integer literals

floating-point literals

boolean literals

character literals including escape sequences

string literals

null pointer literal(C++11)

user-defined literal(C++11)

Operators

Assignment operators: a=b, a+=b, a-=b, a*=b, a/=b, a%=b, a&=b, a|=b, a^=b, a<<=b, a>>=b

Increment and decrement: ++a, --a, a++, a--

Arithmetic operators: +a, -a, a+b, a-b, a*b, a/b, a%b, ~a, a&b, a|b, a^b, a<<b, a>>b

Logical operators: a||b, a&&b, !a

Comparison operators: a==b, a!=b, a<b, a>b, a<=b, a>=b, a<=>b(C++20)

Member access operators: a[b], *a, &a, a->b, a.b, a->*b, a.*b

Other operators: a(...), a,b, a?b:c

Default comparisons(C++20)

Alternative representations of operators

Precedence and associativity

Fold expression(C++17)

new-expression

delete-expression

throw-expression

alignof

sizeof

sizeof...(C++11)

typeid

noexcept(C++11)

Operator overloading

Conversions

Implicit conversions

const_cast

static_cast

reinterpret_cast

dynamic_cast

Explicit conversions (T)a, T(a)

User-defined conversion

 

Each C++ expression (an operator with its operands, 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: prvalue, xvalue, and lvalue, defined as follows:

• a glvalue (“generalized” lvalue) is an expression whose evaluation determines the identity of an object, bit-field, or function;
• a prvalue (“pure” rvalue) is an expression whose evaluation either

• computes the value of the operand of an operator (such prvalue has no result object), or
• initializes an object or a bit-field (such prvalue is said to have a result object). All class and array prvalues have a result object even if it is discarded. In certain contexts, temporary materialization occurs to create a temporary as the result object;

• an xvalue (an “eXpiring” value) is a glvalue that denotes an object or bit-field whose resources can be reused;
• an lvalue (so-called, historically, because lvalues could appear on the left-hand side of an assignment expression) is a glvalue that is not an xvalue;
• an rvalue (so-called, historically, because rvalues could appear on the right-hand side of an assignment expression) is a prvalue or an xvalue.

Note: this taxonomy went through significant changes with past C++ standard revisions, see History below for details.

Primary categories

lvalue

The following expressions are lvalue expressions:

• the name of a variable, a function, a template parameter object (since C++20), or a data member, regardless of type, such as std::cin or std::endl. Even if the variable's type is rvalue reference, the expression consisting of its name is an lvalue expression;
• a function call or an overloaded operator expression, whose return type is lvalue reference, such as std::getline(std::cin, str), std::cout << 1, str1 = str2, or ++it;
• a = b, a += b, a %= b, and all other built-in assignment and compound assignment expressions;
• ++a and --a, the built-in pre-increment and pre-decrement expressions;
• *p, the built-in indirection expression;
• a[n] and p[n], the built-in subscript expressions, where one operand in a[n] is an array lvalue (since C++11);
• a.m, the member of object expression, except where m is a member enumerator or a non-static member function, or where a is an rvalue and m is a non-static data member of non-reference type;
• p->m, the built-in member of pointer expression, except where m is a member enumerator or a non-static member function;
• a.*mp, the pointer to member of object expression, where a is an lvalue and mp is a pointer to data member;
• p->*mp, the built-in pointer to member of pointer expression, where mp is a pointer to data member;
• a, b, the built-in comma expression, where b is an lvalue;
• a ? b : c, the ternary conditional expression for some b and c (e.g., when both are lvalues of the same type, but see definition for detail);
• a string literal, such as "Hello, world!";
• a cast expression to lvalue reference type, such as static_cast<int&>(x);

a function call or an overloaded operator expression, whose return type is rvalue reference to function; a cast expression to rvalue reference to function type, such as static_cast<void (&&)(int)>(x).

(since C++11)

Properties:

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

prvalue

The following expressions are prvalue expressions:

• a literal (except for string literal), such as 42, true or nullptr;
• a function call or an overloaded operator expression, whose return type is non-reference, such as str.substr(1, 2), str1 + str2, or it++;
• a++ and a--, the built-in post-increment and post-decrement expressions;
• a + b, a % b, a & b, a << b, and all other built-in arithmetic expressions;
• a && b, a || b, !a, the built-in logical expressions;
• a < b, a == b, a >= b, and all other built-in comparison expressions;
• &a, the built-in address-of expression;
• a.m, the member of object expression, where m is a member enumerator or a non-static member function, or where a is an rvalue and m is a non-static data member of non-reference type (until C++11);
• p->m, the built-in member of pointer expression, where m is a member enumerator or a non-static member function;
• a.*mp, the pointer to member of object expression, where mp is a pointer to member function, or where a is an rvalue and mp is a pointer to data member (until C++11);
• p->*mp, the built-in pointer to member of pointer expression, where mp is a pointer to member function;
• a, b, the built-in comma expression, where b is an rvalue;
• a ? b : c, the ternary conditional expression for some b and c (see definition for detail);
• a cast expression to non-reference type, such as static_cast<double>(x), std::string{}, or (int)42;
• the this pointer;
• an enumerator;
• non-type template parameter unless its type was a class or (since C++20) an lvalue reference type;

a lambda expression, such as [](int x){ return x * x; };

(since C++11)

a requires-expression, such as requires (T i) { typename T::type; }; a specialization of a concept, such as EqualityComparable<int>.

(since C++20)

Properties:

• Same as rvalue (below).
• A prvalue cannot be polymorphic: the dynamic type of the object it identifies is always the type of the expression.
• A non-class non-array prvalue cannot be cv-qualified. (Note: a function call or cast expression may result in a prvalue of non-class cv-qualified type, but the cv-qualifier is immediately stripped out.)
• A prvalue cannot have incomplete type (except for type void, see below, or when used in decltype specifier)
• A prvalue cannot have abstract class type or an array thereof.

xvalue

The following expressions are xvalue expressions:

• a function call or an overloaded operator expression, whose return type is rvalue reference to object, such as std::move(x);
• a[n], the built-in subscript expression, where one operand is an array rvalue;
• a.m, the member of object expression, where a is an rvalue and m is a non-static data member of non-reference type;
• a.*mp, the pointer to member of object expression, where a is an rvalue and mp is a pointer to data member;
• a ? b : c, the ternary conditional expression for some b and c (see definition for detail);
• a cast expression to rvalue reference to object type, such as static_cast<char&&>(x);

any expression that designates a temporary object, after temporary materialization.

(since C++17)

Properties:

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

In particular, like all rvalues, xvalues bind to rvalue references, and like all glvalues, xvalues may be polymorphic, and non-class xvalues may be cv-qualified.

Mixed categories

glvalue

A glvalue expression is either lvalue or xvalue.

Properties:

• A glvalue may be implicitly converted to a 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.

rvalue

An rvalue expression is either prvalue or xvalue.

Properties:

• Address of an rvalue may not be taken: &int(), &i++, &42, and &std::move(x) are invalid.
• An rvalue can't be used as the left-hand operand of the built-in assignment or compound assignment operators.
• 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, an rvalue binds to the rvalue reference overload (thus, if both copy and move constructors are available, an rvalue argument invokes the move constructor, and likewise with copy and move assignment operators).

(since C++11)

Special categories

Pending member function call

The expressions a.mf and p->mf, where mf is a non-static member function, and the expressions a.*pmf and p->*pmf, where pmf 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 the function call operator, e.g. (p->*pmf)(args).

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 discarded-value contexts (e.g. on a line of its own, as the left-hand operand 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 ?:.

Void expressions have no result object.

(since C++17)

Bit fields

An expression that designates a bit field (e.g. a.m, where a is an lvalue of type struct A { int m: 3; }) is an lvalue expression: it may be used as the left-hand operand 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.

History

CPL

The programming language CPL was first to introduce value categories for expressions: all CPL expressions can be evaluated in "right-hand mode", but only certain kinds of expression are meaningful in "left-hand mode". When evaluated in right-hand mode, an expression is regarded as being a rule for the computation of a value (the right-hand value, or rvalue). When evaluated in left-hand mode an expression effectively gives an address (the left-hand value, or lvalue). "Left" and "Right" here stood for "left of assignment" and "right of assignment".

C

The C programming language followed a similar taxonomy, except that the role of assignment was no longer significant: C expressions are categorized between "lvalue expressions" and others (functions and non-object values), where "lvalue" means an expression that identifies an object, a "locator value".

C++98

Pre-2011 C++ followed the C model, but restored the name "rvalue" to non-lvalue expressions, made functions into lvalues, and added the rule that references can bind to lvalues, but only references to const can bind to rvalues. Several non-lvalue C expressions became lvalue expressions in C++.

C++11

With the introduction of move semantics in C++11, value categories were redefined to characterize two independent 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 the 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.

In C++11, 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 ("pure rvalue") expressions;
• do not have identity and cannot be moved from are not used.

The expressions that have identity are called "glvalue expressions" (glvalue stands for "generalized lvalue"). Both lvalues and xvalues are glvalue expressions.

The expressions that can be moved from are called "rvalue expressions". Both prvalues and xvalues are rvalue expressions.

C++17

In C++17, copy elision was made mandatory in some situations, and that required separation of prvalue expressions from the temporary objects initialized by them, resulting in the system we have today. Note that, in contrast with the C++11 scheme, prvalues are no longer moved from.

Footnotes

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