Regla 0x0016h: Validador de espaciado en operadores unarios

0x0016h: Validador de espaciado en operadores unarios¶

Enunciado normativo¶

NO DEBE haber espacios en blanco entre los operadores unarios *, &, !, ++ y -- y su operando inmediato: *ptr, &var, !flag, ++i.

¿Por qué existe esta regla?¶

El problema¶

Varios símbolos de C son binarios o unarios según el contexto: * multiplica o desreferencia; & hace AND bit a bit o toma una dirección; -- resta o decrementa. El espacio es el único recurso tipográfico que el lector tiene para desambiguarlos de un vistazo: a * b (dos operandos, operador binario) frente a *ptr (un operando, desreferencia), a & b frente a &var. Pegar el operador unario a su operando reproduce la convención matemática y hace que el lector identifique la aridad sin analizar la expresión completa.

Consecuencias de violarla¶

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

ISO/IEC 9899:2011 §6.5.3 (Unary operators) define &, *, !, ++, -- y sizeof como operadores unarios. El espacio no es significativo para el analizador léxico salvo para separar tokens; por eso la norma es convencional. La cátedra la adopta como regla de lectura y la articula con 0x000Ch: Prohibición de espacios en blanco entre operadores unarios (++, --, !) y su operando (mismo principio para ++, --, !) y con 0x0003h: Un espacio antes y después de cada operador binario, que exige espacios alrededor de los operadores binarios: juntas, ambas hacen visible la aridad del operador.

Alcance y excepciones¶

Aplica a * de desreferencia, & de dirección, !, ++ y -- prefijos y sufijos (i++, --j). No aplica a los operadores binarios *, &, -, +, que llevan espacio (0x0003h: Un espacio antes y después de cada operador binario). En las declaraciones, el asterisco de los punteros se pega al identificador por 0x0005h: El asterisco de los punteros debe declararse junto al identificador, criterio compatible con esta regla. sizeof merece atención aparte: sizeof x y sizeof(x) son ambas válidas, pero la cátedra prefiere la forma con paréntesis.

Ejemplos exhaustivos¶

❌ Contraejemplo 1 — Desreferencia y negación con espacio¶

* ptr = 5;
if (! condicion) ++ i;

Por qué falla: * ptr se lee como producto; ! condicion parece una comparación y ++ i una suma. Las tres formas compilan, pero obligan a adivinar la aridad.

❌ Contraejemplo 2 — Dirección y decremento separados¶

p = & valor;
-- contador;
bandera = ! activo;

Por qué falla: el espacio entre & y valor hace pensar en una operación binaria; lo mismo con -- y !. La expresión es correcta pero ilegible.

✅ Ejemplo conforme 1 — Operadores pegados¶

*ptr = 5;
if (!condicion) ++i;

Por qué cumple: cada operador unario queda adherido a su operando, de modo que *, ! y ++ se reconocen como unarios. Se alinea con 0x000Ch: Prohibición de espacios en blanco entre operadores unarios (++, --, !) y su operando.

✅ Ejemplo conforme 2 — Interacción con binarios y declaraciones¶

int *p = &valor;
int total = a * b;      /* binario: sí lleva espacios (0x0003h) */
for (size_t i = 0; i < n; ++i) {
    total += *p;
}

Por qué cumple: el asterisco de la declaración va junto a p (0x0005h: El asterisco de los punteros debe declararse junto al identificador), &valor no lleva espacio, a * b conserva sus espacios por ser binario y *p se distingue de la multiplicación.

⚠️ Casos límite¶

• Menos unario frente a binario: -x sin espacio; a - b con espacios.

• sizeof: sizeof x y sizeof(x) son legales; preferir paréntesis.

• * en declaración frente a desreferencia: int *p; es declaración; *p = 1; es acceso.

• Sufijo i++: también sin espacio; i ++ queda mal.

• && vs &: && es binario lógico y lleva espacios; & unario no.

Cómo detectarla¶

Checklist de autocontrol¶

• Ningún operador unario tiene espacio con su operando.

• Distingo el uso binario del unario de * y &.

• Los operadores binarios sí llevan espacio (0x0003h: Un espacio antes y después de cada operador binario).

• ++i e i++ van pegados en ambos formatos.

• No dejé ++, --, ! con espacio previo tampoco.

Reglas relacionadas¶

• 0x000Ch: Prohibición de espacios en blanco entre operadores unarios (++, --, !) y su operando — prohibición de espacios en ++, -- y !.

• 0x0003h: Un espacio antes y después de cada operador binario — espacios alrededor de operadores binarios.

• 0x0005h: El asterisco de los punteros debe declararse junto al identificador — asterisco de punteros junto al identificador.

• 0x000Bh: Prohibición de espacios en blanco alrededor de operadores de acceso a miembros (-> y .) — espaciado en -> y ..

• 0x0009h: Espaciado consistente en declaraciones de doble puntero (tipo **var) — espaciado en punteros a puntero.