c++ - nomenclatura - snake case

¿Convenciones de nombre para los tipos de plantilla?

Question

Tradicionalmente, los nombres de los tipos de plantillas son solo una letra mayúscula:

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

Pero vacilo en hacer esto porque no es descriptivo y, por lo tanto, es difícil de leer. Entonces, ¿no sería algo como esto mejor:

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

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

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

Los hace sobresalir (y también, son letras mayúsculas otra vez). ¿Cual es tu opinion?

Answer 1

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

Answer 2

En nuestra tienda, usamos la notación núlgara HungF ##. Los argumentos de plantilla son solo argumentos como todos los demás, excepto que no son una constante, 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 significa algo acerca del rol que juega el argumento en el contexto de la función definida.

Answer 3

Intento seguir la noción que utiliza mi proveedor de compiladores: no es demasiado breve ni demasiado detallado. Y me ayuda a leer los mensajes de error que recibo con las plantillas estándar. (Lo cual es otra razón por la que cambié de const T& a T const& ). Algo como:

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

donde mi compilador usualmente usará:

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

Answer 4

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

Answer 5

Para plantillas de C ++ tengo un par de patrones.

Si hay un solo parámetro de plantilla, lo nombro T (o U, V para 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 bastante fáciles de detectar a lo largo del uso de la plantilla.

Sin embargo, evitaría la versión en mayúsculas. La mayoría de las personas utilizan todos los identificadores en mayúsculas en C / C ++ para representar una definición de macro. La repetición de ese patrón para un parámetro de plantilla puede confundir a la gente en el futuro.

Answer 6

Si tengo una clase con un parámetro de tipo, estoy usando el nombre T. También significa que todas las operaciones en esta clase están trabajando con T.

Si tengo pocos parámetros, los estoy nombrando como en su ejemplo AtomT, BioT ...
Si el parámetro de plantilla no es el tipo de objeto con el que trabajamos en clase, por ejemplo, estrategia, comaparator o functor, estoy usando el nombre sin T, por ejemplo, ThreadStrategy, Compare.

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

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

Answer 7

Sigo las mismas convenciones generales que dan nombre a los nombres de los tipos de la plantilla como a las clases y estructuras de nombres, que es poner en mayúscula la primera letra o cada palabra, así:

class MyGizmo
{
};
struct Thingy
{
};
class TPSReport
{
};
template<class ValType> ...
template<typename Number> ...

Answer 8

Utilizo la convención TName para el parámetro de la plantilla y NameT para el parámetro de la 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;