Ing.

Julio Malave
Guía Matriz 0 Arrays

Arrays (Matrices)
¿Qué es un array?
La definición sería algo así: Un array es un conjunto de variables del mismo tipo que
tienen el mismo nombre y se diferencian en el índice.
Pero ¿qué quiere decir esto y para qué lo queremos? Pues bien, supongamos que
somos un meteorólogo y queremos guardar en el ordenador la temperatura que ha
hecho cada hora del día. Para darle cierta utilidad al final calcularemos la media de
las temperaturas. Con lo que sabemos hasta ahora sería algo así:
#include <stdio.h>
int main()
{
/* Declaramos 24 variables, una para cada hora del dia */
int temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8; int temp9, temp10,
temp11, temp12, temp13, temp14, temp15, temp16, int temp17, temp18, temp19,
temp20, temp21, temp22, temp23,
temp0;
int media;
/* Ahora tenemos que dar el valor de cada una */
printf( "Temperatura de las 0: " );
scanf( "%i", &temp0 );
printf( "Temperatura de las 1: " );
scanf( "%i", &temp1 );
printf( "Temperatura de las 2: " );
scanf( "%i", &temp2 );
printf( "Temperatura de las 23: " );
scanf( "%i", &temp23 );
media = (temp0+temp1+temp2+temp3+temp4+ ... +temp23)/24;
printf( "\nLa temperatura media es %i\n", media );
}
Ing. Julio Malave
Guía Matriz 0 Arrays

NOTA: Los puntos suspensivos los he puesto para no tener que escribir todo y que
no ocupe tanto, no se pueden usar en un programa.
Para acortar un poco el programa podríamos hacer algo así:

