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>();

Main.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 template, o utilizo esta palabra clave solo para plantillas de clase como en la Figura 2?

Figura 2: plantillas de clases

TemplHeader.h

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

TemplCpp.cpp

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

Main.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 lo uso extern template? ¿Podemos usarlo solo para clases, o podemos usarlo también para funciones?

Además, la Figura 1 y la Figura 2 pueden expandirse a una solución donde las plantillas están en un solo archivo de encabezado. En ese caso, necesitamos usar la extern templatepalabra clave para evitar múltiples instancias iguales. ¿Es esto solo para clases o funciones también?

Solo debe usar extern templatepara forzar al compilador a no instanciar una plantilla cuando sepa que se instanciará en otro lugar. Se utiliza para reducir el tiempo de compilación y el tamaño del archivo 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 objeto:

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, uno void ReallyBigFunction<int>()se descartará, lo que resultará en una pérdida de tiempo de compilación y tamaño del archivo objeto.

Para no perder tiempo de compilación y tamaño de archivo de objeto, hay una externpalabra clave que hace que el compilador no compile una función de plantilla. Debe usar esto si y solo si sabe que se usa en el mismo binario en otro lugar.

Cambiar source2.cppa:

// source2.cpp

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

Dará como resultado los siguientes archivos de objeto:

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 estén vinculados, el segundo archivo de objeto solo usará el símbolo del primer archivo de objeto. No hay necesidad de descartar ni perder tiempo de compilación ni tamaño de archivo de objeto.

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

Esto también se aplica a las clases y la función como una, e incluso a las funciones de miembro de la plantilla.

Wikipedia tiene la mejor descripción

En C ++ 03, el compilador debe crear una instancia de una plantilla siempre que se encuentre 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 plantilla externas, análogas a las declaraciones de datos externas.

C ++ 03 tiene esta sintaxis para obligar al compilador a crear una instancia de 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 una versión no estándar de esta función 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 debe compilarse en diferentes compiladores.

Mire la muestra en la página vinculada para ver que funciona aproximadamente de la misma manera. Puede esperar que el mensaje desaparezca con futuras versiones de MSVC, excepto, por supuesto, cuando se utilizan otras extensiones de compilador no estándar al mismo tiempo.

extern template solo es necesario si la plantilla de declaración 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, extern templateno tiene ningún efecto porque las definiciones de plantilla en los encabezados estaban incompletas:

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

Por lo tanto, recomendaría simplemente eliminar la extern templatedefinición en ese caso particular: solo necesita agregarlas 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>();

Main.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

salida:

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

y luego man nmvemos que Usignifica indefinido, por lo que la definición se mantuvo solo TemplCppcomo se deseaba.

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 inteligentes a reconstruir todos los includers, que podrían ser muchos archivos
  • Si queremos evitar el exceso de archivos de objetos, no solo necesitamos crear instancias explícitas (lo mismo que con las declaraciones de encabezado incompletas), sino también agregar extern templatecada includer, lo que los programadores probablemente olvidarán hacer.

Se muestran más ejemplos de estos en: Creación de instancias de plantilla explícita : ¿cuándo se usa?

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

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

Probado en Ubuntu 18.04.

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

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

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

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

Si ha utilizado extern para funciones antes, se sigue exactamente la misma filosofía para las plantillas. si no es así, puede ser útil utilizar extern para funciones simples. Además, es posible que desee poner el (los) externo (s) en el archivo de encabezado e incluir el encabezado cuando lo necesite.