15/10/2015

HolaMundo.pascal(online):Captulo9

Ms Siguienteblog

Crearblog Acceder

Publicaciones del Autor

.pas

.c

.java

2 4 DE AG O STO DE 2 0 0 7

Captulo 9
.
Encapsulamiento de Estrucuras
Las clases permiten encapsular la implementacin de la funcionalidad de los objetos. El
usuario (programa que utitiliza los objetos) no necesita conocer como est programado el
objeto que est utilizando. Solo necesita conocer su interface. Es decir: los mtodos
(procedimientos y funciones) definidos en la parte pblica de la clase.
Para probar esto desarrollaremos la clase Pila. Primero implementaremos la pila en un array.
Luego programaremos otra versin que implemente la pila sobre una lista enlazada.
Al programa principal no le debe interesar como est programada (por dentro) la pila. Si
funciona bien entonces la usa y punto.
>> Click para Ms Informacin <<
uPila.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
39:
38:

Recursos / Download
unituPila;
interface
const
MAX_PILA=100;
type
Pila=class
private
arr:array[1..100]ofinteger;
len:integer;
public
constructorcreate();
procedureponer(v:integer);
functionsacar():integer;
end;
implementation
constructorPila.create();
begin
len:=0;
end;
procedurePila.poner(v:integer);
begin
len:=len+1;
arr[len]:=v;
end;
functionPila.sacar():integer;
begin
sacar:=arr[len];
len:=len1;
end;
end.

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

SZDelphi (por JDownloader)

Instalacin y uso de Delphi
Plantilla de Diagramas p/Visio
Contenidos

1 Introduccin
2 Operadores
3 Procedimientos y Funciones
4 Corte de Control
5 Arrays
6 Archivos de Registros
7 Estructuras Dinmicas
8 Arboles y Recursividad
9 Teora de Objetos (intro)
EjemplosResueltos
Ahora en Video!

1/7

15/10/2015

HolaMundo.pascal(online):Captulo9

Si analizamos la seccin public vemos que la clase Pila tiene un constructor y dos mtodos:
poner y sacar.
Las variables de instancia son arr (el array sobre el que implementamos la pila) y len (la
variable que indica la cantidad de elementos que se encuentran apilados).
La variable len debe comenzar en cero (ya que al inicio la pila no tiene elementos). Esta
asignacin la hacemos en el constructor.
Luego, analizando la seccin implementation vemos la implementacin de los mtodos poner
y sacar.
En la implemencin de poner primero incrementamos len y luego asignamos en arr[len] el
elemento v que vamos a meter en la pila. En la implementacin de sacar primero asignamos el
elemento arr[len] como valor de retorno de la funcin y luego decrementamos len.

Acerca del Autor

Ing. Pablo A. Sznajdleder
Agradecimientos

Ahora veamos un programa que pruebe la clase Pila.

testPila.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

No al blog de Java
usesuPila_lista;
varp:Pila;
begin
p:=Pila.create();
p.poner(1);
p.poner(2);
p.poner(3);

Super Baterista

writeln(p.sacar());
writeln(p.sacar());
writeln(p.sacar());
end.

Vemos que el programa principal simplemente crea una instancia de Pila y la utiliza. En el
programa no nos "preocupamos" por manejar el len ni el array. Simplemente trabajamos con la
pila.
Ahora analizaremos otra versin de la clase Pila, la cual implementaremos sobre una lista
enlazada.

Sitios Relacionados
PascAlgo (por Lic. Hugo Cuello)
Algoritmia.net
Java Algorithm Framework

Para esto primero vamos a definir un registro Nodo y un tipo PNodo como ^Nodo. Los
definiremos un una unit (untNodo.pas) separada porque los vamos a volver a utilizar ms
adelante, cuando analicemos la clase ListaOrdenada.
untNodo.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

unituntNodo;
interface
type
PNodo=^Nodo;
Nodo=record
info:integer;
sig:PNodo;
end;
implementation
end.

Veamos la clase Pila implementada con una lista enlazada.

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

2/7

