3.

- Arreglos (Arrays) Bidimensionales

Introducción:

Hasta este momento conoces lo sencillo y útil que es utilizar arreglos cuando es necesario
manipular más de una variable del mismo tipo.

Pero qué sucede si se necesitan utilizar un número importante de variables, por ejemplo:

Si fuera necesario almacenar las temperaturas de todo un día, monitoreando esta magnitud
cada hora, los siete días de la semana.

Con lo aprendido hasta el momento la solución a esta situación sería declarar 7 arreglos
con veinticuatro elementos cada uno, aunque esta tarea no es difícil, sí es muy laboriosa,
tales declaraciones ocuparán varias líneas de código restando legibilidad al código fuente.

Para estos casos especiales el Lenguaje de programación C provee al programador la

capacidad de declarar arreglos multidimensionales, en esta unidad de aprendizaje
estudiarás únicamente los arreglos bidimensionales.

Arreglos bidimensionales:

Los arreglos bidimensionales son un conjunto de variables del mismo tipo (tipo de variable)
agrupadas en filas y columnas, cuyo nombre se diferencia en el índice (números entre
corchetes).

Esta es la sintaxis necesaria para declarar un arreglo bidimensional:

Tipo
1 nombre [ filas
3 ][ columnas ];

2 4

1 Tipo: es cualquier tipo de variable, por ejemplo char, int, float o doublé.

2 Nombre: corresponde al nombre del arreglo, este nombre obedece a las mismas reglas
que el nombre de una variable o el de una constante.

3 [filas]: Lo encerrado entre corchetes (índice) es el tamaño de la primera dimensión del

arreglo, es decir el número de filas (variables) que forman la primera dimensión del arreglo,
este puede estar determinado por el valor que almacena una variable o una constante y
debe de ser un número entero, es posible omitir en la declaración de un
arreglo el tamaño y posteriormente se puede asignar, por ejemplo en tiempo de
ejecución, es decir, cuando se ejecuta el programa.

4 [columnas]: Lo encerrado entre corchetes (índice) es el tamaño de la segunda dimensión

del arreglo, es decir el número de columnas (variables) que forman la segunda dimensión
del arreglo, este puede estar determinado por el valor que almacena una variable o una
constante y debe de ser un número entero, es posible omitir en la declaración de un arreglo
el tamaño y posteriormente se puede asignar. por ejemplo en tiempo de ejecución.

Por ejemplo, para declarar un arreglo bidimensional de números enteros llamado num con
tres filas y dos columnas se hace de la siguiente forma:

intnum[3]num[2];

Con esta línea de código se están declarando seis variables de tipo entero llamadas
num[0][0], num[0][1], num[1] [0], num[1][1], num[2][0] y num[2][1].

Nota: En el Lenguaje C, todos los arreglos bidimensionales usan cero

como índice para el primer elemento.

Una alternativa para realizar esta misma declaración es la siguiente:

int r =3,m=2;

intnum[r][m];

En este caso también se declaró un arreglo de seis variables de tipo entero.

Observa que el tamaño del arreglo está determinado por el valor de la variable r y la
variable m.

Enseguida se muestra una representación gráfica del conjunto de variables que forman al
arreglo bidimensional.

Columna 0 Columna 1

Fila 0 num[0][0] num[0][1]

Fila 1 num[1][0] num[1][1]
Fila 2 num[2][0] num[2][1]
Como puedes ver, en esta representación se indican tanto filas como columnas del
arreglo bidimensional, la lógica es la siguiente:

En el primer elemento: num[0] [0], el primer índice pertenece a la fila 0 y el segundo índice
pertenece a la columna 0.

En el segundo elemento: num[0] [1], el primer índice pertenece a la fila 0 y el segundo

índice pertenece a la columna 1.

En el tercer elemento: num[1] [0], el primer índice pertenece a la fila 1 y el segundo índice
pertenece a la columna 0.

En el cuarto elemento: num[1] [1], el primer índice pertenece a la fila 1 y el segundo índice
pertenece a la columna 1.

En el quinto elemento: num[2] [0], el primer índice pertenece a la fila 2 y el segundo índice
pertenece a la columna 0.

En el sexto elemento: num[2] [1], el primer índice pertenece a la fila 2 y el segundo índice
pertenece a la columna 1.

Si el tamaño del arreglo bidimensional fuera mayor se seguiría la misma lógica.

Un ejemplo de cómo asignar un valor a un elemento de un arreglo bidimensional es el

siguiente:

num[0][0] = 15; /* Asigna 15 al 1er elemento del arreglo bidimensional llamado

num*/

