Diferencia entre las funciones de miembro para una clase de plantilla definida dentro y fuera de la clase

Question

¿Hay alguna diferencia entre definir funciones de miembro para una clase de plantilla dentro de la declaración de clase frente a afuera?

definida en el interior:

template <typename T> 
class A 
{ 
public: 
    void method() 
    { 
     //... 
    } 
}; 

definida fuera:

template <typename T> 
class B 
{ 
public: 
    void method(); 
}; 

template <typename T> 
void B<T>::method() 
{ 
    //... 
} 

Para las clases no de plantilla, esta es la diferencia entre los métodos inline y no inline. ¿Esto también es cierto para las clases de plantilla?

El valor predeterminado para la mayoría de mis colegas es proporcionar definiciones dentro de la clase, pero siempre he preferido las definiciones fuera de la clase. ¿Está justificada mi preferencia?

Editar: Asuma que todo el código anterior se proporciona en el archivo de encabezado de la clase.

Answer 1

Sí, exactamente lo mismo es cierto para las clases de plantilla.

La razón por la cual las definiciones de métodos para las clases de plantilla generalmente se prefieren para estar en línea es que con las plantillas, toda la definición debe estar visible cuando se crea una instancia de la plantilla.

Así que si pones la definición de la función en un archivo .cpp separado, obtendrás un error del enlazador. La única solución general es hacer que la función entre en línea, ya sea definiéndola dentro de la clase o fuera de ella con la palabra clave inline. pero en ambos casos, debe ser visible en cualquier lugar donde se llame a la función, lo que significa que normalmente debe estar en el mismo encabezado que la definición de la clase.

Answer 2

No hay diferencia, aparte de tener que escribir más. Eso incluye el bit template, inline y tener que usar nombres más "elaborados" cuando se refiere a la clase. Por ejemplo

template <typename T> class A { 
    A method(A a) { 
    // whatever 
    } 
}; 

template <typename T> inline A<T> A<T>::method(A a) { 
    // whatever 
} 

Tenga en cuenta que cuando se define la forma en el interior siempre se puede omitir la lista de parámetros de plantilla <T> cuando se hace referencia a A<T> y sólo tiene que utilizar A. Al definirlo afuera, debe usar el nombre "completo" en el tipo de devolución y en el nombre del método (pero no en la lista de parámetros).

Answer 3

Sé esto ... Creo que debe ser algo que ayuda a usted?

defining a member function outside of its template 

No es aceptable para proporcionar la definición de una función miembro de una clase de plantilla como esta:

// This might be in a header file: 
template <typename T> 
class xyz { 
    void foo(); 
    }; 

// ...

// This might be later on in the header file: 
    void xyz<T>::foo() { 
// generic definition of foo() 
    } 

esto está mal para una algunas razones Así es la siguiente:

 void xyz<class T>::foo() { 
     // generic definition of foo() 
     } 

La definición adecuada necesita la palabra clave de plantilla y los mismos argumentos de plantilla que la definición de la plantilla de clase se declaran con.Por lo que da:

 template <typename T> 
      void xyz<T>::foo() { 
      // generic definition of foo() 
       } 

Tenga en cuenta que existen otros tipos de instrucciones de la plantilla, como plantillas miembros, etc., y cada uno lleva en su propia forma. Lo importante es saber cuál tienes para saber cómo escribir cada sabor. Esto es así especialmente porque los mensajes de error de algunos compiladores pueden no ser claros en cuanto a qué está mal. Y, por supuesto, obtener un buen libro actualizado.

Si usted tiene una plantilla anidada dentro de un miembro de la plantilla:

template <typename T> 
     struct xyz { 
     // ... 
     template <typename U> 
     struct abc; 
     // ... 
     }; 

¿Cómo se define abc exterior de XYZ? Esto no funciona:

 template <typename U> 
    struct xyz::abc<U> { // Nope 
     // ... 
    }; 

ni hace esto:

template <typename T, typename U> 
struct xyz<T>::abc<U> { // Nope 
// ... 
}; 

Usted tendría que hacer esto:

 template <typename T> 
     template <typename U> 
      struct xyz<T>::abc { 
      // ... 
      }; 

Tenga en cuenta que es ...abc no ...abc<U> porque abc es una "primaria" modelo. IOWs, esto no es bueno:

// no permitido aquí: plantilla de plantilla struct xyz :: abc {};