expressions.tex

%!TEX root = std.tex
\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}

\pnum
\indextext{expression|(}%
\begin{note}
\ref{expr} defines the syntax, order of evaluation, and meaning
of expressions.\footnote{The precedence of operators is not directly specified, but it can be
derived from the syntax.}
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}

\pnum
\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}

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

\pnum
\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 vary among machines, and is sometimes
adjustable by a library function.
\end{note}

\pnum
\indextext{operator!precedence of}%
\indextext{expression!order of evaluation of}%
\begin{note}
The implementation may regroup operators according to
the usual mathematical rules only
where the operators really are associative or commutative.\footnote{Overloaded
operators are never assumed to be associative or commutative.}
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}

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

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

\rSec2[basic.lval]{Value category}
\pnum
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, bit-field, or function.
\item A \defn{prvalue} is an expression whose evaluation initializes an object or a bit-field,
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 or bit-field 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}

\pnum
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}

\pnum
\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}

\pnum
\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}

\pnum
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}

\pnum
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}

\pnum
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.

\pnum
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.

\pnum
Unless otherwise indicated\iref{dcl.type.simple},
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 may 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}

\pnum
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}

\pnum
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:\footnote{The intent of this list is to specify those circumstances in which an
object may or may not be aliased.}
\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}

\pnum
\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}

\pnum
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.

\pnum
\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}
\item
if both \tcode{p1} and \tcode{p2} are null pointer constants,
\tcode{std::nullptr_t};

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

\item
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};

\item
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'';

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

\item
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;

\item
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;

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

\item
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}

\pnum
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.simple},
\ref{temp.pre},
\ref{temp.concept}).
An unevaluated operand is not evaluated.
\begin{note}
In an unevaluated operand, a non-static class member may 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}

\pnum
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}

\indextext{implicit conversion|see{conversion, implicit}}
\indextext{contextually converted to bool|see{conversion, contextual}}
\indextext{rvalue!lvalue conversion to|see{conversion, lvalue-to-rvalue}}%

\pnum
\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.

\pnum
\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}

\pnum
An expression \tcode{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}.

\pnum
Certain language constructs require that an expression be converted to a Boolean
value. An expression \tcode{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}.

\pnum
Certain language constructs require conversion to a value having
one of a specified set of types appropriate to the construct. An
expression \tcode{e} of class type \tcode{E} 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 \tcode{e} can be implicitly converted to a type \tcode{T}
that is determined as follows:
\tcode{E} 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}.

\pnum
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 \tcode{e}
is used as a glvalue if and only if the initialization uses it as a glvalue.

\pnum
\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}

\pnum
\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}

\pnum
\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.\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}.}
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}.%
\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.}

\pnum
When an lvalue-to-rvalue conversion
is applied to an expression \tcode{e}, and either
\begin{itemize}
\item \tcode{e} is not potentially evaluated, or
\item the evaluation of \tcode{e} results in the evaluation of a member
      \tcode{ex} of the set of potential results of \tcode{e}, and \tcode{ex}
      names a variable \tcode{x} that is not odr-used by
      \tcode{ex}\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 due to access of \tcode{x.n} outside its lifetime
int n = g(true);    // OK, does not access \tcode{y.n}
\end{codeblock}
\end{example}

\pnum
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}

\pnum
\begin{note}
See also~\ref{basic.lval}.
\end{note}

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

\pnum
\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}

\pnum
\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.\footnote{This conversion never applies to non-static member functions because an
lvalue that refers to a non-static member function cannot be obtained.}

\rSec2[conv.rval]{Temporary materialization conversion}
\indextext{conversion!temporary materialization}%

\pnum
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|(}%
\pnum
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}.

\pnum
\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.

\pnum
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}
\item
for every $i > 0$, $\cv{}^3_i$ is the union of
$\cv{}^1_i$ and $\cv{}^2_i$;
\item
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$;
\item
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}

\pnum
\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}

\pnum
\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}

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

\pnum
\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.

\pnum
\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.

\pnum
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.

\pnum
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.

\pnum
\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.

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

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

\pnum
\indextext{promotion!floating-point}%
A prvalue of type \tcode{float} can be converted to a prvalue of type
\tcode{double}. The value is unchanged.

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

\rSec2[conv.integral]{Integral conversions}

\pnum
\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.

\pnum
\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.

\pnum
\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.

\pnum
The conversions allowed as integral promotions are excluded from the set
of integral conversions.

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

\pnum
\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.

\pnum
The conversions allowed as floating-point promotions are excluded from
the set of floating-point conversions.

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

\pnum
\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}

\pnum
\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}

\pnum
\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}

\pnum
A prvalue of type ``pointer to \cv{} \tcode{T}'', where \tcode{T}
is an object type, can be converted to a prvalue of type ``pointer to
\cv{} \tcode{void}''.
The pointer value\iref{basic.compound} is unchanged by this conversion.

\pnum
A prvalue of type ``pointer to \cv{} \tcode{D}'', where \tcode{D}
is a complete class type, can be converted to a prvalue of type ``pointer to
\cv{} \tcode{B}'', where \tcode{B} is a base class\iref{class.derived}
of \tcode{D}. If \tcode{B} is an
inaccessible\iref{class.access} or
ambiguous\iref{class.member.lookup} base class of \tcode{D}, a program
that necessitates this conversion is ill-formed. The result of the
conversion is a pointer to the base class subobject of the derived class
object. The null pointer value is converted to the null pointer value of
the destination type.

\rSec2[conv.mem]{Pointer-to-member conversions}

\pnum
\indextext{conversion!pointer-to-member}%
\indextext{null member pointer conversion|see{conversion, null member pointer}}%
\indextext{constant!null pointer}%
A null pointer constant\iref{conv.ptr} can be converted to a
pointer-to-member
type; the result is the \defnx{null member pointer value}{value!null member pointer}
of that type and is distinguishable from any pointer to member not
created from a null pointer constant.
Such a conversion is called a \defnx{null member pointer conversion}{conversion!null member pointer}.
Two null member pointer values of
the same type shall compare equal. The conversion of a null pointer
constant to a pointer to member of cv-qualified type is a single
conversion, and not the sequence of a pointer-to-member conversion
followed by a qualification conversion\iref{conv.qual}.

\pnum
A prvalue of type ``pointer to member of \tcode{B} of type \cv{}
\tcode{T}'', where \tcode{B} is a class type, can be converted to
a prvalue of type ``pointer to member of \tcode{D} of type \cv{}
\tcode{T}'', where \tcode{D} is a complete class derived\iref{class.derived}
from \tcode{B}. If \tcode{B} is an
inaccessible\iref{class.access},
ambiguous\iref{class.member.lookup}, or virtual\iref{class.mi} base
class of \tcode{D}, or a base class of a virtual base class of
\tcode{D}, a program that necessitates this conversion is ill-formed.
The result of the conversion refers to the same member as the pointer to
member before the conversion took place, but it refers to the base class
member as if it were a member of the derived class. The result refers to
the member in \tcode{D}'s instance of \tcode{B}. Since the result has
type ``pointer to member of \tcode{D} of type \cv{} \tcode{T}'',
indirection through it with a \tcode{D} object is valid. The result is the same
as if indirecting through the pointer to member of \tcode{B} with the
\tcode{B} subobject of \tcode{D}. The null member pointer value is
converted to the null member pointer value of the destination
type.\footnote{The rule for conversion of pointers to members (from pointer to member
of base to pointer to member of derived) appears inverted compared to
the rule for pointers to objects (from pointer to derived to pointer to
base)~(\ref{conv.ptr}, \ref{class.derived}). This inversion is
necessary to ensure type safety. Note that a pointer to member is not
an object pointer or a function pointer
and the rules for conversions
of such pointers do not apply to pointers to members.
\indextext{conversion!pointer-to-member!\idxcode{void*}}%
In particular, a pointer to member cannot be converted to a
\tcode{void*}.}

\rSec2[conv.fctptr]{Function pointer conversions}

\pnum
\indextext{conversion!function pointer}%
A prvalue of type ``pointer to \tcode{noexcept} function''
can be converted to a prvalue of type ``pointer to function''.
The result is a pointer to the function.
A prvalue of type ``pointer to member of type \tcode{noexcept} function''
can be converted to a prvalue of type ``pointer to member of type function''.
The result designates the member function.

\begin{example}
\begin{codeblock}
void (*p)();
void (**pp)() noexcept = &p;    // error: cannot convert to pointer to \tcode{noexcept} function

struct S { typedef void (*p)(); operator p(); };
void (*q)() noexcept = S();     // error: cannot convert to pointer to \tcode{noexcept} function
\end{codeblock}
\end{example}

\rSec2[conv.bool]{Boolean conversions}

\pnum
\indextext{conversion!boolean}%
A prvalue of arithmetic, unscoped enumeration, pointer, or pointer-to-member
type can be converted to a prvalue of type \tcode{bool}. A zero value, null
pointer value, or null member pointer value is converted to \tcode{false}; any
other value is converted to \tcode{true}.

\indextext{conversion!standard|)}

\rSec1[expr.arith.conv]{Usual arithmetic conversions}

\pnum
Many binary operators that expect operands of arithmetic or enumeration
type cause conversions and yield result types in a similar way. The
purpose is to yield a common type, which is also the type of the result.
This pattern is called the \defnx{usual arithmetic conversions}{conversion!usual arithmetic},
which are defined as follows:

\begin{itemize}
\item If either operand is of scoped enumeration type\iref{dcl.enum}, no conversions
are performed; if the other operand does not have the same type, the expression is
ill-formed.

\item If either operand is of type \tcode{long double}, the
other shall be converted to \tcode{long double}.

\item Otherwise, if either operand is \tcode{double}, the other shall be
converted to \tcode{double}.

\item Otherwise, if either operand is \tcode{float}, the other shall be
converted to \tcode{float}.

\item Otherwise, the integral promotions\iref{conv.prom} shall be
performed on both operands.\footnote{As a consequence, operands of type \tcode{bool}, \tcode{char8_t}, \tcode{char16_t},
\tcode{char32_t}, \tcode{wchar_t}, or an enumerated type are converted
to some integral type.}
Then the following rules shall be applied to the promoted operands:

\begin{itemize}

\item If both operands have the same type, no further conversion is
needed.

\item Otherwise, if both operands have signed integer types or both have
unsigned integer types, the operand with the type of lesser integer
conversion rank shall be converted to the type of the operand with
greater rank.

\item Otherwise, if the operand that has unsigned integer type has rank
greater than or equal to the rank of the type of the other operand, the
operand with signed integer type shall be converted to the type of the
operand with unsigned integer type.

\item Otherwise, if the type of the operand with signed integer type can
represent all of the values of the type of the operand with unsigned
integer type, the operand with unsigned integer type shall be converted
to the type of the operand with signed integer type.

\item Otherwise, both operands shall be converted to the unsigned
integer type corresponding to the type of the operand with signed
integer type.
\end{itemize}
\end{itemize}

\pnum
If one operand is of enumeration type
and the other operand is of
a different enumeration type or
a floating-point type,
this behavior is deprecated\iref{depr.arith.conv.enum}.

\rSec1[expr.prim]{Primary expressions}%
\indextext{expression!primary|(}

\begin{bnf}
\nontermdef{primary-expression}\br
    literal\br
    \keyword{this}\br
    \terminal{(} expression \terminal{)}\br
    id-expression\br
    lambda-expression\br
    fold-expression\br
    requires-expression
\end{bnf}

\rSec2[expr.prim.literal]{Literals}

\pnum
A
\indextext{literal}%
\indextext{constant}%
\grammarterm{literal}
is a primary expression.
Its type depends on its form\iref{lex.literal}.
A string literal is an lvalue; all other literals are prvalues.

\rSec2[expr.prim.this]{This}

\pnum
\indextext{\idxcode{this}}%
The keyword \tcode{this} names a pointer to the object for which a non-static member
function\iref{class.this} is invoked or a non-static data member's
initializer\iref{class.mem} is evaluated.

\pnum
If a declaration declares a member function or member function template of a
class \tcode{X}, the expression \tcode{this} is a prvalue of type ``pointer to
\grammarterm{cv-qualifier-seq} \tcode{X}'' between the optional
\grammarterm{cv-qualifier-seq} and the end of the \grammarterm{function-definition},
\grammarterm{member-declarator}, or \grammarterm{declarator}. It shall not appear
before the optional \grammarterm{cv-qualifier-seq} and it shall not appear within
the declaration of a static member function (although its type and value category
are defined within a static member function as they are within a non-static
member function).
\begin{note}
This is because declaration matching does not
occur until the complete declarator is known.
\end{note}
\begin{note}
In a \grammarterm{trailing-return-type},
the class being defined is not required to be complete
for purposes of class member access\iref{expr.ref}.
Class members declared later are not visible.
\begin{example}
\begin{codeblock}
struct A {
  char g();
  template<class T> auto f(T t) -> decltype(t + g())
    { return t + g(); }
};
template auto A::f(int t) -> decltype(t + g());
\end{codeblock}
\end{example}
\end{note}

\pnum
Otherwise, if a \grammarterm{member-declarator} declares a non-static data
member\iref{class.mem} of a class \tcode{X}, the expression \tcode{this} is
a prvalue of type ``pointer to \tcode{X}'' within the
optional default member initializer\iref{class.mem}. It shall not appear elsewhere
in the \grammarterm{member-declarator}.

\pnum
The expression \tcode{this} shall not appear in any other context.
\begin{example}
\begin{codeblock}
class Outer {
  int a[sizeof(*this)];                 // error: not inside a member function
  unsigned int sz = sizeof(*this);      // OK: in default member initializer

  void f() {
    int b[sizeof(*this)];               // OK

    struct Inner {
      int c[sizeof(*this)];             // error: not inside a member function of \tcode{Inner}
    };
  }
};
\end{codeblock}
\end{example}

\rSec2[expr.prim.paren]{Parentheses}

\pnum
\indextext{expression!parenthesized}%
A parenthesized expression \tcode{(E)}
is a primary expression whose type, value, and value category are identical to those of \tcode{E}.
The parenthesized expression can be used in exactly the same contexts as
those where \tcode{E} can be used, and with the same
meaning, except as otherwise indicated.

\rSec2[expr.prim.id]{Names}

\begin{bnf}
\nontermdef{id-expression}\br
    unqualified-id\br
    qualified-id
\end{bnf}

\pnum
\indextext{name}%
\indextext{id-expression}%
An \grammarterm{id-expression} is a restricted form of a
\grammarterm{primary-expression}.
\begin{note}
An \grammarterm{id-expression} can appear after \tcode{.} and \tcode{->}
operators\iref{expr.ref}.
\end{note}

\pnum
An \grammarterm{id-expression} that denotes a non-static data member or
non-static member function of a class can only be used:
\begin{itemize}
\item as part of a class member access\iref{expr.ref} in which the
object expression
refers to the member's class\footnote{This also applies when the object expression
is an implicit \tcode{(*this)}~(\ref{class.mfct.non-static}).} or a class derived from
that class, or

\item to form a pointer to member\iref{expr.unary.op}, or

\item if that \grammarterm{id-expression} denotes a non-static data member
and it appears in an unevaluated operand.
\begin{example}
\begin{codeblock}
struct S {
  int m;
};
int i = sizeof(S::m);           // OK
int j = sizeof(S::m + 42);      // OK
\end{codeblock}
\end{example}
\end{itemize}

\pnum
An \grammarterm{id-expression}
that denotes an immediate function\iref{dcl.constexpr}
shall appear only
\begin{itemize}
\item as a subexpression of an immediate invocation, or
\item in an immediate function context\iref{expr.const}.
\end{itemize}

\pnum
For an \grammarterm{id-expression} that denotes an overload set,
overload resolution is performed
to select a unique function~(\ref{over.match}, \ref{over.over}).
\begin{note}
A program cannot refer to a function
with a trailing \grammarterm{requires-clause}
whose \grammarterm{constraint-expression} is not satisfied,
because such functions are never selected by overload resolution.
\begin{example}
\begin{codeblock}
template<typename T> struct A {
  static void f(int) requires false;
}

void g() {
  A<int>::f(0);                         // error: cannot call \tcode{f}
  void (*p1)(int) = A<int>::f;          // error: cannot take the address of \tcode{f}
  decltype(A<int>::f)* p2 = nullptr;    // error: the type \tcode{decltype(A<int>::f)} is invalid
}
\end{codeblock}
In each case, the constraints of \tcode{f} are not satisfied.
In the declaration of \tcode{p2},
those constraints are required to be satisfied
even though
\tcode{f} is an unevaluated operand\iref{expr.prop}.
\end{example}
\end{note}

\rSec3[expr.prim.id.unqual]{Unqualified names}

\begin{bnf}
\nontermdef{unqualified-id}\br
    identifier\br
    operator-function-id\br
    conversion-function-id\br
    literal-operator-id\br
    \terminal{\~} type-name\br
    \terminal{\~} decltype-specifier\br
    template-id
\end{bnf}

\pnum
\indextext{identifier}%
An \grammarterm{identifier} is only
an \grammarterm{id-expression} if it has
been suitably declared\iref{dcl.dcl}
or if it appears as part of a \grammarterm{declarator-id}\iref{dcl.decl}.
\begin{note}
For \grammarterm{operator-function-id}{s}, see~\ref{over.oper}; for
\grammarterm{conversion-function-id}{s}, see~\ref{class.conv.fct}; for
\grammarterm{literal-operator-id}{s}, see~\ref{over.literal}; for
\grammarterm{template-id}{s}, see~\ref{temp.names}.
A \grammarterm{type-name} or \grammarterm{decltype-specifier}
prefixed by \tcode{\~} denotes the destructor of the type so named;
see~\ref{expr.prim.id.dtor}.
Within the definition of a non-static member function, an
\grammarterm{identifier} that names a non-static member is transformed to a
class member access expression~(\ref{class.mfct.non-static}).
\end{note}

\pnum
The result is the entity denoted by the identifier.
If the entity is a local entity
and naming it from outside of an unevaluated operand
within the declarative region where the \grammarterm{unqualified-id} appears
would result in some intervening \grammarterm{lambda-expression}
capturing it by copy\iref{expr.prim.lambda.capture},
the type of the expression is
the type of a class member access expression\iref{expr.ref}
naming the non-static data member
that would be declared for such a capture
in the closure object of
the innermost such intervening \grammarterm{lambda-expression}.
\begin{note}
If that \grammarterm{lambda-expression} is not declared \tcode{mutable},
the type of such an identifier will typically be \tcode{const} qualified.
\end{note}
The type of the expression is the type of the result.
\begin{note}
If the entity is a template parameter object for
a template parameter of type \tcode{T}\iref{temp.param},
the type of the expression is \tcode{const T}.
\end{note}
\begin{note}
The type will be adjusted as described in \ref{expr.type}
if it is cv-qualified or is a reference type.
\end{note}
The expression is an lvalue
if the entity is a function, variable, structured binding\iref{dcl.struct.bind}, data member, or
template parameter object
and a prvalue otherwise\iref{basic.lval};
it is a bit-field if the identifier designates a bit-field.
\begin{example}
\begin{codeblock}
void f() {
  float x, &r = x;
  [=] {
    decltype(x) y1;             // \tcode{y1} has type \tcode{float}
    decltype((x)) y2 = y1;      // \tcode{y2} has type \tcode{float const\&} because this lambda
                                // is not \tcode{mutable} and \tcode{x} is an lvalue
    decltype(r) r1 = y1;        // \tcode{r1} has type \tcode{float\&}
    decltype((r)) r2 = y2;      // \tcode{r2} has type \tcode{float const\&}
  };
}
\end{codeblock}
\end{example}

\rSec3[expr.prim.id.qual]{Qualified names}

\indextext{operator!scope resolution}%
\indextext{\idxcode{::}|see{operator, scope resolution}}%
%
\begin{bnf}
\nontermdef{qualified-id}\br
    nested-name-specifier \opt{\keyword{template}} unqualified-id
\end{bnf}

\indextext{operator!scope resolution}%
\indextext{name hiding}%
%
\begin{bnf}
\nontermdef{nested-name-specifier}\br
    \terminal{::}\br
    type-name \terminal{::}\br
    namespace-name \terminal{::}\br
    decltype-specifier \terminal{::}\br
    nested-name-specifier identifier \terminal{::}\br
    nested-name-specifier \opt{\keyword{template}} simple-template-id \terminal{::}
\end{bnf}

\pnum
The type denoted by a \grammarterm{decltype-specifier} in a
\grammarterm{nested-name-specifier} shall be a class or enumeration
type.

\pnum
A \grammarterm{nested-name-specifier} that denotes a class, optionally
followed by the keyword \tcode{template}\iref{temp.names}, and then
followed by the name of a member of either that class\iref{class.mem}
or one of its base classes\iref{class.derived}, is a
\indextext{id!qualified}%
\grammarterm{qualified-id};~\ref{class.qual} describes name lookup for
class members that appear in \grammarterm{qualified-id}{s}. The result is the
member. The type of the result is the type of the member. The result is
an lvalue if the member is a static member function or a data member and a
prvalue otherwise.
\begin{note}
A class member can be referred to using a \grammarterm{qualified-id} at any
point in its potential scope\iref{basic.scope.class}.
\end{note}
Where
\grammarterm{type-name} \tcode{::\~}~\grammarterm{type-name} is used,
the two \grammarterm{type-name}{s} shall refer to the same type
(ignoring cv-qualifications);
this notation denotes the destructor of the type so named\iref{expr.prim.id.dtor}.
The \grammarterm{unqualified-id} in a \grammarterm{qualified-id}
shall not be of the form \tcode{\~}\grammarterm{decltype-specifier}.

\pnum
The \grammarterm{nested-name-specifier} \tcode{::} names the global namespace.
A \grammarterm{nested-name-specifier} that names a
namespace\iref{basic.namespace}, optionally followed by the keyword
\tcode{template}\iref{temp.names}, and then followed by the name of a member
of that namespace (or the name of a member of a namespace made visible by a
\grammarterm{using-directive}), is a
\indextext{id!qualified}%
\grammarterm{qualified-id};~\ref{namespace.qual} describes name lookup for
namespace members that appear in \grammarterm{qualified-id}{s}. The result is
the member. The type of the result is the type of the member. The result
is an lvalue if the member is a function, a variable, or a structured binding\iref{dcl.struct.bind} and a prvalue otherwise.

\pnum
A \grammarterm{nested-name-specifier} that denotes an
enumeration\iref{dcl.enum}, followed by the name of an
enumerator of that enumeration, is a \grammarterm{qualified-id}
that refers to the enumerator. The result is the enumerator. The type
of the result is the type of the enumeration. The result is a prvalue.

\pnum
In a \grammarterm{qualified-id}, if the
\grammarterm{unqualified-id}
is a
\grammarterm{conversion-function-id}, its \grammarterm{conversion-type-id}
is first looked up in the class denoted by
the \grammarterm{nested-name-specifier} of the \grammarterm{qualified-id} and
the name, if found, is used.
Otherwise, it is looked up in the context in which
the entire \grammarterm{qualified-id} occurs.
In each of these lookups, only names that denote types or
templates whose specializations are types are considered.

\rSec3[expr.prim.id.dtor]{Destruction}

\pnum
\indextext{expression!destructor call}%
\indextext{expression!pseudo-destructor call}%
An \grammarterm{id-expression} that denotes the destructor of a type \tcode{T}
names the destructor of \tcode{T}
if \tcode{T} is a class type\iref{class.dtor},
otherwise the \grammarterm{id-expression} is said
to name a \defn{pseudo-destructor}.

\pnum
If the \grammarterm{id-expression} names a pseudo-destructor,
\tcode{T} shall be a scalar type and
the \grammarterm{id-expression} shall appear
as the right operand of a class member access\iref{expr.ref} that forms
the \grammarterm{postfix-expression} of a function call\iref{expr.call}.
\begin{note}
Such a call has no effect.
\end{note}

\pnum
\begin{example}
\begin{codeblock}
struct C { };
void f() {
  C * pc = new C;
  using C2 = C;
  pc->C::~C2();     // OK, destroys \tcode{*pc}
  C().C::~C();      // undefined behavior: temporary of type \tcode{C} destroyed twice
  using T = int;
  0 .T::~T();       // OK, no effect
  0.T::~T();        // error: \tcode{0.T} is a \grammarterm{user-defined-floating-point-literal}\iref{lex.ext}
}
\end{codeblock}
\end{example}

