REGISTROS AULA MENTOR

Introducción

La finalidad de este tipo de datos es agrupar bajo un mismo nombre distintas características o
propiedades del objeto con el que estemos trabajando.

Un registro es un tipo de datos estructurado formado por un conjunto de una o más variables
agrupadas bajo un mismo nombre común, para hacer más eficiente e intuitivo el manejo de estas
variables.

A cada una de estas variables que forma parte del registro se le conoce como campo (o atributo),
y puede ser de cualquiera de los tipos explicados.

Si comparamos con el otro tipo estructurado que ya conocemos, las tablas, descubrimos que:

*Los elementos de una tabla son todos del mismo tipo, es un conjunto homogéneo.
*Los elementos de un registro pueden ser de distintos tipos, heterogéneos.

Por otra parte, el acceso a los miembros:

*De una tabla se hace mediante el nombre de la tabla y un índice.

*De un registro se hace mediante el nombre del registro y el nombre del campo.

Podemos agrupar la información referente a una persona (que antes almacenábamos en varias
variables) en un registro, donde cada uno de los campos coincide con una de las variables
previas: nombre, edad, altura y peso. Gráficamente se podría representar:

O se pueden describir todas las características de un libro en una estructura:

-título -autor
-editorial -año de publicación
-etc.

O las características de un producto de una tienda:

-referencia -código de barras
-color -precio
-descuento asociado -etc.

Pasemos a estudiar como se definen y usan los registros en Pascal.

-1-
REGISTROS AULA MENTOR

Definición

Al igual que ocurre con las tablas, podemos definir variables de tipo registro directamente en la
sección de variables, o definir un tipo de usuario registro. Para definir un registro se usa la
palabra reservada record. A continuación se definen los distintos campos del registro junto con
sus tipos. Esto es lo que podemos observar en el siguiente ejemplo:

Type
persona = record
nombre : string;
edad : integer;
peso : real;
altura : real;
end;

Var
alumno : persona;
profesor : record
nombre : string;
edad : integer;
peso : real;
altura : real;
end;
alumno1, alumno2 : persona;

El tipo de datos persona es un registro con cuatro campos y sus correspondientes tipos: nombre,
edad, peso y altura. Una vez definido el tipo de usuario persona se pueden definir variables del
tipo persona.

También se muestra como definir un registro en la sección de variables. El problema es que al

hacerlo de esa forma no se podrá pasar como parámetro a funciones o procedimientos, la misma
situación que ya estudiamos con tablas.

Acceso a los elementos

Para acceder a los elementos basta con utilizar el nombre de la variable, seguido de un punto y
el nombre del campo. De esta forma se puede usar ese campo como una variable más en nuestro
código:

alumno.nombre := 'Fermin Alerce Herranz';

alumno.edad := 48;

writeln('Nombre : ', alumno.nombre);

writeln('Edad : ', alumno.edad);

-2-
REGISTROS AULA MENTOR

write('Peso : ');
readln(alumno.peso);

write('Altura : ');
readln(alumno.altura);

ratio = alumno.peso/alumno.altura;

Operaciones con registros

La única operación permitida con un registro como conjunto es la asignación:

alumno1 := alumno;

Y además se debe cumplir no sólo que respondan a la misma estructura, sino que el tipo
asociado en sus definiciones sea el mismo. Según esto, la sentencia:

profesor := alumno; (* Atención: No compila *)

no compilaría por que la definición de tipos no es la misma.

Por otra parte, no se pueden comparar dos registros de la forma habitual, con el operador =

if ( alumno1 = alumno2 ) then (* Error: operación no permitida *)

Será necesario comparar los campos uno a uno. Para ello se puede codificar una función como
la siguiente:

(* Compara dos registros del tipo persona campo a campo y devuelve TRUE o FALSE
*)
Function compara_persona(per1, per2 : persona): Boolean;
Begin

compara_persona := (per1.nombre = per2.nombre)

AND (per1.edad = per2.edad)

AND (per1.peso = per2.peso)
AND (per1.altura = per2.altura);

End;
Y usarla como se muestra a continuación:

if ( compara_persona(alumno1,alumno2) ) then
writeln('Alumno1 y alumno2 son iguales')
else
writeln('Alumno1 y alumno2 NO son iguales');

-3-
REGISTROS AULA MENTOR

Uso de Registros

Aunque es posible asignar valores a los campos de un registro uno a uno, lo más habitual
es crear un procedimiento que se encargue de la lectura de todo el registro. Observe en el
siguiente ejemplo que es necesario pasar el parámetro por referencia.

(* Lee del teclado toda la información de una persona que se le pasa *)

