______________________________________________________________________
14 Templates [temp]
______________________________________________________________________
1 A class template defines the layout and operations for an unbounded
set of related types. [Example: a single class template List might
provide a common definition for list of int, list of float, and list
of pointers to Shapes. ] A function template defines an unbounded set
of related functions. [Example: a single function template sort()
might provide a common definition for sorting all the types defined by
the List class template. ]
2 A template defines a family of types or functions.
template-declaration:
template < template-parameter-list > declaration
template-parameter-list:
template-parameter
template-parameter-list , template-parameter
The declaration in a template-declaration shall declare or define a
function or a class, define a static data member of a template class,
or define a template member of a class. A template-declaration is a
declaration. A template-declaration is a definition (also) if its
declaration defines a function, a class, or a static data member of a
template class. There shall be exactly one definition for each tem
plate in a program. [Note: there can be many declarations. ] How
ever, if the multiple definitions are in different translation units,
the behavior is undefined (and no diagnostic is required).
+------- BEGIN BOX 1 -------+
This - and all other requirements for unique definitions of templates
in this clause - will have to be rephrased to take the ODR into
account when the ODR is completely defined.
+------- END BOX 1 -------+
3 The name of a template obeys the usual scope and access control rules.
A template-declaration can appear only as a global declaration, as a
member of a namespace, as a member of a class, or as a member of a
class template. A member template shall not be virtual. A destructor
shall not be a template. A local class shall not have a member tem
plate.
4 A template shall not have C linkage. If the linkage of a template is
something other than C or C++, the behavior is implementation-defined.
5 [Example: An array class template might be declared like this:
template<class T> class Array {
T* v;
int sz;
public:
explicit Array(int);
T& operator[](int);
T& elem(int i) { return v[i]; }
// ...
};
The prefix template <class T> specifies that a template is being
declared and that a type-name T will be used in the declaration. In
other words, Array is a parameterized type with T as its parameter. ]
6 [Note: a class template definition specifies how individual classes
can be constructed much as a class definition specifies how individual
objects can be constructed. ]
7 A member template can be defined within its class or separately.
[Example:
template<class T> class string {
public:
template<class T2> int compare(const T2&);
template<class T2> string(const string<T2>& s) { /* ... */ }
// ...
};
template<class T> template<class T2> int string<T>::compare(const T2& s)
{
// ...
}
--end example]
14.1 Template names [temp.names]
1 A template can be referred to by a template-id:
template-id:
template-name < template-argument-list >
template-name:
identifier
template-argument-list:
template-argument
template-argument-list , template-argument
template-argument:
assignment-expression
type-id
template-name
2 A template-id that names a template class is a class-name (_class_).
3 A template-id that names a defined template class can be used exactly
like the names of other defined classes. [Example:
Array<int> v(10);
Array<int>* p = &v;
--end example] [Note: template-ids that name functions are discussed
in _temp.fct_. ]
4 A template-id that names a template class that has been declared but
not defined can be used exactly like the names of other declared but
undefined classes. [Example:
template<class T> class X; // X is a class template
X<int>* p; // ok: pointer to declared class X<int>
X<int> x; // error: object of undefined class X<int>
--end example]
5 The name of a template followed by a < is always taken as the begin
ning of a template-id and never as a name followed by the less-than
operator. Similarly, the first non-nested > is taken as the end of
the template-argument-list rather than a greater-than operator.
[Example:
template<int i> class X { /* ... */ }
X< 1>2 >x1; // syntax error
X<(1>2)>x2; // ok
template<class T> class Y { /* ... */ }
Y< X<1> > x3; // ok
--end example]
6 The name of a class template shall not be declared to refer to any
other template, class, function, object, enumeration, enumerator,
namespace, value, or type in the same scope. Unless explicitly speci
fied to have internal linkage, a template in namespace scope has
external linkage (_basic.link_). A global template name shall be
unique in a program.
7 In a template-argument, an ambiguity between a type-id and an expres
sion is resolved to a type-id. [Example:
template<class T> void f();
template<int I> void f();
void g()
{
f<int()>(); // ``int()'' is a type-id: call the first f()
}
--end example]
14.2 Name resolution [temp.res]
1 A name used in a template is assumed not to name a type unless it has
been explicitly declared to refer to a type in the context enclosing
the template declaration or is qualified by the keyword typename.
[Example:
// no B declared here
class X;
template<class T> class Y {
class Z; // forward declaration of member class
void f() {
X* a1; // declare pointer to X
T* a2; // declare pointer to T
Y* a3; // declare pointer to Y
Z* a4; // declare pointer to Z
typedef typename T::A TA;
TA* a5; // declare pointer to T's A
typename T::A* a6; // declare pointer to T's A
T::A* a7; // T::A is not a type name:
// multiply T::A by a7
B* a8; // B is not a type name:
// multiply B by a8
}
};
--end example]
2 In a template, any use of a qualified-name where the qualifier depends
on a template-parameter can be prefixed by the keyword typename to
indicate that the qualified-name denotes a type.
elaborated-type-specifier:
...
typename ::opt nested-name-specifier identifier full-template-argument-listopt
full-template-argument-list:
< template-argument-list >
3 If a specialization of that template is generated for a template-
argument such that the qualified-name does not denote a type, the spe
cialization is ill-formed. The keyword typename states that the fol
lowing qualified-name names a type. [Note: but gives no clue to what
that type might be. ] The qualified-name shall include a qualifier
containing a template parameter or a template class name.
4 Knowing which names are type names allows the syntax of every template
declaration to be checked. Syntax errors in a template declaration
can therefore be diagnosed at the point of the declaration exactly as
errors for non-template constructs. Other errors, such as type errors
involving template parameters, cannot be diagnosed until later; such
errors shall be diagnosed at the point of instantiation or at the
point where member functions are generated (_temp.inst_). Errors that
can be diagnosed at the point of a template declaration shall be diag
nosed there or later together with the dependent type errors. [Exam
ple:
template<class T> class X {
// ...
void f(T t, int i, char* p)
{
t = i; // typecheck at point of instantiation,
// or at function generation
p = i; // typecheck immediately at template declaration,
// at point of instantiation,
// or at function generation
}
};
--end example] No diagnostics shall be issued for a template defini
tion for which a valid specialization can be generated.
5 Three kinds of names can be used within a template definition:
--The name of the template itself, the names of the template-
parameters (_temp.param_), and names declared within the template
itself.
--Names from the scope of the template definition.
--Names dependent on a template-argument (_temp.arg_) from the scope
of a template instantiation.
6 [Example:
#include <iostream>
using namespace std;
template<class T> class Set {
T* p;
int cnt;
public:
Set();
Set<T>(const Set<T>&);
void printall()
{
for (int i = 0; i<cnt; i++)
cout << p[i] << '\n';
}
// ...
};
--end example] When looking for the declaration of a name used in a
template definition the usual lookup rules (_class.scope0_) are first
applied. [Note: in the example, i is the local variable i declared in
printall, cnt is the member cnt declared in Set, and cout is the stan
dard output stream declared in iostream. However, not every declara
tion can be found this way; the resolution of some names must be post
poned until the actual template-argument is known. For example, even
though the name operator<< is known within the definition of sum() an
a declaration of it can be found in <iostream>, the actual declaration
of operator<< needed to print p[i] cannot be known until it is known
what type T is (_temp.dep_). ]
7 If a name can be bound at the point of the template definition and it
is not a function called in a way that depends on a template-parameter
(as defined in _temp.dep_), it will be bound at the template defini
tion point and the binding is not affected by later declarations.
[Example:
void f(char);
template<class T> void g(T t)
{
f(1); // f(char)
f(T(1)); // dependent
f(t); // dependent
}
void f(int);
void h()
{
g(2); // will cause one call of f(char) followed
// by two calls of f(int)
g('a'); // will cause three calls of f(char)
}
--end example]
14.2.1 Locally declared names [temp.local]
1 Within the scope of a class template or a specialization of a template
the name of the template is equivalent to the name of the template
followed by the template-parameters enclosed in <>. [Example: the
constructor for Set can be referred to as Set() or Set<T>(). ] Other
specializations (_temp.spec_) of the class can be referred to by
explicitly qualifying the template name with appropriate template-
arguments. [Example:
template<class T> class X {
X* p; // meaning X<T>
X<T>* p2;
X<int>* p3;
};
template<class T> class Y;
class Y<int> {
Y* p; // meaning Y<int>
};
--end example] [Note: see _temp.param_ for the scope of template-
parameters. ]
2 A template type-parameter can be used in an elaborated-type-specifier.
[Example:
template<class T> class A {
friend class T;
class T* p;
class T; // error: redeclaration of template parameter T
// (a name declaration, not an elaboration)
// ...
}
--end example]
3 However, a specialization of a template for which a type-parameter
used this way is not in agreement with the elaborated-type-specifier
(_dcl.type_) is ill-formed. [Example:
class C { /* ... */ };
struct S { /* ... */ };
union U { /* ... */ };
enum E { /* ... */ };
A<C> ac; // ok
A<S> as; // ok
A<U> au; // error: parameter T elaborated as a class,
// but the argument supplied for T is a union
A<int> ai; // error: parameter T elaborated as a class,
// but the argument supplied for T is an int
A<E> ae; // error: parameter T elaborated as a class,
// but the argument supplied for T is an enumeration
--end example]
14.2.2 Names from the template's enclosing scope [temp.encl]
1 If a name used in a template isn't defined in the template definition
itself, names declared in the scope enclosing the template are consid
ered. If the name used is found there, the name used refers to the
name in the enclosing context. [Example:
void g(double);
void h();
template<class T> class Z {
public:
void f() {
g(1); // calls g(double)
h++; // error: cannot increment function
}
};
void g(int); // not in scope at the point of the template
// definition, not considered for the call g(1)
--end example] [Note: a template definition behaves exactly like
other definitions. ] [Example:
void g(double);
void h();
class ZZ {
public:
void f() {
g(1); // calls g(double)
h++; // error: cannot increment function
}
};
void g(int); // not in scope at the point of class ZZ
// definition, not considered for the call g(1)
--end example]
14.2.3 Dependent names [temp.dep]
1 Some names used in a template are neither known at the point of the
template definition nor declared within the template definition. Such
names shall depend on a template-argument and shall be in scope at the
point of the template instantiation (_temp.inst_). [Example:
class Horse { /* ... */ };
ostream& operator<<(ostream&,const Horse&);
void hh(Set<Horse>& h)
{
h.printall();
}
In the call of Set<Horse>::printall(), the meaning of the << operator
used to print p[i] in the definition of Set<T>::printall()
(_temp.res_), is
operator<<(ostream&,const Horse&);
This function takes an argument of type Horse and is called from a
template with a template-parameter T for which the template-argument
is Horse. Because this function depends on a template-argument the
call is well-formed. ]
2 A function call depends on a template-argument if the call would have
a different resolution or no resolution if a type, template, or named
constant mentioned in the template-argument were missing from the pro
gram. [Example: some calls that depend on an argument type T are:
1)The function called has a parameter that depends on T according to
the type deduction rules (_temp.deduct_). For example: f(T),
f(Array<T>), and f(const T*).
2)The type of the actual argument depends on T. For example: f(T(1)),
f(t), f(g(t)), and f(&t) assuming that t has the type T.
3)A call is resolved by the use of a conversion to T without either an
argument or a parameter of the called function being of a type that
depended on T as specified in (1) and (2). For example:
struct B { };
struct T : B { };
struct X { operator T(); };
void f(B);
void g(X x)
{
f(x); // meaning f( B( x.operator T() ) )
// so the call f(x) depends on T
}
3 This ill-formed template instantiation uses a function that does not
depend on a template-argument:
template<class T> class Z {
public:
void f() {
g(1); // g() not found in Z's context.
// Look again at point of instantiation
}
};
void g(int);
void h(const Z<Horse>& x)
{
x.f(); // error: g(int) called by g(1) does not depend
// on template-parameter ``Horse''
}
The call x.f() gives raise to the specialization:
Z<Horse>::f() { g(1); }
The call g(1) would call g(int), but since that call in no way depends
on the template-argument Horse and because g(int) wasn't in scope at
the point of the definition of the template, the call x.f() is ill-
formed.
4 On the other hand:
void h(const Z<int>& y)
{
y.f(); // fine: g(int) called by g(1) depends
// on template-parameter ``int''
}
Here, the call y.f() gives raise to the specialization:
Z<int>::f() { g(1); }
The call g(1) calls g(int), and since that call depends on the tem
plate-argument int, the call y.f() is acceptable even though g(int)
wasn't in scope at the point of the template definition. ]
5 A name from a base class (of a non-dependent type) can hide the name
of a template-parameter. [Example:
struct A {
struct B { /* ... */ };
int a;
int Y;
};
template<class B, class a> struct X : A {
B b; // A's B
a b; // error: A's a isn't a type name
};
--end example]
6 However, a name from a template-argument cannot hide a name declared
within a template, a template-parameter, or a name from the template's
enclosing scopes. [Example:
int a;
template<class T> struct Y : T {
struct B { /* ... */ };
B b; // The B defined in Y
void f(int i) { a = i; } // the global a;
Y* p; // Y<T>
};
Y<A> ya;
The members A::B, A::a, and A::Y of the template argument A do not
affect the binding of names in Y<A>. ]
7 A name of a member can hide the name of a template-parameter. [Exam
ple:
template<class T> struct A {
struct B { /* ... */ };
void f();
};
template<class B> void A<B>::f()
{
B b; // A's B, not the template parameter
}
--end example]
14.2.4 Non-local names declared within a template [temp.inject]
1 Names that are not template members can be declared within a template
class or function. When a template is specialized, the names declared
in it are declared as if the specialization had been explicitly
declared at its point of instantiation. If a template is first spe
cialized as the result of use within a block or class, names declared
within the template shall be used only after the template use that
caused the specialization. [Example:
// Assume that Y is not yet declared
template<class T> class X {
friend class Y;
};
Y* py1; // ill-formed: Y is not in scope
// Here is the point of instantiation for X<C>
void g()
{
X<C>* pc; // does not cause instantiation
Y* py2; // ill-formed: Y is not in scope
X<C> c; // causes instantiation of X<C>, so
// names from X<C> can be used
// here on
Y* py3; // ok
}
Y* py4; // ok
--end example]
14.3 Template instantiation [temp.inst]
1 A class generated from a class template is called a generated class.
A function generated from a function template is called a generated
function. A static data member generated from a static data member
template is called a generated static data member. A class defined
with a template-id as its name is called an explicitly specialized
class. A function defined with a template-id as its name is called an
explicitly specialized function. A static data member defined with a
template-id as its name is called an explicitly specialized static
data member. A specialization is a class, function, or static data
member that is either generated or explicitly specialized.
2 [Note: the act of generating a class, function, or static data member
from a template is commonly referred to as template instantiation. ]
14.3.1 Template linkage [temp.linkage]
1 A function template has external linkage, as does a static member of a
class template. Every function template shall have the same defini
tion in every translation unit in which it appears.
14.3.2 Point of instantiation [temp.point]
1 The point of instantiation of a template is the point where names
dependent on the template-argument are bound. That point is immedi
ately before the declaration in the nearest enclosing global or names
pace scope containing the first use of the template requiring its def
inition. [Note: this implies that names used in a template definition
cannot be bound to local names or class member names from the scope of
the template use. They can, however, be bound to names of namespace
members. For example:
// void g(int); not declared here
template<class T> class Y {
public:
void f() { g(1); }
};
void k(const Y<int>& h)
{
void g(int);
h.f(); // error: g(int) called by g(1) not found
// local g() not considered
}
class C {
void g(int);
void m(const Y<int>& h)
{
h.f(); // error: g(int) called by g(1) not found
// C::g() not considered
}
};
namespace N {
void g(int);
void n(const Y<int>& h)
{
h.f(); // N::g(int) called by g(1)
}
}
--end note]
2 Names from both the namespace of the template itself and of the names
pace containing the point of instantiation of a specialization are
used to resolve names for the specialization. Overload resolution is
used to chose between functions with the same name in these two names
paces. [Example:
namespace NN {
void g(int);
void h(int);
template<class T> void f(T t)
{
g(t);
h(t);
k(t);
}
}
namespace MM {
void g(double);
void k(double);
// instantiation point for NN::f(int) and NN::f(double)
void m()
{
NN::f(1); // indirectly calls NN::g(int),
// NN::h, and MM::k.
NN::f(1.0); // indirectly calls MM::g(double),
// NN::h, and MM::k.
}
}
--end example] If a name is found in both namespaces and overload
resolution cannot resolve a use, the program is ill-formed.
3 Each translation unit in which the definition of a template is used in
a way that require definition of a specialization has a point of
instantiation for the template. If this causes names used in the tem
plate definition to bind to different names in different translation
units, the one-definition rule has been violated and any use of the
template is ill-formed. Such violation does not require a diagnostic.
4 A template can be either explicitly instantiated for a given argument
list or be implicitly instantiated. A template that has been used in
a way that require a specialization of its definition will have the
specialization implicitly generated unless it has either been explic
itly instantiated (_temp.explicit_) or explicitly specialized
(_temp.spec_). A specialization will not be implicitly generated
unless the definition of a template specialization is required.
[Example:
template<class T> class Z {
void f();
void g();
};
void h()
{
Z<int> a; // instantiation of class Z<int> required
Z<char>* p; // instantiation of class Z<char> not required
Z<double>* q; // instantiation of class Z<double> not required
a.f(); // instantiation of Z<int>::f() required
p->g(); // instantiation of class Z<char> required, and
// instantiation of Z<char>::g() required
}
Nothing in this example requires class Z<double>, Z<int>::g(), or
Z<char>::f() to be instantiated. ] An implementation shall not
instantiate a function or a class that does not require instantiation.
However, virtual functions can be instantiated for implementation pur
poses.
5 If a virtual function is instantiated, its point of instantiation is
immediately following the point of instantiation for its class.
6 The point of instantiation for a template used inside another template
and not instantiated previous to an instantiation of the enclosing
template is immediately before the point of instantiation of the
enclosing template. [Example:
namespace N {
template<class T> class List {
public:
T* get();
// ...
};
}
template<class K, class V> class Map {
List<V> lt;
V get(K);
// ...
};
void g(Map<char*,int>& m)
{
int i = m.get("Nicholas");
// ...
}
--end example] This allows instantiation of a used template to be
done before instantiation of its user.
7 Implicitly generated template classes, functions, and static data mem
bers are placed in the namespace where the template was defined.
[Example: a call of lt.get() from Map<char*,int>::get() would place
List<int>::get() in the namespace N rather than in the global names
pace. ]
+------- BEGIN BOX 2 -------+
Name injection from an implicitly generated template function special
ization are under debate. That is, it might be banned.
+------- END BOX 2 -------+
8 If a template for which a definition is in scope is used in a way that
involves overload resolution or conversion to a base class, the defi
nition of a template specialization is required. [Example:
template<class T> class B { /* ... */ };
template<class T> class D : public B<T> { /* ... */ };
void f(void*);
void f(B<int>*);
void g(D<int>* p, D<char>* pp)
{
f(p); // instantiation of D<int> required: call f(B<int>*)
B<char>* q = pp; // instantiation of D<char> required:
// convert D<char>* to B<char>*
}
--end example]
9 If an instantiation of a class template is required and the template
is declared but not defined, the program is ill-formed. [Example:
template<class T> class X;
X<char> ch; // error: definition of X required
--end example]
10Recursive instantiation is possible. [Example:
template<int i> int fac() { return i>1 ? i*fac<i-1>() : 1; }
int fac<0>() { return 1; }
int f()
{
return fac<17>();
}
--end example]
11There shall be an implementation quantity that specifies the limit on
the depth of recursive instantiations.
12The result of an infinite recursion in instantiation is undefined. In
particular, an implementation is allowed to report an infinite recur
sion as being ill-formed. [Example:
template<class T> class X {
X<T>* p; // ok
X<T*> a; // instantiation of X<T> requires
// the instantiation of X<T*> which requires
// the instantiation of X<T**> which ...
};
--end example]
13No program shall explicitly instantiate any template more than once,
both explicitly instantiate and explicitly specialize a template, or
specialize a template more than once for a given set of template-
arguments. An implementation is not required to diagnose a violation
of this rule.
14An explicit specialization or explicit instantiation of a template
shall be in the namespace in which the template was defined. [Exam
ple:
namespace N {
template<class T> class X { /* ... */ };
template<class T> class Y { /* ... */ };
template<class T> class Z {
void f(int i) { g(i); }
// ...
};
class X<int> { /* ... */ }; // ok: specialization
// in same namespace
}
template class Y<int>; // error: explicit instantiation
// in different namespace
template class N::Y<char*>; // ok: explicit instantiation
// in same namespace
class N::Y<double> { /* ... */ }; // ok: specialization
// in same namespace
--end example]
15A member function of an explicitly specialized class shall not be
implicitly generated from the general template. Instead, the member
function shall itself be explicitly specialized. [Example:
template<class T> struct A {
void f() { /* ... */ }
};
struct A<int> {
void f();
};
void h()
{
A<int> a;
a.f(); // A<int>::f must be defined somewhere
}
void A<int>::f() { /* ... */ };
--end example] Thus, an explicit specialization of a class implies
the declaration of specializations of all of its members. The defini
tion of each such specialized member which is used shall be provided
in some translation unit.
14.3.3 Instantiation of operator-> [temp.opref]
1 If a template class has an operator->, that operator-> can have a
return type that cannot be dereferenced by -> as long as that opera
tor-> is neither invoked, nor has its address taken, isn't virtual,
nor is explicitly instantiated. [Example:
template<class T> class Ptr {
// ...
T* operator->();
};
Ptr<int> pi; // ok
Ptr<Rec> pr; // ok
void f()
{
pi->m = 7; // error: Ptr<int>::operator->() returns a type
// that cannot be dereference by ->
pr->m = 7; // ok if Rec has an accessible member m
// of suitable type
}
--end example]
14.4 Explicit instantiation [temp.explicit]
1 A class or function specialization can be explicitly instantiated from
its template.
2 The syntax for explicit instantiation is:
explicit-instantiation:
template declaration
Where the unqualifier-id in the declaration shall be a template-id.
[Example:
template class Array<char>;
template void sort<char>(Array<char>&);
--end example]
3 A declaration of the template shall be in scope at the point of
explicit instantiation.
4 A trailing template-argument can be left unspecified in an explicit
instantiation or explicit specialization of a template function pro
vided it can be deduced from the function argument type. [Example:
// instantiate sort(Array<int>&):
// deduce template-argument:
template void sort<>(Array<int>&);
--end example]
5 The explicit instantiation of a class implies the instantiation of all
of its members not previously explicitly specialized in the transla
tion unit containing the explicit instantiation.
14.5 Template specialization [temp.spec]
1 Except for a type member or template class member of a non-specialized
template class, the following can be declared by a declaration where
the declared name is a template-id: a specialized template function, a
template class, or a static member of a template; that is:
specialization:
declaration
[Note: a static member of a template can only be specialized in a def
inition due to syntactic restrictions. ] [Example:
template<class T> class stream;
class stream<char> { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }
void sort<char*>(Array<char*>&) ;
Given these declarations, stream<char> will be used as the definition
of streams of chars; other streams will be handled by template classes
generated from the class template. Similarly, sort<char*> will be
used as the sort function for arguments of type Array<char*>; other
Array types will be sorted by functions generated from the template.
]
2 A declaration of the template being specialized shall be in scope at
the point of declaration of a specialization. [Example:
class X<int> { /* ... */ }; // error: X not a template
template<class T> class X { /* ... */ };
class X<char*> { /* ... */ }; // fine: X is a template
--end example]
3 If a template is explicitly specialized then that specialization shall
be declared before the first use of that specialization in every
translation unit in which it is used. [Example:
template<class T> void sort(Array<T>& v) { /* ... */ }
void f(Array<String>& v)
{
sort(v); // use general template
// sort(Array<T>&), T is String
}
void sort<String>(Array<String>& v); // error: specialize after use
void sort<>(Array<char*>& v); // fine sort<char*> not yet used
--end example] If a function or class template has been explicitly
specialized for a template-argument list no specialization will be
implicitly generated for that template-argument list.
4 It is possible for a specialization with a given function signature to
be generated by more than one function template. In such cases,
explicit specification of the template arguments must be used to
uniquely identify the template function instance that is being spe
cialized. [Example:
template <class T> void f(T);
template <class T> void f(T*);
void f<>(int*); // Ambiguous
void f<int>(int*); // OK
void f<>(int); // OK
--end example]
5 Note that a function with the same name as a template and a type that
exactly matches that of a template is not a specialization
(_temp.over.spec_).
14.6 Class template specializations [temp.class.spec]
1 A primary class template declaration is one in which the class tem
plate name is an identifier. A template declaration in which the
class template name is a template-id, is a partial specialization of
the class template named in the template-id. The primary template
shall be declared before any specializations of that template.
2 [Example:
3 template<class T1, class T2, int I> class A { }; // #1
template<class T, int I> class A<T, T*, I> { }; // #2
template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #3
template<class T> class A<int, T*, 5> { }; // #4
template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #5
4 The first declaration declares the primary (unspecialized) class tem
plate. The second and subsequent declarations declare specializations
of the primary template. ]
5 The template parameters are specified in the angle bracket enclosed
list that immediately follows the keyword template. A template also
has a template argument list. For specializations, this list is
explicitly written immediately following the class template name. For
primary templates, this list is implicitly described by the template
parameter list. Specifically, the order of the template parameters is
the sequence in which they appear in the template parameter list.
[Example: the template argument list for the primary template in the
example above is <T1, T2, I>. ]
6 A nontype argument is nonspecialized if it is the name of a nontype
parameter. All other nontype arguments are specialized.
7 Within the argument list of a class template specialization, the fol
lowing restrictions apply:
--A specialized nontype argument expression shall not involve a tem
plate parameter of the specialization.
--The type of a specialized nontype argument shall not depend on
another type parameter of the specialization.
--The argument list of the specialization shall not be identical to
the implicit argument list of the primary template.
8
14.6.1 Matching of class template [temp.class.spec.match]
specializations
1 When a template class is used in a context that requires a complete
instantiation of the class, it is necessary to determine whether the
instantiation is to be generated using the primary template or one of
the partial specializations. This is done by matching the template
arguments of the template class being used with the template argument
lists of the partial specializations.
--If no matches are found, the instantiation is generated from the
primary template.
--If exactly one matching specialization is found, the instantiation
is generated from that specialization.
--If more than one specialization is found, the partial order rules
(_temp.class.order_) are used to determine whether one of the spe
cializations is more specialized than the others. If none of the
specializations is more specialized than all of the other matching
specializations, then the use of the template class is ambiguous and
the program is ill-formed.
2 A specialization matches a given actual template argument list if the
template arguments of the specialization can be deduced from the
actual template argument list (_temp.deduct_). A nontype template
parameter can also be deduced from the value of an actual template
argument of a nontype parameter of the primary template. [Example:
3 A<int, int, 1> a1; // uses #1
A<int, int*, 1> a2; // uses #2, T is int, I is 1
A<int, char*, 5> a3; // uses #4, T is int
A<int, char*, 1> a4; // uses #5, T1 is int, T2 is char, I is 1
A<int*, int*, 2> a5; // ambiguous: matches #3 and #5
--end example]
4 In a class template reference, (e.g., A<int, int, 1>) the argument
list must match the template parameter list of the primary template.
The template arguments of a specialization are deduced from the argu
ments of the primary template. The template parameter list of a spe
cialization shall not contain default template argument values.1)
14.6.2 Partial ordering of class template [temp.class.order]
specializations
1 For two class template partial specializations, the first is at least
as specialized as the second if:
_________________________
1) There is no way in which they could be used.
--the type arguments of the first template's argument list are at
least as specialized as those of the second template's argument list
using the ordering rules for function templates (_temp.func.order_),
and
--each nontype argument of the first template's argument list is at
least as specialized as that of the second template's argument list.
2 A nontype argument is at least as specialized as another nontype argu
ment if:
--both are formal arguments,
--the first is a value and the second is a formal argument, or
--both are the same value.
3 A template class partial specialization is more specialized than
another if, and only if, it is at least as specialized as the other
template class partial specialization and that template class partial
specialization is not at least as specialized as the first. Otherwise
the two template class partial specializations are unordered.
14.7 Template parameters [temp.param]
1 The syntax for template-parameters is:
template-parameter:
type-parameter
parameter-declaration
type-parameter:
class identifieropt
class identifieropt = type-id
typename identifieropt
typename identifieropt = type-id
template < template-parameter-list > class identifieropt
template < template-parameter-list > class identifieropt = template-name
[Example:
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 example]
2 Default arguments shall not be specified in a declaration or a defini
tion of a specialization.
3 A type-parameter defines its identifier to be a type-name in the scope
of the template declaration. A type-parameter shall not be redeclared
within its scope (including nested scopes). A non-type template-
parameter shall not be assigned to or in any other way have its value
changed. [Example:
template<class T, int i> class Y {
int T; // error: template-parameter redefined
void f() {
char T; // error: template-parameter redefined
i++; // error: change of template-argument value
}
};
template<class X> class X; // error: template-parameter redefined
--end example]
4 A template-parameter that could be interpreted as either an parameter-
declaration or a type-parameter (because its identifier is the name of
an already existing class) is taken as a type-parameter. A template-
parameter hides a variable, type, constant, etc. of the same name in
the enclosing scope. [Example:
class T { /* ... */ };
int i;
template<class T, T i> void f(T t)
{
T t1 = i; // template-arguments T and i
::T t2 = ::i; // globals T and i
}
Here, the template f has a type-parameter called T, rather than an
unnamed non-type parameter of class T. ] There is no semantic differ
ence between class and typename in a template-parameter.
5 There are no restrictions on what can be a template-argument type
beyond the constraints imposed by the set of argument types
(_temp.arg_). In particular, reference types and types containing cv-
qualifiers are allowed. A non-reference template-argument cannot have
its address taken. When a non-reference template-argument is used as
an initializer for a reference a temporary is always used. [Example:
template<const X& x, int i> void f()
{
&x; // ok
&i; // error: address of non-reference template-argument
int& ri = i; // error: non-const reference bound to temporary
const int& cri = i; // ok: reference bound to temporary
}
--end example]
6 A non-type template-parameter shall not be of floating type. [Exam
ple:
template<double d> class X; // error
template<double* pd> class X; // ok
template<double& rd> class X; // ok
--end example]
7 A default template-argument is a type, value, or template specified
after = in a template-parameter. A default template-argument can be
specified in a template declaration or a template definition. The set
of default template-arguments available for use with a template in a
translation unit shall be provided by the first declaration of the
template in that unit.
8 If a template-parameter has a default argument, all subsequent tem
plate-parameters shall have a default argument supplied. [Example:
template<class T1 = int, class T2> class B; // error
--end example]
9 The scope of a template-argument extends from its point of declaration
until the end of its template. In particular, a template-parameter
can be used in the declaration of subsequent template-parameters and
their default arguments. [Example:
template<class T, T* p, class U = T> class X { /* ... */ };
template<class T> void f(T* p = new T);
--end example] A template-parameter cannot be used in preceding tem
plate-parameters or their default arguments.
10A template-parameter can be used in the specification of base classes.
[Example:
template<class T> class X : public Array<T> { /* ... */ };
template<class T> class Y : public T { /* ... */ };
--end example] [Note: the use of a template-parameter as a base class
implies that a class used as a template-argument must be defined and
not just declared. ]
14.8 Template arguments [temp.arg]
1 The types of the template-arguments specified in a template-id shall
match the types specified for the template in its template-parameter-
list. [Example: Arrays as defined in _temp_ can be used like this:
Array<int> v1(20);
typedef complex<double> dcomplex; // complex is a standard
// library template
Array<dcomplex> v2(30);
Array<dcomplex> v3(40);
v1[3] = 7;
v2[3] = v3.elem(4) = dcomplex(7,8);
--end example]
2 A non-type non-reference template-argument shall be a constant-
expression of non-floating type, the address of an object or a func
tion with external linkage, or a non-overloaded pointer to member.
The address of an object or function shall be expressed as &f, plain f
(for function only), or &X::f where f is the function or object name.
In the case of &X::f, X shall be a (possibly qualified) name of a
class and f the name of a static member of X. A pointer to member
shall be expressed as &X::m where X is a (possibly qualified) name of
a class and m is the name of a nonstatic member of X. In particular,
a string literal (_lex.string_) is not an acceptable template-argument
because a string literal is the address of an object with static link
age. [Example:
template<class T, char* p> class X {
// ...
X(const char* q) { /* ... */ }
};
X<int,"Studebaker"> x1; // error: string literal as template-argument
char* p = "Vivisectionist";
X<int,p> x2; // ok
--end example]
3 Similarly, addresses of array elements and non-static class members
are not acceptable as template-arguments. [Example:
int a[10];
struct S { int m; static int s; } s;
X<&a[2],p> x3; // error: address of element
X<&s.m,p> x4; // error: address of member
X<&s.s,p> x5; // error: address of member (dot operator used)
X<&S::s,p> x6; // ok: address of static member
--end example]
4 Nor is a local type or a type with no linkage name an acceptable tem
plate-argument. [Example:
void f()
{
struct S { /* ... */ };
X<S,p> x3; // error: local type used as template-argument
}
--end example]
5 Similarly, a reference template-parameter shall not be bound to a tem
porary, an unnamed lvalue, or a named lvalue with no linkage. [Exam
ple:
template<const int& CRI> struct B { /* ... */ };
B<1> b2; // error: temporary required for template argument
int c = 1;
B<c> b1; // ok
--end example]
6 An argument to a template-parameter of pointer to function type shall
have exactly the type specified by the template parameter. This
allows selection from a set of overloaded functions. [Example:
void f(char);
void f(int);
template<void (*pf)(int)> struct A { /* ... */ };
A<&f> a; // selects f(int)
--end example]
7 If a template-argument to a template class is a function type and that
causes a declaration that does not use the syntactic form of a func
tion declarator to have function type, the program is ill-formed.
[Example:
template<class T>
struct A {
static T t;
};
typedef int function();
A<function> a; // ill-formed: would declare A<function>::t
// as a static member function
--end example]
8 A template has no special access rights to its template-argument
types. A template-argument shall be accessible at the point where it
is used as a template-argument. [Example:
template<class T> class X { /* ... */ };
class Y {
private:
struct S { /* ... */ };
X<S> x; // ok: S is accessible
};
X<Y::S> y; // error: S not accessible
--end example]
9 When default template-arguments are used, a template-argument list can
be empty. In that case the empty <> brackets shall still be used.
[Example:
template<class T = char> class String;
String<>* p; // ok: String<char>
String* q; // syntax error
--end example] The notion of " array type decay" does not apply to
template-parameters. [Example:
template<int a[5]> struct S { /* ... */ };
int v[5];
int* p = v;
S<v> x; // fine
S<p> y; // error
--end example]
14.9 Type equivalence [temp.type]
1 Two template-ids refer to the same class or function if their template
names are identical and in the same scope and their template-arguments
have identical values. [Example:
template<class E, int size> class buffer;
buffer<char,2*512> x;
buffer<char,1024> y;
declares x and y to be of the same type, and
template<class T, void(*err_fct)()> class list { /* ... */ };
list<int,&error_handler1> x1;
list<int,&error_handler2> x2;
list<int,&error_handler2> x3;
list<char,&error_handler2> x4;
declares x2 and x3 to be of the same type. Their type differs from
the types of x1 and x4. ]
14.10 Function templates [temp.fct]
1 A function template specifies how individual functions can be con
structed. [Example: a family of sort functions, might be declared
like this:
template<class T> void sort(Array<T>&);
--end example] A function template specifies an unbounded set of
(overloaded) functions. A function generated from a function template
is called a template function, so is an explicit specialization of a
function template. Template arguments can either be explicitly speci
fied in a call or be deduced from the function arguments.
14.10.1 Explicit template argument [temp.arg.explicit]
specification
1 Template arguments can be specified in a call by qualifying the tem
plate function name by the list of template-arguments exactly as tem
plate-arguments are specified in uses of a class template. [Example:
void f(Array<dcomplex>& cv, Array<int>& ci)
{
sort<dcomplex>(cv); // sort(Array<dcomplex>)
sort<int>(ci); // sort(Array<int>)
}
and
template<class U, class V> U convert(V v);
void g(double d)
{
int i = convert<int,double>(d); // int convert(double)
char c = convert<char,double>(d); // char convert(double)
}
--end example] Implicit conversions (_conv_) are accepted for a func
tion argument for which the parameter has been fixed by explicit spec
ification of template-arguments. [Example:
template<class T> void f(T);
class Complex {
// ...
explicit Complex(double);
};
void g()
{
f<Complex>(1); // ok, means f<Complex>(Complex(1))
}
--end example]
2 For a template function name to be explicitly qualified by template
arguments, the name must be known to refer to a template. When the
name appears after . or -> in a postfix-expression, or after :: in a
qualified-id where the nested-name-specifier depends on a template
parameter, the member template name must be prefixed by the keyword
template. Otherwise the name is assumed to name a non-template.
[Example:
3 class X {
public:
template<size_t> X* alloc();
};
void f(X* p)
{
X* p1 = p->alloc<200>();
// ill-formed: < means less than
X* p2 = p->template alloc<200>();
// fine: < starts explicit qualification
}
4 --end example] If a name prefixed by the keyword template in this way
is not the name of a member template function, the program is ill-
formed.
14.10.2 Template argument deduction [temp.deduct]
1 Template arguments that can be deduced from the function arguments of
a call need not be explicitly specified. [Example:
void f(Array<dcomplex>& cv, Array<int>& ci)
{
sort(cv); // call sort(Array<dcomplex>)
sort(ci); // call sort(Array<int>)
}
and
void g(double d)
{
int i = convert<int>(d); // call convert<int,double>(double)
int c = convert<char>(d); // call convert<char,double>(double)
}
--end example]
2 Type deduction is done for each parameter of a function template that
contains a reference to a template parameter that is not explicitly
specified. The type of the parameter of the function template (call
it P) is compared to the type of the corresponding argument of the
call (call it A), and an attempt is made to find types for the tem
plate type arguments, and values for the template non-type arguments,
that will make P after substitution of the deduced values and explic
itly-specified values (call that the deduced P) compatible with the
call argument. Type deduction is done independently for each parame
ter/argument pair, and the deduced template argument types and values
are then combined. If type deduction cannot be done for any parame
ter/argument pair, or if different parameter/argument pairs yield dif
ferent deduced values for a given template argument, or if any tem
plate argument remains neither deduced nor explicitly specified, tem
plate argument deduction fails.
3 If P is not a reference type:
--if A is an array type, the pointer type produced by the array-to-
pointer standard conversion (_conv.array_) is used in place of A for
type deduction; otherwise,
--if A is a function type, the pointer type produced by the function-
to-pointer standard conversion (_conv.func_) is used in place of A
for type deduction; otherwise,
--the cv-unqualified version of A is used in place of A for type
deduction.
If P is a reference type, the type referred to by P is used in place
of P for type deduction.
4 In general, the deduction process attempts to find template argument
values that will make the deduced P identical to A. However, there
are three cases that allow a difference:
--If the original P is a reference type, the deduced P (i.e., the type
referred to by the reference) can be more cv-qualified than A.
--If P is a pointer or pointer to member type, A can be another
pointer or pointer to member type that can be converted to the
deduced P via a qualification conversion (_conv.qual_).
--If P is a class, A can be a derived class of the deduced P having
the form class-template-name<arguments>. Likewise, if P is a
pointer to a class, A can be a pointer to a derived class of the
underlying type of the deduced P having the form class-template-
name<arguments>. These alternatives are considered only if type
deduction cannot be done otherwise. If they yield more than one
possible deduced P, the type deduction fails.
When deducing arguments in the context of taking the address of an
overloaded function (_over.over_), these inexact deductions are not
considered.
5 A template type argument T or a template non-type argument i can be
deduced if P and A have one of the following forms:
6 T
cv-list T
T*
T&
T[integer-constant]
class-template-name<T>
type(*)(T)
type T::*
T(*)()
T(*)(T)
type[i]
class-template-name<i>
where (T) represents parameter lists where at least one parameter type
contains a T, and () represents parameter lists where no parameter
contains a T. Similarly, <T> represents template argument lists where
at least one argument contains a T, and <i> represents template argu
ment lists where at least one argument contains an i. These forms can
be used in the same way as T is for further composition of types.
[Example:
X<int>(*)(char[6])
is of the form
class-template-name<T> (*)(type[i])
which is a variant of
type (*)(T)
where type is X<int> and T is char[6]. ]
7 In addition, a template-parameter can be deduced from a function or
pointer to member function argument if at most one of a set of over
loaded functions provides a unique match. [Example:
template<class T> void f(void(*)(T,int));
void g(int,int);
void g(char,int);
void h(int,int,int);
void h(char,int);
int m()
{
f(&g); // error: ambiguous
f(&h); // ok: void h(char,int) is a unique match
}
--end example] Template arguments cannot be deduced from function
arguments involving constructs other than the ones specified in here
(_temp.deduct_).
+------- BEGIN BOX 3 -------+
Can a template template-parameter be deduced? and if so how? Spicer
issue 3.19.
+------- END BOX 3 -------+
8 Template arguments of an explicit instantiation or explicit special
ization are deduced (_temp.explicit_, _temp.spec_) according to these
rules specified for deducing function arguments.
9 [Note: a major array bound is not part of a function parameter type so
it can't be deduced from an argument:
template<int i> void f1(int a[10][i]);
template<int i> void f2(int a[i][20]);
void g(int v[10][20])
{
f1(v); // ok: i deduced to be 20
f1<10>(v); // ok
f2(v); // error: cannot deduce template-argument i
f2<10>(v); // ok
}
--end note]
10Nontype parameters shall not be used in expressions in the function
declaration. The type of the function template-parameter shall match
the type of the template-argument exactly. [Example:
template<char c> class A { /* ... */ };
template<int i> void f(A<i>); // error: conversion not allowed
template<int i> void f(A<i+1>); // error: expression not allowed
--end example]
11If function template-arguments are explicitly specified in a call they
are specified in declaration order. Trailing arguments can be left
out of a list of explicit template-arguments. [Example:
template<class X, class Y, class Z> X f(Y,Z);
void g()
{
f<int,char*,double>("aa",3.0);
f<int,char*>("aa",3.0); // Z is deduced to be double
f<int>("aa",3.0); // Y is deduced to be char*, and
// Z is deduced to be double
f("aa",3.0); // error X cannot be deduced
}
--end example]
12A template-parameter cannot be deduced from a default function argu
ment. [Example:
template <class T> void f(T = 5, T = 7);
void g()
{
f(1); // fine: call f<int>(1,7)
f(); // error: cannot deduce T
f<int>(); // fine: call f<int>(5,7)
}
13Here is example in which different parameter/argument pairs produce
inconsistent template argument deductions:
template<class T> void f(T x, T y) { /* ... */ }
struct A { /* ... */ };
struct B : A { /* ... */ };
int g(A a, B b)
{
f(a,a); // ok: T is A
f(b,b); // ok: T is B
f(a,b); // error T could be A or B
f(b,a); // error: T could be A or B
}
14Here is an example where a qualification conversion applies between
the call argument type and the deduced parameter type:
template<class T> void f(const T*) {}
int *p;
void s()
{
f(p); // f(const int *)
}
15Here is an example where the deduced parameter type is a derived class
of a class template reference:
template <class T> struct B { };
template <class T> struct D : public B<T> {};
struct D2 : public B<int> {};
template <class T> void f(B<T>&){}
void main()
{
D<int> d;
D2 d2;
f(d); // calls f(B<int>&)
f(d2); // calls f(B<int>&)
}
--end example]
14.10.3 Overload resolution [temp.over]
1 A function template can be overloaded either by (other) functions of
its name or by (other) function templates of that same name. When a
call to that name is written (explicitly, or implicitly using the
operator notation), template argument deduction (_temp.deduct_) is
performed on each function template to find the template argument val
ues (if any) that can be used with that function template to generate
a function that can be invoked with the call arguments. For each
function template, if the argument deduction succeeds, the deduced
template arguments are used to generate a single template function,
which is added to the candidate functions set to be used in overload
resolution. The complete set of candidate functions includes all the
template functions generated in this way and all of the non-template
overloaded functions of the same name. The template functions are
treated like any other functions in the remainder of overload resolu
tion, except as explicitly noted.2)
2 [Example:
template<class T> T max(T a, T b) { return a>b?a:b; };
void f(int a, int b, char c, char d)
{
int m1 = max(a,b); // max(int a, int b)
char m2 = max(c,d); // max(char a, char b)
int m3 = max(a,c); // error: cannot generate max(int,char)
}
3 Adding
int max(int,int);
to the example above would resolve the third call, by providing a
function that could be called for max(a,c) after using the standard
conversion of char to int for c.
4 Here is an example involving conversions on a function argument
involved in template-parameter deduction:
template<class T> struct B { /* ... */ };
template<class T> struct D : public B<T> { /* ... */ };
template<class T> void f(B<T>&);
void g(B<int>& bi, D<int>& di)
{
f(bi); // f(bi)
f(di); // f( (B<int>&)di )
}
_________________________
2) The parameters of template functions contain no template parameter
types. The set of conversions allowed on deduced arguments is limit
ed, because the argument deduction process produces template functions
with parameters that either match the call arguments exactly or differ
only in ways that can be bridged by the allowed limited conversions.
Non-deduced arguments allow the full range of conversions.
5 Here is an example involving conversions on a function argument not
involved in template-parameter deduction:
template<class T> void f(T*,int); // #1
template<class T> void f(T,char); // #2
void h(int* pi, int i, char c)
{
f(pi,i); // #1: f<int>(pi,i)
f(pi,c); // #2: f<int*>(pi,c)
f(i,c); // #2: f<int>(i,c);
f(i,i); // #2: f<int>(i,char(i))
}
--end example]
6 The template definition is needed to generate specializations of a
template. However, only a function template declaration is needed to
call a specialization. [Example:
template<class T> void f(T); // declaration
void g()
{
f("Annemarie"); // call of f<char*>
}
The call of f is well formed because of the declaration of f, and the
program will be ill-formed unless a definition of f is present in some
translations unit.
7 Here is a case involving explicit specification of some of the tem
plate arguments and deduction of the rest:
template<class X, class Y> void f(X,Y*); // #1
template<class X, class Y> void f(X*,Y); // #2
void g(char* pc, int* pi)
{
f(0,0); // error: ambiguous: f<int,int>(int,int*)
// or f<int,int>(int*,int) ?
f<char*>(pc,pi); // #1: f<char*,int>(char*,int*)
f<char>(pc,pi); // #2: f<char,int*>(char*,int*)
}
--end example]
14.10.4 Overloading and linkage [temp.over.link]
1 It is possible to overload template functions so that specializations
of two different template functions have the same type. [Example:
// file1.c // file2.c
template<class T> template<class T>
void f(T*); void f(T);
void g(int* p) { void h(int* p) {
f(p); // call f_PT_pi f(p); // call f_T_pi
} }
--end example]
2 Such specializations are distinct functions and do not violate the
ODR.
3 The signature of a specialization of a template function consists of
the actual template arguments (whether explicitly specified or
deduced) and the signature of the function template.
4 The signature of a function template consists of its function signa
ture and its return type and template parameter list. The names of
the template parameters are significant only for establishing the
relationship between the template parameters and the rest of the sig
nature.
14.10.5 Overloading and specialization [temp.over.spec]
1 A template function can be overloaded by a function with the same type
as a potentially generated function. [Example:
template<class T> T max(T a, T b) { return a>b?a:b; }
int max(int a, int b);
int min(int a, int b);
template<class T> T min(T a, T b) { return a<b?a:b; }
--end example] Such an overloaded function is a specialization but
not an explicit specialization. The declaration simply guides the
overload resolution. [Note: this implies that a definition of
max(int,int) and min(int,int) will be implicitly generated from the
templates. If such implicit instantiation is not wanted, the explicit
specialization syntax should be used instead:
template<class T> T max(T a, T b) { return a>b?a:b; }
int max<int>(int a, int b);
--end note]
2 Defining a function with the same type as a template specialization
that is called is ill-formed. [Example:
template<class T> T max(T a, T b) { return a>b?a:b; }
int max(int a, int b) { return a>b?a:b; }
void f(int x, int y)
{
max(x,y); // error: duplicate definition of max()
}
If the two definitions of max() are not in the same translation unit
the diagnostic is not required. If a separate definition of a func
tion max(int,int) is needed, the specialization syntax can be used.
If the conversions enabled by an ordinary declaration are also needed,
both can be used.
template<class T> T max(T a, T b) { return a>b?a:b; }
int max<>(int a, int b) { /* ... */ }
void g(char x, int y)
{
max(x,y); // error: no exact match, and no conversions allowed
}
int max(int,int);
void f(char x, int y)
{
max(x,y); // max<int>(int(x),y)
}
--end example]
3 An explicit specialization of a function template shall be inline or
static only if it is explicitly declared to be, and independently of
whether its function template is. [Example:
template<class T> void f(T) { /* ... */ }
template<class T> inline T g(T) { /* ... */ }
inline void f<>(int) { /* ... */ } // ok: inline
int g<>(int) { /* ... */ } // ok: not inline
--end example]
14.10.6 Partial ordering of function templates [temp.func.order]
1 Given two function templates, whether one is more specialized than
another can be determined by transforming each template in turn and
using argument deduction to compare it to the other.
2 The transformation used is:
--For each type template parameter, synthesize a unique type and sub
stitute that for each occurrence of that parameter in the function
parameter list.
--for each nontype template parameter, synthesize a unique value of
the appropriate type and substitute that for each occurrence of that
parameter in the function parameter list.
3 Using the transformed function parameter list, perform argument deduc
tion against the other function template (_temp.deduct_). The trans
formed template is at least as specialized as the other if, and only
if, the deduction succeeds.
4 A template is more specialized than another if, and only if, it is at
least as specialized as the other template and that template is not at
least as specialized as the first. [Example:
template<class T> class A {};
template<class T> void f(T);
template<class T> void f(T*);
template<class T> void f(const T*);
template<class T> void g(T);
template<class T> void g(T&);
template<class T> void h(const T&);
template<class T> void h(A<T>);
void m() {
const int *p;
f(p); // f(const T*) is more specialized than f(T) or f(T*)
float x;
g(x); // Ambiguous: g(T) or g(T&)
A<int> z;
h(z); // h(A<T>) is more specialized than f(const T&)
const A<int> z2;
h(z2); // h(const T&) is called because h(A<T>) is not callable
}
--end example]
14.11 Member function templates [temp.mem.func]
1 A member function of a template class is implicitly a template func
tion with the template-parameters of its class as its template-
parameters. [Example:
template<class T> class Array {
T* v;
int sz;
public:
explicit Array(int);
T& operator[](int);
T& elem(int i) { return v[i]; }
// ...
};
declares three function templates. The subscript function might be
defined like this:
template<class T> T& Array<T>::operator[](int i)
{
if (i<0 || sz<=i) error("Array: range error");
return v[i];
}
2 The template-argument for Array<T>::operator[]() will be determined by
the Array to which the subscripting operation is applied.
Array<int> v1(20);
Array<dcomplex> v2(30);
v1[3] = 7; // Array<int>::operator[]()
v2[3] = dcomplex(7,8); // Array<dcomplex>::operator[]()
--end example]
14.12 Friends [temp.friend]
1 A friend function of a template can be a template function or a non-
template function. [Example:
template<class T> class task {
// ...
friend void next_time();
friend task<T>* preempt(task<T>*);
friend task* prmt(task*); // task is task<T>
friend class task<int>;
// ...
};
Here, next_time() and task<int> become friends of all task classes,
and each task has appropriately typed functions preempt() and prmt()
as friends. The preempt functions might be defined as a template.
template<class T> task<T>* preempt(task<T>* t) { /* ... */ }
--end example]
2 A friend template shall not be defined within a class. [Example:
class A {
template<class T> friend B; // ok
template<class T> friend void f(T); // ok
template<class T> friend BB { /* ... /* }; // error
template<class T> friend void ff(T){ /* ... /* } // error
};
--end example] [Note: a friend declaration can add a name to an
enclosing scope (_temp.inject_). ]
14.13 Static members and variables [temp.static]
1 Each template class or function generated from a template has its own
copies of any static variables or members. [Example:
template<class T> class X {
static T s;
// ...
};
X<int> aa;
X<char*> bb;
Here X<int> has a static member s of type int and X<char*> has a
static member s of type char*. ]
2 Static class member templates are defined similarly to member function
templates. [Example:
template<class T> T X<T>::s = 0;
int X<int>::s = 3;
3 Similarly,
template<class T> f(T* p)
{
static T s;
// ...
};
void g(int a, char* b)
{
f(&a); // call f<int>(int*)
f(&b); // call f<char*>(char**)
}
Here f<int>(int*) has a static member s of type int and
f<char*>(char**) has a static member s of type char*. ]