\rSec0[temp]{Templates}%

\indextext{template|(}

\gramSec[gram.temp]{Templates}

\indextext{parameterized type|see{template}}%

\indextext{type generator|see{template}}

\rSec1[temp.pre]{Preamble}

A \defn{template} defines a family of classes, functions, or variables,

an alias for a family of types, or a concept.

\indextext{\idxcode{template}}%

\begin{bnf}

\nontermdef{template-declaration}\br

template-head declaration\br

template-head concept-definition

\end{bnf}

\begin{bnf}

\nontermdef{template-head}\br

\keyword{template} \terminal{<} template-parameter-list \terminal{>} \opt{requires-clause}

\end{bnf}

\begin{bnf}

\nontermdef{template-parameter-list}\br

template-parameter\br

template-parameter-list \terminal{,} template-parameter

\end{bnf}

\begin{bnf}

\nontermdef{requires-clause}\br

\keyword{requires} constraint-logical-or-expression

\end{bnf}

\begin{bnf}

\nontermdef{constraint-logical-or-expression}\br

constraint-logical-and-expression\br

constraint-logical-or-expression \terminal{||} constraint-logical-and-expression

\end{bnf}

\begin{bnf}

\nontermdef{constraint-logical-and-expression}\br

primary-expression\br

constraint-logical-and-expression \terminal{\&\&} primary-expression

\end{bnf}

\begin{note}

The \tcode{>} token following the

\grammarterm{template-parameter-list} of a

\grammarterm{template-declaration}

can be the product of replacing a

\tcode{>>} token by two consecutive \tcode{>}

tokens\iref{temp.names}.

\end{note}

The \grammarterm{declaration} in a \grammarterm{template-declaration} (if any)

shall

\begin{itemize}

\item declare or define a function, a class, or a variable, or

\item define a member function, a member class, a member enumeration, or a static data member of a

class template or of a class nested within a class template, or

\item define a member template of a class or class template, or

\item be a \grammarterm{friend-type-declaration}, or

\item be a \grammarterm{deduction-guide}, or

\item be an \grammarterm{alias-declaration}.

\end{itemize}

A \grammarterm{template-declaration} is a \grammarterm{declaration}.

A declaration introduced by a template declaration of a

\indextext{variable template!definition of}%

variable is a \defnx{variable template}{template!variable}. A variable template at class scope is a

\defnx{static data member template}{template!static data member}.

\begin{example}

\begin{codeblock}

template<class T>

constexpr T pi = T(3.1415926535897932385L);

template<class T>

T circular_area(T r) {

return pi<T> * r * r;

}

struct matrix_constants {

template<class T>

using pauli = hermitian_matrix<T, 2>;

template<class T>

constexpr static pauli<T> sigma1 = { { 0, 1 }, { 1, 0 } };

template<class T>

constexpr static pauli<T> sigma2 = { { 0, -1i }, { 1i, 0 } };

template<class T>

constexpr static pauli<T> sigma3 = { { 1, 0 }, { 0, -1 } };

};

\end{codeblock}

\end{example}

\begin{note}

A \grammarterm{template-declaration}

can appear only as a namespace scope or class scope declaration.

\end{note}

Its \grammarterm{declaration} shall not be an

\grammarterm{export-declaration}.

In a function template declaration, the \grammarterm{unqualified-id} of the

\grammarterm{declarator-id} shall be a name.

\begin{note}

A class or variable template declaration of a \grammarterm{simple-template-id}

declares a partial specialization\iref{temp.spec.partial}.

\end{note}

In a

\grammarterm{template-declaration},

explicit specialization, or explicit instantiation, the

\grammarterm{init-declarator-list}

in the declaration shall contain at most one declarator.

When such a declaration is used to declare a class template,

no declarator is permitted.

\indextext{template name!linkage of}%

A specialization (explicit or implicit) of one template is

distinct from all specializations of any other template.

A template, an explicit specialization\iref{temp.expl.spec}, and a

partial specialization shall not have C language linkage.

\begin{note}

Default arguments for function templates and for member functions of

class templates are considered definitions for the purpose of template

instantiation\iref{temp.decls} and must obey the one-definition rule\iref{basic.def.odr}.

\end{note}

\begin{note}

A template cannot have the same name as any other

name bound in the same scope\iref{basic.scope.scope}, except

that a function template can share a name with \grammarterm{using-declarator}s,

a type, non-template functions\iref{dcl.fct} and/or function templates\iref{temp.over}.

Specializations, including partial specializations\iref{temp.spec.partial},

do not reintroduce or bind names.

Their target scope is the target scope of the primary template,

so all specializations of a template belong to the same scope as it does.

\begin{example}

\begin{codeblock}

void f() {}

class f {}; // OK

namespace N {

void f(int) {}

}

using N::f; // OK

template<typename> void f(long) {} // \#1, OK

template<typename> void f(long) {} // error: redefinition of \#1

template<typename> void f(long long) {} // OK

template<> void f<int>(long long) {} // OK, doesn't bind a name

\end{codeblock}

\end{example}

\end{note}

\indextext{entity!templated}%

An entity is \defn{templated}

if it is

\begin{itemize}

\item a template,

\item an entity defined\iref{basic.def} or created\iref{class.temporary}

within the \grammarterm{compound-statement}

of an expansion statement\iref{stmt.expand},

\item an entity defined or created in a templated entity,

\item a member of a templated entity,

\item an enumerator for an enumeration that is a templated entity, or

\item the closure type of a \grammarterm{lambda-expression}\iref{expr.prim.lambda.closure}

appearing in the declaration of a templated entity.

\end{itemize}

\begin{note}

A local class, a local or block variable, or a friend function defined in a

templated entity is a templated entity.

\end{note}

A \defnadj{templated}{function} is

a function template or a function that is templated.

A \defnadj{templated}{class} is

a class template or a class that is templated.

A \defnadj{templated}{variable} is

a variable template or a variable that is templated.

A \grammarterm{template-declaration} is written

in terms of its template parameters.

The optional \grammarterm{requires-clause} following a

\grammarterm{template-parameter-list} allows the specification of

constraints\iref{temp.constr.decl} on template arguments\iref{temp.arg}.

The \grammarterm{requires-clause} introduces the

\grammarterm{constraint-expression} that results from interpreting

the \grammarterm{constraint-logical-or-expression} as a

\grammarterm{constraint-expression}.

The \grammarterm{constraint-logical-or-expression} of a

\grammarterm{requires-clause} is an unevaluated operand\iref{expr.context}.

\begin{note}

The expression in a \grammarterm{requires-clause}

uses a restricted grammar to avoid ambiguities.

Parentheses can be used to specify arbitrary expressions

in a \grammarterm{requires-clause}.

\begin{example}

\begin{codeblock}

template<int N> requires N == sizeof new unsigned short

int f(); // error: parentheses required around \tcode{==} expression

\end{codeblock}

\end{example}

\end{note}

A definition of

a function template,

member function of a class template,

variable template,

or static data member of a class template

shall be reachable from the end of every definition domain\iref{basic.def.odr}

in which it is implicitly instantiated\iref{temp.inst} unless the

corresponding specialization is explicitly instantiated\iref{temp.explicit}

in some translation unit; no diagnostic is required.

\rSec1[temp.param]{Template parameters}

The syntax for

\grammarterm{template-parameter}{s}

is:

\begin{bnf}

\nontermdef{template-parameter}\br

type-parameter\br

parameter-declaration\br

type-tt-parameter\br

variable-tt-parameter\br

concept-tt-parameter

\end{bnf}

\begin{bnf}

\nontermdef{type-parameter}\br

type-parameter-key \opt{\terminal{...}} \opt{identifier}\br

type-parameter-key \opt{identifier} \terminal{=} type-id\br

type-constraint \opt{\terminal{...}} \opt{identifier}\br

type-constraint \opt{identifier} \terminal{=} type-id

\end{bnf}

\begin{bnf}

\nontermdef{type-parameter-key}\br

\keyword{class}\br

\keyword{typename}

\end{bnf}

\begin{bnf}

\nontermdef{type-constraint}\br

\opt{nested-name-specifier} concept-name\br

\opt{nested-name-specifier} concept-name \terminal{<} \opt{template-argument-list} \terminal{>}

\end{bnf}

\begin{bnf}

\nontermdef{type-tt-parameter}\br

template-head type-parameter-key \opt{\terminal{...}} \opt{identifier}\br

template-head type-parameter-key \opt{identifier} type-tt-parameter-default

\end{bnf}

\begin{bnf}

\nontermdef{type-tt-parameter-default}\br

\terminal{=} \opt{nested-name-specifier} template-name\br

\terminal{=} nested-name-specifier \terminal{template} template-name

\end{bnf}

\begin{bnf}

\nontermdef{variable-tt-parameter}\br

template-head \terminal{auto} \opt{\terminal{...}} \opt{identifier}\br

template-head \terminal{auto} \opt{identifier} \terminal{=} \opt{nested-name-specifier} template-name

\end{bnf}

\begin{bnf}

\nontermdef{concept-tt-parameter}\br

\terminal{template} \terminal{<} template-parameter-list \terminal{>} \terminal{concept} \opt{\terminal{...}} \opt{identifier}\br

\terminal{template} \terminal{<} template-parameter-list \terminal{>} \terminal{concept} \opt{identifier} \terminal{=} \opt{nested-name-specifier} template-name

\end{bnf}

\indextext{component name}%

The component names of a \grammarterm{type-constraint} are

its \grammarterm{concept-name} and

those of its \grammarterm{nested-name-specifier} (if any).

\begin{note}

The \tcode{>} token following the

\grammarterm{template-parameter-list} of a

\grammarterm{type-tt-parameter},

\grammarterm{variable-tt-parameter}, or

\grammarterm{concept-tt-parameter}

can be the product of replacing a

\tcode{>>} token by two consecutive \tcode{>}

tokens\iref{temp.names}.

\end{note}

A template parameter is of one of the following kinds:

\begin{itemize}

A \defnadj{type}{template parameter} is

a template parameter introduced by a \grammarterm{type-parameter}.

A \defnadj{constant}{template parameter} is

a template parameter introduced by a \grammarterm{parameter-declaration}.

A \defnadj{type template}{template parameter} is

a template parameter introduced by a \grammarterm{type-tt-parameter}.

A \defnadj{variable template}{template parameter} is

a template parameter introduced by a \grammarterm{variable-tt-parameter}.

A \defnadj{concept}{template parameter} is

a template parameter introduced by a \grammarterm{concept-tt-parameter}.

\end{itemize}

Type template template parameters,

variable template template parameters, and

concept template parameters

are collectively referred to as \defnadj{template}{template parameters}.

The \grammarterm{nested-name-specifier} of a \grammarterm{type-constraint},

if any, shall not be dependent.

A concept template parameter shall not have

associated constraints\iref{temp.constr.decl}.

If a \grammarterm{template-parameter} is

a \grammarterm{parameter-declaration} that declares a pack\iref{dcl.fct}, or

otherwise has an ellipsis prior to its optional \grammarterm{identifier},

then the \grammarterm{template-parameter}

declares a template parameter pack\iref{temp.variadic}.

A template parameter pack that is a \grammarterm{parameter-declaration} whose type

contains one or more unexpanded packs is a pack expansion. Similarly,

a template parameter pack that is a template template parameter with a

\grammarterm{template-parameter-list} containing one or more unexpanded

packs is a pack expansion.

A type parameter pack with a \grammarterm{type-constraint} that

contains an unexpanded parameter pack is a pack expansion.

A template parameter pack that is a pack

expansion shall not expand a template parameter pack declared in the same

\grammarterm{template-parameter-list}.

\begin{example}

\begin{codeblock}

template <class... Types> // \tcode{Types} is a template type parameter pack

class Tuple; // but not a pack expansion

template <class T, int... Dims> // \tcode{Dims} is a constant template parameter pack

struct multi_array; // but not a pack expansion

template <class... T>

struct value_holder {

template <T... Values> struct apply { }; // \tcode{Values} is a constant template parameter pack

}; // and a pack expansion

template <class... T, T... Values> // error: \tcode{Values} expands template type parameter

struct static_array; // pack \tcode{T} within the same template parameter list

\end{codeblock}

\end{example}

There is no semantic difference between

\keyword{class}

and

\keyword{typename}

in a

\grammarterm{type-parameter-key}.

\keyword{typename}

followed by an

\grammarterm{unqualified-id}

names a template type parameter.

\keyword{typename}

followed by a

\grammarterm{qualified-id}

denotes the type in a

\grammarterm{parameter-declaration}.

A \grammarterm{template-parameter} of the form

\keyword{class} \grammarterm{identifier} is a \grammarterm{type-parameter}.

\begin{example}

\begin{codeblock}

class T { @\commentellip@ };

int i;

template<class T, T i> void f(T t) {

T t1 = i; // template parameters \tcode{T} and \tcode{i}

::T t2 = ::i; // global namespace members \tcode{T} and \tcode{i}

}

\end{codeblock}

Here, the template \tcode{f} has a type template parameter

called \tcode{T}, rather than an unnamed constant

template parameter of class \tcode{T}.

\end{example}

The \grammarterm{parameter-declaration} of a \grammarterm{template-parameter}

shall not have a \grammarterm{storage-class-specifier}.

Types shall not be defined in a template parameter

declaration.

The \grammarterm{identifier} in

a \grammarterm{template-parameter} denoting a type or template

is not looked up.

An \grammarterm{identifier} that does not follow an ellipsis

is defined to be

\begin{itemize}

a \grammarterm{typedef-name} for a \grammarterm{type-parameter},

a \grammarterm{template-name} for a \grammarterm{variable-tt-parameter},

a \grammarterm{template-name} for a \grammarterm{type-tt-parameter}, or

a \grammarterm{concept-name} for a \grammarterm{concept-tt-parameter},

\end{itemize}

in the scope of the template declaration.

A \grammarterm{type-constraint} \tcode{Q} that designates a concept \tcode{C}

can be used to constrain a

contextually-determined type or template type parameter pack \tcode{T}

with a \grammarterm{constraint-expression} \tcode{E} defined as follows.

If \tcode{Q} is of the form \tcode{C<A$_1$, $\dotsc$, A$_n$>},

then let \tcode{E$'$} be \tcode{C<T, A$_1$, $\dotsc$, A$_n$>}.

Otherwise, let \tcode{E$'$} be \tcode{C<T>}.

If \tcode{T} is not a pack,

then \tcode{E} is \tcode{E$'$},

otherwise \tcode{E} is \tcode{(E$'$ \&\& ...)}.

This \grammarterm{constraint-expression} \tcode{E} is called the

\defnx{immediately-declared constraint}{constraint!immediately-declared}

of \tcode{Q} for \tcode{T}.

The concept designated by a \grammarterm{type-constraint}

shall be a type concept\iref{temp.concept}.

A \grammarterm{type-parameter} that starts with a \grammarterm{type-constraint}

introduces the immediately-declared constraint

of the \grammarterm{type-constraint} for the parameter.

\begin{example}

\begin{codeblock}

template<typename T> concept C1 = true;

template<typename... Ts> concept C2 = true;

template<typename T, typename U> concept C3 = true;

template<C1 T> struct s1; // associates \tcode{C1<T>}

template<C1... T> struct s2; // associates \tcode{(C1<T> \&\& ...)}

template<C2... T> struct s3; // associates \tcode{(C2<T> \&\& ...)}

template<C3<int> T> struct s4; // associates \tcode{C3<T, int>}

template<C3<int>... T> struct s5; // associates \tcode{(C3<T, int> \&\& ...)}

\end{codeblock}

\end{example}

A constant template parameter

shall have one of the following (possibly cv-qualified) types:

\begin{itemize}

\item a structural type (see below),

\item a type that contains a placeholder type\iref{dcl.spec.auto}, or

\item a placeholder for a deduced class type\iref{dcl.type.class.deduct}.

\end{itemize}

The top-level

\grammarterm{cv-qualifier}{s}

on the

\grammarterm{template-parameter}

are ignored when determining its type.

\label{term.structural.type}%

A \defnadj{structural}{type} is one of the following:

\begin{itemize}

\item a scalar type, or

\item an lvalue reference type, or

\item a literal class type with the following properties:

\begin{itemize}

all base classes and non-static data members are public and non-mutable and

the types of all base classes and non-static data members are

structural types or (possibly multidimensional) arrays thereof.

\end{itemize}

\end{itemize}

An \grammarterm{id-expression} naming

a constant template parameter of class type \tcode{T}

denotes a static storage duration object of type \tcode{const T},

known as a \defn{template parameter object},

which is template-argument-equivalent\iref{temp.type} to

the corresponding template argument

after it has been converted

to the type of the template parameter\iref{temp.arg.nontype}.

No two template parameter objects are template-argument-equivalent.

\begin{note}

If an \grammarterm{id-expression} names

a non-reference constant template parameter,

then it is a prvalue if it has non-class type.

Otherwise, if it is of class type \tcode{T},

it is an lvalue and has type \tcode{const T}\iref{expr.prim.id.unqual}.

\end{note}

\begin{example}

\begin{codeblock}

using X = int;

struct A {};

template<const X& x, int i, A a> void f() {

i++; // error: change of template parameter value

&x; // OK

&i; // error: address of non-reference template parameter

&a; // OK

int& ri = i; // error: attempt to bind non-const reference to temporary

const int& cri = i; // OK, const reference binds to temporary

const A& ra = a; // OK, const reference binds to a template parameter object

}

\end{codeblock}

\end{example}

\begin{note}

A constant template parameter

cannot be declared to have type \cv{} \keyword{void}.

\begin{example}

\begin{codeblock}

template<void v> class X; // error

template<void* pv> class Y; // OK

\end{codeblock}

\end{example}

\end{note}

A constant template parameter

\indextext{array!template parameter of type}%

of type ``array of \tcode{T}'' or

\indextext{function!template parameter of type}%

of function type \tcode{T}

is adjusted to be of type ``pointer to \tcode{T}''.

\begin{example}

\begin{codeblock}

template<int* a> struct R { @\commentellip@ };

template<int b[5]> struct S { @\commentellip@ };

int p;

R<&p> w; // OK

S<&p> x; // OK due to parameter adjustment

int v[5];

R<v> y; // OK due to implicit argument conversion

S<v> z; // OK due to both adjustment and conversion

\end{codeblock}

\end{example}

A constant template parameter declared with a type that

contains a placeholder type with a \grammarterm{type-constraint}

introduces the immediately-declared constraint

of the \grammarterm{type-constraint}

for the invented type corresponding to the placeholder\iref{dcl.fct}.

A \defnadj{default}{template argument} is

a template argument\iref{temp.arg} specified after \tcode{=}

in a \grammarterm{template-parameter}.

A default template argument may be specified for

any kind of template parameter

that is not a template parameter pack\iref{temp.variadic}.

A default template argument may be specified in a template declaration.

A default template argument shall not be specified in

the \grammarterm{template-parameter-list}{s}

of the definition of a member of a class template

that appears outside of the member's class.

A default template argument

shall not be specified in a friend class template declaration.

If a friend function template declaration $D$

specifies a default template argument,

that declaration shall be a definition and

there shall be no other declaration of the function template

which is reachable from $D$ or from which $D$ is reachable.

The set of default template arguments

available for use is obtained by merging the default arguments

from all prior declarations of the template in the

same way default function arguments are\iref{dcl.fct.default}.

\begin{example}

\begin{codeblock}

template<class T1, class T2 = int> class A;

template<class T1 = int, class T2> class A;

\end{codeblock}

is equivalent to

\begin{codeblock}

template<class T1 = int, class T2 = int> class A;

\end{codeblock}

\end{example}

If a \grammarterm{template-parameter}

of a class template, variable template, or alias template has

a default template argument,

each subsequent \grammarterm{template-parameter}

shall either have a default template argument supplied or

declare a template parameter pack.

If a \grammarterm{template-parameter} of

a primary class template, primary variable template, or alias template

declares a template parameter pack,

it shall be the last \grammarterm{template-parameter}.

If a \grammarterm{template-parameter} of a function template

declares a template parameter pack, it

shall not be followed by another \grammarterm{template-parameter}

unless that template parameter is deducible from the

parameter-type-list\iref{dcl.fct} of the function template or

has a default argument\iref{temp.deduct}.

A template parameter of a deduction guide template\iref{temp.deduct.guide}

that does not have a default argument shall be deducible

from the parameter-type-list of the deduction guide template.

\begin{example}

\begin{codeblock}

template<class T1 = int, class T2> class B; // error

// \tcode{U} can be neither deduced from the parameter-type-list nor specified

template<class... T, class... U> void f() { } // error

template<class... T, class U> void g() { } // error

\end{codeblock}

\end{example}

\indextext{\idxcode{<}!template and}%

When parsing a default template argument

for a constant template parameter,

the first non-nested \tcode{>} is taken as

the end of the \grammarterm{template-parameter-list}

rather than a greater-than operator.

\begin{example}

\begin{codeblock}

template<int i = 3 > 4 > // syntax error

class X { @\commentellip@ };

template<int i = (3 > 4) > // OK

class Y { @\commentellip@ };

\end{codeblock}

\end{example}

A \grammarterm{template-parameter} of

a template \grammarterm{template-parameter}

is permitted to have a default template argument.

When such default arguments are specified,

they apply to the template \grammarterm{template-parameter}

in the scope of the template \grammarterm{template-parameter}.

\begin{example}

\begin{codeblock}

template <template <class TT = float> class T> struct A {

inline void f();

inline void g();

};

template <template <class TT> class T> void A<T>::f() {

T<> t; // error: \tcode{TT} has no default template argument

}

template <template <class TT = char> class T> void A<T>::g() {

T<> t; // OK, \tcode{T<char>}

}

\end{codeblock}

\end{example}

The associated constraints of a template template parameter

shall not contain a concept-dependent constraint\iref{temp.constr.concept}.

\begin{example}

\begin{codeblock}

template<

template<typename> concept C,

template<C> class TT // error: \tcode{C} forms a concept-dependent constraint

>

struct A {};

\end{codeblock}

\end{example}

\rSec1[temp.names]{Names of template specializations}

A template specialization\iref{temp.spec} can be referred to by a

\grammarterm{template-id}:

\begin{bnf}

\nontermdef{simple-template-id}\br

template-name \terminal{<} \opt{template-argument-list} \terminal{>}

\end{bnf}

\begin{bnf}

\nontermdef{template-id}\br

simple-template-id\br

operator-function-id \terminal{<} \opt{template-argument-list} \terminal{>}\br

literal-operator-id \terminal{<} \opt{template-argument-list} \terminal{>}

\end{bnf}

\begin{bnf}

\nontermdef{template-name}\br

identifier

\end{bnf}

\begin{bnf}

\nontermdef{template-argument-list}\br

template-argument \opt{\terminal{...}}\br

template-argument-list \terminal{,} template-argument \opt{\terminal{...}}

\end{bnf}

\begin{bnf}

\nontermdef{template-argument}\br

constant-expression\br

type-id\br

\opt{nested-name-specifier} template-name\br

nested-name-specifier \terminal{template} template-name

\end{bnf}

\indextext{component name}%

The component name of a

\grammarterm{simple-template-id},

\grammarterm{template-id}, or

\grammarterm{template-name}

is the first name in it.

A \tcode{<} is interpreted as the delimiter of

a \grammarterm{template-argument-list}

if either

\begin{itemize}

it follows a \grammarterm{splice-specifier} that either

\begin{itemize}

\item appears in a type-only context or

\item is preceded by \keyword{template} or \keyword{typename}, or

\end{itemize}

it follows a name that is not a \grammarterm{conversion-function-id} and

\begin{itemize}

that follows the keyword \keyword{template} or a \tcode{\~}

after a \grammarterm{nested-name-specifier} or

in a class member access expression, or

for which name lookup finds the injected-class-name of a class template or

finds any declaration of a template, or

that is an unqualified name

for which name lookup either finds one or more functions or finds nothing, or

that is a terminal name

in a \grammarterm{using-declarator}\iref{namespace.udecl},

in a \grammarterm{declarator-id}\iref{dcl.meaning}, or

in a type-only context

other than a \grammarterm{nested-name-specifier}\iref{temp.res}.

\end{itemize}

\end{itemize}

\begin{note}

If the name is an \grammarterm{identifier},

it is then interpreted as a \grammarterm{template-name}.

The keyword \keyword{template} is used to indicate

that a dependent qualified name\iref{temp.dep.type} denotes a template

where an expression might appear.

\end{note}

\begin{example}

\begin{codeblock}

struct X {

template<std::size_t> X* alloc();

template<std::size_t> static X* adjust();

};

template<class T> void f(T* p) {

T* p1 = p->alloc<200>(); // error: \tcode{<} means less than

T* p2 = p->template alloc<200>(); // OK, \tcode{<} starts template argument list

T::adjust<100>(); // error: \tcode{<} means less than

T::template adjust<100>(); // OK, \tcode{<} starts template argument list

static constexpr std::meta::info r = ^^T::adjust;

T* p3 = [:r:]<200>(); // error: \tcode{<} means less than

T* p4 = template [:r:]<200>(); // OK, \tcode{<} starts template argument list

}}

\end{codeblock}

\end{example}

\indextext{\idxcode{<}!template and}%

When parsing a \grammarterm{template-argument-list},

the first non-nested

\tcode{>}

\begin{footnote}

A \tcode{>} that encloses the \grammarterm{type-id}

of a \keyword{dynamic_cast}, \keyword{static_cast}, \keyword{reinterpret_cast}

or \keyword{const_cast}, or which encloses the \grammarterm{template-argument}{s}

of a subsequent \grammarterm{template-id} or

\grammarterm{splice-specialization-specifier},

is considered nested for the purpose of this description.

\end{footnote}

is taken as the ending delimiter

rather than a greater-than operator.

Similarly, the first non-nested \tcode{>>} is treated as two

consecutive but distinct \tcode{>} tokens, the first of which is taken

as the end of the \grammarterm{template-argument-list} and completes

the \grammarterm{template-id} or \grammarterm{splice-specialization-specifier}.

\begin{note}

The second \tcode{>}

token produced by this replacement rule can terminate an enclosing

\grammarterm{template-id} or \grammarterm{splice-specialization-specifier}

construct or it can be part of a different construct (e.g., a cast).

\end{note}

\begin{example}

\begin{codeblock}

template<int i> class X { @\commentellip@ };

X< 1>2 > x1; // syntax error

X<(1>2)> x2; // OK

template<class T> class Y { @\commentellip@ };

Y<X<1>> x3; // OK, same as \tcode{Y<X<1> > x3;}

Y<X<6>>1>> x4; // syntax error

Y<X<(6>>1)>> x5; // OK

\end{codeblock}

\end{example}

The keyword \keyword{template} shall not appear immediately after

a declarative \grammarterm{nested-name-specifier}\iref{expr.prim.id.qual}.

The \grammarterm{constant-expression} of a \grammarterm{template-argument}

shall not be an unparenthesized \grammarterm{splice-expression}.

\begin{example}

\begin{codeblock}

template<int> struct S { };

constexpr int k = 5;

constexpr std::meta::info r = ^^k;

S<[:r:]> s1; // error: unparenthesized \grammarterm{splice-expression} used as template argument

S<([:r:])> s2; // OK

S<[:r:] + 1> s3; // OK

\end{codeblock}

\end{example}

A name prefixed by the keyword

\keyword{template}

shall be followed by a template argument list or

refer to a class template or an alias template.

The latter case is deprecated\iref{depr.template.template}.

The keyword \keyword{template} shall not appear immediately

before a \tcode{\~} token (as to name a destructor).

\begin{note}

The keyword

\keyword{template}

cannot be applied to non-template members of class templates.

\end{note}

\begin{note}

As is the case with the

\keyword{typename}

prefix, the

\keyword{template}

prefix is well-formed

even when lookup for the name would already find a template.

\end{note}

\begin{example}

\begin{codeblock}

template <class T> struct A {

void f(int);

template <class U> void f(U);

};

template <class T> void f(T t) {

A<T> a;

a.template f<>(t); // OK, calls template

a.template f(t); // error: not a \grammarterm{template-id}

}

template <class T> struct B {

template <class T2> struct C { };

};

// deprecated: \tcode{T::C} is assumed to name a class template:

template <class T, template <class X> class TT = T::template C> struct D { };

D<B<int> > db;

\end{codeblock}

\end{example}

A \grammarterm{template-id} or \grammarterm{splice-specialization-specifier}

is \defnx{valid}{\idxgram{template-id}!valid} if

\begin{itemize}

there are at most as many arguments as there are parameters

or a parameter is a template parameter pack\iref{temp.variadic},

there is an argument for each non-deducible non-pack parameter

that does not have a default \grammarterm{template-argument},

each \grammarterm{template-argument} matches the corresponding

template parameter\iref{temp.arg},

substitution of each template argument into the following

template parameters (if any) succeeds, and

if the \grammarterm{template-id} or

\grammarterm{splice-specialization-specifier} is non-dependent,

the associated constraints are satisfied as specified in the next paragraph.

\end{itemize}

A \grammarterm{simple-template-id} or

\grammarterm{splice-specialization-specifier}

shall be valid unless its respective

\grammarterm{template-name} or \grammarterm{splice-specifier}

names or designates a function template\iref{temp.deduct}.

\begin{example}

\begin{codeblock}

template<class T, T::type n = 0> class X;

struct S {

using type = int;

};

using T1 = X<S, int, int>; // error: too many arguments

using T2 = X<>; // error: no default argument for first template parameter

using T3 = X<1>; // error: value \tcode{1} does not match type-parameter

using T4 = X<int>; // error: substitution failure for second template parameter

using T5 = X<S>; // OK

\end{codeblock}

\end{example}

When the \grammarterm{template-name}

of a \grammarterm{simple-template-id} or

the \grammarterm{splice-specifier}

of a \grammarterm{splice-specialization-specifier}

designates a constrained non-function template

or

a constrained template template parameter,

and

all \grammarterm{template-argument}{s}

in the \grammarterm{simple-template-id} or

\grammarterm{splice-specialization-specifier}

are non-dependent\iref{temp.dep.temp},

the associated constraints\iref{temp.constr.decl}

of the constrained template

shall be satisfied\iref{temp.constr.constr}.

\begin{example}

\begin{codeblock}

template<typename T> concept C1 = sizeof(T) != sizeof(int);

template<C1 T> struct S1 { };

template<C1 T> using Ptr = T*;

S1<int>* p; // error: constraints not satisfied

Ptr<int> p; // error: constraints not satisfied

template<typename T>

struct S2 { Ptr<int> x; }; // ill-formed, no diagnostic required

template<typename T>

struct S3 { Ptr<T> x; }; // OK, satisfaction is not required

S3<int> x; // error: constraints not satisfied

template<template<C1 T> class X>

struct S4 {

X<int> x; // ill-formed, no diagnostic required

};

template<typename T> concept C2 = sizeof(T) == 1;

template<C2 T> struct S { };

template struct S<char[2]>; // error: constraints not satisfied

template<> struct S<char[2]> { }; // error: constraints not satisfied

\end{codeblock}

\end{example}

A \defn{concept-id} is a \grammarterm{simple-template-id}

where the \grammarterm{template-name} is a \grammarterm{concept-name}.

A concept-id is a prvalue of type \tcode{bool}, and

does not name a template specialization.

A concept-id evaluates to \tcode{true}

if the concept's

normalized \grammarterm{constraint-expression}\iref{temp.constr.decl}

is satisfied\iref{temp.constr.constr} by the specified template arguments and

\tcode{false} otherwise.

\begin{note}

Since a \grammarterm{constraint-expression} is an unevaluated operand,

a concept-id appearing in a \grammarterm{constraint-expression}

is not evaluated except as necessary

to determine whether the normalized constraints are satisfied.

\end{note}

\begin{example}

\begin{codeblock}