(* como parámetro por referencia *)
Procedure read_persona(VAR alumno : persona);
Begin
write('Nombre : ');
readln(alumno.nombre);
write('Edad : ');
readln(alumno.edad);
write('Peso : ');
readln(alumno.peso);
write('Altura : ');
readln(alumno.altura);
End;

Del mismo modo creamos un procedimiento para agrupar la presentación de un registro

por pantalla en una función. En este caso no es necesario pasar el registro por referencia:

(* Presenta por pantalla toda la información de un registro del tipo persona que se le pasa
como parámetro *) *)

Procedure write_persona(alumno : persona);

Begin
writeln;
writeln('Nombre : ', alumno.nombre);
writeln('Edad : ', alumno.edad);
writeln('Peso : ', alumno.peso:0:1);
writeln('Altura : ', alumno.altura:0:2);
writeln;
End;
El uso de estas funciones es bastante sencillo. Además puede observar que el uso de
registros como parámetros de funciones es similar al uso de tablas.

read_persona(alumno2);
write_persona(alumno2);

-4-
REGISTROS AULA MENTOR

Registros anidados

Es posible incluso que alguno de los campos de un registro sea a su vez otro registro: en
este caso es necesario que el registro "interior" se defina primero.

Type
Tpersona = record
(* Tipo que define las caracteristicas de una persona *)
nombre : string[TAMNOMBRE];
dni : string[TAMDNI];
edad : integer;
end;
Talumno = record
datos : Tpersona;
teoria : real;
practica : real;
end;

Var
Juan: Talumno;

Observe que el identificador de tipo se ha precedido con una 'T'. A veces se usa esta
notación para hacer más evidente que se esta usando un Tipo definido por el usuario.
Para acceder a los campos del registro anidado o interior se usa el operador ".":

write('Nombre: ');
readln(alu01.datos.nombre);
write('Edad: ');
readln(alu01.datos.edad);
write('Nota Teoria: ');
readln(alu01.teoria);
write('Nota Practica: ');
readln(alu01.practica);

Estudiemos ahora una de las aplicaciones más frecuentes de los registros: las tablas de
registros.

-5-
REGISTROS AULA MENTOR

Tablas de registros

Vamos a utilizar en este apartado las dos estructuras compuestas estudiadas: tablas y registros.

Si ya hemos visto como agrupar la información, por ejemplo, de un alumno, ¿por qué no
agrupamos a los alumnos, del tipo Talumno en una tabla para poder tratar a toda la clase de
forma homogénea?

Observe las siguientes definiciones

Const

TAMCLASE = 10;
TAMNOMBRE = 30;
TAMDNI = 13;

Type

Tpersona = record (* Tipo registro que define las caracteristicas de una persona *)

nombre : string[TAMNOMBRE];
dni: string[TAMDNI];
edad: integer;

end;
(* Tipo que define las caracteristicas de un alumno: persona +notas *)
(* Es un ejemplo de registro anidado *)
Talumno = record

datos: Tpersona;
teoria: real;
practica: real;

end;
(* Tabla de registros del tipo Talumno *)

Tclase = array[1..TAMCLASE] of Talumno;

Var

edad: real; (* Edad media de la clase *)

miclase: Tclase; (* Define miclase como tabla de alumos *)
alumno: Talumno;

De esta forma se puede tratar cada elemento de la tablamiclase (miclase[i]) como una variable
de tipo Talumno:

write('Nombre: ');
readln(miclase[i].datos.nombre);

-6-
REGISTROS AULA MENTOR

write('Edad: ');
readln(miclase[i].datos.edad);

write('Nota Teoria: ');

readln(miclase[i].teoria);

write('Nota Practica: ');

readln(miclase[i].practica);

Claro que no debemos olvidar que lo que hacía verdaderamente potente a las tablas es la
posibilidad de tratar todos los elementos de la tabla mediante bucles.

Si suponemos codificadas las funciones read_alumno y write_alumno, se pueden codificar las

siguientes funciones para la lectura y escritura de los datos de toda la clase:

(* Procedimiento inicial para la lectura de la clase *)

Procedure lee_clase(VAR unaclase: Tclase);
Var
i : integer;
Begin
for i:= 1 to TAMCLASE do
read_alumno(unaclase[i]);
End;

Procedure escribe_clase(unaclase: Tclase);

Var
i : integer;
Begin
for i:= 1 to TAMCLASE do
write_alumno(unaclase[i]);
writeln;
End;