\rSec2[expr.prim.lambda]{Lambda expressions}%
\indextext{expression!lambda|(}

\begin{bnf}
\nontermdef{lambda-expression}\br
    lambda-introducer \opt{lambda-declarator} compound-statement\br
    lambda-introducer \terminal{<} template-parameter-list \terminal{>} \opt{requires-clause} \opt{lambda-declarator} compound-statement
\end{bnf}

\begin{bnf}
\nontermdef{lambda-introducer}\br
    \terminal{[} \opt{lambda-capture} \terminal{]}
\end{bnf}

\begin{bnf}
\nontermdef{lambda-declarator}\br
    \terminal{(} parameter-declaration-clause \terminal{)} \opt{decl-specifier-seq}\br
    \bnfindent\opt{noexcept-specifier} \opt{attribute-specifier-seq} \opt{trailing-return-type} \opt{requires-clause}
\end{bnf}

\pnum
A \grammarterm{lambda-expression} provides
a concise way to create a simple function object.
\begin{example}
\begin{codeblock}
#include <algorithm>
#include <cmath>
void abssort(float* x, unsigned N) {
  std::sort(x, x + N, [](float a, float b) { return std::abs(a) < std::abs(b); });
}
\end{codeblock}
\end{example}

\pnum
A \grammarterm{lambda-expression} is a prvalue
whose result object is called the \defn{closure object}.
\begin{note}
A closure object behaves like a function
object\iref{function.objects}.
\end{note}

\pnum
In the \grammarterm{decl-specifier-seq} of the \grammarterm{lambda-declarator},
each \grammarterm{decl-specifier}
shall be one of \tcode{mutable}, \tcode{constexpr}, or \tcode{consteval}.
\begin{note}
The trailing \grammarterm{requires-clause} is described in \ref{dcl.decl}.
\end{note}

\pnum
If a \grammarterm{lambda-expression} does not include a
\grammarterm{lambda-declarator}, it is as if the \grammarterm{lambda-declarator} were
\tcode{()}.
The lambda return type is \tcode{auto}, which is replaced by the
type specified by the
\grammarterm{trailing-return-type} if provided and/or deduced from
\tcode{return} statements as described in~\ref{dcl.spec.auto}.
\begin{example}
\begin{codeblock}
auto x1 = [](int i){ return i; };       // OK: return type is \tcode{int}
auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from \grammarterm{braced-init-list}
int j;
auto x3 = []()->auto&& { return j; };   // OK: return type is \tcode{int\&}
\end{codeblock}
\end{example}

\pnum
A lambda is a \defn{generic lambda}
if there is a \grammarterm{decl-specifier} that is
a \grammarterm{placeholder-type-specifier} in
the \grammarterm{decl-specifier-seq} of a
\grammarterm{parameter-declaration} of the \grammarterm{lambda-expression},
or if the lambda has a \grammarterm{template-parameter-list}.
\begin{example}
\begin{codeblock}
int i = [](int i, auto a) { return i; }(3, 4);                  // OK: a generic lambda
int j = []<class T>(T t, int i) { return i; }(3, 4);            // OK: a generic lambda
\end{codeblock}
\end{example}

\rSec3[expr.prim.lambda.closure]{Closure types}%

\pnum
The type of a \grammarterm{lambda-expression} (which is also the type of the
closure object) is a unique, unnamed non-union class type,
called the \defn{closure type},
whose properties are described below.

\pnum
The closure type is declared in the smallest block
scope, class scope, or namespace scope that contains the corresponding
\grammarterm{lambda-expression}.
\begin{note}
This determines the set of namespaces and
classes associated with the closure type\iref{basic.lookup.argdep}. The parameter
types of a \grammarterm{lambda-declarator} do not affect these associated namespaces and
classes.
\end{note}
The closure type is not an aggregate type\iref{dcl.init.aggr}.
An implementation may define the closure type differently from what
is described below provided this does not alter the observable behavior of the program
other than by changing:
\begin{itemize}
\item the size and/or alignment of the closure type,

\item whether the closure type is trivially copyable\iref{class.prop}, or

\item whether the closure type is a standard-layout class\iref{class.prop}.
\end{itemize}

An implementation shall not add members of rvalue reference type to the closure
type.

\pnum
The closure type for a \grammarterm{lambda-expression} has a public
inline function call operator (for a non-generic lambda) or
function call operator template (for a generic lambda)\iref{over.call}
whose parameters and return type
are described by the \grammarterm{lambda-expression}'s
\grammarterm{parameter-declaration-clause} and \grammarterm{trailing-return-type}
respectively, and whose
\grammarterm{template-parameter-list} consists of
the specified \grammarterm{template-parameter-list}, if any.
The \grammarterm{requires-clause} of the function call operator template
is the \grammarterm{requires-clause} immediately following
\tcode{<}~\grammarterm{template-parameter-list}{}~\tcode{>}, if any.
The trailing \grammarterm{requires-clause} of the function call operator
or operator template is the \grammarterm{requires-clause}
of the \grammarterm{lambda-declarator}, if any.
\begin{note}
The function call operator for a generic lambda might be
an abbreviated function template\iref{dcl.fct}.
\end{note}
\begin{example}
\begin{codeblock}
auto glambda = [](auto a, auto&& b) { return a < b; };
bool b = glambda(3, 3.14);                                      // OK

auto vglambda = [](auto printer) {
  return [=](auto&& ... ts) {                                   // OK: \tcode{ts} is a function parameter pack
    printer(std::forward<decltype(ts)>(ts)...);

    return [=]() {
      printer(ts ...);
    };
  };
};
auto p = vglambda( [](auto v1, auto v2, auto v3)
                   { std::cout << v1 << v2 << v3; } );
auto q = p(1, 'a', 3.14);                                       // OK: outputs \tcode{1a3.14}
q();                                                            // OK: outputs \tcode{1a3.14}
\end{codeblock}
\end{example}

\pnum
The function call operator or operator template is declared
\tcode{const}~(\ref{class.mfct.non-static}) if and only if the
\grammarterm{lambda-expression}'s \grammarterm{parameter-declaration-clause} is not
followed by \tcode{mutable}. It is neither virtual nor declared \tcode{volatile}. Any
\grammarterm{noexcept-specifier} specified on a \grammarterm{lambda-expression}
applies to the corresponding function call operator or operator template.
An \grammarterm{attribute-specifier-seq} in a \grammarterm{lambda-declarator} appertains
to the type of the corresponding function call operator or operator template.
The function call operator or any given operator template specialization
is a constexpr function if either
the corresponding \grammarterm{lambda-expression}{'s}
\grammarterm{parameter-declaration-clause}
is followed by \tcode{constexpr} or \tcode{consteval}, or
it satisfies the requirements for a constexpr function\iref{dcl.constexpr}.
It is an immediate function\iref{dcl.constexpr}
if the corresponding \grammarterm{lambda-expression}{'s}
\grammarterm{parameter-declaration-clause} is followed by \tcode{consteval}.
\begin{note}
Names referenced in
the \grammarterm{lambda-declarator} are looked up in the context in which the
\grammarterm{lambda-expression} appears.
\end{note}
\begin{example}
\begin{codeblock}
auto ID = [](auto a) { return a; };
static_assert(ID(3) == 3);                      // OK

struct NonLiteral {
  NonLiteral(int n) : n(n) { }
  int n;
};
static_assert(ID(NonLiteral{3}).n == 3);        // ill-formed
\end{codeblock}
\end{example}

\pnum
\begin{example}
\begin{codeblock}
auto monoid = [](auto v) { return [=] { return v; }; };
auto add = [](auto m1) constexpr {
  auto ret = m1();
  return [=](auto m2) mutable {
    auto m1val = m1();
    auto plus = [=](auto m2val) mutable constexpr
                   { return m1val += m2val; };
    ret = plus(m2());
    return monoid(ret);
  };
};
constexpr auto zero = monoid(0);
constexpr auto one = monoid(1);
static_assert(add(one)(zero)() == one());       // OK

// Since \tcode{two} below is not declared \tcode{constexpr}, an evaluation of its \tcode{constexpr} member function call operator
// cannot perform an lvalue-to-rvalue conversion on one of its subobjects (that represents its capture)
// in a constant expression.
auto two = monoid(2);
assert(two() == 2); // OK, not a constant expression.
static_assert(add(one)(one)() == two());        // ill-formed: \tcode{two()} is not a constant expression
static_assert(add(one)(one)() == monoid(2)());  // OK
\end{codeblock}
\end{example}

\pnum
\begin{note}
The function call operator or operator template may be constrained\iref{temp.constr.decl}
by a \grammarterm{type-constraint}\iref{temp.param},
a \grammarterm{requires-clause}\iref{temp.pre},
or a trailing \grammarterm{requires-clause}\iref{dcl.decl}.
\begin{example}
\begin{codeblock}
template <typename T> concept C1 = @\commentellip@;
template <std::size_t N> concept C2 = @\commentellip@;
template <typename A, typename B> concept C3 = @\commentellip@;

auto f = []<typename T1, C1 T2> requires C2<sizeof(T1) + sizeof(T2)>
         (T1 a1, T1 b1, T2 a2, auto a3, auto a4) requires C3<decltype(a4), T2> {
  // \tcode{T2} is constrained by a \grammarterm{type-constraint}.
  // \tcode{T1} and \tcode{T2} are constrained by a \grammarterm{requires-clause}, and
  // \tcode{T2} and the type of \tcode{a4} are constrained by a trailing \grammarterm{requires-clause}.
};
\end{codeblock}
\end{example}
\end{note}

\pnum
The closure type for a non-generic \grammarterm{lambda-expression} with no
\grammarterm{lambda-capture}
whose constraints (if any) are satisfied
has a conversion function to pointer to
function with \Cpp{} language linkage\iref{dcl.link} having
the same parameter and return types as the closure type's function call operator.
The conversion is to ``pointer to \tcode{noexcept} function''
if the function call operator
has a non-throwing exception specification.
The value returned by this conversion function
is the address of a function \tcode{F} that, when invoked,
has the same effect as invoking the closure type's function call operator
on a default-constructed instance of the closure type.
\tcode{F} is a constexpr function
if the function call operator is a constexpr function
and is an immediate function
if the function call operator is an immediate function.

\pnum
For a generic lambda with no \grammarterm{lambda-capture}, the closure type has a
conversion function template to
pointer to function. The conversion function template has the same invented
template parameter list, and the pointer to function has the same
parameter types, as the function call operator template.  The return type of
the pointer to function shall behave as if it were a
\grammarterm{decltype-specifier} denoting the return type of the corresponding
function call operator template specialization.

\pnum
\begin{note}
If the generic lambda has no \grammarterm{trailing-return-type} or
the \grammarterm{trailing-return-type} contains a placeholder type, return type
deduction of the corresponding function call operator template specialization
has to be done. The corresponding specialization is that instantiation of the
function call operator template with the same template arguments as those
deduced for the conversion function template.  Consider the following:
\begin{codeblock}
auto glambda = [](auto a) { return a; };
int (*fp)(int) = glambda;
\end{codeblock}
The behavior of the conversion function of \tcode{glambda} above is like
that of the following conversion function:
\begin{codeblock}
struct Closure {
  template<class T> auto operator()(T t) const { @\commentellip@ }
  template<class T> static auto lambda_call_operator_invoker(T a) {
    // forwards execution to \tcode{operator()(a)} and therefore has
    // the same return type deduced
    @\commentellip@
  }
  template<class T> using fptr_t =
     decltype(lambda_call_operator_invoker(declval<T>())) (*)(T);

  template<class T> operator fptr_t<T>() const
    { return &lambda_call_operator_invoker; }
};
\end{codeblock}
\end{note}

\begin{example}
\begin{codeblock}
void f1(int (*)(int))   { }
void f2(char (*)(int))  { }

void g(int (*)(int))    { }     // \#1
void g(char (*)(char))  { }     // \#2

void h(int (*)(int))    { }     // \#3
void h(char (*)(int))   { }     // \#4

auto glambda = [](auto a) { return a; };
f1(glambda);                    // OK
f2(glambda);                    // error: ID is not convertible
g(glambda);                     // error: ambiguous
h(glambda);                     // OK: calls \#3 since it is convertible from ID
int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
\end{codeblock}
\end{example}

\pnum
The value returned by any given specialization of this conversion function
template is the address of a function \tcode{F} that, when invoked, has the same
effect as invoking the generic lambda's corresponding function call operator
template specialization on a default-constructed instance of the closure type.
\tcode{F} is a constexpr function
if the corresponding specialization is a constexpr function and
\tcode{F} is an immediate function
if the function call operator template specialization is an immediate function.
\begin{note}
This will result in the implicit instantiation of the generic lambda's body.
The instantiated generic lambda's return type and parameter types are required to match
the return type and parameter types of the pointer to function.
\end{note}
\begin{example}
\begin{codeblock}
auto GL = [](auto a) { std::cout << a; return a; };
int (*GL_int)(int) = GL;        // OK: through conversion function template
GL_int(3);                      // OK: same as \tcode{GL(3)}
\end{codeblock}
\end{example}

\pnum
The conversion function or conversion function template is public,
constexpr, non-virtual, non-explicit, const, and has a non-throwing exception
specification\iref{except.spec}.
\begin{example}
\begin{codeblock}
auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
auto C = [](auto a) { return a; };

static_assert(Fwd(C,3) == 3);   // OK

// No specialization of the function call operator template can be constexpr (due to the local static).
auto NC = [](auto a) { static int s; return a; };
static_assert(Fwd(NC,3) == 3);  // ill-formed
\end{codeblock}
\end{example}

\pnum
The \grammarterm{lambda-expression}'s \grammarterm{compound-statement} yields the
\grammarterm{function-body}\iref{dcl.fct.def} of the function call operator, but for
purposes of name lookup\iref{basic.lookup}, determining the type and value of
\tcode{this}\iref{class.this} and transforming \grammarterm{id-expression}{s}
referring to non-static class members into class member access expressions using
\tcode{(*this)}~(\ref{class.mfct.non-static}), the \grammarterm{compound-statement} is
considered in the context of the \grammarterm{lambda-expression}.
\begin{example}
\begin{codeblock}
struct S1 {
  int x, y;
  int operator()(int);
  void f() {
    [=]()->int {
      return operator()(this->x + y);   // equivalent to \tcode{S1::operator()(this->x + (*this).y)}
                                        // \tcode{this} has type \tcode{S1*}
    };
  }
};
\end{codeblock}
\end{example}
Further, a variable \mname{func} is implicitly defined at the beginning of
the \grammarterm{compound-statement} of the \grammarterm{lambda-expression},
with semantics as described in~\ref{dcl.fct.def.general}.

\pnum
The closure type associated with a \grammarterm{lambda-expression} has no
default constructor
if the \grammarterm{lambda-expression} has a \grammarterm{lambda-capture}
and a defaulted default constructor otherwise.
It has a defaulted copy constructor and a defaulted move constructor\iref{class.copy.ctor}.
It has a deleted copy assignment operator if the \grammarterm{lambda-expression}
has a \grammarterm{lambda-capture} and defaulted copy and move assignment
operators otherwise\iref{class.copy.assign}.
\begin{note}
These special member functions are implicitly defined as
usual, and might therefore be defined as deleted.
\end{note}

\pnum
The closure type associated with a \grammarterm{lambda-expression} has an
implicitly-declared destructor\iref{class.dtor}.

\pnum
A member of a closure type shall not be
explicitly instantiated\iref{temp.explicit},
explicitly specialized\iref{temp.expl.spec}, or
named in a friend declaration\iref{class.friend}.

\rSec3[expr.prim.lambda.capture]{Captures}%

\begin{bnf}
\nontermdef{lambda-capture}\br
    capture-default\br
    capture-list\br
    capture-default \terminal{,} capture-list
\end{bnf}

\begin{bnf}
\nontermdef{capture-default}\br
    \terminal{\&}\br
    \terminal{=}
\end{bnf}

\begin{bnf}
\nontermdef{capture-list}\br
    capture\br
    capture-list \terminal{,} capture
\end{bnf}

\begin{bnf}
\nontermdef{capture}\br
    simple-capture \opt{\terminal{...}}\br
    % FIXME: This is wrong. The ... should go after the &.
    \opt{\terminal{...}} init-capture
\end{bnf}

\begin{bnf}
\nontermdef{simple-capture}\br
    identifier\br
    \terminal{\&} identifier\br
    \keyword{this}\br
    \terminal{*} \terminal{this}
\end{bnf}

\begin{bnf}
\nontermdef{init-capture}\br
    identifier initializer\br
    \terminal{\&} identifier initializer
\end{bnf}

\pnum
The body of a \grammarterm{lambda-expression} may refer to variables
with automatic storage duration and the \tcode{*this} object (if any)
of enclosing block scopes by capturing those entities, as described
below.

\pnum
If a \grammarterm{lambda-capture} includes a \grammarterm{capture-default} that
is \tcode{\&}, no identifier in a \grammarterm{simple-capture} of that
\grammarterm{lambda-capture} shall be preceded
by \tcode{\&}. If a \grammarterm{lambda-capture} includes a
\grammarterm{capture-default} that is \tcode{=}, each
\grammarterm{simple-capture} of that \grammarterm{lambda-capture} shall
be of the form
``\tcode{\&} \grammarterm{identifier}'',
``\tcode{this}'',
or ``\tcode{* this}''.
\begin{note}
The form \tcode{[\&,this]} is redundant but accepted
for compatibility with ISO \CppXIV{}.
\end{note}
Ignoring appearances in
\grammarterm{initializer}{s} of \grammarterm{init-capture}{s}, an identifier or
\tcode{this} shall not appear more than once in a
\grammarterm{lambda-capture}.
\begin{example}
\begin{codeblock}
struct S2 { void f(int i); };
void S2::f(int i) {
  [&, i]{ };        // OK
  [&, this, i]{ };  // OK, equivalent to \tcode{[\&, i]}
  [&, &i]{ };       // error: \tcode{i} preceded by \tcode{\&} when \tcode{\&} is the default
  [=, *this]{ };    // OK
  [=, this]{ };     // OK, equivalent to \tcode{[=]}
  [i, i]{ };        // error: \tcode{i} repeated
  [this, *this]{ }; // error: \tcode{this} appears twice
}
\end{codeblock}
\end{example}

\pnum
A \grammarterm{lambda-expression} shall not have
a \grammarterm{capture-default} or \grammarterm{simple-capture}
in its \grammarterm{lambda-introducer}
unless its innermost enclosing scope is a block scope\iref{basic.scope.block}
or it appears within a default member initializer
and its innermost enclosing scope is
the corresponding class scope\iref{basic.scope.class}.

\pnum
The \grammarterm{identifier} in a \grammarterm{simple-capture} is looked up using the
usual rules for unqualified name lookup\iref{basic.lookup.unqual}; each such lookup
shall find a local entity.
The \grammarterm{simple-capture}{s} \tcode{this} and \tcode{* this}
denote the local entity \tcode{*this}.
An entity that is designated by a
\grammarterm{simple-capture}
is said to be \defn{explicitly captured}.

\pnum
If an \grammarterm{identifier} in a \grammarterm{simple-capture} appears
as the \grammarterm{declarator-id} of a parameter of
the \grammarterm{lambda-declarator}{'s} \grammarterm{parameter-declaration-clause},
the program is ill-formed.
\begin{example}
\begin{codeblock}
void f() {
  int x = 0;
  auto g = [x](int x) { return 0; };    // error: parameter and \grammarterm{simple-capture} have the same name
}
\end{codeblock}
\end{example}

\pnum
An \grammarterm{init-capture} behaves as if it declares and explicitly captures a
variable of
the form ``\tcode{auto} \grammarterm{init-capture} \tcode{;}''
whose declarative region is the \grammarterm{lambda-expression}'s
\grammarterm{compound-statement}, except that:
\begin{itemize}
\item if the capture is by copy (see below), the non-static data member
declared for the capture and the variable are treated as two different ways
of referring to the same object, which has the lifetime of the non-static
data member, and no additional copy and destruction is performed, and
\item if the capture is by reference, the variable's lifetime ends when the
closure object's lifetime ends.
\end{itemize}
\begin{note}
This enables an \grammarterm{init-capture} like
``\tcode{x = std::move(x)}''; the second ``\tcode{x}'' must bind to a
declaration in the surrounding context.
\end{note}
\begin{example}
\begin{codeblock}
int x = 4;
auto y = [&r = x, x = x+1]()->int {
            r += 2;
            return x+2;
         }();                               // Updates \tcode{::x} to 6, and initializes \tcode{y} to 7.

auto z = [a = 42](int a) { return 1; };     // error: parameter and local variable have the same name
\end{codeblock}
\end{example}

\pnum
For the purposes of lambda capture,
an expression potentially references local entities as follows:

\begin{itemize}
\item
An \grammarterm{id-expression} that names a local entity
potentially references that entity;
an \grammarterm{id-expression} that names
one or more non-static class members
and does not form a pointer to member\iref{expr.unary.op}
potentially references \tcode{*this}.
\begin{note}
This occurs even if overload resolution
selects a static member function for the \grammarterm{id-expression}.
\end{note}

\item
A \tcode{this} expression potentially references \tcode{*this}.

\item
A \grammarterm{lambda-expression} potentially references
the local entities named by its \grammarterm{simple-capture}{s}.
\end{itemize}

If an expression potentially references a local entity
within a declarative region in which it is odr-usable,
and the expression would be potentially evaluated
if the effect of any enclosing \tcode{typeid} expressions\iref{expr.typeid} were ignored,
the entity is said to be \defnx{implicitly captured}{capture!implicit}
by each intervening \grammarterm{lambda-expression} with an associated
\grammarterm{capture-default} that does not explicitly capture it.
The implicit capture of \tcode{*this} is deprecated when the
\grammarterm{capture-default} is \tcode{=}; see \ref{depr.capture.this}.
\begin{example}
\begin{codeblock}
void f(int, const int (&)[2] = {});         // \#1
void f(const int&, const int (&)[1]);       // \#2
void test() {
  const int x = 17;
  auto g = [](auto a) {
    f(x);                       // OK: calls \#1, does not capture \tcode{x}
  };

  auto g1 = [=](auto a) {
    f(x);                       // OK: calls \#1, captures \tcode{x}
  };

  auto g2 = [=](auto a) {
    int selector[sizeof(a) == 1 ? 1 : 2]{};
    f(x, selector);             // OK: captures \tcode{x}, might call \#1 or \#2
  };

  auto g3 = [=](auto a) {
    typeid(a + x);              // captures \tcode{x} regardless of whether \tcode{a + x} is an unevaluated operand
  };
}
\end{codeblock}
Within \tcode{g1}, an implementation might optimize away
the capture of \tcode{x} as it is not odr-used.
\end{example}
\begin{note}
The set of captured entities is determined syntactically,
and entities might be implicitly captured
even if the expression denoting a local entity
is within a discarded statement\iref{stmt.if}.
\begin{example}
\begin{codeblock}
template<bool B>
void f(int n) {
  [=](auto a) {
    if constexpr (B && sizeof(a) > 4) {
      (void)n;                  // captures \tcode{n} regardless of the value of \tcode{B} and \tcode{sizeof(int)}
    }
  }(0);
}
\end{codeblock}
\end{example}
\end{note}

\pnum
An entity is \defn{captured} if it is captured explicitly or implicitly. An entity
captured by a \grammarterm{lambda-expression} is odr-used\iref{basic.def.odr} in the scope
containing the \grammarterm{lambda-expression}.
\begin{note}
As a consequence, if a \grammarterm{lambda-expression}
explicitly captures an entity that is not odr-usable,
the program is ill-formed\iref{basic.def.odr}.
\end{note}
\begin{example}
\indextext{Bond!James Bond}%
\begin{codeblock}
void f1(int i) {
  int const N = 20;
  auto m1 = [=]{
    int const M = 30;
    auto m2 = [i]{
      int x[N][M];              // OK: \tcode{N} and \tcode{M} are not odr-used
      x[0][0] = i;              // OK: \tcode{i} is explicitly captured by \tcode{m2} and implicitly captured by \tcode{m1}
    };
  };
  struct s1 {
    int f;
    void work(int n) {
      int m = n*n;
      int j = 40;
      auto m3 = [this,m] {
        auto m4 = [&,j] {       // error: \tcode{j} not odr-usable due to intervening lambda \tcode{m3}
          int x = n;            // error: \tcode{n} is odr-used but not odr-usable due to intervening lambda \tcode{m3}
          x += m;               // OK: \tcode{m} implicitly captured by \tcode{m4} and explicitly captured by \tcode{m3}
          x += i;               // error: \tcode{i} is odr-used but not odr-usable
                                // due to intervening function and class scopes
          x += f;               // OK: \tcode{this} captured implicitly by \tcode{m4} and explicitly by \tcode{m3}
        };
      };
    }
  };
}

struct s2 {
  double ohseven = .007;
  auto f() {
    return [this] {
      return [*this] {
          return ohseven;       // OK
      };
    }();
  }
  auto g() {
    return [] {
      return [*this] { };       // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}
    }();
  }
};
\end{codeblock}
\end{example}

\pnum
\begin{note}
Because local entities are not
odr-usable within a default argument\iref{basic.def.odr},
a \grammarterm{lambda-expression} appearing in a default argument
cannot implicitly or explicitly capture any local entity.
Such a \grammarterm{lambda-expression}
can still have an \grammarterm{init-capture} if
any full-expression in its \grammarterm{initializer}
satisfies the constraints of an expression appearing in
a default argument\iref{dcl.fct.default}.
\end{note}
\begin{example}
\begin{codeblock}
void f2() {
  int i = 1;
  void g1(int = ([i]{ return i; })());          // ill-formed
  void g2(int = ([i]{ return 0; })());          // ill-formed
  void g3(int = ([=]{ return i; })());          // ill-formed
  void g4(int = ([=]{ return 0; })());          // OK
  void g5(int = ([]{ return sizeof i; })());    // OK
  void g6(int = ([x=1]{ return x; })());        // OK
  void g7(int = ([x=i]{ return x; })());        // ill-formed
}
\end{codeblock}
\end{example}

\pnum
An entity is \defnx{captured by copy}{captured!by copy} if
\begin{itemize}
\item
it is implicitly captured,
the \grammarterm{capture-default} is \tcode{=}, and
the captured entity is not \tcode{*this}, or
\item
it is explicitly captured with a capture that is not of the form
\tcode{this},
\tcode{\&} \grammarterm{identifier}, or
\tcode{\&} \grammarterm{identifier} \grammarterm{initializer}.
\end{itemize}
For each entity captured by copy, an
unnamed non-static data member is declared in the closure type. The declaration order of
these members is unspecified. The type of such a data member is
the referenced type if the entity is a reference to an object,
an lvalue reference to the referenced function type if the entity is a reference to a function, or
the type of the corresponding captured entity otherwise.
A member of an anonymous union shall not be captured by copy.

\pnum
Every \grammarterm{id-expression} within the \grammarterm{compound-statement} of a
\grammarterm{lambda-expression} that is an odr-use\iref{basic.def.odr} of an
entity captured by copy is transformed into an access to the corresponding unnamed data
member of the closure type.
\begin{note}
An \grammarterm{id-expression} that is not an odr-use refers to
the original entity, never to a member of the closure type.
However, such
an \grammarterm{id-expression} can still cause the implicit capture of the
entity.
\end{note}
If \tcode{*this} is captured by copy, each expression that odr-uses \tcode{*this} is
transformed to instead refer to the corresponding unnamed data member of the closure type.
\begin{example}
\begin{codeblock}
void f(const int*);
void g() {
  const int N = 10;
  [=] {
    int arr[N];     // OK: not an odr-use, refers to automatic variable
    f(&N);          // OK: causes \tcode{N} to be captured; \tcode{\&N} points to
                    // the corresponding member of the closure type
  };
}
\end{codeblock}
\end{example}

\pnum
An entity is \defnx{captured by reference}{captured!by reference} if it is implicitly or explicitly
captured but not captured by copy. It is unspecified whether additional unnamed
non-static data members are declared in the closure type for entities captured by
reference.
If declared, such non-static data members shall be of literal type.
\begin{example}
\begin{codeblock}
// The inner closure type must be a literal type regardless of how reference captures are represented.
static_assert([](int n) { return [&n] { return ++n; }(); }(3) == 4);
\end{codeblock}
\end{example}
A bit-field or a member of an anonymous union
shall not be captured by reference.

\pnum
An \grammarterm{id-expression} within
the \grammarterm{compound-statement} of a \grammarterm{lambda-expression}
that is an odr-use of a reference captured by reference
refers to the entity to which the captured reference is bound and
not to the captured reference.
\begin{note}
The validity of such captures is determined by
the lifetime of the object to which the reference refers,
not by the lifetime of the reference itself.
\end{note}
\begin{example}
\begin{codeblock}
auto h(int &r) {
  return [&] {
    ++r;            // Valid after \tcode{h} returns if the lifetime of the
                    // object to which \tcode{r} is bound has not ended
  };
}
\end{codeblock}
\end{example}

\pnum
If a \grammarterm{lambda-expression} \tcode{m2} captures an entity and that entity is
captured by an immediately enclosing \grammarterm{lambda-expression}
\tcode{m1}, then
\tcode{m2}'s capture is transformed as follows:
\begin{itemize}
\item if \tcode{m1} captures the entity by copy,
\tcode{m2} captures the corresponding
non-static data member of \tcode{m1}'s closure type;
\item if \tcode{m1} captures the entity by reference,
\tcode{m2} captures the same
entity captured by \tcode{m1}.
\end{itemize}
\begin{example}
The nested \grammarterm{lambda-expression}s and invocations below will output
\tcode{123234}.
\begin{codeblock}
int a = 1, b = 1, c = 1;
auto m1 = [a, &b, &c]() mutable {
  auto m2 = [a, b, &c]() mutable {
    std::cout << a << b << c;
    a = 4; b = 4; c = 4;
  };
  a = 3; b = 3; c = 3;
  m2();
};
a = 2; b = 2; c = 2;
m1();
std::cout << a << b << c;
\end{codeblock}
\end{example}

\pnum
When the \grammarterm{lambda-expression} is evaluated, the entities that are
captured by copy are used to direct-initialize each corresponding non-static data member
of the resulting closure object, and the non-static data members corresponding to the
\grammarterm{init-capture}{s} are initialized as indicated by the corresponding
\grammarterm{initializer} (which may be copy- or direct-initialization). (For array members, the array elements are
direct-initialized in increasing subscript order.) These initializations are performed
in the (unspecified) order in which the non-static data members are declared.
\begin{note}
This ensures that the destructions will occur in the reverse order of the constructions.
\end{note}

\pnum
\begin{note}
If a non-reference entity is implicitly or explicitly captured by reference,
invoking the function call operator of the corresponding \grammarterm{lambda-expression}
after the lifetime of the entity has ended is likely to result in undefined behavior.
\end{note}

\pnum
A \grammarterm{simple-capture} followed by an ellipsis is a pack
expansion\iref{temp.variadic}.
\indextext{init-capture pack@\fakegrammarterm{init-capture} pack}%
An \grammarterm{init-capture} preceded by an ellipsis is a pack
expansion that introduces an
\grammarterm{init-capture} pack\iref{temp.variadic}
whose declarative region is
the \grammarterm{lambda-expression}'s \grammarterm{compound-statement}.
\begin{example}
\begin{codeblock}
template<class... Args>
void f(Args... args) {
  auto lm = [&, args...] { return g(args...); };
  lm();

  auto lm2 = [...xs=std::move(args)] { return g(xs...); };
  lm2();
}
\end{codeblock}
\end{example}
\indextext{expression!lambda|)}

\rSec2[expr.prim.fold]{Fold expressions}%
\indextext{expression!fold|(}

\pnum
A fold expression performs a fold of a
pack\iref{temp.variadic} over a binary operator.

\begin{bnf}
\nontermdef{fold-expression}\br
    \terminal{(} cast-expression fold-operator \terminal{...} \terminal{)}\br
    \terminal{(} \terminal{...} fold-operator cast-expression \terminal{)}\br
    \terminal{(} cast-expression fold-operator \terminal{...} fold-operator cast-expression \terminal{)}
\end{bnf}

\begin{bnf}
%% Ed. note: character protrusion would misalign operators with leading `-`.
\microtypesetup{protrusion=false}
\nontermdef{fold-operator} \textnormal{one of}\br
    \terminal{+ }\quad\terminal{- }\quad\terminal{* }\quad\terminal{/ }\quad\terminal{\% }\quad\terminal{\caret{} }\quad\terminal{\& }\quad\terminal{| }\quad\terminal{<< }\quad\terminal{>> }\br
    \terminal{+=}\quad\terminal{-=}\quad\terminal{*=}\quad\terminal{/=}\quad\terminal{\%=}\quad\terminal{\caret=}\quad\terminal{\&=}\quad\terminal{|=}\quad\terminal{<<=}\quad\terminal{>>=}\quad\terminal{=}\br
    \terminal{==}\quad\terminal{!=}\quad\terminal{< }\quad\terminal{> }\quad\terminal{<=}\quad\terminal{>=}\quad\terminal{\&\&}\quad\terminal{||}\quad\terminal{,  }\quad\terminal{.* }\quad\terminal{->*}
\end{bnf}

\pnum
\indextext{fold!unary}%
An expression of the form
\tcode{(...} \placeholder{op} \tcode{e)}
where \placeholder{op} is a \grammarterm{fold-operator}
is called a \defn{unary left fold}.
An expression of the form
\tcode{(e} \placeholder{op} \tcode{...)}
where \placeholder{op} is a \grammarterm{fold-operator}
is called a \defn{unary right fold}.
Unary left folds and unary right folds
are collectively called \defnx{unary folds}{unary fold}.
In a unary fold,
the \grammarterm{cast-expression}
shall contain an unexpanded pack\iref{temp.variadic}.

\pnum
\indextext{fold!binary}%
An expression of the form
\tcode{(e1} \placeholder{op1} \tcode{...} \placeholder{op2} \tcode{e2)}
where \placeholder{op1} and \placeholder{op2} are \grammarterm{fold-operator}{s}
is called a \defn{binary fold}.
In a binary fold,
\placeholder{op1} and \placeholder{op2}
shall be the same \grammarterm{fold-operator},
and either \tcode{e1}
shall contain an unexpanded pack
or \tcode{e2}
shall contain an unexpanded pack,
but not both.
If \tcode{e2} contains an unexpanded pack,
the expression is called a \defn{binary left fold}.
If \tcode{e1} contains an unexpanded pack,
the expression is called a \defn{binary right fold}.
\begin{example}
\begin{codeblock}
template<typename ...Args>
bool f(Args ...args) {
  return (true && ... && args); // OK
}

template<typename ...Args>
bool f(Args ...args) {
  return (args + ... + args);   // error: both operands contain unexpanded packs
}
\end{codeblock}
\end{example}
\indextext{expression!fold|)}%

\rSec2[expr.prim.req]{Requires expressions}
\indextext{expression!requires|(}%

\pnum
A \grammarterm{requires-expression} provides a concise way to express
requirements on template arguments
that can be checked by name lookup\iref{basic.lookup}
or by checking properties of types and expressions.

\begin{bnf}
\nontermdef{requires-expression}\br
    \keyword{requires} \opt{requirement-parameter-list} requirement-body
\end{bnf}

\begin{bnf}
\nontermdef{requirement-parameter-list}\br
    \terminal{(} \opt{parameter-declaration-clause} \terminal{)}
\end{bnf}

\begin{bnf}
\nontermdef{requirement-body}\br
    \terminal{\{} requirement-seq \terminal{\}}
\end{bnf}

\begin{bnf}
\nontermdef{requirement-seq}\br
    requirement\br
    requirement-seq requirement
\end{bnf}

\begin{bnf}
\nontermdef{requirement}\br
    simple-requirement\br
    type-requirement\br
    compound-requirement\br
    nested-requirement
\end{bnf}

\pnum
A \grammarterm{requires-expression} is a prvalue of type \tcode{bool}
whose value is described below.
Expressions appearing within a \grammarterm{requirement-body}
are unevaluated operands\iref{expr.prop}.

\pnum
\begin{example}
A common use of \grammarterm{requires-expression}{}s is to define
requirements in concepts such as the one below:
\begin{codeblock}
template<typename T>
  concept R = requires (T i) {
    typename T::type;
    {*i} -> convertible_to<const typename T::type&>;
  };
\end{codeblock}
A \grammarterm{requires-expression} can also be used in a
\grammarterm{requires-clause}\iref{temp.pre} as a way of writing ad hoc
constraints on template arguments such as the one below:
\begin{codeblock}
template<typename T>
  requires requires (T x) { x + x; }
    T add(T a, T b) { return a + b; }
\end{codeblock}
The first \tcode{requires} introduces the
\grammarterm{requires-clause}, and the second
introduces the \grammarterm{requires-expression}.
\end{example}

\pnum
A \grammarterm{requires-expression} may introduce local parameters using a
\grammarterm{parameter-declaration-clause}\iref{dcl.fct}.
A local parameter of a \grammarterm{requires-expression} shall not have a
default argument.
Each name introduced by a local parameter is in scope from the point
of its declaration until the closing brace of the
\grammarterm{requirement-body}.
These parameters have no linkage, storage, or lifetime; they are only used
as notation for the purpose of defining \grammarterm{requirement}{}s.
The \grammarterm{parameter-declaration-clause} of a
\grammarterm{requirement-parameter-list}
shall not terminate with an ellipsis.
\begin{example}
\begin{codeblock}
template<typename T>
concept C = requires(T t, ...) {    // error: terminates with an ellipsis
  t;
};
\end{codeblock}
\end{example}

\pnum
\indextext{requirement}%
The \grammarterm{requirement-body} contains
a sequence of \grammarterm{requirement}{}s.
These \grammarterm{requirement}{}s may refer to local
parameters, template parameters, and any other declarations visible from the
enclosing context.

\pnum
The substitution of template arguments into a \grammarterm{requires-expression}
may result in the formation of invalid types or expressions in its
requirements or the violation of the semantic constraints of those requirements.
In such cases, the \grammarterm{requires-expression} evaluates to \tcode{false};
it does not cause the program to be ill-formed.
The substitution and semantic constraint checking
proceeds in lexical order and stops when a condition that
determines the result of the \grammarterm{requires-expression} is encountered.
If substitution (if any) and semantic constraint checking succeed,
the \grammarterm{requires-expression} evaluates to \tcode{true}.
\begin{note}
If a \grammarterm{requires-expression} contains invalid types or expressions in
its requirements, and it does not appear within the declaration of a templated
entity, then the program is ill-formed.
\end{note}
If the substitution of template arguments into a \grammarterm{requirement}
would always result in a substitution failure, the program is ill-formed;
no diagnostic required.
\begin{example}
\begin{codeblock}
template<typename T> concept C =
requires {
  new int[-(int)sizeof(T)];     // ill-formed, no diagnostic required
};
\end{codeblock}
\end{example}

\rSec3[expr.prim.req.simple]{Simple requirements}
\indextext{requirement!simple}%

\begin{bnf}
\nontermdef{simple-requirement}\br
    expression \terminal{;}
\end{bnf}

\pnum
A \grammarterm{simple-requirement} asserts
the validity of an \grammarterm{expression}.
\begin{note}
The enclosing \grammarterm{requires-expression} will evaluate to \tcode{false}
if substitution of template arguments into the \grammarterm{expression} fails.
The \grammarterm{expression} is an unevaluated operand\iref{expr.prop}.
\end{note}
\begin{example}
\begin{codeblock}
template<typename T> concept C =
  requires (T a, T b) {
    a + b;          // \tcode{C<T>} is \tcode{true} if \tcode{a + b} is a valid expression
  };
\end{codeblock}
\end{example}

\rSec3[expr.prim.req.type]{Type requirements}
\indextext{requirement!type}%

\begin{bnf}
\nontermdef{type-requirement}\br
    \keyword{typename} \opt{nested-name-specifier} type-name \terminal{;}
\end{bnf}

\pnum
A \grammarterm{type-requirement} asserts the validity of a type.
\begin{note}
The enclosing \grammarterm{requires-expression} will evaluate to \tcode{false}
if substitution of template arguments fails.
\end{note}
\begin{example}
\begin{codeblock}
template<typename T, typename T::type = 0> struct S;
template<typename T> using Ref = T&;

template<typename T> concept C = requires {
  typename T::inner;    // required nested member name
  typename S<T>;        // required class template specialization
  typename Ref<T>;      // required alias template substitution, fails if \tcode{T} is void
};
\end{codeblock}
\end{example}

\pnum
A \grammarterm{type-requirement} that names a class template specialization
does not require that type to be complete\iref{basic.types}.

\rSec3[expr.prim.req.compound]{Compound requirements}
\indextext{requirement!compound}%

\begin{bnf}
\nontermdef{compound-requirement}\br
    \terminal{\{} expression \terminal{\}} \opt{\keyword{noexcept}} \opt{return-type-requirement} \terminal{;}
\end{bnf}

\begin{bnf}
\nontermdef{return-type-requirement}\br
    \terminal{->} type-constraint
\end{bnf}

\pnum
A \grammarterm{compound-requirement} asserts properties
of the \grammarterm{expression} \tcode{E}. Substitution
of template arguments (if any) and verification of
semantic properties proceed in the following order:

\begin{itemize}
\item
Substitution of template arguments (if any)
into the \grammarterm{expression} is performed.

\item
If the \tcode{noexcept} specifier is present,
\tcode{E} shall not be a potentially-throwing expression\iref{except.spec}.

\item
If the \grammarterm{return-type-requirement} is present, then:

\begin{itemize}
\item
Substitution of template arguments (if any)
into the \grammarterm{return-type-requirement} is performed.

\item
The immediately-declared constraint\iref{temp.pre}
of the \grammarterm{type-constraint} for \tcode{decltype((E))}
shall be satisfied.
\begin{example}
Given concepts \tcode{C} and \tcode{D},
\begin{codeblock}
requires {
  { E1 } -> C;
  { E2 } -> @D<A$_1$, $\cdots$, A$_n$>@;
};
\end{codeblock}
is equivalent to
\begin{codeblock}
requires {
  E1; requires C<decltype((E1))>;
  E2; requires @D<decltype((E2)), A$_1$, $\cdots$, A$_n$>@;
};
\end{codeblock}
(including in the case where $n$ is zero).
\end{example}
\end{itemize}
\end{itemize}

\pnum
\begin{example}
\begin{codeblock}
template<typename T> concept C1 = requires(T x) {
  {x++};
};
\end{codeblock}
The \grammarterm{compound-requirement} in \tcode{C1}
requires that \tcode{x++} is a valid expression.
It is equivalent to the \grammarterm{simple-requirement}
\tcode{x++;}.

\begin{codeblock}
template<typename T> concept C2 = requires(T x) {
  {*x} -> same_as<typename T::inner>;
};
\end{codeblock}

The \grammarterm{compound-requirement} in \tcode{C2}
requires that \tcode{*x} is a valid expression,
that \tcode{typename T::inner} is a valid type, and
that \tcode{same_as<decltype((*x)), typename T::inner>} is satisfied.

\begin{codeblock}
template<typename T> concept C3 =
  requires(T x) {
    {g(x)} noexcept;
  };
\end{codeblock}

The \grammarterm{compound-requirement} in \tcode{C3}
requires that \tcode{g(x)} is a valid expression and
that \tcode{g(x)} is non-throwing.
\end{example}

\rSec3[expr.prim.req.nested]{Nested requirements}
\indextext{requirement!nested}%

\begin{bnf}
\nontermdef{nested-requirement}\br
    \keyword{requires} constraint-expression \terminal{;}
\end{bnf}

\pnum
A \grammarterm{nested-requirement} can be used
to specify additional constraints in terms of local parameters.
The \grammarterm{constraint-expression}
shall be satisfied\iref{temp.constr.decl}
by the substituted template arguments, if any.
Substitution of template arguments into a \grammarterm{nested-requirement}
does not result in substitution into the \grammarterm{constraint-expression}
other than as specified in \ref{temp.constr.constr}.
\begin{example}
\begin{codeblock}
template<typename U> concept C = sizeof(U) == 1;

template<typename T> concept D = requires (T t) {
  requires C<decltype (+t)>;
};
\end{codeblock}
\tcode{D<T>} is satisfied if \tcode{sizeof(decltype (+t)) == 1}\iref{temp.constr.atomic}.
\end{example}

\pnum
A local parameter shall only appear as an unevaluated operand\iref{expr.prop}
within the \grammarterm{constraint-expression}.
\begin{example}
\begin{codeblock}
template<typename T> concept C = requires (T a) {
  requires sizeof(a) == 4;      // OK
  requires a == 0;              // error: evaluation of a constraint variable
}
\end{codeblock}
\end{example}
\indextext{expression!requires|)}
\indextext{expression!primary|)}

\rSec1[expr.compound]{Compound expressions}

\rSec2[expr.post]{Postfix expressions}%
\indextext{expression!postfix|(}

\pnum
Postfix expressions group left-to-right.

\begin{bnf}
\nontermdef{postfix-expression}\br
    primary-expression\br
    postfix-expression \terminal{[} expr-or-braced-init-list \terminal{]}\br
    postfix-expression \terminal{(} \opt{expression-list} \terminal{)}\br
    simple-type-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
    typename-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
    simple-type-specifier braced-init-list\br
    typename-specifier braced-init-list\br
    postfix-expression \opt{\terminal{.} \terminal{template}} id-expression\br
    postfix-expression \opt{\terminal{->} \terminal{template}} id-expression\br
    postfix-expression \terminal{++}\br
    postfix-expression \terminal{-{-}}\br
    \keyword{dynamic_cast} \terminal{<} type-id \terminal{>} \terminal{(} expression \terminal{)}\br
    \keyword{static_cast} \terminal{<} type-id \terminal{>} \terminal{(} expression \terminal{)}\br
    \keyword{reinterpret_cast} \terminal{<} type-id \terminal{>} \terminal{(} expression \terminal{)}\br
    \keyword{const_cast} \terminal{<} type-id \terminal{>} \terminal{(} expression \terminal{)}\br
    \keyword{typeid} \terminal{(} expression \terminal{)}\br
    \keyword{typeid} \terminal{(} type-id \terminal{)}
\end{bnf}

\begin{bnf}
\nontermdef{expression-list}\br
    initializer-list
\end{bnf}

\pnum
\begin{note}
The \tcode{>} token following the
\grammarterm{type-id} in a \tcode{dynamic_cast},
\tcode{static_cast}, \tcode{reinterpret_cast}, or
\tcode{const_cast} may be the product of replacing a
\tcode{>{>}} token by two consecutive \tcode{>}
tokens\iref{temp.names}.
\end{note}

\rSec3[expr.sub]{Subscripting}

\pnum
\indextext{operator!subscripting}%
\indextext{\idxcode{[]}|see{operator, subscripting}}%
A postfix expression followed by an expression in square brackets is a
postfix expression. One of the expressions shall be a glvalue of type ``array of
\tcode{T}'' or a prvalue of type ``pointer
to \tcode{T}'' and the other shall be a prvalue of unscoped enumeration or integral type.
The result is of type ``\tcode{T}''.
\indextext{type!incomplete}%
The type ``\tcode{T}'' shall be a completely-defined object type.\footnote{This
is true even if the subscript operator is used in the following common idiom:
\tcode{\&x[0]}.}
The expression \tcode{E1[E2]} is identical (by definition) to
\tcode{*((E1)+(E2))},
except that in the case of an array operand, the result is an lvalue
if that operand is an lvalue and an xvalue otherwise.
The expression \tcode{E1} is sequenced before the expression \tcode{E2}.

\pnum
\begin{note}
A comma expression\iref{expr.comma}
appearing as the \grammarterm{expr-or-braced-init-list}
of a subscripting expression is deprecated;
see \ref{depr.comma.subscript}.
\end{note}

\pnum
\begin{note}
Despite its asymmetric appearance, subscripting is a commutative
operation except for sequencing.
See~\ref{expr.unary} and~\ref{expr.add} for details of \tcode{*} and
\tcode{+} and~\ref{dcl.array} for details of array types.
\end{note}

\pnum
A \grammarterm{braced-init-list} shall not be used with the built-in subscript operator.

\rSec3[expr.call]{Function call}

\pnum
\indextext{expression!function call}%
\indextext{operator!function call}%
\indextext{\idxcode{()}|see{operator, function call}}%
A function call is a postfix expression followed by parentheses
containing a possibly empty, comma-separated list of
\grammarterm{initializer-clause}{s} which
constitute the arguments to the function.
\begin{note}
If the postfix expression is a function or member function name,
the appropriate function and the validity of the call
are determined according to the rules in~\ref{over.match}.
\end{note}
The postfix expression shall
have function type or function pointer type.
For a call to a non-member function or to a static member function,
the postfix expression shall either be an lvalue that refers to a
function (in which case the function-to-pointer standard
conversion\iref{conv.func} is suppressed on the postfix expression),
or have function pointer type.

\pnum
For a call to a non-static member function,
the postfix expression shall be an
implicit~(\ref{class.mfct.non-static}, \ref{class.static}) or explicit
class member access\iref{expr.ref} whose \grammarterm{id-expression} is a
function member name, or a pointer-to-member
expression\iref{expr.mptr.oper} selecting a function member; the call is as a member of
the class object referred to by the
object expression. In the case of an implicit class
member access, the implied object is the one pointed to by \tcode{this}.
\begin{note}
A member function call of the form \tcode{f()} is interpreted as
\tcode{(*this).f()} (see~\ref{class.mfct.non-static}).
\end{note}

\pnum
If the selected
function is non-virtual, or if the \grammarterm{id-expression} in the class
member access expression is a \grammarterm{qualified-id}, that function is
called. Otherwise, its final overrider\iref{class.virtual} in the dynamic type
of the object expression is called; such a call is referred to as a
\defnx{virtual function call}{function!virtual function call}.
\begin{note}
The dynamic type is the type of the object referred to by the
current value of the object expression. \ref{class.cdtor}~describes the
behavior of virtual function calls when the object expression
refers to
an object under construction or destruction.
\end{note}

\pnum
\begin{note}
If a function or member function name is used, and name
lookup\iref{basic.lookup} does not find a declaration of that name,
the program is ill-formed. No function is implicitly declared by such a
call.
\end{note}

\pnum
If the \grammarterm{postfix-expression} names
a destructor or pseudo-destructor\iref{expr.prim.id.dtor},
the type of the function call expression is \tcode{void}; otherwise, the
type of the function call expression is the return type of the
statically chosen function (i.e., ignoring the \tcode{virtual} keyword),
even if the type of the function actually called is different.
\indextext{type!incomplete}%
This return type shall be an object type, a reference type or \cv{}~\tcode{void}.
If the \grammarterm{postfix-expression} names a pseudo-destructor,
the function call has no effect.

\pnum
Calling a function through an
expression whose function type is different
from the function type of the called function's
definition results in undefined behavior.

\pnum
\indextext{function argument|see{argument}}%
\indextext{function parameter|see{parameter}}%
\indextext{initialization!parameter}%
When a function is called, each parameter\iref{dcl.fct} is
initialized~(\ref{dcl.init}, \ref{class.copy.ctor}) with
its corresponding argument.
If there is no corresponding argument,
the default argument for the parameter is used;
the program is ill-formed if one is not present.
\begin{example}
\begin{codeblock}
template<typename ...T> int f(int n = 0, T ...t);
int x = f<int>();               // error: no argument for second function parameter
\end{codeblock}
\end{example}
If the function is a non-static member
function, the \tcode{this} parameter of the function\iref{class.this}
is initialized with a pointer to the object of the call, converted
as if by an explicit type conversion\iref{expr.cast}.
\begin{note}
There is no access or ambiguity checking on this conversion; the access
checking and disambiguation are done as part of the (possibly implicit)
class member access operator.
See~\ref{class.member.lookup}, \ref{class.access.base},
and~\ref{expr.ref}.
\end{note}
When a function is called, the type of any parameter
shall not be a class type that is either incomplete or abstract.
\begin{note}
This still allows a parameter to be a pointer or reference to such
a type. However, it prevents a passed-by-value parameter
to have an incomplete or abstract class type.
\end{note}
It is \impldef{whether the lifetime of a parameter ends when the callee
returns or at the end of the enclosing full-expression} whether the
lifetime of a parameter ends when the function in which it is defined
returns or at the end of the enclosing full-expression.
The initialization and destruction of each parameter occurs
within the context of the calling function.
\begin{example}
The access of the constructor, conversion functions or destructor is
checked at the point of call in the calling function. If a constructor
or destructor for a function parameter throws an exception, the search
for a handler starts in the scope of the calling function; in
particular, if the function called has a \grammarterm{function-try-block}\iref{except.pre}
with a handler that could handle the exception,
this handler is not considered.
\end{example}

\pnum
\indextext{evaluation!order of argument}%
\indextext{evaluation!unspecified order of function call}%
\indextext{evaluation!unspecified order of argument}%
The \grammarterm{postfix-expression} is sequenced before
each \grammarterm{expression} in the \grammarterm{expression-list}
and any default argument.
The initialization of a parameter,
including every associated value computation and side effect,
is indeterminately sequenced with respect to that of any other parameter.
\begin{note}
All side effects of
argument evaluations are sequenced before the function is
entered (see~\ref{intro.execution}).
\end{note}
\begin{example}
\begin{codeblock}
void f() {
  std::string s = "but I have heard it works even if you don't believe in it";
  s.replace(0, 4, "").replace(s.find("even"), 4, "only").replace(s.find(" don't"), 6, "");
  assert(s == "I have heard it works only if you believe in it");       // OK
}
\end{codeblock}
\end{example}
\begin{note}
If an operator function is invoked
using operator notation,
argument evaluation is sequenced
as specified for the built-in operator;
see~\ref{over.match.oper}.
\end{note}
\begin{example}
\begin{codeblock}
struct S {
  S(int);
};
int operator<<(S, int);
int i, j;
int x = S(i=1) << (i=2);
int y = operator<<(S(j=1), j=2);
\end{codeblock}
After performing the initializations,
the value of \tcode{i} is 2 (see~\ref{expr.shift}),
but it is unspecified whether the value of \tcode{j} is 1 or 2.
\end{example}

\pnum
The result of a function call is the
result of the operand of the evaluated \tcode{return} statement\iref{stmt.return}
in the called function (if any),
except in a virtual function call if the return type of the
final overrider is different from the return type of the statically
chosen function, the value returned from the final overrider is
converted to the return type of the statically chosen function.

\pnum
\begin{note}
\indextext{type checking!argument}%
\indextext{function call}%
\indextext{argument passing}%
\indextext{value!call by}%
\indextext{reference!call by}%
\indextext{argument!reference}%
A function can change the values of its non-const parameters, but these
changes cannot affect the values of the arguments except where a
parameter is of a reference type\iref{dcl.ref}; if the reference is to
a const-qualified type, \tcode{const_cast} is required to be used to
cast away the constness in order to modify the argument's value. Where a
parameter is of \tcode{const} reference type a temporary object is
introduced if
needed~(\ref{dcl.type}, \ref{lex.literal}, \ref{lex.string}, \ref{dcl.array}, \ref{class.temporary}).
In addition, it is possible to modify the values of non-constant objects through
pointer parameters.
\end{note}

\pnum
\indextext{declaration!ellipsis in function}%
\indextext{parameter list!variable}%
A function can be declared to accept fewer arguments (by declaring default
arguments\iref{dcl.fct.default}) or more arguments (by using the ellipsis,
\tcode{...}, or a function parameter pack\iref{dcl.fct}) than the number of
parameters in the function definition\iref{dcl.fct.def}.
\begin{note}
This implies that, except where the ellipsis (\tcode{...}) or a function
parameter pack is used, a parameter is available for each argument.
\end{note}

\pnum
\indextext{ellipsis!conversion sequence}%
When there is no parameter for a given argument, the argument is passed
in such a way that the receiving function can obtain the value of the
argument by invoking \tcode{va_arg}\iref{support.runtime}.
\begin{note}
This paragraph does not apply to arguments passed to a function parameter pack.
Function parameter packs are expanded during template instantiation\iref{temp.variadic},
thus each such argument has a corresponding parameter when a function template
specialization is actually called.
\end{note}
The
lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func} standard conversions are
performed on the argument expression.
An argument that has type \cv{}~\tcode{std::nullptr_t} is converted
to type \tcode{void*}\iref{conv.ptr}.
After these conversions, if the
argument does not have arithmetic, enumeration, pointer, pointer-to-member,
or class type, the program is ill-formed. Passing a potentially-evaluated
argument
of a scoped enumeration type or
of a class type\iref{class} having an eligible non-trivial
copy constructor, an eligible non-trivial move constructor,
or a
non-trivial destructor\iref{special},
with no corresponding parameter, is conditionally-supported with
\impldef{passing argument of class type through ellipsis} semantics. If the argument has
integral or enumeration type that is subject to the integral
promotions\iref{conv.prom}, or a floating-point type that is subject to the
floating-point promotion\iref{conv.fpprom}, the value of the argument is converted to the
promoted type before the call. These promotions are referred to as
the \defnx{default argument promotions}{promotion!default argument promotion}.

\pnum
\indextext{function call!recursive}%
Recursive calls are permitted, except to the \tcode{main}
function\iref{basic.start.main}.

\pnum
A function call is an lvalue
if the result type is an lvalue reference type or an rvalue reference to function type,
an xvalue if the result type is an rvalue reference to object type, and a prvalue
otherwise.

\rSec3[expr.type.conv]{Explicit type conversion (functional notation)}

\pnum
\indextext{expression!cast}%
\indextext{explicit type conversion|see{casting}}%
\indextext{type conversion, explicit|see{casting}}%
\indextext{conversion explicit type|see{casting}}%
\indextext{casting}%
A \grammarterm{simple-type-specifier}\iref{dcl.type.simple} or
\grammarterm{typename-specifier}\iref{temp.res} followed
by a parenthesized optional \grammarterm{expression-list} or
by a \grammarterm{braced-init-list}
(the initializer)
constructs a value of the specified type
given the initializer.
\indextext{deduction!class template arguments}%
If the type is a placeholder
for a deduced class type,
it is replaced by the return type
of the function selected by overload resolution
for class template deduction\iref{over.match.class.deduct}
for the remainder of this subclause.

\pnum
If the initializer is a parenthesized single expression,
the type conversion expression is equivalent
to the corresponding cast
expression\iref{expr.cast}.
\indextext{type!incomplete}%
Otherwise, if the type is \cv{}~\tcode{void}
and the initializer is \tcode{()} or \tcode{\{\}}
(after pack expansion, if any),
the expression is a prvalue of the specified type
that performs no initialization.
Otherwise,
the expression is a prvalue of the specified type
whose result object is direct-initialized\iref{dcl.init}
with the initializer.
If the initializer is a parenthesized optional \grammarterm{expression-list},
the specified type shall not be an array type.

\rSec3[expr.ref]{Class member access}

\pnum
\indextext{expression!class member access}%
\indextext{access control!class member}%
\indextext{syntax!class member}%
\indextext{semantics!class member}%
\indextext{operator!class member access}%
\indextext{\idxcode{.}|see{operator, class member access}}%
\indextext{dot operator|see{operator, class member access}}%
\indextext{operator!class member access}%
\indextext{\idxcode{->}|see{operator, class member access}}%
\indextext{arrow operator|see{operator, class member access}}%
A postfix expression followed by a dot \tcode{.} or an arrow \tcode{->},
optionally followed by the keyword
\tcode{template}\iref{temp.names}, and then followed by an
\grammarterm{id-expression}, is a postfix expression. The postfix
expression before the dot or arrow is evaluated;\footnote{If the class member
access expression is evaluated, the subexpression evaluation happens even if the
result is unnecessary to determine
the value of the entire postfix expression, for example if the
\grammarterm{id-expression} denotes a static member.}
the result of that evaluation, together with the
\grammarterm{id-expression}, determines the result of the entire postfix
expression.

\pnum
\indextext{type!incomplete}%
For the first option (dot) the first expression shall be a glvalue.
For the second option (arrow) the first expression
shall be a prvalue having pointer type.
The expression \tcode{E1->E2} is
converted to the equivalent form \tcode{(*(E1)).E2}; the remainder of
\ref{expr.ref}~will address only the first option (dot).\footnote{Note that
\tcode{(*(E1))} is an lvalue.}

\pnum
Abbreviating
\grammarterm{postfix-expression}\tcode{.}\grammarterm{id-expression}
as \tcode{E1.E2}, \tcode{E1} is called the \defn{object expression}.
If the object expression is of scalar type,
\tcode{E2} shall name the pseudo-destructor
of that same type (ignoring cv-qualifications) and
\tcode{E1.E2} is an lvalue of type ``function of () returning \tcode{void}''.
\begin{note}
This value can only be used
for a notional function call\iref{expr.prim.id.dtor}.
\end{note}

\pnum
Otherwise, the object expression shall be of class type.
The class type shall be complete
unless the class member access appears in the definition of that class.
\begin{note}
If the class is incomplete,
lookup in the complete class type is required to refer
to the same declaration\iref{basic.scope.class}.
\end{note}
The \grammarterm{id-expression} shall name a member of the class or of one of
its base classes.
\begin{note}
Because the name of a class is inserted in its class scope\iref{class},
the name of a class is also considered a nested
member of that class.
\end{note}
\begin{note}
\ref{basic.lookup.classref} describes how names are looked up after the
\tcode{.} and \tcode{->} operators.
\end{note}

\pnum
If \tcode{E2} is a bit-field, \tcode{E1.E2} is a bit-field. The
type and value category of \tcode{E1.E2} are determined as follows.
In the remainder of~\ref{expr.ref}, \cvqual{cq} represents either
\tcode{const} or the absence of \tcode{const} and \cvqual{vq} represents
either \tcode{volatile} or the absence of \tcode{volatile}. \cvqual{cv}
represents an arbitrary set of cv-qualifiers, as defined
in~\ref{basic.type.qualifier}.

\pnum
If \tcode{E2} is declared to have type ``reference to \tcode{T}'', then
\tcode{E1.E2} is an lvalue; the type of \tcode{E1.E2} is \tcode{T}.
Otherwise, one of the following rules applies.

\begin{itemize}
\item If \tcode{E2} is a static data member and the type of \tcode{E2}
is \tcode{T}, then \tcode{E1.E2} is an lvalue; the expression designates
the named member of the class. The type of \tcode{E1.E2} is \tcode{T}.

\item If \tcode{E2} is a non-static data member and the type of
\tcode{E1} is ``\cvqual{cq1 vq1} \tcode{X}'', and the type of \tcode{E2}
is ``\cvqual{cq2 vq2} \tcode{T}'', the expression designates the named
member of the object designated by the first expression. If \tcode{E1}
is an lvalue, then \tcode{E1.E2} is an lvalue;
otherwise \tcode{E1.E2} is an xvalue.
Let the notation \cvqual{vq12} stand for the ``union'' of
\cvqual{vq1} and \cvqual{vq2}; that is, if \cvqual{vq1} or \cvqual{vq2}
is \tcode{volatile}, then \cvqual{vq12} is \tcode{volatile}. Similarly,
let the notation \cvqual{cq12} stand for the ``union'' of \cvqual{cq1}
and \cvqual{cq2}; that is, if \cvqual{cq1} or \cvqual{cq2} is
\tcode{const}, then \cvqual{cq12} is \tcode{const}. If \tcode{E2} is
declared to be a \tcode{mutable} member, then the type of \tcode{E1.E2}
is ``\cvqual{vq12} \tcode{T}''. If \tcode{E2} is not declared to be a
\tcode{mutable} member, then the type of \tcode{E1.E2} is
``\cvqual{cq12} \cvqual{vq12} \tcode{T}''.

\item If \tcode{E2} is a (possibly overloaded) member function, function
overload resolution\iref{over.match} is used to determine whether
\tcode{E1.E2} refers to a static or a non-static member function.

\begin{itemize}
\item If it refers to a static member function and the type of
\tcode{E2} is ``function of parameter-type-list returning \tcode{T}'',
then \tcode{E1.E2} is an lvalue; the expression designates the static
member function. The type of \tcode{E1.E2} is the same type as that of
\tcode{E2}, namely ``function of parameter-type-list returning
\tcode{T}''.

\item Otherwise, if \tcode{E1.E2} refers to a non-static member
function and the type of \tcode{E2} is ``function of
parameter-type-list \cv{} \opt{\grammarterm{ref-qualifier}} returning \tcode{T}'', then
\tcode{E1.E2} is a prvalue. The expression designates a
non-static member function. The expression can be used only as the
left-hand operand of a member function call\iref{class.mfct}.
\begin{note}
Any redundant set of parentheses surrounding the expression
is ignored\iref{expr.prim.paren}.
\end{note}
The type of \tcode{E1.E2} is
``function of parameter-type-list \cv{} returning \tcode{T}''.
\end{itemize}

\item If \tcode{E2} is a nested type, the expression \tcode{E1.E2} is
ill-formed.

\item If \tcode{E2} is a member enumerator and the type of \tcode{E2}
is \tcode{T}, the expression \tcode{E1.E2} is a prvalue. The type of
\tcode{E1.E2} is \tcode{T}.
\end{itemize}

\pnum
If \tcode{E2} is a non-static data member or a non-static member
function, the program is ill-formed if the class of which \tcode{E2} is
directly a member is an ambiguous base\iref{class.member.lookup} of
the naming class\iref{class.access.base} of \tcode{E2}.
\begin{note}
The program is also ill-formed if the naming class is an ambiguous base of the class type
of the object expression; see~\ref{class.access.base}.
\end{note}

\rSec3[expr.post.incr]{Increment and decrement}

\pnum
\indextext{expression!increment}%
\indextext{operator!increment}%
\indextext{\idxcode{++}|see{operator, increment}}%
\indextext{postfix \tcode{++}}%
The value of a postfix \tcode{++} expression is the value of its
operand.
\begin{note}
The value obtained is a copy of the original value.
\end{note}
The operand shall be a modifiable lvalue. The type of the operand shall
be an arithmetic type other than \cv{}~\tcode{bool},
or a pointer to a complete object type.
An operand with \tcode{volatile}-qualified type is deprecated;
see~\ref{depr.volatile.type}.
The value of the operand object is modified\iref{defns.access}
by adding \tcode{1} to it.
The
\indextext{value computation}%
value computation of the \tcode{++} expression is sequenced before the
modification of the operand object. With respect to an
indeterminately-sequenced function call, the operation of postfix
\tcode{++} is
a single evaluation.
\begin{note}
Therefore, a function call cannot intervene between the
lvalue-to-rvalue conversion and the side effect associated with any
single postfix ++ operator.
\end{note}
The result is a prvalue. The type of the result is the cv-unqualified
version of the type of the operand.
If the operand is a bit-field that cannot represent the incremented value, the
resulting value of the bit-field is
\impldefplain{value of bit-field that cannot represent!incremented value}.
See also~\ref{expr.add}
and~\ref{expr.ass}.

\pnum
\indextext{expression!decrement}%
\indextext{operator!decrement}%
\indextext{\idxcode{\dcr}|see{operator, decrement}}%
\indextext{postfix \tcode{\dcr}}%
The operand of postfix \tcode{\dcr} is decremented analogously to the
postfix \tcode{++} operator.
\begin{note}
For prefix increment and decrement, see~\ref{expr.pre.incr}.
\end{note}

\rSec3[expr.dynamic.cast]{Dynamic cast}

\pnum
\indextext{expression!dynamic cast}%
\indextext{cast!dynamic}%
The result of the expression \tcode{dynamic_cast<T>(v)} is the result of
converting the expression \tcode{v} to type \tcode{T}.
\indextext{type!incomplete}%
\tcode{T} shall be a pointer or reference to a complete class type, or
``pointer to \cv{} \tcode{void}''. The \tcode{dynamic_cast} operator shall not cast
away constness\iref{expr.const.cast}.

\pnum
If \tcode{T} is a pointer type, \tcode{v} shall be a prvalue of a
pointer to complete class type, and the result is a prvalue of type
\tcode{T}. If \tcode{T} is an lvalue reference type, \tcode{v} shall be
an lvalue of a complete class type, and the result is an lvalue of the
type referred to by \tcode{T}. If \tcode{T} is an rvalue reference type,
\tcode{v} shall be a glvalue having a complete class type, and the
result is an xvalue of the type referred to by \tcode{T}.

\pnum
If the type of \tcode{v} is the same as \tcode{T} (ignoring cv-qualifications),
the result is
\tcode{v} (converted if necessary).

\pnum
If \tcode{T} is ``pointer to \cvqual{cv1} \tcode{B}'' and \tcode{v} has
type ``pointer to \cvqual{cv2} \tcode{D}'' such that \tcode{B} is a base
class of \tcode{D}, the result is a pointer to the unique \tcode{B}
subobject of the \tcode{D} object pointed to by \tcode{v}, or
a null pointer value if \tcode{v} is a null pointer value.
Similarly, if
\tcode{T} is ``reference to \cvqual{cv1} \tcode{B}'' and \tcode{v} has
type \cvqual{cv2} \tcode{D} such that \tcode{B} is a base class of
\tcode{D}, the result is the unique \tcode{B} subobject of the \tcode{D}
object referred to by \tcode{v}.\footnote{The most derived
object\iref{intro.object} pointed or referred to by
\tcode{v} can contain other \tcode{B} objects as base classes, but these
are ignored.}
In both the pointer and
reference cases, the program is ill-formed if \tcode{B} is an inaccessible or
ambiguous base class of \tcode{D}.
\begin{example}
\begin{codeblock}
struct B { };
struct D : B { };
void foo(D* dp) {
  B*  bp = dynamic_cast<B*>(dp);    // equivalent to \tcode{B* bp = dp;}
}
\end{codeblock}
\end{example}

\pnum
Otherwise, \tcode{v} shall be a pointer to or a glvalue of a polymorphic
type\iref{class.virtual}.

\pnum
If \tcode{v} is a null pointer value, the result is a null pointer value.

\pnum
If \tcode{T} is ``pointer to \cv{} \tcode{void}'', then the result
is a pointer to the most derived object pointed to by \tcode{v}.
Otherwise, a runtime check is applied to see if the object pointed or
referred to by \tcode{v} can be converted to the type pointed or
referred to by \tcode{T}.

\pnum
If \tcode{C} is the class type to which \tcode{T} points or refers, the runtime
check logically executes as follows:

\begin{itemize}
\item If, in the most derived object pointed (referred) to by \tcode{v},
\tcode{v} points (refers) to a public base class subobject of a
\tcode{C} object, and if only one object of type \tcode{C} is derived
from the subobject pointed (referred) to by \tcode{v} the result points (refers) to that \tcode{C} object.

\item Otherwise, if \tcode{v} points (refers) to a public base
class subobject of the most derived object, and the type of the most
derived object has a base class, of type \tcode{C}, that is unambiguous
and public, the result points (refers) to the
\tcode{C} subobject of the most derived object.

\item Otherwise, the
runtime check \term{fails}.
\end{itemize}

\pnum
The value of a failed cast to pointer type is the null pointer value of
the required result type. A failed cast to reference type throws
an exception\iref{except.throw} of a type that would match a
handler\iref{except.handle} of type \tcode{std::bad_cast}\iref{bad.cast}.

\indextext{\idxcode{bad_cast}}%
\indexlibraryglobal{bad_cast}%
\begin{example}
\begin{codeblock}
class A { virtual void f(); };
class B { virtual void g(); };
class D : public virtual A, private B { };
void g() {
  D   d;
  B*  bp = (B*)&d;                  // cast needed to break protection
  A*  ap = &d;                      // public derivation, no cast needed
  D&  dr = dynamic_cast<D&>(*bp);   // fails
  ap = dynamic_cast<A*>(bp);        // fails
  bp = dynamic_cast<B*>(ap);        // fails
  ap = dynamic_cast<A*>(&d);        // succeeds
  bp = dynamic_cast<B*>(&d);        // ill-formed (not a runtime check)
}

class E : public D, public B { };
class F : public E, public D { };
void h() {
  F   f;
  A*  ap  = &f;                     // succeeds: finds unique \tcode{A}
  D*  dp  = dynamic_cast<D*>(ap);   // fails: yields null; \tcode{f} has two \tcode{D} subobjects
  E*  ep  = (E*)ap;                 // ill-formed: cast from virtual base
  E*  ep1 = dynamic_cast<E*>(ap);   // succeeds
}
\end{codeblock}
\end{example}
\begin{note}
Subclause \ref{class.cdtor} describes the behavior of a \tcode{dynamic_cast}
applied to an object under construction or destruction.
\end{note}

\rSec3[expr.typeid]{Type identification}

\pnum
\indextext{expression!type identification}%
\indextext{\idxcode{typeid}}%
The result of a \tcode{typeid} expression is an lvalue of static type
\indextext{\idxcode{type_info}}%
\indexlibraryglobal{type_info}%
\tcode{const} \tcode{std::type_info}\iref{type.info} and dynamic type \tcode{const}
\tcode{std::type_info} or \tcode{const} \term{name} where \term{name} is an
\impldef{derived type for \tcode{typeid}} class publicly derived from
\tcode{std::type_info} which preserves the behavior described
in~\ref{type.info}.\footnote{The recommended name for such a class is
\tcode{extended_type_info}.}
The lifetime of the object referred to by the lvalue extends to the end
of the program. Whether or not the destructor is called for the
\tcode{std::type_info} object at the end of the program is unspecified.

\pnum
When \tcode{typeid} is applied to a glvalue whose type is a
polymorphic class type\iref{class.virtual}, the result refers to a
\tcode{std::type_info} object representing the type of the most derived
object\iref{intro.object} (that is, the dynamic type) to which the
glvalue refers. If the glvalue is obtained by applying the
unary \tcode{*} operator to a pointer\footnote{If \tcode{p} is an expression of
pointer type, then \tcode{*p},
\tcode{(*p)}, \tcode{*(p)}, \tcode{((*p))}, \tcode{*((p))}, and so on
all meet this requirement.}
and the pointer is a null pointer value\iref{conv.ptr}, the
\tcode{typeid} expression throws an exception\iref{except.throw} of
a type that would match a handler of type
\indextext{\idxcode{bad_typeid}}%
\indexlibraryglobal{bad_typeid}%
\tcode{std::bad_typeid}
exception\iref{bad.typeid}.

\pnum
When \tcode{typeid} is applied to an expression other than a glvalue of
a polymorphic class type, the result refers to a \tcode{std::type_info}
object representing the static type of the expression.
Lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func} conversions are not applied to
the expression.
If the expression is a prvalue,
the temporary materialization conversion\iref{conv.rval}
is applied.
The expression is an unevaluated operand\iref{expr.prop}.

\pnum
When \tcode{typeid} is applied to a \grammarterm{type-id}, the result
refers to a \tcode{std::type_info} object representing the type of the
\grammarterm{type-id}. If the type of the \grammarterm{type-id} is a reference
to a possibly cv-qualified type, the result of the
\tcode{typeid} expression refers to a \tcode{std::type_info} object
representing the cv-unqualified referenced type. If the type of
the \grammarterm{type-id} is a class type or a reference to a class type,
the class shall be completely-defined.
\begin{note}
The \grammarterm{type-id} cannot denote a function type with
a \grammarterm{cv-qualifier-seq} or a \grammarterm{ref-qualifier}\iref{dcl.fct}.
\end{note}

\pnum
If the type of the expression or \grammarterm{type-id} is a
cv-qualified type, the result of the \tcode{typeid} expression refers
to a \tcode{std::type_info} object representing the cv-unqualified
type.
\begin{example}
\begin{codeblock}
class D { @\commentellip@ };
D d1;
const D d2;

typeid(d1) == typeid(d2);       // yields \tcode{true}
typeid(D)  == typeid(const D);  // yields \tcode{true}
typeid(D)  == typeid(d2);       // yields \tcode{true}
typeid(D)  == typeid(const D&); // yields \tcode{true}
\end{codeblock}
\end{example}

\pnum
If the header \libheaderrefx{typeinfo}{type.info}
is not imported or included prior
to a use of \tcode{typeid}, the program is ill-formed.

\pnum
\begin{note}
Subclause \ref{class.cdtor} describes the behavior of \tcode{typeid}
applied to an object under construction or destruction.
\end{note}

\rSec3[expr.static.cast]{Static cast}

\pnum
\indextext{expression!static cast}%
\indextext{cast!static}%
The result of the expression \tcode{static_cast<T>(v)} is the result of
converting the expression \tcode{v} to type \tcode{T}.
\indextext{cast!static!lvalue}%
\indextext{cast!lvalue}%
If \tcode{T} is an lvalue reference type
or an rvalue reference to function type, the result is an lvalue;
if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
otherwise, the result is a prvalue. The \tcode{static_cast} operator shall not cast
away constness\iref{expr.const.cast}.

\pnum
\indextext{cast!static!reference}%
\indextext{cast!reference}%
An lvalue of type ``\cvqual{cv1} \tcode{B}'', where \tcode{B} is a class
type, can be cast to type ``reference to \cvqual{cv2} \tcode{D}'', where
\tcode{D} is a class derived\iref{class.derived} from \tcode{B},
if \cvqual{cv2} is the
same cv-qualification as, or greater cv-qualification than,
\cvqual{cv1}. If \tcode{B} is a virtual base class of \tcode{D}
or a base class of a virtual base class of \tcode{D},
or if no valid standard conversion from ``pointer to \tcode{D}''
to ``pointer to \tcode{B}'' exists\iref{conv.ptr}, the program is ill-formed.
An xvalue of type
``\cvqual{cv1} \tcode{B}'' can be cast to type ``rvalue reference to
\cvqual{cv2} \tcode{D}'' with the same constraints as for an lvalue of
type ``\cvqual{cv1} \tcode{B}''. If the object
of type ``\cvqual{cv1} \tcode{B}'' is actually a base class subobject of an object
of type \tcode{D}, the result refers to the enclosing object of type
\tcode{D}. Otherwise, the behavior is undefined.
\begin{example}
\begin{codeblock}
struct B { };
struct D : public B { };
D d;
B &br = d;

static_cast<D&>(br);            // produces lvalue denoting the original \tcode{d} object
\end{codeblock}
\end{example}

\pnum
An lvalue
of type ``\cvqual{cv1} \tcode{T1}'' can be cast to type ``rvalue
reference to \cvqual{cv2} \tcode{T2}'' if ``\cvqual{cv2} \tcode{T2}'' is
reference-compatible with ``\cvqual{cv1}
\tcode{T1}''\iref{dcl.init.ref}. If the value is not a bit-field,
the result refers to the object or the specified base class subobject
thereof; otherwise, the lvalue-to-rvalue conversion\iref{conv.lval}
is applied to the bit-field and the resulting prvalue is used as the
\grammarterm{expression} of the \tcode{static_cast} for the remainder of this subclause.
If \tcode{T2} is an inaccessible\iref{class.access} or
ambiguous\iref{class.member.lookup} base class of \tcode{T1},
a program that necessitates such a cast is ill-formed.

\pnum
An expression \tcode{e} can be explicitly converted to a type \tcode{T}
if there is an implicit conversion sequence\iref{over.best.ics}
from \tcode{e} to \tcode{T},
if overload resolution for a direct-initialization\iref{dcl.init}
of an object or reference of type \tcode{T} from \tcode{e}
would find at least one viable function\iref{over.match.viable}, or
if \tcode{T} is an aggregate type\iref{dcl.init.aggr}
having a first element \tcode{x} and
there is an implicit conversion sequence
from \tcode{e} to the type of \tcode{x}.
If \tcode{T} is a reference type, the effect is
the same as performing the declaration and initialization
\begin{codeblock}
T t(e);
\end{codeblock}
for some invented temporary variable \tcode{t}\iref{dcl.init}
and then using the temporary variable as the result of the conversion.
Otherwise, the result object is direct-initialized from \tcode{e}.
\begin{note}
The conversion is ill-formed when attempting to convert an
expression of class type to an inaccessible or ambiguous base class.
\end{note}
\begin{note}
If \tcode{T} is ``array of unknown bound of \tcode{U}'',
this direct-initialization defines the type of the expression as \tcode{U[1]}.
\end{note}

\pnum
Otherwise, the \tcode{static_cast} shall perform one of the conversions
listed below. No other conversion shall be performed explicitly using a
\tcode{static_cast}.

\pnum
Any expression can be explicitly converted to type \cv{}~\tcode{void},
in which case it becomes a discarded-value
expression\iref{expr.prop}.
\begin{note}
However, if the value is in a temporary
object\iref{class.temporary}, the destructor for that
object is
not executed until the usual time, and the value of the object is
preserved for the purpose of executing the destructor.
\end{note}


\pnum
The inverse of any standard conversion sequence\iref{conv} not containing an
lvalue-to-rvalue\iref{conv.lval},
array-to-pointer\iref{conv.array},
function-to-pointer\iref{conv.func},
null pointer\iref{conv.ptr}, null member pointer\iref{conv.mem},
boolean\iref{conv.bool}, or
function pointer\iref{conv.fctptr}
conversion, can be performed explicitly using \tcode{static_cast}. A
program is ill-formed if it uses \tcode{static_cast} to perform the
inverse of an ill-formed standard conversion sequence.
\begin{example}
\begin{codeblock}
struct B { };
struct D : private B { };
void f() {
  static_cast<D*>((B*)0);               // error: \tcode{B} is a private base of \tcode{D}
  static_cast<int B::*>((int D::*)0);   // error: \tcode{B} is a private base of \tcode{D}
}
\end{codeblock}
\end{example}

\pnum
The lvalue-to-rvalue\iref{conv.lval},
array-to-pointer\iref{conv.array}, and
function-to-pointer\iref{conv.func} conversions are applied to the
operand. Such a \tcode{static_cast} is subject to the restriction that
the explicit conversion does not cast away
constness\iref{expr.const.cast}, and the following additional rules
for specific cases:

\pnum
A value of a scoped enumeration type\iref{dcl.enum}
can be explicitly converted to an integral type;
the result is the same as that of converting
to the enumeration's underlying type and then to the destination type.
A value of a scoped enumeration type
can also be explicitly converted to a floating-point type;
the result is the same as that of converting
from the original value to the floating-point type.

\pnum
\indextext{enumeration type!conversion to}%
\indextext{enumeration type!\idxcode{static_cast}!conversion to}%
A value of integral or enumeration type can be explicitly converted to
a complete enumeration type.
If the enumeration type has a fixed underlying type,
the value is first converted to that type
by integral conversion, if necessary, and
then to the enumeration type.
If the enumeration type does not have a fixed underlying type,
the value is unchanged
if the original value is within the range
of the enumeration values\iref{dcl.enum}, and
otherwise, the behavior is undefined.
A value of floating-point type can also be explicitly converted to an enumeration type.
The resulting value is the same as converting the original value to the
underlying type of the enumeration\iref{conv.fpint}, and subsequently to
the enumeration type.

\pnum
\indextext{cast!base class}%
\indextext{cast!derived class}%
A prvalue of type ``pointer to \cvqual{cv1} \tcode{B}'', where \tcode{B}
is a class type, can be converted to a prvalue of type ``pointer to
\cvqual{cv2} \tcode{D}'',
where \tcode{D} is a complete class derived\iref{class.derived}
from \tcode{B},
if \cvqual{cv2} is the same cv-qualification as,
or greater cv-qualification than, \cvqual{cv1}.
If \tcode{B} is a virtual base class of \tcode{D} or
a base class of a virtual base class of \tcode{D}, or
if no valid standard conversion from ``pointer to \tcode{D}''
to ``pointer to \tcode{B}'' exists\iref{conv.ptr}, the program is ill-formed.
The null pointer value\iref{conv.ptr} is converted
to the null pointer value of the destination type. If the prvalue of type
``pointer to \cvqual{cv1} \tcode{B}'' points to a \tcode{B} that is
actually a subobject of an object of type \tcode{D}, the resulting
pointer points to the enclosing object of type \tcode{D}. Otherwise, the
behavior is undefined.

\pnum
\indextext{cast!pointer-to-member}%
A prvalue of type ``pointer to member of \tcode{D} of type \cvqual{cv1}
\tcode{T}'' can be converted to a prvalue of type ``pointer to member of
\tcode{B} of type \cvqual{cv2} \tcode{T}'', where
\tcode{D} is a complete class type and
\tcode{B} is a base class\iref{class.derived} of \tcode{D},
if \cvqual{cv2} is the same cv-qualification
as, or greater cv-qualification than, \cvqual{cv1}.
\begin{note}
Function types (including those used in pointer-to-member-function types)
are never cv-qualified\iref{dcl.fct}.
\end{note}
If no valid standard conversion
from ``pointer to member of \tcode{B} of type \tcode{T}''
to ``pointer to member of \tcode{D} of type \tcode{T}''
exists\iref{conv.mem}, the program is ill-formed.
The null member pointer value\iref{conv.mem} is converted to the null
member pointer value of the destination type. If class \tcode{B}
contains the original member, or is a base or derived class of the class
containing the original member, the resulting pointer to member points
to the original member. Otherwise, the behavior is undefined.
\begin{note}
Although class \tcode{B} need not contain the original member, the
dynamic type of the object with which indirection through the pointer
to member is performed must contain the original member;
see~\ref{expr.mptr.oper}.
\end{note}

\pnum
A prvalue of type ``pointer to \cvqual{cv1} \tcode{void}'' can be
converted to a prvalue of type ``pointer to \cvqual{cv2} \tcode{T}'',
where \tcode{T} is an object type and \cvqual{cv2} is the same
cv-qualification as, or greater cv-qualification than, \cvqual{cv1}.
If the original pointer value represents the address
\tcode{A} of a byte in memory and
\tcode{A} does not satisfy the alignment requirement of \tcode{T},
then the resulting pointer value is unspecified.
Otherwise, if the original pointer value points to an object \placeholder{a},
and there is an object \placeholder{b} of type \tcode{T} (ignoring cv-qualification)
that is pointer-interconvertible\iref{basic.compound} with \placeholder{a},
the result is a pointer to \placeholder{b}.
Otherwise, the pointer value is unchanged by the conversion.
\begin{example}
\begin{codeblock}
T* p1 = new T;
const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
bool b = p1 == p2;  // \tcode{b} will have the value \tcode{true}.
\end{codeblock}
\end{example}

\rSec3[expr.reinterpret.cast]{Reinterpret cast}

\pnum
\indextext{expression!reinterpret cast}%
\indextext{cast!reinterpret}%
The result of the expression \tcode{reinterpret_cast<T>(v)} is the
result of converting the expression \tcode{v} to type \tcode{T}.
\indextext{cast!reinterpret!lvalue}%
\indextext{cast!lvalue}%
If \tcode{T} is an lvalue reference type or an rvalue reference to function type, the result is an lvalue;
if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
otherwise, the result is a prvalue and the
lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func} standard conversions are
performed on the expression \tcode{v}. Conversions that can be performed explicitly
using \tcode{reinterpret_cast} are listed below. No other conversion can
be performed explicitly using \tcode{reinterpret_cast}.

