Hola Mundo 09

15/10/2015
HolaMundo.pascal(online):Captulo9
Ms Siguienteblog
Crearblog Acceder
Publicaciones del Autor

.pas
.c
.java
1 8 DE AG O STO DE 2 0 0 7
Captulo 9
.
Encapsulamiento e Introduccin a Clases y Objetos

Hasta aqu hemos trabajado con procedimientos y funciones. Es decir los procesos por un lado
y los datos por el otro.
Sin embargo, sera ms natural pensar directamente en los objetos que intervienen e
interactan en el contexto del problema que tenemos que resolver.
Para explicar este tema tomaremos como ejemplo el problema 3.2 (analizado en el captulo
3).
Problema 3.2
Leer los datos correspondientes a dos circunferencias y luego los datos que corresponden a 10
puntos. Indicar cuantos puntos estn ubicados dentro del rea de cada una de las
circunferencias, cuantos estn en la interseccin, cuantos no estn en ninguna y cuantos
coinciden con el centro de cada una.
>> Click para Ms Informacin <<
Recursos / Download
SZDelphi (por JDownloader)
Instalacin y uso de Delphi
Recordemos la solucin que planteamos para resolver este problema:
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!
Como analizamos en su momento, en el programa principal definimos todos los contadores

necesarios, los inicializamos y luego leemos los datos de las dos circunferencias (radio, x,y),
http://holamundopascal.blogspot.mx/2007/08/capitulo9.html
1/13
15/10/2015
los datos de los 10 puntos identificados por sus coordenadas, y por cada punto analizamos si
est dentro de alguna, ninguna o de la dos circunferencias. Incrementamos los contadores que
correspondan y (luego del ingreso de los 10 puntos) mostramos los resultados.
Definimos tambin una funcin procesaCirc que recibe los datos de una circunferencia y los
datos de un punto, evala ese punto respecto de esa cirfunferencia e incrementa los
contadores en caso de ser necesario.
Acerca del Autor

