template - typedef c++

Ejemplificación explícita: ¿cuándo se usa?

Question

Después de unas semanas de descanso, estoy tratando de expandir y ampliar mi conocimiento de las plantillas con el libro Plantillas - La Guía Completa de David Vandevoorde y Nicolai M. Josuttis, y lo que intento comprender en este momento es la creación de instancias explícitas de las plantillas. .

En realidad, no tengo ningún problema con el mecanismo como tal, pero no puedo imaginarme una situación en la que me gustaría o quisiera utilizar esta función. Si alguien puede explicarme eso, estaré más que agradecido.

Answer 1

Copiado directamente de http://msdn.microsoft.com/en-us/library/by56e477%28VS.80%29.aspx :

La creación de instancias explícitas le permite crear una instancia de una clase o función con plantilla sin usarla realmente en su código. Debido a que esto es útil cuando está creando archivos de biblioteca (.lib) que usan plantillas para distribución, las definiciones de plantilla no implementadas no se colocan en archivos de objetos (.obj).

(Por ejemplo, libstdc ++ contiene la instanciación explícita de std::basic_string<char,char_traits<char>,allocator<char> > (que es std::string ) así que cada vez que use funciones de std::string , la misma función el código no necesita ser copiado a los objetos. El compilador solo necesita referir (vincular) ésos a libstdc ++.)

Answer 2

Depende del modelo del compilador: aparentemente existe el modelo de Borland y el modelo de CFront. Y también depende de tu intención: si estás escribiendo una biblioteca, podrías (como se mencionó anteriormente) crear instancias explícitas de las especializaciones que deseas.

La página de GNU C ++ discute los modelos aquí https://gcc.gnu.org/onlinedocs/gcc-4.5.2/gcc/Template-Instantiation.html .

Answer 3

Si define una clase de plantilla que solo quiere que funcione para un par de tipos explícitos.

Coloque la declaración de plantilla en el archivo de encabezado como una clase normal.

Coloque la definición de la plantilla en un archivo fuente como una clase normal.

Luego, al final del archivo de origen, ejemplifique explícitamente solo la versión que desea que esté disponible.

Ejemplo tonto:

// StringAdapter.h
template<typename T>
class StringAdapter
{
     public:
         StringAdapter(T* data);
         void doAdapterStuff();
     private:
         std::basic_string<T> m_data;
};
typedef StringAdapter<char>    StrAdapter;
typedef StringAdapter<wchar_t> WStrAdapter;

Fuente:

// StringAdapter.cpp
#include "StringAdapter.h"

template<typename T>
StringAdapter<T>::StringAdapter(T* data)
    :m_data(data)
{}

template<typename T>
void StringAdapter<T>::doAdapterStuff()
{
    /* Manipulate a string */
}

// Explicitly instantiate only the classes you want to be defined.
// In this case I only want the template to work with characters but
// I want to support both char and wchar_t with the same code.
template class StringAdapter<char>;
template class StringAdapter<wchar_t>;

Principal

#include "StringAdapter.h"

// Note: Main can not see the definition of the template from here (just the declaration)
//       So it relies on the explicit instantiation to make sure it links.
int main()
{
  StrAdapter  x("hi There");
  x.doAdapterStuff();
}