Punteros y arrays en C: decaimiento, arr[i] = *(arr+i) y la trampa de sizeof

Los arrays y los punteros son cosas distintas en C que se comportan igual la mayor parte del tiempo. Ese "la mayor parte del tiempo" es lo que vuelve resbaladizo el tema: el código que trata un array como un puntero suele funcionar, hasta el día en que aterriza en uno de los dos lugares donde la diferencia importa y la respuesta es silenciosamente incorrecta.

Esta página traza la línea con precisión.

El decaimiento del array: la regla detrás de todo

En casi toda expresión, el nombre de un array se convierte automáticamente en un puntero a su primer elemento. Esto se llama decaimiento. arr pasa a ser &arr[0], con tipo int *.

#include <stdio.h>

int main(void) {
    int arr[4] = {10, 20, 30, 40};

    printf("arr      = %p\n", (void *)arr);       // decae a &arr[0]
    printf("&arr[0]  = %p\n", (void *)&arr[0]);   // la misma direccion
    printf("*arr     = %d\n", *arr);              // 10, el primer elemento

    int *p = arr;                                  // sin & : el decaimiento lo hace
    printf("*p       = %d\n", *p);

    return 0;
}

El nombre del array y la dirección de su primer elemento se imprimen idénticos. Eso es el decaimiento en acción, y es por lo que puedes asignar un array a un puntero sin ningún &.

Hay exactamente tres lugares donde el decaimiento no ocurre: como operando de sizeof, como operando de &, y al inicializar un array de caracteres a partir de un literal de cadena. En todos los demás, da por hecho el decaimiento.

arr[i] es literalmente *(arr + i)

El estándar de C define el operador de subíndice en términos de aritmética de punteros: a[b] significa *(a + b). La indexación no es una característica aparte: es una abreviatura.

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d   *(arr + %d) = %d\n",
               i, arr[i], i, *(arr + i));
    }

    int *p = arr;
    printf("\np[2] = %d  (un puntero tambien se puede indexar)\n", p[2]);
    printf("2[arr] = %d  (legal, porque la suma es conmutativa)\n", 2[arr]);

    return 0;
}

De ahí salen dos consecuencias. Primera, un puntero se puede indexar: p[2] es *(p + 2), que es por lo que las funciones que reciben un puntero pueden seguir usando la sintaxis familiar arr[i]. Segunda, 2[arr] compila: *(2 + arr) es la misma dirección que *(arr + 2). Nadie escribe eso fuera de un examen, pero zanja la pregunta de si la indexación es "de verdad" aritmética de punteros.

Pasar un array a una función

Por el decaimiento, una función nunca recibe un array. Recibe un puntero.

#include <stdio.h>

// estas tres declaraciones son IDENTICAS para el compilador
int sum_a(int arr[], int n);
int sum_b(int arr[100], int n);   // el 100 se ignora por completo
int sum_c(int *arr, int n);

int sum_c(int *arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];

    printf("n      = %d\n", n);
    printf("suma   = %d\n", sum_c(data, n));

    // tambien funciona con un trozo: un puntero es solo una posicion de inicio
    printf("cola   = %d\n", sum_c(data + 3, 3));

    return 0;
}

Hay tres cosas que rescatar de ese ejemplo.

El tamaño en int arr[100] es documentación, nada más. El compilador reescribe el parámetro como int *arr y nunca comprueba que hayas pasado 100 de nada.

La longitud debe viajar aparte. La función tiene una dirección y ninguna idea de hasta dónde se extienden los datos. Es por esto que prácticamente cada función de C que recibe un array recibe también un conteo: memcpy(dst, src, n), fread(ptr, size, count, f), qsort(base, nmemb, size, cmp). Las cadenas son la excepción solo porque llevan su propia marca de fin, el '\0'.

Pasar un puntero es barato y los datos se comparten. No se hace ninguna copia del array, así que la función puede modificar los elementos de quien la llama, que a menudo es exactamente lo que quieres:

#include <stdio.h>

void double_all(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] *= 2;
    }
}

void print_all(const int *arr, int n) {   // const: promete no modificar
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    int values[5] = {1, 2, 3, 4, 5};

    print_all(values, 5);
    double_all(values, 5);
    print_all(values, 5);      // el array de quien llama cambio de verdad

    return 0;
}

