Operadores, expresiones y conversiones

Las expresiones parecen lo trivial de un lenguaje, pero en C esconden reglas que sorprenden: promociones automáticas, conversiones silenciosas y una precedencia con trampas. Entenderlas es la diferencia entre código que hace lo que crees y bugs que solo aparecen con ciertos valores.

Operadores esenciales

int a = 7, b = 2;
a / b        // 3  — división ENTERA (trunca)
a % b        // 1  — módulo (resto)
a & b        // 2  — AND de bits
a | b        // 7  — OR de bits
a ^ b        // 5  — XOR de bits
a << 1       // 14 — desplazamiento a la izquierda (×2)
a >> 1       // 3  — desplazamiento a la derecha (÷2)

Precedencia: usa paréntesis

C tiene una tabla de precedencia larga y no siempre intuitiva. En vez de memorizarla entera, aplica una regla: cuando dudes, pon paréntesis.

// clásico: & tiene MENOS precedencia que ==
if (flags & MASK == 0)     // ❌ se evalúa como flags & (MASK == 0)
if ((flags & MASK) == 0)   // ✅ lo que querías

Promociones enteras

Antes de operar, C promociona los tipos enteros pequeños (char, short) a int. Esto explica comportamientos raros:

char a = 100, b = 100;
char c = a + b;      // a y b se promocionan a int: 200, que cabe en int
                     // pero al asignar a char (a menudo 8 bits con signo)
                     // 200 no cabe → resultado dependiente de implementación

La aritmética “ocurre en int” aunque los operandos sean más pequeños. Tenerlo presente evita sorpresas al mezclar tipos.

Las conversiones aritméticas usuales

Cuando operas tipos distintos, C convierte ambos a un tipo común siguiendo reglas fijas (el “de mayor rango gana”). El caso peligroso es mezclar con y sin signo:

unsigned u = 0;
int s = -1;
u - 1        // unsigned: da un número ENORME, no -1
s < u        // -1 se convierte a unsigned gigante → false (¡trampa!)

Operadores a nivel de bits

En sistemas manipularás bits constantemente (flags, máscaras, registros de hardware):

#define LEER   (1u << 0)   // 0b001
#define ESCRIBIR (1u << 1) // 0b010
#define EJECUTAR (1u << 2) // 0b100

unsigned permisos = LEER | ESCRIBIR;   // activar dos flags
permisos |=  EJECUTAR;                  // activar uno
permisos &= ~ESCRIBIR;                  // desactivar uno
bool puede_leer = permisos & LEER;      // comprobar

Este patrón —máscaras con |, &, ~, <<— es el pan de cada día del programador de sistemas. Usa siempre literales unsigned (1u) para evitar problemas de signo en los desplazamientos.