Introducción

Vamos a ver un tutorial de cómo trabajar con arreglos, arrays o vectores en el lenguaje de programación C. Veremos cómo inicializar un arreglo, recorrerlo o modificarlo.

Nota: en este caso array, vector y arreglo son la misma cosa.

Declaración de un vector o array

La sintaxis es:

tipo nombreDeLaVariable[longitudDelArreglo];

Por ejemplo, para declarar un array de 3 enteros usamos esto:

int numeros[3];

Para uno de 5 elementos de tipo double esto:

double calificaciones[5];

Declaración y llenado de un array

En los ejemplos de arriba declaramos los arreglos pero no les pusimos datos iniciales, sólo dijimos cuánto medirán. Para poner datos iniciales la sintaxis es:

tipo nombreDeLaVariable[longitud] = {elemento1, elemento2,…};

Aquí tenemos un array de 3 números enteros, inicializado al inicio:

int numeros[3] = {80, 50, 200};

También puede ser de tipo doble:

double calificaciones[5] = {80.5, 90, 50.95, 99.7, 97.5};

Por otro lado, podemos dejar que el compilador infiera la longitud del vector si nosotros lo inicializamos:

char nombre[] = {'L', 'u', 'i', 's'};

En este caso la longitud es de 4, pero no tuvimos que decirla porque el compilador la inferirá. Y no afectará al rendimiento de nuestro programa.

Modificar el valor de un arreglo

Podemos cambiar el valor que tiene un valor dentro de un array. Recordemos que los vectores comienzan en 0. Si tenemos este arreglo:

char nombre[] = {'L', 'u', 'i', 's'};

Y hago lo siguiente:

nombre[3] = 'z';

El contenido será “Luiz” en lugar de “Luis”

Leer un array

Podemos acceder a un array igualmente a través de su índice. Por ejemplo, si tenemos este arreglo:

int numeros[3] = {80, 50, 200};

Y queremos asignar una variable a la posición 2 (la que tiene el número 200) podemos hacer esto

int miNumero = numeros[2];

Ahora miNumero tendrá el valor de 200

Recorrer un arreglo

Para recorrer un arreglo usamos un ciclo for que va desde 0 hasta la longitud de nuestro arreglo. Por ejemplo, el siguiente código imprime el valor y el índice de un arreglo:

#include <stdio.h>

int main(int argc, char const *argv[])
{
	char nombre[] = {'L', 'u', 'i', 's'};
	// En este caso, 4 es lo que mide nuestro arreglo pero
	// el mayor índice es el 3, así que siempre irá desde
	// 0 hasta 3 (ya que al llegar a 4 no se cumple la condición de < 4)
	for (int i = 0; i < 4; ++i)
	{
		printf("Estamos en el indice %d y el valor es %c\n", i, nombre[i]);
	}
	return 0;
}

La salida del programa será la siguiente:

Declaración de array bidimensional o de dos dimensiones

Anteriormente vimos los arreglos como una lista simple, pero también podemos tener arreglos de dos dimensiones.

Veamos este ejemplo que especifica un arreglo que representa un teclado matricial:

/*
	Es obligatorio declarar el tamaño de todas las dimensiones
	excepto de la primera, pero de todos modos también la declaramos
	para dejar claro el ejemplo
*/
char teclado[4][4] = {
	{'1', '2', '3', 'A'},
	{'4', '5', '6', 'B'},
	{'7', '8', '9', 'C'},
	{'*', '0', '#', 'D'},
};

Como dice el código: debemos declarar el tamaño de todas las dimensiones, pero podemos dejar la primera vacía. Esto quiere decir que este código es válido:

char teclado[][4] = {
	{'1', '2', '3', 'A'},
	{'4', '5', '6', 'B'},
	{'7', '8', '9', 'C'},
	{'*', '0', '#', 'D'},
};

En este caso no pusimos la longitud de la primera dimensión, pero sí de la segunda. Para aclarar más las cosas, este código es inválido:

char teclado[][] = {
	{'1', '2', '3', 'A'},
	{'4', '5', '6', 'B'},
	{'7', '8', '9', 'C'},
	{'*', '0', '#', 'D'},
};