#include <stdio.h>
int main()
{
/* Declaramos 24 variables, una para cada hora del dia */
int temp1, temp2, temp3, temp4, temp5, temp6, temp7,
temp8; int temp9, temp10, temp11, temp12, temp13, temp14, temp15,
temp16; int temp17, temp18, temp19, temp20, temp21, temp22, temp23,
temp0;
int media;
/* Ahora tenemos que dar el valor de cada una */
printf( "Introduzca las temperaturas desde las 0 hasta las 23
separadas por un espacion: " );
scanf( "%i %i %i ... %i", &temp0, &temp1, &temp2, ... &temp23 );

media = (temp0+temp1+temp2+temp3+temp4+ ... +temp23)/24;

printf( "\nLa temperatura media es %i\n", media );
}

Y esto con un ejemplo que tiene tan sólo 24 variables, ¡¡imagínate si son más!!
Y precisamente aquí es donde nos vienen de perlas los arrays. Vamos a hacer el
programa con un array. Usaremos nuestros conocimientos de bucles for y de scanf.

#include <stdio.h>
Ing. Julio Malave
Guía Matriz 0 Arrays

int main()
{
int temp[24];/*Con esto ya tenemos declaradas las 24 variables */
float media;
int hora;
/* Ahora tenemos que dar el valor de cada una */
for( hora=0; hora<24; hora++ )
{
printf( "Temperatura de las %i: ", hora );
scanf( "%i", &temp[hora] );
media += temp[hora];
}
media = media / 24;
printf( "\nLa temperatura media es %f\n", media );
}
Como ves es un programa más rápido de escribir (y es menos aburrido hacerlo), y
más
cómodo para el usuario que el anterior.
Como ya hemos comentado cuando declaramos una variable lo que estamos
haciendo es reservar una zona de la memoria para ella. Cuando declaramos un
array lo que hacemos (en este ejemplo) es reservar espacio en memoria para 24
variables de tipo int. El tamaño del array (24) lo indicamos entre corchetes al
definirlo. Esta es la parte de la definición que dice: Un array es un conjunto de
variables del mismo tipo que tienen el mismo nombre.
La parte final de la definición dice: y se diferencian en el índice. En ejemplo
recorremos la matriz mediante un bucle for y vamos dando valores a los distintos
elementos de la matriz. Para indicar a qué elemento nos referimos usamos un
número entre corchetes (en este caso la variable hora), este número es lo que se
llama Índice. El primer elemento de la matriz en C tiene el índice 0, El segundo tiene
el 1 y así sucesivamente.
De modo que si queremos dar un valor al elemento 4 (índice 3) haremos:
Ing. Julio Malave
Guía Matriz 0 Arrays

temp[ 3 ] = 20;
NOTA: No hay que confundirse. En la declaración del array el número entre
corchetes es el número de elementos, en cambio cuando ya usamos la matriz el
número entre corchetes es el índice.
Declaración de un Array
La forma general de declarar un array es la siguiente:
tipo_de_dato nombre_del_array[ dimensión ];
El tipo_de_dato es uno de los tipos de datos conocidos (int, char, float...) o de los
definidos por el usuario con typdef. En el ejemplo era int.
El nombre_del_array es el nombre que damos al array, en el ejemplo era temp.
La dimensión es el número de elementos que tiene el array.
Como he indicado antes, al declarar un array reservamos en memoria tantas
variables del tipo_de_dato como las indicada en dimensión.
Sobre la dimensión de un Array
Hemos visto en el ejemplo que tenemos que indicar en varios sitios el tamaño del
array:
en la declaración, en el bucle for y al calcular la media. Este es un programa
pequeño, en un programa mayor probablemente habrá que escribirlo muchas más
veces. Si en un momento dado queremos cambiar la dimensión del array tendremos
que cambiar todos.
Si nos equivocamos al escribir el tamaño (ponemos 25 en vez de 24) cometeremos
un error y puede que no nos demos cuenta. Por eso es mejor usar una constante
con nombre, por ejemplo, ELEMENTOS.
#include <stdio.h>
#define ELEMENTOS 24
int main()
{
int temp[ELEMENTOS];/*Con esto ya tenemos declaradas las 24
variables */
float media;
Ing. Julio Malave
Guía Matriz 0 Arrays

int hora;
/* Ahora tenemos que dar el valor de cada una */
for( hora=0; hora<ELEMENTOS; hora++ )
{
printf( "Temperatura de las %i: ", hora );
scanf( "%i", &temp[hora] );
media += temp[hora];
}
media = media / ELEMENTOS;
printf( "\nLa temperatura media es %f\n", media );
}
Ahora con sólo cambiar el valor de elementos una vez lo estaremos haciendo en
todo el programa.
Inicializar un array
En C se pueden inicializar los arrays al declararlos igual que hacíamos con las
variables.
Recordemos que se podía hacer:
int hojas = 34;
Pues con arrays se puede hacer:
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24,
22, 21, 20, 18, 17, 16, 17, 15, 14, 14, 14, 13, 12 };
Ahora el elemento 0 (que será el primero), es decir temperaturas[0] valdrá 15. El
elemento 1 (el segundo) valdrá 18 y así con todos. Vamos a ver un ejemplo:
#include <stdio.h>
int main()
{
int hora;
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25,
Ing. Julio Malave
Guía Matriz 0 Arrays

24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14, 14, 13, 12 };
for (hora=0 ; hora<24 ; hora++ )
{
printf( "La temperatura a las %i era de %i grados.\n", hora,
temperaturas[hora] );
}
}
Pero a ver quién es el habilidoso que no se equivoca al meter los datos, no es difícil
olvidarse alguno. Hemos indicado al compilador que nos reserve memoria para un
array de 24 elementos de tipo int. ¿Qué ocurre si metemos menos de los
reservados? Pues no pasa nada, sólo que los elementos que falten valdrán cero.
#include <stdio.h>
int main()
{
int hora;
/* Faltan los tres últimos elementos */
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25,
24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14 };
for (hora=0 ; hora<24 ; hora++ )
{
printf( "La temperatura a las %i era de %i grados.\n",
hora, temperaturas[hora] );
}
}
El resultado será:
La temperatura a las 0 era de 15 grados.
La temperatura a las 1 era de 18 grados.
La temperatura a las 2 era de 20 grados.
Ing. Julio Malave
Guía Matriz 0 Arrays

La temperatura a las 3 era de 23 grados.