Marca los parámetros de solo lectura como const int *, igual que hace print_all. Documenta la intención y deja que el compilador detecte una escritura accidental.

La trampa de sizeof

Aquí está el error que atrapa a todo programador de C una vez. sizeof es uno de los dos lugares donde no ocurre el decaimiento, así que da el tamaño real del array donde el array está declarado, y el tamaño de un puntero en cualquier sitio donde el array haya decaído.

#include <stdio.h>

void inspect(int arr[]) {
    printf("dentro de la funcion: sizeof(arr) = %zu\n", sizeof arr);
    printf("dentro de la funcion: longitud calculada = %zu  <-- MAL\n",
           sizeof arr / sizeof arr[0]);
}

int main(void) {
    int data[10] = {0};

    printf("en main: sizeof(data) = %zu\n", sizeof data);
    printf("en main: longitud = %zu  <-- correcto\n",
           sizeof data / sizeof data[0]);

    inspect(data);
    return 0;
}

En main, sizeof data son 40 bytes y la longitud da 10. Dentro de inspect, sizeof arr es el tamaño de un puntero —8 en una máquina de 64 bits— y la "longitud" sale 2. El código se ve idéntico y está silenciosamente mal.

La regla que se deduce: calcula la longitud de un array solo en el ámbito donde el array fue declarado, y pásala desde ahí.

El & de un array no es del mismo tipo

El otro lugar donde no ocurre el decaimiento es el operador &. &arr es un puntero al array entero, no a su primer elemento. Ambos guardan la misma dirección; la diferencia es lo que significa "suma 1".

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    printf("arr      = %p   arr + 1  = %p\n",
           (void *)arr, (void *)(arr + 1));      // avanza 4 bytes (un int)
    printf("&arr     = %p   &arr + 1 = %p\n",
           (void *)&arr, (void *)(&arr + 1));    // avanza 20 bytes (el array)

    return 0;
}

La misma dirección de partida, distinta zancada. arr tiene tipo int * y avanza de a un elemento; &arr tiene tipo int (*)[5] y avanza el array entero. Este es el mecanismo que hace que pasar una fila de un array 2D funcione, cosa que se cubre en arrays multidimensionales.

Puntero a array frente a array de punteros

Dos declaraciones que se parecen y significan cosas opuestas:

int *p[5];     // array de 5 punteros a int
int (*q)[5];   // puntero a un array de 5 ints

[] tiene mayor precedencia que *, así que int *p[5] se analiza como "p es un array, de punteros". Los paréntesis de int (*q)[5] obligan al * a asociarse primero: "q es un puntero, a un array".

int *p[5]                     int (*q)[5]

 p[0] -> [ int ]               q -> [ int | int | int | int | int ]
 p[1] -> [ int ]                     un bloque contiguo de 5
 p[2] -> [ int ]
 p[3] -> [ int ]
 p[4] -> [ int ]
 cinco direcciones separadas

Un array de punteros es el caso común, y ya lo has usado: char *argv[] es un array de punteros a cadenas, una por argumento de la línea de comandos. También es la forma de guardar una lista de cadenas de distintas longitudes sin desperdiciar espacio.

#include <stdio.h>

int main(void) {
    // array de punteros: cada entrada apunta a una cadena de su propia longitud
    const char *days[] = {"lunes", "martes", "miercoles"};
    int n = sizeof days / sizeof days[0];

    for (int i = 0; i < n; i++) {
        printf("%d: %s\n", i, days[i]);
    }

    // puntero a un array de 5 ints
    int block[5] = {1, 2, 3, 4, 5};
    int (*q)[5] = &block;

    printf("via q: %d %d\n", (*q)[0], (*q)[4]);
    printf("sizeof(*q) = %zu bytes (el array entero)\n", sizeof *q);

    return 0;
}

Fíjate en (*q)[0]: desreferencia el puntero para obtener el array y luego indéxalo. Los paréntesis vuelven a ser obligatorios, por la misma razón de precedencia.

Dónde difieren de verdad arrays y punteros

Ten presente esta tabla corta y la confusión desaparece:

El nombre de un array no es una variable que guarda una dirección: es el almacenamiento, y la dirección se calcula bajo demanda. Por eso no puedes asignarle nada.