Class template

A class template defines a family of classes.

Syntax

Explanation

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

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

Classes, functions , variables (since C++14)

Explicit instantiation can only appear in the enclosing namespace of the template, unless it uses qualified-id:

namespace N
{
    template<class T>
    class Y // template definition
    {
        void mf() {}
    };
}
 
// template class Y<int>; // error: class template Y not visible in the global namespace
using N::Y;
// template class Y<int>; // error: explicit instantiation outside
                          // of the namespace of the template
template class N::Y<char*>;       // OK: explicit instantiation
template void N::Y<double>::mf(); // OK: explicit instantiation

Explicit instantiation has no effect if an explicit specialization appeared before for the same set of template arguments.

Only the declaration is required to be visible when explicitly instantiating a function template , a variable template (since C++14)

If a function template , variable template (since C++14)

When an explicit instantiation names a class template specialization, it serves as an explicit instantiation of the same kind (declaration or definition) of each of its non-inherited non-template members that has not been previously explicitly specialized in the translation unit. If this explicit instantiation is a definition, it is also an explicit instantiation definition only for the members that have been defined at this point.

Explicit instantiation definitions ignore member access specifiers: parameter types and return types may be private.

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 // template definition
{
    void f() {}
    void g(); // never defined
};
 
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

If a class template has been declared, but not defined, at the point of instantiation, the instantiation yields an incomplete class type:

template<class T>
class X;    // declaration, not definition
 
X<char> ch; // error: incomplete type X<char>

Keywords

export(until C++11) extern(since C++11)

See also

• template parameters and arguments allow templates to be parameterized
• 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)