\rSec0[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{equality~operator}}%

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

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

\indextext{expression|(}%

\enternote

Clause~\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.

\exitnote

\indextext{operator!overloaded}%

\enternote

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

expressions of class type~(Clause \ref{class}) or enumeration

type~(\ref{dcl.enum}). Uses of overloaded operators are transformed into

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

obey the rules for syntax specified in Clause~\ref{expr}, but the

requirements of operand type, value category, and evaluation order 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~(\ref{over.oper}), and are not guaranteed for operands of type

\tcode{bool}.

\exitnote

Clause~\ref{expr} 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 \term{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 Clause~\ref{expr};

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

\indextext{exception!arithmetic}%

\indextext{exception!undefined arithmetic}%

\indextext{overflow!undefined}%

\indextext{zero!division by undefined}%

\indextext{zero!remainder undefined}%

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

mathematically defined or not in the range of representable values for

its type, the behavior is undefined.

\enternote

\indextext{overflow}%

most existing implementations of \Cpp ignore integer overflows.

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

and all floating point exceptions vary among machines, and is usually

adjustable by a library function.

\exitnote

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

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

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

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

\indextext{expression!rvalue~reference}%

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,

\item a cast to an rvalue reference to object type,

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

of non-reference type

in which the object expression is an xvalue, 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.

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

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

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

appear~(\ref{expr.typeid}, \ref{expr.sizeof}, \ref{expr.unary.noexcept}, \ref{dcl.type.simple}).

An unevaluated operand is not evaluated. An unevaluated operand is

considered a full-expression.

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

named~(\ref{expr.prim}) and naming of objects or functions does not, by

itself, require that a definition be provided~(\ref{basic.def.odr}).

Whenever a glvalue expression appears as an operand of an operator that

expects a prvalue for that operand, the

lvalue-to-rvalue~(\ref{conv.lval}), array-to-pointer~(\ref{conv.array}),

or function-to-pointer~(\ref{conv.func}) standard conversions are

applied to convert the expression to a prvalue.

\enternote

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

expression of type \tcode{const int} can, for example, be used where

a prvalue expression of type \tcode{int} is required.

\exitnote

\indextext{conversion!usual arithmetic}%

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 \term{usual arithmetic conversions},

which are defined as follows:

\begin{itemize}

\item If either operand is of scoped enumeration type~(\ref{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} \tcode{double}, the

other shall be converted to \tcode{long} \tcode{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~(\ref{conv.prom}) shall be

performed on both operands.\footnote{As a consequence, operands of type \tcode{bool}, \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}

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

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

evaluated and its value is discarded. The array-to-pointer~(\ref{conv.array})

and function-to-pointer~(\ref{conv.func}) standard conversions are not

applied. The lvalue-to-rvalue conversion~(\ref{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}~(\ref{expr.prim.general}),

\item subscripting~(\ref{expr.sub}),

\item class member access~(\ref{expr.ref}),

\item indirection~(\ref{expr.unary.op}),

\item pointer-to-member operation~(\ref{expr.mptr.oper}),

\item conditional expression~(\ref{expr.cond}) where both the second and the

third operands are one of these expressions, or

\item comma expression~(\ref{expr.comma}) where the right operand is one of

these expressions.

\end{itemize}

\enternote Using an overloaded operator causes a function call; the

above covers only operators with built-in meaning. If the lvalue is of

class type, it must have a volatile copy constructor to initialize the

temporary that is the result of the lvalue-to-rvalue

conversion. \exitnote

The values of the floating operands and the results of floating

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.cast},~\ref{expr.static.cast}

and~\ref{expr.ass}.}

The \term{cv-combined type} of two types \tcode{T1} and \tcode{T2}

is a type \tcode{T3}

similar to \tcode{T1} whose cv-qualification signature~(\ref{conv.qual}) is:

\begin{itemize}

for every $j > 0$, \cv$_{3,j}$ is the union of

\cv$_{1,j}$ and \cv$_{2,j}$;

if the resulting \cv$_{3,j}$ is different from

\cv$_{1,j}$ or \cv$_{2,j}$, then

\tcode{const} is added to every \cv$_{3,k}$ for $0 < k < j$.

\end{itemize}

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

construction ensures that

both can be converted to \tcode{T3}. \exitnote

The \term{composite pointer type} of

two operands \tcode{p1} and

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

pointer or pointer to member type or

\tcode{std::nullptr_t}, is:

\begin{itemize}

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

\tcode{std::nullptr_t};

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

respectively;

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

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

\tcode{void}'', where \cvqual{cv12} is the union of \cvqual{cv1}

and \cvqual{cv2};

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}~(\ref{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;

if \tcode{T1} is ``pointer to member of \tcode{C1} of type \cvqual{cv1} \tcode{U1}'' and \tcode{T2} is

``pointer to member of \tcode{C2} of type \cvqual{cv2} \tcode{U2}'' where \tcode{C1} is

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

\tcode{C1}~(\ref{dcl.init.ref}), the cv-combined type of \tcode{T2} and \tcode{T1} or the cv-combined type

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

if \tcode{T1} and \tcode{T2} are similar multi-level mixed pointer and pointer to

member types~(\ref{conv.qual}), the cv-combined type of \tcode{T1} and

\tcode{T2};

otherwise, a program that necessitates the determination of a

composite pointer type is ill-formed.

\end{itemize}

\begin{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}''.

\rSec1[expr.prim]{Primary expressions}%

\indextext{expression!primary|(}

\rSec2[expr.prim.general]{General}

\begin{bnf}

\nontermdef{primary-expression}\br

literal\br

\terminal{this}\br

\terminal{(} expression \terminal{)}\br

id-expression\br

lambda-expression

\end{bnf}

\begin{bnf}

\nontermdef{id-expression}\br

unqualified-id\br

qualified-id

\end{bnf}

\begin{bnf}

\nontermdef{unqualified-id}\br

identifier\br

operator-function-id\br

conversion-function-id\br

literal-operator-id\br

\terminal{\tilde} class-name\br

\terminal{\tilde} decltype-specifier\br

template-id

\end{bnf}

A

\indextext{literal}%

\indextext{constant}%

\grammarterm{literal}

is a primary expression.

Its type depends on its form~(\ref{lex.literal}).

A string literal is an lvalue; all other literals are prvalues.

\indextext{\idxcode{this}}%

The keyword \tcode{this} names a pointer to the object for which a non-static member

function~(\ref{class.this}) is invoked or a non-static data member's

initializer~(\ref{class.mem}) is evaluated.

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-qualifer-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). \enternote this is because declaration matching does not

occur until the complete declarator is known. \exitnote Unlike the object

expression in other contexts, \tcode{*this} is not required to be of complete

type for purposes of class member access~(\ref{expr.ref}) outside the member

function body. \enternote only class members declared prior to the declaration

are visible. \exitnote

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

Otherwise, if a \grammarterm{member-declarator} declares a non-static data

member~(\ref{class.mem}) of a class \tcode{X}, the expression \tcode{this} is

a prvalue of type ``pointer to \tcode{X}'' within the

optional \grammarterm{brace-or-equal-initializer}. It shall not appear elsewhere

in the \grammarterm{member-declarator}.

The expression \tcode{this} shall not appear in any other context.

\begin{codeblock}

class Outer {

int a[sizeof(*this)]; // error: not inside a member function

unsigned int sz = sizeof(*this); // OK: in \grammarterm{brace-or-equal-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}

\indextext{expression!parenthesized}%

A parenthesized expression is a primary expression whose type and value

are identical to those of the enclosed expression. The presence of

parentheses does not affect whether the expression is an lvalue. The

parenthesized expression can be used in exactly the same contexts as

those where the enclosed expression can be used, and with the same

meaning, except as otherwise indicated.

\indextext{name}%

\indextext{id-expression}%

An \grammarterm{id-expression} is a restricted form of a

\grammarterm{primary-expression}.

\enternote

an \grammarterm{id-expression} can appear after \tcode{.} and \tcode{->}

operators~(\ref{expr.ref}).

\exitnote

\indextext{identifier}%

An \grammarterm{identifier} is an \grammarterm{id-expression} provided it has

been suitably declared (Clause~\ref{dcl.dcl}).

\enternote

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{class-name}

or \grammarterm{decltype-specifier}

prefixed by \tcode{\tilde} denotes a destructor; see~\ref{class.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}).

\exitnote

The type of the expression is the type of the \grammarterm{identifier}. The

result is the entity denoted by the identifier. The result is an lvalue

if the entity is a function, variable, or data member and a prvalue otherwise.

\indextext{operator!scope~resolution}%

\indextext{\idxcode{::}|see{scope~resolution~operator}}%

\begin{bnf}

\nontermdef{qualified-id}\br

nested-name-specifier \terminal{template}\opt 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 \terminal{template}\opt simple-template-id \terminal{::}

\end{bnf}

The type denoted by a \grammarterm{decltype-specifier} in a

\grammarterm{nested-name-specifier} shall be a class or enumeration

type.

A \grammarterm{nested-name-specifier} that denotes a class, optionally

followed by the keyword \tcode{template}~(\ref{temp.names}), and then

followed by the name of a member of either that class~(\ref{class.mem})

or one of its base classes (Clause~\ref{class.derived}), is a

\indextext{id!qualified}%

\grammarterm{qualified-id};~\ref{class.qual} describes name lookup for

class members that appear in \grammarterm{qualified-ids}. 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.

\enternote

a class member can be referred to using a \grammarterm{qualified-id} at any

point in its potential scope~(\ref{basic.scope.class}).

\exitnote

Where

\grammarterm{class-name} \tcode{::\tilde} \grammarterm{class-name} is used,

the two \grammarterm{class-name}{s} shall refer to the same class; this

notation names the destructor~(\ref{class.dtor}).

The form \grammarterm{\tilde} \grammarterm{decltype-specifier} also denotes the destructor,

but it shall not be used as the \grammarterm{unqualified-id} in a \grammarterm{qualified-id}.

\enternote

a \grammarterm{typedef-name} that names a class is a

\grammarterm{class-name}~(\ref{class.name}).

\exitnote

A \tcode{::}, or a \grammarterm{nested-name-specifier} that names a

namespace~(\ref{basic.namespace}), in either case 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-ids}. 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 or a variable and a prvalue otherwise.

A \grammarterm{nested-name-specifier} that denotes an

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

In a \grammarterm{qualified-id}, if the

\grammarterm{unqualified-id}

is a

\grammarterm{conversion-function-id}, its \grammarterm{conversion-type-id}

shall denote the same type in both the context in which the entire

\grammarterm{qualified-id} occurs and in the context of the class denoted

by the \grammarterm{nested-name-specifier}.

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~(\ref{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~(\ref{expr.unary.op}), or

\item if that \grammarterm{id-expression} denotes a non-static data member

and it appears in an unevaluated operand.

\begin{codeblock}

struct S {

int m;

};

int i = sizeof(S::m); // OK

int j = sizeof(S::m + 42); // OK

\end{codeblock}

\end{itemize}

\rSec2[expr.prim.lambda]{Lambda expressions}%

\indextext{expression!lambda|(}

Lambda expressions provide a concise way to create simple function objects.

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

\begin{bnf}

\nontermdef{lambda-expression}\br

lambda-introducer lambda-declarator\opt compound-statement

\end{bnf}

\begin{bnf}

\nontermdef{lambda-introducer}\br

\terminal{[} lambda-capture\opt \terminal{]}

\end{bnf}

\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 \terminal{...\opt}\br

capture-list \terminal{,} capture \terminal{...\opt}

\end{bnf}

\begin{bnf}

\nontermdef{capture}\br

simple-capture\br

init-capture

\end{bnf}

\begin{bnf}

\nontermdef{simple-capture}\br

identifier\br

\terminal{\&} identifier\br

\terminal{this}

\end{bnf}

\begin{bnf}

\nontermdef{init-capture}\br

identifier initializer\br

\terminal{\&} identifier initializer

\end{bnf}

\begin{bnf}

\nontermdef{lambda-declarator}\br

\terminal{(} parameter-declaration-clause \terminal{)} \terminal{mutable}\opt\br

\hspace*{\bnfindentinc}exception-specification\opt attribute-specifier-seq\opt trailing-return-type\opt

\end{bnf}

The evaluation of a \grammarterm{lambda-expression} results in a prvalue

temporary~(\ref{class.temporary}). This temporary is called the \defn{closure object}. A

\grammarterm{lambda-expression} shall not appear in an unevaluated operand

(Clause~\ref{expr}). \enternote A closure object behaves like a function

object~(\ref{function.objects}).\exitnote

The type of the \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. This class type is not an

aggregate~(\ref{dcl.init.aggr}). The closure type is declared in the smallest block

scope, class scope, or namespace scope that contains the corresponding

\grammarterm{lambda-expression}. \enternote This determines the set of namespaces and

classes associated with the closure type~(\ref{basic.lookup.argdep}). The parameter

types of a \grammarterm{lambda-declarator} do not affect these associated namespaces and

classes. \exitnote 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 (Clause~\ref{class}),

\item whether the closure type is a standard-layout class (Clause~\ref{class}),

or

\item whether the closure type is a POD class (Clause~\ref{class}).

\end{itemize}

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

type.

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

\grammarterm{trailing-return-type} if provided and/or deduced from

\tcode{return} statements as described in~\ref{dcl.spec.auto}.

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

The closure type for a non-generic \grammarterm{lambda-expression} has a public

inline function call operator~(\ref{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.

For a generic lambda, the closure type has a public inline function call

operator member template~(\ref{temp.mem}) whose

\grammarterm{template-parameter-list} consists of one invented type

\grammarterm{template-parameter} for each occurrence of \tcode{auto} in the

lambda's \grammarterm{parameter-declaration-clause}, in order of appearance.

The invented type \grammarterm{template-parameter} is a parameter pack if

the corresponding \grammarterm{parameter-declaration} declares a function

parameter pack~(\ref{dcl.fct}). The return type and function parameters of the

function call operator template are derived from the

\grammarterm{lambda-expression}{'s} \grammarterm{trailing-return-type} and

\grammarterm{parameter-declaration-clause} by replacing each occurrence of

\tcode{auto} in the \grammarterm{decl-specifier}{s} of the

\grammarterm{parameter-declaration-clause} with the name of the corresponding

invented \grammarterm{template-parameter}.

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

This 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{exception-specification} 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.

\enternote Names referenced in

the \grammarterm{lambda-declarator} are looked up in the context in which the

\grammarterm{lambda-expression} appears. \exitnote

The closure type for a non-generic \grammarterm{lambda-expression} with no

\grammarterm{lambda-capture}

has a public non-virtual non-explicit const conversion function to pointer to

function with \Cpp language linkage~(\ref{dcl.link}) having

the same parameter and return types as the closure type's function call operator. The

value returned by this conversion function shall be the address of a function that, when

invoked, has the same effect as invoking the closure type's function call operator.

For a generic lambda with no \grammarterm{lambda-capture}, the closure type has a

public non-virtual non-explicit const conversion function template to

pointer to function. The conversion function template has the same invented

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

\enternote 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 { ... }

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

...

}

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}

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

The value returned by any given specialization of this conversion function

template shall be the address of a function that, when invoked, has the same

effect as invoking the generic lambda's corresponding function call operator

template specialization.

This will result in the implicit instantiation of the generic lambda's body.

The instantiated generic lambda's return type and parameter types shall match

the return type and parameter types of the pointer to function.

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

The \grammarterm{lambda-expression}'s \grammarterm{compound-statement} yields the

\grammarterm{function-body}~(\ref{dcl.fct.def}) of the function call operator, but for

purposes of name lookup~(\ref{basic.lookup}), determining the type and value of

\tcode{this}~(\ref{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}. \enterexample

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

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}''. 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}. \enterexample

\begin{codeblock}

struct S2 { void f(int i); };

void S2::f(int i) {

[&, i]{ }; // OK

[&, &i]{ }; // error: \tcode{i} preceded by \tcode{\&} when \tcode{\&} is the default

[=, this]{ }; // error: \tcode{this} when \tcode{=} is the default

[i, i]{ }; // error: \tcode{i} repeated

}

\end{codeblock}

A \grammarterm{lambda-expression} whose smallest enclosing scope is a block

scope~(\ref{basic.scope.block}) is a \defn{local lambda expression}; any other

\grammarterm{lambda-expression} shall not have a \grammarterm{capture-default} or

\grammarterm{simple-capture} in its

\grammarterm{lambda-introducer}. The \defn{reaching scope} of a local lambda expression

is the set of enclosing scopes up to and including the innermost enclosing function and

its parameters. \enternote This reaching scope includes any intervening

\grammarterm{lambda-expression}{s}. \exitnote

The \grammarterm{identifier} in a \grammarterm{simple-capture} is looked up using the

usual rules for unqualified name lookup~(\ref{basic.lookup.unqual}); each such lookup

shall find a variable with automatic storage duration declared in

the reaching scope of the local lambda expression. An entity (i.e. a variable or

\tcode{this}) is said to be \defn{explicitly captured} if it is found by this

process.

For every \grammarterm{init-capture} a non-static data member named by the

\grammarterm{identifier} of the \grammarterm{init-capture} is declared in the closure type.

This member is not a bit-field and not \tcode{mutable}.

The type of that member corresponds to the type of a hypothetical variable

declaration of

the form ``\tcode{auto} \grammarterm{init-capture} \tcode{;}'', except that the

variable name (i.e., the \grammarterm{identifier} of the \grammarterm{init-capture}) is

replaced by a unique identifier.

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.

No entity is captured by an \grammarterm{init-capture}. Within the

\grammarterm{lambda-expression}{s} \grammarterm{lambda-declarator} and

\grammarterm{compound-statement},

the \grammarterm{identifier} in the \grammarterm{init-capture} hides any declaration

of the same name in scopes enclosing the \grammarterm{lambda-expression}.

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

\end{codeblock}

A \grammarterm{lambda-expression} with an associated

\grammarterm{capture-default} that does not explicitly capture \tcode{this} or

a variable with automatic storage duration (this excludes any \grammarterm{id-expression}

that has been found to refer to an \grammarterm{init-capture}{'s} associated

\indextext{implicit capture!definition of}%

non-static data member), is said to \term{implicitly capture} the entity (i.e.,

\tcode{this} or a variable) if the \grammarterm{compound-statement}:

\begin{itemize}

\item odr-uses~(\ref{basic.def.odr}) the entity, or

\item names the entity in a potentially-evaluated

expression~(\ref{basic.def.odr}) where the enclosing full-expression depends on

a generic lambda parameter declared within the reaching scope of the

\grammarterm{lambda-expression}.

\end{itemize}

\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 g2 = [=](auto a) {

int selector[sizeof(a) == 1 ? 1 : 2]{};

f(x, selector); // OK: is a dependent expression, so captures \tcode{x}

};

}

\end{codeblock}

All such implicitly captured

entities shall be declared within the reaching scope of the lambda expression.

\enternote The implicit capture of an entity by a nested

\grammarterm{lambda-expression} can cause its implicit capture by the containing

\grammarterm{lambda-expression} (see below). Implicit odr-uses of \tcode{this} can result

in implicit capture. \exitnote

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

captured by a \grammarterm{lambda-expression} is odr-used~(\ref{basic.def.odr}) in the scope

containing the \grammarterm{lambda-expression}. If \tcode{this} is captured by a local

lambda expression, its nearest enclosing function shall be a non-static member function.

If a \grammarterm{lambda-expression} or an instantiation of the function call

operator template of a generic lambda odr-uses~(\ref{basic.def.odr}) \tcode{this} or a

variable with automatic storage duration from its reaching scope, that

entity shall be captured by the \grammarterm{lambda-expression}. If a

\grammarterm{lambda-expression} captures an entity and that entity is not defined or

captured in the immediately enclosing lambda expression or function, the program is

ill-formed. \enterexample

\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 captured by \tcode{m3}

int x = n; // error: \tcode{n} implicitly captured by \tcode{m4}

// but not captured by \tcode{m3}

x += m; // OK: \tcode{m} implicitly captured by \tcode{m4}

// and explicitly captured by \tcode{m3}

x += i; // error: \tcode{i} is outside of the reaching scope

x += f; // OK: \tcode{this} captured implicitly by \tcode{m4}

// and explicitly by \tcode{m3}

};

};

}

};

}

\end{codeblock}

A \grammarterm{lambda-expression} appearing in a default argument shall not

implicitly or explicitly capture any entity. \enterexample

\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