Explicit instantiation

Question

Hi guys, After few weeks brake (had to finish couple of assignments for my study, by the way, why God allowed anyone to invent Java?), I'm trying to expand and extend my knowlege of templates with book: Templates - The Complete Guide by David Vandevoorde and Nicolai M. Josuttis, and what I'm trying to understand at this moment is as in topic, explicit instantiation of templates. I mean I don't have a problem with the mechanism as such but I can't imagine a situation in which I would like or want to use this feature. If anyone can explain that to me I will be more than grateful. Thank you.

Answer 1

Directly copied from http://msdn.microsoft.com/en-us/library/by56e477%28VS.80%29.aspx:

Explicit instantiation lets you create an instantiation of a templated class or function without actually using it in your code. Because this is useful when you are creating library (.lib) files that use templates for distribution, uninstantiated template definitions are not put into object (.obj) files.

(For instance, libstdc++ contains the explicit instantiation of std::basic_string<char,char_traits<char>,allocator<char> > (which is std::string) so every time you use functions of std::string, the same function code doesn't need to be copied to objects. The compiler only need to refer (link) those to libstdc++.)

Answer 2

If you define a template class that you only whant to work for a couple of explicit types.

Put the template declaration in the header file just like a normal class.

Put the template definition in a source file just like a normal class.
Then at the end of the source file explicitly instanciate only the version you want to be available.

Silly example:

// StringAdapt.h
template<typename T>
class StringAdapter
{
     public:
         StringAdapter(T* data);
         void doAdapterStuff();
     private:
         std::basic_string<T> m_data;
};
typedef StringAdapter<char>    StrAdapter;
typedef StringAdapter<wchar_t> WStrAdapter;

Source:

// StringAdapt.cpp
#include "StringAdapter.h"

template<typename T>
StringAdapter<T>::StringAdapter(T* data)
    :m_data(data)
{}

template<typename T>
void StringAdapter<T>::doAdapterStuff()
{
    /* Manipulate a string */
}

// Explicitly instanciate only the classes you want to be defined.
// In this case I only want the template to work with characters but
// I want to support both char and wchar_t with the same code.
template class StringAdapter<char>;
template class StringAdapter<wchar_t>;

Main

#include "StringAdapter.h"

// Note: Main can not see the definition of the template from here (just the declaration)
//       So it relies on the explicit instanciation to make sure it links.
int main()
{
  StrAdapter  x("hi There");
  x.doAdapterStuff();
}