REGISTROS
CONCEPTO DE REGISTROS: Un registro es una estructura heterogénea de datos, denominados campos y a los que accedemos por nombre. Al igual que en cualquier otro dato, el tipo registro (Record) antes de poder ser utilizado debe ser declarado en la sección de tipos.
La única operación (a parte de la lectura) que se puede realizar con una variable registro como tal es la asignación, es decir, se pueden copiar todos los campos de una variable registro a otra variable registro del mismo tipo. Además un registro puede ser pasado como parámetro a una función o prpcedimiento.
DECLARACIÓN DE UN REGISTRO:
La sintaxis de declaración de un registro es la siguiente:
Type
Tipo registro = Record
Campo1:Tipo1;
....
Campo N:TipoN;
End;
En donde:
TipoRegistro: Nombre de la estructura o dato del registro.
Campo: Lista de uno o mas campos separados por comas.
Tipo: Cualquier tipo de dato estándar o de finido por el usuario.
Por ejemplo:
Type
Alumno=Record
Nombre:String;
Edad:Integer;
Domicilio:String;
Grado:String[10]
Telefono:String[10];
End;
Esta declaración ha creado un tipo de dato llamado Alumno con cinco campos.
VARIABLE TIPO REGISTRO:
La de un registro por si solo no significa nada, para poder usar un registro es necesario que se declare una variable del tipo registro en el bloque Var, de la siguiente manera:
Var
NombreRegistro:TipoRegistro;
Por ejemplo, basándose en la declaración de registro anterior podríamos tener:
Var
Estudiante: Alumno;
Aux:Alumno;
ACCESAR A LOS CAMPOS DE UN REGISTRO:
Es importante saber como accesar a uno o más campos de un registro, la menera más común es la siguiente:
NombreRegistro.Campo
Por ejemplo:
Alumno.Nombre:='José María';
Alumno.Edad:=5;
Alumno.Domicilio:='Av. Angamos 325';
Alumno.Grado:='Primero';
Alumno.Telefono:='842564';
Cuando los datos ya están almacenados en el registro se puede manipular de forma similar a los otros datos en memoria.
LECTURA DE LOS CAMPOS DE UN REGISTRO:
Readln(Alumno.Nombre);
Readln(Alumno.Telefono);
ESCRITURA DE LOS CAMPOS DE UN REGISTRO:
Writeln(Alumno.Nombre);
Writeln('Nro. Telefononico: ',Alumno.Telefono);
Por ejemplo basándonos en el registro alumno (Primera declaración), tendríamos el siguiente programa:
Program Registro1;
Uses Crt;
Type
Alumno =Record
Nombre:String;
Edad:Integer;
Domicilio:String;
Grado:String[10]
Telefono:String[10];
End;
Var
DatosA;Alumno;
Begin
Clrscr;
(*Lectura de datos *)
Write('Nombre : ');Readln(DatosA.Nombre);
Write('Edad: ');Readln(DatosA.Edad);
Write('Domicilio: ');Readln(DatosA.Domicilio);
Write('Grado: ');Readln(DatosA.Grado);
Write('Telefono: ');Readln(DatosA.Telefono);
(*Escritura de los datos del registro*)
Clrscr;
Writeln('DATOS DEL ALUMNO ');
Writeln(DatosA.Nombre);
Writeln(DatosA.Edad);
Writeln(DatosA.Domicilio);
Writeln(DatosA.Grado);
Writeln(DatosA.Telefono);
Readkey;
End.
REGISTROS ANIDADOS:
En la construcción de un programa grande que maneje registros, a menudo nos tocaremos con la necesidad de tener registros anidados, eso quiere decir que es posible declarar un tipo registro con campos que sean otros registros.
Veamos la siguiente declaración:
Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac:Fecha;
GrupoSangre:String[10];
End;
Var
DatosA;Alumno;
Obsérvese que la variable FechNac es de tipo Fecha la cual hemos declrado anteriormente. Otra forma de declarar el registro anterior sería.
Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac=Record
dia,mes,anno:String[2];
End;
GrupoSangre:String[10];
End;
Lo malo de declarar un registro de esta manera (sin definición ni tipo) es que este no se puede mandar como parámetro.
COMO ACCESAR A REGISTROS ANIDADOS:
Para accesar a un campo de un registro anidado debemos de tener en cuenta la jerarquía de los registros, desde el nombre del registro principal (raíz) hasta el campo específico.
Por ejemplo basándonos en el registro alumno (Primera declaración), tendríamos el siguiente programa:
Program Registro2;
Uses Crt;
Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac:Fecha;
GrupoSangre:String[10];
End;
Var
DatosA;Alumno;
DatosEs:DatosEspecificos;
Procedure Leer;
Begin
Readln(DatosA.Apellidos);
Readln(DatosEs.FechNac.Dia);
End;
Procedure Escribir;
Begin
Writeln(DatosA.Apellidos);
Writeln(DatosEs.FechNac.Dia);
End;
Begin
Clrscr;
Leer;
Escribir;
Readkey;
End.
ARRAY DE REGISTROS:
En casos muy raros utilizaremos registros simples o unitarios, por lo general nos veremos en la necesidad de usar varios registros, la forma más adecuada de utilizar varios registros, la forma más adecuada de utilizar varios registros a la vez es mediante un arreglo de registro. El siguiente ejemplo detalla como podemos leer, escribir y manipular los datos de un arreglo:
Program Registro3;
Uses Crt;
Const
Max=10;
(*Declaracion del registro anidado*)
Type
Notas=Record
N1,N2,N3:Real;
End;
Alumno=Record
Nombres:String[30];
Nota:Notas;
Promedio:Real;
End;
(*declaracion del arreglo de registro*)
Type
ArrAlumn0=Array[1..MAx] of Alumno;
Var
i:Integer;
(*En el procedimiento leer se pasa como parámetro un arreglos de registros);
Procedure Leer(Var Al:ArrAlum);
Begin
For I:=1 To Max Do
Begin
Clrscr;
Write('Ingrese el nombre del alumno ',i,':');
Readln(A[i].Nombres);
Write('Nota 1:');Readln(A[i].Nota.N1);
Write('Nota 2:');Readln(A[i].Nota.N2);
Write('Nota 3:');Readln(A[i].Nota.N3);
End;
End;
{La función Promedio recibe como parámetro solo un registro por lo que el parámetro debe ser de tipo Alumno, es decir un solo registro; y devuelve el promedio}
Function PromedioA(Alu:Alumno):Real;
Begin
PromedioA:=(Alu.Nota.N1+Alu.Nota.N2+Alu.Nota.N3)/3;
End;
Procedure CalcularPromedio(Var Al:ArrAlum);
Procedure Escribir(Var Al:ArrAlum);
Begin
For I:=1 To Max Do
Al[i].Promedio:=PromedioA(Al[i]);
End;
Procedure Escribir(Var Al:ArrAlum);
Begin
For I:=1 To Max Do
Begin
Clrscr;
Writeln('Nombre del Alumno ',i,':',A[i].Nombres);
Writeln('Nota 1:',A[i].Nota.N1);
Writeln('Nota 2:',A[i].Nota.N2);
Writeln('Nota 3:',A[i].Nota.N3);
Writeln('Promedio: ',Al[i].Promedio:4:2);
Writeln;
End;
End;
(*Declaración de la variable Alum del tipo ArrAlum, arreglo de registros)
Var
Alum:ArrAlum;
Begin
Clrscr;
Leer(Alum);
CalcularPromedio(Alum);
Clrscr;
Escribir(Alum);
Readkey
End.
Como todo arreglo el proceso de lectura y escritura es mediante un bucle repetitivo, en este caso hemos usado la sentencia For, y se debe de leer cada uno de los datos, por separado.
Otro aspecto es que el campo Promedio no es ingresado por el usuario, si no que se calcula mediante el procedimiento CalcularPromedio, este procedimiento le pasa como referencia un registro (El registro actual ) a la función PromedioA, el cual con los datos de ese único registro calcula el promedio y lo retorna.
Debemos diferenciar en los parámetros de referencia de las funciones y procedimientos, ya que a los procedimientos se les pasa como parámetros un arreglo de registros (de tipo ArrAlum) mientras que a la Función solo se le pasa un registro (de tipo Alumno).
No hay comentarios:
Publicar un comentario