Ing. Pablo A. Sznajdleder
Agradecimientos
No al blog de Java
Super Baterista
Si hacemos un anlisis de los objetos que intervienen e interactan en el contexto de este
problema podremos identificar los siguiente objetos:
c1, c2 dos circunferencias, cada una identificada por su radio y por su centro
plano el plano que contiene a las dos circunferencias
pi 10 puntos identificados por sus coordenadas
Los objetos tienen atributos. Por ejemplo: c1 puede tener radio=10 y centro en (4, 2)
mientras que c2 puede tener radio=6 y centro en (3,7).
c1 y c2 son dos objetos del mismo tipo (son circunferencias) y por lo tanto tienen los mismos
atributos: un radio y un centro identificado por un par (x,y), pero con diferentes valores.
Decimos entonces que c1 y c2 son objetos de la misma clase o bien son instancias de la misma
clase: la clase Circunferencia.
Sitios Relacionados
PascAlgo (por Lic. Hugo Cuello)
Algoritmia.net
Clases y Objetos
Java Algorithm Framework
Una clase es un tipo de datos (definido por el programador). Por lo tanto un objeto es una
variable cuyo tipo de datos es una clase.
El siguiente cdigo Pascal define dos objetos c1 y c2 cuyo tipo de datos es la clase
Circunferencia.
var c1,c2: Circunferencia;
En una clase podemos definir datos y operaciones. Los atributos de un objeto son datos y
(siguiendo con el problema) una operacin para la clase Circunferencia podra ser
procesarPunto. Es decir: un objeto circunferencia debera ser capz de recordar su radio y su
centro identificado por las coordenadas (x,y), y de evaluar y procesar un punto en relacin a s
mismo.
uCircunferencia.pas (versin 1, interface)
1:
2:
3:
4:
5:
6:
7:
8:
9:
unituCircunferencia;
interface
usesmath;
type
Circunferencia=class
2/13
15/10/2015
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
private
//atributos
radio:real;
x,y:real;
public
//metodos
constructorcreate(r,cx,cy:real);
functionprocesarPunto(px,py:real):real;
end;
//continuamasabajoconlaseccionimplementation
En el cdigo anterior definimos la clase Circunferencia. Las clases tienen una parte privada
(identificada por la palabra private) y una parte pblica (identificada por la palabra public).
Generalmente los atributos se definen en la parte privada y los mtodos (operaciones
asociadas a los datos) se definen en la parte pblica.
Los mtodos pueden definirse como procedimientos o funciones. Adems existe un mtodo
especial: el contructor.
El Constructor
El constructor es un mtodo especial cuyo objetivo es permitir inicializar al objeto. Es decir:
en el contructor (generalmente) se reciben (como parmetro) los valores con los que se dar
valor a los atributos del objeto.
En otros lenguajes de programacin como C++ o Java el constructor obligatoriamente debe
tener el mismo nombre que la clase. Sin embargo, en Pascal puede tener cualquier nombre.
Simplemente se diferencia de los otros mtodos porque no se define como procedure ni como
function: se define como constructor. En todos los casos nosotros lo llamaremos create.
Por convensin cada clase ser definida en una unit de Pascal que tendr el mismo nombre de
la clase pero anteponiendo el prefijo u. Por eso en este caso la unit es: uCircunferencia.pas
Veamos la continuacin de uCircunferencia.pas donde analizaremos la implementacin de los
mtodos definidos en la clase.
uCircunferencia.pas (versin 1, implementation)
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:
implementation
//implementaciondelcontructor
constructorCircunferencia.create(r,cx,cy:real);
begin
radio:=r;//dentrodelosmetodostenemosacceso
x:=cx;//alosatributos(variablesde
y:=cy;//deinstanciadelaclase)
end;
//implementaciondelmetodoprocesarPunto
functionCircunferencia.procesarPunto(px,py:real):real;
vard:real;
begin
//siescentro
if((px=x)AND(py=y))thenbegin
procesarPunto:=0;
exit;
end;
//calculoladistanciaalcentro
d:=sqrt(power(pxx,2)+power(pyy,2));
//siestadentrodelareadelacircunferencia...
if(d<=radio)thenbegin
procesarPunto:=1;
exit;
end;
//elpuntocaefueradelarea
3/13
15/10/2015
32: procesarPunto:=1;
33: end;
34:
35: end.
36:
Para escribir la implementacin de cada uno de los mtodos hay que hacer referencia a la
clase en donde el mtodo est definido. Por eso el prototipo se define as (como funcin):
function NombreClase.nombreMetodo(...): tipoRetorno;
o bien (si lo definimos como procedimiento):
procedure NombreClase.nombreMetodo(...);
Ahora podemos analizar el cdigo de un programa que utilice lo anterior.

problema3.2oop.pas (versin 1)
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:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
usesuCircunferencia;
var
c1,c2:Circunferencia;//definimosdosobjetos
radio,x,y:real;
i:integer;
ret1,ret2:real;
contInterseccion,contFueraAmbas:integer;
contDentroC1,contDentroC2:integer;
contCentroC1,contCentroC2:integer;
contFueraC1,contFueraC2:integer;
begin
//inicializamosloscontadores
contInterseccion:=0;
contFueraAmbas:=0;
//...(asicontodoslosquefaltan...)
write('IngreseCircunferencia1(radio,x,y):');
readln(radio,x,y);
//instanciamoslaprimercircunferencia
c1:=Circunferencia.create(radio,x,y);
readln(radio,x,y);
//instanciamoslasegundacircunferencia
fori:=1to10dobegin
write('Ingresepunto',i,'(x,y):');
readln(x,y);
ret1:=c1.procesarPunto(x,y);
//analizamoslosresultados...
if((ret1<0)AND(ret2<0))thenbegin
contInterseccion:=contInterseccion+1;
continue;
end;
if((ret1>0)AND(ret2>0))thenbegin
contFueraAmbas:=contFueraAmbas+1;
continue;
end;
//:
//asiparatodaslasposibilidades
//:
end;
end.
4/13
15/10/2015
En el programa principal que acabamos de ver instanciamos dos objetos circunferencia (c1 y
c2 en la lneas 24 y 30), luego leemos los 10 puntos e incovamos (por cada punto) el mtodo
procesarPunto en cada una de las dos circunferencias (lneas 36 y 37) e incrementamos los
contadores que corresponda segn los resultados ret1 y ret2.
Variables de Instancia
Los objetos, una vez creados decimos que estn instanciados. Llamamos instancia a un objeto
que h sido creado y (por lo tanto) sus atributos tienen valor. Por este motivo, decimos que los
datos definidos en la clase (atributos y todas las variables que podamos definir) son variables
de instancia. Cada objeto de la clase mantiene valores particulares para cada una de esas
variables.
Desde el punto de vista de una circunferencia, si procesamos un punto podemos indicar si el

