13 Templates [temp]

13.4 Template arguments [temp.arg]

13.4.1 General [temp.arg.general]

There are three forms of template-argument, corresponding to the three forms of template-parameter: type, non-type and template.

The type and form of each template-argument specified in a template-id shall match the type and form specified for the corresponding parameter declared by the template in its template-parameter-list.

When the parameter declared by the template is a template parameter pack, it will correspond to zero or more template-arguments.

[Example 1: 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; // 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 example]

The template argument list of a template-head is a template argument list in which the

n^{th}

template argument has the value of the

n^{th}

template parameter of the template-head.

If the

n^{th}

template parameter is a template parameter pack ([temp.variadic]), the

n^{th}

template argument is a pack expansion whose pattern is the name of the template parameter pack.

In a template-argument, an ambiguity between a type-id and an expression is resolved to a type-id, regardless of the form of the corresponding template-parameter.112

[Example 2: 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]

[Note 1:

Names used in a template-argument are subject to access control where they appear.

Because a template-parameter is not a class member, no access control applies.

— end note]

[Example 3: template<class T> class X { static T t; }; class Y { private: struct S { /* ... */ }; X<S> x; // OK, S is accessible // X<Y::S> has a static member of type Y::S // OK, even though Y::S is private }; X<Y::S> y; // error: S not accessible — end example]

For a template argument that is a class type or a class template, the template definition has no special access rights to the members of the template argument.

[Example 4: template <template <class TT> class T> class A { typename T<int>::S s; }; template <class U> class B { private: struct S { /* ... */ }; }; A<B> b; // error: A has no access to B::S — end example]

When template argument packs or default template arguments are used, a template-argument list can be empty.

In that case the empty <> brackets shall still be used as the template-argument-list.

[Example 5: template<class T = char> class String; String<>* p; // OK, String<char> String* q; // syntax error template<class ... Elements> class Tuple; Tuple<>* t; // OK, Elements is empty Tuple* u; // syntax error — end example]

An explicit destructor call ([class.dtor]) for an object that has a type that is a class template specialization may explicitly specify the template-arguments.

[Example 6: 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 example]

If the use of a template argument gives rise to an ill-formed construct in the instantiation of a template specialization, the program is ill-formed.

When name lookup for the component name of a template-id finds an overload set, both non-template functions in the overload set and function templates in the overload set for which the template-arguments do not match the template-parameters are ignored.

[Note 2:

If none of the function templates have matching template-parameters, the program is ill-formed.

— end note]

When a simple-template-id does not name a function, a default template-argument is implicitly instantiated when the value of that default argument is needed.

[Example 7: template<typename T, typename U = int> struct S { }; S<bool>* p; // the type of p is S<bool, int>*

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

— end example]

A template-argument followed by an ellipsis is a pack expansion .

112)112)

There is no such ambiguity in a default template-argument because the form of the template-parameter determines the allowable forms of the template-argument.