Docs ejecutables de C: Arrays

Q: ¿Cómo se declara un array en C?

Indica el tipo de los elementos, un nombre y un tamaño entre corchetes: int scores[5]; reserva espacio para cinco enteros. El tamaño debe ser una constante conocida donde se declara el array (salvo en los arrays de longitud variable), y los elementos quedan sin inicializar a menos que les des valores.

Q: ¿Cómo se obtiene la longitud de un array en C?

sizeof(arr) / sizeof(arr[0]) - el tamaño total en bytes dividido entre el tamaño de un elemento. Solo funciona en el ámbito donde se declaró el array: una vez que lo pasas a una función ya se degradó a un puntero y sizeof mide el puntero.

Q: ¿Qué pasa si te sales del final de un array en C?

Nada te detiene. C no comprueba los límites, así que arr[10] en un array de 5 elementos lee o escribe la memoria que haya ahí. Eso es comportamiento indefinido: puede imprimir basura, corromper otra variable o fallar - y puede parecer que funciona hasta que deja de hacerlo.

Q: ¿Cómo se inicializan a cero todos los elementos de un array en C?

int arr[100] = {0}; - todos los elementos que no listes se inicializan a cero, así que un solo cero pone a cero el array entero. int arr[100] = {}; también funciona en C23. Sin ningún inicializador, el contenido de un array local es basura indeterminada.

Un array es un bloque de tamaño fijo de elementos del mismo tipo, dispuestos uno tras otro en memoria. Esa disposición contigua lo explica todo: es la razón de que indexar sea instantáneo, de que arrays y punteros estén tan relacionados, y de que C pueda darte la dirección del elemento cero y dejar que encuentres el resto con aritmética.

Declarar un array

Tipo de los elementos, nombre y un tamaño entre corchetes:

int    scores[5];       // 5 ints
double prices[100];     // 100 doubles
char   initials[3];     // 3 chars

El tamaño es el número de elementos, y debe conocerse donde se declara el array: normalmente un literal o una constante definida con #define. La memoria se reserva de inmediato; no se asigna nada después.

Un array local recién declarado contiene basura, no ceros:

#include <stdio.h>

int main(void) {
    int uninitialized[5];        // el contenido es indeterminado
    int zeroed[5] = {0};         // todos los elementos valen 0

    printf("con ceros:      ");
    for (int i = 0; i < 5; i++) printf("%d ", zeroed[i]);

    printf("\nsin inicializar: ");
    for (int i = 0; i < 5; i++) printf("%d ", uninitialized[i]);
    printf("   <-- lo que hubiera en esa memoria\n");

    return 0;
}

La segunda fila puede imprimir ceros, puede imprimir números enormes, y puede cambiar entre ejecuciones o entre una compilación de depuración y una de release. Leer esos valores es comportamiento indefinido; inicializa antes de leer.

Inicializar

Varias formas, todas útiles:

#include <stdio.h>

int main(void) {
    int a[5] = {10, 20, 30, 40, 50};   // lista completa
    int b[5] = {1, 2};                 // el resto se rellena con ceros: 1 2 0 0 0
    int c[5] = {0};                    // el array entero queda en cero
    int d[]  = {7, 8, 9};              // tamaño deducido: 3 elementos
    int e[5] = {[4] = 99, [0] = 1};    // inicializadores designados (C99)

    int n = sizeof d / sizeof d[0];

    printf("a: "); for (int i = 0; i < 5; i++) printf("%d ", a[i]);
    printf("\nb: "); for (int i = 0; i < 5; i++) printf("%d ", b[i]);
    printf("\nc: "); for (int i = 0; i < 5; i++) printf("%d ", c[i]);
    printf("\nd: "); for (int i = 0; i < n; i++) printf("%d ", d[i]);
    printf("  (tamano deducido como %d)", n);
    printf("\ne: "); for (int i = 0; i < 5; i++) printf("%d ", e[i]);
    printf("\n");

    return 0;
}

El truco del {0} es el que hay que recordar: todos los elementos que no listes se inicializan a cero, así que un único cero pone a cero el array completo. Los inicializadores designados ([4] = 99) te dejan fijar posiciones concretas y dejar el resto en cero, lo que resulta cómodo para tablas de consulta que están casi vacías.

Algo que no puedes hacer es asignar un array después:

int a[3] = {1, 2, 3};
int b[3];
b = a;                    // error: un array no es asignable
memcpy(b, a, sizeof a);   // así es como se copia uno