Nota: El elemento llamado num[0] [0] es únicamente una variable con una
dirección de memoria, por lo tanto, solamente puede almacenar un valor.

Otro ejemplo de cómo asignar valores a los elementos de un arreglo bidimensional es el

siguiente:

int t[2][2] = { { 15, 17 },

{ 18, 20 } };
Ahora el primer elemento que será t[0][0] almacenará un 15.

El segundo elemento t[0][1] almacenará un 17, el tercer elemento t[1][0]almacenará un 18

y el cuarto elemento t[1][1] almacenará un 20.

Como puedes observar se utilizaron los operadores { } para realizar la asignación, además
de que los números asignados están separados por el operador coma (,).

Lo siguiente, es la representación gráfica del arreglo:

num[0][0]=15 num[0][1]=17
num[1][0]=18 num[1][1]=20

Para acceder al valor almacenado en un elemento de un arreglo bidimensional y

almacenarlo en otra variable (que no sea un elemento de un arreglo) se puede realizar lo
siguiente:

Para aclarar lo anteriormente explicado analiza el siguiente código fuente, el cual vas a
retomar posteriormente para realizar una actividad integradora.

Este código fuente declara un arreglo bidimensional de siete filas y veinticuatro columnas
con lo cual se declaran ciento sesenta y ocho variables, para almacenar la temperatura de
las veinticuatro horas de un día por toda una semana, es decir, por siete días. Después de
almacenar esta información el programa calcula el promedio de la temperatura de toda la
semana y lo muestra por pantalla.
El resultado de editar, depurar y compilar este código fuente es el siguiente:
Explicación:

En la primer línea de código después de la llave de apertura de la función main() se declara

un arreglo bidimensional llamado temp de ocho filas y veinticuatro columnas, no se asigno
ningún valor a los ciento sesenta y ocho elementos que forman este arreglo bidimensional,
quedando de la siguiente forma:

floattemp[7][24];

En las siguientes dos líneas de código se declararon tres variables la primera de tipo float
llamada media a la cual se le asigno un valor de cero, las siguientes dos variables
declaradas son de tipo entero sus nombres son hora y día, estas dos variables no fueron
iniciadas en esta línea sino más abajo dentro de las dos sentencias de control for.

Enseguida encontramos un par de sentencias de control for anidadas, es decir, una dentro
de la otra, la primera es la que a continuación se muestra:

for( dia=1 ; dia<8 ; dia++ )

Esta sentencia de control for, se ejecutara siete veces de acuerdo a la condición de que:
dia<8 ;

Por esto se ejecutará únicamente siete veces (los 7 días de una semana) ya que la variable
día se inicio con uno.

Dentro de esta sentencia de control for se encuentra otra sentencia for, la cual se muestra
enseguida:

Como puedes observar esta sentencia repetirá el código escrito entre { y } veinticuatro
veces (las 24 horas que forman un día), entonces esta última sentencia de control (for) se
repetirá siete veces, con lo cual se solicitara la temperatura de
los siete días de la semana con sus veinticuatro horas.

El código escrito entre { y } se encarga de solicitar la

temperatura del día 1 a las 0 horas, ya que estos son los
valores con que se iniciaron las variables día y hora
respectivamente.

La función scanf( )es la encargada de solicitar por el teclado la

temperatura y guardar esta información en cada uno de los
elementos del arreglo bidimensional, el primer elemento donde
se guarda la primera lectura es: temp[1][0], el segundo se
guarda en el elemento temp[1][1], y así sucesivamente hasta
el último.

Observa que los índices que establecen el número de

elemento están determinados por las variables día y hora.

Para poder calcular el promedio semanal de la temperatura es

necesario sumar cada uno de los valores introducidos para
realizar esta operación se implemento la siguiente línea de
código:

media = media +temp[dia][hora];

En la variable llamada media de tipo float se van almacenando

y sumando el valor guardado en cada uno de los elementos
del arreglo bidimensional.

Por último, después de que se ejecutaron por completo las dos

sentencias de control for encontramos las siguientes líneas:

media = media/168;

printf( "El promedio de la temperatura en toda la semana

es: %f\n ", media );

La primera línea se encarga de calcular el promedio y la

segunda de mostrar este resultado en pantalla.

Conclusión

Los arreglos bidimensionales son un conjunto de variables del

mismo tipo, agrupadas en filas y columnas, cuyo nombre se
diferencia en el índice.

La implementación de un arreglo bidimensional permite al

programador manejar una gran cantidad de variables del
mismo tipo, con mayor claridad que los arreglos
unidimensionales.

¡Buen trabajo, cada vez falta menos para terminar!

¡Sigue adelante!