How do I force a particular instance of a C++ template to instantiate?

Question

See title. I have a template. I want to force a particular instance of a template to instantiate. How do I do this?

More specifically, can you force an abstract template class to instantiate?

Answer 1

abstract class cannot be instantiated.you probably want to do something along the lines of:

Abstract *a = new Implementation(...);

To force template instantiation, call template with template parameters:

std::max<int>(...);
std::pair<int, string>(...);

Answer 2

You can't force generic templates to instantiate, the compiler can only generate code if the type is completely known.

Forcing an instantiation is done by providing all types explicitly:

template std::vector<int>;

Comeaus template FAQ covers the related issues in some detail.

Answer 3

If I understand your question correctly, you have a template class, and you want to force the compiler to generate the code for use with some specific type. For example, you may want to ensure the code for std::vector<int> exists in your program.

The best way to ensure this is to simply construct an instance of the class:

void EnsureInstantiation()
{
    std::vector<int> intvector;
    std::vector<boo> boolvector;
    /// etc.
}

The trick is that you don't even have to call EnsureInstantiation anywhere in your code. Just make sure it's not static or else the compiler may optimize it out.

Answer 4

You can force instantiation by using the template with the desired parameter. For example you could define a function using all the required methods:

void force_int_instance() {
  Abstract<int> *a;
  a->some_method();
  a->some_other_method(1, 2, 3);
}

You don't need to actually call that function anywhere, so it's not a problem that the pointer is not initialized. But the compiler has to assume that the function might be called from another object file, so it has to instantiate the template.

Answer 5

I'm going to answer what I think you meant, not what you said.

I am guessing the issue is one of two things. The first is that you have code in a template that's not getting compiled when you compile the template file itself, which can be very annoying. That can be fixed in your compiler settings.

The other is you want to have something special for a particular type, perhaps to debug it. That is called explicit instanciation but does not really instanciate anything just makes sure it's always defined after that point.

http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/topic/com.ibm.vacpp6m.doc/language/ref/clrc16explicit_instantiation.htm

Answer 6

What you also can try is explicit instantiation:

template class vector<int>;                    // class
template int& vector<int>::operator[](int);    // member
template int convert<int,double>(double);      // function