Los índices empiezan en cero

El primer elemento es arr[0] y el último es arr[n-1]. No existe arr[n].

#include <stdio.h>

int main(void) {
    int scores[5] = {88, 92, 75, 60, 100};

    printf("primero  scores[0] = %d\n", scores[0]);
    printf("tercero  scores[2] = %d\n", scores[2]);
    printf("ultimo   scores[4] = %d\n", scores[4]);

    scores[1] = 95;                       // escribir en un elemento
    printf("tras la actualizacion, scores[1] = %d\n", scores[1]);

    printf("\ndirecciones (fijate en el espaciado regular):\n");
    for (int i = 0; i < 5; i++) {
        printf("  scores[%d] en %p\n", i, (void *)&scores[i]);
    }

    return 0;
}

Ejecuta ese último bucle y mira las direcciones: cada una está exactamente sizeof(int) bytes más allá de la anterior. Los elementos están realmente dispuestos uno a continuación de otro:

 indice     0         1         2         3         4
         +--------+--------+--------+--------+--------+
 valor   |   88   |   95   |   75   |   60   |  100   |
         +--------+--------+--------+--------+--------+
 offset   +0       +4       +8       +12      +16      bytes
          ^
          &scores[0], que es tambien a lo que `scores` se degrada

Indexar desde cero no es una elección arbitraria: hace que el índice sea un desplazamiento desde el inicio, que es exactamente lo que necesita la aritmética de direcciones. scores[i] se define como *(scores + i); ver punteros y arrays.

Obtener la longitud

C no guarda la longitud de un array en ningún sitio en tiempo de ejecución, pero el compilador la conoce, y sizeof te da acceso a ella:

#include <stdio.h>

int main(void) {
    double prices[] = {4.99, 12.50, 0.99, 7.25};

    printf("bytes totales    = %zu\n", sizeof prices);
    printf("bytes por item   = %zu\n", sizeof prices[0]);
    printf("longitud         = %zu\n", sizeof prices / sizeof prices[0]);

    return 0;
}

sizeof(arr) / sizeof(arr[0]) es el modismo. Dividir entre arr[0] en lugar de entre un sizeof(double) escrito a mano hace que la línea siga funcionando si cambias el tipo de los elementos.

La trampa: esto solo funciona donde se declaró el array. Pasa el array a una función y el parámetro es un puntero, así que sizeof mide el puntero: normalmente 8 bytes, dando una "longitud" de 1 o 2. Por eso toda función de C que recibe un array recibe también un conteo:

#include <stdio.h>

int sum(const int *arr, int n) {       // la longitud debe pasarse
    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];   // calculado AQUI, donde es correcto

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

    return 0;
}

Recorrer un array

La forma estándar es un bucle for desde 0 mientras i < n:

#include <stdio.h>

int main(void) {
    int temps[7] = {18, 21, 25, 22, 19, 17, 24};
    int n = sizeof temps / sizeof temps[0];

    int total = 0, hottest = temps[0], coldest = temps[0];

    for (int i = 0; i < n; i++) {
        total += temps[i];
        if (temps[i] > hottest) hottest = temps[i];
        if (temps[i] < coldest) coldest = temps[i];
    }

    printf("lecturas: ");
    for (int i = 0; i < n; i++) printf("%d ", temps[i]);

    printf("\npromedio:  %.1f\n", (double)total / n);
    printf("maxima:    %d\n", hottest);
    printf("minima:    %d\n", coldest);

    return 0;
}

Fíjate en i < n, no en i <= n. Con n elementos los índices válidos van de 0 a n - 1, así que <= da una pasada de más y lee más allá del final. Inicializar hottest y coldest con temps[0] en lugar de con 0 es el otro hábito que vale la pena copiar: arrancar un máximo en cero se rompe en silencio con datos que son todos negativos.

Salirse de los límites es comportamiento indefinido

Esta es la parte de C que sorprende a quien viene de otros lenguajes. No hay comprobación de límites. Ninguna en tiempo de compilación, ninguna en tiempo de ejecución. arr[10] en un array de cinco elementos no es un error: es un cálculo de dirección que el compilador realiza sin decir nada.

int arr[5] = {1, 2, 3, 4, 5};
arr[7] = 99;     // escribe 8 bytes mas alla del final del array
int x = arr[-1]; // lee antes del inicio

Lo que pasa después es comportamiento indefinido, y sus síntomas son de una variedad poco útil:

