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 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 apply to 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.
Whenever a glvalue appears as an operand of an operator that
requires a prvalue for that operand, the
lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]),
or function-to-pointer ([conv.func]) 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]).
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 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 ([ub:expr.basic.lvalue.union.initialization]).