ILE C/C++ Language Reference

Explicit Instantiation

C++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
 
namespace N {
   template<class T> void f(T&) { }
}
 
template void N::f<int>(int&);
// The explicit instantiation is in namespace N.
 
int* p = 0;
template<class T> T g(T = &p);
template char g(char);                  // explicit instantiation
 
template <class T> class X {
   private:
      T v(T arg) { return arg; };
};
 
template int X<int>::v(int);    // explicit instantiation
 
template<class T> T g(T val) { return val;}
template<class T> void Array<T>::mf() { }

A template declaration must be in scope at the point of instantiation of the template's explicit instantiation. An explicit instantiation of a template specialization is in the same namespace where you defined the template.

Access checking rules do not apply to names in explicit instantiations. Template arguments and names in a declaration of an explicit instantiation may be private types or objects. In the above example, the compiler allows the explicit instantiation template int X<int>::v(int) even though the member function is declared private.

The compiler does not use default arguments when you explicitly instantiate a template. In the above example the compiler allows the explicit instantiation template char g(char) even though the default argument is an address of type int.

The following examples show template instantiation using extern:

template<class T>class C {
   static int i;
   void f(T) { }
};
template<class U>int C<U>::i = 0;
extern template C<int>;  // extern explicit template instantiation
C<int>c;   // does not cause instantiation of C<int>::i
           // or C<int>::f(int) in this file,
           // but the class is instantiated for mapping
C<char>d;  // normal instantiations
template<class C> C foo(C c) { return c; }
extern template int foo<int>(int);  // extern explicit template instantiation
int i = foo(1);  // does not cause instantiation of the body of foo<int>

Related References


[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]