parece funcionar, porque la memoria que tocó no se estaba usando;
otra variable cambia sin razón visible;
el programa falla con un error de segmentación, posiblemente mucho después;
el comportamiento difiere entre -O0 y -O2.

"Parece funcionar" es el peligroso, porque significa que el error llega a producción. Tres defensas:

Recorre con i < n. La mayoría de los desbordamientos son errores de desplazamiento por uno en la condición de un bucle.
Valida los índices que vienen de la entrada.

#include <stdio.h>

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

    int requests[4] = {2, 5, -1, 4};    // dos de estos estan fuera de rango

    for (int i = 0; i < 4; i++) {
        int idx = requests[i];
        if (idx >= 0 && idx < n) {
            printf("arr[%d] = %d\n", idx, arr[idx]);
        } else {
            printf("indice %d rechazado (el rango valido es 0..%d)\n", idx, n - 1);
        }
    }

    return 0;
}

Compila con un sanitizer mientras desarrollas. gcc -fsanitize=address -g prog.c convierte la mayoría de los desbordamientos en un informe inmediato que nombra el archivo, la línea y el array implicado.

Arrays de otros tipos

La misma sintaxis funciona para cualquier tipo de elemento, incluidas las estructuras:

#include <stdio.h>

typedef struct {
    const char *name;
    int         score;
} Player;

int main(void) {
    Player players[3] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Ken",   85}
    };
    int n = sizeof players / sizeof players[0];

    for (int i = 0; i < n; i++) {
        printf("%-6s %3d\n", players[i].name, players[i].score);
    }

    // un array de char es una cadena cuando termina con '\0'
    char word[6] = "hello";        // 5 caracteres mas el terminador
    printf("\nword = %s (%zu bytes de almacenamiento)\n", word, sizeof word);

    return 0;
}

La línea char word[6] = "hello"; merece una pausa: una cadena de C no es más que un array de char cuyo último byte significativo es '\0'. Ese terminador es la razón de que el array necesite seis huecos para cinco letras.

Arrays de longitud variable, en breve

C99 permite un array cuyo tamaño es un valor de tiempo de ejecución:

int n = get_count();
int buffer[n];        // un array de longitud variable

Dos advertencias. El tamaño queda fijo una vez creado el array, así que un VLA no es una lista que crezca. Y la memoria viene de la pila, así que una n grande o controlada por un atacante puede desbordarla y tumbar el programa, que es la razón de que muchos proyectos, incluido el kernel de Linux, prohíban los VLAs por completo. Además, para las implementaciones de C11 su soporte es opcional.

Cuando el tamaño realmente no se conoce hasta tiempo de ejecución, reserva memoria en su lugar:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 6;                              // imagina que esto vino de la entrada

    int *arr = malloc(n * sizeof *arr);     // heap, no pila
    if (arr == NULL) {
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = (i + 1) * (i + 1);
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);              // indexar funciona exactamente igual
    }
    printf("\n");

    free(arr);
    return 0;
}

Fíjate en que arr[i] se lee de forma idéntica tanto si arr es un array como si es un puntero a memoria reservada: a la sintaxis de indexación le da igual. Todos los detalles en memoria dinámica.

Preguntas frecuentes

¿Cómo se declara un array en C?

Indica el tipo de los elementos, un nombre y un tamaño entre corchetes: int scores[5]; reserva espacio para cinco enteros. El tamaño debe ser una constante conocida donde se declara el array (salvo en los arrays de longitud variable), y los elementos quedan sin inicializar a menos que les des valores.

¿Cómo se obtiene la longitud de un array en C?

sizeof(arr) / sizeof(arr[0]) - el tamaño total en bytes dividido entre el tamaño de un elemento. Solo funciona en el ámbito donde se declaró el array: una vez que lo pasas a una función ya se degradó a un puntero y sizeof mide el puntero.

¿Qué pasa si te sales del final de un array en C?

Nada te detiene. C no comprueba los límites, así que arr[10] en un array de 5 elementos lee o escribe la memoria que haya ahí. Eso es comportamiento indefinido: puede imprimir basura, corromper otra variable o fallar - y puede parecer que funciona hasta que deja de hacerlo.

¿Cómo se inicializan a cero todos los elementos de un array en C?

int arr[100] = {0}; - todos los elementos que no listes se inicializan a cero, así que un solo cero pone a cero el array entero. int arr[100] = {}; también funciona en C23. Sin ningún inicializador, el contenido de un array local es basura indeterminada.

Conceptos relacionados