punto est dentro o fuera del rea y (si est adentro) si fu centro. Pero no nos incumbe la
relacin que exista entre ese punto y la otra circunferencia.
Podemos modificar la clase Circunferencia para que lleve la informacin estadstica
(contadores) de los puntos que proces y as liberar de esta responsabilidad al programa
principal.
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:
interface
usesmath;
type
private
radio:real;
x,y:real;
contCentro:integer;//contadordecentros
contDentro:integer;//cont.dentrodelarea
contFuera:integer;//cont.fueradelarea
public
//metodosdeacceso
functiongetContCentro():integer;
functiongetContDentro():integer;
functiongetContFuera():integer;
end;
Como vemos agregamos tres variables de instancia: contCentro, contDentro y contFuera.

Estas variables (son contadores) deben inicializarse en cero antes de que la circunferencia
comience a procesar puntos. Esto lo haremos en el constructor.
Mtodos de Acceso
Las variables de instancia que definimos en la clase (en la seccin private) estn
encapsuladas. No pueden ser accedidas por fuera de la clase. Por lo tanto, la nica forma de
tener acceso al valor de las variables es a travs de mtodos de acceso que provea la misma
clase.
Por convensin estos mtodos se deben llamar "get" seguido del nombre de la variable a la
permiten acceder.
En la clase Circunferencia definimos (hasta ahora) tres mtodos de acceso:
5/13
15/10/2015
getContDentro // retorna el valor de la variable contDentro
getContFuera // retorna el valor de la variable contFuera
getContCentro // retorna el valor de la variable contCentro

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:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
implementation
begin
radio:=r;
x:=cx;
y:=cy;
//loscontadoresdebeninicializarseencero
//elconstructoresunbuenlugarparahacerlo...
contCentro:=0;
contDentro:=0;
contFuera:=0;
end;
functionCircunferencia.procesarPunto(px
,py:real):real;
vard:real;
begin
//siescentro
if((px=x)AND(py=y))thenbegin
contCentro:=contCentro+1;
procesarPunto:=0;
exit;
end;
//calculoladistanciaalcentro
d:=sqrt(power(pxx,2)+power(pyy,2));
//siestadentrodelareadelacircunferencia
if(d<=radio)thenbegin
contDentro:=contDentro+1;
procesarPunto:=1;
exit;
end;
//elpuntocaefueradelarea
contFuera:=contFuera+1;
procesarPunto:=1;
end;
functionCircunferencia.getContCentro():integer;
begin
//simplementeretornamoselvalordelcontador
getContCentro:=contCentro;
end;
functionCircunferencia.getContDentro():integer;
begin
getContDentro:=contDentro;
end;
functionCircunferencia.getContFuera():integer;
begin
getContFuera:=contFuera;
end;
end.
Ahora el programa principal queda liberado de la responsabilidad de manejar los contadores de

cada una de las circunferencias. Solo maneja los contadores que exceden el contexto de una
circunferencia (contInterseccion y contFueraAmbas)
1:
6/13
15/10/2015
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:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
61:
62:
63:
64:
65:
var
c1,c2:Circunferencia;
radio,x,y:real;
i:integer;
ret1,ret2:real;
//contInterseccionycontFueraAmbas
//losmanejamos"amano".
begin
contFueraAmbas:=0;
readln(radio,x,y);
readln(radio,x,y);
fori:=1to10dobegin
write('Ingresepunto',i,'(x,y):');
readln(x,y);
//dentrodelasdos=>estaenlainterseccion
continue;
end;
//fueradelasdos
continue;
end;
end;
//pedimoslosdatosalacircunferenciac1
writeln('Circunferencia1:');
writeln('DentrodelArea:',c1.getContDentro());
writeln('FueradelArea:',c1.getContFuera());
writeln('Centros:',c1.getContCentro());
//pedimoslosdatosalacircunferenciac2
writeln('DentrodelArea:',c2.getContDentro());
writeln('FueradelArea:',c2.getContFuera());
writeln('Centros:',c2.getContCentro());
//mostramosloscontadoresque"llevamosamano"
writeln('Interseccion:',contInterseccion);
writeln('FueradeAmbas:',contFueraAmbas);
end.
Avancemos un poco ms. Vamos a darle a la clase Circunferencia la responsabilidad de leer

