BotonMenu
BotonIndice

Visita : http://www.conoce3000.com
Paypal : https://www.paypal.me/conoce3000/1

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL


5. TIPOS DE DATOS ESTRUCTURADOS, CONSTANTES, VARIABLES CON VALOR INICIAL O POR DEFECTO.
5.4. REGISTROS.
5. TIPOS DE DATOS ESTRUCTURADOS, CONSTANTES, VARIABLES CON VALOR INICIAL O POR DEFECTO.
5.4. REGISTROS.
5. TIPOS DE DATOS ESTRUCTURADOS, CONSTANTES, VARIABLES CON VALOR INICIAL O POR DEFECTO.
5.4. REGISTROS.

SIGUIENTE

SIGUIENTE

SIGUIENTE


‒ Registros.

Al igual que un arreglo, los registros son un conjunto de espacios o bloques de memoria, pero los registros permiten bloques de memoria de tipos de datos diferentes, a los bloques o espacios de memoria de los registros se les conoce como campos, cada campo debe tener su propio identificador. El campo de un registro puede ser un tipo de dato simple o cualquier tipo de dato estructurado.

Un registro se usa para representar un conjunto heterogéneo de datos. En donde cada dato es relacionado con una entidad física o abstracta, como por ejemplo: Un empleado y los datos registrados en planilla; una fecha con sus atributos mes, día y año; un producto con sus datos de registro en almacén, etc.

Un registro se puede declarar como un nuevo tipo de dato o una variable, para tal efecto se hace uso de las palabras reservadas record y end, se debe tener presente que cuando se declara el registro como un tipo de dato se debe usar el signo igual (=) después del identificador, y cuando se declara como una variable se debe usar los dos puntos (:).

A continuación un programa de ejemplo que permite declarar un registro Alumno como una variable, hace la lectura desde el teclado para cada campo y después lo muestra por pantalla:


Descargar
{$codepage UTF8}

VAR  Alumno : Record
                Nombre:String;
                Edad : byte;
                Sexo : Char;
              End;

BEGIN
  Writeln('Lectura de un registro');
  Writeln('Nombre : ');Readln(Alumno.Nombre);
  Writeln('Edad : ');Readln(Alumno.Edad);
  Writeln('Sexo : ');Readln(Alumno.Sexo);
  Writeln('Muestra registro por pantalla');
  Writeln('Nombre : ',Alumno.Nombre);
  Writeln('Edad : ',Alumno.Edad);
  Writeln('Sexo : ',Alumno.Sexo);
END.
Código fuente 16: Declaración de un registro como una variable.
Descargar

En el ejemplo anterior, se hace uso del punto para acceder a un determinado campo del registro Alumno. Si por ejemplo se quisiera asignar al campo Edad del registro Alumno el valor 20 se tendría que hacer del siguiente modo:

Alumno.Edad:=20;

El programa anterior explica como acceder a un campo del registro, el siguiente programa permite crear un arreglo de 10 alumnos, en donde el registro alumno se declara como un tipo de dato para usarlo en el arreglo.


Descargar
{$codepage UTF8}

TYPE TAlumno = Record
                Nombre:String;
                Edad  : byte;
                Sexo  : Char;
               End;

VAR   alumnos:array [1..10] of  TAlumno;
      i,j : byte;
      aux : TAlumno;

BEGIN      
   for i:=1 to 10 do
    Begin
      Writeln('Registro [',i,']');
      Write('   Nombre : ');Readln(alumnos[i].Nombre);
      Write('   Edad    : ');Readln(alumnos[i].Edad);
      Write('   Sexo : ');Readln(alumnos[i].Sexo);
    End;
     For i:=2 to 10 do
       Begin
         aux:=alumnos[i];
         j:=i-1;
         While ( (j>=1) and (alumnos[j].Nombre>aux.Nombre) ) do
            Begin
              alumnos[j+1]:= alumnos[j];
              j := j - 1;
            End;
         alumnos[j+1]:=aux;
       End;
    Writeln;
    for i:= 1 to 10 do
      Writeln(alumnos[i].Nombre:10,alumnos[i].Edad:10,alumnos[i].Sexo:10);
