Bucles, funciones y arreglos en C: off-by-one y ASan
Curso de C 2 con Apple clang 21: if, bucles, funciones, = vs ==, por qué sizeof da 8 dentro de una función y un off-by-one que cambió 7 por 500.
Serie: curso de C 2/6 (principiante). Esta clase es para ti si terminaste la clase 1 o ya sabes compilar un hola mundo: quizá llevas C en la universidad, estás en un bootcamp que toca sistemas embebidos o te acaban de asignar un módulo en C en tu primer trabajo. Al terminar vas a escribir if, bucles y tus propias funciones, vas a pasar arreglos a funciones de forma correcta y vas a encontrar en segundos, no en horas, el bug de arreglos más común de C: escribir un elemento de más.
Los arreglos son el punto donde C deja de protegerte. Un programa en Java o Python que lee más allá del final de un arreglo se detiene con una excepción; un programa en C sigue de largo, y lo que pasa después depende de los flags del compilador. Esta clase lo muestra literalmente: un bug, cuatro builds, cuatro resultados distintos. Todo el código se compiló y ejecutó con Apple clang 21.0.0 en una Mac con Apple Silicon (M1 Pro), macOS 26, siempre con -std=c17 -Wall -Wextra; las rutas de la salida se acortaron a ~/demo/.
if, bucles y funciones en un solo programa
Aquí tienes un pequeño reporte de calificaciones. Usa todo lo que explica esta sección:
#include <stdio.h>
#define N 5
double average(const int scores[], int n) {
int sum = 0;
for (int i = 0; i < n; i++)
sum += scores[i];
return (double)sum / n;
}
char grade(int score) {
if (score >= 90) return 'A';
else if (score >= 80) return 'B';
else if (score >= 70) return 'C';
return 'F';
}
int main(void) {
int scores[N] = {88, 92, 79, 65, 95};
for (int i = 0; i < N; i++)
printf("student %d: %3d -> %c\n", i + 1, scores[i], grade(scores[i]));
printf("average: %.1f\n", average(scores, N));
int i = 0;
while (i < N && scores[i] < 90) /* first student with an A */
i++;
if (i < N) printf("first A: student %d\n", i + 1);
return 0;
}
student 1: 88 -> B
student 2: 92 -> A
student 3: 79 -> C
student 4: 65 -> F
student 5: 95 -> A
average: 83.8
first A: student 2
Los términos, una sola vez:
#define N 5es una constante del preprocesador: cadaNse reemplaza por5antes de compilar.int scores[N]es un arreglo (array): 5 int uno junto al otro en memoria, con índices de0a4.- Una función tiene un tipo de retorno (
double,char), un nombre y parámetros.const int scores[]promete que la función no va a modificar el arreglo. for (init; condición; paso)se repite mientras la condición sea verdadera.whilesolo revisa una condición.&&es "y", y hace cortocircuito: eni < N && scores[i] < 90, cuandoillega a 5 el lado derecho nunca se evalúa, así quescores[5]nunca se lee. Si inviertes los dos lados, tienes un bug.
Cuatro bugs que el compilador te avisa
Este archivo compila y corre:
#include <stdio.h>
int sign(int x) {
if (x > 0) return 1;
if (x < 0) return -1;
} /* forgot: return 0 */
int main(void) {
int n = 5;
if (n = 0) /* meant n == 0 */
printf("n is zero\n");
printf("n is now %d, sign(n) = %d\n", n, sign(n));
int a[3] = {1, 2, 3};
a[3] = 4; /* index 3 does not exist */
switch (n) {
case 0: printf("zero\n");
case 1: printf("one\n"); /* fall through */
}
return 0;
}
Los warnings de clang (recortados a la primera línea de cada uno):
traps.c:6:1: warning: non-void function does not return a value in all control paths [-Wreturn-type]
traps.c:10:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
traps.c:10:11: note: use '==' to turn this assignment into an equality comparison
traps.c:15:5: warning: array index 3 is past the end of the array (that has type 'int[3]') [-Warray-bounds]
3 warnings generated.
Y la ejecución:
n is now 0, sign(n) = 0
zero
one
Tres sorpresas en tres líneas. n = 0 asignó 0, así que el if fue falso y n quedó destruido. sign(0) imprimió 0, lo que parece correcto pero es pura suerte: llegar al final de una función no void y usar el resultado es comportamiento indefinido, y obtienes lo que haya quedado en el registro de retorno. Un borrador anterior de este mismo archivo, con un bucle extra en main, imprimió sign(n) = 1, y el archivo de arriba compilado con -O2 imprimió sign(n) = -1. Tres builds, tres respuestas. Y switch imprimió tanto zero como one, porque sin break la ejecución cae (fall-through) al siguiente case. El fall-through no está incluido en -Wall -Wextra; agrega -Wimplicit-fallthrough y clang dice:
traps.c:19:5: warning: unannotated fall-through between switch labels [-Wimplicit-fallthrough]
traps.c:19:5: note: insert 'break;' to avoid fall-through
Cuando el fall-through es intencional, márcalo. En C23 es [[fallthrough]]; (compilado con -std=c23 en clang 21); en C17 clang sugiere __attribute__((fallthrough));.
Una trampa más de bucles que -Wall -Wextra no detecta:
for (unsigned i = 2; i >= 0; i--) /* i >= 0 is always true */
i=2
i=1
i=0
i=4294967295
i=4294967294
(Lo detuvimos después de 5 líneas.) Un valor unsigned nunca puede ser negativo, así que 0 - 1 da la vuelta a 4,294,967,295. Solo -Wtype-limits o -Wtautological-unsigned-zero-compare lo reportan: result of comparison of unsigned expression >= 0 is always true.
Los arreglos se convierten en punteros y sizeof miente dentro de las funciones
#include <stdio.h>
void show(int arr[]) {
printf("inside show: sizeof(arr) = %zu\n", sizeof(arr));
}
int main(void) {
int a[5] = {1, 2, 3, 4, 5};
printf("in main: sizeof(a) = %zu\n", sizeof(a));
printf("elements: %zu\n", sizeof(a) / sizeof(a[0]));
show(a);
printf("a = %p\n", (void *)a);
printf("&a[0] = %p\n", (void *)&a[0]);
printf("&a = %p\n", (void *)&a);
printf("a + 1 = %p (+%td bytes)\n", (void *)(a + 1), (char *)(a + 1) - (char *)a);
printf("&a + 1 = %p (+%td bytes)\n", (void *)(&a + 1), (char *)(&a + 1) - (char *)a);
return 0;
}
sizeoftrap.c:4:54: warning: sizeof on array function parameter will return size of 'int *' instead of 'int[]' [-Wsizeof-array-argument]
in main: sizeof(a) = 20
elements: 5
inside show: sizeof(arr) = 8
a = 0x16f38e470
&a[0] = 0x16f38e470
&a = 0x16f38e470
a + 1 = 0x16f38e474 (+4 bytes)
&a + 1 = 0x16f38e484 (+20 bytes)
Cuando pasas un arreglo a una función, C pasa solo la dirección de su primer elemento. Esto se llama array decay (decaimiento del arreglo): int arr[] en una lista de parámetros significa exactamente int *arr. Dentro de show, sizeof(arr) es el tamaño de un puntero (8), no del arreglo (20). Las direcciones muestran la diferencia entre las tres formas de escribirlo: a, &a[0] y &a imprimen la misma dirección, pero a + 1 avanza un int (4 bytes) mientras que &a + 1 avanza el arreglo completo (20 bytes), porque &a tiene tipo "puntero a arreglo de 5 int". Tus direcciones van a cambiar en cada ejecución (aleatorización del espacio de direcciones).
La regla que se desprende: una función no puede averiguar cuánto mide un arreglo. Pásale la longitud:
double average(const int scores[], int n); /* every C API does this */
int n = (int)(sizeof a / sizeof a[0]); /* only valid where a is a real array */
Off-by-one: un bug, cuatro resultados
El bug de arreglos más común escribe un elemento de más:
#include <stdio.h>
int main(void) {
int guard = 7;
int a[5];
for (int i = 0; i <= 5; i++) /* <= should be < */
a[i] = i * 100;
printf("a[4]=%d guard=%d\n", a[4], guard);
return 0;
}
No hay warning: el índice es una variable, y -Warray-bounds solo ve índices constantes. Lo compilamos de cuatro maneras:
| Build | Salida | Código de salida |
|---|---|---|
clang -O0 (por defecto) |
Abort trap: 6 |
134 |
clang -O0 -fno-stack-protector |
a[4]=400 guard=500 |
0 |
clang -O2 |
a[4]=400 guard=7 |
0 |
clang -fsanitize=address -g |
stack-buffer-overflow ... offbyone.c:7 |
134 |
- En
-O0, Apple clang inserta un stack protector (encontramos___stack_chk_failen el binario connm). La escritura de más pisó su valor canario y el programa abortó al final demain, sin número de línea. - Sin el protector,
a[5]cayó justo sobreguard, que en silencio pasó a valer 500. Es el peor caso: datos equivocados y código de salida 0. - En
-O2la salida parecía correcta. El bug sigue ahí; el optimizador simplemente acomodó la memoria de otra forma. "En release funciona" no prueba nada. - Con AddressSanitizer (ASan), el programa se detuvo en la primera escritura inválida:
==74769==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x00016b9b63b4 ...
WRITE of size 4 at 0x00016b9b63b4 thread T0
#0 0x0001044489c0 in main offbyone.c:7
This frame has 1 object(s):
[32, 52) 'a' (line 5) <== Memory access at offset 52 overflows this variable
SUMMARY: AddressSanitizer: stack-buffer-overflow offbyone.c:7 in main
Léelo de arriba hacia abajo: una escritura (WRITE) de 4 bytes, en la línea 7, justo después de los 20 bytes (offsets 32 a 52) de a. Ese es todo el diagnóstico. ASan agrega revisiones alrededor de cada acceso a memoria; cuesta velocidad, medida abajo, pero convierte "a veces sale mal" en "siempre se detiene en la línea".
Error típico → lo que realmente pasa → solución
| Error | Lo que vimos | Solución |
|---|---|---|
if (n = 0) |
condición falsa, n sobrescrito |
==; nunca ignores -Wparentheses |
falta un return |
sign(0) dio 0, 1 o -1 según el build |
retorna en todos los caminos; -Wreturn-type |
switch sin break |
imprimió zero y one |
break;, o marca la intención con [[fallthrough]]; |
unsigned i; i >= 0; i-- |
pasó de 0 a 4294967295 | usa int, o for (unsigned i = n; i-- > 0; ) |
sizeof(arr) en una función |
8 en vez de 20 | pasa la longitud como parámetro |
i <= N sobre a[N] |
abort, corrupción silenciosa o "todo bien" | i < N; prueba con -fsanitize=address |
¿Cuánto cuesta ASan? (medido)
Para decidir si ASan puede quedarse activado en los builds del día a día, medimos 200 pasadas sobre un arreglo de 1,000,000 de int (200 millones de lecturas, valores de un generador con semilla fija), 7 ejecuciones de cada una, mediana. Cada pasada suma un rango un poco más corto, para que el optimizador no pueda reutilizar un mismo resultado en las 200.
| Build | Mediana | Factor | Tamaño del binario |
|---|---|---|---|
-O0 |
190.1 ms | 33,528 B | |
-O0 -fsanitize=address |
314.4 ms | 1.7× | 51,272 B |
-O2 |
10.2 ms | 33,512 B | |
-O2 -fsanitize=address |
35.7 ms | 3.5× | 51,320 B |
-O2 con ASan siguió siendo cinco veces más rápido que -O0 sin nada. Un primer intento en el que cada pasada sumaba el arreglo completo dio números de -O2 sospechosamente rápidos hasta que variamos la longitud: un buen recordatorio de revisar si tu benchmark tiene trabajo que el compilador puede saltarse. Nuestra recomendación para principiantes: desarrolla siempre con -g -fsanitize=address,undefined, y corre tus tests de la misma forma.
Límites honestos y notas de versión
- Solo se ejecutó con Apple clang 21.0.0 en macOS 26 arm64. En Linux, gcc y clang soportan el mismo
-fsanitize=address(no lo ejecutamos aquí); MSVC tiene/fsanitize=address(no lo ejecutamos aquí). - Que el stack protector venga activado por defecto depende de la plataforma y de la distribución; el abort en
-O0es lo que hizo Apple clang aquí, no una garantía. - Declarar la variable del bucle dentro de
for (int i = 0; ...)es C99.[[fallthrough]]es C23; lo compilamos con-std=c23. Con-std=c17el mismo archivo falló por otra característica de C23 (nullptr:use of undeclared identifier 'nullptr'). - Los arreglos de longitud variable (
int a[n]) existen desde C99 pero pasaron a ser opcionales en C11; no los usamos. - Las direcciones cambian en cada ejecución; los tiempos son de una sola máquina.
Ejercicios
1. Esta función debería devolver el promedio del arreglo. Para {10, 20, 30, 40, 50} imprime 15.0. ¿Por qué, y cómo lo arreglas?
double avg(int a[]) {
int n = sizeof(a) / sizeof(a[0]);
int s = 0;
for (int i = 0; i < n; i++) s += a[i];
return (double)s / n;
}
2. Escribe void reverse(int a[], int n), que invierte un arreglo en su lugar, e int max_of(const int a[], int n). Pruébalas con {3, 9, -2, 7, 5} y con un arreglo de un solo elemento, compilando con -fsanitize=address,undefined.
Respuestas
1. Dentro de la función a es un puntero, así que n vale 8 / 4 = 2 y la función promedia solo 10 y 20. clang avisa dos veces: -Wsizeof-array-argument y 'sizeof (a)' will return the size of the pointer, not the array itself [-Wsizeof-pointer-div]. Solución: double avg(const int a[], int n) y llamar a avg(a, (int)(sizeof a / sizeof a[0])) desde donde se declara a.
2. Una solución, que corrió limpia con ASan y UBSan:
void reverse(int a[], int n) {
for (int i = 0, j = n - 1; i < j; i++, j--) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
int max_of(const int a[], int n) {
int m = a[0];
for (int i = 1; i < n; i++)
if (a[i] > m) m = a[i];
return m;
}
5 7 -2 9 3
max = 9
one = 42, max = 42
i < j (y no i <= j) se detiene antes de que el elemento del medio se intercambie consigo mismo, y con un solo elemento el cuerpo del bucle nunca se ejecuta. max_of arranca desde a[0], no desde 0, así que funciona con arreglos donde todo es negativo.
Lo que sigue
La clase 3 abre la caja que el array decay dejó entrever: punteros, malloc y free, y lo que dice ASan sobre use-after-free, double free y fugas de memoria.
- Anterior: curso de C 1/6: primer programa, tipos, printf y warnings
- Siguiente: curso de C 3/6: punteros y malloc
- Más adelante: strings, structs y buffer overflows, comportamiento indefinido y optimización, caché, make y lldb
- Arreglos en la práctica: algoritmos de ordenamiento en C/C++ con ASan (en inglés), y la hoja de ruta para aprender a programar
Preguntas frecuentes
¿Por qué sizeof de un arreglo da 8 dentro de una función en C?
Un parámetro arreglo es en realidad un puntero: void f(int arr[]) significa void f(int *arr), así que sizeof(arr) es el tamaño de un puntero, 8 bytes en una Mac de 64 bits, y no 20 para cinco int. clang avisa con -Wsizeof-array-argument. Pasa la longitud como parámetro aparte y calcúlala en quien llama con sizeof a / sizeof a[0].
¿C revisa los límites de un arreglo?
No. Escribir a[5] en int a[5] compila y muchas veces corre. En nuestra prueba el mismo bug abortó en -O0 (stack protector, código de salida 134), cambió en silencio una variable vecina de 7 a 500 sin stack protector y pareció correcto en -O2. Compila con -fsanitize=address mientras desarrollas: se detuvo con stack-buffer-overflow en la línea exacta.
¿Cuánto más lento es un programa compilado con AddressSanitizer?
En nuestro benchmark de lectura de arreglos, unas 1.7 veces en -O0 (de 190 ms a 314 ms) y unas 3.5 veces en -O2 (de 10.2 ms a 35.7 ms), y el binario pasó de unos 33 KB a 51 KB. Es lo bastante barato para dejar ASan activado en todos los tests y builds de depuración.