Almacenar definiciones de funciones de plantilla C ++ en un archivo .CPP

Tengo un código de plantilla que preferiría haber 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 plantillas 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&);

Tenga en cuenta las dos últimas líneas: la función de plantilla foo :: do solo se usa con ints y std :: strings, por lo que esas definiciones significan que la aplicación se vinculará.

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

El problema que describe puede resolverse definiendo la plantilla en el encabezado o mediante el enfoque que describió anteriormente.

Recomiendo leer los siguientes puntos de C ++ FAQ Lite :

• ¿Por qué no puedo separar la definición de mi clase de plantillas de su declaración y ponerla dentro de un archivo .cpp?
• ¿Cómo puedo evitar errores de enlazador con mis funciones de plantilla?
• ¿Cómo ayuda la exportación de palabras clave de C ++ con los errores del enlazador de plantillas?

Entran en muchos detalles sobre estos (y otros) problemas de plantilla.

Para otros en esta página que se preguntan cuál es la sintaxis correcta (como lo hice yo) para la especialización explícita de plantillas (o al menos en VS2008), es la siguiente ...

En su archivo .h ...

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

Y en tu archivo .cpp

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

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

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

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

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

Su ejemplo es correcto pero no muy portátil. También hay una sintaxis un poco más limpia 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. ¿Deberían compilarse otras versiones de la clase con plantilla? ¿Se supone que el mantenedor de la biblioteca anticipa todos los posibles usos de plantilla 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 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 en foo-impl.cpplugar de hacerlo, foo.cppya 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 le gustaría usar.

Esto permite mucha más flexibilidad al compartir 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á volviendo a compilar el mismo archivo de encabezado en cada unidad de traducción.

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

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

Consulte las preguntas frecuentes sobre esto.

Esa es una forma estándar de definir funciones de plantilla. Creo que hay tres métodos que leo para definir plantillas. O probablemente 4. Cada uno con pros y contras.

1. Definir en la definición de clase. No me gusta para nada porque creo que las definiciones de clase son estrictamente de referencia y deberían ser fáciles de leer. Sin embargo, es mucho menos complicado definir plantillas en clase que fuera. Y no todas las declaraciones de plantilla están en el mismo nivel de complejidad. Este método también hace que la plantilla sea una plantilla verdadera.

2. Defina la plantilla en el mismo encabezado, pero fuera de la clase. Esta es mi forma preferida la mayoría de las veces. Mantiene su definición de clase ordenada, la plantilla sigue siendo una plantilla verdadera. Sin embargo, requiere un nombre completo de la plantilla que puede ser complicado. Además, su código está disponible para todos. Pero si necesita que su código esté en línea, esta es la única manera. También puede lograr esto creando un archivo .INL al final de sus definiciones de clase.

3. Incluya el header.h y la implementación.CPP en su main.CPP. Creo que así es como se hace. No tendrá que preparar ninguna instancia previa, se comportará como una plantilla verdadera. El problema que tengo es que no es natural. Normalmente no incluimos y esperamos incluir archivos de origen. Supongo que dado que incluiste el archivo fuente, las funciones de la plantilla se pueden incorporar.

4. Este último método, que era la forma publicada, es definir las plantillas en un archivo fuente, al igual que el número 3; pero en lugar de incluir el archivo fuente, crearemos una instancia previa de las plantillas que necesitaremos. No tengo ningún problema con este método y a veces resulta útil. Tenemos un código grande, no puede beneficiarse de estar en línea, así que solo póngalo en un archivo CPP. Y si conocemos instancias comunes y podemos predefinirlas. Esto nos salva de escribir básicamente lo mismo 5, 10 veces. Este método tiene la ventaja de mantener nuestro código patentado. Pero no recomiendo poner pequeñas funciones de uso regular en los archivos CPP. Como esto reducirá el rendimiento de su biblioteca.

Tenga en cuenta que no conozco las consecuencias de un archivo obj hinchado.

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

Editar: corregido en función del comentario.

Tomemos un ejemplo, digamos por alguna razón que desea tener una clase de plantilla:

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

template <>
void DemoT<int>::test()
{
    printf("int test (int)\n");
}


template <>
void DemoT<bool>::test()
{
    printf("int test (bool)\n");
}

Si compila este código con Visual Studio, funciona de forma inmediata. gcc producirá un error de enlazador (si se usa el mismo archivo de encabezado de múltiples archivos .cpp):

error : multiple definition of `DemoT<int>::test()'; your.o: .../test_template.h:16: first defined here

Es posible mover la implementación al archivo .cpp, pero luego debe declarar una clase como esta:

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

template <>
void DemoT<int>::test();

template <>
void DemoT<bool>::test();

// Instantiate parametrized template classes, implementation resides on .cpp side.
template class DemoT<bool>;
template class DemoT<int>;

Y luego .cpp se verá así:

//test_template.cpp:
#include "test_template.h"

template <>
void DemoT<int>::test()
{
    printf("int test (int)\n");
}


template <>
void DemoT<bool>::test()
{
    printf("int test (bool)\n");
}

Sin dos últimas líneas en el archivo de encabezado, gcc funcionará bien, pero Visual Studio producirá un error:

 error LNK2019: unresolved external symbol "public: void __cdecl DemoT<int>::test(void)" (?test@?$DemoT@H@@QEAAXXZ) referenced in function

la sintaxis de clase de plantilla es opcional en caso de que desee exponer la función a través de la exportación .dll, pero esto es aplicable solo para la plataforma de Windows, por lo que test_template.h podría verse así:

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

#ifdef _WIN32
    #define DLL_EXPORT __declspec(dllexport) 
#else
    #define DLL_EXPORT
#endif

template <>
void DLL_EXPORT DemoT<int>::test();

template <>
void DLL_EXPORT DemoT<bool>::test();

con el archivo .cpp del ejemplo anterior.

Sin embargo, esto le da más dolor de cabeza al enlazador, por lo que se recomienda usar el ejemplo anterior si no exporta la función .dll.

¡Hora de una actualización! 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, haga 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.

No hay nada malo con 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 de clase explícita, la Biblioteca de verificación de conceptos de Boost (BCCL) puede ayudarlo a generar código de función de plantilla en archivos cpp.

Ninguno de los anteriores funcionó para mí, así que así es como lo resolví, mi clase solo tiene 1 método.

.h

class Model
{
    template <class T>
    void build(T* b, uint32_t number);
};

.cpp

#include "Model.h"
template <class T>
void Model::build(T* b, uint32_t number)
{
    //implementation
}

void TemporaryFunction()
{
    Model m;
    m.build<B1>(new B1(),1);
    m.build<B2>(new B2(), 1);
    m.build<B3>(new B3(), 1);
}

esto evita errores del enlazador y no es necesario llamar a TemporaryFunction en absoluto