END.
Código fuente 17: Declaración de un registro como un tipo de dato para usarlo en un arreglo.
Descargar

El programa declara una lista de alumnos, en donde todos los bloques de memoria o elementos de la lista son del tipo de dato TAlumno. Como el arreglo tiene como tipo de dato a TAlumno, entonces para acceder al nombre del registro 5 de la lista de alumnos se hace del siguiente modo:

alumnos[5].Nombre

y para acceder a todos los elementos o bloques de memoria del arreglo hacemos uso del bucle for tal como se vio en el programa anterior. El programa anterior usa el método de inserción para ordenar la lista de alumnos, pero con la diferencia de comparar el campo Nombre y no los registros dentro del bucle While.

La palabra reservada with nos permite crear bloques de instrucciones para acceder a un campo de un determinado registro sin usar el punto, por ejemplo la siguiente instrucción del programa anterior:

   Write(' Nombre : ');Readln(alumnos[i].Nombre);
   Write(' Edad : ');Readln(alumnos[i].Edad);
   Write(' Sexo : ');Readln(alumnos[i].Sexo);

se puede reemplazar con el siguiente código:

With alumnos[i] do
Begin
   Write(' Nombre : ');Readln(Nombre);
   Write(' Edad : ');Readln(Edad);
   Write(' Sexo : ');Readln(Sexo);
End;

A continuación el programa completo usando with:


Descargar
{$codepage UTF8}

TYPE TAlumno = Record
                Nombre:String;
                Edad  : byte;
                Sexo  : Char;
               End;

VAR   alumnos:array [1..10] of  TAlumno;
      i,j : byte;
      aux : TAlumno;

BEGIN      
   for i:=1 to 10 do
    Begin
      Writeln('Registro [',i,']');
      With alumnos[i] do
        Begin
          Write('   Nombre : ');Readln(Nombre);
          Write('   Edad    : ');Readln(Edad);
          Write('   Sexo : ');Readln(Sexo)
        End   
    End;
     For i:=2 to 10 do
       Begin
         aux:=alumnos[i];
         j:=i-1;
         While ( (j>=1) and (alumnos[j].Nombre>aux.Nombre) ) do
            Begin
              alumnos[j+1]:= alumnos[j];
              j := j - 1;
            End;
         alumnos[j+1]:=aux;
       End;
    Writeln;
    for i:= 1 to 10 do
      Writeln(alumnos[i].Nombre:10,alumnos[i].Edad:10,alumnos[i].Sexo:10);
END.
Código fuente 18: Uso del operador With.
Descargar

El campo de un registro como mencione anteriormente, puede ser un tipo de dato simple o un tipo de dato estructurado, esto nos dice que el campo de un registro puede ser otro registro, a esto se les conoce como registros encadenados o concatenados.

Continuando con el ejemplo, ampliaremos el registro TAlumno adicionando un nuevo campo Direccion, que sera un registro con los campos: Calle, Numero, CodPostal. A continuación el programa:


Descargar
{$codepage UTF8}

TYPE TDireccion = Record
                     Calle : String;
                     Numero : integer;
                     CodPostal : String;
                   End;
  TAlumno = Record
              Nombre:String;
              Edad  : byte;
              Sexo  : Char;
              Direccion : TDireccion;
            End; 

VAR alumnos:array [1..10] of  TAlumno;
     i,j    : byte;
     aux    : TAlumno;

BEGIN
  for i:=1 to 10 do
   Begin
     Writeln('Registro [',i,']');
     With alumnos[i] do
       Begin
        Write('   Nombre : ');Readln(Nombre);
        Write('   Edad    : ');Readln(Edad);
        Write('   Sexo : ');Readln(Sexo);
        Writeln('   Direccion :');
        With Direccion do
          Begin
            Write('     Calle : ');Readln(Calle);
            Write('     Numero : ');Readln(Numero);
            Write('     Codigo Postal : ');Readln(CodPostal)
          End
       End
     End;
     For i:=2 to 10 do
      Begin
        aux:=alumnos[i];
        j:=i-1;
        While ( (j>=1) and (alumnos[j].Nombre>aux.Nombre) ) do
           Begin
             alumnos[j+1]:= alumnos[j];
             j := j - 1;
           End;
        alumnos[j+1]:=aux;
      End;
  Writeln;
  for i:= 1 to 10 do
    With alumnos[i] do
      Write(Nombre:10,Edad:10,Sexo:10,Direccion.Calle:10,
            Direccion.Numero:10,Direccion.CodPostal:10);
