\rSec0[temp]{Templates}%

\indextext{template|(}

\gramSec[gram.temp]{Templates}

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

\indextext{type generator|see{template}}

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

family of types.

\indextext{\idxcode{template}}%

\begin{bnf}

\nontermdef{template-declaration}\br

\terminal{template <} template-parameter-list \terminal{>} declaration

\end{bnf}

\begin{bnf}

\nontermdef{template-parameter-list}\br

template-parameter\br

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

\end{bnf}

\begin{note} The \tcode{>} token following the

\grammarterm{template-parameter-list} of a

\grammarterm{template-declaration}

may be the product of replacing a

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

tokens~(\ref{temp.names}).\end{note}

The

\grammarterm{declaration}

in a

\grammarterm{template-declaration}

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}

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

\indextext{template!definition of}%

A \grammarterm{template-declaration} is also a definition

if its \grammarterm{declaration} defines a function, a class, a variable, or a

static data member. 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 pauli<T> sigma1 = { { 0, 1 }, { 1, 0 } };

template<class T>

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

template<class T>

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

};

\end{codeblock}

\end{example}

A

\grammarterm{template-declaration}

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

In a function template declaration, the last component of the

\grammarterm{declarator-id}

shall not be a

\grammarterm{template-id}.

\begin{note}

That last component may be an \grammarterm{identifier}, an \grammarterm{operator-function-id},

a \grammarterm{conversion-function-id}, or a \grammarterm{literal-operator-id}. In

a class template declaration, if the

class name

is a

\grammarterm{simple-template-id},

the declaration declares a class template partial specialization~(\ref{temp.class.spec}).

\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 template name has linkage~(\ref{basic.link}).

Specializations (explicit or implicit) of

a template that has internal linkage are

distinct from all specializations in other translation

units.

A template, a template explicit specialization~(\ref{temp.expl.spec}), and a class

template partial specialization shall not have C linkage. Use of a linkage specification

other than \tcode{"C"} or \tcode{"C++"} with any of these constructs is

conditionally-supported, with

\impldef{semantics of linkage specification on templates} semantics.

Template definitions shall obey the one-definition rule~(\ref{basic.def.odr}).

\begin{note}

Default arguments for function templates and for member functions of

class templates are considered definitions for the purpose of template

instantiation~(\ref{temp.decls}) and must also obey the one-definition rule.

\end{note}

A class template shall not have the same name as any other

template, class, function, variable, enumeration, enumerator, namespace, or

type in the same scope~(\ref{basic.scope}), except as specified in~\ref{temp.class.spec}.

Except that a function template can be overloaded either by non-template

functions~(\ref{dcl.fct}) with the same name or by other function templates

with the same name~(\ref{temp.over}),

a template name declared in namespace scope or in class scope shall be unique

in that scope.

\indextext{entity!templated}%

A \defn{templated entity} is

\begin{itemize}

\item a template,

