Arreglos estáticos de variables: vectores, matrices, listas
Introducción
¡Bienvenidas y bienvenidos a una nueva clase del curso de Programación Básica, el avance que has conseguido al llegar aquí es sensacional! En esta ocasión nos enfocaremos a entender el concepto de arreglos de variables. La idea es relativamente simple, imagina que vives en un edificio de departamentos, si quieres dar instrucciones al repartidor de pizza para que te entregue tu comida, le das la dirección donde se ubica el departamento, pero no basta, le tienes que dar el número de departamento, y ahí está el truco, la dirección de un departamento se determina con un número y las computadoras son maravillosas para manejar números.
Una aplicación muy frecuente del uso de estos arreglos es el manejo de vectores; las matrices son otro objeto matemático que vas a usar con mucha frecuencia en tus estudios, para hacer herramientas computacionales que manipulen este tipo de datos se usan los arreglos.
Pues bueno, vayamos a los detalles, ya verás cuan útil te va a resultar el saber usar los arreglos.
Desarrollo del tema
¿Qué son los arreglos?
Comencemos definiendo el concepto de arreglo, un arreglo es un conjunto ordenado de variables del mismo tipo, las variables comparten un nombre en común, pero son identificadas unas con otras con un número.
Si tu necesitas manipular muchas variables del mismo tipo que representan cosas semejantes, por ejemplo, las estaturas de un grupo de N personas, con lo que sabemos hasta ahora tendríamos que declarar cada una de las N variables que almacenarán los datos, imagina que N=1000 . ¡¡¿¿Te imaginas todo lo que tendrías que escribir para declarar 1000 variables??!!, y peor, ahora piensa en la línea de código que tendrías que escribir para sumar esas 1000 variables ¡¿verdad que resulta completamente impráctico?!
No te preocupes, para eso nos van a servir los arreglos, en vez de declarar 1000 variables:
double estatutura1, estatura2, …, estatura1000;
Lo que hacemos es que declaramos un solo conjunto de variables que se llame estatura y le decimos con un número cuantos elementos existirán en el conjunto:
double estatura[1000];
Al ejecutarse la línea anterior el programa le solicita al sistema operativo espacio en memoria para localizar 1000 variables del tipo double (8000 bytes) y el sistema operativo asigna el nombre de la variable a esa memoria que consiguió.
Nota dos puntos muy importantes en la declaración, tienes un solo nombre y un solo tipo de dato, por eso, TODAS las variables que pertenecen al conjunto DEBEN ser del mismo tipo. Segundo punto importante, es necesario decir con cuantas variables va a contar el conjunto, y debemos ser MUY cuidadosos de no tratar de usar más variables de las que solicitaste
¿Verdad que nos hemos ahorrado mucho que escribir? ¡Pero no solo hemos logrado eso! Mira, para usar la primera variable del conjunto nos vamos a referir a ella con el nombre estatura y usaremos los corchetes para indicar cual de ese conjunto queremos usar. La primera variable será estatura[0], la segunda estatura[1], y así sucesivamente hasta llegar a la última que es la estatura[999]. ¡!!Podemos escribir el nombre del arreglo y dentro de los corchetes poner una variable!!! Ahora si ya está descubierto el gran poder que tienen los arreglos, los podemos ver como variables que podemos controlar con otras variables.
Reglas de uso de arreglos:
1. Lo primero es declarar el arreglo, como cualquier tipo de variable usada en C, primero hay que declararla, la declaración se hace así:
tipo nombre[cantidad];
El tipo se refiere al tipo de datos que contendrá el arreglo (char, int, float, double ….) el nombre debe cumplir con las reglas de nombramiento de C, y la cantidad es el número de variables que formará el conjunto arreglo.
En una declaración de un arreglo la cantidad de ser una constante, no podemos poner dentro de los corchetes una variable, por eso reciben el nombre de arreglos estáticos, durante toda la corrida del programa el arreglo tendrá la cantidad indicada de datos y cada vez que se corra el programa el arreglo tendrá el mismo tamaño siempre. Más adelante veremos cómo manejar otro tipo de arreglos que se llaman arreglos dinámicos que ahí sí, dependiendo de condiciones de la corrida el tamaño del arreglo puede ser determinado en el momento y no ser siempre el mimo, pero un paso a la vez.
2. Uso de las variables cuando el arreglo ya ha sido definido: para acceder al valor de una variable del conjunto arreglo se usa el nombre del arreglo y entre corchetes, se pone el número correspondiente a la variable que queremos usar. En este caso el número SI puede ser el valor de otra variable (solamente en la declaración es donde dentro de los corchetes se pone una constante). La primera variable del arreglo ocupa la posición 0 y la última ocupa cantidad-1. El valor que ponemos dentro del corchete debe ser un entero, el compilador hará un cast implícito si se nos ocurriera poner otro tipo de dato dentro de los corchetes.
3. Es OBLIGACIÓN del programador asegurarse de elegir variables que pertenezcan al arreglo, es decir, si se eligieron 10 variables para el arreglo edad:
double edad[10];
Cuando usemos alguna variable, por ejemplo, la primera:
edad[0]=40;
Pero note que para poner la edad del último elemento tendremos que escribir
edad[9]
Dado que el 0 ocupa una posición, la última posición es el tamaño del arreglo menos uno.
Si por algún descuido intentamos usar una variable del arreglo que excede el tamaño, el compilador NO marcará un error y no nos advertirá de nuestro error, el único error que aparecerá es que cuando intentemos escribir en un lugar de memoria que no nos pertenece, el sistema operativo detendrá el programa con la indicación segmentation fault y el programa abortará la ejecución. Consideremos esta falla como la indicación del sistema operativo como un gran regaño, semejante a que si la policía nos hubiera encontrado dentro de una casa que no es nuestra.
Aplicaciones de usos de arreglos:
Los arreglos y los ciclos for están íntimamente relacionados, por ejemplo, pensemos en la necesidad de almacenar de manera separada la estatura de 10 personas, ¿Cómo pedimos los 10 valores de cada persona?, ¿en verdad tenemos que escribir parejas de printf y scanf para capturar las 10 variables? ¿y si fueran 1000?
Afortunadamente el conjunto de arreglos y ciclos for salvan la situación:
//Declaración del arreglo:
double edad [10];
int i;
.
.
.
//Llenado del arreglo:
for (i=0;i<10;i++)
{
printf (“ De el valor de edad[%d]=”);
scanf(“%lf”,&edad[i]);
}
Con las líneas anteriores llenaríamos los 10 valores que contiene el arreglo, ¡!no hay que escribir una línea para cada variable!!
¿En qué situaciones prácticas usamos a los arreglos? Cuando necesitemos almacenar muchos datos de manera independiente es una muy buena oportunidad de usar arreglos. Si necesitamos hacer operaciones entre muchos datos también es un indicativo de usar arreglos.
En física y matemáticas hay unos objetos que se llaman vectores, esto vectores son un conjunto ordenado de números (¡precisamente lo que es un arreglo!), efectivamente los vectores se implementan computacionalmente con arreglos, las operaciones con las que se manipulan los vectores se pueden programar en c.
Arreglos de 2 dimensiones:
Así como definimos los arreglos hace un momento, podemos definir arreglos que su identificación dependa no solo de un número sino de dos, a estos arreglos se les llama arreglos bidimensionales, y si dependiera de tres números llamarán arreglos tridimensionales.
La declaración de arreglos bidimensionales se hace de manera muy parecida a los unidimensionales:
tipo nombre [tam1][tam2]
donde tipo es el tipo de variables del arreglo, nombre debe cumplir con las reglas de nombramiento y tam1 se refiere al tamaño en la primera dimensión del arreglo y tam2 es el tamaño en la segunda dimensión (no tienen por qué ser iguales).
Para acceder o cambiar el valor de una variable se hace igual:
//Declarando un arreglo bidimensional de 100 renglones y 200 columnas:
double matriz[100][200];
//modificando el valor del primer elemento en los renglones y el primero en las columnas:
matriz[0][0]=20.4;
Todas las obligaciones de las que platicamos para los arreglos unidimensionales se aplican para estos.
Las matrices son objetos matemáticos que descubrirán y verán que son de GRAN utilidad en múltiples aplicaciones ¡incluidos los videojuegos!
Aritmética de vectores y matrices:
Como vimos anteriormente, un arreglo que contenga N datos es la forma perfecta de majeo de un objeto matemático que se llama vector en un espacio de N dimensiones, la aritmética de vectores nos enseña como manipular estos objetos, veamos operaciones básicas entre dos vectores, llamemos a los vectores A,B y C:
Suma de vectores.
C=A+B
La manera en que se calcula la i-esima componente de C es sumando las i-esimas componentes de A y de B:
C[i]=A[i]+B[i]
Resta de vectores:
C=A-B
C[i]=A[i]-B[i]
La multiplicación de vectores tiene un comportamiento particular, El producto punto entre dos vectores da como resultado un escalar, no un vector, por eso también se llama producto escalar, la operación se realiza como la suma sobre cada componente del producto de las componentes:
p= A[0]B[0]+A[1]B[1]+…+A[N-1][B[N-1]
Esto se representa simbólicamente como:
Piense en un pedazo de código en el que se calculen todas las componentes y valores de las operaciones anteriores.
Soluciones prácticas a las complicaciones que intervienen en el uso de arreglos estáticos.
Como ya indicamos, el tamaño de un arreglo está fijo, imaginemos una situación donde queremos calcular el promedio de peso un grupo de personas, pero el número de personas algunas veces son unas y otras ya son más o menos ¿Cómo resolvemos si el tamaño del arreglo debe ser estático?, muy fácilmente, declaremos el arreglo con una cantidad de datos más grande de lo que pudiéramos usar en el peor escenario, de tal manera que aseguramos que SIEMPRE habrá lugar en el arreglo y nuestro programa cuidará de solo usar lo que se necesita.
Ejercicios:
Haga un programa que calcule el promedio de peso de un grupo de N personas, donde N será uno de los datos que el programa debe solicitar:
#include <stdio.h>
Int main (void)
{
int N, i;
double peso[1000];
double suma, promedio;
//preguntando por el número de personas
printf(“Cuantas personas? N=”);
scanf (“%d”,&N);
//introduciendo los datos :
for (i=0;i<N;i++)
{
printf(“Dame el peso número %d =”,i);
scanf (“%lf”,&peso[i]);
}
//calculando la suma de los pesos:
suma=0;
for (i=0;i<N;i++)
suma+=peso[i];
promedio=suma/N;
printfo(“El peso promedio es: %lf”,promedio);
return 0; }
Conclusión
Como habrás visto, los arreglos son elementos de programación MUY importantes, nos sirven para almacenar y manejar muchos datos en conjunto. Recuerda que tu tienes la responsabilidad de solicitar un tamaño suficientemente grande de datos para asegurar que no excederás este tamaño. Segunda condición importante, no intentarás leer o escribir en una variable que no sea parte del arreglo que definiste, es MUY importante no cometer errores en la posición donde queremos leer o escribir un dato.
¡Ánimo, el uso de arreglos va a ser de gran utilidad!
Fuentes de información
- En bucle https://en.wikipedia.org/wiki/For_loop
- Matriz (estructura de datos) https://en.wikipedia.org/wiki/Array_(data_structure)
- Formación https://code.fandom.com/wiki/Array