Question

Is this a correct usage of extern template in C++11? (Can it be that the extern template class and respective template class is visible in the same translation unit?)

// example.hpp:
#pragma once
template< typename T >
class C {
    void f(T);
};
// question is about the next two lines
extern template class C< float >;
extern template class C< double >;
// example_def.hpp:
#include "example.hpp"
template< typename T >
void C< T >::f(T) {
    //... smth. practicable
}
// example.cpp:
#include "example_def.hpp"
template class C< float >;
template class C< double >;
// other.hpp:
#pragma once
void g();
// other.cpp:
#include "other.hpp"
#include "example.hpp"
// maybe those two lines should be here instead?
void g() {
    C< float >();
    C< double >();
}
// main.cpp:
#include "example.hpp"
#include "other.hpp"
// ...and here?
int main() {
    C< float >();
    C< double >();
    g();
    return 0;
}

Answer 1

Yes, both an extern template class specification (called explicit instantiation declaration by the Standard) and a template class specification (called explicit instantiation definition by the Standard) can be in the same translation unit, if the definition (without extern) follows the declaration (with extern):

(§14.7.2/11) If an entity is the subject of both an explicit instantiation declaration and an explicit instantiation definition in the same translation unit, the definition shall follow the declaration. An entity that is the subject of an explicit instantiation declaration and that is also used in a way that would otherwise cause an implicit instantiation (14.7.1) in the translation unit shall be the subject of an explicit instantiation definition somewhere in the program; otherwise the program is ill-formed, no diagnostic required. [ Note: This rule does apply to inline functions even though an explicit instantiation declaration of such an entity has no other normative effect. This is needed to ensure that if the address of an inline function is taken in a translation unit in which the implementation chose to suppress the out-of-line body, another translation unit will supply the body. — end note ] An explicit instantiation declaration shall not name a specialization of a template with internal linkage.

(Emphasis mine). The terms explicit instantiation declaration and explicit instantiation definition are defined here:

(§14.7.2/2) The syntax for explicit instantiation is:

explicit-instantiation:
extern_opt template declaration

There are two forms of explicit instantiation: an explicit instantiation definition and an explicit instantiation declaration. An explicit instantiation declaration begins with the extern keyword.

---

The effect of these explicit instantiations is as follows:

1. The explicit instantiation declaration (with extern) prevents all implicit instantiations to take effect (except for inline functions and class template specializations, §14.7.2/10).

2. The explicit instantiation definition (without extern) causes the instantiation to happen no matter what, i.e. it overrides the explicit instantiation declaration (this also follows from §14.7.2/10).

---

General comments
The fact that your explicit instantiation declarations are located in the header file that defines the template implies that anyone who includes the header files in order to make use of the template will either have to also add an explicit instantiation definition, or, alternatively, needs to link to the code of another .cpp file that includes such an explicit instantiation definition.

This can be confusing and is probably not a very good idea when you expect many different users to instantiate the template for many different types. But it can be sensible if the number of instantiations for distinct types is small and you can anticipate them all. Of course you must make sure that there is one (or several) .cpp file(s) that include explicit instantiation definitions for all the instantiations required, and that its corresponding object file is linked with the project at build time.