\item an entity defined~(\ref{basic.def}) or created~(\ref{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}~(\ref{expr.prim.lambda.closure})

appearing in the declaration of a templated entity.

\end{itemize}

\begin{note}

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

templated entity is a templated entity.

\end{note}

A function template, member function of a class template, variable template,

or static data

member of a class template shall be defined in every translation unit in

which it is implicitly instantiated~(\ref{temp.inst}) unless the

corresponding specialization is explicitly instantiated~(\ref{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

\end{bnf}

\begin{bnf}

\nontermdef{type-parameter}\br

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

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

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

\terminal{template <} template-parameter-list \terminal{>} type-parameter-key identifier\opt{} \terminal{=} id-expression

\end{bnf}

\begin{bnf}

\nontermdef{type-parameter-key}\br

\terminal{class}\br

\terminal{typename}

\end{bnf}

\begin{note} The \tcode{>} token following the

\grammarterm{template-parameter-list} of a

\grammarterm{type-parameter}

may be the product of replacing a

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

tokens~(\ref{temp.names}).\end{note}

There is no semantic difference between

\tcode{class}

and

\tcode{typename}

in a

\grammarterm{type-parameter-key}.

\tcode{typename}

followed by an

\grammarterm{unqualified-id}

names a template type parameter.

\tcode{typename}

followed by a

\grammarterm{qualified-id}

denotes the type in a non-type%

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

\grammarterm{parameter-declaration}.

A \grammarterm{template-parameter} of the form

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

A

\grammarterm{type-parameter}

whose identifier does not follow an ellipsis

defines its

\grammarterm{identifier}

to be a

\grammarterm{typedef-name}

(if declared without

\tcode{template})

or

\grammarterm{template-name}

(if declared with

\tcode{template})

in the scope of the template declaration.

\begin{note}

A template argument may 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}

A non-type

\grammarterm{template-parameter}

shall have one of the following (optionally

cv-qualified)

types:

\begin{itemize}

\item integral or enumeration type,

\item pointer to object or pointer to function,

\item lvalue reference to object or lvalue reference to function,

\item pointer to member,

\item \tcode{std::nullptr_t}, or

\item a type that contains a placeholder type~(\ref{dcl.spec.auto}).

\end{itemize}

\begin{note}

Other types are disallowed either explicitly below or implicitly by

the rules governing the form of

\grammarterm{template-argument}{s}~(\ref{temp.arg}).

\end{note}

The top-level

\grammarterm{cv-qualifier}{s}

on the

\grammarterm{template-parameter}

are ignored when determining its type.

A non-type non-reference

\grammarterm{template-parameter}

is a prvalue.

It shall not be assigned to or in any other way have its value changed.

A non-type non-reference

\grammarterm{template-parameter}

cannot have its address taken.

When a non-type non-reference

\grammarterm{template-parameter}

is used as an initializer for a reference, a temporary is always used.

\begin{example}

\begin{codeblock}

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

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

&x; // OK

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

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

const int& cri = i; // OK: const reference bound to temporary

}

\end{codeblock}

\end{example}

A non-type

\grammarterm{template-parameter}

shall not be declared to have floating-point, class, or void type.

\begin{example}

\begin{codeblock}

template<double d> class X; // error

template<double* pd> class Y; // OK

template<double& rd> class Z; // OK

\end{codeblock}

\end{example}

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}

A

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

is a

