Los arrays permiten almacenar un conjunto de datos re­la­cio­na­dos en C sin tener que crear múltiples variables. Por regla general, los arrays son uni­di­me­n­sio­na­les, pero pueden ampliarse con cualquier número de di­me­n­sio­nes. Te mostramos cómo crear arrays 2D en C y cómo uti­li­zar­los efi­ca­z­me­n­te.

Conceptos básicos de los arrays en C

Para poder crear y dominar efi­ca­z­me­n­te los arrays 2D en C, primero debes saber algunas cosas básicas sobre los arrays en el lenguaje de pro­gra­ma­ción C. Como en muchos otros lenguajes, los arrays son un bloque de memoria en el que se pueden almacenar varios valores del mismo tipo de datos. Esto permite guardar y resumir varios valores bajo un mismo nombre de variable. El tamaño del array debe conocerse en tiempo de co­m­pi­la­ción y no puede mo­di­fi­car­se po­s­te­rio­r­me­n­te. El siguiente bloque de código muestra cómo crear arrays en C:

int cifras1[15]; 
// Opcionalmente, los valores almacenados pueden ser especificados al crear el array: 
int cifras2[5] = {1, 2, 3, 4, 5};
c

En este ejemplo, el tipo de datos que se va a guardar se es­pe­ci­fi­ca como es habitual antes del nombre de la variable. Los corchetes indican que esta variable no es un valor único, sino un array. El número entero entre los corchetes indica cuántos elementos de este tipo de datos pueden al­ma­ce­nar­se en el array. En el ejemplo anterior, el array cifras1 se crea sin ini­cia­li­zar, lo que significa que no se escriben valores en los campos. Estos pueden re­lle­nar­se con valores más adelante en el código.

El array cifras2, por otro lado, se ini­cia­li­za ma­nua­l­me­n­te cuando se crea. Este enfoque no es re­co­me­n­da­ble en la mayoría de los casos, ya que consume mucho tiempo para arrays grandes y el código re­su­l­ta­n­te es a menudo ilegible. Por tanto, es mejor intentar llenar los arrays pro­gra­má­ti­ca­me­n­te, por ejemplo con un bucle for:

cifras2[100]; 
for(int i = 0; i < 100; i++) { 
cifras2[i] = i + 1; 
} 
// Crea un array que contiene los números enteros del 1 al 100.
c
Nota

De­pe­n­die­n­do del sistema operativo en el que estés tra­ba­ja­n­do, del estándar C que estés uti­li­za­n­do y del lugar de tu programa en el que hayas declarado una variable no ini­cia­li­za­da, esta variable puede contener un valor aleatorio. Lo mismo ocurre con los campos de array. Por lo tanto, es mejor no acceder a campos que aún no hayas ini­cia­li­za­do, es­pe­cia­l­me­n­te si el valor al­ma­ce­na­do en ellos debe in­te­r­pre­tar­se como un pointer.

Una vez creado un array, el índice puede uti­li­zar­se para acceder a valores in­di­vi­dua­les. Ten en cuenta que los arrays empiezan con el índice 0. El siguiente ejemplo sirve para ilu­s­trar­lo:

int cifras2[5] = {1, 2, 3, 4, 5}; 
cifras2[3] = cifras2[2]; 
printf("%d\n", cifras2[3]); 
// Resultado: 3
c

Un array 2D puede rea­li­zar­se en C creando un array en el que cada campo contenga otro array. Sigue leyendo para saber más.

Cómo crear un array 2D en C

Los arrays 2D en C no son más que arrays uni­di­me­n­sio­na­les cuyos campos contienen cada uno otro array. Por tanto, un array 2D puede en­te­n­de­r­se como una tabla o matriz de valores. Los arrays 2D se pueden crear y rellenar con la siguiente sintaxis:

2d_ints[10][10]; 
2d_ints[0][1] = 0; 
2d_ints[2][1] = 2; 
2d_ints[9][4] = 36; 
// etc.
c

Aquí, el número entre corchetes de la izquierda re­pre­se­n­ta el índice del primer array al que se va a acceder y el número de la derecha re­pre­se­n­ta el índice de la segunda. Estos dos números pueden vi­sua­li­zar­se como coor­de­na­das bi­di­me­n­sio­na­les o números de fila o columna. Al igual que los arrays uni­di­me­n­sio­na­les, los arrays bi­di­me­n­sio­na­les también pueden ini­cia­li­zar­se con valores cuando se crean.

