7 Expressions [expr]

7.3 Standard conversions [conv]

7.3.1 Lvalue-to-rvalue conversion [conv.lval]

A glvalue of a non-function, non-array type T can be converted to a prvalue.52

If T is an incomplete type, a program that necessitates this conversion is ill-formed.

If T is a non-class type, the type of the prvalue is the cv-unqualified version of T.

Otherwise, the type of the prvalue is T.53

When an lvalue-to-rvalue conversion is applied to an expression E, and either

(2.1)
E is not potentially evaluated, or
(2.2)
the evaluation of E results in the evaluation of a member $E_{x}$ of the set of potential results of E, and $E_{x}$ names a variable x that is not odr-used by $E_{x}$ ([basic.def.odr]),

the value contained in the referenced object is not accessed.

[Example

struct S { int n; };
auto f() {
S x { 1 };
constexpr S y { 2 };
return [&](bool b) { return (b ? y : x).n; };
}
auto g = f();
int m = g(false);   // undefined behavior: access of x.n outside its lifetime
int n = g(true);    // OK, does not access y.n

— end example

]

The result of the conversion is determined according to the following rules:

(3.1)
If T is cv std::nullptr_t, the result is a null pointer constant ([conv.ptr]).
[Note
: Since the conversion does not access the object to which the glvalue refers, there is no side effect even if T is volatile-qualified ([intro.execution]), and the glvalue can refer to an inactive member of a union ([class.union]). — end note
]
(3.2)
Otherwise, if T has a class type, the conversion copy-initializes the result object from the glvalue.
(3.3)
Otherwise, if the object to which the glvalue refers contains an invalid pointer value ([basic.stc.dynamic.deallocation], [basic.stc.dynamic.safety]), the behavior is implementation-defined.
(3.4)
Otherwise, the object indicated by the glvalue is read ([defns.access]), and the value contained in the object is the prvalue result.

[Note