|An Introduction to GCC - for the GNU compilers gcc and g++|
by Brian J. Gough, foreword by Richard M. Stallman
Paperback (6"x9"), 144 pages
RRP £12.95 ($19.95)
"A wonderfully thorough guide... well-written, seriously usable information" --- Linux User and Developer Magazine (Issue 40, June 2004) Get a printed copy>>>
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
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 ‘templates.cc’ contains an explicit
instantiation of the
Buffer<float> class used by the program
‘tprog.cc’ 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 tprog.cc $ g++ -Wall -fno-implicit-templates -c templates.cc $ 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
If the program is modified to use additional types, then further
explicit instantiations can be added to the file ‘templates.cc’.
For example, the following code adds instantiations for Buffer objects
#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 ‘templates.cc’ 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.
|ISBN 0954161793||An Introduction to GCC - for the GNU compilers gcc and g++||See the print edition|