\pnum
The \tcode{reinterpret_cast} operator shall not cast away constness\iref{expr.const.cast}.
An expression of integral, enumeration, pointer, or pointer-to-member type
can be explicitly converted to its own type; such a cast yields the value of
its operand.

\pnum
\begin{note}
The mapping performed by \tcode{reinterpret_cast} might, or might not, produce a
representation different from the original value.
\end{note}

\pnum
\indextext{cast!reinterpret!pointer to integer}%
\indextext{cast!pointer to integer}%
A pointer can be explicitly converted to any integral type large enough
to hold all values of its type.
\indextext{conversion!implementation-defined pointer integer}%
The mapping function is \impldef{mapping of pointer to integer}.
\begin{note}
It is intended to be unsurprising to those who know the addressing
structure of the underlying machine.
\end{note}
A value of type \tcode{std::nullptr_t} can be converted to an integral
type; the conversion has the same meaning and validity as a conversion of
\tcode{(void*)0} to the integral type.
\begin{note}
A \tcode{reinterpret_cast}
cannot be used to convert a value of any type to the type
\tcode{std::nullptr_t}.
\end{note}

\pnum
\indextext{cast!reinterpret!integer to pointer}%
\indextext{cast!integer to pointer}%
A value of integral type or enumeration type can be explicitly converted
to a pointer. A pointer converted to an integer of sufficient size (if
any such exists on the implementation) and back to the same pointer type
will have its original value;
\indextext{conversion!implementation-defined pointer integer}%
mappings between pointers and integers are otherwise
\impldef{conversions between pointers and integers}.
\begin{note}
Except as described in \ref{basic.stc.dynamic.safety}, the result of
such a conversion will not be a safely-derived pointer value.
\end{note}

