Regla 0x010Bh: Proporcionalidad en longitud de identificadores según su alcance

0x010Bh: Proporcionalidad en longitud de identificadores según su alcance¶

Enunciado normativo¶

DEBE usarse un nombre de al menos 3 caracteres para todo identificador de alcance global, externo o de nivel de archivo (variables globales y funciones públicas). Los nombres breves o de un solo carácter SE RESERVAN para variables locales, típicamente contadores de iteración.

¿Por qué existe esta regla?¶

El problema¶

Un identificador global pertenece al espacio de nombres de todo el programa y, si tiene enlace externo, al de todas las unidades de traducción enlazadas. Un int x; global obliga a quien lo lee a recorrer el archivo para deducir qué guarda, y arriesga chocar con un símbolo homónimo de otra unidad o de la biblioteca estándar. Un contador i, en cambio, vive dentro de un for: su significado queda claro por el contexto inmediato y por su ciclo de vida corto. La longitud del nombre, entonces, debe compensar la falta de contexto que impone el alcance.

Consecuencias de violarla¶

Fundamento en el estándar y en la cátedra¶

ISO/IEC 9899:2011 §6.2.1 y §6.2.2 regulan ámbitos y enlaces, y §7.1.3 reserva muchos identificadores para la implementación; §5.2.4.1 sólo garantiza 31 caracteres significativos para nombres externos. La cátedra aplica 0x0101h: Los identificadores deben ser descriptivos al alcance del identificador.

Alcance y excepciones¶

Aplica a variables globales, variables static de archivo y funciones con enlace externo o de nivel de archivo. No aplica a variables locales ni a parámetros, donde i, j, k y n son legítimos. Tampoco a miembros de struct/union, que tienen su propio ámbito y su nombre se lee junto al de la variable. El nombre de un contador local puede ser corto aunque se use tres veces.

Ejemplos exhaustivos¶

❌ Contraejemplo 1 — Global monocaracter¶

#include <stdio.h>

int x;

int main(void)
{
    x = 42;
    printf("%d\n", x);
    return 0;
}

Por qué falla: x no describe nada y ocupa el espacio de nombres externo. Otra unidad de traducción que defina int x; provoca colisión en el enlazador; la misma letra puede además aparecer como parámetro en media docena de funciones sin que el lector advierta que son objetos distintos.

❌ Contraejemplo 2 — Función pública abreviada y static de archivo opaco¶

int n = 0;          /* alcance de archivo, nombre opaco */
void f(void);       /* función pública con nombre de una letra */

static int c = 0;   /* también opaco, pese a ser static */

Por qué falla: aunque static evita el choque externo, c sigue sin decir qué cuenta; f no anticipa qué hace ni permite buscarla por nombre. La regla apunta a la proporcionalidad: static int contador_reintentos; sí cumple.

✅ Ejemplo conforme 1 — Global descriptivo y restringido¶

static size_t total_elementos = 0;

void inicializar_sistema(void);

Por qué cumple: total_elementos describe su rol en 3 o más caracteres y el static limita el enlace al archivo, conforme a 0x0106h: Las variables globales deben ser declaradas como static o usar prefijo g_. El prototipo inicializar_sistema deja verbo y objeto a la vista, según 0x0105h: Los nombres de funciones deben usar snake_case estricto en minúsculas.

✅ Ejemplo conforme 2 — Interacción con contadores locales¶

void imprimir_edades(const int edades[], size_t cantidad)
{
    for (size_t i = 0; i < cantidad; i++) {
        printf("%zu\n", (size_t)edades[i]);
    }
}

Por qué cumple: i vive dentro del for y su rol de índice es evidente por contexto; el parámetro cantidad —no n— describe qué mide. La regla no penaliza la brevedad local, sólo exige proporcionalidad con el alcance.

⚠️ Casos límite¶

• Bucles anidados: i, j, k son aceptables; conviene que su anidación no supere lo que la vista abarca.

• Parámetros matemáticos: n en una función puramente algebraica puede tolerarse, aunque la cátedra prefiere cantidad o tamano.

• Nombres de 3+ caracteres pero opacos: abc, tmp, var no cumplen; la regla combina longitud mínima y descriptividad.

• Nombres reservados: evitar igualmente prefijos __/_A, ver 0x010Ch: Auditor de identificadores reservados con doble guion bajo o guion bajo inicial.

Cómo detectarla¶

Checklist de autocontrol¶

• Todo global y toda función pública llevan un nombre de 3+ caracteres.

• Los nombres de una letra sólo aparecen en locales de iteración.

• Las globales son static o llevan prefijo g_ (0x0106h: Las variables globales deben ser declaradas como static o usar prefijo g_).

• El nombre distingue al objeto de cualquier otro global del programa.

• El nombre describe el rol semántico y no la letra o el tipo.

Reglas relacionadas¶

• 0x0101h: Los identificadores deben ser descriptivos — los identificadores deben ser descriptivos; aquí se fija su longitud mínima.

• 0x0102h: Los argumentos de función y las variables locales deben usar snake_case en minúsculas — el nombre descriptivo se escribe igual en snake_case.

• 0x0106h: Las variables globales deben ser declaradas como static o usar prefijo g_ — restringir el alcance con static o prefijo g_.

• 0x2006h: Mantené el alcance de las variables al mínimo posible — mantener el alcance mínimo evita necesitar nombres largos.

• 0x0105h: Los nombres de funciones deben usar snake_case estricto en minúsculas — las funciones usan snake_case en minúsculas.