\rSec0[expr]{Expressions}

\gramSec[gram.expr]{Expressions}

\indextext{\idxcode{operator new}|seealso{\tcode{new}}}%

\indextext{\idxcode{operator delete}|seealso{\tcode{delete}}}%

\indextext{usual arithmetic conversions|see{conversion, usual arithmetic}}%

\indextext{\idxcode{==}|see{operator, equality}}%

\indextext{\idxcode{"!=}|see{operator, inequality}}

\indextext{\idxcode{static_cast}|see{cast, static}}%

\indextext{\idxcode{dynamic_cast}|see{cast, dynamic}}%

\indextext{\idxcode{const_cast}|see{cast, const}}%

\indextext{\idxcode{reinterpret_cast}|see{cast, reinterpret}}

\rSec1[expr.pre]{Preamble}

\indextext{expression|(}%

\begin{note}

\ref{expr} defines the syntax, order of evaluation, and meaning

of expressions.

\begin{footnote}

The precedence of operators is not directly specified, but it can be

derived from the syntax.

\end{footnote}

An expression is a sequence of operators and operands that specifies a

computation. An expression can result in a value and can cause side

effects.

\end{note}

\indextext{operator!overloaded}%

\begin{note}

Operators can be overloaded, that is, given meaning when applied to

expressions of \link{class}{class} type or

\link{enumeration}{dcl.enum} type. Uses of overloaded operators are transformed into

function calls as described in~\ref{over.oper}. Overloaded operators

obey the rules for syntax and evaluation order specified in \ref{expr.compound},

but the requirements of operand type and value category are replaced

by the rules for function call. Relations between operators, such as

\tcode{++a} meaning \tcode{a += 1}, are not guaranteed for \link{overloaded

operators}{over.oper}.

\end{note}

Subclause \ref{expr.compound} defines the effects of operators when applied to types

for which they have not been overloaded. Operator overloading shall not

modify the rules for the \defnadj{built-in}{operators},

that is, for operators applied to types for which they are defined by this

Standard. However, these built-in operators participate in overload

resolution, and as part of that process user-defined conversions will be

considered where necessary to convert the operands to types appropriate

for the built-in operator. If a built-in operator is selected, such

conversions will be applied to the operands before the operation is

considered further according to the rules in \ref{expr.compound};

see~\ref{over.match.oper}, \ref{over.built}.

\indextext{exception!arithmetic}%

\indextext{exception!undefined arithmetic}%

\indextext{overflow!undefined}%

\indextext{zero!division by undefined}%

\indextext{zero!remainder undefined}%

An \defnadj{arithmetic}{expression} is

\begin{itemize}

\item a unary plus or minus\iref{expr.unary.op},

\item an addition\iref{expr.add},

\item a subtraction\iref{expr.sub}, or

\item a multiplication, division, or remainder\iref{expr.mul}

\end{itemize}

expression where every (possibly converted) operand is of arithmetic type.

\begin{note}

There exist non-arithmetic expressions such as compound assignment\iref{expr.assign}

which are defined in terms of arithmetic expressions.

\end{note}

The behavior of evaluating an arithmetic expression is undefined\ubdef{expr.expr.eval}

if the mathematical result is neither

\begin{itemize}

in the range of representable values for its type nor

a negative infinity, positive infinity, or NaN

that is among the values of the type.

\end{itemize}

\begin{note}

If the operands are of a type that adheres to \IsoFloatUndated,

division by zero is the only case

where an arithmetic expression has undefined behavior\iref{expr.mul}.

However, some well-defined arithmetic expressions

are not core constant expressions\iref{expr.const.core}.

\begin{example}

The following example assumes that \tcode{std::float32_t} is supported\iref{basic.extended.fp}.

\begin{codeblock}

constexpr std::float32_t min = std::numeric_limits<std::float32_t>::min(); // OK

constexpr std::float32_t max = std::numeric_limits<std::float32_t>::max(); // OK

constexpr std::float32_t inf = std::numeric_limits<std::float32_t>::infinity(); // OK

constexpr std::float32_t nan = std::numeric_limits<std::float32_t>::quiet_NaN(); // OK

// Furthermore, if arithmetic expressions with operands of type \tcode{std::float32_t}

// behave as specified in ISO/IEC 60559 for binary32:

constexpr std::float32_t inf2 = inf * 2; // OK, also positive infinity

constexpr std::float32_t zero = min / max; // OK, result cannot be represented, and is rounded to zero

constexpr std::float32_t oflo = max * 2; // error: non-finite result but operands are finite\iref{expr.const.core}

constexpr std::float32_t nan2 = nan * 2; // OK, propagating a NaN

constexpr std::float32_t udef = inf * 0; // error: result is NaN but neither operand is NaN\iref{expr.const.core}

constexpr std::float32_t div0 = max / 0; // error: division by zero is undefined\iref{expr.mul,expr.const.core}

\end{codeblock}

\end{example}

\end{note}

\begin{note}

\indextext{overflow}%

Treatment of division by zero, forming a remainder using a zero divisor,

and all floating-point exceptions varies among machines, and is sometimes

adjustable by a library function.

\end{note}

\indextext{operator!precedence of}%

\indextext{expression!order of evaluation of}%

\begin{note}

The implementation can regroup operators according to

the usual mathematical rules only

where the operators really are associative or commutative.

\begin{footnote}

Overloaded

operators are never assumed to be associative or commutative.

\end{footnote}

For example, in the following fragment

\begin{codeblock}

int a, b;

@\commentellip@

a = a + 32760 + b + 5;

\end{codeblock}

the expression statement behaves exactly the same as

\begin{codeblock}

a = (((a + 32760) + b) + 5);

\end{codeblock}

due to the associativity and precedence of these operators. Thus, the

result of the sum \tcode{(a + 32760)} is next added to \tcode{b}, and

that result is then added to \tcode{5} which results in the value assigned to

\tcode{a}. On a machine in which overflows produce an exception and in

which the range of values representable by an \tcode{int} is

\crange{-32768}{+32767}, the implementation cannot rewrite this

expression as

\begin{codeblock}

a = ((a + b) + 32765);

\end{codeblock}

since if the values for \tcode{a} and \tcode{b} were, respectively,

$-32754$ and $-15$, the sum \tcode{a + b} would produce an exception while

the original expression would not; nor can the expression be rewritten

as either

\begin{codeblock}

a = ((a + 32765) + b);

\end{codeblock}

or

\begin{codeblock}

a = (a + (b + 32765));

\end{codeblock}

since the values for \tcode{a} and \tcode{b} might have been,

respectively, 4 and $-8$ or $-17$ and 12. However on a machine in which

overflows do not produce an exception and in which the results of

overflows are reversible, the above expression statement can be

rewritten by the implementation in any of the above ways because the

same result will occur.

\end{note}

The values of the floating-point operands and

the results of floating-point expressions

may be represented in greater precision and range than that

required by the type; the types are not changed\

thereby.

\begin{footnote}

The cast and assignment operators must still perform their specific

conversions as described in~\ref{expr.type.conv}, \ref{expr.cast},

\ref{expr.static.cast} and~\ref{expr.assign}.

\end{footnote}

\rSec1[expr.prop]{Properties of expressions}

\rSec2[basic.lval]{Value category}

Expressions are categorized according to the taxonomy in \fref{basic.lval}.

\begin{importgraphic}

{Expression category taxonomy}

{basic.lval}

{valuecategories.pdf}

\end{importgraphic}

\begin{itemize}

\item A \defn{glvalue} is an expression

whose evaluation determines the identity of

an object, function, non-static data member, or

a direct base class relationship.

\item A \defn{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 \cv{}~\keyword{void}.

\item An \defn{xvalue} is a glvalue that denotes an object whose resources can be reused (usually because it is near the end of its lifetime).

\item An \defn{lvalue} is a glvalue that is not an xvalue.

\item An \defn{rvalue} is a prvalue or an xvalue.

\end{itemize}

Every expression belongs to exactly one of the fundamental categories in this

taxonomy: lvalue, xvalue, or prvalue. This property of an expression is called

its \defn{value category}.

\begin{note}

The discussion of each built-in operator in

\ref{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.

\end{note}

\begin{note}

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.

\end{note}

\indextext{expression!rvalue reference}%

\begin{note}

An expression is an xvalue if it is:

\begin{itemize}

\item a move-eligible \grammarterm{id-expression}\iref{expr.prim.id.unqual}

or \grammarterm{splice-expression}\iref{expr.prim.splice},

\item the result of calling a function, whether implicitly or explicitly,

whose return type is an rvalue reference to object type\iref{expr.call},

\item a cast to an rvalue reference to

object type\iref{expr.type.conv,expr.dynamic.cast,expr.static.cast,

expr.reinterpret.cast,expr.const.cast,expr.cast},

\item a subscripting operation with an xvalue array operand\iref{expr.sub},

\item a class member access expression designating a non-static data member

of non-reference type

in which the object expression is an xvalue\iref{expr.ref}, or

\item a \tcode{.*} pointer-to-member expression in which the first operand is

an xvalue and the second operand is a pointer to data member\iref{expr.mptr.oper}.

\end{itemize}

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}

\begin{example}

\begin{codeblock}

struct A {

int m;

};

A&& operator+(A, A);

A&& f();

A a;

A&& ar = static_cast<A&&>(a);

\end{codeblock}

The expressions \tcode{f()}, \tcode{f().m}, \tcode{\keyword{static_cast}<A\&\&>(a)}, and \tcode{a + a}

are xvalues. The expression \tcode{ar} is an lvalue.

\end{example}

The \defnx{result}{result!glvalue} of a glvalue is the entity denoted by the expression.

The \defnx{result}{result!prvalue} of a prvalue

is the value that the expression stores into its context;

a prvalue that has type \cv{}~\keyword{void} has no result.

A prvalue whose result is the value \placeholder{V}

is sometimes said to have or name the value \placeholder{V}.

The \defn{result object} of a prvalue is the object initialized by the prvalue;

a prvalue that has type \cv{}~\keyword{void}

has no result object.

\begin{note}

Except when the prvalue is the operand of a \grammarterm{decltype-specifier},

a prvalue of object type always has a result object.

For a discarded prvalue that has type other than \cv{}~\keyword{void},

a temporary object is materialized; see \ref{expr.context}.

\end{note}

Whenever a glvalue appears as an operand of an operator that

requires a prvalue for that operand, the

lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},

or function-to-pointer\iref{conv.func} standard conversions are

applied to convert the expression to a prvalue.

\begin{note}

An attempt to bind an rvalue reference to an lvalue is not such a context; see~\ref{dcl.init.ref}.

\end{note}

\begin{note}

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 \tcode{\keyword{const} \keyword{int}} can, for example, be used where

a prvalue of type \keyword{int} is required.

\end{note}

\begin{note}

There are no prvalue bit-fields; if a bit-field is converted to a

prvalue\iref{conv.lval}, a prvalue of the type of the bit-field is

created, which might then be promoted\iref{conv.prom}.

\end{note}

Unless otherwise specified\iref{expr.reinterpret.cast, expr.const.cast},

whenever a prvalue

that is not the result of the lvalue-to-rvalue conversion\iref{conv.lval}

appears as an operand of an operator,

the \link{temporary materialization conversion}{conv.rval} is

applied to convert the expression to an xvalue.

\begin{note}

The discussion of reference initialization in~\ref{dcl.init.ref} and of

temporaries in~\ref{class.temporary} indicates the behavior of lvalues

and rvalues in other significant contexts.

\end{note}

Unless otherwise indicated\iref{dcl.type.decltype},

a prvalue shall always have complete type or the \keyword{void} type;

if it has a class type or (possibly multidimensional) array of class type,

that class shall not be an abstract class\iref{class.abstract}.

A glvalue shall not have type \cv{}~\keyword{void}.

\begin{note}

A glvalue can have complete or incomplete non-\keyword{void} type.

Class and array prvalues can have cv-qualified types; other prvalues

always have cv-unqualified types. See \ref{expr.type}.

\end{note}

An lvalue is \defn{modifiable} unless its type is const-qualified

or is a function type.

\begin{note}

A program that attempts

to modify an object through a nonmodifiable lvalue or through an rvalue

is ill-formed\iref{expr.assign,expr.post.incr,expr.pre.incr}.

\end{note}

An object of dynamic type $\tcode{T}_\text{obj}$ is

\defn{type-accessible} through a glvalue of type $\tcode{T}_\text{ref}$

if $\tcode{T}_\text{ref}$ is similar\iref{conv.qual} to:

\begin{itemize}

\item $\tcode{T}_\text{obj}$,

\item a type that is the signed or unsigned type corresponding to $\tcode{T}_\text{obj}$, or

\item a \keyword{char}, \tcode{\keyword{unsigned} \keyword{char}}, or \tcode{std::byte} type.

\end{itemize}

If a program attempts to access\iref{defns.access}

the stored value of an object through a glvalue

through which it is not type-accessible,

the behavior is undefined\ubdef{expr.basic.lvalue.strict.aliasing.violation}.

\begin{footnote}

The intent of this list is to specify those circumstances in which an

object can or cannot be aliased.

\end{footnote}

If a program invokes

a defaulted copy/move constructor or copy/move assignment operator

for a union of type \tcode{U} with a glvalue argument

that does not denote an object of type \cv{}~\tcode{U} within its lifetime,

the behavior is undefined\ubdef{expr.basic.lvalue.union.initialization}.

\begin{note}

In C, an entire object of structure type can be accessed, e.g., using assignment.

By contrast, \Cpp{} has no notion of accessing an object of class type

through an lvalue of class type.

\end{note}

\rSec2[expr.type]{Type}

\indextext{expression!reference}%

If an expression initially has the type ``reference to

\tcode{T}''\iref{dcl.ref,dcl.init.ref}, the type is adjusted to

\tcode{T} prior to any further analysis;

the value category of the expression is not altered.

Let $X$ be the object or function denoted by the reference.

If a pointer to $X$ would be valid in

the context of the evaluation of the expression\iref{basic.fundamental},

the result designates $X$;

otherwise, the behavior is undefined\ubdef{expr.type.reference.lifetime}.

\begin{note}

Before the lifetime of the reference has started or after it has ended,

the behavior is undefined (see~\ref{basic.life}).

\end{note}

If a prvalue initially has the type ``\cv{}~\tcode{T}'', where

\tcode{T} is a cv-unqualified non-class, non-array type, the type of

the expression is adjusted to \tcode{T} prior to any further analysis.

\indextext{pointer!composite pointer type}%

The \defn{composite pointer type} of

two operands \tcode{p1} and

\tcode{p2} having types \tcode{T1} and \tcode{T2}, respectively, where at least one is a

pointer or pointer-to-member type or

\tcode{std::nullptr_t}, is:

\begin{itemize}

if both \tcode{p1} and \tcode{p2} are null pointer constants,

\tcode{std::nullptr_t};

if either \tcode{p1} or \tcode{p2} is a null pointer constant, \tcode{T2} or \tcode{T1},

respectively;

if \tcode{T1} or \tcode{T2} is ``pointer to \cvqual{cv1} \keyword{void}'' and the

other type is ``pointer to \cvqual{cv2} \tcode{T}'',

where \tcode{T} is an object type or \keyword{void},

``pointer to \cvqual{cv12} \keyword{void}'',

where \cvqual{cv12} is the union of \cvqual{cv1} and \cvqual{cv2};

if \tcode{T1} or \tcode{T2} is ``pointer to \keyword{noexcept} function'' and the

other type is ``pointer to function'', where the function types are otherwise the same,

``pointer to function'';

if \tcode{T1} is ``pointer to \tcode{C1}'' and \tcode{T2} is ``pointer to

\tcode{C2}'', where \tcode{C1} is reference-related to \tcode{C2} or \tcode{C2} is

reference-related to \tcode{C1}\iref{dcl.init.ref},

the qualification-combined type\iref{conv.qual}

of \tcode{T1} and \tcode{T2} or the qualification-combined type of \tcode{T2} and \tcode{T1},

respectively;

if \tcode{T1} or \tcode{T2} is

``pointer to member of \tcode{C1} of type function'',

the other type is

``pointer to member of \tcode{C2} of type \keyword{noexcept} function'', and

\tcode{C1} is reference-related to \tcode{C2} or

\tcode{C2} is reference-related to \tcode{C1}\iref{dcl.init.ref},

where the function types are otherwise the same,

``pointer to member of \tcode{C2} of type function'' or

``pointer to member of \tcode{C1} of type function'', respectively;

if \tcode{T1} is

``pointer to member of \tcode{C1} of type \cvqual{cv1} \tcode{U}'' and

\tcode{T2} is

``pointer to member of \tcode{C2} of type \cvqual{cv2} \tcode{U}'',

for some non-function type \tcode{U},

where \tcode{C1} is

reference-related to \tcode{C2} or \tcode{C2} is reference-related to

\tcode{C1}\iref{dcl.init.ref}, the qualification-combined type of \tcode{T2} and \tcode{T1} or the qualification-combined type

of \tcode{T1} and \tcode{T2}, respectively;

if \tcode{T1} and \tcode{T2} are similar types\iref{conv.qual}, the qualification-combined type of \tcode{T1} and

\tcode{T2};

otherwise, a program that necessitates the determination of a

composite pointer type is ill-formed.

\end{itemize}

\begin{example}

\begin{codeblock}

typedef void *p;

typedef const int *q;

typedef int **pi;

typedef const int **pci;

\end{codeblock}

The composite pointer type of \tcode{p} and \tcode{q} is ``pointer to \tcode{\keyword{const} \keyword{void}}''; the

composite pointer type of \tcode{pi} and \tcode{pci} is ``pointer to \tcode{\keyword{const}} pointer to

\tcode{\keyword{const} \keyword{int}}''.

\end{example}

\rSec2[expr.context]{Context dependence}

\label{term.unevaluated.operand}%

In some contexts, \defnx{unevaluated operands}{unevaluated operand}

appear\iref{expr.prim.req.simple,

temp.concept}.

An unevaluated operand is not evaluated.

\begin{note}

In an unevaluated operand, a non-static class member can be

named\iref{expr.prim.id} and naming of objects or functions does not, by

itself, require that a definition be provided\iref{basic.def.odr}.

An unevaluated operand is considered a \deflink{full-expression}{intro.execution}.

\end{note}

In some contexts, an expression only appears for its side effects. Such an

expression is called a \defn{discarded-value expression}.

The \link{array-to-pointer}{conv.array}

and \link{function-to-pointer}{conv.func} standard conversions are not

applied. The \link{lvalue-to-rvalue}{conv.lval} conversion is applied

if and only if

the expression is a glvalue of volatile-qualified type and it is one of the

following:

\begin{itemize}

\item \tcode{(} \grammarterm{expression} \tcode{)}, where

\grammarterm{expression} is one of these expressions,

\item \grammarterm{id-expression}\iref{expr.prim.id},

\item \grammarterm{splice-expression}\iref{expr.prim.splice},

\item \link{subscripting}{expr.sub},

\item \link{class member access}{expr.ref},

\item \deflink{indirection}{expr.unary.op},

\item \link{pointer-to-member operation}{expr.mptr.oper},

\item \link{conditional expression}{expr.cond} where both the second and the

third operands are one of these expressions, or

\item \link{comma expression}{expr.comma} where the right operand is one of

these expressions.

\end{itemize}

\begin{note}

Using an overloaded operator causes a function call; the

above covers only operators with built-in meaning.

\end{note}

The temporary materialization conversion\iref{conv.rval} is applied

if the (possibly converted) expression is a prvalue of object type.

\begin{note}

If the original expression is an lvalue of class type,

it must have a volatile copy constructor to initialize the temporary object

that is the result object of the temporary materialization conversion.

\end{note}

The expression is evaluated and its result (if any) is discarded.

\rSec1[conv]{Standard conversions}

\rSec2[conv.general]{General}

\indextext{implicit conversion|see{conversion, implicit}}

\indextext{contextually converted to \tcode{bool}|see{conversion, contextual to \tcode{bool}}}

\indextext{rvalue!lvalue conversion to|see{conversion, lvalue-to-rvalue}}%

\indextext{conversion!standard|(}%

\indextext{conversion!implicit}%

Standard conversions are implicit conversions with built-in meaning.

\ref{conv} enumerates the full set of such conversions. A

\defnx{standard conversion sequence}{conversion sequence!standard} is a sequence of standard

conversions in the following order:

\begin{itemize}

\item Zero or one conversion from the following set: lvalue-to-rvalue

conversion, array-to-pointer conversion, and function-to-pointer

conversion.

\item Zero or one conversion from the following set: integral

promotions, floating-point promotion, integral conversions, floating-point

conversions, floating-integral conversions, pointer conversions,

pointer-to-member conversions, and boolean conversions.

\item Zero or one function pointer conversion.

\item Zero or one qualification conversion.

\end{itemize}

\begin{note}

A standard conversion sequence can be empty, i.e., it can consist of no

conversions.

\end{note}

A standard conversion sequence will be applied to

an expression if necessary to convert it to an expression having

a required destination type and value category.

\begin{note}

Expressions with a given type will be implicitly converted to other

types in several contexts:

\begin{itemize}

\item When used as operands of operators. The operator's requirements

for its operands dictate the destination type\iref{expr.compound}.

\item When used in the condition of an \keyword{if} statement\iref{stmt.if} or

iteration statement\iref{stmt.iter}. The destination type is

\keyword{bool}.

\item When used in the expression of a \keyword{switch} statement\iref{stmt.switch}.

The destination type is integral.

\item When used as the source expression for an initialization (which

includes use as an argument in a function call and use as the expression

in a \keyword{return} statement). The type of the entity being initialized

is (generally) the destination type.

See~\ref{dcl.init}, \ref{dcl.init.ref}.

\end{itemize}

\end{note}

An expression $E$ can be

\defnx{implicitly converted}{conversion!implicit} to a type \tcode{T} if and only if the

declaration \tcode{T t = $E$;} is well-formed, for some invented temporary

variable \tcode{t}\iref{dcl.init}.

Certain language constructs require that an expression be converted to a Boolean

value. An expression $E$ appearing in such a context is said to be

\defnx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}} and is well-formed if and only if

the declaration \tcode{\keyword{bool} t($E$);} is well-formed, for some invented temporary

variable \tcode{t}\iref{dcl.init}.

Certain language constructs require conversion to a value having

one of a specified set of types appropriate to the construct. An

expression $E$ of class type \tcode{C} appearing in such a

context is said to be

\indextext{conversion!contextual}%

\defn{contextually implicitly converted} to a specified type \tcode{T} and is

well-formed if and only if $E$ can be implicitly converted to a type \tcode{T}

that is determined as follows:

\tcode{C} is searched for non-explicit conversion functions

whose return type is \cv{} \tcode{T} or reference to \cv{}

\tcode{T} such that \tcode{T} is allowed by the context.

There shall be exactly one such \tcode{T}.

The effect of any implicit

conversion is the same as performing the corresponding declaration and initialization

and then using the temporary variable as the result of the conversion.

The result is an lvalue if \tcode{T} is an lvalue reference

type or an rvalue reference to function type\iref{dcl.ref},

an xvalue if \tcode{T} is an rvalue reference to object type,

and a prvalue otherwise. The expression $E$

is used as a glvalue if and only if the initialization uses it as a glvalue.

\begin{note}

For class types, user-defined conversions are considered as well;

see~\ref{class.conv}. In general, an implicit conversion

sequence\iref{over.best.ics} consists of a standard conversion

sequence followed by a user-defined conversion followed by another

standard conversion sequence.

\end{note}

\begin{note}

There are some contexts where certain conversions are suppressed. For

example, the lvalue-to-rvalue conversion is not done on the operand of

the unary \tcode{\&} operator. Specific exceptions are given in the

descriptions of those operators and contexts.

\end{note}

\rSec2[conv.lval]{Lvalue-to-rvalue conversion}

\indextext{conversion!lvalue-to-rvalue}%

\indextext{type!incomplete}%

A \deflink{glvalue}{basic.lval} of a non-function, non-array type \tcode{T}

can be converted to

a prvalue.

\begin{footnote}

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~\ref{basic.lval}.

\end{footnote}

If \tcode{T} is an incomplete type, a

program that necessitates this conversion is ill-formed. If \tcode{T}

is a non-class type, the type of the prvalue is

the cv-unqualified version of \tcode{T}. Otherwise, the type of the

prvalue is \tcode{T}.

\begin{footnote}

In \Cpp{} class and array prvalues can have cv-qualified types.

This differs from C, in which non-lvalues never have

cv-qualified types.

\end{footnote}

When an lvalue-to-rvalue conversion

is applied to an expression $E$, and either

\begin{itemize}

\item $E$ is not potentially evaluated, or

\item the evaluation of $E$ results in the evaluation of a member

$E_\tcode{x}$ of the set of potential results of $E$, and $E_\tcode{x}$

names a variable \tcode{x} that is not odr-used by

$E_\tcode{x}$\iref{basic.def.odr},

\end{itemize}

the value contained in the referenced object is not accessed.

\begin{example}

\begin{codeblock}

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 \tcode{x.n} outside its lifetime

int n = g(true); // OK, does not access \tcode{y.n}

\end{codeblock}

\end{example}

The result of the conversion is determined according to the

following rules:

\begin{itemize}

\item If \tcode{T} is \cv{}~\tcode{std::nullptr_t}, the result is a

null pointer constant\iref{conv.ptr}.

\begin{note}

Since the conversion does not access the object to which the glvalue refers,

there is no side effect even if \tcode{T} is volatile-qualified\iref{intro.execution}, and

the glvalue can refer to an inactive member of a union\iref{class.union}.

\end{note}

\item Otherwise, if \tcode{T} has a class

type, the conversion copy-initializes the result object from

the glvalue.

\item 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\ubdef{conv.lval.valid.representation}.

\begin{example}

\begin{codeblock}

bool f() {

bool b = true;

char c = 42;

memcpy(&b, &c, 1);

return b; // undefined behavior if \tcode{42} is not a valid value representation for \keyword{bool}

}

\end{codeblock}

\end{example}

\item Otherwise, the object indicated by the glvalue is read\iref{defns.access}.

Let \tcode{V} be the value contained in the object.

The prvalue result is

\begin{itemize}

the value of type \tcode{T} congruent\iref{basic.fundamental} to \tcode{V}

if \tcode{T} is an integer type,

the result of \tcode{reinterpret_cast<T>(reinterpret_cast<std::uintptr_t>(V))}

if \tcode{T} is volatile-qualified

and \tcode{V} is a pointer value

that is not valid in the context of the evaluation\iref{basic.compound}, and

\tcode{V} otherwise.

\end{itemize}

\end{itemize}

\begin{note}

See also~\ref{basic.lval}.

\end{note}

\rSec2[conv.array]{Array-to-pointer conversion}

\indextext{conversion!array-to-pointer}%

\indextext{decay!array|see{conversion, array-to-pointer}}%

\indextext{decay!function|see{conversion, function-to-pointer}}%

An expression $E$ of type ``array of \tcode{N} \tcode{T}'' or ``array

of unknown bound of \tcode{T}'' can be converted to a prvalue of type

``pointer to \tcode{T}''.

If $E$ is a prvalue,

the temporary materialization conversion\iref{conv.rval} is applied.

If the result of $E$ (possibly converted) is an object

whose type is similar to the type of $E$,

the result is a pointer to the first element of the array;

otherwise, the behavior is undefined.

\rSec2[conv.func]{Function-to-pointer conversion}

\indextext{conversion!function-to-pointer}%

An lvalue of function type \tcode{T} can be converted to a prvalue of

type ``pointer to \tcode{T}''. The result is a pointer to the

function.

\begin{footnote}

This conversion never applies to non-static member functions because an

lvalue that refers to a non-static member function cannot be obtained.

\end{footnote}

\rSec2[conv.rval]{Temporary materialization conversion}

\indextext{conversion!temporary materialization}%

A prvalue of type \tcode{T} can be converted to an xvalue of type \tcode{T}.

This conversion initializes a temporary object\iref{class.temporary} of type \tcode{T} from the prvalue

by evaluating the prvalue with the temporary object as its result object,

and produces an xvalue denoting the temporary object.

\tcode{T} shall be a complete type.

\begin{note}

If \tcode{T} is a class type (or array thereof),

it must have an accessible and non-deleted destructor;

see~\ref{class.dtor}.

\end{note}

\begin{example}

\begin{codeblock}

struct X { int n; };

int k = X().n; // OK, \tcode{X()} prvalue is converted to xvalue

\end{codeblock}

\end{example}

\rSec2[conv.qual]{Qualification conversions}

\indextext{conversion!qualification|(}%

A \defn{qualification-decomposition} of a type \tcode{T}

is a sequence of

$\cv{}_i$ and $P_i$

such that \tcode{T} is

\begin{indented}

``$\cv{}_0$ $P_0$ $\cv{}_1$ $P_1$ $\cdots$ $\cv{}_{n-1}$ $P_{n-1}$ $\cv{}_n$ \tcode{U}'' for $n \geq 0$,

\end{indented}

where

each $\cv{}_i$ is a set of cv-qualifiers\iref{basic.type.qualifier}, and

each $P_i$ is

``pointer to''\iref{dcl.ptr},

``pointer to member of class $C_i$ of type''\iref{dcl.mptr},

``array of $N_i$'', or

``array of unknown bound of''\iref{dcl.array}.

If $P_i$ designates an array,

the cv-qualifiers $\cv{}_{i+1}$ on the element type are also taken as

the cv-qualifiers $\cv{}_i$ of the array.

\begin{example}

The type denoted by the \grammarterm{type-id} \tcode{const int **}

has three qualification-decompositions,

taking \tcode{U}

as ``\keyword{int}'',

as ``pointer to \tcode{\keyword{const} \keyword{int}}'', and

as ``pointer to pointer to \tcode{\keyword{const} \keyword{int}}''.

\end{example}

\indextext{type!similar|see{similar types}}%

Two types \tcode{T1} and \tcode{T2} are \defnx{similar}{similar types} if

they have qualification-decompositions with the same $n$

such that corresponding $P_i$ components are either the same

or one is ``array of $N_i$'' and the other is ``array of unknown bound of'',

and the types denoted by \tcode{U} are the same.

The \defnadj{qualification-combined}{type} of two types \tcode{T1} and \tcode{T2}

is the type \tcode{T3}

similar to \tcode{T1} whose qualification-decomposition is such that:

\begin{itemize}

for every $i > 0$, $\cv{}^3_i$ is the union of

$\cv{}^1_i$ and $\cv{}^2_i$,

if either $P^1_i$ or $P^2_i$ is ``array of unknown bound of'',

$P^3_i$ is ``array of unknown bound of'', otherwise it is $P^1_i$, and

if the resulting $\cv{}^3_i$ is different from $\cv{}^1_i$ or $\cv{}^2_i$,

or the resulting $P^3_i$ is different from $P^1_i$ or $P^2_i$,

then \keyword{const} is added to every $\cv{}^3_k$ for $0 < k < i$,

\end{itemize}

where $\cv{}^j_i$ and $P^j_i$ are the components of

the qualification-decomposition of $\tcode{T}j$.

A prvalue of type \tcode{T1}

can be converted to type \tcode{T2}

if the qualification-combined type of \tcode{T1} and \tcode{T2} is \tcode{T2}.

\begin{note}

If a program could assign a pointer of type \tcode{T**} to a pointer of

type \keyword{const} \tcode{T**} (that is, if line \#1 below were

allowed), a program could inadvertently modify a const object

(as it is done on line \#2). For example,

\begin{codeblock}

int main() {

const char c = 'c';

char* pc;

const char** pcc = &pc; // \#1: not allowed

*pcc = &c;

*pc = 'C'; // \#2: modifies a const object

}

\end{codeblock}

\end{note}

\begin{note}

Given similar types \tcode{T1} and \tcode{T2}, this

construction ensures that

both can be converted to the qualification-combined type of \tcode{T1} and \tcode{T2}.

\end{note}

\begin{note}

A prvalue of type ``pointer to \cvqual{cv1} \tcode{T}'' can be

converted to a prvalue of type ``pointer to \cvqual{cv2} \tcode{T}'' if

``\cvqual{cv2} \tcode{T}'' is more cv-qualified than ``\cvqual{cv1}

\tcode{T}''.

A prvalue of type ``pointer to member of \tcode{X} of type \cvqual{cv1}

\tcode{T}'' can be converted to a prvalue of type ``pointer to member

of \tcode{X} of type \cvqual{cv2} \tcode{T}'' if ``\cvqual{cv2}

\tcode{T}'' is more cv-qualified than ``\cvqual{cv1} \tcode{T}''.

\end{note}

\begin{note}

Function types (including those used in pointer-to-member-function types)

are never cv-qualified\iref{dcl.fct}.

\end{note}

\indextext{conversion!qualification|)}

\rSec2[conv.prom]{Integral promotions}

For the purposes of \ref{conv.prom},

a \defnadj{converted}{bit-field} is a prvalue that is the result of

an lvalue-to-rvalue conversion\iref{conv.lval} applied to

a bit-field\iref{class.bit}.

\indextext{promotion!integral}%

A prvalue that is not a converted bit-field and has an integer type other than

\keyword{bool}, \keyword{char8_t}, \keyword{char16_t},

\keyword{char32_t}, or \keyword{wchar_t} whose integer conversion

rank\iref{conv.rank} is less than the rank of \keyword{int} can be

converted to a prvalue of type \keyword{int} if \keyword{int} can represent

all the values of the source type; otherwise, the source prvalue can be

converted to a prvalue of type \tcode{\keyword{unsigned} \keyword{int}}.

\indextext{type!underlying!enumeration}%

A prvalue of an unscoped enumeration type whose underlying type is not

fixed can be converted to a prvalue of the first of the following

types that can represent all the values of the enumeration\iref{dcl.enum}: \keyword{int},

\tcode{\keyword{unsigned} \keyword{int}}, \tcode{\keyword{long} \keyword{int}}, \tcode{\keyword{unsigned} \keyword{long} \keyword{int}},

\tcode{\keyword{long} \keyword{long} \keyword{int}}, or \tcode{\keyword{unsigned} \keyword{long} \keyword{long} \keyword{int}}. If none of the types in that

list can represent all the values of the enumeration, a prvalue of an unscoped

enumeration type can be converted to a prvalue of the extended integer type with lowest

integer conversion rank\iref{conv.rank} greater than the rank of \tcode{long long}

in which all the values of the enumeration can be represented. If there are

two such extended types, the signed one is chosen.

A prvalue of an unscoped enumeration type whose underlying type is

fixed\iref{dcl.enum} can be converted to a prvalue of its underlying type. Moreover,

if integral promotion can be applied to its underlying type, a prvalue of an unscoped

enumeration type whose underlying type is fixed can also be converted to a prvalue of

the promoted underlying type.

\begin{note}

A converted bit-field of enumeration type is treated as

any other value of that type for promotion purposes.

\end{note}

A converted bit-field of integral type can be converted

to a prvalue of type \keyword{int} if \keyword{int} can represent all the

values of the bit-field; otherwise, it can be converted to

\tcode{\keyword{unsigned} \keyword{int}} if \tcode{\keyword{unsigned} \keyword{int}} can represent all the

values of the bit-field.

\indextext{type!underlying!\idxcode{wchar_t}}%

\indextext{type!underlying!\idxcode{char16_t}}%

\indextext{type!underlying!\idxcode{char32_t}}%

A prvalue of type

\keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, or

\keyword{wchar_t}\iref{basic.fundamental}

(including a converted bit-field that was not

already promoted to \keyword{int} or \tcode{\keyword{unsigned} \keyword{int}}

according to the rules above)

can be converted to a prvalue

of the first of the following types that can represent all the values of

its underlying type:

\keyword{int},

\tcode{\keyword{unsigned} \keyword{int}},

\tcode{\keyword{long} \keyword{int}},

\tcode{\keyword{unsigned} \keyword{long} \keyword{int}},

\tcode{\keyword{long} \keyword{long} \keyword{int}},

\tcode{\keyword{unsigned} \keyword{long} \keyword{long} \keyword{int}}, or

its underlying type.

\indextext{promotion!bool to int}%

A prvalue of type \keyword{bool} can be converted to a prvalue of type

\keyword{int}, with \keyword{false} becoming zero and \keyword{true} becoming

one.

These conversions are called \defnx{integral promotions}{integral promotion}.

\rSec2[conv.fpprom]{Floating-point promotion}

\indextext{promotion!floating-point}%

A prvalue of type \keyword{float} can be converted to a prvalue of type

\keyword{double}. The value is unchanged.

This conversion is called \defn{floating-point promotion}.

\rSec2[conv.integral]{Integral conversions}

\indextext{conversion!integral}%

A prvalue of an integer type can be converted to a prvalue of another

integer type. A prvalue of an unscoped enumeration type can be converted to