Almacenamiento de definiciones de función de plantilla C++ en un archivo .CPP

Question

Tengo un código de plantilla que preferiría tener almacenado en un archivo CPP en lugar de en línea en el encabezado. Sé que esto se puede hacer siempre que sepa qué tipos de plantilla se utilizarán. Por ejemplo:

archivo .h

class foo 
{ 
public: 
    template <typename T> 
    void do(const T& t); 
}; 

archivo .cpp

template <typename T> 
void foo::do(const T& t) 
{ 
    // Do something with t 
} 

template void foo::do<int>(const int&); 
template void foo::do<std::string>(const std::string&); 

Nota las dos últimas líneas - la función de plantilla foo :: hacerlo sólo se utiliza con enteros y std :: strings, entonces esas definiciones significan que la aplicación enlazará.

Mi pregunta es: ¿es esto un hack desagradable o esto funcionará con otros compiladores/vinculadores? Solo estoy usando este código con VS2008 en este momento pero querré portar a otros entornos.

Answer 1

El problema que describe puede resolverse definiendo la plantilla en el encabezado o mediante el enfoque que describa arriba.

recomiendo la lectura de los siguientes puntos de la C++ FAQ Lite:

• Why can’t I separate the definition of my templates class from its declaration and put it inside a .cpp file?
• How can I avoid linker errors with my template functions?
• How does the C++ keyword export help with template linker errors?

Entran en una gran cantidad de detalles acerca de estos (y otros) problemas de plantilla .

Answer 2

Sí, esa es la forma estándar de hacer especialización instanciación explícita. Como dijiste, no puedes crear una instancia de esta plantilla con otros tipos.

Editar: corregido en base al comentario.

Answer 3

Esto debería funcionar bien en todas las plantillas compatibles. La instanciación de plantilla explícita es parte del estándar de C++.

Answer 4

Hay, en el último estándar, una palabra clave (export) que podría ayudar a aliviar este problema, pero no está implementado en ningún compilador del que sea consciente, aparte de Comeau.

Consulte el FAQ-lite acerca de esto.

Answer 5

Este código está bien formado. Solo debe prestar atención a que la definición de la plantilla sea visible en el momento de la creación de instancias. Para citar la norma, § 14.7.2.4:

La definición de una plantilla no exportada función, una plantilla no exportada función miembro, o una función no exportada miembro o miembro de datos estáticos de una plantilla de clase deberá estar presente en cada unidad de traducción en la que está explícitamente instanciado.

Answer 6

No hay nada de malo en el ejemplo que ha dado. Pero debo decir que creo que no es eficiente almacenar definiciones de funciones en un archivo cpp. Solo entiendo la necesidad de separar la declaración y la definición de la función.

Cuando se usa junto con la creación de instancias explícitas de clases, la Biblioteca de comprobación de conceptos de Boost (BCCL) puede ayudarlo a generar código de función de plantilla en archivos cpp.

Answer 7

Definitivamente no es un hack desagradable, pero tenga en cuenta el hecho de que tendrá que hacerlo (la especialización de plantilla explícita) para cada clase/tipo que desee utilizar con la plantilla dada. En el caso de que MUCHOS tipos soliciten la creación de instancias de plantillas, puede haber MUCHAS líneas en su archivo .cpp. Para solucionar este problema, puede tener una TemplateClassInst.cpp en cada proyecto que use, de modo que tenga un mayor control sobre qué tipos se crearán instancias. Obviamente, esta solución no será perfecta (también conocida como bala de plata) ya que podrías terminar rompiendo el ODR :).

Answer 8

Para otros en esta página preguntando qué la sintaxis correcta es (al igual que yo) de especialización de plantilla explícita (o al menos en VS2008), su siguiente ...

En su archivo .h ...

template<typename T> 
class foo 
{ 
public: 
    void bar(const T &t); 
}; 

Y en su archivo .cpp

template <class T> 
void foo<T>::bar(const T &t) 
{ } 

// Explicit template instantiation 
template class foo<int>; 

Answer 9

tiempo de actualizar! Cree un archivo en línea (.inl, o probablemente cualquier otro) y simplemente copie todas sus definiciones en él. Asegúrese de agregar la plantilla sobre cada función (template <typename T, ...>). Ahora, en lugar de incluir el archivo de encabezado en el archivo en línea, haces lo contrario. Incluya el archivo en línea después de la declaración de su clase (#include "file.inl").

Realmente no sé por qué nadie ha mencionado esto. No veo inconvenientes inmediatos.

Answer 10

Su ejemplo es correcto pero no muy portátil. También hay una sintaxis ligeramente más clara que se puede usar (como lo señala @ namespace-sid).

Supongamos que la clase con plantilla es parte de alguna biblioteca que se va a compartir. ¿Deben compilarse otras versiones de la clase con plantilla? ¿Se supone que el mantenedor de la biblioteca debe anticipar todos los usos posibles de la clase?

Un enfoque alternativo es una ligera variación de lo que tiene: agregue un tercer archivo que es el archivo de implementación/instanciación de la plantilla.

archivo foo.h

// Standard header file guards omitted 

template <typename T> 
class foo 
{ 
public: 
    void bar(const T& t); 
}; 

archivo foo.cpp

// Always include your headers 
#include "foo.h" 

template <typename T> 
void foo::bar(const T& t) 
{ 
    // Do something with t 
} 

archivo foo-impl.cpp

// Yes, we include the .cpp file 
#include "foo.cpp" 
template class foo<int>; 

La única advertencia es que necesita decirle al compilador que compile foo-impl.cpp en lugar de foo.cpp ya que la compilación no hace nada.

Por supuesto, puede tener múltiples implementaciones en el tercer archivo o tener múltiples archivos de implementación para cada tipo que desee utilizar.

Esto permite mucha más flexibilidad cuando se comparte la clase de plantilla para otros usos.

Esta configuración también reduce los tiempos de compilación para las clases reutilizadas porque no está recompilando el mismo archivo de encabezado en cada unidad de traducción.