%!TEX root = std.tex

\rSec0[temp]{Templates}%

\indextext{template|(}

\gramSec[gram.temp]{Templates}

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

\indextext{type generator|see{template}}

\rSec1[temp.pre]{Preamble}

\pnum

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}

\pnum

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}

\pnum

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}

\pnum

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

\pnum

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.

\pnum

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

\pnum

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

\end{note}

\pnum

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

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.

\pnum

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}

\pnum

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}

\pnum

The syntax for

\grammarterm{template-parameter}{s}

is:

\begin{bnf}

\nontermdef{template-parameter}\br

type-parameter\br

parameter-declaration

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

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

template-head type-parameter-key \opt{identifier} \terminal{=} id-expression

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

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

can be the product of replacing a

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

tokens\iref{temp.names}.

\end{note}

\pnum

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 non-type

\begin{footnote}

Since template

\grammarterm{template-parameter}{s}

and template

\grammarterm{template-argument}{s}

are treated as types for descriptive purposes, the terms

\term{non-type parameter}

and

\term{non-type argument}

are used to refer to non-type, non-template parameters and arguments.

\end{footnote}

\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 \grammarterm{type-parameter}

called \tcode{T}, rather than an unnamed non-type

\grammarterm{template-parameter} of class \tcode{T}.

\end{example}

A \grammarterm{template-parameter} declaration shall not

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

Types shall not be defined in a \grammarterm{template-parameter}

declaration.

\pnum

The \grammarterm{identifier} in a \grammarterm{type-parameter} is not looked up.

A \grammarterm{type-parameter}

whose \grammarterm{identifier} does not follow an ellipsis

defines its

\grammarterm{identifier}

to be a

\grammarterm{typedef-name}

(if declared without

\keyword{template})

or

\grammarterm{template-name}

(if declared with

\keyword{template})

in the scope of the template declaration.

\begin{note}

A template argument can be a class template or alias template.

For example,

\begin{codeblock}

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

template<class K, class V, template<class T> class C = myarray>

class Map {

C<K> key;

C<V> value;

};

\end{codeblock}

\end{note}

\pnum

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$, $\cdots$, A$_n$>},

then let \tcode{E$'$} be \tcode{C<T, A$_1$, $\cdots$, 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}.

\pnum

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}

\pnum

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

\pnum

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

\item

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

\item

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

structural types or (possibly multidimensional) array thereof.

\end{itemize}

\end{itemize}

\pnum

An \grammarterm{id-expression} naming

a non-type \grammarterm{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 \grammarterm{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-type non-reference \grammarterm{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 \grammarterm{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}

\pnum

\begin{note}

A non-type

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

\pnum

A non-type

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

\pnum

A non-type 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}.

\pnum

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 \grammarterm{template-parameter} (type, non-type, template)

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.

\pnum

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}

\pnum

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

be a template parameter pack.

If a \grammarterm{template-parameter} of

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

is a template parameter pack,

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

A template parameter pack of a function template

shall not be followed by another template parameter

unless that template parameter can be deduced 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}%

\pnum

When parsing a default template argument

for a non-type \grammarterm{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}

\pnum

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}

\pnum

If a \grammarterm{template-parameter} is a

\grammarterm{type-parameter} with an ellipsis prior to its

optional \grammarterm{identifier} or is a

\grammarterm{parameter-declaration} that declares a

pack\iref{dcl.fct}, then the \grammarterm{template-parameter}

is 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 \grammarterm{type-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 non-type 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 non-type 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}

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

\pnum

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

id-expression\br

braced-init-list

\end{bnf}

\pnum

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

\pnum

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

a \grammarterm{template-argument-list}

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

\begin{itemize}

\item

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

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

in a class member access expression, or

\item

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

finds any declaration of a template, or

\item

that is an unqualified name

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

\item

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}

\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

}

\end{codeblock}

\end{example}

\pnum

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

\begin{note}

The second \tcode{>}

token produced by this replacement rule can terminate an enclosing

\grammarterm{template-id} 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}

\pnum

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

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

\pnum

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}

\pnum

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

\begin{itemize}

\item

there are at most as many arguments as there are parameters

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

\item

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

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

\item

each \grammarterm{template-argument} matches the corresponding

\grammarterm{template-parameter}\iref{temp.arg},

\item

substitution of each template argument into the following

template parameters (if any) succeeds, and

\item

if the \grammarterm{template-id} is non-dependent,

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

\end{itemize}

A \grammarterm{simple-template-id} shall be valid unless it names a

function template specialization\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}

\pnum

When the \grammarterm{template-name}

of a \grammarterm{simple-template-id}

names a constrained non-function template

or

a constrained template \grammarterm{template-parameter},

and

all \grammarterm{template-argument}{s}

in the \grammarterm{simple-template-id}

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}

\pnum

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}

template<typename T> concept C = true;

static_assert(C<int>); // OK

\end{codeblock}

\end{example}

\rSec1[temp.arg]{Template arguments}

\rSec2[temp.arg.general]{General}

\pnum

\indextext{argument!template}%

There are three forms of

\grammarterm{template-argument},

corresponding to the three forms of

\grammarterm{template-parameter}:

type, non-type and template.

The type and form of each

\grammarterm{template-argument}

specified in a

\grammarterm{template-id}

shall match the type and form specified for the corresponding

parameter declared by the template in its

\grammarterm{template-parameter-list}.

When the parameter declared by the template is a template

parameter pack\iref{temp.variadic}, it will correspond to zero or more

\grammarterm{template-argument}{s}.

\begin{example}

\begin{codeblock}

template<class T> class Array {

T* v;

int sz;

public:

explicit Array(int);

T& operator[](int);

T& elem(int i) { return v[i]; }

};

Array<int> v1(20);

typedef std::complex<double> dcomplex; // \tcode{std::complex} is a standard library template

Array<dcomplex> v2(30);

Array<dcomplex> v3(40);

void bar() {

v1[3] = 7;

v2[3] = v3.elem(4) = dcomplex(7,8);

}

\end{codeblock}

\end{example}

\pnum

The template argument list of a \grammarterm{template-head} is

a template argument list in which the $n^\text{th}$ template argument

has the value of

the $n^\text{th}$ template parameter of the \grammarterm{template-head}.

If the $n^\text{th}$ template parameter is

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

the $n^\text{th}$ template argument is a pack expansion

whose pattern is the name of the template parameter pack.

\pnum

In a

\grammarterm{template-argument},

an ambiguity between a

\grammarterm{type-id}

and an expression is resolved to a

\grammarterm{type-id},

regardless of the form of the corresponding

\grammarterm{template-parameter}.

\begin{footnote}

There is no such ambiguity in a default

\grammarterm{template-argument}

because the form of the

\grammarterm{template-parameter}

determines the allowable forms of the

\grammarterm{template-argument}.

\end{footnote}

\begin{example}

\begin{codeblock}

template<class T> void f();

template<int I> void f();

void g() {

f<int()>(); // \tcode{int()} is a type-id: call the first \tcode{f()}

}

\end{codeblock}

\end{example}

\pnum

\begin{note}

Names used in a \grammarterm{template-argument}

are subject to access control where they appear.

Because a \grammarterm{template-parameter} is not a class member,

no access control applies.

\end{note}

\begin{example}

\begin{codeblock}

template<class T> class X {

static T t;

};

class Y {

private:

struct S { @\commentellip@ };