\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 class type\iref{class} or enumeration

type\iref{dcl.enum}. 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 overloaded

operators\iref{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 subclause \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}%

If during the evaluation of an expression, the result is not

mathematically defined or not in the range of representable values for

its type, the behavior is undefined.

\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 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.ass}.

\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 or function.

\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{}~\tcode{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 classifications 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 classify expressions, not values.

\end{note}

\indextext{expression!rvalue reference}%

\begin{note}

An expression is an xvalue if it is:

\begin{itemize}

\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

(\ref{expr.type.conv}, \ref{expr.dynamic.cast}, \ref{expr.static.cast}

\ref{expr.reinterpret.cast}, \ref{expr.const.cast}, \ref{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{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{}~\tcode{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 non-discarded prvalue

that is used to compute the value of an operand of a built-in operator

or a prvalue that has type \cv{}~\tcode{void}

has no result object.

\begin{note}

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

a prvalue of class or array type always has a result object.

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

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

\end{note}

Whenever a glvalue appears as an operand of an operator that

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

a prvalue of type \tcode{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}

Whenever a prvalue appears as an operand of an operator that

expects a glvalue for that operand, the

temporary materialization conversion\iref{conv.rval} is

applied to convert the expression to an xvalue.

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.

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

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

if it has a class type or (possibly multi-dimensional) array of class type,

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

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

\begin{note}

A glvalue can have complete or incomplete non-\tcode{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~(\ref{expr.ass}, \ref{expr.post.incr}, \ref{expr.pre.incr}).

\end{note}

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

the stored value of an object through a glvalue

whose type is not similar\iref{conv.qual} to

one of the following types the behavior is

undefined:

\begin{footnote}

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

object can or cannot be aliased.

\end{footnote}

\begin{itemize}

\item the dynamic type of the object,

\item a type that is the signed or unsigned type corresponding to the

dynamic type of the object, or

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

\end{itemize}

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.

\begin{note}

Unlike in C, \Cpp{} has no accesses of class type.

\end{note}

\rSec2[expr.type]{Type}

\indextext{expression!reference}%

If an expression initially has the type ``reference to

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

\tcode{T} prior to any further analysis. The expression designates the

object or function denoted by the reference, and the expression

is an lvalue or an xvalue, depending on the expression.

\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} \tcode{void}'' and the

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

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

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

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

if \tcode{T1} or \tcode{T2} is ``pointer to \tcode{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 \cvqual{cv1} \tcode{C1}'' and \tcode{T2} is ``pointer to

\cvqual{cv2} \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 cv-combined type\iref{conv.qual}

of \tcode{T1} and \tcode{T2} or the cv-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 \tcode{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 cv-combined type of \tcode{T2} and \tcode{T1} or the cv-combined type

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

if \tcode{T1} and \tcode{T2} are similar types\iref{conv.qual}, the cv-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{const void}''; the

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

\tcode{const int}''.

\end{example}

\rSec2[expr.context]{Context dependence}

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

appear~(\ref{expr.prim.req},

\ref{expr.typeid},

\ref{expr.sizeof},

\ref{expr.unary.noexcept},

\ref{dcl.type.decltype},

\ref{temp.pre},

\ref{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 full-expression\iref{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 array-to-pointer\iref{conv.array}

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

applied. The lvalue-to-rvalue conversion\iref{conv.lval} 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 subscripting\iref{expr.sub},

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

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

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

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

third operands are one of these expressions, or

\item comma expression\iref{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}

If the (possibly converted) expression is a prvalue,

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

\begin{note}

If the 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 lvalue-to-rvalue

conversion.

\end{note}

The glvalue expression is evaluated and its value is discarded.

\rSec1[conv]{Standard conversions}

\rSec2[conv.general]{General}

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

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

\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 a required destination type.

\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 \tcode{if} statement\iref{stmt.if} or

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

\tcode{bool}.

\item When used in the expression of a \tcode{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 \tcode{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{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 glvalue\iref{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 ISO 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 object to which the glvalue refers contains an invalid

pointer value~(\ref{basic.stc.dynamic.deallocation},

\ref{basic.stc.dynamic.safety}), the behavior is

\impldef{lvalue-to-rvalue conversion of an invalid pointer value}.

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

and the value contained in the object is the prvalue result.

\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 lvalue or rvalue 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}''.

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

The result is a pointer to the first element of the array.

\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{cv-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 cv-decompositions,

taking \tcode{U}

as ``\tcode{int}'',

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

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

\end{example}

The $n$-tuple of cv-qualifiers after the first one

in the longest cv-decomposition of \tcode{T}, that is,

$\cv{}_1, \cv{}_2, \dotsc, \cv{}_n$, is called the

\defn{cv-qualification signature} of \tcode{T}.

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

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

they have cv-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{cv-combined}{type} of two types \tcode{T1} and \tcode{T2}

is the type \tcode{T3}

similar to \tcode{T1} whose cv-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 \tcode{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 cv-decomposition of $\tcode{T}j$.

A prvalue of type \tcode{T1}

can be converted to type \tcode{T2}

if the cv-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 \tcode{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 cv-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}

\indextext{promotion!integral}%

A prvalue of an integer type other than \tcode{bool}, \tcode{char16_t},

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

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

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

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

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

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

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

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

A prvalue of type \tcode{char16_t}, \tcode{char32_t}, or

\tcode{wchar_t}\iref{basic.fundamental} can be converted to a prvalue

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

its underlying type: \tcode{int}, \tcode{unsigned int}, \tcode{long int},

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

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

represent all the values of its underlying type, a prvalue of type

\tcode{char16_t}, \tcode{char32_t}, or \tcode{wchar_t} can be converted

to a prvalue of its underlying type.

\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}: \tcode{int},

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

\tcode{long long int}, or \tcode{unsigned long long 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.

A prvalue for an integral bit-field\iref{class.bit} can be converted

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

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

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

values of the bit-field. If the bit-field is larger yet, no integral

promotion applies to it. If the bit-field has an enumerated type, it is

treated as any other value of that type for promotion purposes.

\indextext{promotion!bool to int}%

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

\tcode{int}, with \tcode{false} becoming zero and \tcode{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 \tcode{float} can be converted to a prvalue of type

\tcode{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

a prvalue of an integer type.

\indextext{conversion!bool@\tcode{bool}}%

If the destination type is \tcode{bool}, see~\ref{conv.bool}. If the

source type is \tcode{bool}, the value \tcode{false} is converted to

zero and the value \tcode{true} is converted to one.

\indextext{conversion!to unsigned}%

\indextext{conversion!to signed}%

Otherwise, the result is the unique value of the destination type

that is congruent to the source integer modulo $2^N$,

where $N$ is the width of the destination type.

The conversions allowed as integral promotions are excluded from the set

of integral conversions.

\rSec2[conv.double]{Floating-point conversions}

\indextext{conversion!floating-point}%

A prvalue of floating-point type can be converted to a prvalue of

another floating-point type. If the source value can be exactly

represented in the destination type, the result of the conversion is

that exact representation. If the source value is between two adjacent

destination values, the result of the conversion is an

\impldef{result of inexact floating-point conversion} choice of either of those values.

Otherwise, the behavior is undefined.

The conversions allowed as floating-point promotions are excluded from

the set of floating-point conversions.

\rSec2[conv.fpint]{Floating-integral conversions}

\indextext{conversion!floating to integral}%

A prvalue of a floating-point type can be converted to a prvalue of an

integer type. The conversion truncates; that is, the fractional part is

discarded.

\indextext{value!undefined unrepresentable integral}%

The behavior is undefined if the truncated value cannot be represented

in the destination type.

\begin{note}

If the destination type is \tcode{bool}, see~\ref{conv.bool}.

\end{note}

\indextext{conversion!integral to floating}%

\indextext{truncation}%

\indextext{rounding}%

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

a prvalue of a floating-point type. The result is exact if possible. If the value being

converted is in the range of values that can be represented but the value cannot be

represented exactly, it is an \impldef{value of result of inexact integer to

floating-point conversion} choice of either the next lower or higher representable

value.

\begin{note}

Loss of precision occurs if the integral value cannot be represented

exactly as a value of the floating-point type.

\end{note}

If the value being converted is

outside the range of values that can be represented, the behavior is undefined. If the

source type is \tcode{bool}, the value \tcode{false} is converted to zero and the value

\tcode{true} is converted to one.

\rSec2[conv.ptr]{Pointer conversions}

\indextext{conversion!pointer}%

\indextext{null pointer conversion|see{conversion, null pointer}}%

\indextext{pointer!zero|see{value, null pointer}}%

\indextext{value!null pointer}%

A \defnx{null pointer constant}{constant!null pointer} is an integer literal\iref{lex.icon} with

value zero

or a prvalue of type \tcode{std::nullptr_t}. A null pointer constant can be

converted to a pointer type; the

result is the null pointer value of that type\iref{basic.compound} and is

distinguishable from every other value of

object pointer or function pointer

type.

Such a conversion is called a \defnx{null pointer conversion}{conversion!null pointer}.

Two null pointer values of the same type shall compare

equal. The conversion of a null pointer constant to a pointer to

cv-qualified type is a single conversion, and not the sequence of a

pointer conversion followed by a qualification

conversion\iref{conv.qual}. A null pointer constant of integral type

can be converted to a prvalue of type \tcode{std::nullptr_t}.

\begin{note}

The resulting prvalue is not a null pointer value.

\end{note}

A prvalue of type ``pointer to \cv{} \tcode{T}'', where \tcode{T}