\pnum
\indextext{cast!reinterpret!pointer-to-function}%
\indextext{cast!pointer-to-function}%
\indextext{cast!undefined pointer-to-function}%
A function pointer can be explicitly converted
to a function pointer of a different type.
\indextext{function call!undefined}%
\begin{note}
The effect of calling a function through a pointer to a function
type\iref{dcl.fct} that is not the same as the type used in the
definition of the function is undefined\iref{expr.call}.
\end{note}
Except that converting
a prvalue of type ``pointer to \tcode{T1}'' to the type ``pointer to
\tcode{T2}'' (where \tcode{T1} and \tcode{T2} are function types) and
back to its original type yields the original pointer value, the result
of such a pointer conversion is unspecified.
\begin{note}
See also~\ref{conv.ptr} for more details of pointer conversions.
\end{note}

\pnum
An object pointer
can be explicitly converted to an object pointer of a different type.\footnote{The
types may have different \cv-qualifiers, subject to
the overall
restriction that a \tcode{reinterpret_cast} cannot cast away constness.}
When a prvalue \tcode{v} of object pointer type is converted to
the object pointer type ``pointer to \cv{}~\tcode{T}'', the result is \tcode{static_cast<\cv{} T*>(static_cast<\cv{}~void*>(v))}.
\begin{note}
Converting a prvalue of type ``pointer to \tcode{T1}'' to
the type ``pointer to \tcode{T2}'' (where \tcode{T1} and \tcode{T2} are
object types and where the alignment requirements of \tcode{T2} are no
stricter than those of \tcode{T1}) and back to its original type yields
the original pointer value.
\end{note}

\pnum
Converting a function pointer to an object pointer
type or vice versa is
conditionally-supported. The meaning of such a conversion is
\impldef{converting function pointer to object pointer and vice versa},
except that if an implementation
supports conversions in both directions, converting a prvalue of one type to the other
type and back, possibly with different cv-qualification, shall yield the original
pointer value.

\pnum
The null pointer value\iref{conv.ptr} is converted to the null pointer value
of the destination type.
\begin{note}
A null pointer constant of type \tcode{std::nullptr_t} cannot be converted to a
pointer type, and a null pointer constant of integral type is not necessarily
converted to a null pointer value.
\end{note}

\pnum
\indextext{cast!reinterpret!pointer-to-member}%
\indextext{cast!pointer-to-member}%
A prvalue of type ``pointer to member of \tcode{X} of type \tcode{T1}''
can be explicitly converted to a prvalue of a different type ``pointer to member of
\tcode{Y} of type \tcode{T2}'' if \tcode{T1} and \tcode{T2} are both
function types or both object types.\footnote{\tcode{T1} and \tcode{T2} may have
different \cv-qualifiers, subject to
the overall restriction that a \tcode{reinterpret_cast} cannot cast away
constness.} The null member pointer value\iref{conv.mem} is converted to the
null member pointer value of the destination type. The result of this
conversion is unspecified, except in the following cases:

\begin{itemize}
\item Converting a prvalue of type ``pointer to member function'' to a
different pointer-to-member-function type and back to its original type
yields the original pointer-to-member value.

\item Converting a prvalue of type ``pointer to data member of \tcode{X}
of type \tcode{T1}'' to the type ``pointer to data member of \tcode{Y}
of type \tcode{T2}'' (where the alignment requirements of \tcode{T2} are
no stricter than those of \tcode{T1}) and back to its original type
yields the original pointer-to-member value.
\end{itemize}

\pnum
\indextext{cast!reinterpret!reference}%
\indextext{cast!reference}%
A glvalue of type \tcode{T1},
designating an object \placeholder{x},
can be cast to the type ``reference to \tcode{T2}''
if an expression of type ``pointer to \tcode{T1}''
can be explicitly converted to the type ``pointer to \tcode{T2}''
using a \tcode{reinterpret_cast}.
The result is that of \tcode{*reinterpret_cast<T2 *>(p)}
where \tcode{p} is a pointer to \placeholder{x}
of type ``pointer to \tcode{T1}''.
No temporary is created, no copy is made, and
no constructors\iref{class.ctor} or conversion
functions\iref{class.conv} are called.%
\footnote{This is sometimes referred to as a \defn{type pun}
when the result refers to the same object as the source glvalue.}

\rSec3[expr.const.cast]{Const cast}

\pnum
\indextext{expression!const cast}%
\indextext{cast!const}%
The result of the expression \tcode{const_cast<T>(v)} is of type
\tcode{T}. If \tcode{T} is an lvalue reference to object type, the result is an
lvalue;
if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
otherwise, the result is a prvalue and the
lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func} standard conversions are
performed on the expression \tcode{v}. Conversions that can be performed explicitly using
\tcode{const_cast} are listed below. No other conversion shall be
performed explicitly using \tcode{const_cast}.

\pnum
\begin{note}
Subject to the restrictions in this subclause, an expression may be cast
to its own type using a \tcode{const_cast} operator.
\end{note}

\pnum
For two similar types \tcode{T1} and \tcode{T2}\iref{conv.qual},
a prvalue of type \tcode{T1} may be explicitly
converted to the type \tcode{T2} using a \tcode{const_cast}
if, considering the cv-decompositions of both types,
each $P^1_i$ is the same as $P^2_i$ for all $i$.
The result of a \tcode{const_cast} refers to the original entity.
\begin{example}
\begin{codeblock}
typedef int *A[3];                  // array of 3 pointer to \tcode{int}
typedef const int *const CA[3];     // array of 3 const pointer to \tcode{const int}

CA &&r = A{};                       // OK, reference binds to temporary array object
                                    // after qualification conversion to type \tcode{CA}
A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
A &&r2 = const_cast<A&&>(CA{});     // OK
\end{codeblock}
\end{example}

\pnum
For two object types \tcode{T1} and \tcode{T2}, if a pointer to \tcode{T1} can
be explicitly converted to the type ``pointer to \tcode{T2}'' using a
\tcode{const_cast}, then the following conversions can also be made:
\begin{itemize}
\item an lvalue of type \tcode{T1} can be explicitly converted to an lvalue
of type \tcode{T2} using the cast \tcode{const_cast<T2\&>};

