Arrays 2D en C: arrays multidimensionales, disposición en memoria y matrices

Un array multidimensional es un array cuyos elementos son a su vez arrays. int grid[3][4]; no es un tipo especial de cuadrícula: son tres elementos, cada uno de los cuales es un array de cuatro ints, almacenados uno detrás de otro. En cuanto eso encaja, el resto del tema se deduce: la disposición, la aritmética de índices y la regla por lo demás desconcertante sobre pasarlos a funciones.

Dos dimensiones cubren casi cualquier uso práctico —cuadrículas, tablas, matrices, tableros de juego, imágenes— así que eso es con lo que trabaja esta página.

Declarar e inicializar

int grid[3][4];        // 3 filas, 4 columnas: 12 ints

El primer número es cuántas filas, el segundo cuántas columnas. Los inicializadores pueden escribirse planos o con llaves internas; vale la pena usar las llaves porque muestran la forma.

#include <stdio.h>

int main(void) {
    int a[2][3] = {{1, 2, 3}, {4, 5, 6}};   // con llaves por fila: lo mas claro
    int b[2][3] = {1, 2, 3, 4, 5, 6};       // plano: el mismo resultado
    int c[2][3] = {{1, 2}, {4}};            // filas parciales: el resto son cero
    int d[2][3] = {0};                      // todos los elementos en cero
    int e[][3]  = {{1, 2, 3}, {4, 5, 6}};   // filas deducidas, columnas obligatorias

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

    return 0;
}

La forma int e[][3] importa: puedes dejar en blanco la cantidad de filas y dejar que el inicializador la decida, pero la cantidad de columnas nunca es opcional. La siguiente sección explica por qué.

Disposición por filas

C guarda un array 2D en orden por filas (row-major): la fila 0 entera, luego la fila 1 entera, y así, en un bloque de memoria ininterrumpido. No hay ningún array de punteros a filas entre bastidores.

int grid[3][4] = {{ 1, 2, 3, 4},
                  { 5, 6, 7, 8},
                  { 9,10,11,12}};

como te lo imaginas              como esta en memoria de verdad
+----+----+----+----+
|  1 |  2 |  3 |  4 |   fila 0   +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+            | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|
|  5 |  6 |  7 |  8 |   fila 1   +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+             \_ fila 0 __/\_ fila 1 __/\_ fila 2 _/
|  9 | 10 | 11 | 12 |   fila 2
+----+----+----+----+            grid[i][j] esta en el indice i*4 + j

Esa fórmula, i * columnas + j, es todo el mecanismo, y es por lo que el compilador debe conocer la cantidad de columnas para indexar cualquier cosa. La cantidad de filas nunca entra en el cálculo.

Puedes ver la disposición directamente imprimiendo direcciones:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    printf("direcciones de los elementos, en orden de memoria:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("grid[%d][%d] = %2d en %p\n", i, j, grid[i][j], (void *)&grid[i][j]);
        }
    }

    // el mismo bloque leido como una tira plana de 12 ints
    printf("\naplanado: ");
    int *flat = &grid[0][0];
    for (int k = 0; k < 12; k++) {
        printf("%d ", flat[k]);
    }
    printf("\n");

    return 0;
}

Las direcciones suben de sizeof(int) en sizeof(int) sin huecos, incluido donde una fila termina y empieza la siguiente. El bucle aplanado lo demuestra: flat[k] recorre los doce elementos como una sola tira.

Esta disposición también tiene una consecuencia de rendimiento que vale la pena conocer: recorrer primero las filas y luego las columnas toca la memoria en orden, cosa que a la caché de la CPU le gusta. Invertir el anidamiento para que el bucle interno baje por una columna salta una fila entera cada vez y puede correr varias veces más lento en un array grande.

Bucles anidados

Dos dimensiones piden dos bucles for: el externo elige la fila, el interno recorre las columnas de esa fila.

#include <stdio.h>

#define ROWS 3
#define COLS 4

int main(void) {
    int grid[ROWS][COLS];

    // llenar con una tabla de multiplicar
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] = (i + 1) * (j + 1);
        }
    }

    // imprimirla como una tabla
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }

    // totales por fila y un total general
    int grand = 0;
    printf("\ntotales por fila: ");
    for (int i = 0; i < ROWS; i++) {
        int rowSum = 0;
        for (int j = 0; j < COLS; j++) {
            rowSum += grid[i][j];
        }
        grand += rowSum;
        printf("%d ", rowSum);
    }
    printf("\ntotal general: %d\n", grand);

    return 0;
}

Nombra los contadores según lo que significan (i/row para filas, j/col para columnas) y mantén el orden consistente: grid[row][col] en todas partes. La mitad de los errores con arrays 2D son un par de índices intercambiados.

Los tamaños con #define tampoco son decoración: ahora los límites de los bucles y la declaración no pueden desincronizarse cuando cambies la forma.

Pasar un array 2D a una función

Aquí está la regla que hace tropezar a todo el mundo: el parámetro de la función debe declarar la cantidad de columnas.

#include <stdio.h>

#define COLS 4

