Quick basic
12) Arreglos
- Arreglos de una dimensión:
Hasta el momento hemos visto las estructuras de datos más sencillas que son las variables, pero ahora veremos otras estructuras de datos que se llaman arreglos.
Para ver más o menos para que se utilizan estas estructuras, vamos a ver lo siguiente:
Debemos introducir los nombres de 4 personas y guardarlos para luego volverlos a imprimir en el mismo orden en que entraron. La primera forma que se nos podría ocurrir, es usar 4 variables de tipo String, guardar los nombres en ellas y luego volverlos a imprimir, algo así como:
CLS
PRINT "CAPTURA
DE PERSONAS:"
INPUT "Persona
1";
persona1$
INPUT "Persona
2";
persona2$
INPUT "Persona
3";
persona3$
INPUT "Persona
4";
persona4$
PRINT "SALIDA
DE PERSONAS:"
PRINT "Persona
1";
persona1$
PRINT "Persona
2";
persona2$
PRINT "Persona
3";
persona3$
PRINT "Persona
4";
persona4$
Esta es la manera más trabajosa de hacerlo ¡Que tal si fueran 100 o 200 personas!
Los arreglos (también llamados arrays, matrices o vectores) son espacios de memoria que se utilizan para almacenar información de un tipo de dato determinado. Podemos tener arreglos de enteros, de cadena, de simple precisión, etc. Podemos imaginar un arreglo sencillo de la siguiente forma:
Cada cuadro (o dirección del arreglo) es un espacio reservado en memoria para guardar información del tipo que vaya a ser el arreglo. Siguiendo con el ejemplo de las 4 personas, se supone que el arreglo será de tipo String ya que almacenaremos cadenas de caracteres. Para utilizar un arreglo, debemos declararlo primero con la siguiente sintaxis:
DIM nombre del arreglo(tamaño del arreglo) AS tipo de dato
Siguiendo con el ejemplo anterior, podemos declarar nuestro arreglo de la siguiente forma:
DIM personas(4) AS STRING
Ahora veremos como llenar las localidades que reservamos en el arreglo.
DIM
personas(4)
AS STRING
CLS
PRINT "CAPTURA DE PERSONAS:"
INPUT "Persona 1";
persona(1)
INPUT "Persona 2";
persona(2)
INPUT "Persona 3";
persona(3)
INPUT "Persona 4";
persona(4)
PRINT "SALIDA DE PERSONAS:"
PRINT "Persona 1";
persona(1)
PRINT "Persona 2";
persona(2)
PRINT "Persona 3";
persona(3)
PRINT "Persona 4";
persona(4)
En realidad el programa anterior es muy trabajoso todavía, pero nos ilustra de una manera como es que se llenan las direcciones de un arreglo. De lo anterior podemos ver que el nombre de la persona 1 se almacenará en la dirección 1 del arreglo, la persona 2 en la dirección 2, la persona 3 en la dirección 3 del arreglo, etc, etc, etc. Si quisiéramos llenar una dirección 5 se produciría un mensaje límite fuera de rango, ya que queremos poner valores en una dirección que no existe.
Como las direcciones están especificadas por un número, podemos utilizar un FOR para rellenar el arreglo en la posición del contador, empezando el contador en el límite inferior del arreglo y terminando en el límite superior. Veamos como se hace:
DIM
personas(4)
AS STRING 'Declaramos
nuestro arreglo
CLS
PRINT "CAPTURA
DE PERSONAS:"
FOR
c
=
1
TO
4
PRINT "Persona";
c;
":";
: INPUT "",
personas(c)
'Rellena
arreglo en la posición de c
NEXT
c
PRINT "SALIDA
DE PERSONAS:"
FOR
c
=
1
TO
4
PRINT "Persona";
c;
":";
personas(c)
'Imprime
arreglo en la posición c
NEXT
c
Existe otra forma de declarar un arreglo que es la siguiente:
Sintaxis: DIM nombre del arreglo(límite inferior TO límite superior) AS tipo de dato
De lo anterior podemos deducir que es posible tener arreglos cuyo límite inferior sea cualquier entero corto. Por ejemplo:
DIM
elementos(3
TO
19)
AS INTEGER
DIM
goles(0
TO
15)
AS INTEGER
El limite inferior por default es 0. Sí el límite inferior es cero, porqué empezamos a rellenar el arreglo desde la posición 1?. Si consideramos el formato:
DIM nombre del arreglo(tamaño del arreglo) AS tipo de dato
podemos ampliar lo siguiente:
· Si empezamos a rellenar el arreglo con 1 como límite inferior, entonces QBasic lo entenderá y nos dejará que lo rellenemos desde 1 para terminar en 4. En pocas palabras, si empezamos a rellenar en 1, el tamaño del arreglo permanece igual.
· Si queremos llenar el arreglo empezando desde 0, entonces terminaremos de introducir todas las personas en la posición 3 del arreglo. Pero como en realidad tamaño del arreglo es el límite superior, todavía podríamos introducir el nombre de una persona más en la posición 4 del arreglo. En pocas palabras si comenzamos a rellenar el arreglo desde 0, el tamaño del arreglo se incrementaría en 1.
Ya que QBasic lo permite, es recomendable empezar a rellenar el arreglo desde 1, aunque hay quién prefiere establecer desde el principio los límites del arreglo usando:
DIM personas(1 TO 4) AS STRING
Aunque no es muy común que se utilicen arreglos cuyo límite inferior sea diferente de 1, puede que se dé el caso y por eso se usa el TO para poner donde empieza y donde termina un arreglo.
- Arreglos de más de una dimensión:
Supongamos que queremos capturar los siguientes datos de 5 personas para luego imprimirlos en el mismo orden en que entraron:
· Nombre
· Apellido
· Edad
A simple vista se puede antojar utilizar 5 (1 por cada persona) arreglos de 3 elementos (en cada dirección iría un dato) tipo String; o también 3 (1 por cada dato) arreglos de 5 elementos (en cada elemento iría una persona). Como esto es algo tedioso (imaginemos unas 100 personas y unos 30 datos para algún curriculum...), lo mejor es utilizar un arreglo de dos dimensiones. En realidad la sentencia DIM no se limita a declarar variables o arreglos de 1 sola dimensión, sino que va mucho más allá:
DIM
personas(1
TO
10,
1
TO
5)
ó
DIM
personas(10,
5) 'Arreglo
de 2 dimensiones
DIM abuelos(2,
3,
15)
ó
DIM abuelos(1
TO 2,
1 TO
10,
1 TO
15)
'Arreglo de 3 dimensiones
Las dimensiones de un arreglo en QBasic pueden ser desde 0 (que es una variable sencilla) hasta 60 dimensiones; y el rango de los límites puede ser cualquier número en el intervalo de -36768 a 36767, pero el número de elementos no debe sobrepasar los 36767. Ahora veremos como utilizar un arreglo de dos dimensiones:
DIM
personas(5,
3)
AS STRING
'Entrada
de datos
FOR
individuo
=
1
TO
5
COLOR
10
CLS
PRINT TAB(33);
"CAPTURA
DE DATOS"
: PRINT
COLOR
15
PRINT "DATOS
DE LA PERSONA";
: PRINT
individuo
COLOR
7:
PRINT
FOR
dato
=
1
TO
3
IF
dato
=
1
THEN
INPUT "Introduzca
el nombre ->",
personas(individuo,
dato)
ELSEIF
dato
=
2
THEN
INPUT "Introduzca
el apellido ->",
personas(individuo,
dato)
ELSEIF
dato
=
3
THEN
INPUT "Introduzca
el sexo (M / F ) ->",
personas(individuo,
dato)
END IF
NEXT
dato
PRINT
COLOR
15
PRINT TAB(22);
"HECHO.
PRESIONE <ENTER> PARA CONTINUAR";
: INPUT "",
enter$
CLS
NEXT
individuo
'Salida
de datos
FOR
individuo
=
1
TO
5
COLOR
10
CLS
PRINT TAB(33);
"SALIDA
DE DATOS":
PRINT
COLOR
15
PRINT "DATOS
DE LA PERSONA";
: PRINT
individuo
COLOR
7:
PRINT
FOR
dato
=
1
TO
3
IF
dato
=
1
THEN
PRINT "Nombre
->";
personas(individuo,
dato)
ELSEIF
dato
=
2
THEN
PRINT "Apellido
->";
personas(individuo,
dato)
ELSEIF
dato
=
3
THEN
PRINT "Sexo
(M / F) ->";
personas(individuo,
dato)
END IF
NEXT
dato
PRINT
COLOR
15
PRINT TAB(22);
"HECHO.
PRESIONE <ENTER> PARA CONTINUAR";
: INPUT "",
enter$
CLS
NEXT
individuo
· En el ejemplo anterior utilizamos un arreglo de dos dimensiones para almacenar los datos de las personas. La primera dimensión identifica a las personas en una dirección respectiva (la persona 1 se representa en la dirección 1 de la primera dimensión del arreglo, la persona 2 en la dirección 2, la persona 3 en la 3, etc.) y en la segunda dimensión se guardan los datos de cada persona.
· Con el primer FOR nos posicionamos en la dirección de la persona y cuando con el segundo FOR terminamos de recolectar los datos, entonces se continua con la siguiente persona.
· Los datos se guardan usando la conveniencia de que el elemento 1 de la segunda dimensión corresponde al nombre de la persona, el elemento 2 al apellido y el elemento 3 a la edad. Por esto puse los ELSEIF.
Ahora veamos como utilizar un arreglo de 3 dimensiones:
'Recolecta
las horas trabajadas por semana de 2 trabajadores pertenecientes
'a
3 departamentos diferentes de 2 sucursales de una cadena comercial.
DIM empleados(2, 3, 2) AS INTEGER
FOR
sucursal
=
1
TO
2
COLOR
15
CLS
PRINT TAB(20);
"CAPTURA
DE HORAS TRABAJADAS SEMANALMENTE"
PRINT
COLOR
15
PRINT TAB(30);
"SUCURSAL";
sucursal
PRINT
FOR
departamento
=
1
TO
3
COLOR
15
PRINT "DEPARTAMENTO";
departamento
FOR
empleado
=
1
TO
2
COLOR
7
PRINT "Horas
trabajadas por el empleado";
empleado;
"->";
COLOR
10:
INPUT "",
empleados(sucursal,
departamento,
empleado)
NEXT
empleado
PRINT
NEXT
departamento
NEXT
sucursal
· La primera dimensión del arreglo corresponde a la sucursal, la segunda parte al departamento en donde trabaja el empleado y en la 3ª dimensión se almacenará el no. de horas que trabajó en la semana.
· El primer FOR nos sirve para primeramente colocarnos en la sucursal, el segundo FOR para colocarnos en el departamento, y el 3er. FOR nos sirve para recolectar las horas trabajadas de los empleados; cuando este ultimo FOR termina, entonces se prosigue con el siguiente departamento; y cuando se terminan los departamentos, entonces continuamos con la siguiente sucursal.
- LBOUND y UBOUND:
Estas dos funciones nos permiten obtener los límites inferior y superior de la dimensión de un arreglo (UBOUND, abreviatura de Upper Bound o límite superior; LBOUND, abreviatura de Lower Bound o límite inferior) respectivamente.
Sintaxis:
UBOUND(nombre
del arreglo[,dimensión])
LBOUND(nombre
del arreglo[,dimensión])
Si el arreglo es de una dimensión, entonces solo ponemos el nombre del arreglo. Por ejemplo si tenemos el arreglo:
DIM cubo(1 TO 20, 2 TO 9, 3 TO 15) AS SINGLE
Entonces:
LBOUND(empleados,
1)
'Devolverá
1 que es el límite inferior de la primera dimensión
LBOUND(empleados,
2)
'Devolverá
2 que es el límite inferior de la segunda dimensión
LBOUND(empleados,
3)
'Devolverá
3 que es el límite inferior de la tercera dimensión
y
UBOUND(empleados,
1)
'Devolverá
20 que es el límite superior de la 1° dimensión
UBOUND(empleados,
2)
'Devolverá
9 que es el límite superior de la 2° dimensión
UBOUND(empleados,
3)
'Devolverá
15 que es el límite superior de la 3° dimensión
Si quisiéramos obtener los límites superior e inferior del siguiente arreglo:
DIM vector(3) AS INTEGER
Es posible que si en un programa empezamos a rellenar este arreglo desde 1 creamos que como empezamos a rellenar desde 1, entonces LBOUND nos retornará 1; lo cual no hay nada más falso. Por otro lado y como ya hemos visto que los arreglos comienzan virtualmente en 0, entonces:
LBOUND(vector)
'Devolverá
0 ya que los arreglos empiezan desde 0.
UBOUND(vector)
'Devolverá
3 ya que en efecto el límite superior es 3.
De lo anterior podemos deducir que:
· Suponiendo que empezamos a rellenar un arreglo desde un número que no sea cero y luego queremos referirnos al menor elemento en una determinada dimensión utilizando LBOUND, entonces deberemos poner los limites usando TO. Ejemplo:
DIM
prueba(3
TO
6)
CLS
PRINT "El
limite inferior del arreglo prueba es",
LBOUND(prueba)
PRINT "El
limite superior del arreglo prueba es",
UBOUND(prueba)
· Podemos utilizar la declaración OPTION BASE n para indicar que el limite inferior de todos los arreglos de nuestro programa que no declaremos con TO empezarán en n, donde n puede ser 0 o 1. Ejemplo:
OPTION BASE
0
DIM
prueba(3
TO
6)
DIM
perros(3)
CLS
PRINT "El
limite inferior del arreglo prueba es",
LBOUND(prueba)
PRINT "El
limite superior del arreglo prueba es",
UBOUND(prueba)
PRINT
PRINT "El
limite inferior del arreglo perros es",
LBOUND(perros)
PRINT "El
limite superior del arreglo perros es",
UBOUND(perros)
Si se va a utilizar la declaración OPTION
BASE, entonces esta debe de ir antes de cualquier arreglo.
TO ofrece una mejor manera de
definir los límites del arreglo.
- Arreglos estáticos y dinámicos:
Existen dos tipos de arreglos: estáticos y dinámicos. Una arreglo estático es un arreglo cuyo número de elementos en cada dimensión permanecerá igual durante le ejecución del programa; por otro lado un arreglo dinámico es un arreglo cuyo número de elementos en cada dimensión puede cambiar en el transcurso del programa; o sea, puede hacerse más chico o más grande. Hasta el momento solo hemos manejado arreglos estáticos. Ya que los arreglos ocupan espacio en memoria, debemos indicarle al compilador si queremos que haga flexible a los arreglos y a la memoria, ó indicarle que los arreglos permanecerán con el mismo número de elementos durante todo el programa.
Si vamos a usar arreglos dinámicos en nuestro programa, entonces debemos de poner $DYNAMIC al inicio del programa y a manera de comentario, esto es:
'$DYNAMIC ó REM $DYNAMIC
Por otro lado si en nuestro programa solo vamos utilizar arreglos estáticos, entonces podemos poner $STATIC al inicio del programa, aunque no es necesario.
'$STATIC ó REM $STATIC
Todos los arreglos por default son estáticos y tipo Single.
- ERASE y REDIM:
La sentencia ERASE reinicializa un arreglo poniendo todos los elementos a cero y todas las cadenas en nulo ( "" ) (en pocas palabras lo resetea). Ejemplo:
'Ejemplo
de borrado de arreglos.
DIM
prueba(1
TO
5)
CLS
PRINT "le
damos valores al arreglo prueba:"
FOR
x
=
1
TO
5
STEP
1
prueba(x)
=
x
PRINT "Prueba
(";
x;
")
->";
prueba(x)
NEXT
x
PRINT
ERASE
prueba
PRINT "luego
de resetear el arreglo prueba:"
FOR
x
=
1
TO
5
STEP
1
PRINT "Prueba
(";
x;
")
->";
prueba(x)
NEXT
x
Para borrar más de un arreglo solo hay que ponerlos separados por comas ( , ) después de ERASE. Por otro lado, la sentencia REDIM cambia el numero de elementos que contienen las dimensiones de un arreglo $DYNAMIC.
'Ejemplo
de arreglo dinámicos.
REM $DYNAMIC
DIM
prueba(1
TO
5)
CLS
PRINT "Al
principio el limite inferior del arreglo es";
LBOUND(prueba)
PRINT "y
el límite superior es";
UBOUND(prueba)
PRINT
REDIM
prueba(7
TO
100)
'Cambiamos
lo límites del arreglo.
PRINT "Luego
el limite inferior del arreglo es";
LBOUND(prueba)
PRINT "y
el límite superior es";
UBOUND(prueba)
REDIM cambia el número de elementos en las dimensiones de un arreglo, no las dimensiones; o sea, no podemos tener algo como:
REM $DYNAMIC
DIM
arreglo(5,
6)
'Array
de 2 dimensiones
REDIM
arreglo(3,
5,
6)
'Array
de 3 dimensiones
Por último solo queda mencionar que al cambiar el tamaño del un arreglo, todos los elementos se resetean (números a 0 y cadenas a "" ). También es posible cambiar el número de elementos del arreglo $DYNAMIC, primero borrándolo con ERASE y luego volver a declarar los límites con DIM, aunque es más engorroso.
'Ejemplo
de arreglo dinámicos II.
REM $DYNAMIC
DIM
prueba(1
TO
5)
CLS
PRINT "Al
principio el límite inferior del arreglo es";
LBOUND(prueba)
PRINT "y
el límite superior es";
UBOUND(prueba)
PRINT
ERASE
prueba
'Primero
lo borramos...
DIM
prueba(5
TO
20)
'y
luego lo volvemos a declarar.
PRINT "Luego
el limite inferior del arreglo es";
LBOUND(prueba)
PRINT "y
el límite superior es";
UBOUND(prueba)
Descargar gratis los programas y compiladores necesarios para aprender a programar
¿Buscas algo?