Figura 1: plantillas de funciones

TemplHeader.h

template<typename T>
void f();

TemplCpp.cpp

template<typename T>
void f(){
   //...
}    
//explicit instantation
template void f<T>();

Principal.cpp

#include "TemplHeader.h"
extern template void f<T>(); //is this correct?
int main() {
    f<char>();
    return 0;
}

¿Es esta la forma correcta de usar extern templateo uso esta palabra clave solo para plantillas de clase como en la Figura 2?

Figura 2: plantillas de clase

TemplHeader.h

template<typename T>
class foo {
    T f();
};

TemplCpp.cpp

template<typename T>
void foo<T>::f() {
    //...
}
//explicit instantation
template class foo<int>;

Principal.cpp

#include "TemplHeader.h"
extern template class foo<int>();
int main() {
    foo<int> test;
    return 0;
}

Sé que es bueno poner todo esto en un archivo de encabezado, pero si instanciamos plantillas con los mismos parámetros en varios archivos, obtendremos varias definiciones iguales y el compilador las eliminará todas (excepto una) para evitar errores. ¿Cómo uso extern template? ¿Podemos usarlo solo para clases, o podemos usarlo también para funciones?

Además, la Figura 1 y la Figura 2 se pueden expandir a una solución donde las plantillas están en un solo archivo de encabezado. En ese caso, tenemos que usar el extern template palabra clave para evitar varias instancias iguales. ¿Esto es solo para clases o funciones también?

Solo debes usar extern template forzar al compilador a no instanciar una plantilla cuando sabes que será instanciado en otro lugar. Se utiliza para reducir el tiempo de compilación y el tamaño del archivo de objeto.

Por ejemplo:

// header.h

template<typename T>
void ReallyBigFunction()
{
    // Body
}

// source1.cpp

#include "header.h"
void something1()
{
    ReallyBigFunction<int>();
}

// source2.cpp

#include "header.h"
void something2()
{
    ReallyBigFunction<int>();
}

Esto dará como resultado los siguientes archivos de objetos:

source1.o
    void something1()
    void ReallyBigFunction<int>()    // Compiled first time

source2.o
    void something2()
    void ReallyBigFunction<int>()    // Compiled second time

Si ambos archivos están vinculados entre sí, uno void ReallyBigFunction<int>() se descartará, lo que resultará en tiempo de compilación y tamaño de archivo de objeto desperdiciados.

Para no desperdiciar el tiempo de compilación y el tamaño del archivo de objeto, hay un extern palabra clave que hace que el compilador no compile una función de plantilla. deberías usar esto si y solo si sabes se usa en el mismo binario en otro lugar.

Cambiando source2.cpp a:

// source2.cpp

#include "header.h"
extern template void ReallyBigFunction<int>();
void something2()
{
    ReallyBigFunction<int>();
}

Dará como resultado los siguientes archivos de objetos:

source1.o
    void something1()
    void ReallyBigFunction<int>() // compiled just one time

source2.o
    void something2()
    // No ReallyBigFunction<int> here because of the extern

Cuando ambos se vinculen, el segundo archivo de objeto solo usará el símbolo del primer archivo de objeto. No es necesario descartar ni desperdiciar tiempo de compilación ni tamaño de archivo de objeto.

Esto solo debe usarse dentro de un proyecto, como en momentos en que usa una plantilla como vector<int> varias veces, debe usar extern en todos los archivos de origen menos uno.

Esto también se aplica a las clases y funciones como una sola, e incluso a las funciones de miembros de plantilla.

Wikipedia tiene la mejor descripción

En C++03, el compilador debe instanciar una plantilla cada vez que se encuentra una plantilla completamente especificada en una unidad de traducción. Si se crea una instancia de la plantilla con los mismos tipos en muchas unidades de traducción, esto puede aumentar drásticamente los tiempos de compilación. No hay forma de evitar esto en C++03, por lo que C++11 introdujo declaraciones de plantillas externas, análogas a las declaraciones de datos externas.

C++03 tiene esta sintaxis para obligar al compilador a instanciar una plantilla:

  template class std::vector<MyClass>;

C++ 11 ahora proporciona esta sintaxis:

  extern template class std::vector<MyClass>;

que le dice al compilador que no cree una instancia de la plantilla en esta unidad de traducción.

