Programación en Pascal/Arrays

De Wikilibros, la colección de libros de texto de contenido libre.
Saltar a: navegación, buscar

Los arrays son cadenas o listas de algo. Normalmente siempre serán del mismo tipo.

Hasta ahora, hemos visto un tipo de datos que es una cadena: los strings. Son cadenas de caracteres.

Los arrays son prácticamente imprescindibles en casi cualquier tipo de programa. De una forma u otra, todo programa necesita almacenar en memoria grandes cantidades de datos. Por ejemplo, un editor de texto almacena caracteres; un programa de música datos de samples, un programa de conversión almacena datos del dato que va a convertir, un programa de video frames, un juego almacena sus características y escenas, y así con la práctica mayoría de los programas.

Declaración de un array[editar]

La organización "array" es, probablemente, la estructura de datos más conocida debido a que en muchos lenguajes es la única disponible explícitamente.

Un "array" es una estructura homogénea que está constituida por componentes del mismo tipo, llamado tipo base.

También se denomina estructura de acceso aleatorio, o acceso directo, porque todos sus componentes pueden seleccionarse arbitrariamente y son igualmente accesibles. Para designar a un componente aislado, el nombre de la estructura se amplía con el llamado índice de selección del componente. El índice debe ser un valor del tipo definido como tipo índice del array.

     La definición de un tipo "array" T especifica un tipo base To y un tipo índice I.
                               TYPE      T = ARRAY [ I ]      OF  To
     Ejemplos:
                               TYPE vector = ARRAY [1..3] OF REAL
                               TYPE linea = ARRAY [1..80] OF CHAR
                               TYPE nombre = ARRAY [1..32] OF CHAR

Los índices de un "array" deben ser de tipo ordinal. No suele ser posible utilizar el tipo INTEGER porque se excedería el espacio de memoria accesible. Para usar valores enteros como índices, hay que indicar un subrango de enteros.

Un valor de tipo "array" se puede designar por un constructor donde se indica el nombre del tipo y valores constantes de los componentes separados por comas y encerrados entre paréntesis.

     Ejemplo:             vector (2.57, 3.14, -8.16)

Para especificar un mismo valor a componentes consecutivos, se puede usar un factor de repetición de la forma "n of valor"; donde "n" indica el número de componentes que recibirán el mismo valor, y debe ser una expresión constante de tipo INTEGER. El "valor" puede ser una constante u otro constructor del mismo tipo que el componente.

     Ejemplos:             vector (3 OF 1.0) es equivalente a vector (1.0,1.0,1.0)
                           vector (7.2, 2 OF 3.0)

Para seleccionar un componente individual de un "array" se usa un selector que consiste en escribir el nombre de la variable de tipo "array" seguido por el nombre correspondiente al componente, escrito entre corchetes.

     Ejemplo:                  si v := vector (2.57, 3.14, -8.16)
                               entonces v [1] es igual a 2.57.

Los componentes de un "array" se pueden someter a todas las operaciones permitidas para su tipo. La única operación definida para el "array" como tal, es la asignación ( := ).

La forma habitual de operar con "arrays" es actualizar componentes aislados.

El hecho de que los índices tengan que ser de un tipo de datos definido tiene una consecuencia importante: los índices pueden calcularse, es decir, puede ponerse una expresión en lugar de una constante. La expresión debe evaluarse y su resultado determina el componente seleccionado. Esta generalización proporciona una herramienta de programación potente pero, al mismo tiempo, da ocasión a uno de los errores de programación más frecuentes: el valor resultante puede estar fuera del intervalo especificado como campo de variación de los índices. Se supone que en tales casos, la implementación en un equipo concreto ha previsto la emisión de mensajes de error.

Los valores organizados en forma de "array" se suelen manejar utilizando índices variables y sentencias repetitivas que permiten construir algoritmos para realizar tratamientos sistemáticos.

Los índices son de tipo escalar, es decir, un tipo no estructurado en el que está definida una relación de orden. Si el tipo base también está ordenado, entonces queda establecida una relación de orden para ese tipo "array".

La relación de orden entre dos "arrays" está determinada por los dos componentes desiguales, correspondientes, con menor índice.