\grammarterm{template-argument}~(\ref{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~(\ref{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

specifies a default

\grammarterm{template-argument},

that declaration shall be a definition and shall be the only declaration of

the function template in the translation unit.

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

\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~(\ref{dcl.fct}) of the function template or has a

default argument~(\ref{temp.deduct}).

A template parameter of a deduction guide template (\ref{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}

A

\grammarterm{template-parameter}

shall

not be given default arguments by two different declarations in the same scope.

\begin{example}

\begin{codeblock}

template<class T = int> class X;

template<class T = int> class X { @\commentellip@ }; // error

\end{codeblock}

\end{example}

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

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}

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 <class T = float> struct B {};

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}

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 parameter

pack~(\ref{dcl.fct}), then the \grammarterm{template-parameter}

is a template parameter pack~(\ref{temp.variadic}).

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

contains one or more unexpanded parameter 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

parameter packs is a pack expansion. A template parameter pack that is a pack

expansion shall not expand a parameter pack declared in the same

\grammarterm{template-parameter-list}.

\begin{example}

\begin{codeblock}

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

// but not a pack expansion

template <class T, int... Dims> struct multi_array; // \tcode{Dims} is a non-type template parameter pack

// 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> struct static_array;// error: \tcode{Values} expands template type parameter

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

\end{codeblock}

\end{example}

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

A template specialization~(\ref{temp.spec}) can be referred to by a

\grammarterm{template-id}:

\begin{bnf}

\nontermdef{simple-template-id}\br

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

\end{bnf}

\begin{bnf}

\nontermdef{template-id}\br

simple-template-id\br

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

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

\end{bnf}

\begin{bnf}

\nontermdef{template-name}\br

identifier

\end{bnf}

\begin{bnf}

\nontermdef{template-argument-list}\br

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

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

\end{bnf}

\begin{bnf}

\nontermdef{template-argument}\br

constant-expression\br

type-id\br

id-expression

\end{bnf}

\begin{note}

The name lookup rules~(\ref{basic.lookup}) are used to associate the use of

a name with a template declaration;

that is, to identify a name as a

\grammarterm{template-name}.

\end{note}

For a

\grammarterm{template-name}

to be explicitly qualified by the template arguments,

the name must be known to refer to a template.

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

After name lookup~(\ref{basic.lookup}) finds that a name is a

\grammarterm{template-name}

or that an \grammarterm{operator-function-id} or a \grammarterm{literal-operator-id} refers to a set of

overloaded functions any member of which is a function template,

if this is followed by a

\tcode{<},

the

\tcode{<}

is always taken as the delimiter of a

\grammarterm{template-argument-list}

and never as the less-than operator.

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

the first non-nested

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

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

or \tcode{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.

}

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 may terminate an enclosing

\grammarterm{template-id} construct or it may 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 \tcode{template} is said to appear at the top level in

a \grammarterm{qualified-id}

if it appears outside of a \grammarterm{template-argument-list} or

\grammarterm{decltype-specifier}.

In a \grammarterm{qualified-id} of a \grammarterm{declarator-id} or

in a \grammarterm{qualified-id} formed by a \grammarterm{class-head-name} (Clause~\ref{class}) or

\grammarterm{enum-head-name}~(\ref{dcl.enum}),

the keyword \tcode{template} shall not appear at the top level.

In a \grammarterm{qualified-id} used as the name in a

\grammarterm{typename-specifier}~(\ref{temp.res}),

\grammarterm{elaborated-type-specifier}~(\ref{dcl.type.elab}),

\grammarterm{using-declaration}~(\ref{namespace.udecl}), or

\grammarterm{class-or-decltype} (Clause~\ref{class.derived}),

an optional keyword \tcode{template} appearing at the top level is ignored.

In these contexts, a \tcode{<} token is always assumed to introduce a

\grammarterm{template-argument-list}.

In all other contexts, when naming a template specialization of

a member of an unknown specialization~(\ref{temp.dep.type}),

the member template name shall be prefixed by the keyword \tcode{template}.

\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>(); // ill-formed: \tcode{<} means less than

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

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

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

}

\end{codeblock}

\end{example}

A name prefixed by the keyword

\tcode{template}

shall be a \grammarterm{template-id} or

the name shall refer to a class template or an alias template.

\begin{note}

The keyword

\tcode{template}

may not be applied to non-template members of class templates.

\end{note}

\begin{note}

As is the case with the

\tcode{typename}

prefix, the

\tcode{template}

prefix is allowed in cases where it is not strictly

necessary; i.e., when the \grammarterm{nested-name-specifier} or

the expression on the left of

the

\tcode{->}

or

\tcode{.}

is not dependent on a

\grammarterm{template-parameter}, or the use does not appear in the

scope of 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 { };

};

// OK: \tcode{T::template C} names a class template:

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

D<B<int> > db;

\end{codeblock}

\end{example}

\indextext{specialization!class template}%

A

\grammarterm{simple-template-id}

that names a class template specialization is a

\grammarterm{class-name}

(Clause~\ref{class}).

A \grammarterm{template-id} that names an alias template

specialization is a \grammarterm{type-name}.

\rSec1[temp.arg]{Template arguments}

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

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

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

The name of a

\grammarterm{template-argument}

shall be accessible at the point where it is used as a

\grammarterm{template-argument}.

\begin{note}

If the name of the

\grammarterm{template-argument}

is accessible at the point where it is used as a

\grammarterm{template-argument},

there is no further access restriction in the resulting instantiation where the

corresponding

\grammarterm{template-parameter}

name is used.

\end{note}

\begin{example}

\begin{codeblock}

template<class T> class X {

static T t;

};

class Y {

private:

struct S { @\commentellip@ };

X<S> x; // OK: \tcode{S} is accessible

// \tcode{X<Y::S>} has a static member of type \tcode{Y::S}

// OK: even though \tcode{Y::S} is private

};

X<Y::S> y; // error: \tcode{S} not accessible

\end{codeblock}

\end{example}

For a

\grammarterm{template-argument}

that is a class type or a class template, the template

definition has no special access rights to the

members of the \grammarterm{template-argument}. \begin{example}

\begin{codeblock}

template <template <class TT> class T> class A {

typename T<int>::S s;

};

template <class U> class B {

private:

struct S { @\commentellip@ };

};

A<B> b; // ill-formed: \tcode{A} has no access to \tcode{B::S}

\end{codeblock}

\end{example}

When template argument packs or default

\grammarterm{template-argument}{s}

are used, a

\grammarterm{template-argument}

list can be empty.

In that case the empty

\tcode{<>}

brackets shall still be used as the

\grammarterm{template-argument-list}.

\begin{example}

\begin{codeblock}

template<class T = char> class String;

String<>* p; // OK: \tcode{String<char>}

String* q; // syntax error

template<class ... Elements> class Tuple;

Tuple<>* t; // OK: \tcode{Elements} is empty

Tuple* u; // syntax error

\end{codeblock}

\end{example}

An explicit destructor call~(\ref{class.dtor}) for an object that has a type

that is a class template specialization may explicitly specify the

\grammarterm{template-argument}{s}.

\begin{example}

\begin{codeblock}

template<class T> struct A {

~A();

};

void f(A<int>* p, A<int>* q) {

p->A<int>::~A(); // OK: destructor call

q->A<int>::~A<int>(); // OK: destructor call

}

\end{codeblock}

\end{example}

If the use of a

\grammarterm{template-argument}

gives rise to an ill-formed construct in the instantiation of a

template specialization, the program is ill-formed.

When the template in a

\grammarterm{template-id}

is an overloaded function template, both non-template functions in the overload

set and function templates in the overload set for

which the

\grammarterm{template-argument}{s}

do not match the

\grammarterm{template-parameter}{s}

are ignored.

If none of the function templates have matching

\grammarterm{template-parameter}{s},

the program is ill-formed.

When a \grammarterm{simple-template-id} does not name a function,

a default \grammarterm{template-argument} is

implicitly instantiated~(\ref{temp.inst})

when the value of that default argument is needed.

\begin{example}

\begin{codeblock}

template<typename T, typename U = int> struct S { };

S<bool>* p; // the type of \tcode{p} is \tcode{S<bool, int>*}

\end{codeblock}

The default argument for \tcode{U} is instantiated to form the type \tcode{S<bool, int>*}.

\end{example}

A \grammarterm{template-argument} followed by an ellipsis is

a pack expansion~(\ref{temp.variadic}).

\rSec2[temp.arg.type]{Template type arguments}

A

\grammarterm{template-argument}

for a

\grammarterm{template-parameter}

which is a type

shall be a

\grammarterm{type-id}.

\begin{example}

\begin{codeblock}

template <class T> class X { };

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

struct { } unnamed_obj;

void f() {

struct A { };

enum { e1 };

typedef struct { } B;

B b;

X<A> x1; // OK

X<A*> x2; // OK

X<B> x3; // OK

f(e1); // OK

f(unnamed_obj); // OK

f(b); // OK

}

\end{codeblock}

\end{example}

\begin{note}

A template type argument may be an incomplete type~(\ref{basic.types}).

\end{note}

\rSec2[temp.arg.nontype]{Template non-type arguments}

If the type of a \grammarterm{template-parameter}

contains a placeholder type~(\ref{dcl.spec.auto}, \ref{temp.param}),

the deduced parameter type is determined

from the type of the \grammarterm{template-argument}

by placeholder type deduction~(\ref{dcl.type.auto.deduct}).

If a deduced parameter type is not permitted

for a \grammarterm{template-parameter} declaration~(\ref{temp.param}),

the program is ill-formed.

A

\grammarterm{template-argument}

for a non-type

\grammarterm{template-parameter}

shall be

a converted

constant expression~(\ref{expr.const})

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

For a non-type \grammarterm{template-parameter} of reference or pointer type,

the value of the constant expression shall not refer to

(or for a pointer type, shall not be the address of):

\begin{itemize}

\item a subobject~(\ref{intro.object}),

\item a temporary object~(\ref{class.temporary}),