Ya que estamos dejando que el compilador adivine la longitud de la segunda dimensión, cosa que no es válida. Si intentamos compilar de todos modos, saldrá este error:

note: declaration of ‘teclado’ as multidimensional array must have bounds for all dimensions except the first

Leer array de dos dimensiones

Con el ejemplo del arreglo de arriba vamos a ver este código para recorrerlo.

En este caso recorremos tanto en X como en Y. Podemos imaginar el arreglo como una tabla. Para acceder a él, usamos lo siguiente:

<em>arreglo[x][y]</em>

Aquí el código:

#include <stdio.h>

int main(int argc, char const *argv[])
{
	// Notar los dos grupos de corchetes [][]

	// Nuestro arreglo mide 4 x 4

	/*
		Es obligatorio declarar el tamaño de la dimensión de todas las dimensiones
		excepto de la primera, pero de todos modos también la declaramos
		para dejar claro el ejemplo
	*/
	char teclado[4][4] = {
		{'1', '2', '3', 'A'},
		{'4', '5', '6', 'B'},
		{'7', '8', '9', 'C'},
		{'*', '0', '#', 'D'},
	};

	// Un ciclo para leer las filas del arreglo
	for (int indiceFila = 0; indiceFila < 4; ++indiceFila)
	{
		printf("--Fila %d\n", indiceFila );
		// Dentro del ciclo, ponemos otro ciclo para leer cada celda de la fila
		for (int indiceCelda = 0; indiceCelda < 4; ++indiceCelda)
		{
			printf("Estamos en [%d]x[%d] y el valor es %c\n", indiceFila, indiceCelda, teclado[indiceFila][indiceCelda]);
		}
	}
	return 0;
}

Creamos 2 ciclos; uno dentro del otro. Para abstraerlo mejor, al primer índice lo tomamos como el índice de la fila. Y al segundo índice lo tomamos como el índice de la celda. Esta es la salida:

Todo lo que vimos con arreglos de una dimensión aplica para estos arreglos de dos dimensiones. Podemos declararlos sin inicializar sus datos, leerlos o modificarlos.

Arreglos de más dimensiones

Es algo muy raro pero podemos usar arreglos de 3, 4, 5 o infinitas dimensiones. No se me ocurre para qué pero aquí dejo la declaración de un arreglo de 2 x 2 x 3; es decir, uno de 3 dimensiones:

int granArreglo[2][2][3] = {
	{
		{'H', 'o', 'l'},
		{'a', ' ', 'm'},
	},
	{
		{'u', 'n', 'd'},
		{'o', '!', '!'},
	},
};

Para recorrerlo hacemos lo mismo de siempre…

#include <stdio.h>

int main(int argc, char const *argv[])
{
	int granArreglo[2][2][3] = {
		{
			{'H', 'o', 'l'},
			{'a', ' ', 'm'},
		},
		{
			{'u', 'n', 'd'},
			{'o', '!', '!'},
		},
	};
	for (int i = 0; i < 2; ++i)
	{
		for (int j = 0; j < 2; ++j)
		{
			for (int k = 0; k < 3; ++k)
			{
				printf("Estamos en [%d][%d][%d] y el valor es %c\n", i, j, k, granArreglo[i][j][k]);
			}
		}
	}
	return 0;
}

Con la siguiente salida:

Conclusión

La mayoría de ejemplos fueron con arreglos de tipo char pero igualmente podemos trabajar con arreglos de cualquier tipo.

Por cierto, también podemos acceder a un índice dependiendo de una variable. En lugar de esto:

arreglo[2] = 'M';

Podemos tener algo así:

int indice = 2;
arreglo[indice] = 'M';

Igualmente para leerlo. En lugar de esto:

printf("El valor es: %c", arreglo[2]);

Podemos tener esto:

int indice = 2;
printf("El valor es: %c", arreglo[indice]);

Espero que haya quedado claro este pequeño tutorial de arreglos en C.

Si quieres ver más tutoriales de C puedes hacer click aquí.

Cualquier duda déjala en los comentarios.