Observe:
El paso de parámetros a la función de lectura por REFERENCIA,
y a la función de escritura por VALOR.
Al mismo tiempo observe los bucles de ambas funciones,
y cómo se utilizan las funciones read_alumno y write_alumno: Se le pasan como parámetro un
elemento de la tabla, que será del tipo alumno.
Una vez que tiene los datos de su clase querrá hacer algún tipo de cálculos con ellos. Vamos a
realizar como ejemplo una función que nos presente por pantalla la edad media de la clase.

Para ello necesitamos que la función reciba como parámetro toda la clase. ¿Por valor o por
referencia? Recuerde: si no va a modificar el parámetro se debe pasar por valor.

Debemos codificar un bucle que vaya recorriendo cada elemento de la tabla (la clase) y
sumando la edad de cada alumno. Finalizado el bucle, dividimos por el número de alumnos. El
código resultante es:

-7-
REGISTROS AULA MENTOR

Procedure edad_media(unaclase: Tclase);

Var
i : integer;
suma : real;
media: real;
Begin
suma := 0;
for i:= 1 to TAMCLASE do
suma := suma + unaclase[i].datos.edad;
media := suma/TAMCLASE;
writeln('La edad media de la clase es de ', media:0:1);
End;

Puede estudiar todo el código de estos ejemplos en registros.pas.

(*
Tema 8: Registros

Programa ejemplo del uso de registros:

- definición
- acceso a los campos
- uso con funciones
- registros anidados
- tablas de registros
*)
Program Registros04;

Const
TAMCLASE = 2;
TAMNOMBRE = 30;

Type
Tpersona = record (* Tipo que define las caracteristicas de una persona *)
nombre : string[TAMNOMBRE];
edad : integer;
end;

Talumno = record
datos : Tpersona;
teoria : real;
practica : real;
end;

Tclase = array[1..TAMCLASE] of Talumno;

Var
miclase : Tclase; (* Define miclase como tabla de personas *)
alu01 : Talumno;

-8-
REGISTROS AULA MENTOR

(* Presenta por pantalla toda la información de una persona que se le pasa *)

(* como parámetro *)
Procedure write_persona(persona : Tpersona);
Begin
writeln;
write('Nombre: ', persona.nombre);
write(' Edad: ', persona.edad);
writeln;
End;

(* Presenta por pantalla toda la información del alumno que se le pasa *)

(* como parámetro *)
(* Aunque se podría codificar esta función partendo de cero, vamos a *)
(* codificarla partiendo de write_persona, para reutilizar el código *)
Procedure write_alumno(alumno : Talumno);
Begin
write_persona(alumno.datos);
write(' Teoria: ', alumno.teoria:0:1, ' Practica: ', alumno.practica:0:1);
write(' Nota media: ', (alumno.teoria+alumno.practica)/2:0:2);
End;

(* Lee del teclado toda la información de una persona que se le pasa *)

(* como parámetro por referencia *)
Procedure read_persona(VAR alumno : Tpersona);
Begin
writeln;
write('Nombre : ');
readln(alumno.nombre);

write('Edad : ');
readln(alumno.edad);
writeln;
End;

(* Presenta por pantalla toda la inforamción del alumno que se le pasa *)

(* como parámetro *)
(* Aunque se podría codificar esta función partendo de cero, vamos a *)
(* codificarla partiendo de write_persona, para reutilizar el código *)
Procedure read_alumno(VAR alumno : Talumno);
(* Pruebe a no pasar alumno por referencia... *)
Begin
read_persona(alumno.datos);
write('Nota Teoria: ');
readln(alumno.teoria);

write('Nota Practica: ');

readln(alumno.practica);

-9-
REGISTROS AULA MENTOR

End;

(* Procedimiento para la lectura de la clase *)

Procedure lee_clase(VAR unaclase: Tclase);
Var
i : integer;
Begin
i := 1;
for i:= 1 to TAMCLASE do
begin
read_alumno(unaclase[i]);
end;
End;

(* Procedimiento para presentar por pantalla los datos de la clase *)

Procedure escribe_clase(unaclase: Tclase);
Var
i : integer;
Begin
for i:= 1 to TAMCLASE do
write_alumno(unaclase[i]);
writeln;
End;

(* Calcula la edad media de al clase. *)

Procedure edad_media(unaclase: Tclase);
Var
i : integer;
suma : real;
media: real;
Begin
suma := 0;
for i:= 1 to TAMCLASE do
suma := suma + unaclase[i].datos.edad;
media := suma/TAMCLASE;
writeln('La edad media de la clase es de ', media:0:1);
End;

(* Programa principal *)
Begin

lee_clase(miclase);
escribe_clase(miclase);

edad_media(miclase);

End.

- 10 -