\rSec0[temp]{Templates}%

\indextext{template|(}

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

\indextext{type generator|see{template}}

A \term{template} defines a family of classes or functions 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}

\enternote The \tcode{>} token following the

\nonterminal{template-parameter-list} of a

\nonterminal{template-declaration}

may be the product of replacing a

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

tokens~(\ref{temp.names}).\exitnote

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

\indextext{template!variable}%

\indextext{template!static data member}%

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

\term{static data member template}.

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

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

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

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 C or 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}).

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.

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.

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}

\enternote The \tcode{>} token following the

\nonterminal{template-parameter-list} of a

\nonterminal{type-parameter}

may be the product of replacing a

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

tokens~(\ref{temp.names}).\exitnote

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

\grammarterm{non-type parameter}

and

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

class T { /* ... */ };

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

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.

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

For example,

\begin{codeblock}

template<class T> class myarray { /* ... */ };

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

class Map {

C<K> key;

C<V> value;

};

\end{codeblock}

A non-type

\grammarterm{template-parameter}

shall have one of the following (optionally

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

\end{itemize}

Other types are disallowed either explicitly below or implicitly by

the rules governing the form of

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

The top-level

\grammarterm{cv-qualifiers}

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

A non-type

\grammarterm{template-parameter}

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

\begin{codeblock}

template<double d> class X; // error

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

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

\end{codeblock}

A non-type

\grammarterm{template-parameter}

of type ``array of

or ``function returning

is adjusted to be of type

or ``pointer to function returning

\tcode{T}'',

respectively.

\begin{codeblock}

template<int* a> struct R { /* ... */ };

template<int b[5]> struct S { /* ... */ };

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}

A

\term{default template-argument}

is a

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

\tcode{=}

in a

\grammarterm{template-parameter}.

A default

\grammarterm{tem\-plate-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 with a template

declaration or definition is obtained by merging the default arguments

from the definition (if in scope) and all declarations in scope in the

same way default function arguments are~(\ref{dcl.fct.default}).

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

If a

\grammarterm{template-parameter}

of a class 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 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

\grammarterm{parameter-type-list} of the function template or has a

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

\begin{codeblock}

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

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

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

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

\end{codeblock}

A

\grammarterm{template-parameter}

shall

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

\begin{codeblock}

template<class T = int> class X;

template<class T = int> class X { /*... */ }; // error

\end{codeblock}

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

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

class X { /* ... */ };

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

class Y { /* ... */ };

\end{codeblock}

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

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

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

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

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 \nonterminal{template-argument-list} and completes

the \nonterminal{template-id}. \enternote The second \tcode{>}

token produced by this replacement rule may terminate an enclosing

\nonterminal{template-id} construct or it may be part of a different

construct (e.g. a cast).\exitnote

\begin{codeblock}

template<int i> class X @\tcode{\{ /* ... */ \};}@

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

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

template<class T> class Y @\tcode{\{ /* ... */ \};}@

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}

When the name of a member template specialization appears after

\tcode{.}

or

\tcode{->}

in a

\grammarterm{postfix-expression}

or after a

\grammarterm{nested-name-specifier}

in a

\grammarterm{qualified-id},

and the

object expression of the

\grammarterm{postfix-expression}

is type-dependent

or

the \grammarterm{nested-name-specifier} in the

\grammarterm{qualified-id}

refers to a dependent type, but the name is not

a member of the current instantiation~(\ref{temp.dep.type}),

the member template name must be prefixed by the keyword

\tcode{template}.

Otherwise the name is assumed to name a non-template.

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

A name prefixed by the keyword

\tcode{template}

shall be a \grammarterm{template-id} or the name shall refer to a class template.

The keyword

\tcode{template}

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

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.

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

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

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

The name of a

\grammarterm{template-argument}

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

\grammarterm{template-argument}.

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.

\begin{codeblock}

template<class T> class X {

static T t;

};

class Y {

private:

struct S { /* ... */ };

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}

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

\begin{codeblock}

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

typename T<int>::S s;

};

template <class U> class B {

private:

struct S { /* ... */ };

};

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

\end{codeblock}

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

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

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.

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

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

If a declaration acquires a function type through a type dependent on a

\grammarterm{template-parameter}

and this causes a declaration that does not use the

syntactic form of a function declarator to have function type,

the program is ill-formed.

\begin{codeblock}

template<class T> struct A {

static T t;

};

typedef int function();

A<function> a; // ill-formed: would declare \tcode{A<function>::t}

// as a static member function

\end{codeblock}

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

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

\item a string literal~(\ref{lex.string}),

\item the result of a \tcode{typeid} expression~(\ref{expr.typeid}), or

\item a predefined \tcode{__func__} variable~(\ref{dcl.fct.def.general}).

\end{itemize}

If the \grammarterm{template-argument}

represents a set of overloaded functions

(or a pointer or member pointer to such),

the matching function is selected from the set~(\ref{over.over}).

\begin{codeblock}

template<const int* pci> struct X { /* ... */ };

int ai[10];

X<ai> xi; // array to pointer and qualification conversions

struct Y { /* ... */ };