\item a glvalue of type \tcode{T1} can be explicitly converted to an xvalue
of type \tcode{T2} using the cast \tcode{const_cast<T2\&\&>}; and

\item if \tcode{T1} is a class type, a prvalue of type \tcode{T1} can be
explicitly converted to an xvalue of type \tcode{T2} using the cast
\tcode{const_cast<T2\&\&>}.
\end{itemize}

The result of a reference \tcode{const_cast} refers
to the original object if the operand is a glvalue and
to the result of applying the temporary materialization conversion\iref{conv.rval} otherwise.

\pnum
A null pointer value\iref{conv.ptr} is converted to the null pointer
value of the destination type. The null member pointer
value\iref{conv.mem} is converted to the null member pointer value of
the destination type.

\pnum
\begin{note}
Depending on the type of the object, a write operation through the
pointer, lvalue or pointer to data member resulting from a
\tcode{const_cast} that casts away a const-qualifier\footnote{\tcode{const_cast}
is not limited to conversions that cast away a
const-qualifier.}
may produce undefined behavior\iref{dcl.type.cv}.
\end{note}

\pnum
\indextext{\idxcode{const}!cast away}%
A conversion from a type \tcode{T1} to a type \tcode{T2}
\defnx{casts away constness}{casting away constness}
if \tcode{T1} and \tcode{T2} are different,
there is a cv-decomposition\iref{conv.qual} of \tcode{T1}
yielding \placeholder{n} such that
\tcode{T2} has a cv-decomposition of the form
\begin{indented}
$\cv{}_0^2$ $P_0^2$ $\cv{}_1^2$ $P_1^2$ $\cdots$ $\cv{}_{n-1}^2$ $P_{n-1}^2$ $\cv{}_n^2$ $\mathtt{U}_2$,
\end{indented}
and there is no qualification conversion that converts \tcode{T1} to
\begin{indented}
$\cv{}_0^2$ $P_0^1$ $\cv{}_1^2$ $P_1^1$ $\cdots$ $\cv{}_{n-1}^2$ $P_{n-1}^1$ $\cv{}_n^2$ $\mathtt{U}_1$.
\end{indented}

\pnum
Casting from an lvalue of type \tcode{T1} to an lvalue of type
\tcode{T2} using an lvalue reference cast
or casting from an expression of type \tcode{T1} to an xvalue of type \tcode{T2} using
an rvalue reference cast
casts away constness if a cast from a prvalue of type ``pointer to \tcode{T1}'' to the type ``pointer to
\tcode{T2}'' casts away constness.

\pnum
\begin{note}
Some conversions which involve only changes in cv-qualification cannot
be done using \tcode{const_cast.} For instance, conversions between
pointers to functions are not covered because such conversions lead to
values whose use causes undefined behavior. For the same reasons,
conversions between pointers to member functions, and in particular, the
conversion from a pointer to a const member function to a pointer to a
non-const member function, are not covered.
\end{note}
\indextext{expression!postfix|)}

\rSec2[expr.unary]{Unary expressions}

