Class template
A class template defines a family of classes.
Contents |
Syntax
template < parameter-list > declaration
|
(1) | ||||||||
export template < parameter-list > declaration
|
(2) | (until C++11) | |||||||
Explanation
declaration defines or declares a class (including struct and union), a member class or member enumeration type, a function or member function, a static data member of a class template, or a alias template. It may also define a template specialization. This page focuses on class templates.
parameter-list is a non-empty comma-separated list of the template parameters, each of which is either non-type parameter, a type parameter, a template parameter, or a parameter pack of any of those.
(until C++11)export was an optional modifier which declared the template as exported (when used with a class template, it declared all of its members exported as well). Files that instantiated exported templates did not need to include their definitions: the declaration was sufficient. Implementations of export were rare and disagreed with each other on details.
Class template instantiation
A class template by itself is not a type, or an object, or any other entity. No code is generated from a source file that contains only template definitions. In order for any code to appear, a template must be instantiated: the template arguments must be provided so that the compiler can generate an actual class (or function, from a function template).
Explicit instantiation
template class name < argument-list > ;
|
(1) | ||||||||
extern template class name < argument-list > ;
|
(2) | (since C++11) | |||||||
An explicit instantiation definition forces instantiation of the class, struct, or union they refer to. It may appear in the program anywhere after the template definition, and for a given argument-list, is only allowed to appear once in the entire program.
| An explicit instantiation declaration (an extern template) prevents implicit instantiations: the code that would otherwise cause an implicit instantiation has to use the explicit instantiation definition provided somewhere else in the program (typically, in another file: this can be used to reduce compilation times) | (since C++11) |
Implicit instantiation
When code refers to a template in context that requires a completely defined type, or when the completeness of the type affects the code, and this particular type has not been explicitly instantiated, implicit instantiation occurs. For example, when an object of this type is constructed, but not when a pointer to this type is constructed.
This applies to the members of the class template: unless the member is used in the program, it is not instantiated, and does not require a definition.
template<class T> struct Z { void f() {} void g(); // never defined }; // template definition template struct Z<double>; // explicit instantiation of Z<double> Z<int> a; // implicit instantiation of Z<int> Z<char>* p; // nothing is instantiated here p->f(); // implicit instantiation of Z<char> and Z<char>::f() occurs here. // Z<char>::g() is never needed and never instantiated: it does not have to be defined
See also
- template parameters and arguments allow templates to be parametrized
- function template declaration declares a function template
- template specialization defines an existing template for a specific type
- parameter packs allows the use of lists of types in templates (since C++11)