sus propios datos. Para esto agregaremos un nuevo constructor (sin argumentos) y crearemos
un nuevo mtodo: ingresarDatos.
1:
2:
3:
4:
5:
6:
7:
8:
9:
interface
usesmath;
type
7/13
15/10/2015
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
private
radio:real;
x,y:real;
contCentro:integer;
contDentro:integer;
contFuera:integer;
public
constructorcreate();//sobrecarga
procedureingresarDatos();
end;
Sobrecarga
Como podemos ver, ahora tenemos definidos dos constructores. Se llaman exactamente igual
(create) pero reciben diferentes argumentos. El primero recibe 3 parmetros de tipo real,
el segundo no recibe nada. Decimos entonces que sobrecargamos (en este caso) el constructor.
Podemos sobrecargar cualquier mtodo. Esto implica escribirlo ms de una vez pero con
diferente cantidad y/o tipos de parmetros.
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:
implementation
constructorCircunferencia.create();
begin
//contructornulo...nohacemosnada
end;
begin
//:
//todoloqueestaba...
//:
end;
procedureCircunferencia.ingresarDatos();
begin
write('IngreseCircunferencia(radio,x,y):');
readln(radio,x,y);
end;
//:
//acasiguieestandotodoloqueestaba...
//:
end.
Ahora veamos como queda el programa principal:

1:
2:
3:
4:
5:
6:
7:
8:
9:
var
radio,x,y:real;
i:integer;
ret1,ret2:real;
8/13
15/10/2015
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
begin
contFueraAmbas:=0;
//instanciamosyleemos
c1:=Circunferencia.create();
c1.ingresarDatos();
//instanciamosyleemos
c2.ingresarDatos();
//:
//:
end.
El prximo paso ser desligar al programa principal de la responsabilidad de leer los puntos a
mano. Para esto vamos a crear una clase Punto con dos atributos: x,y (sus cordenadas) y con
un mtodo ingresarDatos. Tambin tendremos que sobrecargar el mtodo procesarPunto de la
clase Circunferencia (que reciba dos valores tipo real) para que ahora reciba una instancia
de la clase Punto.
uPunto.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:
38:
39:
40:
41:
42:
43:
unituPunto;
interface
type
Punto=class
private
x,y:real;
public
constructorcreate();
//metodosdeaccesoalosatributos
functiongetX():real;
functiongetY():real;
end;
implementation
//constructornulo...nohacenada...
constructorPunto.create();
begin
end;
procedurePunto.ingresarDatos();
begin
write('Ingresepunto(x,y):');
readln(x,y);
end;
functionPunto.getX():real;
begin
getX:=x;
end;
functionPunto.getY():real;
begin
getY:=y;
end;
end.
Ahora sobrecargamos el mtodo procesarPunto en la clase Circunferencia.

