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 5 es una constante del preprocesador: cada N se reemplaza por 5 antes de compilar.
  • int scores[N] es un arreglo (array): 5 int uno junto al otro en memoria, con índices de 0 a 4.
  • 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. while solo revisa una condición.
  • && es "y", y hace cortocircuito: en i < N && scores[i] < 90, cuando i llega a 5 el lado derecho nunca se evalúa, así que scores[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
Diagrama. El bug, un bucle de i desde 0 hasta 5 inclusive que escribe en int a[5], se compila de cuatro maneras. Con -O0 el stack protector lo nota y el programa muere con Abort trap 6, código de salida 134. Con -O0 y -fno-stack-protector corre, sale con 0 y una variable vecina llamada guard cambia en silencio de 7 a 500. Con -O2 corre, sale con 0 e imprime guard=7, así que parece correcto. Con -fsanitize=address se detiene con stack-buffer-overflow en la línea 7 de offbyone.c.
Un mismo bug off-by-one, cuatro builds, cuatro resultados distintos. Solo AddressSanitizer señala la línea. Apple clang 21, macOS arm64.
  • En -O0, Apple clang inserta un stack protector (encontramos ___stack_chk_fail en el binario con nm). La escritura de más pisó su valor canario y el programa abortó al final de main, sin número de línea.
  • Sin el protector, a[5] cayó justo sobre guard, que en silencio pasó a valer 500. Es el peor caso: datos equivocados y código de salida 0.
  • En -O2 la 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
Gráfico de barras. -O0 tardó 190.1 milisegundos y -O0 con ASan 314.4, unas 1.7 veces más lento. -O2 tardó 10.2 milisegundos y -O2 con ASan 35.7, unas 3.5 veces más lento, pero aun así mucho más rápido que -O0 sin ASan.
Lo que cuesta AddressSanitizer: 200 pasadas sobre un arreglo de 1 millón de int (200 millones de lecturas). Mediana de 7 ejecuciones, Mac con Apple Silicon (M1 Pro).

-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 -O0 es 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=c17 el 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.

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.

  • #c
  • #principiante
  • #arreglos
  • #funciones
  • #addresssanitizer
  • #off-by-one

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