¿Cuáles son las convenciones de nomenclatura más comunes en C?

¿Cuáles son las convenciones de nomenclatura que se usan comúnmente en C? Sé que hay al menos dos:

1. GNU / linux / K&R con menos_funciones_case
2. ? nombre ? con funciones UpperCaseFoo

Estoy hablando de C solo aquí. La mayoría de nuestros proyectos son pequeños sistemas integrados en los que usamos C.

Aquí está el que estoy planeando usar para mi próximo proyecto:

Convención de nomenclatura C

Struct              TitleCase
Struct Members      lower_case or lowerCase

Enum                ETitleCase
Enum Members        ALL_CAPS or lowerCase

Public functions    pfx_TitleCase (pfx = two or three letter module prefix)
Private functions   TitleCase
Trivial variables   i,x,n,f etc...
Local variables     lower_case or lowerCase
Global variables    g_lowerCase or g_lower_case (searchable by g_ prefix)

Lo más importante aquí es la consistencia. Dicho esto, sigo la convención de codificación GTK +, que se puede resumir de la siguiente manera:

1. Todas las macros y constantes en los casquillos: MAX_BUFFER_SIZE, TRACKING_ID_PREFIX.
2. Estructurar nombres y typedef's en camelcase: GtkWidget, TrackingOrder.
3. Funciones que operan en estructuras: estilo clásico C: gtk_widget_show(), tracking_order_process().
4. Punteros: nada especial aquí: GtkWidget *foo, TrackingOrder *bar.
5. Variables globales: simplemente no use variables globales. Son malvados
6. Funciones que están allí, pero que no deben llamarse directamente, o que tienen usos oscuros, o lo que sea: uno o más subrayados al principio: _refrobnicate_data_tables(), _destroy_cache().

Los "punteros de estructura" no son entidades que necesitan una cláusula de convención de nomenclatura para cubrirlos. Son justos struct WhatEver *. NO oculte el hecho de que hay un puntero involucrado en un typedef inteligente y "obvio". No sirve para nada, es más largo de escribir y destruye el equilibrio entre declaración y acceso.

Bueno, en primer lugar, C no tiene funciones públicas / privadas / virtuales. Eso es C ++ y tiene diferentes convenciones. En C normalmente tienes:

• Constantes en ALL_CAPS
• Subraya la delimitación de palabras en estructuras o nombres de funciones, casi nunca ve el caso de camello en C;
• structs, typedefs, uniones, miembros (de uniones y estructuras) y los valores de enumeración suelen estar en minúsculas (en mi experiencia) en lugar de la convención C ++ / Java / C # / etc. de convertir la primera letra en mayúscula, pero supongo que es posible en C también.

C ++ es más complejo. He visto una verdadera mezcla aquí. Caso de camello para nombres de clase o minúsculas + guiones bajos (el caso de camello es más común en mi experiencia). Las estructuras se usan raramente (y típicamente porque una biblioteca las requiere, de lo contrario usaría clases).

Sabes, me gusta mantenerlo simple, pero claro ... Así que esto es lo que uso, en C:

• Variables triviales :, i,n,cetc. (solo una letra. Si una letra no está clara, conviértala en una variable local)
• Las variables locales :lowerCamelCase
• Variables globales :g_lowerCamelCase
• Variables Const :ALL_CAPS
• Variables de puntero : agregue p_a al prefijo. Para variables globales sería gp_var, para variables locales p_var, para variables constantes p_VAR. Si se utilizan punteros lejanos, utilice un en fp_lugar de p_.
• Estructuras : ModuleCamelCase(Módulo = nombre completo del módulo, o una abreviatura de 2-3 letras, pero aún en CamelCase.)
• Variables de miembro de estructura :lowerCamelCase
• Enumeraciones :ModuleCamelCase
• Valores de enumeración :ALL_CAPS
• Funciones publicas :ModuleCamelCase
• Funciones privadas :CamelCase
• Macros :CamelCase

Escribo typedef my structs, pero uso el mismo nombre para la etiqueta y typedef. La etiqueta no está destinada a ser de uso común. En cambio, es preferible usar typedef. También reenvío la declaración typedef en el encabezado del módulo público para la encapsulación y para poder usar el nombre typedef'd en la definición.

struct Ejemplo completo :

typdef struct TheName TheName;
struct TheName{
    int var;
    TheName *p_link;
};

Codificación en C #, java, C, C ++ y objetivo C al mismo tiempo, adopté una convención de nomenclatura muy simple y clara para simplificar mi vida.

En primer lugar, se basa en el poder de los IDE modernos (como eclipse, Xcode ...), con la posibilidad de obtener información rápida al pasar el mouse o presionar Ctrl ... Al aceptar eso, eliminé el uso de cualquier prefijo, sufijo y otros marcadores que simplemente proporciona el IDE.