Arrays multidimensionales[editar]

Turbo Pascal no limita el número de dimensiones de un array, pero sí que debe estar declarado el tipo de cada subíndice.


identificador = array [índice1] of array [índice 2].. of array [índice n] of tipo de elemento identificador = array [índice 1, índice 2,...,índice n] of tipo de elemento Ampliando el ejemplo anterior supongase que ahora deseamos capturar calificaciones para 3 materias en cuyo caso aplicaremos un array tridimensional. De la siguiente forma :

Ejemplo:

Program Tridimensional;

{El siguiente programa captura calificaciones
de 5 alumnos en 3 examenes de 3 materias 
distintas, y despliega en pantalla los promedios
ordenados en forma descendente }

Uses Crt; Const

 MaxAlumno  = 5;
 MaxExamen  = 4; {Columna 4 almacena el promedio}
 MaxMateria = 3;
 materia    : array[1..3]of string[8]=('Fisica','Ingles','Historia');

Var

 Alumno     : array [1..MaxAlumno] of string[10];
 examen     : array [1..MaxAlumno,1..MaxExamen,1..MaxMateria] of real;
 aux_examen : array [1..MaxExamen]of real;
 {reserva 60 posiciones de memoria de datos reales :
  5 filas por 4 columnas y 3 dimensiones}
 promedio   :real;
 aux_alumno :string [10];
 i,j,k,col,ren : byte;

begin

 ClrScr;
 {lectura de arrays paralelos de manera simultánea}
 for k:=1 to MaxMateria do
   begin
     ClrScr;
     gotoxy(34,3);Write(materia[k]);
     gotoxy(5,5);Write('Nombre');
     gotoxy(20,5);Write('Examen1 Examen2 Examen3 Promedio');
     col:=5;ren:=6;
     for i:=1 to MaxAlumno do
       begin
         gotoxy(col,ren);
         if k=1 then
           ReadLn(alumno[i]) {lectura de vector}
         else
           Write(alumno[i]);
         col:=22;promedio:=0;
         for j:=1 to MaxExamen-1 do
           begin
             gotoxy(col,ren);
             ReadLn(examen[i,j,k]); {lectura de matríz}
             promedio:=promedio+examen[i,j,k];
             col:=col+10
           end;
         examen[i,j+1,k]:=promedio/3;
         gotoxy(col,ren);Write(promedio/3:3:2);
         inc(ren);
         col:=5
       end;
     gotoxy(15,22);
     Write('Presione una tecla para continuar....');
     ReadKey
   end;
 {ordenación}
 for k:=1 to MaxMateria do
   for i:=1 to MaxAlumno-1 do
     for j:=i+1 to MaxAlumno do
       begin
         if examen[i,MaxExamen,k]<examen[j,MaxExamen,k] then
           begin
             {intercambio de nombres en vector}
             aux_alumno:=alumno[i];
             alumno[i] :=alumno[j];
             alumno[j] :=aux_alumno;
             {intercambio de calificaciones en matríz}
             move(examen[i,k],aux_examen,SizeOf(aux_examen));
             move(examen[j,k],examen[i,k],SizeOf(aux_examen));
             move(aux_examen,examen[j,k],SizeOf(aux_examen))
           end
       end;
 {recorrido de matríz y vector}
 for k:=1 to MaxMateria do
   begin
     ClrScr;
     gotoxy(35,4);Write(materia[k]);
     gotoxy(25,5);Write('Datos ordenados');
     gotoxy(5,6);Write('Nombre');
     gotoxy(20,6);Write('Examen1 Examen2 Examen3 Promedio');
     col:=5;ren:=7;
     for i:=1 to MaxAlumno do
       begin
         gotoxy(col,ren);
         Write(alumno[i]);
         col:=22;
         for j:=1 to MaxExamen do
           begin
             gotoxy(col,ren);
             Write(examen[i,j,k]:3:2);
             col:=col+10
           end;
         col:=5;
         inc(ren)
       end;
     gotoxy(15,22);
     Write('Presione una tecla para continuar....');
     readkey
   end

end.

Arrays dinámicos[editar]