The expression \tcode{::new (declval<void*>()) T(declval<Args>()...)}

\end{itemize}

A variable is named by an expression

if the expression is an \grammarterm{id-expression} that denotes it.

A variable \tcode{x} whose name appears as a

any reference to a non-volatile const object or reference

with internal or no linkage initialized with a constant expression

\end{itemize}

or defines a constexpr variable initialized to a TU-local value (defined below).

\begin{note}

\indextext{non-initialization odr-use|see{odr-use, non-initialization}}%

A \defnx{non-initialization odr-use}{odr-use!non-initialization}

the initialization of a non-block static or thread storage duration variable.

A non-block variable with static storage duration

having initialization

with side effects is initialized in this case,

\end{footnote}

It is \impldef{threads and program points at which deferred dynamic initialization is performed}

in which threads and at which points in the program such deferred dynamic initialization occurs.

The implementation will implicitly declare these member functions for some class

types when the program does not explicitly declare them.

The implementation will implicitly define them

needed for constant evaluation\iref{expr.const}.

\end{note}

An implicitly-declared special member function is declared at the closing

that is defaulted and not defined as deleted

is

\defnx{implicitly defined}{constructor!implicitly defined}

to initialize an object of its class type\iref{intro.object},

when it is needed for constant evaluation\iref{expr.const}, or

when it is explicitly defaulted after its first declaration.

that is defaulted and not defined as deleted

is

\term{implicitly defined}

when it is needed for constant evaluation\iref{expr.const}, or

when it is explicitly defaulted after its first declaration.

\begin{note}

The copy/move constructor is implicitly defined even if the implementation elided

\end{note}

If the implicitly-defined constructor would satisfy the requirements of a

constexpr constructor\iref{dcl.constexpr}, the implicitly-defined

that is defaulted and not defined as deleted

is

\term{implicitly defined}

(e.g., when it is selected by overload resolution

to assign to an object of its class type),

when it is needed for constant evaluation\iref{expr.const}, or

The program is ill-formed if overload resolution fails.

Destructor selection does not constitute

a reference to,

the selected destructor,

and in particular,

the selected destructor may be deleted\iref{dcl.fct.def.delete}.

that is defaulted and not defined as deleted

is

\defnx{implicitly defined}{destructor!implicitly defined}

or when it is explicitly defaulted after its first declaration.

\grammarterm{initializer-clause} that is an \grammarterm{assignment-expression}

is a constant expression\iref{expr.const}.

The member shall still be defined in a namespace scope if

namespace scope definition shall not contain an \grammarterm{initializer}.

The declaration of an inline static data member (which is a definition)

may specify a \grammarterm{brace-or-equal-initializer}. If the

\begin{note}

There is exactly one definition of a static data member

\end{note}

called a \defnadj{local}{class}.

\begin{note}

A declaration in a local class

a local entity

from an

enclosing scope.

\item otherwise, \tcode{decltype($E$)} is the type of $E$.

\end{itemize}

\begin{example}

\begin{codeblock}

\begin{note}

in a default argument.

\end{note}

\begin{example}

int f(int a, int b = a); // error: parameter \tcode{a} used as default argument

typedef int I;

int g(float I, int b = I(2)); // error: parameter \tcode{I} found

\end{codeblock}

\end{example}

A non-static member shall not appear in a default argument unless it appears as

Implementations are

permitted to provide additional predefined variables with names that are reserved to the

implementation\iref{lex.name}. If a predefined variable is not

\end{footnote}

\begin{example}

\begin{codeblock}

function. It applies even for references in expressions that are not

potentially-evaluated. For an overload set, only the

function selected by overload resolution is referenced. The implicit

constitute a reference.

\end{note}

\item in an expression, the function is selected by

overload resolution~(\ref{over.match}, \ref{over.over});

unevaluated operand, would be odr-used if the expression were

potentially-evaluated;

In the declaration of \tcode{p2},

those constraints are required to be satisfied

even though

\end{example}

\end{note}

An entity is \defn{captured} if it is captured explicitly or implicitly. An entity

the \grammarterm{lambda-expression}.

\begin{note}

As a consequence, if a \grammarterm{lambda-expression}

Every \grammarterm{id-expression} within the \grammarterm{compound-statement} of a

entity captured by copy is transformed into an access to the corresponding unnamed data

member of the closure type.

\begin{note}

A \grammarterm{requires-expression} is a prvalue of type \tcode{bool}

whose value is described below.

Expressions appearing within a \grammarterm{requirement-body}

\begin{example}

\begin{note}

The enclosing \grammarterm{requires-expression} will evaluate to \keyword{false}

if substitution of template arguments into the \grammarterm{expression} fails.

\end{note}

\begin{example}

\begin{codeblock}

\end{example}

within the \grammarterm{constraint-expression}.

\begin{example}

\begin{codeblock}

If the expression is a prvalue,

the temporary materialization conversion\iref{conv.rval}

is applied.

When \keyword{typeid} is applied to a \grammarterm{type-id}, the result

The \keyword{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,

\grammarterm{type-id}.

\indextext{type!incomplete}%

The \keyword{sizeof} operator shall not be applied to an expression that

\indextext{\idxcode{noexcept}}%

\indextext{expression!\idxcode{noexcept}}%

The \keyword{noexcept} operator determines whether the evaluation of its operand,

exception\iref{except.throw}.

\begin{bnf}

A simple assignment whose left operand is of

a volatile-qualified type is deprecated\iref{depr.volatile.type}

unless the (possibly parenthesized) assignment is a discarded-value expression or

The behavior of an expression of the form \tcode{E1 \placeholder{op}= E2}

a reference to \keyword{this} or to a variable with

automatic storage duration defined outside that

\grammarterm{lambda-expression}, where

\begin{example}

\begin{codeblock}

void g() {

\end{itemize}

\begin{note}

A manifestly constant-evaluated expression

\end{note}

a subexpression of one of the above

\end{itemize}

\indextext{function!needed for constant evaluation}%

Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.

If the expression \tcode{TS::value} is well-formed

then specializations of each of the two templates meet

the \oldconcept{TransformationTrait} requirements with a base characteristic of

\tcode{integral_constant<size_t, TS::value>}.

The expression \tcode{is >> std::forward<T>(x)} is well-formed

\tcode{Istream} is publicly and unambiguously derived from \tcode{ios_base}.

\tcode{ranges::begin(E)} is ill-formed.

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::begin(E)} is ill-formed with no diagnostic required.

\tcode{ranges::end(E)} is ill-formed.

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::end(E)} is ill-formed with no diagnostic required.

\tcode{ranges::rbegin(E)} is ill-formed.

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::rbegin(E)} is ill-formed with no diagnostic required.

\tcode{ranges::rend(E)} is ill-formed.

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::rend(E)} is ill-formed with no diagnostic required.

\tcode{ranges::data(E)} is ill-formed.

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::data(E)} is ill-formed with no diagnostic required.

\end{codeblock}

\end{example}

\begin{note}

an entity to be defined.

\end{note}

A \keyword{case} or \keyword{default} label appearing within such an