_{^{La advertencia: nonstandard extension used...}}

Microsoft VC++ solía tener un no estándar versión de esta característica desde hace algunos años (en C++03). El compilador advierte sobre eso para evitar problemas de portabilidad con el código que también necesitaba compilarse en diferentes compiladores.

Mira la muestra en el pagina enlazada para ver que funciona más o menos de la misma manera. Puede esperar que el mensaje desaparezca con futuras versiones de MSVC, excepto, por supuesto, cuando use otro extensiones de compilador no estándar al mismo tiempo.

extern template solo es necesario si la declaración de la plantilla está completa

Esto se insinuó en otras respuestas, pero no creo que se le haya dado suficiente énfasis.

Lo que esto significa es que en los ejemplos de OP, el extern template no tiene efecto porque las definiciones de plantilla en los encabezados estaban incompletas:

• void f();: solo declaración, sin cuerpo
• class foo: declara método f() pero no tiene definición

Así que recomendaría simplemente quitar el extern template definición en ese caso particular: solo necesita agregarlos si las clases están completamente definidas.

Por ejemplo:

TemplHeader.h

template<typename T>
void f();

TemplCpp.cpp

template<typename T>
void f(){}

// Explicit instantiation for char.
template void f<char>();

Principal.cpp

#include "TemplHeader.h"

// Commented out from OP code, has no effect.
// extern template void f<T>(); //is this correct?

int main() {
    f<char>();
    return 0;
}

compilar y ver símbolos con nm:

g++ -std=c++11 -Wall -Wextra -pedantic -c -o TemplCpp.o TemplCpp.cpp
g++ -std=c++11 -Wall -Wextra -pedantic -c -o Main.o Main.cpp
g++ -std=c++11 -Wall -Wextra -pedantic -o Main.out Main.o TemplCpp.o
echo TemplCpp.o
nm -C TemplCpp.o | grep f
echo Main.o
nm -C Main.o | grep f

producción:

TemplCpp.o
0000000000000000 W void f<char>()
Main.o
                 U void f<char>()

y luego de man nm vemos eso U significa indefinido, por lo que la definición se quedó solo en TemplCpp como se desee.

Todo esto se reduce a la compensación de declaraciones de encabezado completas:

• ventajas:
  • permite que el código externo use nuestra plantilla con nuevos tipos
  • tenemos la opción de no agregar instancias explícitas si estamos de acuerdo con la hinchazón de objetos
• desventajas:
  • al desarrollar esa clase, los cambios en la implementación del encabezado llevarán a los sistemas de compilación inteligente a reconstruir todos los incluidos, que podrían ser muchos archivos
  • si queremos evitar la sobrecarga de archivos de objetos, no solo debemos hacer instancias explícitas (igual que con las declaraciones de encabezado incompletas), sino también agregar extern template en cada incluidor, que los programadores probablemente olvidarán hacer

Más ejemplos de estos se muestran en: Creación de instancias de plantillas explícitas: ¿cuándo se usa?

Dado que el tiempo de compilación es tan crítico en proyectos grandes, recomendaría encarecidamente declaraciones de plantillas incompletas, a menos que partes externas absolutamente necesiten reutilizar su código con sus propias clases personalizadas complejas.

Y en ese caso, primero intentaría usar el polimorfismo para evitar el problema del tiempo de compilación, y solo usaría plantillas si se pueden lograr mejoras de rendimiento notables.

Probado en Ubuntu 18.04.

El problema conocido con las plantillas es el código hinchado, que es consecuencia de generar la definición de clase en todos y cada uno de los módulos que invocan la especialización de plantilla de clase. Para evitar esto, comenzando con C++0x, se podría usar la palabra clave externo frente a la especialización de plantilla de clase

#include <MyClass>
extern template class CMyClass<int>;

La instanciación explícita de la clase de plantilla debe ocurrir solo en una sola unidad de traducción, preferiblemente la que tiene definición de plantilla (MyClass.cpp)

template class CMyClass<int>;
template class CMyClass<float>;

Si ha usado extern para funciones anteriormente, se sigue exactamente la misma filosofía para las plantillas. si no es así, puede ser útil pasar por extern para funciones simples. Además, es posible que desee colocar los elementos externos en el archivo de encabezado e incluir el encabezado cuando lo necesite.