END.
Código fuente 19: Ejemplo con un registro encadenado.
Descargar

El programa usa otra instrucción with para el campo Direccion, cada bloque de instrucciones with si contiene más de una instrucción se debe encerrar dentro de un begin y end.

Muchas veces los datos que están relacionados con una entidad física o abstracta, no son tan uniformes como para poderlos colocar a todos dentro de un mismo registro. Por ejemplo, suponiendo que en una tienda se tenga que registrar los espejos que se venden y en donde las dimensiones varían por la forma del espejo, que pueden ser rectangular o circular, entonces se debe crear un registro que tenga un campo, en el que se pueda almacenar el ancho y alto, en caso el espejo sea rectangular o el diámetro en caso el espejo sea circular, en estos casos es necesario el uso de un registro variante.

Un registro variante permite colocar diferentes campos del registro en un mismo bloque de memoria, a este bloque de memoria se le conoce como parte variante del registro y siempre se debe colocar al final de un registro. Para declarar el registro variante de los espejos lo hacemos del siguiente modo:

Type TTipoEspejo=(Rectangular,Circular);
   TEspejos = Record
         Fabricante : string;
         Precio : Real;
         case TipoEspejo: TTipoEspejo of
               Rectangular : ( ancho:integer;alto:integer);
               Circular : ( diametro :integer);
         End;

En esta declaración se ha creado un tipo de dato enumerado TTipoEspejo, que nos sirve para crear el campo de selección TipoEspejo, también se pudo utilizar un tipo de dato byte en vez de TTipoEspejo, pero se estarían usando valores numéricos como 0 y 1, en vez de Rectangular y Circular. Como se puede observar se esta usando la palabra reservada Case, para indicarle al compilador que se usará el campo TipoEspejo como un campo de selección y de esa manera saber como se interpretará los campos ancho, alto y diámetro según sea el caso Circular o Rectangular. En un registro variante sólo se puede declarar un campo de selección al final del registro. Como este campo de selección tiene sólo dos posibles valores, cuando TipoEspejo sea Rectangular el registro contendrá los campos ancho y alto, y en el caso que sea Circular contendrá el campo diametro. También se debe tener en cuenta que los campos se declaran encerrándolos entre paréntesis, observe que después del campo alto, no es necesario colocar el punto y coma. Los campos ancho y alto se pudieron haber escrito del siguiente modo:

Rectangular : ( ancho,alto :integer);

En un registro variante un campo de selección sólo puede ser de un tipo de dato: entero ( excepto int64 y qword), un tipo de dato booleano, enumerado on un caracter de tipo char. A continuación el programa de ejemplo:


Descargar
{$codepage UTF8}

TYPE
  TTipoEspejo=(Rectangular,Circular);
  TEspejos = Record
               Fabricante : string;
               Precio : Real;  
               case TipoEspejo: TTipoEspejo of
                      Rectangular :  ( ancho,alto:integer);
                      Circular : ( diametro :integer);
             End;

VAR  Espejos:array [1..10] of  TEspejos;  
     i,j      : byte;
     aux : TEspejos;
     TE:char;

