Operadores y expresiones

1. Expresiones

Una expresión es una combinación de valores, variables, llamadas a funciones y operadores que produce un resultado. a + b * 2 es una expresión, pero también lo son a, 42, printf("hola") o x = 5. En C, toda expresión tiene dos cosas:

• Un valor, que se calcula al ejecutar.
• Un tipo, que el compilador determina al compilar, a partir de los tipos de los operandos. El tipo decide cómo se hace la operación: 7 / 2 y 7.0 / 2 usan instrucciones distintas del procesador y dan resultados distintos.

Algunas expresiones, además, tienen un efecto secundario: cambian algo además de producir un valor. La asignación cambia una variable; printf escribe en la salida. Una sentencia simple de C es casi siempre eso: una expresión seguida de ;, que se evalúa por su efecto y cuyo valor se descarta. x = 5; es una expresión de asignación, que vale 5, convertida en sentencia.

2. Los operadores aritméticos

No hay operador de potencia: 2 ^ 3 compila, pero ^ es el «o exclusivo» de bits del tema 8 y vale 1. Para potencias de números reales está pow, de math.h; para potencias de 2 enteras, el desplazamiento 1 << n, también del tema 8. Y hay un detalle que separa a C de Bash: en $(( )) todas las cuentas eran con enteros de 64 bits, mientras que en C cada operación se hace en el tipo que resulta de sus operandos, como veremos en las secciones 8 y 9.

3. La división entera

Cuando los dos operandos son enteros, / hace una división entera: el resultado es entero y los decimales se descartan. Desde C99, el descarte es siempre hacia cero, también con negativos, y el resto conserva el signo del dividendo:

#include <stdio.h>

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

$ gcc -std=c17 -Wall -Wextra -o division division.c && ./division
 7 / 2 =  3    7 % 2 =  1
-7 / 2 = -3   -7 % 2 = -1
 7 / -2 = -3    7 % -2 = 1
 7 / 2.0 = 3.5
 1 / 3 * 3 = 0,  1 * 3 / 3 = 1

Tres consecuencias prácticas. Primera: -7 / 2 es −3 y no −4, porque se trunca hacia cero, y -7 % 2 es −1. Comprobar si un número es impar con n % 2 == 1 falla con los negativos; lo correcto es n % 2 != 0. Segunda: basta con que un operando sea de punto flotante para que la división lo sea, como en 7 / 2.0. Tercera: el orden de las operaciones importa, porque cada división entera pierde información en el momento: 1 / 3 * 3 vale 0, mientras que 1 * 3 / 3 vale 1. Al calcular porcentajes con enteros, se multiplica primero y se divide al final: parte * 100 / total.

Dividir un entero por cero, en cambio, no es un detalle: es comportamiento indefinido, y en Linux sobre x86-64 el procesador lo detecta y el núcleo termina el proceso con una señal:

$ ./porcero 4
dividiendo 100 entre 4
resultado: 25
$ ./porcero
dividiendo 100 entre 0
Floating point exception
$ echo $?
136
$ kill -l 8
FPE

El nombre del mensaje, «excepción de punto flotante», es engañoso: la división fue entera. Es el nombre histórico de la señal SIGFPE, la número 8, que el núcleo envía ante un error aritmético. El código de salida lo confirma: 136 es 128 + 8, la convención de la shell para «terminado por la señal 8» que mencionamos en el tema 3. Hay un segundo caso que produce la misma señal y que pocos recuerdan: INT_MIN / -1, cuyo resultado, 2147483648, no cabe en un int. Con números de punto flotante, en cambio, dividir por cero no detiene nada: da infinito, como vimos en el tema 5. La regla es comprobar el divisor antes de dividir, cuando venga de datos externos.

4. Asignación, incremento y decremento

El operador = guarda un valor en una variable, y la expresión completa vale lo que se guardó. Por eso p = q = r = 0 funciona: se evalúa de derecha a izquierda, r = 0 vale 0, que se asigna a q, y así sigue. Cada operador aritmético, y cada operador de bits, tiene además una versión de asignación compuesta: total += 5 es total = total + 5.

