PASCAL
Tipos
de datos definidos por el usuario :
·
de tipo
simple :
·
Subrango
·
Enumerados
·
de tipo
estructurado :
·
Conjunto
Se
define a partir de un ordinal estableciendo unos límites inferior y superior
para el tipo subrango.
Declaración :
Type
Subrango =liminf...limsup ;
Var
s :Subrango ;
Las
variables de un tipo subrango admiten las mismas operaciones que el ordinal del
cual proceden. También resulta posible asignar a una variable de tipo subrango
otra que ha sido declarada como perteneciente al tipo ordinal del cual se deriva
el subrango. Los subrangos se utilizan para dar una mayor legibilidad a los
programas.
Type
Meses = 1..12 ;
Var
m :meses ;
i :byte ;
Begin
Repeat
Readln(i) ;
Until (i >= 1) AND (i <=12) ;
m :=i ;
Estas
variables se emplean también en un array con salario de 12 meses del año :
Type
Meses = 1..12 ;
Arr =Array [meses] of real ;
Los
subrangos pueden ser también :
Type
Mayusculas = A..Z ;{de tipo char (ordinal)}
Han
de ser de tipo ordinal. Son aquellos en los que el programador establece los
valores que van a poder tomar las variables al declarar el tipo mediante la
especificación de una lista de identificadores válidos.
Los
identificadores han de comenzar en carácter, y no se pueden repetir en la
enumeración de tipos.
Declaración :
Type
Enumerado = (id1, id2, id3, ... ,idn) ;
{0
1 2
... n}
Var
e :Enumerado ;
Esta
variable sólo podrá recibir la lista de identificadores :
Begin
e :=id4 ; {por ejemplo}
Los
tipos enumerados se utilizan para una mayor legibilidad y para limitar el número
de valores que va a poder tomar una determinada variable.
No
es posible leer directamente valores de tipo enumerado ni desde teclado, ni
desde un archivo de texto. Tampoco se pueden escribir en pantalla ni en archivos
de texto (secuenciales) variables de este tipo. Solamente se pueden utilizar
para manipulación interna de datos.
Operaciones
que admite :
·
de relacción
(>,<,<>,>=,<=,=...)
·
de
asignación
·
Ord (e) ;
·
Pred (e) ;
·
Succ (e) ;
El
valor ordinal de un dato de este tipo se corresponde con la posición del
identificador en la declaración del tipo, y el 1º tiene valor ordinal 0 :
Writeln Ord(e)) ; {e :=id4} à
{Solución = 3}
Las
funciones Pred y Succ quedan indefinidas cuando se trata del 1º o último
identificador de la lista.
Las
variables de tipo enumerado pueden ser variables de control en bucles FOR o
usarse de selectores en un CASE.
Ejemplo :
Definir tipo enumerado.
Type
Marcas = (seat, fiat, renault, citroen) ;
Var
m : Marcas ;
Begin
For m =seat to citroen do
<acciones >;
Para
transformar For en While :
m :=seat ;
While
m <citroen do
Begin
<acciones> ;
If m<>citroen then
m :=Succ(m) ;
<acciones> ;
End ;
En
estructuras selectivas :
Case
m of
seat : acc1 ;
fiat :acc2 ;
renault :acc3 ;
citroen :acc4 ;
End ;
Las
variables de tipo enumerado se emplean en Registros Variantes, que se utilizan
para ahorrar espacio tanto en la memoria del
ordenador (arrays) como en disco (ficheros).
Los
Registros Variantes constan de una parte fija que en ocasiones es posible que no
la tengan. Si la tienen, ha de ser lo primero que aparezca en la declaración
del tipo. A continuación tienen siempre un campo selector y por úlltimo
aparece la parte variante.
Ejemplo :
Array de empleados
tipo por horas
B
A
nombre
nombre
nombre
categoría
categoría
categoría
nº
horas
salario base
salario base
ptas/hora
nº horas extra
tlfo casa
complementos tlfo móvil
tlfo móvil
Necesitaríamos
lo siguiente :
nombre
salario base nº
horas
Categoría ptas/hora
nº horas extra
tlfo casa complementos
tlfo móvil
Sin embargo, perdemos espacio porque no se rellenan todos los campos.
Registros
Variantes (se toma el que más ocupa) (sería el 3º, pero tomamos el 2º)
Parte
fija à
nombre
campo selector à
categoría
(tipo
enumerado)
Se
utilizan para transformar datos de un tipo a otro.
Type
c.selector = (porhoras,B,A) ;
Type
categoria=(porhoras,B,A) ;{tipo enumerado}
Reg = RECORD
nombre : String [40] ;
Case categoria :cargo of {no son anidados}
por horas : (numh :byte ;ph :integer) ;
B :(salariobase :real ;hextr :byte ;complementos :real ;tlfnomovil :string) ;
A : (salariobaseA :real ;tlfno :
string[12] ;tlfnomov :string[12]) ;
End ;
End ;
{para
dejar un sólo valor vacío }
{
c : ( ) ;
}
{ arr=array[1..100]of reg ; }
Var
a :arr ;
i :integer ;
resp :string ;
Begin {leer info. de empleados}
For
i :=1 to 100 do
Begin
Readln(a[i].nombre) ;
Writeln(‘Deme categoría (porhoras, A,B)’) ;
Readln(resp) ;
If resp = ‘porhoras’ then
Begin
a[i].categoria :=porhoras ;
Readln(a[i].numh) ;
Readn(a[i].ph) ;
End ;
Else
If
resp=’categoria A’ then
Begin
a[i].categoria :=A ; {tipo enumerado}
Readln(a[i].salariobaseA) ;
Readln(a[i].........etc.......
. .
.
End ;
Else
If resp=’Clase B’ then
Begin
a[i].categoria := B ;
Readln(a.[i].salariobase) ;
. .
.
End ;
End ;
End ;
End ;
For i :=1
to 100 do {presenta datos}
Begin
Writeln(a[i].nombre) ;
Case a[i].categoria of {es un enumerado}
porhoras :Begin
Writeln(a[i].numh) ;
Writeln(a[i].ph) ;
End ;
B : Begin
Writeln(a[i].salariobase) ;
Writeln(a[i]. .........etc.........
. .
.
End ;
A : Begin
Writeln(a[i].salariobaseA) ;
Writeln(a[i]. .........etc.........
. .
.
End ;
End ;
End ;
End.
Para
ordenarlo se hace como siempre, se intercambian registros completos.