2d_floats[2][6] = { 
{0.1, 3.56, 6.346, 8.9, 45.345, 2.284} 
{7.0, 1.12, 9.74, 0.0, 3.56, 4.4} 
}
c

El principio de un array dentro de otro array no se limita a dos di­me­n­sio­nes. Puedes utilizar este método para crear arrays con cualquier número de di­me­n­sio­nes.

int 4d_ints[10][10][10][10]
c
Web Hosting
El hosting que crece con tu proyecto
  • Tiempo de actividad de 99.99 % y seguridad ga­ra­n­ti­za­da
  • Aumenta el re­n­di­mie­n­to según el tráfico de tu página web
  • Incluye dominio, SSL, e-mail y soporte 24/7

Casos prácticos de arrays 2D in C

Iterar sobre un array 2D

La apli­ca­ción más común de los arrays 2D en C (o arrays mu­l­ti­di­me­n­sio­na­les) es la creación de es­tru­c­tu­ras de datos mu­l­ti­di­me­n­sio­na­les. En el siguiente ejemplo, un array bi­di­me­n­sio­nal se rellena al­te­r­na­ti­va­me­n­te con ceros y unos para re­pre­se­n­tar un tablero de ajedrez:

#include <stdio.h> 
#define ARRAY_LENGTH 8 
int main() { 
    int tablero de ajedrez[8][8]; 
    for(int i = 0; i < ARRAY_LENGTH; i++) { 
        for(int j = 0; j < ARRAY_LENGTH; j++) { 
            tablero de ajedrez[i][j] = (i + j) % 2; 
            printf("%d", tablero de ajedrez[i][j]); 
        } 
        printf("\n"); 
    } 
    return 0; 
} 
/* 
Resultado: 
01010101 
10101010 
01010101 
10101010 
01010101 
10101010 
01010101 
10101010 
*/
c

Array de strings

Un detalle que es muy im­po­r­ta­n­te para el uso hábil de los arrays: un array es en realidad solo un pointer a una posición en memoria y el co­m­pi­la­dor de C lo entiende como tal. El índice que se es­pe­ci­fi­ca al escribir o leer campos in­di­vi­dua­les re­pre­se­n­ta, por tanto, el de­s­pla­za­mie­n­to a lo largo del array en relación con la dirección base. El siguiente ejemplo lo ilustra:

int cifras2[5] = {1, 2, 3, 4, 5}; 
printf("%d\n", *cifras2); 
// Resultado: 1 
printf("%d\n", *(cifras2 + 2)); 
// Resultado: 3
c

Las strings o cadenas se tratan del mismo modo en C. Por tanto, es posible iterar sobre una cadena como si fuera un array. Esto puede verse en el siguiente ejemplo, en el que tres registros al­ma­ce­na­dos en un array se muestran carácter a carácter en ma­yú­s­cu­las. Para acceder a los ca­ra­c­te­res, se utiliza el campo índice del array (corchetes):

#include <stdio.h> 
 
int main() { 
    char* frase[3]; 
    frase[0] = "¡Hola! Esta es la primera frase.\n"; 
    frase[1] = "Esta es la segunda frase.\n"; 
    frase[2] = "Y esta, la tercera.\n"; 
    printf("Frases originales:\n\n"); 
    for(int i = 0; i < 3; i++) { 
        printf("%s", frases[i]); 
    } 
    printf("\nFrases cambiadas:\n\n"); 
    for(int i = 0; i < 3; i++) { 
        int j = 0; 
        while(frases[i][j] != '\n') { 
            if(frases[i][j] >= 'a' && frases[i][j] <= 'z') { 
                printf("%c", frases[i][j] - 0x20); 
            } else { 
                printf("%c", frases[i][j]); 
            } 
            j++; 
        } 
        printf("\n"); 
    } 
} 
/* 
Resultado: 
Frases originales: 
 
¡Hola! Esta es la primera frase. 
Esta es la segunda frase. 
Y esta, la tercera. 
 
Frases cambiadas: 
 
¡HOLA! ESTA ES LA PRIMERA FRASE. 
ESTA ES LA SEGUNDA FRASE. 
Y ESTA, LA TERCERA. 
*/
c
Ir al menú principal