Entonces, la convención:

• Cualquier nombre DEBE ser una oración legible que explique lo que tienes. Como "esta es mi convención".
• Luego, 4 métodos para sacar una convención de una oración:
  1. THIS_IS_MY_CONVENTION para macros, miembros de enumeración
  2. ThisIsMyConvention para nombre de archivo, nombre de objeto (clase, estructura, enumeración, unión ...), nombre de función, nombre de método, typedef
  3. this_is_my_convention variables globales y locales,
     parámetros, estructura y elementos de unión
  4. thisismyconvention [opcional] variables muy locales y temporales (como un índice de bucle for ())

Y eso es.

Da

class MyClass {
    enum TheEnumeration {
        FIRST_ELEMENT,
        SECOND_ELEMENT,
    }

    int class_variable;

    int MyMethod(int first_param, int second_parameter) {
        int local_variable;
        TheEnumeration local_enum;
        for(int myindex=0, myindex<class_variable, myindex++) {
             localEnum = FIRST_ELEMENT;
        }
    }
}

Recomendaría no mezclar mayúsculas y minúsculas y subrayar la separación (como usted propuso para los miembros de la estructura). Esto es confuso. Podrías pensar, hey, tengo, get_lengthasí que probablemente debería haberlo hecho make_subsety luego descubres que en realidad es así makeSubset. Use el principio de mínimo asombro y sea consistente.

Encuentro que CamelCase es útil para escribir nombres, como estructuras, typedefs y enumeraciones. Eso es todo, sin embargo. Para todo lo demás (nombres de funciones, nombres de miembros de estructura, etc.) utilizo underscore_separation.

Aquí hay uno (aparentemente) poco común, que he encontrado útil: el nombre del módulo en CamelCase, luego un guión bajo, luego la función o el nombre del alcance del archivo en CamelCase. Así por ejemplo:

Bluetooth_Init()
CommsHub_Update()
Serial_TxBuffer[]

Estoy confundido por una cosa: estás planeando crear una nueva convención de nomenclatura para un nuevo proyecto. En general, debe tener una convención de nomenclatura que abarque toda la empresa o el equipo. Si ya tiene proyectos que tienen alguna forma de convención de nomenclatura, no debe cambiar la convención para un nuevo proyecto. Si la convención anterior es solo la codificación de sus prácticas existentes, entonces usted es dorado. Cuanto más se diferencie de los estándares de facto existentes, más difícil será ganar mente en el nuevo estándar.

La única sugerencia que agregaría es que me ha gustado _t al final de los tipos en el estilo de uint32_t y size_t. Para mí es muy c-ish, aunque algunos podrían quejarse de que es simplemente "húngaro" inverso.

También debe pensar en el orden de las palabras para completar el nombre automático .

Una buena práctica: nombre de biblioteca + nombre de módulo + acción + tema

Si una parte no es relevante, simplemente omítala, pero siempre se debe presentar al menos un nombre de módulo y una acción.

Ejemplos:

• nombre de la función: os_task_set_prio, list_get_size,avg_get
• define (aquí generalmente no hay parte de acción ):OS_TASK_PRIO_MAX

Podría haber muchos, principalmente IDE dictan algunas tendencias y las convenciones de C ++ también están presionando. Para C comúnmente:

• UNDERSCORED_UPPER_CASE (definiciones de macro, constantes, miembros de enumeración)
• underscored_lower_case (variables, funciones)
• CamelCase (tipos personalizados: estructuras, enumeraciones, uniones)
• uncappedCamelCase (estilo Java oppa)
• UnderScored_CamelCase (variables, funciones bajo tipo de espacios de nombres)

La notación húngara para los globales está bien pero no para los tipos. E incluso para nombres triviales, utilice al menos dos caracteres.

Creo que pueden ayudar para principiantes: convención de nomenclatura de variables en c

1. Debe usar el carácter alfabético (az, AZ), el dígito (0-9) y la puntuación inferior (_). No está permitido usar ningún Carácter especial como:%, $, #, @ etc. Por lo tanto, puede usar user_name como variable pero no puede usar user & name .
2. No puede usar espacios en blanco entre palabras. Por lo tanto, puede usar user_name o username o username como variable pero no puede usar el nombre de usuario .
3. No se puede comenzar a nombrar con dígitos. Por lo tanto, puede usar user1 o user2 como variable pero no puede usar 1user .
4. Es un lenguaje sensible a mayúsculas y minúsculas. Mayúsculas y minúsculas son significativas. Si usa una variable como nombre de usuario, entonces no puede usar USERNAME o Username para uso de padre.
5. No puede usar ninguna palabra clave (char, int, if, for, while, etc.) para la declaración de variables.
6. El estándar ANSI reconoce una longitud de 31 caracteres para un nombre de variable