// el tamano de columna es obligatorio; la cantidad de filas viene como argumento aparte
void print_grid(int grid[][COLS], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }
}

// exactamente el mismo parametro, escrito como el puntero que realmente es
void scale_grid(int (*grid)[COLS], int rows, int factor) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] *= factor;
        }
    }
}

int main(void) {
    int grid[3][COLS] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    print_grid(grid, 3);
    scale_grid(grid, 3, 10);
    printf("\ndespues de escalar:\n");
    print_grid(grid, 3);

    return 0;
}

La razón es el decaimiento. Pasar grid lo convierte en un puntero a su primer elemento, y sus elementos son filas, así que el tipo es int (*)[4]: puntero a un array de 4 ints. Para que grid[i][j] signifique algo, el compilador debe saber cuánto ocupa una fila, y eso es el 4. La cantidad de filas está genuinamente ausente del tipo, que es por lo que viaja como un argumento aparte.

Fíjate en que int (*grid)[COLS] e int grid[][COLS] son el mismo parámetro escrito de dos formas: los paréntesis son obligatorios, ya que int *grid[COLS] sería en cambio un array de punteros. Esa distinción se cubre en punteros y arrays.

Si la cantidad de columnas solo se conoce en tiempo de ejecución, los parámetros de tipo modificado variablemente de C99 te dejan pasarla primero:

void print_any(int rows, int cols, int grid[rows][cols]);

rows y cols deben declararse antes del parámetro de tipo array que los usa. Donde eso no esté disponible, la alternativa habitual es un array 1D plano más aritmética de índices hecha a mano:

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

// tratar un bloque plano como filas x columnas y hacer la aritmetica tu mismo
void print_flat(const int *data, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", data[i * cols + j]);
        }
        printf("\n");
    }
}

int main(void) {
    int rows = 2, cols = 5;

    int *data = malloc((size_t)rows * cols * sizeof *data);
    if (data == NULL) return 1;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            data[i * cols + j] = i * 10 + j;
        }
    }

    print_flat(data, rows, cols);
    free(data);
    return 0;
}

data[i * cols + j] es exactamente lo que el compilador escribe por ti en el caso de tamaño fijo. Hacerlo a mano cuesta una línea y funciona para cualquier forma decidida en tiempo de ejecución.

Un ejemplo con matrices

La multiplicación de matrices junta toda la página: tres bucles anidados sobre un almacenamiento por filas.

#include <stdio.h>

#define N 3

void multiply(const int a[][N], const int b[][N], int out[][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            int total = 0;
            for (int k = 0; k < N; k++) {
                total += a[i][k] * b[k][j];
            }
            out[i][j] = total;
        }
    }
}

void print_matrix(const char *label, const int m[][N]) {
    printf("%s\n", label);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%5d", m[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main(void) {
    int a[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int b[N][N] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int product[N][N] = {0};

    print_matrix("A:", a);
    print_matrix("B:", b);

    multiply(a, b, product);
    print_matrix("A x B:", product);

    // transponer A en el mismo lugar
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {     // empezar en i+1 para intercambiar cada par una vez
            int temp = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = temp;
        }
    }
    print_matrix("A transpuesta:", a);

    return 0;
}

Dos detalles que vale la pena copiar. El bucle interno k empareja a[i][k] con b[k][j]: un índice recorre una fila y el otro recorre una columna. Y la transposición empieza su bucle interno en j = i + 1: empezar en 0 intercambiaría cada par dos veces y dejaría la matriz igual.

Tres dimensiones y más allá

El patrón se extiende, y también la regla sobre los parámetros de las funciones: toda dimensión salvo la primera debe declararse.

#include <stdio.h>

int main(void) {
    // 2 capas, 3 filas, 4 columnas
    int cube[2][3][4] = {0};

    for (int z = 0; z < 2; z++) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                cube[z][i][j] = z * 100 + i * 10 + j;
            }
        }
    }

    for (int z = 0; z < 2; z++) {
        printf("capa %d:\n", z);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                printf("%5d", cube[z][i][j]);
            }
            printf("\n");
        }
    }

    printf("\nelementos totales: %zu\n", sizeof cube / sizeof cube[0][0][0]);
    return 0;
}

En la práctica, tres dimensiones es donde los arrays de tamaño fijo empiezan a sentirse incómodos, y la mayoría del código pasa a un bloque plano con índices calculados o a un array de estructuras que nombra lo que significa cada eje.

Errores comunes

• Escribir grid[i, j]. El operador coma evalúa i, lo descarta e indexa con j. Compila. Está mal. Usa grid[i][j].
• Intercambiar los índices. grid[col][row] lee un elemento real del lugar equivocado, así que no hay ningún error que lo detecte. Mantén el orden [fila][columna] en todas partes.
• Omitir el tamaño de columna en un parámetro. void f(int grid[][]) no compila, y eso es el compilador salvándote.
• Salirse de los límites. Como con cualquier array, no hay comprobación de límites. grid[0][5] en una cuadrícula [3][4] lee en silencio grid[1][1], porque la disposición es contigua y a la aritmética le da igual.