BEGIN
  for i:=1 to 10 do
    Begin  
      Writeln('Registro [',i,']');
      With Espejos[i] do
        Begin
          Write('   Fabricante : ');Readln(Fabricante);
          Write('   Precio    : ');Readln(Precio);
          Write('   Tipo de Espejo [C]ircular [R]ectangular  :');readln(TE);
            Case  TE of
               'R','r' : Begin
                           TipoEspejo:=Rectangular;
                           Write('      Ancho : ');readln(ancho);
                           Write('      Alto : ');readln(alto)  
                         End;  
               'C','c' : Begin
                           TipoEspejo:=Circular;
                           Write('      Diametro :  ');readln(diametro)
                         End;  
            End;  
        End  

    End; 



 For i:=2 to 10 do  

    Begin
      aux:=Espejos[i];
      j:=i-1;

      While ( (j>=1) and (Espejos[j].Precio>aux.Precio) ) do  

        Begin

          Espejos[j+1]:= Espejos[j];  

          j := j - 1;  

        End;

      Espejos[j+1]:=aux;  

    End;

 Writeln;  
 for i:= 1 to 10 do
   With Espejos[i] do
     Begin
       Write(Fabricante:10,Precio:10:2);
       Case TipoEspejo of
          Rectangular :  Write('Rectangular':15,ancho:10,'x',alto);
          Circular    : Write('Circular':15,diametro:10);
       End;

       Writeln;
     End
END.
Código fuente 20: Ejemplo de un registro variante.
Descargar

El programa lo que hace es pedir una lista de productos que son los espejos, para almacenarlos en el arreglo Espejos, para la lectura de los campos TipoEspejo, ancho, alto y diametro, se hace uso de una variable TE de tipo char, porque los tipos enumerados no se pueden usar directamente con rutinas read y readln. El programa luego Ordena la lista por el precio, para después mostrarlo por pantalla.

Los registros variantes también se pueden escribir sin campo de selección, los campos de selección sólo sirven para saber por parte del programador que es lo que se ha grabado en la parte variante del registro. El registro TEspejos también se pudo haber escrito del siguiente modo:

TEspejos = Record
         Fabricante : string;
         Precio : Real;
         TipoEspejo : TTipoEspejo;
              case TTipoEspejo of
                    Rectangular : ( ancho,alto:integer);
                    Circular : ( diametro :integer);
              End;

El tamaño en bytes de un registro debería ser la suma de los tamaños de sus campos, pero no es muy fácil determinarlo manualmente debido al proceso de alineación interna de los datos o los campos de un registro que realiza el compilador, dependiendo del microprocesador que se esté usando. La alineación se hace con el objetivo de mejorar el rendimiento de los programas en cuanto a velocidad, ya que los microprocesadores modernos mueven los datos de la memoria en bloques de 2, 4, 8, 16 y 32 bytes, de acuerdo a ciertas reglas de alineación de los datos, para saber el tamaño de un registro se recomienda usar la función SizeOf, del siguiente modo:

Writeln(sizeOf(Reg02));

Un registro variante también puede servir para obtener el ordinal de un tipo de dato char, recordemos que los campos de un registro variante ocupan el mismo bloque de memoria, y por ende este bloque de memoria puede ser interpretado por el compilador de dos modos diferentes, El ejemplo siguiente ilustra este caso.


Descargar
{$codepage UTF8}

VAR 

 Registro01 : Record
 Case Boolean of
      True : (N:byte);
      False :(C:char)
 End;

BEGIN
 Registro01.C:='A';
 Writeln(Registro01.N)
END.
Figura 21 : Usando un registro variante para obtener el ordinar de un tipo de dato char.
Descargar

y para terminar este capítulo los registros variantes también se pueden encadenar




SIGUIENTE
SIGUIENTE
SIGUIENTE


 
‒ Comentarios y sugerencias.

Agradezco de antemano, todo comentario, sugerencia, y donativo (a través de Paypal me), que ayude a mejorar los contenidos educativos de Conoce 3000. Además, cualquier pregunta o duda que tengas lo puedes hacer por este medio. Pero, todo contenido que pueda resultar ofensivo, malicioso, racista, sexista, discriminatorio, obsceno, vulgar será eliminado.








PORTADA |  INTERESANTE |  APUNTES |  LIBROS |  GALERIA


Creative Commons License


Todos los textos, imágenes y videos de Conoce3000 estan colocados bajo una licencia : Creative Commons Reconocimiento-NoComercial 3.0 Unported License.