15/10/2015

HolaMundo.pascal(online):Captulo9

uPila.pas (implementada en una lista enlazada)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

unituPila;
interface
usesuntNodo;
type
Pila=class
private
p:PNodo;
public
constructorcreate();
procedureponer(v:integer);
functionsacar():integer;
end;
implementation
constructorPila.create();
begin
end;
procedurePila.poner(v:integer);
varnuevo:PNodo;
begin
new(nuevo);
nuevo^.info:=v;
nuevo^.sig:=p;
p:=nuevo;
end;
functionPila.sacar():integer;
varaux:PNodo;
begin
sacar:=p^.info;
aux:=p;
p:=p^.sig;
dispose(aux);
end;
end.

Como podemos ver, la parte pblica es exactamente igual. No cambi respecto de la

implementacin anterior. Es decir que la interface de los objetos tipo Pila sigue siendo la
misma por lo tanto este cambio no afecta a los programa que los utilicen..
Obviamente la implementacin es totalmente diferente. A nivel variables de instancia ya no
estn ni arr ni len. En su lugar est el puntero p de tipo PNodo. Luego la implementacin de
los mtodos poner y sacar es la misma que estudiamos en el captulo 7.

Clase ListaOrdenada
Para terminar, analizaremos una clase que implementa una lista sobre la cual se podrn
insertar valores ordenados en forma ascendente, con y sin repeticin.

Veamos la interface de la unit uListaOrdenada.pas.

uListaOrdenada.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

unituListaOrdenada;
interface
usesuntNodo;
type
ListaOrdenada=class
private
lst:PNodo;
actual:PNodo;

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

3/7

15/10/2015

HolaMundo.pascal(online):Captulo9
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

public
constructorcreate();
//buscaelvalorvretorna
//true=>esta,false=>noesta
functionbuscar(v:integer):boolean;
//inserta(ordenado)unvalor
functioninsertar(v:integer
;okRep:boolean):boolean;
//liberalosnodosdelalista
procedureliberar();
//asignaelsiguientevalordelalista
//enlavariablevyretornatrueofalse
//siexisteonounproximovalor
functionsiguiente(varv:integer):boolean;
end;
//:
//masabajoestalaseccionimplementation
//:

Ahora analizaremos la implementacin de cada uno de los mtodos definidos en la interface.

