[conv.lval]

# 7 Expressions [[expr]](./#expr)

## 7.3 Standard conversions [[conv]](conv#lval)

### 7.3.2 Lvalue-to-rvalue conversion [conv.lval]

[1](#1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/expressions.tex#L612)

A [glvalue](basic.lval#def:glvalue "7.2.1 Value category [basic.lval]") of a non-function, non-array type T can be converted to
a prvalue[.](#1.sentence-1)[43](#footnote-43 "For historical reasons, this conversion is called the “lvalue-to-rvalue” conversion, even though that name does not accurately reflect the taxonomy of expressions described in [basic.lval].")

If T is an incomplete type, a
program that necessitates this conversion is ill-formed[.](#1.sentence-2)

If T is a non-class type, the type of the prvalue is
the cv-unqualified version of T[.](#1.sentence-3)

Otherwise, the type of the
prvalue is T[.](#1.sentence-4)[44](#footnote-44 "In C++ class and array prvalues can have cv-qualified types. This differs from C, in which non-lvalues never have cv-qualified types.")

[2](#2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/expressions.tex#L634)

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

- [(2.1)](#2.1)

E is not potentially evaluated, or

- [(2.2)](#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 ([[basic.def.odr]](basic.def.odr "6.3 One-definition rule")),

the value contained in the referenced object is not accessed[.](#2.sentence-1)

[*Example [1](#example-1)*: 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 lifetimeint n = g(true); // OK, does not access y.n — *end example*]

[3](#3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/expressions.tex#L659)

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

- [(3.1)](#3.1)

  If T is cv std​::​nullptr_t, the result is a
null pointer constant ([[conv.ptr]](conv.ptr "7.3.12 Pointer conversions"))[.](#3.1.sentence-1)
  [*Note [1](#note-1)*:
  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]](intro.execution "6.10.1 Sequential execution")), and
the glvalue can refer to an inactive member of a union ([[class.union]](class.union "11.5 Unions"))[.](#3.1.sentence-2)
 — *end note*]

- [(3.2)](#3.2)

  Otherwise, if T has a class
type, the conversion copy-initializes the result object from
the glvalue[.](#3.2.sentence-1)

- [(3.3)](#3.3)

  Otherwise, if the object to which the glvalue refers contains an invalid
pointer value ([[basic.compound]](basic.compound "6.9.4 Compound types")), the behavior isimplementation-defined[.](#3.3.sentence-1)

- [(3.4)](#3.4)

  Otherwise, if the bits in the value representation of
the object to which the glvalue refers
are not valid for the object's type, the behavior is undefined[.](#3.4.sentence-1)
  [*Example [2](#example-2)*: bool f() {bool b = true; char c = 42;
 memcpy(&b, &c, 1); return b; // undefined behavior if 42 is not a valid value representation for bool} — *end example*]

- [(3.5)](#3.5)

  Otherwise, the object indicated by the glvalue is read ([[defns.access]](defns.access "3.1 access"))[.](#3.5.sentence-1)
  Let V be the value contained in the object[.](#3.5.sentence-2)
  If T is an integer type,
the prvalue result is
the value of type T congruent ([[basic.fundamental]](basic.fundamental "6.9.2 Fundamental types")) to V, andV otherwise[.](#3.5.sentence-3)

[4](#4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/expressions.tex#L702)

[*Note [2](#note-2)*:

See also [[basic.lval]](basic.lval "7.2.1 Value category")[.](#4.sentence-1)

— *end note*]

[43)](#footnote-43)[43)](#footnoteref-43)

For historical reasons, this conversion is called the “lvalue-to-rvalue”
conversion, even though that name does not accurately reflect the taxonomy
of expressions described in [[basic.lval]](basic.lval "7.2.1 Value category")[.](#footnote-43.sentence-1)

[44)](#footnote-44)[44)](#footnoteref-44)

In C++ class and array prvalues can have cv-qualified types[.](#footnote-44.sentence-1)

This differs from C, in which non-lvalues never have
cv-qualified types[.](#footnote-44.sentence-2)