Template Instantiation

Template Instantiation
The act of creating a new definition of a function, class, or member of a class from a template declaration and one or more template arguments is called template instantiation. The definition created from a template instantiation is called a specialization.

1. Implicit Instantiation
Unless a template specialization has been explicitly instantiated or explicitly specialized, the compiler will generate a specialization for the template only when it needs the definition. This is called implicit instantiation.

If the compiler must instantiate a class template specialization and the template is declared, you must also define the template.

For example, if you declare a pointer to a class, the definition of that class is not needed and the class will not be implicitly instantiated. The following example demonstrates when the compiler instantiates a template class:

template<class T> class X {
  public:
    X* p;
    void f();
    void g();
};
 
X<int>* q;
X<int> r;
X<float>* s;
r.f();
s->g();
 

The compiler requires the instantiation of the following classes and functions:

    * X<int> when the object r is declared
    * X<int>::f() at the member function call r.f()
    * X<float> and X<float>::g() at the class member access function call s->g()

Therefore, the functions X<T>::f() and X<T>::g() must be defined in order for the above example to compile. (The compiler will use the default constructor of class X when it creates object r.) The compiler does not require the instantiation of the following definitions:

    * class X when the pointer p is declared
    * X<int> when the pointer q is declared
    * X<float> when the pointer s is declared

    
2. Explicit Instantiation
You can explicitly tell the compiler when it should generate a definition from a template. This is called explicit instantiation.

Syntax - Explicit Instantiation Declaration
 
>>-template--template_declaration------------------------------><
 
 

The following are examples of explicit instantiations:

template<class T> class Array { void mf(); };
template class Array<char>;      // explicit instantiation
template void Array<int>::mf();  // explicit instantiation
 
template<class T> void sort(Array<T>& v) { }
template void sort(Array<char>&); // explicit instantiation