Los operadores ++ y -- suman o restan 1, y tienen dos formas que se distinguen por el valor de la expresión:

#include <stdio.h>

int main(void)
{
    int a = 5, b = 5;
    int x = a++;                 /* usa 5, después a vale 6 */
    int y = ++b;                 /* b vale 6, después usa 6 */

    printf("x = %d, a = %d\n", x, a);
    printf("y = %d, b = %d\n", y, b);

    int total = 10;
    total += 5;                  /* total = total + 5 */
    total *= 2;                  /* total = total * 2 */
    total %= 7;                  /* total = total % 7 */
    printf("total = %d\n", total);

    int p, q, r;
    p = q = r = 0;               /* la asignación también es una expresión */
    printf("p = %d, q = %d, r = %d\n", p, q, r);
    return 0;
}

$ ./incremento
x = 5, a = 6
y = 6, b = 6
total = 2
p = 0, q = 0, r = 0

El postincremento a++ vale el valor anterior de a, y el preincremento ++b vale el nuevo. Las dos formas incrementan la variable; solo difieren en lo que entregan a la expresión que las rodea. Cuando se usan solas, como en el i++ de un for, son equivalentes. La recomendación es no usarlas dentro de expresiones más grandes salvo en modismos muy conocidos, porque es fácil equivocarse, y porque usar la misma variable dos veces en una expresión que la modifica es comportamiento indefinido, como veremos en la sección 13.

Recuerda también el error del tema 4: como la asignación es una expresión con valor, if (x = 0) compila, asigna 0 y nunca entra. -Wall lo advierte.

5. Comparaciones y operadores lógicos

Los operadores relacionales, <, <=, >, >=, == y !=, comparan dos valores y producen un int: 1 si la comparación es cierta, 0 si no. Los operadores lógicos combinan condiciones: && (y), || (o) y ! (no). Para ellos, cualquier valor distinto de cero es verdadero, y también devuelven 0 o 1. Pero && y || tienen una propiedad fundamental, la evaluación en cortocircuito: evalúan el operando de la izquierda primero, y si con él ya se conoce el resultado, el de la derecha no se evalúa.

#include <stdio.h>

static int comprobar(const char *nombre, int resultado)
{
    printf("  se evaluó %s\n", nombre);
    return resultado;
}

int main(void)
{
    printf("5 > 3 vale %d, 5 < 3 vale %d, !7 vale %d\n", 5 > 3, 5 < 3, !7);

    printf("falso && ...:\n");
    if (comprobar("A", 0) && comprobar("B", 1))
        printf("  entró\n");

    printf("verdadero || ...:\n");
    if (comprobar("C", 1) || comprobar("D", 1))
        printf("  entró\n");

    int divisor = 0;
    if (divisor != 0 && 100 / divisor > 5)
        printf("cociente grande\n");
    else
        printf("división evitada\n");
    return 0;
}

$ ./logicos
5 > 3 vale 1, 5 < 3 vale 0, !7 vale 0
falso && ...:
  se evaluó A
verdadero || ...:
  se evaluó C
  entró
división evitada

B y D nunca se evaluaron: si el primer operando de && es falso, el resultado es falso sin mirar el segundo; si el primero de || es verdadero, el resultado es verdadero. El último if muestra por qué esto importa: divisor != 0 && 100 / divisor > 5 nunca divide por cero, porque la división solo se evalúa si la primera condición se cumplió. Es el mismo principio de && y || en Bash, y el patrón que usaremos sin parar con los punteros: p != NULL && p->valor > 0.

No hay que confundir && con &, ni || con |. Los simples son operadores de bits, del tema 8: operan bit a bit, no hacen cortocircuito, y 1 & 2 vale 0 aunque los dos sean «verdaderos».

6. El operador condicional y la coma

El operador condicional condición ? a : b es el único de C con tres operandos: vale a si la condición es verdadera y b si no, y solo evalúa uno de los dos. Es útil para elegir un valor dentro de una expresión, como un plural:

$ cat tern.c
#include <stdio.h>
int main(void)
{
    int n = 3;
    printf("%d archivo%s\n", n, n == 1 ? "" : "s");
    int a = (n++, n * 2);
    printf("%d %d\n", n, a);
    return 0;
}
$ ./tern
3 archivos
4 8

