Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions




7.4.3 Explicit template instantiation

To achieve complete control over the compilation of templates with g++ it is possible to require explicit instantiation of each occurrence of a template, using the option -fno-implicit-templates. This method is not needed when using the GNU Linker--it is an alternative provided for systems with linkers which cannot eliminate duplicate definitions of template functions in object files.

In this approach, template functions are no longer compiled at the point where they are used, as a result of the -fno-implicit-templates option. Instead, the compiler looks for an explicit instantiation of the template using the template keyword with a specific type to force its compilation (this is a GNU extension to the standard behavior). These instantiations are typically placed in a separate source file, which is then compiled to make an object file containing all the template functions required by a program. This ensures that each template appears in only one object file, and is compatible with linkers which cannot eliminate duplicate definitions in object files.

For example, the following file '' contains an explicit instantiation of the Buffer<float> class used by the program '' given above:

#include "buffer.h"
template class Buffer<float>;

The whole program can be compiled and linked using explicit instantiation with the following commands:

$ g++ -Wall -fno-implicit-templates -c
$ g++ -Wall -fno-implicit-templates -c
$ g++ tprog.o templates.o
$ ./a.out 
stored value = 1.25

The object code for all the template functions is contained in the file 'templates.o'. There is no object code for template functions in 'tprog.o' when it is compiled with the -fno-implicit-templates option.

If the program is modified to use additional types, then further explicit instantiations can be added to the file ''. For example, the following code adds instantiations for Buffer objects containing double and int values:

#include "buffer.h"
template class Buffer<float>;
template class Buffer<double>;
template class Buffer<int>;

The disadvantage of explicit instantiation is that it is necessary to know which template types are needed by the program. For a complicated program this may be difficult to determine in advance. Any missing template instantiations can be determined at link time, however, and added to the list of explicit instantiations, by noting which functions are undefined.

Explicit instantiation can also be used to make libraries of precompiled template functions, by creating an object file containing all the required instantiations of a template function (as in the file '' above). For example, the object file created from the template instantiations above contains the machine code needed for Buffer classes with 'float', 'double' and 'int' types, and could be distributed in a library.

  Published under the terms of the GNU General Public License Design by Interspire