Explicit Initialisation of Function Templates

[suvarna271]

Why will i use explicit instantiation of a template, for a type? If I do not use explicit instantiation, the template is used to create the necessary function then what is the use of explicit instantiation?

template <class Any>
void Swap (Any &, Any &);
// template prototype
 
template <> void Swap<job>(job &, job &);
// explicit specialization for job
 
int main(void)
{
 
template void Swap<char>(char &, char &); 
// explicit instantiation for char
 
short a, b;
Swap(a,b);
// implicit template instantiation for short
 
job n, m;
Swap(n, m);
// use explicit specialization for job
 
char g, h;
Swap(g, h);
// use explicit template instantiation for char
 
}
 

In the above eg. explicit instantiation is done for char type. What is the use of this?? If the compiler can make use of the template to make a fn for char type.

<eg. taken from C++ Primer>

If there are any refrences that can help me clear my concept, pls do include those.

[Banfa]

You would use an explicit specialisation if the generalised template function does not suffice for the type in question. By declaring the specialisation

template void Swap<char>(char &, char &);

You are telling the compiler it exists somewhere, that then leaves you free to put the actual specialisation of the function for the type into another source file.

However this is not a good way to do it, as a rule of thumb you should never specialise function templates because you can just overload them (normally), i.e. you declare your function

void Swap(char &, char &);

In function overloading the compiler/linker will always prefer a non-template function that matches exactly to the use of a template specialised or otherwise.

[suvarna271]

Thanks Banfa. But i wanted to know about Explicit instantiation
template void Swap<char>(char &, char &);

I think you have explained about Explicit specialisation
template<> void Swap<char>(char &, char &);

[weaknessforcats]

You use explicit instantiation when the compiler may not be able to figure out the coorect type to use with the template specialization.

There is no term explicit initialization.

So this code:

void Swap<char>(a, b); 

tells the compiler to use char and not promtote the char to an int or long or short, or some other type.

Maybe you have a class with an operator char and your template has a class T. The compiler will use the class type in the template which is not what you want. By explicitly using char you force the compiler to convert the class type to a char by calling the operator char and then to use that result in the template function call.

[Banfa]

@suvarna271 you're right, I'm sorry.

A use of an explicit instantiation

template void Swap<char>(char &, char &);

would be when writing a library that you wanted to include the code for template using the type of the explicit instantiation but where the code of the library did not use that type. The explicit instantiation forces the compiler put the code for that template instantiation into the object whether it is used or not.

Off the top of my head I can not think of a good example as to why you would want to do this but that is what it is for.