Arreglos

A diferencia de los elementos estudiados hasta ahora, los arreglos pertenecen al dominio de los tipos de datos y no al de las instrucciones de Pascal. A grandes rasgos, son conjuntos de variables que comparten un mismo nombre, pudiendo ser referenciadas de manera individual las variables del conjunto con ayuda de uno o más índices. Los arreglos guardan estrecha similitud con elementos de datos de la vida cotidiana, como los vectores y las tablas, y en cierto modo trazan una línea que separa la programación básica de la avanzada. Como la sintaxis formal de los arreglos es muy general, se comenzará definiendo los arreglos unidimensionales o vectores.

Arreglos unidimensionales: vectores

Supóngase que se tienen cinco variables: a, b, c, d y e. Si se desea hacer referencia a las cinco, deben usarse sus nombres, y eso implicaría, a nivel de programación, poner sus nombres en cada sentencia que se requiera (ReadLn, fórmulas, etc.) y repetir las mismas cinco veces. Un enfoque más general es poner a las variables un mismo nombre, y distinguirlas por un número, parecido a como hacen los libros de matemáticas para referirse de manera general a las componentes de los vectores o de las tuplas. Entonces, se hablaría de a(1), a(2), a(3), a(4) y a(5), en vez de las letras usadas anteriormente; como ya se sabe cómo generar los índices (los números entre paréntesis que permiten distinguir las variables), se puede usar un ciclo para manipular las variables y usar menos código.

La sintaxis para declarar un arreglo de una sola dimensión es:

Var
 <nomb> : Array [<li>..<ls>] Of <tipo>;

donde <nomb> es el nombre del arreglo, <li> es el valor inferior que puede tomar el índice y <ls> es el valor superior del índice. Un ejemplo real de declaración de arreglos se muestra a continuación:

Var
 a : Array[1..5] Of Integer;

que produce un arreglo llamado a de cinco variables enteras. La primera es a[1], la segunda es a[2], y así sucesivamente.

¿Cuál es la utilidad de este esquema? Si se tienen que leer cinco variables declaradas por separado, con nombres distintos, se usaría algo como esto:

ReadLn(a);
ReadLn(b);
ReadLn(c);
ReadLn(d);
ReadLn(e);

mientras que con arreglos, basta escribir:

For i := 1 To 5 Do
 ReadLn(a[i]);

que es evidentemente más cómodo.

A lo largo del curso se han visto programas que suman una cantidad de números usando dos variables, una para leer cada número y otra para acumular la suma. Este enfoque tiene la desventaja de que se pierden los valores de los sumandos. El uso de arreglos permite calcular la suma de los números con una cantidad mínima de código y a la vez conservar cada valor, como muestra el siguiente programa completo:

Program SumaN;
Uses WinCrt;
Const
 n = 5; {Cant. de #s}
Var
 nums: Array[1..n] Of Integer;
 s, i: Integer;
Begin
For i:=1 To n Do Begin
 Write('Número: ');
 ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('Suma: ', s);
End.

Nótese el uso de una constante para marcar el tamaño del arreglo; dicha constante, naturalmente, también sirve para controlar el For. De este modo, sólo se hace necesario cambiar un número para adecuar el programa a la escala apropiada.

Arreglos bidimensionales: tablas

Siguiendo la misma línea, se pueden relacionar grupos de vectores para formar tablas. Por ejemplo, supóngase que se quieren almacenar nombres de personas y sus respectivos números de teléfonos; se puede tener un vector de nombres y uno de números, de modo que el i-ésimo número de teléfono (en un vector) sea de la i-ésima persona (en el otro vector). Pues bien: existe un modo de fundir ambos vectores en un solo tipo de variable, una tabla de dos columnas y varias filas (o viceversa) en la que la posición [1, i] indique el nombre de una persona y la posición [2, i] indique el número de teléfono de esa persona. Para declarar esta estructura, se escribe:

Var
 Tabla: Array[1..2, 1..n] Of String;.

y de manera general, se puede declarar un arreglo bidimensional así:

Var
 <nomb>: Array[<li1>..<ls1>, <li2>..<ls2>] Of <tipo>;

De hecho, aunque no están contemplados en el programa del Laboratorio de Elementos de Computación, se pueden definir más dimensiones; no hay un límite definido a la cantidad de dimensiones de un arreglo.

Volviendo al ejemplo de la lista de personas y números de teléfono, se puede escribir un programa completo que use una tabla para leer y guardar esta información:

Program Telefonos;
Uses WinCrt;
Const
 n = 5;
Var
 Tabla: Array[1..2, 1..n] Of String;
 i: Integer;
Begin
For i:=1 To n Do Begin
 ReadLn(Tabla[1, i]);
 Write('Teléfono: ');
 ReadLn(Tabla[2,i]);
 WriteLn('Persona: ', i);
 Write('Nombre: ');
End;
End.

En este momento, los datos están en la memoria, y el esfuerzo que se requirió para leerlos fue menor que usando 10 variables independientes (cinco para los nombres y cinco para los números). Además, con sólo cambiar un valor, el de n, el programa almacena más pares de nombre y teléfono. Y aunque no se verá aquí, manipular esos datos una vez leídos es igual de fácil.

Unas consideraciones importantes sobre los arreglos: son racimos o conjuntos de variables, pero no pueden manejarse como tales. Siempre deberá hacerse referencia a una posición específica del arreglo; si se desea acceder a una parte del mismo o a su totalidad, deberá hacerse de manera iterativa, visitando los elementos que lo componen uno a uno.