Regla 0x0010h: Prohibición de llaves redundantes en inicialización de tipos escalares

0x0010h: Prohibición de llaves redundantes en inicialización de tipos escalares¶

Enunciado normativo¶

NO DEBE usarse llaves de inicialización en variables de tipo escalar (enteros, caracteres, flotantes, punteros). Las llaves {...} DEBEN reservarse para struct y arreglos.

Un escalar se inicializa con su valor literal directo.

¿Por qué existe esta regla?¶

El problema¶

En C las llaves de inicialización están pensadas para agregados (structs y arreglos). El estándar tolera llaves alrededor de un escalar (§6.7.9p11), pero esa tolerancia oculta la diferencia entre un dato simple y una colección de elementos y elimina la señal visual de que se está inicializando un agregado.

Reservar las llaves para agregados mantiene el contrato: al ver {0}, el lector sabe que hay una estructura o un arreglo; al ver = 0, sabe que hay un escalar.

Consecuencias de violarla¶

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

El estándar permite inicializar un escalar con una lista entre llaves (§6.7.9p11), pero la inicialización idiomática de agregados es {0} (§6.7.9p21). La cátedra separa ambos casos para que las llaves indiquen siempre “agregado”, en coherencia con 0x3018h: Inicialización idiomática de agregados con {0} en lugar de memset inmediato.

Alcance y excepciones¶

Aplica a variables escalares: int, char, float, double, punteros y bool. No alcanza a struct, union ni arreglos, donde {0} es la forma correcta y recomendada. Los designadores (.campo = x) siguen siendo válidos dentro de un agregado.

Ejemplos exhaustivos¶

❌ Contraejemplo 1 — Escalar con llaves¶

int contador = {0};
float tasa = {0.0};

Por qué falla: las llaves sugieren un agregado; el lector debe detenerse a comprobar el tipo y descubre que es un escalar.

❌ Contraejemplo 2 — Puntero y carácter con llaves¶

char inicial = {'a'};
int *ptr = {NULL};

Por qué falla: inicial y ptr son escalares; las llaves son toleradas por el estándar pero ocultan su naturaleza y rompen la uniformidad.

✅ Ejemplo conforme 1 — Escalares directos¶

int contador = 0;
float tasa = 0.0f;
char inicial = 'a';
int *ptr = NULL;

Justificación: cada escalar recibe su valor literal sin llaves, de modo que la forma de la inicialización coincide con la naturaleza del tipo.

✅ Ejemplo conforme 2 — Llaves solo para agregados¶

struct punto_t origen = {0};
int muestras[8] = {0};
struct punto_t p = { .x = 1, .y = 2 };

Justificación: las llaves aparecen únicamente donde hay una estructura o un arreglo, y los designadores asignan campos específicos dentro del agregado.

⚠️ Casos límite¶

• typedef de agregado: si el alias designa un struct, {0} es correcto aunque el nombre parezca un escalar.

• Arreglo de un elemento: int v[1] = {0}; es un agregado y conserva las llaves.

• Inicialización parcial: int v[4] = {1}; inicializa el primer elemento y pone el resto en cero; es un patrón válido de agregado.

Cómo detectarla¶

Checklist de autocontrol¶

• ¿Inicialicé los escalares sin llaves?

• ¿Usé {0} solo para structs y arreglos?

• ¿Distinguí un typedef de agregado de uno escalar?

• ¿Revisé también punteros y caracteres?

Reglas relacionadas¶

• 0x7001h: Siempre debés inicializar las variables a un valor conocido — inicialización de variables a un valor conocido.

• 0x3018h: Inicialización idiomática de agregados con {0} en lugar de memset inmediato — inicialización idiomática de agregados con {0}.

• 0x301Ch: Detector de variables locales no inicializadas con modificador const — las variables const se inicializan en su declaración.

• 0x0002h: Una declaración de variable por línea — una variable por línea permite inicializar cada una.

• 0x0103h: Las constantes (const o #define) deben nombrarse en MAYUSCULAS_SNAKE_CASE — las constantes escalares mantienen su valor literal.