\pnum
\indextext{expression!unary|(}%
Expressions with unary operators group right-to-left.

\indextext{expression!unary}%
\indextext{operator!unary}%
\indextext{operator!\idxcode{sizeof}}%
\indextext{operator!cast}%
%
\begin{bnf}
\nontermdef{unary-expression}\br
    postfix-expression\br
    unary-operator cast-expression\br
    \terminal{++} cast-expression\br
    \terminal{-{-}} cast-expression\br
    await-expression\br
    \keyword{sizeof} unary-expression\br
    \keyword{sizeof} \terminal{(} type-id \terminal{)}\br
    \keyword{sizeof} \terminal{...} \terminal{(} identifier \terminal{)}\br
    \keyword{alignof} \terminal{(} type-id \terminal{)}\br
    noexcept-expression\br
    new-expression\br
    delete-expression
\end{bnf}

\indextext{operator!indirection}%
\indextext{\idxcode{*}|see{operator, indirection}}%
\indextext{operator!address-of}%
\indextext{\idxcode{\&}|see{operator, address-of}}%
\indextext{operator!unary minus}%
\indextext{\idxcode{-}|see{operator, unary minus}}%
\indextext{operator!unary plus}%
\indextext{\idxcode{+}|see{operator, unary plus}}%
\indextext{operator!logical negation}%
\indextext{\idxcode{"!}|see{operator, logical negation}}%
\indextext{operator!ones' complement}%
\indextext{~@\tcode{\~}|see{operator, ones' complement}}%
\indextext{operator!increment}%
\indextext{operator!decrement}%
%
\begin{bnf}
\nontermdef{unary-operator} \textnormal{one of}\br
    \terminal{*  \&  +  -  !  \~}
\end{bnf}

\rSec3[expr.unary.op]{Unary operators}

\pnum
\indextext{expression!unary operator}%
\indextext{operator!unary}%
The unary \tcode{*} operator performs \defn{indirection}:
\indextext{dereferencing|see{indirection}}%
the expression to which it is applied shall be a pointer to an object
type, or a pointer to a function type and the result is an lvalue
referring to the object or function to which the expression points. If
the type of the expression is ``pointer to \tcode{T}'', the type of the
result is ``\tcode{T}''.
\begin{note}
\indextext{type!incomplete}%
Indirection through a pointer to an incomplete type (other than
\cv{} \tcode{void}) is valid. The lvalue thus obtained can be
used in limited ways (to initialize a reference, for example); this
lvalue must not be converted to a prvalue, see~\ref{conv.lval}.
\end{note}

\pnum
The result of each of the following unary operators is a prvalue.

\pnum
\indextext{name!address of cv-qualified}%
\indextext{expression!pointer-to-member constant}%
The result of the unary \tcode{\&} operator is a pointer to its operand.
\begin{itemize}
\item
If the operand is a \grammarterm{qualified-id} naming a non-static or variant member \tcode{m}
of some class \tcode{C} with type \tcode{T}, the result has type ``pointer to member
of class \tcode{C} of type \tcode{T}'' and is a prvalue designating \tcode{C::m}.
\item
Otherwise, if the operand is an lvalue of type \tcode{T},
the resulting expression is a prvalue of type ``pointer to \tcode{T}''
whose result is a pointer to the designated object\iref{intro.memory} or function.
\begin{note}
In particular, taking the address of a variable of type ``\cv{}~\tcode{T}''
yields a pointer of type ``pointer to \cv{}~\tcode{T}''.
\end{note}
\item
Otherwise, the program is ill-formed.
\end{itemize}
\begin{example}
\begin{codeblock}
struct A { int i; };
struct B : A { };
... &B::i ...       // has type \tcode{int A::*}
int a;
int* p1 = &a;
int* p2 = p1 + 1;   // defined behavior
bool b = p2 > p1;   // defined behavior, with value \tcode{true}
\end{codeblock}
\end{example}
\begin{note}
A pointer to member formed from a \tcode{mutable} non-static data
member\iref{dcl.stc} does not reflect the \tcode{mutable} specifier
associated with the non-static data member.
\end{note}

\pnum
A pointer to member is only formed when an explicit \tcode{\&} is used
and its operand is a \grammarterm{qualified-id} not enclosed in
parentheses.
\begin{note}
That is, the expression \tcode{\&(qualified-id)}, where the
\grammarterm{qualified-id} is enclosed in parentheses, does not form an
expression of type ``pointer to member''. Neither does
\tcode{qualified-id}, because there is no implicit conversion from a
\grammarterm{qualified-id} for a non-static member function to the type
``pointer to member function'' as there is from an lvalue of function
type to the type ``pointer to function''\iref{conv.func}. Nor is
\tcode{\&unqualified-id} a pointer to member, even within the scope of
the \grammarterm{unqualified-id}'s class.
\end{note}

\pnum
If \tcode{\&} is applied to an lvalue of incomplete class type and the
complete type declares \tcode{operator\&()}, it is unspecified whether
the operator has the built-in meaning or the operator function is
called. The operand of \tcode{\&} shall not be a bit-field.

\pnum
\indextext{overloaded function!address of}%
\begin{note}
The address of an overloaded function\iref{over} can be taken
only in a context that uniquely determines which version of the
overloaded function is referred to (see~\ref{over.over}).
Since the context might determine whether the operand is a static or
non-static member function, the context can also affect whether the
expression has type ``pointer to function'' or ``pointer to member
function''.
\end{note}

\pnum
\indextext{operator!unary plus}%
The operand of the unary \tcode{+} operator shall have arithmetic, unscoped
enumeration, or pointer type and the result is the value of the
argument. Integral promotion is performed on integral or enumeration
operands. The type of the result is the type of the promoted operand.

\pnum
\indextext{operator!unary minus}%
The operand of the unary \tcode{-} operator shall have arithmetic or unscoped
enumeration type and the result is the negation of its operand. Integral
promotion is performed on integral or enumeration operands. The negative
of an unsigned quantity is computed by subtracting its value from $2^n$,
where $n$ is the number of bits in the promoted operand. The type of the
result is the type of the promoted operand.

\pnum
\indextext{operator!logical negation}%
The operand of the logical negation operator \tcode{!} is contextually
converted to \tcode{bool}\iref{conv};
its value is \tcode{true}
if the converted operand is \tcode{false} and \tcode{false} otherwise.
The type of the result is \tcode{bool}.

\pnum
\indextext{signed integer representation!ones' complement}%
\indextext{operator!ones' complement}%
The operand of \tcode{\~{}} shall have integral or unscoped enumeration type; the
result is the ones' complement of its operand. Integral promotions are
performed. The type of the result is the type of the promoted operand.
There is an ambiguity
in the grammar when \tcode{\~{}} is followed by
a \grammarterm{type-name} or \grammarterm{decltype-specifier}.
The ambiguity is resolved by treating \tcode{\~{}} as the unary complement
operator rather than as the start of an \grammarterm{unqualified-id}
naming a destructor.
\begin{note}
Because the grammar does not permit an operator to follow the
\tcode{.}, \tcode{->}, or \tcode{::} tokens, a \tcode{\~{}} followed by
a \grammarterm{type-name} or \grammarterm{decltype-specifier} in a
member access expression or \grammarterm{qualified-id} is
unambiguously parsed as a destructor name.
\end{note}

\rSec3[expr.pre.incr]{Increment and decrement}

\pnum
\indextext{expression!increment}%
\indextext{expression!decrement}%
The operand of prefix \tcode{++}
\indextext{operator!increment}%
\indextext{prefix \tcode{++}}%
is modified\iref{defns.access} by adding \tcode{1}.
\indextext{prefix \tcode{\dcr}}%
The operand shall be a modifiable lvalue. The type of the operand shall
be an arithmetic type other than \cv{}~\tcode{bool},
or a pointer to a completely-defined object type.
An operand with \tcode{volatile}-qualified type is deprecated;
see~\ref{depr.volatile.type}.
The result is the updated operand; it is an lvalue, and it is a
bit-field if the operand is a bit-field.
The expression \tcode{++x} is equivalent to \tcode{x+=1}.
\indextext{operator!\idxcode{+=}}%
\begin{note}
See the discussions of addition\iref{expr.add} and assignment
operators\iref{expr.ass} for information on conversions.
\end{note}

\pnum
The operand of prefix
\indextext{operator!decrement}%
\tcode{\dcr} is modified\iref{defns.access} by subtracting \tcode{1}.
The requirements on the operand of prefix
\tcode{\dcr} and the properties of its result are otherwise the same as
those of prefix \tcode{++}.
\begin{note}
For postfix increment and decrement, see~\ref{expr.post.incr}.
\end{note}

\rSec3[expr.await]{Await}
\indextext{expression!await}%
\indextext{\idxcode{co_await}}%

\pnum
The \tcode{co_await} expression is used to suspend evaluation of a
coroutine\iref{dcl.fct.def.coroutine} while awaiting completion of
the computation represented by the operand expression.

\begin{bnf}
\nontermdef{await-expression}\br
    \terminal{co_await} cast-expression
\end{bnf}

\pnum
An \grammarterm{await-expression} shall appear only in a potentially-evaluated
expression within the \grammarterm{compound-statement} of a
\grammarterm{function-body} outside of a \grammarterm{handler}\iref{except.pre}.
In a \grammarterm{declaration-statement} or in the
\grammarterm{simple-declaration} (if any)
of a \grammarterm{for-init-statement}, an \grammarterm{await-expression}
shall appear only in an \grammarterm{initializer} of that
\grammarterm{declaration-statement} or \grammarterm{simple-declaration}.
An \grammarterm{await-expression} shall not appear in a
default argument\iref{dcl.fct.default}.
An \grammarterm{await-expression} shall not appear in the initializer of
a block-scope variable with static or thread storage duration.
A context within a function where an \grammarterm{await-expression} can appear
is called a \term{suspension context} of the function.

\pnum
Evaluation of an \grammarterm{await-expression} involves the following
auxiliary types, expressions, and objects:

\begin{itemize}
\item
\placeholder{p} is an lvalue naming the promise
object\iref{dcl.fct.def.coroutine}
of the enclosing coroutine and \tcode{P} is the type of that object.

\item \placeholder{a} is the \grammarterm{cast-expression} if
the \grammarterm{await-expression} was implicitly produced by a
\grammarterm{yield-expression}\iref{expr.yield}, an initial suspend point,
or a final suspend point\iref{dcl.fct.def.coroutine}.
Otherwise, the \grammarterm{unqualified-id} \tcode{await_transform} is
looked up within the scope of \tcode{P} by class member access
lookup\iref{basic.lookup.classref},
and if this lookup finds at least one declaration, then \placeholder{a} is
\mbox{\placeholder{p}\tcode{.await_transform(}\grammarterm{cast-expression}\tcode{)}};
otherwise, \placeholder{a} is the  \grammarterm{cast-expression}.

\item
\placeholder{o} is determined by enumerating the applicable
\tcode{operator co_await} functions for an argument
\placeholder{a}\iref{over.match.oper}, and choosing the best one through
overload resolution\iref{over.match}. If overload resolution is ambiguous,
the program is ill-formed.
If no viable functions are found, \placeholder{o} is \placeholder{a}.
Otherwise, \placeholder{o} is a call to the selected function
with the argument \placeholder{a}.
If \placeholder{o} would be a prvalue,
the temporary materialization conversion\iref{conv.rval} is applied.

\item
\placeholder{e} is an lvalue
referring to the result of evaluating
the (possibly-converted) \placeholder{o}.

\item
% FIXME: h needs to be an expression so we can use it as an argument
% to await_suspend. What should its value category be?
% Don't forget to remove "and objects" from the intro sentence when
% this is fixed.
\placeholder{h} is an object of type
\tcode{std::coroutine_handle<P>}
referring to the enclosing coroutine.

\item
\placeholder{await-ready} is the expression
\placeholder{e}\tcode{.await_ready()},
contextually converted to \tcode{bool}.

\item
\placeholder{await-suspend} is the expression
\placeholder{e}\tcode{.await_suspend(}\placeholder{h}\tcode{)},
which shall be a prvalue of type \tcode{void}, \tcode{bool}, or
\tcode{std::coroutine_handle<Z>} for some type \tcode{Z}.

\item
\placeholder{await-resume} is the expression
\placeholder{e}\tcode{.await_resume()}.
\end{itemize}

\pnum
The \grammarterm{await-expression} has the same type and value category
as the \placeholder{await-resume} expression.

\pnum
The \grammarterm{await-expression} evaluates
the (possibly-converted) \placeholder{o} expression and
the \placeholder{await-ready} expression, then:
\begin{itemize}
\item
If the result of \placeholder{await-ready} is \tcode{false},
the coroutine is considered suspended.
Then:
\begin{itemize}
\item
If the type of \placeholder{await-suspend}
is \tcode{std::coroutine_handle<Z>},
\placeholder{await-suspend}\tcode{.resume()} is evaluated.
\begin{note}
This resumes the coroutine referred to
by the result of \placeholder{await-suspend}.
Any number of coroutines may be successively resumed in this fashion,
eventually returning control flow to the current coroutine caller or
resumer\iref{dcl.fct.def.coroutine}.
\end{note}

\item
Otherwise, if the type of \placeholder{await-suspend}
is \tcode{bool},
\placeholder{await-suspend} is evaluated,
and the coroutine is resumed if the result is \tcode{false}.

\item
Otherwise, \placeholder{await-suspend} is evaluated.
\end{itemize}
If the evaluation of \placeholder{await-suspend}
exits via an exception, the exception is caught,
the coroutine is resumed, and the exception is immediately
re-thrown\iref{except.throw}. Otherwise, control flow returns
to the current coroutine caller or resumer\iref{dcl.fct.def.coroutine}
without exiting any scopes\iref{stmt.jump}.

\item
If the result of \placeholder{await-ready} is \tcode{true},
or when the coroutine is resumed,
the \placeholder{await-resume} expression is evaluated, and
its result is the result of the \grammarterm{await-expression}.
\end{itemize}

\pnum
\begin{example}
\begin{codeblock}
template <typename T>
struct my_future {
  @\commentellip@
  bool await_ready();
  void await_suspend(std::coroutine_handle<>);
  T await_resume();
};

template <class Rep, class Period>
auto operator co_await(std::chrono::duration<Rep, Period> d) {
  struct awaiter {
    std::chrono::system_clock::duration duration;
    @\commentellip@
    awaiter(std::chrono::system_clock::duration d) : duration(d) {}
    bool await_ready() const { return duration.count() <= 0; }
    void await_resume() {}
    void await_suspend(std::coroutine_handle<> h) { @\commentellip@ }
  };
  return awaiter{d};
}

using namespace std::chrono;

my_future<int> h();

my_future<void> g() {
  std::cout << "just about go to sleep...\n";
  co_await 10ms;
  std::cout << "resumed\n";
  co_await h();
}

auto f(int x = co_await h());   // error: \grammarterm{await-expression} outside of function suspension context
int a[] = { co_await h() };     // error: \grammarterm{await-expression} outside of function suspension context
\end{codeblock}
\end{example}

\rSec3[expr.sizeof]{Sizeof}

\pnum
\indextext{expression!\idxcode{sizeof}}%
\indextext{operator!\idxcode{sizeof}}%
\indextext{byte}%
The \tcode{sizeof} operator yields the number of bytes
occupied by a non-potentially-overlapping object of the type
of its operand. The operand is either an expression,
which is an unevaluated operand\iref{expr.prop}, or a parenthesized
\grammarterm{type-id}.
\indextext{type!incomplete}%
The \tcode{sizeof} operator shall not be applied to an expression that
has function or incomplete type,
to the parenthesized name of such
types, or to a glvalue that designates a bit-field.
The result of \tcode{sizeof}
applied to any of the narrow character types is \tcode{1}.
The result of
\tcode{sizeof} applied to any other fundamental
type\iref{basic.fundamental} is \impldef{\tcode{sizeof} applied to
fundamental types
other than \tcode{char}, \tcode{signed char}, and \tcode{unsigned char}}.
\begin{note}
In particular, \tcode{sizeof(bool)}, \tcode{sizeof(char16_t)},
\tcode{sizeof(char32_t)}, and \tcode{sizeof(wchar_t)} are
implementation-defined.\footnote{\tcode{sizeof(bool)} is not required to be \tcode{1}.}
\end{note}
\begin{note}
See~\ref{intro.memory} for the definition of \term{byte}
and~\ref{basic.types} for the definition of \term{object representation}.
\end{note}

\pnum
\indextext{reference!\idxcode{sizeof}}%
When applied to a reference type, the result is the size
of the referenced type.
\indextext{class object!\idxcode{sizeof}}%
When applied to a class, the result is the number of bytes in an object
of that class including any padding required for placing objects of that
type in an array.
The result of applying \tcode{sizeof} to a
potentially-overlapping subobject is
the size of the type, not the size of the subobject.%
\footnote{The actual size of a potentially-overlapping subobject
may be less than the result of
applying \tcode{sizeof} to the subobject, due to virtual base classes
and less strict padding requirements on potentially-overlapping subobjects.}
\indextext{array!\idxcode{sizeof}}%
When applied to an array, the result is the total number of bytes in the
array. This implies that the size of an array of $n$ elements is
$n$ times the size of an element.

\pnum
The lvalue-to-rvalue\iref{conv.lval},
array-to-pointer\iref{conv.array}, and
function-to-pointer\iref{conv.func} standard conversions are not
applied to the operand of \tcode{sizeof}.
If the operand is a prvalue,
the temporary materialization conversion\iref{conv.rval}
is applied.

\pnum
The identifier in a \tcode{sizeof...} expression shall name a
pack. The \tcode{sizeof...} operator yields the number of elements
in the pack\iref{temp.variadic}.
A \tcode{sizeof...} expression is a pack expansion\iref{temp.variadic}.
\begin{example}
\begin{codeblock}
template<class... Types>
struct count {
  static const std::size_t value = sizeof...(Types);
};
\end{codeblock}
\end{example}

\pnum
\indextext{\idxcode{size_t}}%
\indexlibraryglobal{size_t}%
The result of \tcode{sizeof} and \tcode{sizeof...} is a prvalue of type
\tcode{std::size_t}.
\begin{note}
A \tcode{sizeof} expression
is an integral constant expression\iref{expr.const}.
The type \tcode{std::size_t} is defined in the standard header
\libheader{cstddef}~(\ref{cstddef.syn}, \ref{support.types.layout}).
\end{note}

\rSec3[expr.alignof]{Alignof}

\pnum
\indextext{\idxcode{alignof}}%
\indextext{expression!\idxcode{alignof}}%
An \tcode{alignof} expression yields the alignment requirement
of its operand type. The operand shall be a \grammarterm{type-id}
representing a complete object type, or an array thereof, or a reference
to one of those types.

\pnum
The result is a prvalue of type \tcode{std::size_t}.
\begin{note}
An \tcode{alignof} expression
is an integral constant expression\iref{expr.const}.
The type \tcode{std::size_t} is defined in the standard header
\libheader{cstddef}~(\ref{cstddef.syn}, \ref{support.types.layout}).
\end{note}

\pnum
When \tcode{alignof} is applied to a reference type, the result
is the alignment of the referenced type. When \tcode{alignof}
is applied to an array type, the result is the alignment of the
element type.

\rSec3[expr.unary.noexcept]{\tcode{noexcept} operator}

\pnum
\indextext{\idxcode{noexcept}}%
\indextext{expression!\idxcode{noexcept}}%
The \tcode{noexcept} operator determines whether the evaluation of its operand,
which is an unevaluated operand\iref{expr.prop}, can throw an
exception\iref{except.throw}.

\begin{bnf}
\nontermdef{noexcept-expression}\br
  \keyword{noexcept} \terminal{(} expression \terminal{)}
\end{bnf}

\pnum
The result of the \tcode{noexcept} operator is a prvalue of type \tcode{bool}.
\begin{note}
A \grammarterm{noexcept-expression}
is an integral constant expression\iref{expr.const}.
\end{note}

\pnum
The result of the \tcode{noexcept} operator is \tcode{true}
unless the \grammarterm{expression} is potentially-throwing\iref{except.spec}.
\indextext{expression!unary|)}

\rSec3[expr.new]{New}

\pnum
\indextext{expression!\idxcode{new}}%
\indextext{free store|seealso{\tcode{new}, \tcode{delete}}}%
\indextext{memory management|see{\tcode{new}, \tcode{delete}}}%
\indextext{storage management|see{\tcode{new}, \tcode{delete}}}%
\indextext{\idxcode{new}}%
The \grammarterm{new-expression} attempts to create an object of the
\grammarterm{type-id}\iref{dcl.name} or \grammarterm{new-type-id} to which
it is applied. The type of that object is the \defnadj{allocated}{type}.
\indextext{type!incomplete}%
This type shall be a complete object type, but not an abstract class
type or array
thereof~(\ref{intro.object}, \ref{basic.types}, \ref{class.abstract}).
\begin{note}
Because references are not objects, references cannot be created by
\grammarterm{new-expression}{s}.
\end{note}
\begin{note}
The \grammarterm{type-id} may be a cv-qualified type, in which case the
object created by the \grammarterm{new-expression} has a cv-qualified type.
\end{note}

\begin{bnf}
\nontermdef{new-expression}\br
    \opt{\terminal{::}} \keyword{new} \opt{new-placement} new-type-id \opt{new-initializer} \br
    \opt{\terminal{::}} \keyword{new} \opt{new-placement} \terminal{(} type-id \terminal{)} \opt{new-initializer}
\end{bnf}

\indextext{\idxcode{new}!storage allocation}%
%
\begin{bnf}
\nontermdef{new-placement}\br
    \terminal{(} expression-list \terminal{)}
\end{bnf}

\begin{bnf}
\nontermdef{new-type-id}\br
    type-specifier-seq \opt{new-declarator}
\end{bnf}

\begin{bnf}
\nontermdef{new-declarator}\br
    ptr-operator \opt{new-declarator} \br
    noptr-new-declarator
\end{bnf}

\begin{bnf}
\nontermdef{noptr-new-declarator}\br
    \terminal{[} \opt{expression} \terminal{]} \opt{attribute-specifier-seq}\br
    noptr-new-declarator \terminal{[} constant-expression \terminal{]} \opt{attribute-specifier-seq}
\end{bnf}

\begin{bnf}
\nontermdef{new-initializer}\br
    \terminal{(} \opt{expression-list} \terminal{)}\br
    braced-init-list
\end{bnf}

\pnum
If a placeholder type\iref{dcl.spec.auto} appears in the
\grammarterm{type-specifier-seq} of a \grammarterm{new-type-id} or
\grammarterm{type-id} of a \grammarterm{new-expression},
the allocated type is deduced as follows:
Let
\placeholder{init} be the \grammarterm{new-initializer}, if any,
and
\tcode{T} be the \grammarterm{new-type-id} or \grammarterm{type-id} of
the \grammarterm{new-expression}, then the allocated type is the type
deduced for the variable \tcode{x} in the invented
declaration\iref{dcl.spec.auto}:

\begin{codeblock}
T x @\textrm{\placeholder{init}}@ ;
\end{codeblock}

\begin{example}
\begin{codeblock}
new auto(1);                    // allocated type is \tcode{int}
auto x = new auto('a');         // allocated type is \tcode{char}, \tcode{x} is of type \tcode{char*}

template<class T> struct A { A(T, T); };
auto y = new A{1, 2};           // allocated type is \tcode{A<int>}
\end{codeblock}
\end{example}

\pnum
The \grammarterm{new-type-id} in a \grammarterm{new-expression} is the longest
possible sequence of \grammarterm{new-declarator}{s}.
\begin{note}
This prevents ambiguities between the declarator operators \tcode{\&}, \tcode{\&\&},
\tcode{*}, and \tcode{[]} and their expression counterparts.
\end{note}
\begin{example}
\begin{codeblock}
new int * i;                    // syntax error: parsed as \tcode{(new int*) i}, not as \tcode{(new int)*i}
\end{codeblock}
The \tcode{*} is the pointer declarator and not the multiplication
operator.
\end{example}

\pnum
\begin{note}
\indextext{ambiguity!parentheses and}%
Parentheses in a \grammarterm{new-type-id} of a \grammarterm{new-expression}
can have surprising effects.
\begin{example}
\begin{codeblock}
new int(*[10])();               // error
\end{codeblock}
is ill-formed because the binding is
\begin{codeblock}
(new int) (*[10])();            // error
\end{codeblock}

Instead, the explicitly parenthesized version of the \tcode{new}
operator can be used to create objects of compound
types\iref{basic.compound}:

\begin{codeblock}
new (int (*[10])());
\end{codeblock}
allocates an array of \tcode{10} pointers to functions (taking no
argument and returning \tcode{int}).
\end{example}
\end{note}

\pnum
\indextext{storage duration!dynamic}%
Objects created by a \grammarterm{new-expression} have dynamic storage
duration\iref{basic.stc.dynamic}.
\begin{note}
\indextext{\idxcode{new}!scoping and}%
The lifetime of such an object is not necessarily restricted to the
scope in which it is created.
\end{note}
When the allocated object is not an array, the result of the \grammarterm{new-expression}
is a pointer to the object created.

\pnum
\indextext{array!\idxcode{new}}%
When the allocated object is an array (that is, the
\grammarterm{noptr-new-declarator} syntax is used or the
\grammarterm{new-type-id} or \grammarterm{type-id} denotes an array type), the
\grammarterm{new-expression} yields a pointer to the initial element (if
any) of the array.
\begin{note}
Both \tcode{new int} and \tcode{new int[10]} have type \tcode{int*} and
the type of \tcode{new int[i][10]} is \tcode{int (*)[10]}
\end{note}
The \grammarterm{attribute-specifier-seq} in a \grammarterm{noptr-new-declarator} appertains
to the associated array type.

\pnum
Every \grammarterm{constant-expression} in a
\grammarterm{noptr-new-declarator} shall be a converted constant
expression\iref{expr.const} of type \tcode{std::size_t} and
its value shall be greater than zero.
\begin{example}
Given the definition \tcode{int n = 42},
\tcode{new float[n][5]} is well-formed (because \tcode{n} is the
\grammarterm{expression} of a \grammarterm{noptr-new-declarator}), but
\tcode{new float[5][n]} is ill-formed (because \tcode{n} is not a
constant expression).
\end{example}

\pnum
If the \grammarterm{type-id} or \grammarterm{new-type-id}
denotes an array type of unknown bound\iref{dcl.array},
the \grammarterm{new-initializer} shall not be omitted;
the allocated object is an array with \tcode{n} elements,
where \tcode{n} is determined from the number of initial elements
supplied in
the \grammarterm{new-initializer}~(\ref{dcl.init.aggr}, \ref{dcl.init.string}).

\pnum
\indextext{\idxcode{new}}%
If the \grammarterm{expression} in a \grammarterm{noptr-new-declarator}
is present, it is implicitly converted to \tcode{std::size_t}.
\indextext{function!allocation}%
The \grammarterm{expression} is erroneous if:
\begin{itemize}
\item
the expression is of non-class type and its value before converting to
\tcode{std::size_t} is less than zero;

\item
the expression is of class type and its value before application of the second
standard conversion\iref{over.ics.user}\footnote{If the conversion function
returns a signed integer type, the second standard conversion converts to the
unsigned type \tcode{std::size_t} and thus thwarts any attempt to detect a
negative value afterwards.} is less than zero;

\item
its value is such that the size of the allocated object would exceed the
\impldef{maximum size of an allocated object} limit\iref{implimits}; or

\item
the \grammarterm{new-initializer} is a \grammarterm{braced-init-list} and the
number of array elements for which initializers are provided (including the
terminating \tcode{'\textbackslash 0'} in a string literal\iref{lex.string}) exceeds the
number of elements to initialize.
\end{itemize}

If the \grammarterm{expression} is erroneous after converting to \tcode{std::size_t}:
\begin{itemize}
\item
if the \grammarterm{expression} is a core constant expression,
the program is ill-formed;
\item
otherwise, an allocation function is not called; instead
\begin{itemize}
\item
if the allocation function that would have been called
has a non-throwing exception specification\iref{except.spec},
the value of the \grammarterm{new-expression}
is the null pointer value of the required result type;
\item
otherwise, the \grammarterm{new-expression} terminates by throwing an
exception of a type that would match a handler\iref{except.handle} of type
\tcode{std::bad_array_new_length}\iref{new.badlength}.
\end{itemize}
\end{itemize}
When the value of the \grammarterm{expression} is zero, the allocation
function is called to allocate an array with no elements.

\pnum
A \grammarterm{new-expression} may obtain storage for the object by calling an
allocation function\iref{basic.stc.dynamic.allocation}. If
the \grammarterm{new-expression} terminates by throwing an exception, it
may release storage by calling a deallocation
function\iref{basic.stc.dynamic.deallocation}. If the allocated type
is a non-array type, the allocation function's name is
\indextext{\idxcode{operator new}}%
\indextext{\idxcode{operator delete}}%
\tcode{operator new} and the deallocation function's name is
\tcode{operator delete}. If the allocated type is an array type, the
allocation function's name is
\indextext{\idxcode{operator new}}%
\indextext{\idxcode{operator delete}}%
\tcode{operator new[]}
and the deallocation function's name is
\tcode{operator delete[]}.
\begin{note}
An implementation is required to provide default definitions for the global
allocation
functions~(\ref{basic.stc.dynamic}, \ref{new.delete.single}, \ref{new.delete.array}).
A \Cpp{} program can provide alternative definitions of
these functions\iref{replacement.functions} and/or class-specific
versions\iref{class.free}.
The set of allocation and deallocation functions that may be called
by a \grammarterm{new-expression}
may include functions that do not perform allocation or deallocation;
for example, see \ref{new.delete.placement}.
\end{note}

\pnum
\indextext{operator!scope resolution}%
If the \grammarterm{new-expression} begins with a unary \tcode{::}
operator, the allocation function's name is looked up in the global
scope. Otherwise, if the allocated type is a class type \tcode{T} or
array thereof, the allocation function's name is looked up in the scope
of \tcode{T}. If this lookup fails to find the name, or if the allocated
type is not a class type, the allocation function's name is looked up in
the global scope.

\pnum
An implementation is allowed to omit a call to a replaceable global allocation
function~(\ref{new.delete.single}, \ref{new.delete.array}). When it does so,
the storage is instead provided by the implementation or provided by extending
the allocation of another \grammarterm{new-expression}.

\pnum
During an evaluation of a constant expression,
a call to an allocation function is always omitted.
\begin{note}
Only \grammarterm{new-expression}{s} that would otherwise result in
a call to a replaceable global allocation function
can be evaluated in constant expressions\iref{expr.const}.
\end{note}

\pnum
The implementation may
extend the allocation of a \grammarterm{new-expression} \tcode{e1} to provide
storage for a \grammarterm{new-expression} \tcode{e2} if the
following would be true were the allocation not extended:
\begin{itemize}
\item the evaluation of \tcode{e1} is sequenced before the evaluation of
\tcode{e2}, and

\item \tcode{e2} is evaluated whenever \tcode{e1} obtains storage, and

\item both \tcode{e1} and \tcode{e2} invoke the same replaceable global
allocation function, and

\item if the allocation function invoked by \tcode{e1} and \tcode{e2} is
throwing, any exceptions thrown in the evaluation of either \tcode{e1} or
\tcode{e2} would be first caught in the same handler, and

\item the pointer values produced by \tcode{e1} and \tcode{e2} are operands to
evaluated \grammarterm{delete-expression}{s}, and

\item the evaluation of \tcode{e2} is sequenced before the evaluation of the
\grammarterm{delete-expression} whose operand is the pointer value produced
by \tcode{e1}.
\end{itemize}

\begin{example}
\begin{codeblock}
void can_merge(int x) {
  // These allocations are safe for merging:
  std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
  std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
  std::unique_ptr<char[]> c{new (std::nothrow) char[x]};

  g(a.get(), b.get(), c.get());
}

void cannot_merge(int x) {
  std::unique_ptr<char[]> a{new char[8]};
  try {
    // Merging this allocation would change its catch handler.
    std::unique_ptr<char[]> b{new char[x]};
  } catch (const std::bad_alloc& e) {
    std::cerr << "Allocation failed: " << e.what() << std::endl;
    throw;
  }
}
\end{codeblock}
\end{example}

\pnum
When a \grammarterm{new-expression} calls an allocation function and that
allocation has not been extended, the
\grammarterm{new-expression} passes the amount of space requested to the
allocation function as the first argument of type
\tcode{std::size_t}. That argument shall be no less than the size
of the object being created; it may be greater than the size of the
object being created only if the object is an array and
the allocation function is not a non-allocating form\iref{new.delete.placement}.
For arrays of
\tcode{char}, \tcode{unsigned char}, and \tcode{std::byte},
the difference between the
result of the \grammarterm{new-expression} and the address returned by the
allocation function shall be an integral multiple of the
strictest fundamental
alignment requirement\iref{basic.align} of any object type whose size
is no greater than the size of the array being created.
\begin{note}
\indextext{allocation!alignment storage}%
Because allocation functions are assumed to return pointers to storage
that is appropriately aligned for objects of any type
with fundamental alignment, this constraint
on array allocation overhead permits the common idiom of allocating
character arrays into which objects of other types will later be placed.
\end{note}

\pnum
When a \grammarterm{new-expression} calls an allocation function and that
allocation has been extended, the size argument to the allocation call shall
be no greater than the sum of the sizes for the omitted calls as specified
above, plus the size for the extended call had it not been extended, plus any
padding necessary to align the allocated objects within the allocated memory.

\pnum
\indextext{placement new-expression@placement \gterm{new-expression}|see{\gterm{new-expression}, placement}}%
The \grammarterm{new-placement} syntax is used to supply additional
arguments to an allocation function; such an expression is called
a \defnx{placement \grammarterm{new-expression}}{\idxgram{new-expression}!placement}.

\pnum
Overload resolution is
performed on a function call created by assembling an argument list.
The first argument is
the amount of space requested,
and has type \tcode{std::size_t}.
If the type of the allocated object has new-extended alignment,
the next argument is
the type's alignment,
and has type \tcode{std::align_val_t}.
If the \grammarterm{new-placement} syntax is used,
the \grammarterm{initializer-clause}{s}
in its \grammarterm{expression-list}
are the succeeding arguments.
If no matching function is found then
\begin{itemize}

\item
if the allocated object type has new-extended alignment,
the alignment argument is removed from the argument list;

\item
otherwise, an argument that
is the type's alignment and has type \tcode{std::align_val_t}
is added into the argument list immediately after the first argument;

\end{itemize}
and then overload resolution is performed again.

\pnum
\begin{example}
\begin{itemize}
\item \tcode{new T} results in one of the following calls:
\begin{codeblock}
operator new(sizeof(T))
operator new(sizeof(T), std::align_val_t(alignof(T)))
\end{codeblock}
\item \tcode{new(2,f) T} results in one of the following calls:
\begin{codeblock}
operator new(sizeof(T), 2, f)
operator new(sizeof(T), std::align_val_t(alignof(T)), 2, f)
\end{codeblock}
\item \tcode{new T[5]} results in one of the following calls:
\begin{codeblock}
operator new[](sizeof(T) * 5 + x)
operator new[](sizeof(T) * 5 + x, std::align_val_t(alignof(T)))
\end{codeblock}
\item \tcode{new(2,f) T[5]} results in one of the following calls:
\begin{codeblock}
operator new[](sizeof(T) * 5 + x, 2, f)
operator new[](sizeof(T) * 5 + x, std::align_val_t(alignof(T)), 2, f)
\end{codeblock}
\end{itemize}
Here, each instance of \tcode{x} is a non-negative unspecified value
representing array allocation overhead; the result of the
\grammarterm{new-expression} will be offset by this amount from the value
returned by \tcode{operator new[]}. This overhead may be applied in all
array \grammarterm{new-expression}{s}, including those referencing
a placement allocation function, except when referencing
the library function \tcode{operator new[](std::size_t, void*)}.
The amount of overhead may vary from one
invocation of \tcode{new} to another.
\end{example}

\pnum
\begin{note}
Unless an allocation function has a non-throwing
exception specification\iref{except.spec},
it indicates failure to allocate storage by throwing a
\indextext{\idxcode{bad_alloc}}%
\indexlibraryglobal{bad_alloc}%
\tcode{std::bad_alloc} exception~(\ref{basic.stc.dynamic.allocation},
\ref{except}, \ref{bad.alloc});
it returns a non-null pointer otherwise. If the allocation function
has a non-throwing exception specification,
it returns null to indicate failure to allocate storage
and a non-null pointer otherwise.
\end{note}
If the allocation function is a non-allocating
form\iref{new.delete.placement} that returns null,
the behavior is undefined.
Otherwise,
if the allocation function returns null, initialization shall not be
done, the deallocation function shall not be called, and the value of
the \grammarterm{new-expression} shall be null.

\pnum
\begin{note}
When the allocation function returns a value other than null, it must be
a pointer to a block of storage in which space for the object has been
reserved. The block of storage is assumed to be appropriately aligned
and of the requested size. The address of the created object will not
necessarily be the same as that of the block if the object is an array.
\end{note}

\pnum
\indextext{\idxcode{new}!array of class objects and}%
\indextext{\idxcode{new}!initialization and}%
\indextext{\idxcode{new}!constructor and}%
\indextext{\idxcode{new}!default constructor and}%
A \grammarterm{new-expression} that creates an object of type \tcode{T}
initializes that object as follows:

\begin{itemize}
\item If the \grammarterm{new-initializer} is omitted, the object is
default-initialized\iref{dcl.init}.
\begin{note}
If no initialization
is performed, the object has an indeterminate value.
\end{note}

\item Otherwise, the \grammarterm{new-initializer} is interpreted according to
the initialization rules of~\ref{dcl.init} for direct-initialization.
\end{itemize}

\pnum
\indextext{\idxcode{new}!unspecified order of evaluation}%
\indextext{\idxcode{new}!unspecified constructor and}%
The invocation of the allocation function is sequenced before
the evaluations of expressions in the \grammarterm{new-initializer}. Initialization of
the allocated object is sequenced before the
\indextext{value computation}%
value computation of the
\grammarterm{new-expression}.

\pnum
If the \grammarterm{new-expression} creates an object or an array of
objects of class type, access and ambiguity control are done for the
allocation function, the deallocation function\iref{class.free}, and
the constructor\iref{class.ctor} selected for the initialization (if any).
If the \grammarterm{new-expression}
creates an array of objects of class type, the destructor is potentially
invoked\iref{class.dtor}.

\pnum
\indextext{\idxcode{new}!exception and}%
If any part of the object initialization described above\footnote{This may
include evaluating a \grammarterm{new-initializer} and/or calling
a constructor.}
terminates by throwing an exception and a suitable deallocation function
can be found, the deallocation function is called to free the memory in
which the object was being constructed, after which the exception
continues to propagate in the context of the \grammarterm{new-expression}.
If no unambiguous matching deallocation function can be found,
propagating the exception does not cause the object's memory to be
freed.
\begin{note}
This is appropriate when the called allocation function does not
allocate memory; otherwise, it is likely to result in a memory leak.
\end{note}

\pnum
If the \grammarterm{new-expression} begins with a unary \tcode{::}
operator, the deallocation function's name is looked up in the global
scope. Otherwise, if the allocated type is a class type \tcode{T} or an
array thereof, the deallocation function's name is looked up in the
scope of \tcode{T}. If this lookup fails to find the name, or if the
allocated type is not a class type or array thereof, the deallocation
function's name is looked up in the global scope.

\pnum
A declaration of a placement deallocation function matches the
declaration of a placement allocation function if it has the same number
of parameters and, after parameter transformations\iref{dcl.fct}, all
parameter types except the first are identical. If
the lookup finds a single matching deallocation function, that function
will be called; otherwise, no deallocation function will be called. If
the lookup finds a usual deallocation
function
and that function,
considered as a placement deallocation function, would have been
selected as a match for the allocation function, the program is
ill-formed. For a non-placement allocation function, the normal deallocation
function lookup is used to find the matching deallocation
function\iref{expr.delete}.
\begin{example}
\begin{codeblock}
struct S {
  // Placement allocation function:
  static void* operator new(std::size_t, std::size_t);

  // Usual (non-placement) deallocation function:
  static void operator delete(void*, std::size_t);
};

S* p = new (0) S;   // ill-formed: non-placement deallocation function matches
                    // placement allocation function
\end{codeblock}

\end{example}

\pnum
If a \grammarterm{new-expression} calls a deallocation function, it passes
the value returned from the allocation function call as the first
argument of type \tcode{void*}. If a placement deallocation function is
called, it is passed the same additional arguments as were passed to the
placement allocation function, that is, the same arguments as those
specified with the \grammarterm{new-placement} syntax.
If the implementation is allowed
to introduce a temporary object or make a copy of any argument
as part of the call to the allocation function,
it is unspecified whether the same object is used in the call
to both the allocation and deallocation functions.

\rSec3[expr.delete]{Delete}

\pnum
\indextext{expression!\idxcode{delete}}%
\indextext{\idxcode{delete}}%
The \grammarterm{delete-expression} operator destroys a most derived
object\iref{intro.object} or array created by a
\grammarterm{new-expression}.

\begin{bnf}
\nontermdef{delete-expression}\br
    \opt{\terminal{::}} \keyword{delete} cast-expression\br
    \opt{\terminal{::}} \keyword{delete} \terminal{[} \terminal{]} cast-expression
\end{bnf}

The first alternative is a
\defnx{single-object delete expression}{delete!single-object}, and the
second is an \defnx{array delete expression}{delete!array}.
Whenever the \tcode{delete} keyword is immediately followed by empty square
brackets, it shall be interpreted as the second alternative.\footnote{A
\grammarterm{lambda-expression} with a \grammarterm{lambda-introducer}
that consists of empty square brackets can follow the \tcode{delete} keyword
if the \grammarterm{lambda-expression} is enclosed in parentheses.}
The operand shall be of pointer to object type or of class type. If of
class type, the operand is contextually implicitly converted\iref{conv}
to a pointer to object
type.\footnote{This implies that an object
cannot be deleted using a pointer of type
\tcode{void*} because \tcode{void} is not an object type.}
The \grammarterm{delete-expression}'s result has type
\tcode{void}.

\pnum
\indextext{\idxcode{delete}!single-object}%
If the operand has a class type, the operand is converted to a pointer
type by calling the above-mentioned conversion function, and the
converted operand is used in place of the original operand for the
remainder of this subclause.
In a single-object delete expression, the value of the operand of
\tcode{delete} may be a null pointer value, a pointer to a non-array object
created by a previous \grammarterm{new-expression},
or a pointer to a
subobject\iref{intro.object} representing a base class of such an
object\iref{class.derived}. If not, the behavior is undefined.
\indextext{array!\idxcode{delete}}%
In an array delete expression, the value of the operand of \tcode{delete}
may be a null pointer value or a pointer value that resulted from
a previous array \grammarterm{new-expression}.\footnote{For nonzero-length
arrays, this is the same as a pointer to the first
element of the array created by that \grammarterm{new-expression}.
Zero-length arrays do not have a first element.}
If not, the behavior is undefined.
\begin{note}
This means that the syntax of the \grammarterm{delete-expression} must
match the type of the object allocated by \tcode{new}, not the syntax of the
\grammarterm{new-expression}.
\end{note}
\begin{note}
A pointer to a \tcode{const} type can be the operand of a
\grammarterm{delete-expression}; it is not necessary to cast away the
constness\iref{expr.const.cast} of the pointer expression before it is
used as the operand of the \grammarterm{delete-expression}.
\end{note}

\pnum
\indextext{\idxcode{delete}!undefined}%
In a single-object delete expression, if the static type of the object to be
deleted is different from its dynamic type
and the selected deallocation function (see below)
is not a destroying operator delete,
the static type shall be a base
class of the dynamic type of the object to be deleted and the static type shall
have a virtual destructor or the behavior is undefined. In an array delete
expression, if the dynamic type of the object to be deleted differs from its
static type, the behavior is undefined.

\pnum
The \grammarterm{cast-expression} in a \grammarterm{delete-expression} shall
be evaluated exactly once.

\pnum
\indextext{type!incomplete}%
If the object being deleted has incomplete class type at the point of
deletion and the complete class has a non-trivial destructor or a
deallocation function, the behavior is undefined.

\pnum
\indextext{\idxcode{delete}!destructor and}%
If the value of the operand of the \grammarterm{delete-expression} is not a
null pointer value
and the selected deallocation function (see below)
is not a destroying operator delete,
the \grammarterm{delete-expression} will invoke the
destructor (if any) for the object or the elements of the array being
deleted. In the case of an array, the elements will be destroyed in
order of decreasing address (that is, in reverse order of the completion
of their constructor; see~\ref{class.base.init}).

\pnum
If the value of the operand of the \grammarterm{delete-expression} is not a
null pointer value, then:

\begin{itemize}
\item
If the allocation call for the \grammarterm{new-expression} for the object to
be deleted was not omitted and the allocation was not extended\iref{expr.new}, the
\grammarterm{delete-expression} shall call a deallocation
function\iref{basic.stc.dynamic.deallocation}. The value returned from the
allocation call of the \grammarterm{new-expression} shall be passed as the
first argument to the deallocation function.

\item
Otherwise, if the allocation was extended or was provided by extending the
allocation of another \grammarterm{new-expression}, and the
\grammarterm{delete-expression} for every other pointer value produced by a
\grammarterm{new-expression} that had storage provided by the extended
\grammarterm{new-expression} has been evaluated, the
\grammarterm{delete-expression} shall call a deallocation function. The value
returned from the allocation call of the extended \grammarterm{new-expression}
shall be passed as the first argument to the deallocation function.

\item
Otherwise, the \grammarterm{delete-expression} will not call a
deallocation function.
\end{itemize}
\begin{note}
The deallocation function is called regardless of whether the destructor
for the object or some element of the array throws an exception.
\end{note}
If the value of the operand of the \grammarterm{delete-expression} is a
null pointer value, it is unspecified whether a deallocation function will be
called as described above.

\pnum
\begin{note}
An implementation provides default definitions of the global
deallocation functions \tcode{operator delete} for
non-arrays\iref{new.delete.single} and
\indextext{\idxcode{operator delete}}%
\tcode{operator delete[]} for arrays\iref{new.delete.array}. A \Cpp{}
program can provide alternative definitions of these
functions\iref{replacement.functions}, and/or class-specific
versions\iref{class.free}.
\end{note}

\pnum
When the keyword \tcode{delete} in a \grammarterm{delete-expression} is
preceded by the unary \tcode{::} operator, the deallocation function's name is looked
up in global scope. Otherwise, the lookup considers class-specific deallocation
functions\iref{class.free}. If no class-specific deallocation function is found,
the deallocation function's name is looked up in global scope.

\pnum
If deallocation function lookup finds more than one usual
deallocation function,
the function to be called is selected as follows:
\begin{itemize}
\item
If any of the deallocation functions is a destroying operator delete,
all deallocation functions that are not destroying operator deletes
are eliminated from further consideration.
\item
If the type has new-extended alignment,
a function with a parameter of type \tcode{std::align_val_t} is preferred;
otherwise a function without such a parameter is preferred.
If any preferred functions are found,
all non-preferred functions are eliminated from further consideration.
\item
If exactly one function remains,
that function is selected and the selection process terminates.
\item
If the deallocation functions have class scope,
the one without a parameter of type \tcode{std::size_t} is selected.
\item
If the type is complete
and if, for an array delete expression only,
the operand is a pointer to a class type with a
non-trivial destructor or a (possibly multi-dimensional) array thereof,
the function with a parameter of type \tcode{std::size_t} is selected.
\item
Otherwise, it is unspecified
whether a deallocation function with a parameter of type \tcode{std::size_t}
is selected.
\end{itemize}

\pnum
For a single-object delete expression,
the deleted object is
the object denoted by the operand
if its static type does not have a virtual destructor,
and its most-derived object otherwise.
\begin{note}
If the deallocation function is not a destroying operator delete
and the deleted object is not the most derived object in the former case,
the behavior is undefined,
as stated above.
\end{note}
For an array delete expression,
the deleted object is
the array object.
When a \grammarterm{delete-expression}
is executed, the selected deallocation function shall be called with
the address of the deleted object
in a single-object delete expression, or
the address of the deleted object
suitably adjusted for the array allocation
overhead\iref{expr.new} in an array delete expression,
as its first argument.
\begin{note}
Any cv-qualifiers in the type of the deleted object
are ignored when forming this argument.
\end{note}
If a destroying operator delete is used,
an unspecified value
is passed as the argument
corresponding to the parameter of type \tcode{std::destroying_delete_t}.
If a deallocation function
with a parameter of type \tcode{std::align_val_t}
is used,
the alignment of the type of the deleted object
is passed as the corresponding argument.
If a deallocation function
with a parameter of type \tcode{std::size_t} is used,
the size of the deleted object
in a single-object delete expression, or
of the array plus allocation overhead
in an array delete expression,
is passed as the corresponding argument.
\begin{note}
If this results in a call to a replaceable deallocation function,
and either
the first argument was not the result of
a prior call to a replaceable allocation function or
the second or third argument was not the corresponding argument in said call,
the behavior is undefined~(\ref{new.delete.single}, \ref{new.delete.array}).
\end{note}

\pnum
Access and ambiguity control are done for both the deallocation function
and the destructor~(\ref{class.dtor}, \ref{class.free}).

\rSec2[expr.cast]{Explicit type conversion (cast notation)}%
\indextext{expression!cast|(}

\pnum
The result of the expression \tcode{(T)} \grammarterm{cast-expression} is
of type \tcode{T}. The result is an lvalue if \tcode{T} is an lvalue
reference type or an rvalue reference to function type and an xvalue if \tcode{T}
is an rvalue reference to object type; otherwise the result is a prvalue.
\begin{note}
If \tcode{T} is a non-class type that is cv-qualified, the
\grammarterm{cv-qualifier}{s} are discarded when determining the type of the
resulting prvalue; see \ref{expr.prop}.
\end{note}

\pnum
An explicit type conversion can be expressed using functional
notation\iref{expr.type.conv}, a type conversion operator
(\tcode{dynamic_cast}, \tcode{static_cast}, \tcode{reinterpret_cast},
\tcode{const_cast}), or the \term{cast} notation.

\begin{bnf}
\nontermdef{cast-expression}\br
    unary-expression\br
    \terminal{(} type-id \terminal{)} cast-expression
\end{bnf}

\pnum
Any type conversion not mentioned below and not explicitly defined by
the user\iref{class.conv} is ill-formed.

\pnum
The conversions performed by
\begin{itemize}
\indextext{cast!const}%
\indextext{cast!static}%
\indextext{cast!reinterpret}%
\item a \tcode{const_cast}\iref{expr.const.cast},
\item a \tcode{static_cast}\iref{expr.static.cast},
\item a \tcode{static_cast} followed by a \tcode{const_cast},
\item a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}, or
\item a \tcode{reinterpret_cast} followed by a \tcode{const_cast},
\end{itemize}
can be performed using the cast notation of explicit type conversion.
The same semantic restrictions and behaviors apply, with the exception
that in performing a \tcode{static_cast} in the following situations the
conversion is valid even if the base class is inaccessible:
\begin{itemize}
\item a pointer to an object of derived class type or an lvalue or
rvalue of derived class type may be explicitly converted to a pointer or
reference to an unambiguous base class type, respectively;

\item a pointer to member of derived class type may be explicitly
converted to a pointer to member of an unambiguous non-virtual base
class type;

\item a pointer to an object of an unambiguous non-virtual base class
type, a glvalue of an unambiguous non-virtual base class type,
or a pointer to member of an unambiguous non-virtual base class type may
be explicitly converted to a pointer, a reference, or a pointer to
member of a derived class type, respectively.
\end{itemize}

If a conversion can be interpreted in more than one of the ways listed
above, the interpretation that appears first in the list is used, even
if a cast resulting from that interpretation is ill-formed. If a
conversion can be interpreted in more than one way as a
\tcode{static_cast} followed by a \tcode{const_cast}, the conversion is
ill-formed.
\begin{example}
\begin{codeblock}
struct A { };
struct I1 : A { };
struct I2 : A { };
struct D : I1, I2 { };
A* foo( D* p ) {
  return (A*)( p );             // ill-formed \tcode{static_cast} interpretation
}
\end{codeblock}
\end{example}

\pnum
\indextext{class!cast to incomplete}%
The operand of a cast using the cast notation can be a prvalue of type
``pointer to incomplete class type''. The destination type of a cast
using the cast notation can be ``pointer to incomplete class type''. If
both the operand and destination types are class types and one or both
are incomplete, it is unspecified whether the \tcode{static_cast} or the
\tcode{reinterpret_cast} interpretation is used, even if there is an
inheritance relationship between the two classes.
\begin{note}
For example, if the classes were defined later in the translation unit,
a multi-pass compiler would be permitted to interpret a cast between
pointers to the classes as if the class types were complete at the point
of the cast.
\end{note}
\indextext{expression!cast|)}

\rSec2[expr.mptr.oper]{Pointer-to-member operators}

\pnum
\indextext{expression!pointer-to-member}%
\indextext{pointer to member}%
\indextext{operator!pointer to member}%
\indextext{\idxcode{.*}|see{operator, pointer to member}}%
\indextext{operator!pointer to member}%
\indextext{\idxcode{->*}|see{operator, pointer to member}}%
The pointer-to-member operators \tcode{->*} and \tcode{.*} group
left-to-right.

\begin{bnf}
\nontermdef{pm-expression}\br
    cast-expression\br
    pm-expression \terminal{.*} cast-expression\br
    pm-expression \terminal{->*} cast-expression
\end{bnf}

\pnum
The binary operator \tcode{.*} binds its second operand, which shall be
of type ``pointer to member of \tcode{T}'' to its first operand, which shall be
a glvalue
of
class \tcode{T} or of a class of which \tcode{T} is an unambiguous and
accessible base class. The result is an object or a function of the type
specified by the second operand.

\pnum
The binary operator \tcode{->*} binds its second operand, which shall be
of type ``pointer to member of \tcode{T}'' to its first operand, which shall be of
type ``pointer to \tcode{U}''
where \tcode{U} is either \tcode{T} or
a class of which \tcode{T}
is an unambiguous and accessible base class.
The expression \tcode{E1->*E2} is converted into the equivalent form
\tcode{(*(E1)).*E2}.

\pnum
Abbreviating \grammarterm{pm-expression}\tcode{.*}\grammarterm{cast-expression} as \tcode{E1.*E2}, \tcode{E1}
is called the \defn{object expression}.
If the dynamic type of \tcode{E1} does not
contain the member to which
\tcode{E2} refers, the behavior is undefined.
Otherwise, the expression \tcode{E1} is sequenced before the expression \tcode{E2}.

\pnum
The restrictions on cv-qualification, and the manner in which
the cv-qualifiers of the operands are combined to produce the
cv-qualifiers of the result, are the same as the rules for
\tcode{E1.E2} given in~\ref{expr.ref}.
\begin{note}
It is not possible to use a pointer to member that refers to a
\tcode{mutable} member to modify a const class object. For
example,
\begin{codeblock}
struct S {
  S() : i(0) { }
  mutable int i;
};
void f()
{
const S cs;
int S::* pm = &S::i;            // \tcode{pm} refers to \tcode{mutable} member \tcode{S::i}
cs.*pm = 88;                    // ill-formed: \tcode{cs} is a const object
}
\end{codeblock}
\end{note}

\pnum
\indextext{function!pointer to member}%
If the result of \tcode{.*} or \tcode{->*} is a function, then that
result can be used only as the operand for the function call operator
\tcode{()}.
\begin{example}
\begin{codeblock}
(ptr_to_obj->*ptr_to_mfct)(10);
\end{codeblock}
calls the member function denoted by \tcode{ptr_to_mfct} for the object
pointed to by \tcode{ptr_to_obj}.
\end{example}
In a \tcode{.*} expression whose object expression is an rvalue, the program is
ill-formed if the second operand is a pointer to member function
whose \grammarterm{ref-qualifier} is \tcode{\&},
unless its \grammarterm{cv-qualifier-seq} is \tcode{const}.
In a \tcode{.*}
expression whose object expression is an lvalue, the program is ill-formed if the second
operand is
a pointer to member function
whose \grammarterm{ref-qualifier} is \tcode{\&\&}.
The result of a \tcode{.*} expression
whose second operand is a pointer to a data member is an lvalue if the first
operand is an lvalue and an xvalue otherwise. The result of a \tcode{.*} expression whose
second operand is a pointer to a member function is a prvalue.
If the second operand is the null
member pointer value\iref{conv.mem}, the behavior is undefined.

\rSec2[expr.mul]{Multiplicative operators}%
\indextext{expression!multiplicative operators}%
\indextext{operator!multiplicative}

\pnum
The multiplicative operators \tcode{*}, \tcode{/}, and \tcode{\%} group
left-to-right.

\indextext{operator!multiplication}%
\indextext{\idxcode{*}|see{operator, multiplication}}%
\indextext{operator!division}%
\indextext{\idxcode{/}|see{operator, division}}%
\indextext{operator!remainder}%
\indextext{\idxcode{\%}|see{operator, remainder}}%
\indextext{remainder operator|see{operator, remainder}}%
%
\begin{bnf}
\nontermdef{multiplicative-expression}\br
    pm-expression\br
    multiplicative-expression \terminal{*} pm-expression\br
    multiplicative-expression \terminal{/} pm-expression\br
    multiplicative-expression \terminal{\%} pm-expression
\end{bnf}

\pnum
The operands of \tcode{*} and \tcode{/} shall have arithmetic or unscoped
enumeration type; the operands of \tcode{\%} shall have integral or unscoped
enumeration type. The usual arithmetic conversions\iref{expr.arith.conv} are performed on the
operands and determine the type of the result.

\pnum
The binary \tcode{*} operator indicates multiplication.

\pnum
The binary \tcode{/} operator yields the quotient, and the binary
\tcode{\%} operator yields the remainder from the division of the first
expression by the second.
\indextext{zero!undefined division by}%
If the second operand of \tcode{/} or \tcode{\%} is zero the behavior is
undefined.
For integral operands the \tcode{/} operator yields the algebraic quotient with
any fractional part discarded;\footnote{This is often called truncation towards
zero.} if the quotient \tcode{a/b} is representable in the type of the result,
\tcode{(a/b)*b + a\%b} is equal to \tcode{a}; otherwise, the behavior
of both \tcode{a/b} and \tcode{a\%b} is undefined.

\rSec2[expr.add]{Additive operators}%
\indextext{expression!additive operators}%
\indextext{operator!additive}

\pnum
The additive operators \tcode{+} and \tcode{-} group left-to-right. The
usual arithmetic conversions\iref{expr.arith.conv} are performed for operands of arithmetic or
enumeration type.

\indextext{operator!addition}%
\indextext{addition operator|see{operator, addition}}%
\indextext{\idxcode{+}|see{operator, addition}}%
\indextext{operator!subtraction}%
\indextext{subtraction operator|see{operator, subtraction}}%
\indextext{\idxcode{-}|see{operator, subtraction}}%
%
\begin{bnf}
\nontermdef{additive-expression}\br
    multiplicative-expression\br
    additive-expression \terminal{+} multiplicative-expression\br
    additive-expression \terminal{-} multiplicative-expression
\end{bnf}

\indextext{incomplete}%
For addition, either both operands shall have arithmetic or unscoped enumeration
type, or one operand shall be a pointer to a completely-defined object
type and the other shall have integral or unscoped enumeration type.

\pnum
For subtraction, one of the following shall hold:
\begin{itemize}
\item both operands have arithmetic or unscoped enumeration type; or

\indextext{arithmetic!pointer}%
\item both operands are pointers to cv-qualified or cv-unqualified
versions of the same completely-defined object type; or

\item the left operand is a pointer to a completely-defined object type
and the right operand has integral or unscoped enumeration type.
\end{itemize}

\pnum
The result of the binary \tcode{+} operator is the sum of the operands.
The result of the binary \tcode{-} operator is the difference resulting
from the subtraction of the second operand from the first.

\pnum
\indextext{arithmetic!pointer}%
When an expression \tcode{J} that has integral type
is added to or subtracted from an expression \tcode{P} of pointer type,
the result has the type of \tcode{P}.
\begin{itemize}
\item If \tcode{P} evaluates to a null pointer value and
\tcode{J} evaluates to 0, the result is a null pointer value.
\item Otherwise, if \tcode{P} points to an array element $i$
of an array object \tcode{x} with $n$ elements\iref{dcl.array},%
\footnote{As specified in \ref{basic.compound},
an object that is not an array element
is considered to belong to a single-element array for this purpose and
a pointer past the last element of an array of $n$ elements
is considered to be equivalent to a pointer to a hypothetical array element
$n$ for this purpose.}
the expressions \tcode{P + J} and \tcode{J + P}
(where \tcode{J} has the value $j$)
point to the (possibly-hypothetical) array element
$i + j$ of \tcode{x} if $0 \le i + j \le n$
and the expression \tcode{P - J}
points to the (possibly-hypothetical) array element
$i - j$ of \tcode{x} if $0 \le i - j \le n$.
\item Otherwise, the behavior is undefined.
\end{itemize}

\pnum
\indextext{\idxcode{ptrdiff_t}!implementation-defined type of}%
\indextext{subtraction!implementation-defined pointer}%
\indextext{\idxcode{ptrdiff_t}}%
\indextext{comparison!undefined pointer}%
When two pointer expressions \tcode{P} and \tcode{Q} are subtracted,
the type of the result is an \impldef{type of \tcode{ptrdiff_t}} signed
integral type; this type shall be the same type that is defined as
\tcode{std::ptrdiff_t} in the \libheader{cstddef}
header\iref{support.types.layout}.
\begin{itemize}
\item If \tcode{P} and \tcode{Q} both evaluate to null pointer values,
the result is 0.
\item Otherwise, if \tcode{P} and \tcode{Q} point to, respectively,
array elements $i$ and $j$
of the same array object \tcode{x},
the expression \tcode{P - Q} has the value $i - j$.
\item Otherwise, the behavior is undefined.
\begin{note}
If the value $i - j$
is not in the range of representable values
of type \tcode{std::ptrdiff_t},
the behavior is undefined.
\end{note}
\end{itemize}

\pnum
For addition or subtraction, if the expressions \tcode{P} or \tcode{Q} have
type ``pointer to \cv{}~\tcode{T}'', where \tcode{T} and the array element type
are not similar\iref{conv.qual}, the behavior is undefined.
\begin{note}
In particular, a pointer to a base class cannot be used for
pointer arithmetic when the array contains objects of a derived class type.
\end{note}

\rSec2[expr.shift]{Shift operators}

\pnum
\indextext{expression!left-shift-operator}%
\indextext{expression!right-shift-operator}%
\indextext{shift operator!left|see{operator, left shift}}%
\indextext{shift operator!right|see{operator, right shift}}%
\indextext{right shift operator|see{operator, right shift}}%
\indextext{left shift operator|see{operator, left shift}}%
The shift operators \tcode{<<} and \tcode{>>} group left-to-right.

\indextext{operator!left shift}%
\indextext{\idxcode{<<}|see{operator, left shift}}%
\indextext{operator!right shift}%
\indextext{\idxcode{>>}|see{operator, right shift}}%
%
\begin{bnf}
\nontermdef{shift-expression}\br
    additive-expression\br
    shift-expression \terminal{<<} additive-expression\br
    shift-expression \terminal{>>} additive-expression
\end{bnf}

The operands shall be of integral or unscoped enumeration type and integral
promotions are performed. The type of the result is that of the promoted
left operand.
\indextext{left shift!undefined}%
The behavior is undefined if the right operand is negative, or greater
than or equal to the width of the promoted left operand.

\pnum
The value of \tcode{E1 << E2} is the unique value congruent to
$\tcode{E1} \times 2^\tcode{E2}$ modulo $2^N$,
where $N$ is the width of the type of the result.
\begin{note}
\tcode{E1} is left-shifted \tcode{E2} bit positions;
vacated bits are zero-filled.
\end{note}

\pnum
The value of \tcode{E1 >> E2} is $\tcode{E1} / 2^\tcode{E2}$, rounded down.
\begin{note}
\tcode{E1} is right-shifted \tcode{E2} bit positions.
Right-shift on signed integral types is an arithmetic right shift,
which performs sign-extension.
\end{note}

\pnum
The expression \tcode{E1} is sequenced before the expression \tcode{E2}.

\rSec2[expr.spaceship]{Three-way comparison operator}
\indextext{expression!three-way comparison}%
\indextext{expression!spaceship}%

\pnum
The three-way comparison operator groups left-to-right.

\indextext{\idxcode{<=>}|see{operator, three-way comparison}}%
\indextext{operator!three-way comparison}%
\indextext{operator!spaceship}%

\begin{bnf}
\nontermdef{compare-expression}\br
    shift-expression\br
    compare-expression \terminal{<=>} shift-expression
\end{bnf}

\pnum
The expression \tcode{p <=> q} is a prvalue indicating whether
\tcode{p} is less than, equal to, greater than, or incomparable with
\tcode{q}.

\pnum
If one of the operands is of type \tcode{bool}
and the other is not, the program is ill-formed.

\pnum
If both operands have arithmetic types,
or one operand has integral type and
the other operand has unscoped enumeration type,
the usual arithmetic conversions\iref{expr.arith.conv} are applied to the operands.
Then:

\begin{itemize}
\item
If a narrowing conversion\iref{dcl.init.list} is required,
other than from an integral type to a floating-point type,
the program is ill-formed.

\item
Otherwise, if the operands have integral type,
the result is of type \tcode{std::strong_ordering}.
The result is
\tcode{std::strong_ordering::equal}
if both operands are arithmetically equal,
\tcode{std::strong_ordering::less}
if the first operand is arithmetically
less than the second operand,
and
\tcode{std::strong_ordering::greater}
otherwise.
\item
Otherwise, the operands have floating-point type, and
the result is of type \tcode{std::partial_ordering}.
The expression \tcode{a <=> b} yields
\tcode{std::partial_ordering::less}
if \tcode{a} is less than \tcode{b},
\tcode{std::partial_ordering::greater}
if \tcode{a} is greater than \tcode{b},
\tcode{std::partial_ordering::equivalent}
if \tcode{a} is equivalent to \tcode{b},
and
\tcode{std::partial_ordering::unordered} otherwise.
\end{itemize}

\pnum
If both operands have the same enumeration type \tcode{E},
the operator yields the result of
converting the operands to the underlying type of \tcode{E}
and applying \tcode{<=>} to the converted operands.

\pnum
If at least one of the operands is of pointer type,
array-to-pointer conversions\iref{conv.array},
pointer conversions\iref{conv.ptr},
function pointer conversions\iref{conv.fctptr},
and
qualification conversions\iref{conv.qual}
are performed on both operands
to bring them to their composite pointer type\iref{expr.type}.
%
If at least one of the operands is of pointer-to-member type,
pointer-to-member conversions\iref{conv.mem}
and
qualification conversions\iref{conv.qual}
are performed on both operands
to bring them to their composite pointer type\iref{expr.type}.
%
If both operands are null pointer constants,
but not both of integer type,
pointer conversions\iref{conv.ptr}
are performed on both operands
to bring them to their composite pointer type\iref{expr.type}.
%
In all cases, after the conversions, the operands shall have the same type.
\begin{note}
If both of the operands are arrays,
array-to-pointer conversions\iref{conv.array} are not applied.
\end{note}

\pnum
If the composite pointer type is an object pointer type,
\tcode{p <=> q} is of type \tcode{std::strong_ordering}.
If two pointer operands \tcode{p} and \tcode{q} compare equal\iref{expr.eq},
\tcode{p <=> q} yields \tcode{std::strong_ordering::equal};
if \tcode{p} and \tcode{q} compare unequal,
\tcode{p <=> q} yields
\tcode{std::strong_ordering::less}
if \tcode{q} compares greater than \tcode{p}
and
\tcode{std::strong_ordering::greater}
if \tcode{p} compares greater than \tcode{q}\iref{expr.rel}.
Otherwise, the result is unspecified.

\pnum
Otherwise, the program is ill-formed.

\pnum
The three comparison category types\iref{cmp.categories}
(the types
\tcode{std::strong_ordering},
\tcode{std::weak_ordering}, and
\tcode{std::partial_ordering})
are not predefined;
if the header \libheaderref{compare}
is not imported or included prior to a use of such a class type --
even an implicit use in which the type is not named
(e.g., via the \tcode{auto} specifier\iref{dcl.spec.auto}
in a defaulted three-way comparison\iref{class.spaceship}
or use of the built-in operator) -- the program is ill-formed.

\rSec2[expr.rel]{Relational operators}%
\indextext{expression!relational operators}%
\indextext{operator!relational}

\pnum
The relational operators group left-to-right.
\begin{example}
\tcode{a<b<c} means \tcode{(a<b)<c} and \emph{not}
\tcode{(a<b)\&\&(b<c)}.
\end{example}
\indextext{operator!less than}%
\indextext{\idxcode{<}|see{operator, less than}}%
\indextext{operator!greater than}%
\indextext{\idxcode{>}|see{operator, greater than}}%
\indextext{operator!less than or equal to}%
\indextext{\idxcode{<=}|see{operator, less than or equal to}}%
\indextext{operator!greater than or equal to}%
\indextext{\idxcode{>=}|see{operator, greater than or equal to}}%
%
\begin{bnf}
\nontermdef{relational-expression}\br
    compare-expression\br
    relational-expression \terminal{<} compare-expression\br
    relational-expression \terminal{>} compare-expression\br
    relational-expression \terminal{<=} compare-expression\br
    relational-expression \terminal{>=} compare-expression
\end{bnf}
%
The
lvalue-to-rvalue\iref{conv.lval},
array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func}
standard conversions are performed on the operands.
The comparison is deprecated if
both operands were of array type
prior to these conversions\iref{depr.array.comp}.

\pnum
The converted operands shall have arithmetic, enumeration, or pointer type.
The
operators \tcode{<} (less than), \tcode{>} (greater than), \tcode{<=}
(less than or equal to), and \tcode{>=} (greater than or equal to) all
yield \tcode{false} or \tcode{true}. The type of the result is
\tcode{bool}.

\pnum
The usual arithmetic conversions\iref{expr.arith.conv} are performed on operands of arithmetic
or enumeration type. If both operands are pointers, pointer
conversions\iref{conv.ptr} and qualification conversions\iref{conv.qual}
are performed to bring
them to their composite pointer type\iref{expr.type}.
After conversions, the operands shall have the same type.

\pnum
The result of comparing unequal pointers to objects%
\footnote{As specified in \ref{basic.compound},
an object that is not an array element
is considered to belong to a
single-element array for this purpose and
a pointer past the last element of an array of $n$ elements
is considered to be equivalent to a pointer to a hypothetical array element
$n$ for this purpose.}
is defined in terms of a partial order consistent with the following rules:

\begin{itemize}
\item If two pointers point to different elements of the same array, or to
subobjects thereof, the pointer to the element with the higher subscript
is required to compare greater.

\item If two pointers point to different non-static data members of the same
object, or to subobjects of such members, recursively,
the pointer to the later declared member is required to compare greater provided
the two members have the same access control\iref{class.access},
neither member is a subobject of zero size,
and their class is not a union.

\item Otherwise, neither pointer is required to compare greater than the other.

\end{itemize}

\pnum
If two operands \tcode{p} and \tcode{q} compare equal\iref{expr.eq},
\tcode{p<=q} and \tcode{p>=q} both yield \tcode{true} and \tcode{p<q} and
\tcode{p>q} both yield \tcode{false}. Otherwise, if a pointer \tcode{p}
compares greater than a pointer \tcode{q}, \tcode{p>=q}, \tcode{p>q},
\tcode{q<=p}, and \tcode{q<p} all yield \tcode{true} and \tcode{p<=q},
\tcode{p<q}, \tcode{q>=p}, and \tcode{q>p} all yield \tcode{false}.
Otherwise, the result of each of the operators is unspecified.

\pnum
If both operands (after conversions) are of arithmetic or enumeration type, each
of the operators shall yield \tcode{true} if the specified relationship is true
and \tcode{false} if it is false.

\rSec2[expr.eq]{Equality operators}%
\indextext{expression!equality operators}%
\indextext{operator!equality}%
\indextext{operator!inequality}

\begin{bnf}
\nontermdef{equality-expression}\br
    relational-expression\br
    equality-expression \terminal{==} relational-expression\br
    equality-expression \terminal{!=} relational-expression
\end{bnf}

\pnum
The \tcode{==} (equal to) and the \tcode{!=} (not equal to) operators
group left-to-right.
The
lvalue-to-rvalue\iref{conv.lval},
array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func}
standard conversions are performed on the operands.
The comparison is deprecated if
both operands were of array type
prior to these conversions\iref{depr.array.comp}.

\pnum
The converted operands shall have arithmetic, enumeration, pointer,
or pointer-to-member type, or type \tcode{std::nullptr_t}. The operators
\tcode{==} and \tcode{!=} both yield \tcode{true} or \tcode{false}, i.e., a
result of type \tcode{bool}. In each case below, the operands shall have the
same type after the specified conversions have been applied.

\pnum
\indextext{comparison!pointer}%
\indextext{comparison!pointer to function}%
If at least one of the operands is a pointer,
pointer conversions\iref{conv.ptr},
function pointer conversions\iref{conv.fctptr}, and
qualification conversions\iref{conv.qual}
are performed on both operands to bring them to their composite pointer type\iref{expr.type}.
Comparing pointers is defined as follows:

\begin{itemize}
\item
If one pointer represents the address of a complete object, and another
pointer represents the address one past the last element of a different
complete object,%
\footnote{As specified in \ref{basic.compound},
an object that is not an array element is
considered to belong to a single-element array for this purpose.}
the result of the comparison is unspecified.
\item
Otherwise, if the pointers are both null, both point to the same
\indextext{address}%
function, or both represent the same address\iref{basic.compound},
they compare equal.
\item
Otherwise, the pointers compare unequal.
\end{itemize}

\pnum
If at least one of the operands is a pointer to member,
pointer-to-member conversions\iref{conv.mem},
function pointer conversions\iref{conv.fctptr}, and
qualification conversions\iref{conv.qual}
are performed on both operands to bring them to
their composite pointer type\iref{expr.type}.
Comparing pointers to members is defined as follows:

\begin{itemize}
\item
If two pointers to members are both the null member pointer value, they compare
equal.

\item
If only one of two pointers to members is the null member pointer value, they
compare unequal.

\item
If either is a pointer to a virtual member function, the result is unspecified.

\item
If one refers to a member of class \tcode{C1} and the other refers to a member
of a different class \tcode{C2}, where neither is a base class of the other,
the result is unspecified.
\begin{example}
\begin{codeblock}
struct A {};
struct B : A { int x; };
struct C : A { int x; };

int A::*bx = (int(A::*))&B::x;
int A::*cx = (int(A::*))&C::x;

bool b1 = (bx == cx);   // unspecified
\end{codeblock}
\end{example}

\item
If both refer to (possibly different) members of the same union\iref{class.union},
they compare equal.

\item
Otherwise, two pointers to members compare equal if they would refer to the same member of
the same most derived object\iref{intro.object} or the same subobject if
indirection with a hypothetical object of the associated
class type were performed, otherwise they compare unequal.
\begin{example}
\begin{codeblock}
struct B {
  int f();
};
struct L : B { };
struct R : B { };
struct D : L, R { };

int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr);          // \tcode{false}
bool y = (pb == pl);            // \tcode{true}
\end{codeblock}
\end{example}
\end{itemize}

\pnum
Two operands of type \tcode{std::nullptr_t} or one operand of type
\tcode{std::nullptr_t} and the other a null pointer constant compare equal.

\pnum
If two operands compare equal, the result is \tcode{true} for
the \tcode{==} operator and \tcode{false} for the \tcode{!=} operator. If two operands
compare unequal, the result is \tcode{false} for the \tcode{==} operator and
\tcode{true} for the \tcode{!=} operator. Otherwise, the result of each of the
operators is unspecified.

\pnum
If both operands are of arithmetic or enumeration type, the usual arithmetic
conversions\iref{expr.arith.conv} are performed on both operands; each of the operators shall yield
\tcode{true} if the specified relationship is true and \tcode{false} if it is
false.

\rSec2[expr.bit.and]{Bitwise AND operator}%
\indextext{expression!bitwise AND}%
\indextext{operator!bitwise}%
\indextext{operator!bitwise AND}%
\indextext{\idxcode{\&}|see{operator, bitwise AND}}%

\begin{bnf}
\nontermdef{and-expression}\br
    equality-expression\br
    and-expression \terminal{\&} equality-expression
\end{bnf}

\pnum
The \tcode{\&} operator groups left-to-right.
The operands shall be of integral or unscoped enumeration type.
The usual arithmetic conversions\iref{expr.arith.conv} are performed.
Given the coefficients $\tcode{x}_i$ and $\tcode{y}_i$
of the base-2 representation\iref{basic.fundamental}
of the converted operands \tcode{x} and \tcode{y},
the coefficient $\tcode{r}_i$
of the base-2 representation of the result \tcode{r}
is 1 if both $\tcode{x}_i$ and $\tcode{y}_i$ are 1, and 0 otherwise.
\begin{note}
The result is the bitwise \logop{AND} function of the operands.
\end{note}

\rSec2[expr.xor]{Bitwise exclusive OR operator}%
\indextext{expression!bitwise exclusive OR}%
\indextext{operator!bitwise exclusive OR}%
\indextext{\idxcode{\caret}|see{operator, bitwise exclusive OR}}

\begin{bnf}
\nontermdef{exclusive-or-expression}\br
    and-expression\br
    exclusive-or-expression \terminal{\caret} and-expression
\end{bnf}

\pnum
The \tcode{\^} operator groups left-to-right.
The operands shall be of integral or unscoped enumeration type.
The usual arithmetic conversions\iref{expr.arith.conv} are performed.
Given the coefficients $\tcode{x}_i$ and $\tcode{y}_i$
of the base-2 representation\iref{basic.fundamental}
of the converted operands \tcode{x} and \tcode{y},
the coefficient $\tcode{r}_i$
of the base-2 representation of the result \tcode{r}
is 1 if either (but not both) of $\tcode{x}_i$ and $\tcode{y}_i$ are 1,
and 0 otherwise.
\begin{note}
The result is the bitwise exclusive \logop{OR} function of the operands.
\end{note}

\rSec2[expr.or]{Bitwise inclusive OR operator}%
\indextext{expression!bitwise inclusive OR}%
\indextext{operator!bitwise inclusive OR}%
\indextext{\idxcode{"|}|see{operator, bitwise inclusive OR}}

\begin{bnf}
\nontermdef{inclusive-or-expression}\br
    exclusive-or-expression\br
    inclusive-or-expression \terminal{|} exclusive-or-expression
\end{bnf}

\pnum
The \tcode{|} operator groups left-to-right.
The operands shall be of integral or unscoped enumeration type.
The usual arithmetic conversions\iref{expr.arith.conv} are performed.
Given the coefficients $\tcode{x}_i$ and $\tcode{y}_i$
of the base-2 representation\iref{basic.fundamental}
of the converted operands \tcode{x} and \tcode{y},
the coefficient $\tcode{r}_i$
of the base-2 representation of the result \tcode{r}
is 1 if at least one of $\tcode{x}_i$ and $\tcode{y}_i$ are 1, and 0 otherwise.
\begin{note}
The result is the bitwise inclusive \logop{OR} function of the operands.
\end{note}

\rSec2[expr.log.and]{Logical AND operator}%
\indextext{expression!logical AND}%
\indextext{operator!logical AND}%
\indextext{\idxcode{\&\&}|see{operator, logical AND}}%

\begin{bnf}
\nontermdef{logical-and-expression}\br
    inclusive-or-expression\br
    logical-and-expression \terminal{\&\&} inclusive-or-expression
\end{bnf}

\pnum
The \tcode{\&\&} operator groups left-to-right. The operands are both
contextually converted to \tcode{bool}\iref{conv}.
The
result is \tcode{true} if both operands are \tcode{true} and
\tcode{false} otherwise. Unlike \tcode{\&}, \tcode{\&\&} guarantees
left-to-right evaluation: the second operand is not evaluated if the
first operand is \tcode{false}.

\pnum
The result is a \tcode{bool}.
\indextext{operator!side effects and logical AND}%
If the second expression is evaluated, every
\indextext{value computation}%
value computation and
\indextext{side effects}
side
effect associated with the first expression is sequenced before every
value computation and side effect associated with the second expression.

\rSec2[expr.log.or]{Logical OR operator}%
\indextext{expression!logical OR}%
\indextext{operator!logical OR}%
\indextext{\idxcode{"|"|}|see{operator, logical OR}}%

\begin{bnf}
\nontermdef{logical-or-expression}\br
    logical-and-expression\br
    logical-or-expression \terminal{||} logical-and-expression
\end{bnf}

\pnum
The \tcode{||} operator groups left-to-right. The operands are both
contextually converted to \tcode{bool}\iref{conv}.
The result is
\tcode{true} if either of its operands is \tcode{true}, and
\tcode{false} otherwise. Unlike \tcode{|}, \tcode{||} guarantees
left-to-right evaluation; moreover, the second operand is not evaluated
if the first operand evaluates to \tcode{true}.

\pnum
The result is a \tcode{bool}.
\indextext{operator!side effects and logical OR}%
If the second expression is evaluated, every
\indextext{value computation}%
value computation and
\indextext{side effects}%
side effect
associated with the first expression is sequenced before every value computation
and side effect associated with the second expression.

\rSec2[expr.cond]{Conditional operator}%
\indextext{expression!conditional operator}%
\indextext{operator!conditional expression}%
\indextext{\idxcode{?:}|see{operator, conditional expression}}%

\begin{bnf}
\nontermdef{conditional-expression}\br
    logical-or-expression\br
    logical-or-expression \terminal{?} expression \terminal{:} assignment-expression
\end{bnf}

\pnum
Conditional expressions group right-to-left. The first expression is
contextually converted to \tcode{bool}\iref{conv}.
It is
evaluated and if it is \tcode{true}, the result of the conditional
expression is the value of the second expression, otherwise that of the
third expression. Only one of the second and third expressions is
evaluated. Every
\indextext{value computation}%
value computation and side effect associated with the
first expression is sequenced before every value computation and side
effect associated with the second or third expression.

\pnum
If either the second or the third operand has type \tcode{void},
one of the following shall hold:
\begin{itemize}
\indextext{conditional-expression!throw-expression in}%
\item The second or the third operand (but not both) is a (possibly
parenthesized) \grammarterm{throw-expression}\iref{expr.throw}; the result
is of the type and value category of the other.
The \grammarterm{conditional-expression}
is a bit-field if that operand is a bit-field.

\item Both the second and the third operands have type \tcode{void}; the
result is of type \tcode{void} and is a prvalue.
\begin{note}
This
includes the case where both operands are \grammarterm{throw-expression}{s}.
\end{note}
\end{itemize}

\pnum
Otherwise, if the second and third operand are glvalue bit-fields
of the same value category and
of types \cvqual{cv1} \tcode{T} and \cvqual{cv2} \tcode{T}, respectively,
the operands are considered to be of type \cv{} \tcode{T}
for the remainder of this subclause,
where \cv{} is the union of \cvqual{cv1} and \cvqual{cv2}.

\pnum
Otherwise, if the second and third operand have different types and
either has (possibly cv-qualified) class type, or if both
are glvalues of the same value category and the same type except for
cv-qualification, an attempt is made to
form an implicit conversion sequence\iref{over.best.ics} from
each of those operands to the type of the other.
\begin{note}
Properties such as access, whether an operand is a bit-field, or whether
a conversion function is deleted are ignored for that determination.
\end{note}
Attempts are made to form an implicit conversion sequence
from an operand expression \tcode{E1} of type \tcode{T1}
to a target type related to the type \tcode{T2}
of the operand expression \tcode{E2} as follows:

\begin{itemize}
\item If \tcode{E2} is an lvalue, the target type is
``lvalue reference to \tcode{T2}'', subject to the
constraint that in the conversion the reference must bind
directly\iref{dcl.init.ref} to a glvalue.

\item If \tcode{E2} is an xvalue, the target type is
``rvalue reference to \tcode{T2}'',
subject to the constraint that the reference must bind directly.

\item If \tcode{E2} is a prvalue or if neither of the conversion sequences above can be
formed and at least one of the operands has (possibly cv-qualified) class type:
\begin{itemize}
\item if \tcode{T1} and \tcode{T2} are the same class type
(ignoring cv-qualification) and
\tcode{T2} is at least as cv-qualified as \tcode{T1},
the target type is \tcode{T2},

\item otherwise, if \tcode{T2} is a base class of \tcode{T1},
the target type is \cvqual{cv1} \tcode{T2}, where \cvqual{cv1}
denotes the cv-qualifiers of \tcode{T1},

\item otherwise, the target type is the type that \tcode{E2} would have
after applying the
lvalue-to-rvalue\iref{conv.lval},
array-to-pointer\iref{conv.array}, and
function-to-pointer\iref{conv.func}
standard conversions.
\end{itemize}
\end{itemize}

Using this process, it is determined whether an implicit conversion
sequence can be formed from the second operand
to the target type determined for the third operand, and vice versa.
If both sequences can be formed, or one can be formed but it is the
ambiguous conversion sequence, the program is ill-formed.
If no conversion sequence can be formed, the operands are left unchanged
and further checking is performed as described below.
Otherwise, if exactly one conversion sequence can be formed,
that conversion is applied to the chosen operand
and the converted operand is used in place of the original operand for
the remainder of this subclause.
\begin{note}
The conversion might be ill-formed even if an implicit conversion
sequence could be formed.
\end{note}

\pnum
If the second and third operands are glvalues of the same value category
and have the same type, the
result is of that type and value category and it is a bit-field if the
second or the third operand is a bit-field, or if both are bit-fields.

\pnum
Otherwise, the result is a prvalue. If the second and third operands do
not have the same type, and either has (possibly cv-qualified) class
type, overload resolution is used to determine the conversions (if any)
to be applied to the operands~(\ref{over.match.oper}, \ref{over.built}).
If the overload resolution fails, the program is ill-formed. Otherwise,
the conversions thus determined are applied, and the converted operands
are used in place of the original operands for the remainder of this
subclause.

\pnum
Lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
and function-to-pointer\iref{conv.func} standard conversions are
performed on the second and third operands. After those conversions, one
of the following shall hold:

\begin{itemize}
\item The second and third operands have the same type; the result is of
that type and the result object is initialized using the selected operand.

\item The second and third operands have arithmetic or enumeration type;
the usual arithmetic conversions\iref{expr.arith.conv} are performed to bring them to a common
type, and the result is of that type.

\item One or both of the second and third operands have pointer type;
pointer conversions\iref{conv.ptr},
function pointer conversions\iref{conv.fctptr}, and
qualification conversions\iref{conv.qual}
are performed to bring them to their
composite pointer type\iref{expr.type}. The result is of the composite
pointer type.

\item One or both of the second and third operands have pointer-to-member type;
pointer to member conversions\iref{conv.mem},
function pointer conversions\iref{conv.fctptr}, and
qualification conversions\iref{conv.qual}
are performed to bring them to their composite
pointer type\iref{expr.type}. The result is of the composite pointer type.

\item
Both the second and third operands have type \tcode{std::nullptr_t} or one has
that type and the other is a null pointer constant. The result is of type
\tcode{std::nullptr_t}.

\end{itemize}

\rSec2[expr.yield]{Yielding a value}%
\indextext{expression!yield}%
\indextext{\idxcode{co_yield}}%

\begin{bnf}
  \nontermdef{yield-expression}\br
  \terminal{co_yield} assignment-expression\br
  \terminal{co_yield} braced-init-list
\end{bnf}

\pnum
A \grammarterm{yield-expression} shall appear only within a suspension context
of a function\iref{expr.await}.
Let \placeholder{e} be the operand of the \grammarterm{yield-expression} and
\placeholder{p} be an lvalue naming the promise object of the enclosing
coroutine\iref{dcl.fct.def.coroutine}, then the \grammarterm{yield-expression}
is equivalent to the expression
\tcode{co_await }\placeholder{p}\tcode{.yield_value(}\placeholder{e}\tcode{)}.

\begin{example}
\begin{codeblock}
template <typename T>
struct my_generator {
  struct promise_type {
    T current_value;
    @\commentellip@
    auto yield_value(T v) {
      current_value = std::move(v);
      return std::suspend_always{};
    }
  };
  struct iterator { @\commentellip@ };
  iterator begin();
  iterator end();
};

my_generator<pair<int,int>> g1() {
  for (int i = i; i < 10; ++i) co_yield {i,i};
}
my_generator<pair<int,int>> g2() {
  for (int i = i; i < 10; ++i) co_yield make_pair(i,i);
}

auto f(int x = co_yield 5);     // error: \grammarterm{yield-expression} outside of function suspension context
int a[] = { co_yield 1 };       // error: \grammarterm{yield-expression} outside of function suspension context

int main() {
  auto r1 = g1();
  auto r2 = g2();
  assert(std::equal(r1.begin(), r1.end(), r2.begin(), r2.end()));
}
\end{codeblock}
\end{example}

\rSec2[expr.throw]{Throwing an exception}%
\indextext{expression!\idxcode{throw}}%
\indextext{exception handling!throwing}%
\indextext{\idxcode{throw}}%
%
\begin{bnf}
\nontermdef{throw-expression}\br
    \keyword{throw}  \opt{assignment-expression}
\end{bnf}

\pnum
A \grammarterm{throw-expression} is of type \tcode{void}.

\pnum
Evaluating a \grammarterm{throw-expression} with an operand throws an
exception\iref{except.throw}; the type of the exception object is determined by removing
any top-level \grammarterm{cv-qualifier}{s} from the static type of the
operand and adjusting the type
from ``array of \tcode{T}'' or function type \tcode{T}
to ``pointer to \tcode{T}''.

\pnum
\indextext{exception handling!rethrow}%
A
\grammarterm{throw-expression}
with no operand rethrows the currently handled exception\iref{except.handle}.
The exception is reactivated with the existing exception object;
no new exception object is created.
The exception is no longer considered to be caught.
\begin{example}
Code that must be executed because of an exception, but cannot
completely handle the exception itself, can be written like this:
\begin{codeblock}
try {
  // ...
} catch (...) {     // catch all exceptions
  // respond (partially) to exception
  throw;            // pass the exception to some other handler
}
\end{codeblock}
\end{example}

\pnum
\indextext{exception handling!rethrow}%
\indextext{exception handling!terminate called@\tcode{terminate} called}%
\indextext{\idxcode{terminate}!called}%
If no exception is presently being handled,
evaluating a
\grammarterm{throw-expression}
with no operand calls
\tcode{std::\brk{}terminate()}\iref{except.terminate}.

\rSec2[expr.ass]{Assignment and compound assignment operators}%
\indextext{expression!assignment and compound assignment}

\pnum
\indextext{operator!assignment}%
\indextext{\idxcode{=}|see{assignment operator}}%
\indextext{operator!\idxcode{+=}}%
\indextext{operator!\idxcode{-=}}%
\indextext{operator!\idxcode{*=}}%
\indextext{operator!\idxcode{/=}}%
\indextext{operator!\idxcode{\%=}}%
\indextext{operator!\idxcode{>>=}}%
\indextext{operator!\idxcode{<<=}}%
\indextext{operator!\idxcode{\&=}}%
\indextext{operator!\idxcode{\caret=}}%
\indextext{operator!\idxcode{"|=}}%
The assignment operator (\tcode{=}) and the compound assignment
operators all group right-to-left.
\indextext{assignment!and lvalue}%
All
require a modifiable lvalue as their left operand; their result is an lvalue
referring to the left operand. The result in all cases is a bit-field if
the left operand is a bit-field. In all cases, the assignment is
sequenced after the
\indextext{value computation}%
value computation of the right and left operands,
and before the
value computation of the assignment expression.
The right operand is sequenced before the left operand.
With
respect to an indeterminately-sequenced function call, the operation of
a compound assignment is a single evaluation.
\begin{note}
Therefore, a function call cannot intervene between the
lvalue-to-rvalue conversion and the side effect associated with any
single compound assignment operator.
\end{note}

\begin{bnf}
\nontermdef{assignment-expression}\br
    conditional-expression\br
    yield-expression\br
    throw-expression\br
    logical-or-expression assignment-operator initializer-clause
\end{bnf}

\begin{bnf}
\nontermdef{assignment-operator} \textnormal{one of}\br
    \terminal{=  *=  /=  \%=   +=  -=  >>=  <<=  \&=  \caret=  |=}
\end{bnf}

\pnum
In simple assignment (\tcode{=}), the object referred to by the left operand
is modified\iref{defns.access}
by replacing its value with the result of the right operand.

\pnum
\indextext{assignment!conversion by}%
If the right operand is an expression, it is implicitly
converted\iref{conv} to the cv-unqualified type of the left
operand.

\pnum
\indextext{reference!assignment to}%
When the left operand of an assignment operator
is a bit-field that cannot represent the value of the expression, the
resulting value of the bit-field is
\impldefplain{value of bit-field that cannot represent!assigned value}.

\pnum
A simple assignment whose left operand is of
a \tcode{volatile}-qualified type is deprecated\iref{depr.volatile.type}
unless the (possibly parenthesized) assignment is a discarded-value expression or
an unevaluated operand.

\pnum
The behavior of an expression of the form \tcode{E1 \placeholder{op}= E2}
is equivalent to \tcode{E1 = E1 \placeholder{op} E2} except
that \tcode{E1} is evaluated only once.
Such expressions are deprecated
if \tcode{E1} has \tcode{volatile}-qualified type; see~\ref{depr.volatile.type}.
For \tcode{+=} and \tcode{-=},
\tcode{E1} shall either have arithmetic type or be a pointer to a
possibly cv-qualified completely-defined object type. In all other
cases, \tcode{E1} shall have arithmetic type.

\pnum
If the value being stored in an object is read via another object that
overlaps in any way the storage of the first object, then the overlap shall be
exact and the two objects shall have the same type, otherwise the behavior is
undefined.
\begin{note}
This restriction applies to the relationship
between the left and right sides of the assignment operation; it is not a
statement about how the target of the assignment may be aliased in general.
See~\ref{basic.lval}.
\end{note}

\pnum
A \grammarterm{braced-init-list} may appear on the right-hand side of
\begin{itemize}
\item an assignment to a scalar, in which case the initializer list shall have
at most a single element. The meaning of \tcode{x = \{v\}}, where \tcode{T} is the
scalar type of the expression \tcode{x}, is that of \tcode{x = T\{v\}}. The meaning of
\tcode{x = \{\}} is \tcode{x = T\{\}}.

\item an assignment to an object of class type, in which case the initializer
list is passed as the argument to the assignment operator function selected by
overload resolution~(\ref{over.ass}, \ref{over.match}).
\end{itemize}
\begin{example}
\begin{codeblock}
complex<double> z;
z = { 1,2 };        // meaning \tcode{z.operator=(\{1,2\})}
z += { 1, 2 };      // meaning \tcode{z.operator+=(\{1,2\})}
int a, b;
a = b = { 1 };      // meaning \tcode{a=b=1;}
a = { 1 } = b;      // syntax error
\end{codeblock}
\end{example}

\rSec2[expr.comma]{Comma operator}%
\indextext{expression!comma}%
\indextext{operator!comma}%
\indextext{comma operator|see{operator, comma}}%
\indextext{\idxcode{,}|see{operator, comma}}%
\indextext{sequencing operator|see{operator, comma}}%

\pnum
The comma operator groups left-to-right.

\begin{bnf}
\nontermdef{expression}\br
    assignment-expression\br
    expression \terminal{,} assignment-expression
\end{bnf}

A pair of expressions separated by a comma is evaluated left-to-right;
the left expression is
a discarded-value expression\iref{expr.prop}.
Every
\indextext{value computation}%
value computation and side effect
associated with the left expression is sequenced before every value
computation and side effect associated with the right expression.
\indextext{operator!side effects and comma}%
The type and value of the
result are the type and value of the right operand; the result is of the same
value category as its right operand, and is a bit-field if its
right operand is a bit-field.
If the right operand is a temporary expression\iref{class.temporary},
the result is a temporary expression.

\pnum
In contexts where comma is given a special meaning,
\begin{example}
in
lists of arguments to functions\iref{expr.call} and lists of
initializers\iref{dcl.init}
\end{example}
the comma operator as
described in this subclause can appear only in parentheses.
\begin{example}
\begin{codeblock}
f(a, (t=3, t+2), c);
\end{codeblock}
has three arguments, the second of which has the value
\tcode{5}.
\end{example}

\pnum
\begin{note}
A comma expression
appearing as the \grammarterm{expr-or-braced-init-list}
of a subscripting expression\iref{expr.sub} is deprecated;
see \ref{depr.comma.subscript}.
\end{note}

\rSec1[expr.const]{Constant expressions}%
\indextext{expression!constant}

\pnum
Certain contexts require expressions that satisfy additional
requirements as detailed in this subclause; other contexts have different
semantics depending on whether or not an expression satisfies these requirements.
Expressions that satisfy these requirements,
assuming that copy elision\iref{class.copy.elision} is not performed,
are called
\indexdefn{expression!constant}%
\defnx{constant expressions}{constant expression}.
\begin{note}
Constant expressions can be evaluated
during translation.
\end{note}

\begin{bnf}
\nontermdef{constant-expression}\br
    conditional-expression
\end{bnf}

\pnum
A variable or temporary object \tcode{o} is \defn{constant-initialized} if
\begin{itemize}
\item
  either it has an initializer or
  its default-initialization results in some initialization being performed, and
\item
  the full-expression of its initialization is a constant expression
  when interpreted as a \grammarterm{constant-expression},
  except that if \tcode{o} is an object,
  that full-expression
  may also invoke constexpr constructors
  for \tcode{o} and its subobjects
  even if those objects are of non-literal class types.
  \begin{note}
  Such a class may have a non-trivial destructor.
  Within this evaluation,
  \tcode{std::is_constant_evaluated()}\iref{meta.const.eval}
  returns \tcode{true}.
\end{note}
\end{itemize}

\pnum
A variable is \defn{usable in constant expressions} after
its initializing declaration is encountered if it is a constexpr variable, or
it is a constant-initialized variable
of reference type or of const-qualified integral or enumeration type.
An object or reference is \defn{usable in constant expressions} if it is
\begin{itemize}
\item a variable that is usable in constant expressions, or
\item a template parameter object\iref{temp.param}, or
\item a string literal object\iref{lex.string}, or
\item a temporary object of non-volatile const-qualified literal type
  whose lifetime is extended\iref{class.temporary}
  to that of a variable that is usable in constant expressions, or
\item a non-mutable subobject or reference member of any of the above.
\end{itemize}

\pnum
An expression \tcode{e} is a \defnadj{core constant}{expression}
unless the evaluation of \tcode{e}, following the rules of the abstract
machine\iref{intro.execution}, would evaluate one of the following:
\begin{itemize}
\item
\tcode{this}\iref{expr.prim.this}, except in a constexpr
function\iref{dcl.constexpr} that is being evaluated as part
of \tcode{e};

\item
an invocation of a non-constexpr function
\begin{note}
Overload resolution\iref{over.match}
is applied as usual.
\end{note}%
;

\item
an invocation of an undefined constexpr function;

\item
an invocation of an instantiated constexpr function
that fails to satisfy the requirements
for a constexpr function;

\item
an invocation of a virtual function\iref{class.virtual}
for an object unless
  \begin{itemize}
  \item the object is usable in constant expressions or
  \item its lifetime began within the evaluation of \tcode{e};
  \end{itemize}

\item
an expression that would exceed the implementation-defined
limits (see \ref{implimits});

\item
an operation that would have undefined behavior
as specified in \ref{intro} through \ref{cpp}
of this document
\begin{note}
including,
for example, signed integer overflow\iref{expr.prop}, certain
pointer arithmetic\iref{expr.add}, division by
zero\iref{expr.mul}, or certain shift operations\iref{expr.shift}
\end{note}%
;

\item
an lvalue-to-rvalue conversion\iref{conv.lval} unless
it is applied to
\begin{itemize}
  \item
  a non-volatile glvalue that refers to an object that is
  usable in constant expressions, or

  \item
  a non-volatile glvalue of literal type that refers to a non-volatile object
  whose lifetime began within the evaluation of \tcode{e};
\end{itemize}

\item
an lvalue-to-rvalue conversion\iref{conv.lval}
that is applied to a glvalue
that refers to a non-active member of a union or a subobject thereof;

\item
an lvalue-to-rvalue conversion that is applied to
an object with an indeterminate value\iref{basic.indet};

\item
an invocation of an implicitly-defined copy/move constructor or
copy/move assignment operator
for a union whose active member (if any) is mutable,
unless the lifetime of the union object began within the evaluation of \tcode{e};

\item
an \grammarterm{id-expression} that refers to a variable or
data member of reference type
unless the reference has a preceding initialization and either
\begin{itemize}
  \item
  it is usable in constant expressions or

  \item
  its lifetime began within the evaluation of \tcode{e};
\end{itemize}

\item
in a \grammarterm{lambda-expression},
a reference to \tcode{this} or to a variable with
automatic storage duration defined outside that
\grammarterm{lambda-expression}, where
the reference would be an odr-use~(\ref{basic.def.odr}, \ref{expr.prim.lambda});
\begin{example}
\begin{codeblock}
void g() {
  const int n = 0;
  [=] {
    constexpr int i = n;        // OK, \tcode{n} is not odr-used here
    constexpr int j = *&n;      // ill-formed, \tcode{\&n} would be an odr-use of \tcode{n}
  };
}
\end{codeblock}
\end{example}
\begin{note}
If the odr-use occurs in an invocation
of a function call operator of a closure type,
it no longer refers to \tcode{this} or to an enclosing automatic variable
due to the transformation\iref{expr.prim.lambda.capture}
of the \grammarterm{id-expression} into
an access of the corresponding data member.
\begin{example}
\begin{codeblock}
auto monad = [](auto v) { return [=] { return v; }; };
auto bind = [](auto m) {
  return [=](auto fvm) { return fvm(m()); };
};

// OK to have captures to automatic objects created during constant expression evaluation.
static_assert(bind(monad(2))(monad)() == monad(2)());
\end{codeblock}
\end{example}
\end{note}

\item
a conversion from type \cv{}~\tcode{void*} to a pointer-to-object type;

\item
a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast};

\item
modification of an object~(\ref{expr.ass}, \ref{expr.post.incr},
\ref{expr.pre.incr})
unless it is applied to a non-volatile lvalue of literal type
that refers to a non-volatile object
whose lifetime began within the evaluation of \tcode{e};

\item
a \grammarterm{new-expression}\iref{expr.new},
unless the selected allocation function is
a replaceable global allocation function~(\ref{new.delete.single},
\ref{new.delete.array}) and
the allocated storage is deallocated within the evaluation of \tcode{e};

\item
a \grammarterm{delete-expression}\iref{expr.delete},
unless it deallocates a region of storage
allocated within the evaluation of \tcode{e};

\item
a call to an instance of
\tcode{std::allocator<T>::allocate}\iref{allocator.members},
unless the allocated storage is deallocated within the evaluation of \tcode{e};

\item
a call to an instance of
\tcode{std::allocator<T>::deallocate}\iref{allocator.members},
unless it deallocates a region of storage
allocated within the evaluation of \tcode{e};

\item
an \grammarterm{await-expression}\iref{expr.await};

\item
a \grammarterm{yield-expression}\iref{expr.yield};

\item
a three-way comparison\iref{expr.spaceship},
relational\iref{expr.rel}, or equality\iref{expr.eq}
operator where the result is unspecified;

\item
a \grammarterm{throw-expression}\iref{expr.throw} or
a dynamic cast\iref{expr.dynamic.cast} or \tcode{typeid}\iref{expr.typeid} expression
that would throw an exception;

\item
an \grammarterm{asm-declaration}\iref{dcl.asm}; or

\item
an invocation of the \tcode{va_arg} macro\iref{cstdarg.syn}.
\end{itemize}

If \tcode{e} satisfies the constraints of a core constant expression, but
evaluation of \tcode{e} would evaluate an operation that has undefined behavior
as specified in \ref{library} through \ref{\lastlibchapter} of this document, or
an invocation of the \tcode{va_start} macro\iref{cstdarg.syn},
it is unspecified whether \tcode{e} is a core constant expression.

\begin{example}
\begin{codeblock}
int x;                              // not constant
struct A {
  constexpr A(bool b) : m(b?42:x) { }
  int m;
};
constexpr int v = A(true).m;        // OK: constructor call initializes \tcode{m} with the value \tcode{42}

constexpr int w = A(false).m;       // error: initializer for \tcode{m} is \tcode{x}, which is non-constant

constexpr int f1(int k) {
  constexpr int x = k;              // error: \tcode{x} is not initialized by a constant expression
                                    // because lifetime of \tcode{k} began outside the initializer of \tcode{x}
  return x;
}
constexpr int f2(int k) {
  int x = k;                        // OK: not required to be a constant expression
                                    // because \tcode{x} is not \tcode{constexpr}
  return x;
}

constexpr int incr(int &n) {
  return ++n;
}
constexpr int g(int k) {
  constexpr int x = incr(k);        // error: \tcode{incr(k)} is not a core constant expression
                                    // because lifetime of \tcode{k} began outside the expression \tcode{incr(k)}
  return x;
}
constexpr int h(int k) {
  int x = incr(k);                  // OK: \tcode{incr(k)} is not required to be a core constant expression
  return x;
}
constexpr int y = h(1);             // OK: initializes \tcode{y} with the value \tcode{2}
                                    // \tcode{h(1)} is a core constant expression because
                                    // the lifetime of \tcode{k} begins inside \tcode{h(1)}
\end{codeblock}
\end{example}

\pnum
For the purposes of determining
whether an expression \tcode{e} is a core constant expression,
the evaluation of a call to a member function of \tcode{std::allocator<T>}
as defined in \ref{allocator.members}, where \tcode{T} is a literal type,
does not disqualify \tcode{e} from being a core constant expression,
even if the actual evaluation of such a call
would otherwise fail the requirements for a core constant expression.
Similarly, the evaluation of a call to
\tcode{std::destroy_at},
\tcode{std::ranges::destroy_at},
\tcode{std::construct_at}, or
\tcode{std::ranges::construct_at}
does not disqualify \tcode{e}
from being a core constant expression unless:
\begin{itemize}
\item
  for a call to \tcode{std::construct_at} or \tcode{std::ranges::construct_at},
  the first argument, of type \tcode{T*},
  does not point
  to storage allocated with \tcode{std::allocator<T>} or
  to an object whose lifetime began within the evaluation of \tcode{e}, or
  the evaluation of the underlying constructor call
  disqualifies \tcode{e} from being a core constant expression, or
\item
  for a call to \tcode{std::destroy_at} or \tcode{std::ranges::destroy_at},
  the first argument, of type \tcode{T*},
  does not point
  to storage allocated with \tcode{std::allocator<T>} or
  to an object whose lifetime began within the evaluation of \tcode{e}, or
  the evaluation of the underlying destructor call
  disqualifies \tcode{e} from being a core constant expression.
\end{itemize}

\pnum
An object \tcode{a} is said to have \defnadj{constant}{destruction} if:
\begin{itemize}
\item
  it is not of class type nor (possibly multi-dimensional) array thereof, or
\item
  it is of class type or (possibly multi-dimensional) array thereof,
  that class type has a constexpr destructor, and
  for a hypothetical expression \tcode{e}
  whose only effect is to destroy \tcode{a},
  \tcode{e} would be a core constant expression
  if the lifetime of \tcode{a} and its non-mutable subobjects
  (but not its mutable subobjects) were considered to start within \tcode{e}.
\end{itemize}

\pnum
An \defnadj{integral constant}{expression}
is an expression of integral or
unscoped enumeration type, implicitly converted to a prvalue, where the converted expression is a core constant expression.
\begin{note}
Such expressions may be
used as bit-field lengths\iref{class.bit}, as enumerator
initializers if the underlying type is not fixed\iref{dcl.enum},
and as alignments\iref{dcl.align}.
\end{note}

\pnum
If an expression of literal class type is used in a context where an
integral constant expression is required, then that expression is
contextually implicitly converted\iref{conv} to an integral or unscoped
enumeration type
and the selected conversion function shall be \tcode{constexpr}.
\begin{example}
\begin{codeblock}
struct A {
  constexpr A(int i) : val(i) { }
  constexpr operator int() const { return val; }
  constexpr operator long() const { return 42; }
private:
  int val;
};
constexpr A a = alignof(int);
alignas(a) int n;               // error: ambiguous conversion
struct B { int n : a; };        // error: ambiguous conversion
\end{codeblock}
\end{example}

\pnum
A \defnadj{converted constant}{expression}
of type \tcode{T} is an
expression, implicitly converted to type \tcode{T}, where
the converted expression is a constant expression and the
implicit conversion sequence contains only
\begin{itemize}
\item user-defined conversions,
\item lvalue-to-rvalue conversions\iref{conv.lval},
\item array-to-pointer conversions\iref{conv.array},
\item function-to-pointer conversions\iref{conv.func},
\item qualification conversions\iref{conv.qual},
\item integral promotions\iref{conv.prom},
\item integral conversions\iref{conv.integral} other than narrowing conversions\iref{dcl.init.list},
\item null pointer conversions\iref{conv.ptr} from \tcode{std::nullptr_t},
\item null member pointer conversions\iref{conv.mem} from \tcode{std::nullptr_t}, and
\item function pointer conversions\iref{conv.fctptr},
\end{itemize}
and where the reference binding (if any) binds directly.
\begin{note}
Such expressions may be used in \tcode{new}
expressions\iref{expr.new}, as case expressions\iref{stmt.switch},
as enumerator initializers if the underlying type is
fixed\iref{dcl.enum}, as array bounds\iref{dcl.array}, and
as non-type template
arguments\iref{temp.arg}.
\end{note}
\indextext{contextually converted constant expression of type \tcode{bool}|see{conversion, contextual}}%
\indextext{conversion!contextual to constant expression of type \tcode{bool}}%
A \term{contextually converted constant expression of type \tcode{bool}} is
an expression, contextually converted to \tcode{bool}\iref{conv},
where the converted expression is a constant expression and
the conversion sequence contains only the conversions above.

\pnum
A \defnadj{constant}{expression} is either
a glvalue core constant expression that refers to
an entity that is a permitted result of a constant expression (as defined below), or
a prvalue core constant expression whose value
satisfies the following constraints:
\begin{itemize}
  \item
  if the value is an object of class type,
  each non-static data member of reference type refers to
  an entity that is a permitted result of a constant expression,
  \item
  if the value is of pointer type, it contains
  the address of an object with static storage duration,
  the address past the end of such an object\iref{expr.add},
  the address of a non-immediate function,
  or a null pointer value,

  \item
  if the value is of pointer-to-member-function type,
  it does not designate an immediate function, and

  \item
  if the value is an object of class or array type,
  each subobject satisfies these constraints for the value.
\end{itemize}
An entity is a
\defnx{permitted result of a constant expression}{constant expression!permitted result of}
if it is an
object with static storage duration that either is not a temporary object or is
a temporary object whose value satisfies the above constraints, or if
it is a non-immediate function.
\begin{example}
\begin{codeblock}
consteval int f() { return 42; }
consteval auto g() { return f; }
consteval int h(int (*p)() = g()) { return p(); }
constexpr int r = h();                          // OK
constexpr auto e = g();                         // ill-formed: a pointer to an immediate function is
                                                // not a permitted result of a constant expression
\end{codeblock}
\end{example}

\pnum
\begin{note}
Since this document
imposes no restrictions on the accuracy of floating-point operations, it is unspecified whether the
evaluation of a floating-point expression during translation yields the same result as the
evaluation of the same expression (or the same operations on the same values) during program
execution.\footnote{Nonetheless, implementations should provide consistent results,
irrespective of whether the evaluation was performed during translation and/or during program
execution.}
\begin{example}
\begin{codeblock}
bool f() {
    char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
    int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
    return sizeof(array) == size;
}
\end{codeblock}
It is unspecified whether the value of \tcode{f()} will be \tcode{true} or \tcode{false}.
\end{example}
\end{note}

\pnum
An expression or conversion is in an \defn{immediate function context}
if it is potentially evaluated and
its innermost non-block scope is
a function parameter scope of an immediate function.
An expression or conversion is an \defn{immediate invocation}
if it is an explicit or implicit invocation of an immediate function and
is not in an immediate function context.
An immediate invocation shall be a constant expression.

\pnum
An expression or conversion \tcode{e} is \defn{manifestly constant-evaluated}
if it is:
\begin{itemize}
\item a \grammarterm{constant-expression}, or
\item the condition of a constexpr if statement\iref{stmt.if}, or
\item an immediate invocation, or
\item the result of substitution into an atomic constraint expression
to determine whether it is satisfied\iref{temp.constr.atomic}, or
\item the initializer of a variable
that is usable in constant expressions or
has constant initialization.\footnote{Testing this condition
may involve a trial evaluation of its initializer as described above.}
\begin{example}
\begin{codeblock}
template<bool> struct X {};
X<std::is_constant_evaluated()> x;                      // type \tcode{X<true>}
int y;
const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
double z[a];                                            // ill-formed: \tcode{a} is not usable
                                                        // in constant expressions
const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2
int c = y + (std::is_constant_evaluated() ? 2 : y);     // dynamic initialization to \tcode{y+y}

constexpr int f() {
  const int n = std::is_constant_evaluated() ? 13 : 17; // \tcode{n} is 13
  int m = std::is_constant_evaluated() ? 13 : 17;       // \tcode{m} might be 13 or 17 (see below)
  char arr[n] = {}; // char[13]
  return m + sizeof(arr);
}
int p = f();                                            // \tcode{m} is 13; initialized to 26
int q = p + f();                                        // \tcode{m} is 17 for this call; initialized to 56
\end{codeblock}
\end{example}
\end{itemize}
\begin{note}
A manifestly constant-evaluated expression
is evaluated even in an unevaluated operand.
\end{note}

\pnum
\indextext{expression!potentially constant evaluated}%
An expression or conversion is \defn{potentially constant evaluated}
if it is:
\begin{itemize}
\item
a manifestly constant-evaluated expression,

\item
a potentially-evaluated expression\iref{basic.def.odr},

\item
an immediate subexpression of a \grammarterm{braced-init-list},%
\footnote{Constant evaluation may be necessary to determine whether a narrowing conversion is performed\iref{dcl.init.list}.}

\item
an expression of the form \tcode{\&} \grammarterm{cast-expression}
that occurs within a templated entity,%
\footnote{Constant evaluation may be necessary to determine whether such an expression is value-dependent\iref{temp.dep.constexpr}.}
or

\item
a subexpression of one of the above
that is not a subexpression of a nested unevaluated operand.
\end{itemize}

\indextext{function!needed for constant evaluation}%
\indextext{variable!needed for constant evaluation}%
A function or variable is
\defn{needed for constant evaluation}
if it is:
\begin{itemize}
\item
a constexpr function that is named by an expression\iref{basic.def.odr}
that is potentially constant evaluated, or

\item
a variable whose name appears as a potentially constant evaluated expression
that is either a constexpr variable or
is of non-volatile const-qualified integral type or of reference type.
\end{itemize}

\begin{example}
\begin{codeblock}
struct N {
  constexpr N() {}
  N(N const&) = delete;
};
template<typename T> constexpr void bad_assert_copyable() { T t; T t2 = t; }
using ineffective = decltype(bad_assert_copyable<N>());
                        // \tcode{bad_assert_copyable<N>} is not needed for constant evaluation
                        // (and thus not instantiated)
template<typename T> consteval void assert_copyable() { T t; T t2 = t; }
using check = decltype(assert_copyable<N>());
                        // error: \tcode{assert_copyable<N>} is instantiated (because it is needed for constant
                        // evaluation), but the attempt to copy \tcode{t} is ill-formed
\end{codeblock}
\end{example}

\indextext{expression|)}