C++: Is there any sense using the "extern" keyword for templates?

Question

Consider the following example:

fnc.h:

#include <iostream>

template <class T> //common template definition
void fnc()
{
    std::cout << "common";
}

fnc.cpp:

#include "fnc.h"

template<> //specialization for "int"
void fnc<int>()
{
    std::cout << "int";
}

main.cpp

#include "fnc.h"

extern template void fnc<int>(); // compiler will not generate fnc<int> and linker will be used to find "fnc<int>" in other object files

int main()
{
    fnc<double>(); //using instantiation from common template
    fnc<int>(); using specialization from "fnc.cpp"
}

Then I replace extern template void fnc<int>(); with template<> void fnc<int>(); and assume the behavior will be same. Is there any real meaning to using the extern keyword with templates or was it introduced for readability only?

Answer 1

It's not for specializations. Technically what you did is ill-formed, no diagnostic required. You have an explicit instantiation declaration, but no matching definition. The explicit specialization doesn't count for matching against the declaration you provided (even though some compilers implement it in a way that hides the fact).

This construct is for deferring instantiation, to make a compiler not try to instantiate the template in the current translation unit. So you may use it for hiding the template completely and exposing only for a finite set of types:

Header:

template <class T>
void fnc();

extern template void fnc<int>(); // The instantiation is elsewhere.

Source:

template <class T> //common template definition
void fnc()
{
    std::cout << "common";
}

template void fnc<int>(); // explicit instantiation

Or to prevent a frequently used specialization from being instantiated in every TU:

Common header:

#include <vector>
extern template std::vector<unsigned char>; // look for member definitions elsewhere.

One source file:

template std::vector<unsigned char>; // The member functions are defined in this TU

The later use case may save a on compile times.