uCircunferencia.pas (versin 4)
9/13
15/10/2015
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:
43:
44:
45:
46:
47:
48:
interface
usesmath,uPunto;
type
private
radio:real;
x,y:real;
contCentro:integer;
contDentro:integer;
contFuera:integer;
public
//dosconstructures
constructorcreate();
//dosprocesarPunto...
functionprocesarPunto(p:Punto):real;
end;
implementation
//:
//:
functionCircunferencia.procesarPunto(p:Punto):real;
begin
//invocamoslaotraversiondeprocesarPunto
//pasandolelosvaloresxeydelpuntop
procesarPunto:=procesarPunto(p.getX(),p.getY());
end;
end.
El programa principal ahora ser:

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:
usesuCircunferencia,uPunto;
var
p:Punto;//definimosunobjetodelaclasePunto
i:integer;
ret1,ret2:real;
begin
contFueraAmbas:=0;
//instanciamosc1
c1.ingresarDatos();
//instanciamosc2
c2.ingresarDatos();
//instanciamosp
p:=Punto.create();
10/13
15/10/2015
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
fori:=1to10dobegin
p.ingresarDatos();
ret1:=c1.procesarPunto(p);//recibeunpunto
ret2:=c2.procesarPunto(p);//:O)
//:
//todoloqueestabasigueestando...
//:
end;
end.
Ahora (para finalizar) intentaremos evitar que el programa principal se ocupe del contador de
puntos que pertenecen al rea interseccin y del contador de puntos que caen fuera de ambas
circunferencias.
La solucin ser crear una nueva clase: la clase Plano. El plano tendr dos circunferencias y la
responsabilidad de mantener los contadores que excedan las atribuciones de las circunferencias
que contiene.
uPlano.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:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
unituPlano;
interface
usesuCircunferencia,uPunto;
type
Plano=class
private
public
constructorcreate(circ1,circ2:Circunferencia);
procedureprocesarPunto(p:Punto);
//metodosdeacceso
functiongetContInterseccion():integer;
functiongetContFueraAmbas():integer;
end;
implementation
constructorPlano.create(circ1,circ2:Circunferencia);
begin
//asignamoscirc1ycirc2alasvbles.deinstancia
c1:=circ1;
c2:=circ2;
contFueraAmbas:=0;
end;
procedurePlano.procesarPunto(p:Punto);
varret1,ret2:real;
begin
//pasamoselpuntoacadacircunferencia
ret1:=c1.procesarPunto(p);
ret2:=c2.procesarPunto(p);
//incrementamosloscontadoresquecorresponda
exit;
end;
end;
end;
functionPlano.getContInterseccion():integer;
begin
11/13
15/10/2015
54: getContInterseccion:=contInterseccion;
55: end;
56:end.
57: functionPlano.getContFueraAmbas():integer;
58: begin
59: getContFueraAmbas:=contFueraAmbas;
60: end;
61: end.
62:
Ahora veamos la versin final del programa principal.

problema3.2oop.pas (versin 5, final)
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:
usesuCircunferencia,uPunto,uPlano;
var
p:Punto;
pla:Plano;
i:integer;
begin
//instanciamosc1
c1.ingresarDatos();
//instanciamosc2
c2.ingresarDatos();
//instanciamoselplano
pla:=Plano.create(c1,c2);
//instanciamosunpunto
p:=Punto.create();
fori:=1to10dobegin
p.ingresarDatos();
pla.procesarPunto(p);
end;
writeln('Dentro:',c1.getContDentro());
writeln('Fuera:',c1.getContFuera());
writeln('Centro:',c1.getContCentro());
writeln('Dentro:',c2.getContDentro());
writeln('Fuera:',c2.getContFuera());
writeln('Centro:',c2.getContCentro());
writeln('FueradeAmbas:',pla.getContFueraAmbas());
writeln('Interseccion:',pla.getContInterseccion());
end.
Algoritmos y Estructuras de Datos UTN UBA.

Publicado por PabloSZ
No hay comentarios:
Publicar un comentario en la entrada
12/13
15/10/2015
Entrada ms reciente
Pgina principal
Entrada antigua
Suscribirse a: Enviar comentarios (Atom)
Todos los Derechos Reservados Propiedad Intelectual Nro. 591212
13/13

Hola Mundo 09

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Hola Mundo 09

Încărcat de

Drepturi de autor:

Formate disponibile

15/10/2015

Publicaciones del Autor

Encapsulamiento e Introduccin a Clases y Objetos

>> Click para Ms Informacin <<

Recordemos la solucin que planteamos para resolver este problema:

Plantilla de Diagramas p/Visio

Como analizamos en su momento, en el programa principal definimos todos los contadores

Acerca del Autor

Java Algorithm Framework

Ahora podemos analizar el cdigo de un programa que utilice lo anterior.

Desde el punto de vista de una circunferencia, si procesamos un punto podemos indicar si el

Como vemos agregamos tres variables de instancia: contCentro, contDentro y contFuera.

uCircunferencia.pas (versin 2, implementation)

Ahora el programa principal queda liberado de la responsabilidad de manejar los contadores de

Avancemos un poco ms. Vamos a darle a la clase Circunferencia la responsabilidad de leer

Ahora veamos como queda el programa principal:

Ahora sobrecargamos el mtodo procesarPunto en la clase Circunferencia.

El programa principal ahora ser:

Ahora veamos la versin final del programa principal.

Algoritmos y Estructuras de Datos UTN UBA.

Suscribirse a: Enviar comentarios (Atom)

Todos los Derechos Reservados Propiedad Intelectual Nro. 591212

S-ar putea să vă placă și