7 Standard conversions [conv]

A glvalue of a non-function, non-array type T can be converted to a prvalue.57 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.58

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 ex of the set of potential results of e, and ex names a variable x that is not odr-used by ex,

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 due to 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. [ Note: Since no value is fetched from memory, there is no side effect for a volatile access ([intro.execution]), and an inactive member of a union may be accessed.  — 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 value contained in the object indicated by the glvalue is the prvalue result.

[ Note: See also [basic.lval]. — end note ]