uListaOrdenada.pas (implementacin: function buscar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

implementation
functionListaOrdenada.buscar(v:integer):boolean;
varaux:PNodo;
begin
aux:=lst;
while((aux<>NIL)AND(aux^.info<>v))dobegin
aux:=aux^.sig;
end;
if(aux<>NIL)thenbegin
buscar:=true;
endelsebegin
buscar:=false;
end;
end;

La implementacin del mtodo buscar es exactamente igual a la que estudiamos en el captulo

7. La nica diferencia es que como el puntero al inicio de la lista (lst) es una variable de
instancia no es necesario recibirla como parmetro.
El puntero lst (y actual para la implementacin de siguiente) se inicializan en NIL en el
constructor.

uListaOrdenada.pas (implementacin: constructor create)

18:
19:
20:
21:
22:
23:
24:

constructorListaOrdenada.create();
begin
lst:=NIL;
actual:=NIL;
end;

uListaOrdenada.pas (implementacin: function insertar)

El objetivo de esta funcin es insertar (ordenado) un valor en la lista. Si el valor ya existe
entonces lo volvemos a insertar o no dependiendo del valor de okRep.

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

4/7

15/10/2015

HolaMundo.pascal(online):Captulo9

La implementacin es prcticamente igual a la estudiada en el captulo 7.

24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

functionListaOrdenada.insertar(
v:integer
;okRep:boolean):boolean;
varaux,ant,nuevo:PNodo;
begin
//lalistaestavacia...
if(lst=NIL)thenbegin
new(nuevo);
nuevo^.info:=v;
nuevo^.sig:=NIL;
lst:=nuevo;
insertar:=false;
exit;
end;
//elvaloresanterioralprimero
if(v<lst^.info)thenbegin
new(nuevo);
nuevo^.info:=v;
nuevo^.sig:=lst;
lst:=nuevo;
insertar:=false;
exit;
end;
aux:=lst;
ant:=NIL;
while((aux<>NIL)AND(aux^.info<=v))dobegin
ant:=aux;
aux:=aux^.sig;
end;
//llegoalfinaldelalista
if(aux=NIL)thenbegin
new(nuevo);
nuevo^.info:=v;
ant^.sig:=nuevo;
nuevo^.sig:=NIL;
insertar:=false;
exit;
end;
//elvalorexiste...
if(aux^.info=v)thenbegin
if(okRep)thenbegin
new(nuevo);
nuevo^.info:=v;
nuevo^.sig:=aux^.sig;
aux^.sig:=nuevo;
end;
//estaba...retornotrue
insertar:=true;
exit;
end;
//encontreunomayor...
//insertamosentreantyaux
new(nuevo);
nuevo^.info:=v;
nuevo^.sig:=aux;
ant^.sig:=nuevo;
insertar:=false;
end;

uListaOrdenada.pas (implementacin: function siguiente)

89:
90:
91:
92:
93:

functionListaOrdenada.siguiente(
varv:integer):boolean;
begin
if(actual=NIL)thenbegin

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

5/7

15/10/2015

HolaMundo.pascal(online):Captulo9
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:

actual:=lst;
v:=actual^.info;
siguiente:=true;
endelsebegin
actual:=actual^.sig;
if(actual<>NIL)thenbegin
v:=actual^.info;
siguiente:=true;
endelsebegin
siguiente:=false;
end;
end;
end;

Esta funcin es "nueva". Permite iterarar la lista. La primera vez que la invocamos retorna (en
el parmetro v) el valor del primer nodo. La segunda vez retorna el valor del segundo nodo y
as hasta el ltimo nodo.
La funcin retorna true o false segn exista un nodo ms para iterar por lo tanto en un
programa podremos iterar la lista (recorrerla de principio a fin) as:
while( lista.siguiente(v) ) do begin ....

uListaOrdenada.pas (implementacin: procedure liberar)

107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:

procedureListaOrdenada.liberar();
varauxSig,aux:PNodo;
begin
aux:=lst;
while(aux<>NIL)dobegin
auxSig:=aux^.sig;
dispose(aux);
aux:=auxSig;
end;
end;
end.

otra vez, la misma implementacin que estudiamos antes.

Ahora veamos un programa principal que utiliza un objeto de la clase ListaOrdenada. Pide al
usuario que ingrese valores y los agrega a la lista. Cuando el usuario finaliza el ingreso de
datos (ingresando un valor cero) itera la lista para mostrar su contenido y luego la libera.
testListaOrdenada.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

usesuListaOrdenada;
var
lista:ListaOrdenada;
valor,iOkRep:integer;
okRep:boolean;
begin
lista:=ListaOrdenada.create();
write(
'Ingrese[valor,repetido(1=>si,0=>no)]:');
readln(valor,iOkRep);
while(valor<>0)dobegin
if(iOkRep>0)thenbegin
okRep:=true;
endelsebegin
okRep:=false;
end;
lista.insertar(valor,okRep);

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

6/7

15/10/2015

HolaMundo.pascal(online):Captulo9
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:

write(
'Ingrese[valor,repetido(1=>si,0=>no)]:');
readln(valor,iOkRep);
end;
writeln('[LISTA]');
//iteramoslalistaconelmetodosiguiente()
while(lista.siguiente(valor))dobegin
writeln(valor);
end;
lista.liberar();
end.

Algoritmos y Estructuras de Datos UTN UBA.

Publicado por PabloSZ

No hay comentarios:
Publicar un comentario en la entrada

Entrada ms reciente

Pgina principal

Entrada antigua

Suscribirse a: Enviar comentarios (Atom)

Todos los Derechos Reservados Propiedad Intelectual Nro. 591212

http://holamundopascal.blogspot.mx/2007/08/capitulo9_24.html

7/7