%!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{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}

\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 storage class shall not be specified in a

\grammarterm{template-parameter}

declaration.

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

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 multi-dimensional) 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},

whose value is that of the corresponding template argument

after it has been converted

to the type of the \grammarterm{template-parameter}.

All such template parameters in the program of the same type

with the same value denote the same template parameter object.

A template parameter object shall have constant destruction\iref{expr.const}.

\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

\defnx{default template-argument}{\idxgram{template-argument}!default}

is a

\grammarterm{template-argument}\iref{temp.arg} specified after

\tcode{=}

in a

\grammarterm{template-parameter}.

A default

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

\grammarterm{template-argument}

may be specified in a template declaration.

A default

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

\grammarterm{template-argument}

shall not be specified in a friend class template declaration.

If a friend function template declaration $D$

specifies a default \grammarterm{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

\grammarterm{template-argument}{s}

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

\grammarterm{template-argument},

each subsequent

\grammarterm{template-parameter}

shall either have a default

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

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

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

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

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();