Una unidad es un conjunto de
constantes, variables, tipos de datos, procedimientos, funciones y objetos que
se compilan independientemente del programa principal. TurboPascal tiene una
serie de unidades estándar entre las cuales destacan :
Crt : Permite ejercer control sobre el teclado y la pantalla.
Dos : Proporciona acceso a las funciones del DOS.
Se usa con GetDate, GetTime, ..., y tiene un procedimiento, Exec, que
permite ejecutar
otros programas.
Para ello:
1.
Hay que establecer $M :tamaño de pila,
liberar memoria para libre.
2.
Almacenar antes los vectores de interrupción
(Swap Vectors) :
{$M 9827,0,0}
Begin
----------- ;
----------- ;
----------- ;
SwapVectors ;
Exec(‘c :\dos\command.com’,’/c
dir’) ;
SwapVectors ;
----------- ;
----------- ;
end.
La instrucción Exec(‘GetEnv(comspec)’, busca el command.com.
Printer : Da acceso a la impresora.
Begin
WriteLn(LST,’Cadena de texto’) ;{ Printer asocia la impresora a
la variable LST}
Para Pascal la impresora es un archivo de texto, y se maneja como tal :
(sin usar
Printer)
Var
impresora :text ;
Begin
Assign(impresora,’LPT1’) ;
Rewrite(impresora) ;
WriteLn(impresora,’cadena de texto’) ;
Close(impresora) ;
End.
Strings :Permite manejar cadenas terminadas en
nulo (arrays con base en 0) :
Type
cadena=array(0..n) of char ;
Estas cadenas terminan con NULL (carácter nulo), lo que tiene la ventaja de no
tener un tamaño tope (sólo el de la gestión DOS). Se manipula por un puntero
llamado PCHAR, y estas cadenas necesitan de la unidad Strings y de la directiva
{$X+}.
Overlays : Proporciona la gestión de
recubrimientos, que consisten en que varios procedimientos
ocupan simultáneamente las mismas posiciones de
memoria, con lo cual los programas pueden ser mayores que la memoria disponible.
Necesitamos la unidad Overlays y las directivas {$F+} (Far Calls) y {$O+}.{$O
nombre procedimientos afectados}
Para inicializar la unidad Overlays :
OVRinit(nombreproced.OVR)
System : No es preciso ponerla ya que se usa
por defecto.
Graph : Proporciona procedimientos y funciones
para manipular gráficos.
Nosotros podemos crear
nuestras propias unidades, que nos servirán para :
·
Crear una librería de
procedimientos y funciones.
·
Dividir un programa.
Las unidades permiten que los
programas superen la barrera de los 64KB (al estar divididos) y permiten que
diversos programas utilicen los mismos módulos/unidades.
Para crear una unidad se
comienza :
Unit Nombre ;
Donde Nombre será el nombre
que emplearemos para grabar la unidad en memoria.
Después comienza la parte de
INTERFACE (parte de declaración de objetos exprtados, es decir, aquellos que
son visibles desde los programas que los van a llamar) que terminará cuando
comience la parte de implementación :
INTERFACE
Cabeceras de constantes, variables,tipos, procedimientos y
funciones.(objetos)
Tras esto empieza la parte de
IMPLEMENTATION (parte de declaración de objetos privados, para uso exclusivo de
la unidad, no se necesita poner la lista de parámetros formales), que terminará
con Begin o con End.
IMPLEMENTATION
Constantes, variables,tipos, procedimientos y funciones.(objetos)
BEGIN
/ END
Con Begin : Sección de
inicialización (optativo). Esta sección se utiliza para inicializar variables
necesitadas por unidades o bien para la apertura de ficheros. Es frecuente que
no la haya. Lo que se encuentra en esta sección se ejecuta antes de cualquier
otra cosa que haya.
Con End : Indica que sólo
son objetos privados.
Unit Ejemplo ;
INTERFACE
Procedure Intercambiar(var x, y :integer) ;
Function Mayor(a, b :integer) ;
IMPLEMENTATION
Procedure Intercambiar;
Var aux :integer ;
Begin
aux :=x ;
x :=y ;
y :=aux ;
end ;
Function Mayor;
Begin
If a>b then
Mayor :=a
Else
Mayor :=b ;
end ;
{Sección de inicialización si la hubiese}
END.
Una unidad puede hacer uso de
otras unidades (en interface o implementation). Al terminar una unidad se
compila primero en memoria y luego en disco.
1.
Primero se guarda como EJEMPLO.PAS
2.
Se compila (para detectar errores)
3.
Se guarda sin errores.
4.
Se compila en disco (si fuera un Programa se
originaría un .EXE, pero al ser una unidad se origina un .TPU).
Para usar esta unidad :
Program xxxxxxxx ;
Uses
Ejemplo ;
Las unidades (archivos con
extensión .TPU) primero se buscan en Tpl ( librería que se carga automáticamente
al llamar a Turbo.tpl) que contiene todas las unidades estándar. Para añadir o
quitar unidades a Tpl empleamos Tpumover.
Después de buscar en
Turbo.tpl, se busca en el subdirectorio actual, y si no lo encuentra, lo busca
en donde le indique la sección directorio (Opciones / Directorios).
Es posible utilizar más de
una unidad en un programa, tanto si son predefinidas como definidas por el
usuario : Uses Crt, Dos, Ejemplo ;
Si hay
procedimientos/funciones con el mismo nombre en distintas unidades, para
identificarlos emplearemos la notación unidad.nombre_procedimiento/función.
Program Amigos ;
Var i, j,m ;
{$I Sumadiv.pas}
Function SonAmigos(i,j :integer) :boolean ;
Begin
SonAmigos :=(SumaDivisores(i)=j)
AND (SumaDivisores(j)=i)
end ;
Function
SumaDivisores(m :integer) :integer ;
Var
i :integer ;
suma :integer ;
Begin
suma :=0 ;
For i :=(m
DIV 2) downto 1 do
If m MOD i = 0 then
Suma :=Suma+i ;
SumaDivisores :=suma ;
end ;
Begin
m :=500 ;
For i :=1
to m-1 do
For j :=i+1 to m do
If SonAmigos(i,j) then WriteLn(i,j)
end.
FASES
EN LA CONSTRUCCIÓN DE PROGRAMAS.
La construcción de un
programa atraviesa las siguientes fases sucesivas :
1. Análisis del programa.
2.
Diseño del algoritmo (siguiendo las reglas de
la programación modular).
3.
Codificación (escribir el programa en un
lenguaje de programación).
4.
Depuración (eliminación de errores).
5.
Pruebas (funcionamiento del programa) e
Integración (por si es muy grande).
6.
Verificación (aplicar pruebas matemáticas para
controlar el mayor número de casos posibles).
7.
Mantenimiento (dotar al programa de documentación
interna y externa).
El uso de Unidades y de
Programación Orientada a Objetos (POO) permite reutilizar el código.
PROGRAMACIÓN ORIENTADA A OBJETOS (POO).
En Pascal, los Objetos son
perecidos a los registros, con la diferencia de que los Objetos además de
incluir datos, incluyen rutinas para la manipulación de dichos datos.
Para trabajar con objetos
deberíamos comenzar diseñando las diversas estructuras entresacando de todas
ellas las características comunes e implementando un tipo objeto genérico del
cual descendieran los demás.
Declaración de objetos :
Type
Nombre=OBJECT
dato1 :tipo1 ;
dato2 :tipo2 ;
procedure procedimiento1 ;
Procedure procedimiento2[(parámetros)] :
end ;
Dentor del tipo, se incluyen
cabeceras de procedimientos y funciones. La implementación de estos
procedimientos y funciones dentro del objeto se efectúa de forma independiente,
y a estos procedimientos y funciones dentro del objeto se les denomina Métodos.
Declaración de métodos :
Procedure
Nombre.procedimiento1 ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;
Procedure
Nombre.procedimiento2[(lista parámetros formales)] ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;
Los datos de un objeto son
siempre accesibles para los métodos a pesar de que estén declarados en lugares
diferentes (de forma independiente) .Ejemplo :
Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
procedure Inicializar(n :string ;de :integer ;d :string) ;
end ;
Procedure
Persona.Inicializar(n :string ;de :integer ;d :string) ;
Begin
nombre :=n ;
edad := ed ;
domicilio :=d ;
End ;
{Para trabajar con objetos,
necesitamos variables de tipo objeto llamadas Instancias del objeto.}
{A los diferentes tipos se
les denomina Clases}
Var
p :Persona ;
n,d :string :
ed :integer ;
BEGIN
WriteLn(‘Nombre :’) ;
ReadLn(n) ;
WriteLn( ‘Edad :’) ;
ReadLn(ed) ;
WriteLn(‘Domicilio :’) ;
ReadLn(d) ;
p.inicializar(n,ed,d) ;
END.
Los objetos pueden heredar
campos y métodos de otros objetos. Cuando esto sucede lo declararemos de la
siguiente manera :
Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
procedure Inicializar(n :string ;de :integer ;d :string) ;
end ;
Alumno=OBJECT
(Persona) { Hereda Persona}
nota :real ;
Procedure Inicializar(n :string ; ed :integer ; d :string ;
no :real) ;
end ;
Procedure
Persona.Inicializar.....
Begin
...............
End ;
Procedure
Alumno.Inicialzar(n :string ; ed :integer ; d :string ;
no :real) ;
Begin
nombre :=n ;
edad :=ed ;
domicilio :=d ;
nota :=no ;
End ;
Var a :Alumno ;
El objeto descendiente hereda
los campos y métodos del objeto padre, y puede tener más campos y métodos
nuevos y también puede redefinirlos.
Todos los métodos vistos
hasta ahora eran ESTÁTICOS (las referencias se resuelven en tiempo de compilación),
pero los métodos también pueden ser VIRTUALES (las referencias se resuelven en
tiempo de ejecución). Cuando el compilador detecta la compilación de un método
virtual, crea una Tabla de Métodos Virtuales. Las instancias (variables)
declaradas de un tipo objeto con métodos virtuales (tipo método virtual),
necesitan inicializarse a través de unCONSTRUCTOR, que enlaza la instancia con
la Tabla de Métodos Virtuales.
Para eliminar la conexión se
emplean DESTRUCTORES (sólo cuando se trabaja con estructuras dinámicas(punteros)),
necesarios siempre que usamos métodos virtuales.
Para que un método sea un
constructor, habrá que sustituir la palabra ‘procedure’ por
‘constructor’.
Para que un método sea un
destructor, habrá que sustituir la palabra ‘procedure’ por
‘destructor’.
Un método es virtual cuando
su cabecera acaba en ‘virtual ;’.
Los métodos virtuales son el
instrumento adecuado para el POLIMORFISMO. Un método es polimórfico cuando se
ejecuta de diferente forma segús el objeto desde el cual se le llame.
CARACTERÍSTICAS DE LA PROGRAMACIÓN ORIENTADA A
OBJETOS.
·
Encapsulación.
·
Herencia.
·
Polimorfismo.
La Encapsulación consiste en
que los objetos agrupan tanto los datos como los procedimientos necesarios para
su manipulación. No se debe acceder a los datos de un objeto directamente, sino
que siempre se debe hacer a través de los métodos correspondientes. (Ejemplo :
En lugar de referenciar area, referenciaríamos figura.area, siendo figura el
objeto).
Cuando trabajamos con
unidades es posible declarar tipos de objeto en dichas unidades. Si se desea que
el usuario de una unidad (que use objetos) no pueda acceder a los campos o a
determinados métodos del objeto, habrá que declararlos como privados, para lo
cual la declaración de objeto se hará en la sección de Interface, pero los métodos
tendrán que ser implementados en la sección de Implementation.Ejemplo :
Unit <Nombre_Unidad> ;
{De 8 caracteres máximo}
INTERFACE
Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
Procedure Inicializar(n :string ; de :integer ; d :string) ;
end ;
Alumno=OBJECT (Persona)
nota :real ;
procedure Inicializar(n :string ; de :integer ; d :string ;no :real) ;
end ;
IMPLEMENTATION
Procedure persona.Inicializar(-------------------) ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;
Procedure alumno.Inicializar(-------------------) ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;
Para declarar las partes
privadas :
1.
Declaramos las partes PUBLICAS : 1º
datos y luego métodos.
2.
Declaramos las partes PRIVADAS poniendo ántes
‘PRIVATE’ :1º datos y luego métodos.
Ejemplo :
Type Persona=OBJECT
domicilio :string ;
{Partes}
procedure Inicializar (--------------------------) ; {Públicas}
PRIVATE
nombre :string ; {Partes}
edad ;integer ; {Privadas}
end ;
En un tipo objeto la
declaración de los métodos debe ir después de los datos (excepto cuandoy
parte privada).
Es posible utilizar punteros
con los objetos de la forma habitual :
Type
puntero=^Persona ;
Persona=OBJECT
------------- ;
------------- ;
end ;
Variable
p :puntero ;
Begin
New(p) ;
p^.Inicializar(‘Pedro’,5,’Goya’) ;
------------------- ;
------------------- ;
------------------- ;
Dispose(p) ;
end ;
Type
figura=OBJECT
nombre :string ;
area :real ;
perimetro :real ;
Constructor Inicializar ;{Para llamar a virtuales}
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
Procedure Visualizar ;
end ;
Rectangulo=OBJECT
(figura)
base :real ;
altura :real ;
{Si se redefine virtual se amntiene la cabecera}
Constructor Inicializar(d,a :real) ;
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
end ;
Circulo=OBJECT (figura)
radio :real ;
Constructor Inicializar(r :real) ;
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
end ;
Constructor figura.Inicializar ;
Begin
WriteLn(‘Indique
la figura :’) ;
ReadLn(nombre) ;
End ;
Procedure figura.CalcularArea ;
Begin
area :=0 ;
End ;
Procedure figura.CalcularPerimetro ;
Begin
perimetro :=0 ;
End ;
Procedure figura.Visualizar ;
Begin
CalcularArea ;
CalcularPerimetro ;
WriteLn(‘La
figura es’,nombre) ;
WriteLn(‘El area es’,area) ;
WriteLn(‘El
perimetro es’,perimetro) ;
end ;
Constructor Rectangulo.Inicializar(b,a :real) ;
Begin
base :=b ;
altura :=a ;
nombre :=’Rectangulo’ ;
End ;
Procedure Rectangulo.CalcularArea ;
Begin
area :=base*altura ;
End ;
Procedure Rectangulo.CalcularPerimetro ;
Begin
perimetro:=2*(base+altura) ;
End ;
Constructor Circulo.Inicializar(r:real) ;
Begin
radio :=r ;
nombre :=’Circulo’ ;
End ;
Procedure Circulo.CalcularArea ;
Begin
area :=3.141592*radio*radio;
End ;
Procedure Circulo.CalcularPerimetro ;
Begin
perimetro:=2*3.141592*radio;
End ;
Var
f :figura ;
c :Circulo ;
rec :Rectangulo ;
a,b :real ;
r :real ;
Begin
WriteLn(‘Deme
Radio’) ;
ReadLn(r) ;
c.Inicializar(r) ;
c.Visualizar ;
{Es polimórfico:se comporta de una manera o de otra según desde donde se le
llame
Sin virtual, nos pasa en Visualizar 0,0 (lo que había en compilación).Con
virtual pasa lo que hay en
ejecución).}
WriteLn(‘Deme
Base y Altura :’) ;
ReadLn(b,a) ;
rec.Inicializar(r) ;
rec.visualizar ;
Con punteros :
Type
rt=^Rectangulo ;
cr=^Circulo ;
Var
c :cr ;
rec :rt ;
a,b,r :real ;
Begin
WriteLn....... ;
ReadLn(r) ;
New(c) ;
c^.Inicializar(r) ;
c^.Visualizar ;
WriteLn........ ;
New(rec) ;
rec^.Inicializar(b,a) ;
rec^.Visualizar ;