Convenciones de nomenclatura para tipos de plantilla?

Question

Tradicionalmente, los nombres de los tipos de plantilla son apenas una sola letra mayúscula:

template<class A, class B, class C> 
class Foo {}; 

Pero dudan en hacer esto porque es no descriptivo y duro, por lo tanto leer. Por lo tanto, no sería algo como esto mejor:

template<class AtomT, class BioT, class ChemT> 
class Foo {}; 

También tienden a pensar lo siguiente no sería una mala idea:

template<class ATOM, class BIO, class CHEM> 
class Foo {}; 

Esto hace que se destacan (y también, es superior -casas cartas otra vez). ¿Cual es tu opinion?

Answer 1

Para plantillas de C++ que tienen un par de patrones

Si hay sólo un único parámetro de plantilla, I nombrarlo T (o U, V para las plantillas anidadas).

Cuando hay varios parámetros y el uso no es inmediatamente obvio, entonces uso nombres descriptivos con el prefijo T. Por ejemplo, TKey, TValue, TIdentifiier, etc ... Esto hace que los parámetros sean fáciles de detectar durante el uso de la plantilla .

Sin embargo, evitaría la versión en mayúsculas. La mayoría de las personas usa todos los identificadores en mayúscula en C/C++ para representar una definición de macro. Repetir ese patrón para un parámetro de plantilla es probable que confunda a las personas en el camino.

Answer 2

Generalmente, la forma tradicional es usar T si solo hay un tipo de param. Si hay más, use T como prefijo, p. TAtom. El prefijo "T" ayuda a ver instantáneamente su parámetro de tipo. Usar TAtom para un parámetro de tipo único también es válido.

Answer 3

Si tengo clase con un parámetro de tipo I estoy usando nombre de T. También significa que todos operartion en esta clase están trabajando con T.

Si tengo unos pocos parámetros que estoy nombrando como en su AtomT explamle , BioT ...
Si el parámetro de la plantilla no es el tipo de objeto con el que trabajamos en clas eg estrategia, comaparator o funtor, uso el nombre sin T, p. ej. ThreadStrategy, Compare.

A veces para evitar mezclar estilos Estoy haciendo typedefs en clase:
typedef T value_type;

-
Boost convención de nomenclatura (http://www.boost.org/development/requirements.html#Naming_consistency) dice acerca de los parámetros de plantilla siguientes:
nombres de los parámetros de plantilla comienzan con una letra mayúscula.

Answer 4

No debe usar una convención de nomenclatura especial para plantillas, solo use la misma convención que para cualquier otro tipo (como para clases o variables). No debería importar en el código si está trabajando con tipos/valores de plantilla o normales.

Answer 5

Intento seguir la idea que usa mi compilador: no es demasiado corto y no es demasiado detallado. Y me ayuda a leer los mensajes de error que recibo con las plantillas estándar. (Que es otra razón por la que cambié de const T& a T const&).Algo así como:

template <class Ty, class Container> 
class my_algo { ... 

donde mi compilador suele utilizar:

template <class _Ty, class _Container> 
class std_algo { ... 

Answer 6

utilizo convención TNAME para el parámetro de plantilla y Namet para el parámetro de plantilla almacenada.

template <typename TFirst, typename TSecond> 
class Templated 
{ 
    typedef TFirst FirstT; 
    typedef TSecond SecondT; 
} 

typedef Templated<int, std::string> MyTemplated; 
... 
const MyTemplated::FirstT size; 

Answer 7

que siguen las mismas convenciones de denominación generales typenames parámetro de plantilla como yo sigo nombrando clases & estructuras, que es capitalizar la primera letra o cada palabra, así:

class MyGizmo 
{ 
}; 

struct Thingy 
{ 
}; 

class TPSReport 
{ 
}; 


template<class ValType> ... 

template<typename Number> ... 

Answer 8

En nuestra tienda , usamos la notación de HungF ## ngarian. Los argumentos de plantilla son solo argumentos como todos los demás, excepto que no son un const, ni una variable, sino un tipo.

template< typename at_Container, typename at_Functor > 
at_Functor& foreach(const at_Container& ac_Cont, at_Functor& av_Func) { 
    return std::foreach(ac_Cont.begin(), ac_Cont.end(), av_Func); 
} 

El prefijo describe el tipo, mientras que el nombre es para decir algo del papel juega el argumento en el contexto de la función definida.