...
La temperatura a las 17 era de 17 grados.
La temperatura a las 18 era de 15 grados.
La temperatura a las 19 era de 14 grados.
La temperatura a las 20 era de 14 grados.
La temperatura a las 21 era de 0 grados.
La temperatura a las 22 era de 0 grados.
La temperatura a las 23 era de 0 grados.
Vemos que los últimos 3 elementos son nulos, que son aquellos a los que no hemos
dado valores. El compilador no nos avisa que hemos metido menos datos de los
reservados.
NOTA: Fíjate que para recorrer del elemento 0 al 23 (24 elementos) hacemos:
for(hora=0; hora<24; hora++). La condición es que hora sea menos de 24. También
podíamos haber hecho que hora! = 24.
Ahora vamos a ver el caso contrario, metemos más datos de los reservados. Vamos
a meter 25 en vez de 24. Si hacemos esto dependiendo del compilador obtendremos
un error o al menos un warning (aviso). En unos compiladores el programa se creará
y en otros no, pero aun así nos avisa del fallo. Debe indicarse que estamos
intentando guardar un dato de más, no hemos reservado memoria para él.
Si la matriz debe tener una longitud determinada usamos este método de definir el
número de elementos. En nuestro caso era conveniente, porque los dias siempre
tienen 24 horas. Es conveniente definir el tamaño de la matriz para que nos avise si
metemos más elementos de los necesarios.
En los demás casos podemos usar un método alternativo, dejar al ordenador que
cuente los elementos que hemos metido y nos reserve espacio para ellos:
#include <stdio.h>
int main()
{
int hora;
/* Faltan los tres últimos elementos */
Ing. Julio Malave
Guía Matriz 0 Arrays

int temperaturas[] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25,
24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14 };
for ( hora=0 ; hora<24 ; hora++ )
{
printf( "La temperatura a las %i era de %i grados.\n", hora,
temperaturas[hora] );
}
}
Vemos que no hemos especificado la dimensión del array temperaturas. Hemos
dejado los corchetes en blanco. El ordenador contará los elementos que hemos
puesto entre llaves y reservará espacio para ellos. De esta forma siempre habrá el
espacio necesario, ni más ni menos. La pega es que si ponemos más de los que
queríamos no nos daremos cuenta.
Para saber en este caso cuantos elementos tiene la matriz podemos usar el
operador sizeof. Dividimos el tamaño de la matriz entre el tamaño de sus elementos
y tenemos el número de elementos.
#include <stdio.h>
int main()
{
int hora;
int elementos;
int temperaturas[] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25,
24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14 };

elementos = sizeof temperaturas / sizeof(int);

for ( hora=0 ; hora<elementos ; hora++ )
{
printf( "La temperatura a las %i era de %i grados.\n",
hora, temperas[hora] );
Ing. Julio Malave
Guía Matriz 0 Arrays

}
printf( "Han sido %i elementos.\n" , elementos );
}
Recorrer un array
En el apartado anterior veíamos un ejemplo que mostraba todos los datos de un
array.
Veíamos también lo que pasaba si metíamos más o menos elementos al inicializar
la matriz. Ahora vamos a ver qué pasa si intentamos imprimir más elementos de los
que hay en la matriz, en este caso intentamos imprimir 28 elementos cuando sólo
hay 24:
#include <stdio.h>
int main()
{
int hora;
/* Faltan los tres últimos elementos */
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25,
24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14, 13, 13, 12 };
for (hora=0 ; hora<28 ; hora++ )
{
printf( "La temperatura a las %i era de %i grados.\n",
hora, temperaturas[hora] );
}
}
Lo que se obtiene en mi ordenador es:
La temperatura a las 22 era de 15 grados.
...
La temperatura a las 23 era de 12 grados.
La temperatura a las 24 era de 24 grados.
Ing. Julio Malave
Guía Matriz 0 Arrays

La temperatura a las 25 era de 3424248 grados.

La temperatura a las 26 era de 7042 grados.
La temperatura a las 27 era de 1 grados.

Vemos que a partir del elemento 24 (incluído) tenemos resultados extraños. Esto es
porque nos hemos salido de los límites del array e intenta acceder al elemento
temperaturas [25] y sucesivos que no existen. Así que nos muestra el contenido de
la memoria que está justo detrás de temperaturas [23] (esto es lo más probable)
que puede ser cualquiera. Al contrario que otros lenguajes C no comprueba los
límites del array, nos deja saltárnoslos a la torera. Este programa no da error al
compilar ni al ejecutar, tan sólo devuelve resultados extraños. Tampoco bloqueará
el sistema porque no estamos escribiendo en la memoria sino leyendo de ella.
Otra cosa muy diferente es meter datos en elementos que no existen. Veamos un
ejemplo (ni se te ocurra ejecutarlo):
#include <stdio.h>
int main()
{
int temp[24];
float media;
int hora;
for( hora=0; hora<28; hora++ )
{
printf( "Temperatura de las %i: ", hora );
scanf( "%i", &temp[hora] );
media += temp[hora];
}
media = media / 24;
printf( "\nLa temperatura media es %f\n", media );
}
Ing. Julio Malave
Guía Matriz 0 Arrays

Lo he probado en mi ordenador y se ha bloqueado. He tenido que apagarlo. El

problema ahora es que estamos intentando escribir en el elemento temp[24] que no
existe y puede ser un lugar cualquiera de la memoria. Como consecuencia de esto
podemos estar cambiando algún programa o dato de la memoria que no debemos
y el sistema se bloquea. Así que mucho cuidado con esto