PDF de programación - Programación 2º cuatrimestre (Pascal/TurboPascal)

Joaquín Béjar García

Programación 2º cuatrimestre (Pascal/TurboPascal)

Tipos de datos definidos por el usuario :

• de tipo simple :

• Subrango
• Enumerados
• de tipo estructurado :

• Conjunto

Readln(i) ;

Subrango =liminf...limsup ;

s :Subrango ;

Meses = 1..12 ;

m :meses ;
i :byte ;

Type

Var


Begin



Repeat

Until (i >= 1) AND (i <=12) ;
m :=i ;


SUBRANGO.
Se define a partir de un ordinal estableciendo unos límites inferior y superior para el tipo subrango.
Declaración :
Type



Var



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.



Estas variables se emplean también en un array con salario de 12 meses del año :



Los subrangos pueden ser también :



ENUMERADOS.

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



Var



Esta variable sólo podrá recibir la lista de identificadores :

Enumerado = (id1, id2, id3, ... ,idn) ;


{0 1 2 ... n}

Meses = 1..12 ;
Arr =Array [meses] of real ;

Mayusculas = A..Z ;{de tipo char (ordinal)}

Type



Type


e :Enumerado ;



1



Begin


Joaquín Béjar García



e :=id4 ; {por ejemplo}

Programación 2º cuatrimestre (Pascal/TurboPascal)



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) ;

Marcas = (seat, fiat, renault, citroen) ;

m : Marcas ;

Type

Var

Begin



For m =seat to citroen do


<acciones >;

Writeln Ord(e)) ; {e :=id4} {Solución = 3}

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 :

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.



Para transformar For en While :



En estructuras selectivas :



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).


m :=seat ;
While m <citroen do
Begin



End ;

<acciones> ;
If m<>citroen then

<acciones> ;

Case m of



End ;

seat : acc1 ;
fiat :acc2 ;
renault :acc3 ;
citroen :acc4 ;

m :=Succ(m) ;



2



Joaquín Béjar García



B
nombre
categoría
salario base
nº horas extra
tlfo móvil

tipo por horas
nombre
categoría
nº horas
ptas/hora
complementos

Programación 2º cuatrimestre (Pascal/TurboPascal)

REGISTROS VARIANTES.

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



Necesitaríamos lo siguiente :
salario base
nombre
ptas/hora
categoría
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.



A
nombre
categoría
salario base
tlfo casa
tlfo móvil

nº horas
nº horas extra

c.selector = (porhoras,B,A) ;

Type

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 ;

}

c : ( ) ;


End ;



{para dejar un sólo valor vacío }
{
{ arr=array[1..100]of reg ; }



Var



Begin {leer info. de empleados}



For i :=1 to 100 do
Begin

a :arr ;
i :integer ;
resp :string ;



3





Joaquín Béjar García

Programación 2º cuatrimestre (Pascal/TurboPascal)



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) ;



a[i].categoria :=A ; {tipo enumerado}
Readln(a[i].salariobaseA) ;
Readln(a[i].........etc.......


. . .

If resp=’Clase B’ then
Begin



End ;

a[i].categoria := B ;
Readln(a.[i].salariobase) ;
. . .

End ;
Else



End ;

If resp=’categoria A’ then
Begin



End ;
Else



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.



4





Joaquín Béjar García

Type

Var


Conjunto = SET of tipobase ;

c :conjunto ;

Programación 2º cuatrimestre (Pascal/TurboPascal)


Para ordenarlo se hace como siempre, se intercambian registros completos.

CONJUNTO.

Es un tipo de dato estructurado en el que las variables pueden almacenar varios valores de un tipo simple, al cual
se le denomina tipo base. La declaración de un tipo conjunto se hace :



El tipo base ha de ser un ordinal. Los valores ordinales de los elementos han de estar entre 0..255.

Las siguientes declaraciones son ilegales :



Las siguientes declaraciones son legales :



Aunque para facilitar la legibilidad se suele escribir :

Letras =’A’.. ‘Z’ ;


Conjunto = SET of Letras ;
Ejemplo : Conjunto de letras de una frase :

Conjunto = SET of integer ;
Conjunto = SET of 1997..2000 ;

Conjunto = SET of char ;
Conjunto =SET of ‘A’..’Z’ ;

Type



For i :=1 to Lenght(frase) do {para coger carácter a carácter no puedo Copy(frase,i,1) }

frase[i] ;



{porque da una subcadena, y no puede entrar en un conjunto}


Podemos simular conjuntos mediante arrays de booleanos :

ConjuntoArr = ARRAY [1..6] of boolean ; { aprox. como Conjunto = SET of 1..6 ;}

Para introducir un elemento :



En los conjuntos, no puede haber repeticiones en los elementos (solo habrá un elemento de cada).



ConjuntoArr[5] :=True ; {se mete el elemento 5 en el conjunto}

Type

Letras=’A’..’Z’ ;
Conjunto=SET of Letras ;
Arr= ARRAY[‘A’..’Z’] of boolean ;

c :conjunto ;
a :arr ;
i :integer ;



Var



5





Joaquín Béjar García

c :=[ ] ; { se asigna conjunto vacío, es obligatorio}
Readln (car) ;
c :=c+[car] ; {elemento c UNION conjunto car}{[car] = conjunto del contenido de car}

car :char ;

Programación 2º cuatrimestre (Pascal/TurboPascal)



Begin

{usando conjuntos}



{usando arrays}



Para ver si un elemento está en un conjunto :


{usando conjuntos}
For car :=’A’.. ‘Z’ do

If car IN c then



Writeln(car) ;



a[car] :=False ; {inicialización del conjunto}

For car :=’A’.. ‘Z’ do ;

Readln[car] ;
a[car] :=True ; {introducido elemento en conjunto}

{comprueba que esté en el conjunto}

{usando arrays}
For car :=’A’.. ‘Z’ do



Writeln(car) ;

If a[car] then {comprueba que esté en el conjunto}



Operaciones de conjuntos :
• Definición de tipos :


• Declaración de variables :


también es posible la forma : c : SET of ‘A’..’Z’ ;
el paso por variable, se necesita haber declarado el tipo, ya que :



Procedure Ejemplo(variable p1 :SET of ‘A’..’Z’) ;

c :Conj ;

Type


Var


Conj=SET of tipobase ; {tipobase=simple y ordinal con valores ordinales entre 0..255}

pero tiene poca utilidad, y en programación modular, para

car :char ;{tipobase}
c :Conj ;


no es válido, produciéndose un error de concordancia
Hay que declarar también :



Para dar valores a variables de tipo conjunto (que no pueden ser leidos desde teclado o escritos por pantalla),
debemos hacerlo elemento a elemento, para lo que usamos la variable tipobase.


Var


Begin
{hay que INICIALIZAR siempre}
c :=[ ] ;{inicializamos a conjunto vacío} o c :=[‘A’..’Z’] ;{inici