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 cvvoid.
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.
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.
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
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 1: 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 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 cvvoid 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 cvvoid
has no result object.
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.
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 constint can, for example, be used where
a prvalue of type int is required.
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]).
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.decltype]),
a prvalue shall always have complete type or the void type;
if it has a class type or (possibly multidimensional) array of class type,
that class shall not be an abstract class ([class.abstract]).
If a program attempts to access
the stored value of an object through a glvalue
whose type is not similar to
one of the following types the behavior is
undefined:43
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 cvU within its lifetime,
the behavior is undefined.