El operador coma evalúa su operando izquierdo, descarta el valor, y luego evalúa el derecho, que es el valor de toda la expresión: (n++, n * 2) incrementa n y vale 8. Su único uso habitual es en un for con dos variables, como for (i = 0, j = n - 1; i < j; i++, j--). No hay que confundirlo con las comas que separan argumentos de una función o variables de una declaración, que no son operadores.

7. El desbordamiento

Ya vimos dos veces que el desbordamiento de un entero con signo es comportamiento indefinido: en el tema 1 con INT_MAX + 1, y en el tema 4 al hablar de la optimización. Ahora podemos ver el caso que hace famosa a esta regla. Esta función intenta comprobar si a x se le puede sumar 1 sin desbordar, con una idea que parece razonable: si la suma da la vuelta, el resultado será menor que x.

#include <stdio.h>
#include <limits.h>

/* ¿cabe x + 1 en un int? (una comprobación incorrecta) */
int cabe_uno_mas(int x)
{
    int siguiente = x + 1;

    return siguiente > x;
}

int main(void)
{
    printf("cabe_uno_mas(5)       = %d\n", cabe_uno_mas(5));
    printf("cabe_uno_mas(INT_MAX) = %d\n", cabe_uno_mas(INT_MAX));
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -O0 -o desborde desborde.c && ./desborde
cabe_uno_mas(5)       = 1
cabe_uno_mas(INT_MAX) = 0
$ gcc -std=c17 -Wall -Wextra -O2 -o desborde desborde.c && ./desborde
cabe_uno_mas(5)       = 1
cabe_uno_mas(INT_MAX) = 1
$ gcc -std=c17 -O2 -S -fno-asynchronous-unwind-tables -o - desborde.c | sed -n '/^cabe_uno_mas:/,/ret/p'
cabe_uno_mas:
	endbr64
	movl	$1, %eax
	ret

Sin optimizar, la comprobación «funciona»: la suma da la vuelta a un número negativo, y la función responde 0. Con -O2, responde 1, y el ensamblador muestra por qué: la función entera se redujo a «devolver 1». El razonamiento del compilador es impecable desde las reglas del lenguaje: el desbordamiento con signo no puede ocurrir en un programa correcto, de modo que x + 1 es siempre mayor que x, y la comparación es siempre verdadera. Si se escribe directamente return x + 1 > x;, sin la variable intermedia, gcc la simplifica incluso con -O0. No hay ninguna advertencia. Es la razón por la que errores de este tipo han producido vulnerabilidades reales: la comprobación de seguridad estaba en el fuente, pero no en el ejecutable.

Hay varias herramientas para tratar con esto, y conviene conocerlas todas:

Las dos últimas son las que se usan para escribir código correcto. Este programa muestra ambas:

#include <stdio.h>
#include <limits.h>
#include <stdckdint.h>

int main(void)
{
    int a = INT_MAX - 5;
    int resultado;

    /* forma 1: comprobar antes de operar */
    if (a > INT_MAX - 10)
        printf("a + 10 se desbordaría\n");

    /* forma 2: C23, ckd_add devuelve true si hubo desbordamiento */
    if (ckd_add(&resultado, a, 10))
        printf("ckd_add: desbordamiento, resultado truncado = %d\n", resultado);
    if (!ckd_add(&resultado, a, 3))
        printf("ckd_add: a + 3 = %d\n", resultado);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra -o seguro seguro.c && ./seguro
a + 10 se desbordaría
ckd_add: desbordamiento, resultado truncado = -2147483644
ckd_add: a + 3 = 2147483645

La comprobación previa a > INT_MAX - 10 no puede desbordar, porque INT_MAX - 10 es un valor válido; es la forma algebraicamente equivalente de «a + 10 > INT_MAX», reordenada para que ninguna operación se salga del rango. ckd_add recibe la dirección donde guardar el resultado, que en caso de desbordamiento contiene el valor «dado la vuelta», y devuelve verdadero si hubo desbordamiento. En compiladores anteriores a C23, gcc y clang ofrecen lo mismo como __builtin_add_overflow.

8. La promoción entera

Los procesadores no suman bytes sueltos: trabajan con registros de al menos 32 bits. C refleja eso con una regla que se aplica antes de casi cualquier operación: la promoción entera. Todo operando de un tipo más chico que int, como char, short o bool, se convierte primero a int.

$ ./cp                                 # sizeof c y sizeof(c + 0), con char c
1 4
$ ./conversiones | head -n 1         # unsigned char a = 200, b = 100
a + b = 300, y sizeof(a + b) = 4

Un char ocupa 1 byte, pero c + 0 ya es un int, de 4. Y a + b, con dos unsigned char de 200 y 100, vale 300, aunque 300 no cabe en un byte: la suma se hizo en int. El desbordamiento solo aparecería al guardar el resultado de nuevo en un unsigned char, que lo dejaría en 44. La promoción es casi siempre una ventaja, porque evita desbordamientos en los cálculos intermedios, pero tiene un efecto sorprendente con los operadores de bits, que veremos en el tema 8: ~ aplicado a un unsigned char de valor 0 da −1, un int con todos los bits encendidos, y no 255.

9. Las conversiones aritméticas habituales

Cuando un operador recibe dos operandos de tipos distintos, C los lleva a un tipo común antes de operar, siguiendo las conversiones aritméticas habituales. Simplificadas, son estas, en orden:

1. Si uno es de punto flotante, el otro se convierte a ese tipo, y gana el más grande: long double, luego double, luego float. Así, 7 / 2.0 es una división de double. flotante
2. Si no, se aplica la promoción entera a los dos: los tipos chicos pasan a int. promoción
3. Si los dos tienen el mismo signo, el de menor rango se convierte al de mayor: int con long da long. mismo signo
4. Si uno tiene signo y el otro no, y el sin signo es de rango igual o mayor, el que tiene signo se convierte a sin signo. Si el tipo con signo es más grande y puede representar todos los valores del otro, gana el con signo. mezcla de signos

La cuarta regla es la que produce las sorpresas. -1 < 1u compara un int con un unsigned int, del mismo rango, de modo que −1 se convierte a sin signo: 4294967295, como vimos en el tema 5. Y la combinación más común de todas en la programación de sistemas es un entero con un size_t, sin signo y de 8 bytes. Este programa reúne varios casos:

#include <stdio.h>
#include <stdint.h>
#include <string.h>

int main(void)
{
    unsigned char a = 200, b = 100;
    printf("a + b = %d, y sizeof(a + b) = %zu\n", a + b, sizeof(a + b));

    int votos = 7, total = 2;
    double promedio = votos / total;
    printf("promedio = %.2f\n", promedio);
    printf("promedio = %.2f\n", (double) votos / total);

    uint32_t ancho = 100000, alto = 100000;
    uint64_t pixeles = ancho * alto;
    printf("pixeles = %llu\n", (unsigned long long) pixeles);
    pixeles = (uint64_t) ancho * alto;
    printf("pixeles = %llu\n", (unsigned long long) pixeles);

    const char *vacia = "";
    printf("strlen(vacia) - 1 = %zu\n", strlen(vacia) - 1);

    int negativo = -1;
    unsigned int uno = 1;
    printf("-1 < 1u es %s\n", negativo < uno ? "verdadero" : "falso");
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o conversiones conversiones.c
conversiones.c: In function ‘main’:
conversiones.c:26:40: warning: comparison of integer expressions of different signedness: ‘int’ and ‘unsigned int’ [-Wsign-compare]
…
$ ./conversiones
a + b = 300, y sizeof(a + b) = 4
promedio = 3.00
promedio = 3.50
pixeles = 1410065408
pixeles = 10000000000
strlen(vacia) - 1 = 18446744073709551615
-1 < 1u es falso

Cada línea es un error clásico:

• El promedio de 3,00. votos / total es una división entre dos int, que da 3; recién después se convierte a double para guardarlo. El tipo del destino no influye en cómo se calcula la expresión. Hay que convertir un operando antes de dividir.
• Los píxeles perdidos. ancho * alto multiplica dos uint32_t, y el resultado se calcula en 32 bits: diez mil millones no cabe, da la vuelta a 1410065408, y ese valor ya truncado se guarda en el uint64_t. Ninguna advertencia lo señala, ni siquiera -Wconversion. Al calcular tamaños de memoria o de archivos con enteros de 32 bits, este error es frecuente y peligroso.
• strlen(vacia) - 1. strlen devuelve un size_t, sin signo, y 0 − 1 da la vuelta al mayor valor posible. Un código que recorra «hasta el último carácter» con strlen(s) - 1 falla con la cadena vacía.

El mismo problema de size_t aparece en un bucle que cuenta hacia atrás. El compilador, por suerte, lo advierte:

$ gcc -std=c17 -Wall -Wextra -o bucle bucle.c
bucle.c: In function ‘main’:
bucle.c:6:26: warning: comparison of unsigned expression in ‘>= 0’ is always true [-Wtype-limits]
    6 |     for (size_t i = 2; i >= 0; i--)
      |                          ^~

Un size_t siempre es mayor o igual que cero: cuando i vale 0 y se decrementa, da la vuelta a un número enorme, y el bucle sigue, ahora leyendo fuera del arreglo. La forma correcta de recorrer hacia atrás con un índice sin signo es for (size_t i = n; i > 0; i--), usando datos[i - 1] dentro.

10. Conversiones al asignar

Al asignar un valor a una variable de otro tipo, C lo convierte al tipo del destino, sin preguntar. Si el valor cabe, no hay problema; si no cabe, depende de los tipos:

#include <stdio.h>

int main(void)
{
    int grande = 70000;
    short corto = grande;              /* no cabe en 16 bits */
    unsigned char byte = -1;           /* negativo en un sin signo */
    int truncado = 3.99;               /* de double a int */
    int negativo = -3.99;

    printf("corto = %d, byte = %d, truncado = %d, negativo = %d\n",
           corto, byte, truncado, negativo);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o asignar asignar.c && ./asignar
corto = 4464, byte = 255, truncado = 3, negativo = -3
$ gcc -std=c17 -Wall -Wextra -Wconversion -o asignar asignar.c 2>&1 | grep warning
asignar.c:6:19: warning: conversion from ‘int’ to ‘short int’ may change value [-Wconversion]
asignar.c:7:26: warning: unsigned conversion from ‘int’ to ‘unsigned char’ changes value from ‘-1’ to ‘255’ [-Wsign-conversion]
asignar.c:8:20: warning: conversion from ‘double’ to ‘int’ changes value from ‘3.9900000000000002e+0’ to ‘3’ [-Wfloat-conversion]
asignar.c:9:20: warning: conversion from ‘double’ to ‘int’ changes value from ‘-3.9900000000000002e+0’ to ‘-3’ [-Wfloat-conversion]

Estas conversiones silenciosas son la razón de ser de -Wconversion, que vimos en el tema 4. Con código nuevo vale la pena usarla, y resolver cada advertencia con una conversión explícita cuando la pérdida es intencional. Fíjate en que el redondeo no es automático: 3,99 se convierte en 3, no en 4. Para redondear está round, de math.h.

11. Conversiones explícitas

Una conversión explícita, o cast, se escribe con el tipo destino entre paréntesis delante de la expresión: (double) votos. Hace la misma conversión que haría una asignación, pero en el lugar exacto donde se la pone, y deja claro que es intencional. Ya la usamos varias veces: (void *) con %p en el tema 1, (intmax_t) con los tipos del sistema en el tema 5, y en conversiones.c para arreglar los dos errores:

• (double) votos / total convierte votos antes de dividir; por las conversiones habituales, total también pasa a double, y la división da 3,5. En cambio, (double) (votos / total) convierte el resultado de una división entera ya hecha, y sigue dando 3,0.
• (uint64_t) ancho * alto convierte ancho a 64 bits, y la multiplicación se hace en 64 bits.

Una conversión explícita no comprueba nada: le dice al compilador que el programador sabe lo que hace. Si el valor no cabe, el resultado es el mismo que en la sección anterior, y con punto flotante puede ser comportamiento indefinido:

$ ./dbl
-2147483648
$ gcc -std=c17 -Wall -Wextra -fsanitize=float-cast-overflow -o dbl dbl.c && ./dbl
dbl.c:5:5: runtime error: 3e+10 is outside the range of representable values of type 'int'
-2147483648

Por eso los casts deben ser pocos y estar justificados. Muchos casts en un programa suelen indicar que los tipos de las variables están mal elegidos; y uno que «arregla» una advertencia sin entenderla puede esconder un error real.

12. Precedencia y asociatividad

Cuando una expresión tiene varios operadores, la precedencia decide cuáles se aplican primero, y la asociatividad, el orden entre operadores de la misma precedencia. C tiene quince niveles:

La mayor parte de la tabla coincide con la intuición matemática: multiplicar antes que sumar, comparar antes de combinar con &&, asignar al final. La asociatividad de izquierda a derecha hace que 20 - 5 - 3 sea (20 - 5) - 3, 12; la de derecha a izquierda de la asignación hace funcionar p = q = r = 0. Pero hay dos lugares donde la tabla traiciona:

#include <stdio.h>

int main(void)
{
    int a = 2, b = 3, c = 4;
    int permisos = 6;

    printf("a + b * c       = %d\n", a + b * c);
    printf("(a + b) * c     = %d\n", (a + b) * c);
    printf("20 - 5 - 3      = %d\n", 20 - 5 - 3);
    printf("1 << 2 + 1      = %d\n", 1 << 2 + 1);
    if (permisos & 4 == 4)
        printf("tiene lectura\n");
    else
        printf("no tiene lectura (?)\n");
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o precedencia precedencia.c
precedencia.c: In function ‘main’:
precedencia.c:11:40: warning: suggest parentheses around ‘+’ inside ‘<<’ [-Wparentheses]
   11 |     printf("1 << 2 + 1      = %d\n", 1 << 2 + 1);
      |                                        ^~
precedencia.c:12:18: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
   12 |     if (permisos & 4 == 4)
      |                  ^
$ ./precedencia
a + b * c       = 14
(a + b) * c     = 20
20 - 5 - 3      = 12
1 << 2 + 1      = 8
no tiene lectura (?)

1 << 2 + 1 vale 8 y no 5: la suma tiene más precedencia que el desplazamiento, y la expresión es 1 << 3. Y permisos & 4 == 4 no comprueba si el bit de lectura está encendido: == tiene más precedencia que &, de modo que primero se compara 4 == 4, que da 1, y luego se calcula 6 & 1, que da 0. Es un defecto reconocido del diseño de C, heredado de cuando & también se usaba como «y» lógico, y es exactamente el tipo de comprobación de permisos o de banderas que escribiremos en el tema 8. Lo correcto es (permisos & 4) != 0. -Wall advierte de los dos casos.

Nadie recuerda la tabla entera, y no hace falta. La regla práctica es memorizar lo básico, aritmética antes que comparaciones, comparaciones antes que && y ||, asignación al final, y poner paréntesis en todo lo demás, en especial cuando aparecen operadores de bits o desplazamientos. Los paréntesis no cuestan nada y le ahorran al lector consultar la tabla.

13. El orden de evaluación

La precedencia dice cómo se agrupan los operandos, pero no en qué orden se calculan. En f() + g(), la precedencia dice que se suman los dos resultados; el estándar no dice cuál de las dos funciones se llama primero. Es no especificado: el compilador elige, y puede elegir distinto en cada caso.

#include <stdio.h>

static int f(const char *nombre, int valor)
{
    printf("[%s]", nombre);
    return valor;
}

int main(void)
{
    int i = 1;

    int suma = f("izquierda", 1) + f("derecha", 2);
    printf("  suma = %d\n", suma);

    i = i++ + 1;
    printf("i = %d\n", i);
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o orden orden.c
orden.c: In function ‘main’:
orden.c:16:7: warning: operation on ‘i’ may be undefined [-Wsequence-point]
   16 |     i = i++ + 1;
      |     ~~^~~~~~~~~
$ ./orden
[izquierda][derecha]  suma = 3
i = 2

Aquí gcc llamó primero a la función de la izquierda, pero un programa que dependa de eso no es correcto. La suma no cambia, pero el orden de los mensajes sí: si las funciones tuvieran efectos que interactúan, como leer de un archivo, el resultado dependería del compilador. Lo mismo vale para los argumentos de una función: en printf("%d %d", f(), g()), el orden de las llamadas no está definido.

La segunda línea es más grave. i = i++ + 1 modifica i dos veces, con la asignación y con el ++, sin que el estándar ordene esas dos modificaciones entre sí. Eso no es solo no especificado: es comportamiento indefinido, y -Wall lo advierte con -Wsequence-point. El resultado, 2, es uno entre varios posibles. La regla para no caer nunca en esto es simple: en una misma expresión, si una variable se modifica, no se la usa ni se la modifica en ningún otro lugar.

Hay excepciones que el estándar sí ordena, y que justamente por eso son seguras: &&, ||, el operador coma y ?: evalúan siempre su operando izquierdo, o la condición, antes que el resto. Por eso divisor != 0 && 100 / divisor > 5 es correcto.

14. Errores frecuentes

15. Resumen

• Toda expresión tiene un valor y un tipo; algunas tienen además efectos secundarios. El tipo de los operandos decide cómo se hace la operación.
• La división entera trunca hacia cero, y el resto toma el signo del dividendo. Dividir un entero por cero, o INT_MIN por −1, termina el programa con SIGFPE.
• a++ vale el valor anterior y ++a el nuevo. La asignación es una expresión que vale lo asignado.
• Las comparaciones y los operadores lógicos devuelven 0 o 1. && y || hacen cortocircuito: el operando derecho solo se evalúa si hace falta.
• El desbordamiento con signo es comportamiento indefinido, y el optimizador puede eliminar comprobaciones como x + 1 > x. Se detecta con -fsanitize=undefined y se evita comprobando antes de operar o con ckd_add de C23.
• La promoción entera convierte los tipos menores que int a int antes de operar.
• Las conversiones aritméticas habituales llevan los operandos a un tipo común; al mezclar con signo y sin signo del mismo rango, gana el sin signo, y −1 se vuelve enorme.
• El tipo del destino no cambia cómo se calcula una expresión: double p = 7 / 2 vale 3, y uint64_t t = a32 * b32 desborda en 32 bits.
• Al asignar, el valor se convierte al tipo del destino: los sin signo conservan los bits bajos, y de punto flotante a entero se trunca hacia cero. -Wconversion advierte de las pérdidas.
• Un cast convierte en un lugar preciso, sin comprobar nada.
• == tiene más precedencia que &, y + más que <<: con operadores de bits, siempre paréntesis.
• El orden de evaluación de los operandos no está especificado, salvo en &&, ||, ?: y la coma. Modificar una variable dos veces en una expresión es comportamiento indefinido.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Escribe una función es_par(int n) correcta para negativos, y otra modulo(int a, int b) que devuelva siempre un resto entre 0 y b - 1, aunque a sea negativo. Pruébalas con −7, −1, 0 y 7.
2. Modifica porcero.c para que compruebe el divisor y, si es 0, informe el error por stderr y termine con EXIT_FAILURE. Prueba también ./intmin con −1 y protégelo.
3. Escribe suma_segura(int a, int b, int *resultado) que devuelva 0 si la suma desbordaría y 1 si no, sin usar ckd_add. Cubre también el caso de b negativo. Compárala con ckd_add compilando con -std=c23.
4. Compila desborde.c con -O1, -O2 y -O2 -fwrapv, y mira el ensamblador de cabe_uno_mas en cada caso. ¿En qué nivel desaparece la suma?
5. Calcula el tamaño en bytes de una imagen de 70000 × 70000 píxeles de 4 bytes cada uno, primero con int y después con size_t. Compila con -Wall -Wextra -Wconversion y anota qué advierte el compilador y qué no.
6. Agrega paréntesis a precedencia.c hasta que compile sin advertencias y cada línea haga lo que su texto sugiere.
7. Escribe un bucle que recorra un arreglo de 5 enteros de atrás hacia adelante usando un índice size_t, sin advertencias y sin salirse del arreglo.