Operadores en C: aritméticos, lógicos y precedencia

Los operadores son los verbos de C: toman valores y producen otros nuevos. Hay cerca de 40, pero una docena cubre casi todo el código, y dos de ellos tienen trampas lo bastante afiladas como para merecer su propia sección.

Operadores aritméticos

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3, division entera! */
    printf("a %% b  = %d\n", a % b);  /* 2, el resto */
    printf("-a     = %d\n", -a);      /* menos unario */
    return 0;
}

(%% en la cadena de formato imprime un signo de porcentaje literal; un % solo empezaría un especificador de formato.)

Los cinco operadores aritméticos binarios son + - * / %, más el - unario para la negación y el +, que esencialmente no hace nada.

La trampa de la división entera

a / b con dos enteros hace división entera y tira el resto. No hay redondeo: el resultado se trunca hacia cero.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* la division ocurre PRIMERO, como ints */
    printf("promedio mal  = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Ese último caso es el error que sobrevive hasta producción. Asignar a un double no ayuda: la división total / count ya está hecha, y ya es un int, antes de que ocurra la asignación. La solución es hacer que un operando sea de punto flotante dentro de la expresión, normalmente con una conversión.

Dos reglas relacionadas: dividir entre cero con enteros es comportamiento indefinido y típicamente revienta el programa, y INT_MIN / -1 se desborda.

El operador módulo

% da el resto y funciona solo con enteros:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d es par\n", i);
        } else {
            printf("%d es impar\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d segundos = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Comprobar x % 2 == 0 para la paridad y usar % n para que un índice dé la vuelta en un array son los dos usos cotidianos.

Con números negativos, el % de C sigue el signo del dividendo:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, no 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Así que x % 2 == 1 es una prueba rota de imparidad cuando x puede ser negativo: -7 % 2 es -1. Usa x % 2 != 0 en su lugar.

Para restos de punto flotante, % es un error de compilación; usa fmod() de math.h.

Asignación y asignación compuesta

= guarda un valor. Las formas compuestas combinan una operación con el guardado:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 significa x = x + 5, pero evalúa x una sola vez, lo que importa cuando el destino es algo como arr[compute_index()].

La asignación es en sí una expresión que produce el valor asignado, que es por lo que a = b = c = 0 funciona (asigna de derecha a izquierda) y por lo que el error de = frente a == compila en silencio.

Incremento y decremento

++ suma uno, -- resta uno. Cada uno viene en forma prefija y sufija:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a recibe 5 (el valor viejo), luego i pasa a 6 */
    printf("sufijo: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j pasa a 6 primero, luego b recibe 6 */
    printf("prefijo: b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* como sentencia suelta, identico a ++k */
    printf("sentencia: k = %d\n", k);
    return 0;
}

Como sentencia suelta las dos son intercambiables, e i++ es la elección convencional en un encabezado for por ninguna razón más profunda que la tradición.

Lo que no debes hacer es usar una variable más de una vez en una expresión donde además se modifica:

int i = 5;
int x = i++ + i++;      /* comportamiento indefinido */
arr[i] = i++;           /* comportamiento indefinido */
printf("%d %d", i++, i);/* comportamiento indefinido */

C no define el orden en que se evalúan esas subexpresiones, así que el resultado no es meramente no especificado: el comportamiento del programa entero queda indefinido. Parte la sentencia en dos y la ambigüedad desaparece.

Operadores de comparación

Son seis, y todos producen un int: 1 para verdadero y 0 para falso.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

Que el resultado sea un int corriente en lugar de un tipo booleano propio es un rasgo definitorio de C; mira booleanos en C para lo que se deriva de ello, incluido el error de = frente a ==.

Dos errores de comparación son específicos de C. El encadenamiento no funciona como sugieren las matemáticas: if (1 < x < 10) siempre es verdadero, porque 1 < x se evalúa a 0 o 1 y luego eso se compara con 10. Escribe if (x > 1 && x < 10). Y comparar cadenas con == compara punteros, no texto: usa strcmp de string.h.

Operadores lógicos

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("Puede conducir\n");
    }

    if (age < 13 || age > 65) {
        printf("Entrada con descuento\n");
    } else {
        printf("Precio completo\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& es Y, || es O, ! es NO. Los tres tratan cualquier valor distinto de cero como verdadero.

Hacen cortocircuito: && se detiene en cuanto un operando es falso, y || se detiene en cuanto uno es verdadero. El resto nunca se evalúa, y eso no es solo una optimización: es una garantía en la que puedes apoyarte para la seguridad.

#include <stdio.h>

int is_safe(int *p) {
    /* Si p es NULL, *p nunca se evalua: el && se detiene antes. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("con un puntero real: %d\n", is_safe(&value));
    printf("con NULL:            %d\n", is_safe(NULL));
    return 0;
}

Invierte el orden de esas dos pruebas y la llamada con NULL desreferencia un puntero nulo y revienta. Protege primero, usa después: el orden dentro de una cadena && es parte de la lógica.

El operador condicional

El único operador de tres operandos de C elige entre dos valores:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d articulo%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condicion ? valor_si_verdadero : valor_si_falso. Es una expresión, así que cabe donde una sentencia if no puede: dentro de un argumento de printf, en un inicializador. Mantenlo corto; los condicionales anidados se vuelven ilegibles rápido.

Operadores de bits, en breve

Estos trabajan sobre los bits individuales de un entero:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 en binario */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8,  1000, Y */
    printf("a | b  = %u\n", a | b);    /* 14, 1110, O */
    printf("a ^ b  = %u\n", a ^ b);    /* 6,  0110, O exclusivo */
    printf("~a     = %u\n", ~a);       /* NO: invierte cada bit */
    printf("a << 2 = %u\n", a << 2);   /* 48: desplaza a la izquierda, multiplica por 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3:  desplaza a la derecha, divide entre 4 */
    return 0;
}

Se usan para banderas, máscaras y registros de hardware. Dos advertencias: & y | no son && ni || (no hacen cortocircuito y operan bit a bit), y desplazar un valor con signo o desplazar más allá del ancho del tipo es indefinido. Usa tipos sin signo para trabajar con bits.

Precedencia

Cuando una expresión no tiene paréntesis, esta tabla decide qué se asocia con qué. La precedencia más alta primero:

Las consecuencias prácticas:

a + b * c       /* significa a + (b * c) */
a < b == c < d  /* significa (a < b) == (c < d), rara vez lo que querias */
x & 1 == 0      /* significa x & (1 == 0), o sea x & 0: un error clasico */
*p++            /* significa *(p++): desreferencia p y luego avanzalo */

Esa tercera línea merece memorizarse: == se asocia más fuerte que &, así que las pruebas con máscaras de bits necesitan paréntesis: (x & 1) == 0.

Nadie recuerda los quince niveles, y nadie lo necesita. Aprende que * le gana a +, que las comparaciones le ganan a && y este a ||, y que todo lo demás lleva paréntesis:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

Esa línea tiene paréntesis redundantes y es mejor gracias a ellos.