Explicit instantiation of templates: any experience?

[Steven T. Hatton]

Has anybody here used explicit instantiation of templates? Has it worked
well? Are there any issues to be aware of?

 

[Noah Roberts]

Has anybody here used explicit instantiation of templates? Has it worked
well? Are there any issues to be aware of?

Sure it's worked. Don't do it in headers...don't know what else to
tell yah.

 

[Victor Bazarov]

Has anybody here used explicit instantiation of templates? Has it
worked well? Are there any issues to be aware of?

The only "problem" or "issue" that I know of is that you have to
predict what template arguments the users of your templates are
going to use. What I've often seen are instantiations of some
calculation templates based on 'float', 'double', 'long double',
and, if applicable, 'complex' variations of those, which makes
it possible to hide the implementation in a library (binary) and
still have only one codebase [for you to maintain].

V

 

[Craig Scott]

Has anybody here used explicit instantiation of templates? Has it worked

well? Are there any issues to be aware of?

There are issues, but they can be managed. Explicit instantiation is
perhaps not one of the more common-knowledge parts of templates in C++,
so consider whether others who may be working on your code will follow
what you are doing. But this should be a minor issue, since the syntax
at least is straightforward. To develop a good understanding of this
topic, I strongly recommend you get hold of "C++ Templates" by
Vandevoorde and Josuttis, then read section 10.5 on Explicit
Instantiation and also Appendix A on the One Definition Rule.

Explicit instantiation requires you to have a very good understanding
of how your templates will be used. For example, if you explicitly
instantiate a non-specialized class, you are enforcing that the class
cannot be specialised in any other code (that would be an ill-formed
C++ program). You have to make it very clear to clients of your class
that they cannot create an explicit specialization for the particular
type you explicitly instantiated. This can get ugly pretty fast if
there are more than a couple of types involved.

A case where explicit instantiation is particularly useful, however, is
when you have a base class with virtual functions and you make a
template subclass for it. Interestingly, if you instantiate an object
of the subclass, the C++ standard does not require the compiler to
instantiate all the virtual functions from the subclass. Therefore, if
you pass the object around by its base pointer, any client code calling
the virtual functions through that base pointer will not trigger an
implicit instantiation of the subclass' virtual function. In practice,
I believe compilers will generally instantiate all virtual functions
when an object is instantiated, since not to do so is generally
counter-intuitive for the average programmer, but I am not willing to
make a blanket statement that they all do. Perhaps someone else can
impart some wisdom here? The relevant part of the C++ standard is
14.7.1.9:

"... It is unspecified whether or not an implementation implicitly
instantiates a virtual member function of
a class template if the virtual member function would not otherwise be
instantiated."