universidad autonoma

Casa abierta al tiempo
UNIVERSIDAD AUTONOMA
METROPOLITANA
UNIDAD IZTAPALAPA
'cas
'IJCENCZATURA EN COMPUTACI~N
PROYECTO DE INVESTIGACI~N:
4 O G R A M A C I d N ORIENTADA A OBJETOS
ALUMNOS:
4 a . Esther +nes
Rosaes
,
Miguel Neri Vázquez
ASESORES:
Ing.Miguel h g e i Gumin López
Ing. Hugo Borderas TordscWas
~NDICE
.,
1. Introdurnon .......................................................................................................................
1
1.1 ¿ Qué es Programacion Orientada a Objetos
? .......................................................
1
.,
sistemas
1.2 Construmon de
....................................................................................
-4
p 3. c;risis del s o w e ..................................................................................................
5
1.4 Principal enemigo delos sistemas: el cambio .........................................................
7
1.5 T6cnicas para proteger los
a sistemas .................................................................... 8
1.5.1 tinea de defensa Marginot ......................................................................
8
1.5.2 EstrategiaSuiza ......................................................................................
9
1.5.3 Estrategiambda .......................................................................................
9
1.5.4 Programadon Orientada a Objetos........................................................
2.
r quéProgramacionOrientadaaObjetos
? ...............................................................
10
10
IL
2.1 Binding Temprano ............................................................................................... ? 2
2.2 Binding Tardio { Binding Dinámico ....................................................................
13
2.3 Técnicas de empaquetamiento ............................................................................ 14
2.3.1 Conexiones y filtros de UNiX ................................................................. 15
2.3.2 Bibliotecas de rutinas ............................................................................
16
2.3.3 C.I. de S o w e ..................................................................................
16
3. Conceptos básicos de la Programación Orientada a Objetos
..............................................
.,
19
3.1 Objetos y Encapsulaaon ......................................................................................
19
3.2 Mensajes ...........................................................................................................
2 0
3.3 Miitodos ........................................................................................................... 3 2
instancias
3.4 Gases e
...............................................................................................
0
13
3.5 Herencia ............................................................................................................
-24
4. OOPC Programaubn Orientada a Objetos usando lenguaje
C ............................................
26
4.1 Objetos enOOPC ................................................................................................
26
4.2 Mensajes .............................................................................................................
27
4.3 lmplementauon de la Herencia
............................................................................
32
.
. . .
4.4 bmdaaones de OOPG ......................................................................................... 36
..............................................................
37
Objetos
Programacibn
5. Orientada
Lenguajes
ade
5.1 Smdftdk-80 ......................................................................................................... 37
5.1.1 Mensajes ..............................................................................................
37
5.1.2 Clases ..................................................................................................
39
5.1.3 2*1&&~ ...............................................................................................
42
5.1.4 Herencia ...............................................................................................
47
5.1.5 Metadases ...........................................................................................
48
5.1.6 Rutinas primitbas...................................................................................
49
5.1.7 Variables dedase indexadas .................................................................
5.1.8 Estruduras de wntmly bloques ............................................................
49
50
..............................................
5.1.9 Clases bisicas en el sistema Smdftalk-80
51
5.2 Objective-C .........................................................................................................
52
5.2.1 Identificadores de objeto .......................................................................
52
5.2.2 Mensajes ..............................................................................................
53
5.2.3 Objeto constructor o fabricante .............................................................
55
5.2.4 Partes de un objeto...............................................................................
56
5.2.5 La construcdbn de instancias.................................................................
56
5.2.6 Mecanismo de Herencia ........................................................................
57
5.2.7 Métodos ...............................................................................................
5.2.8 Lavariable SELF ...................................................................................
59
60
5.2.9 Mbtodos paralos objetos fabricantes.....................................................
60
j 5.2.10 Super ...................................................................................................
61
5.3 C++ .....................................................................................................................
62
P
5.3.1 Antecedentes .........................................................................................
62
5.3.2 Definiaones ...........................................................................................
63
FA
4
5.3.2.1 Secciones deun clase .............................................................
63
5.3.2.2El operador I : .........................................................................
64
5.3.2.3 Funciones virtudes
..................................................................
64
.,
5.3.2.4 Dedaraaon Fflend .................................................................. 64
5.3.3 Clases ................................................................................................... 64
5.3.4 Constructores ........................................................................................
66
5.3.5 Derivadbn dedases flerenüa) .............................................................
70
6. Bibliografia ........................................................................................................................
87
-
I. INTRODUCCI~N
La programaciónorientadaa' objetos surge como una rrk#na&a para ma)war la
produdbidadde los progn#n&dores y h m que el manPenimienZo delos programas sea másfácil
de realizar. Esta nueva Ocnica de programar no ha tomado la fuerza que debiera ya que ha
iai\ado una verdadera dikrsión sobre ella. La mayor parte de la gente que tiene quever con la
computadónhatenido m contada indireCEO con este estib devisualizar la programación
(ventanas,íamos, funciones de biblioteca. etcétera)
l. 1 ¿Qué et Rogmmad6n Orientada ObjaQs?
Dado que la parte cemhl de la Ingenieria de la R o g m d ó n es, precisamente. la
amdwción de programas, es necesario saber, entonces, que existen varias formas o estilos de
programar una computadora: con procedimientos, funcional, relacional
y orientado a o m s
enlre abos. El estilo de Rogramadón Orientadaa Objetos se originó al crearse el lenguaje de
simulación S W L A en 1966 por Dah1 y Nygaard, surge por la necesidad de hacer, cada día,
sistemas más complejos. Esta h
c
i
apuede ayudar a simplificar el desarello de programas,
hacer que édos sean más W e s de mmejw y de entender.La programaci6n Orientada
a Objetos
y paradigmasque,usadossistem&camente,
estábasadaenunconjuntopequelíodeideas
pmpotcionan unestilo de programarque se espera sea cada vez más popular.
Los paradigmasprinc@alet
de estátécnica son la shnulación, los mensajes, I n s dases y la
herenda El paradigma de la simulación pmpordwra al programador un enbque peculiar. es
decir el programador desea que
la computadora adiie y se comporte comosi fuera unobjeto real.
por ejemplo,un
avibn, una cental generadoradeeiecbiadad.
etdtera En estos casos la
computadora. al ejewtw elprograma, simulael comportamiento del o b j j real y así, por ejemplo,
en el caso de un sirnulalor de
d,
la computadora puede estar generando imagenes de un
vuelo, como las que un pildo obsem'aal mwer los controles de una cabinasimilar a la de un
aereoplano. Las ventajas de contar con estos simuladores son
varias y basta am mencionar que
pueden servir para capacitar a futuros pilotos u operarios de plantas o equipos que deswrollan
procesos muy complejos
o peligrosos utilizando computadoras que implicancosto
un menor.
mediante la simulación deotros
Ahora bien, la simulación de un objeto cumplejo se logra
objetos no tan complejos los cuales, al intecatuar enlre si, producen amo resultado el
comportamiento del primero.Deunaformasimilar,
el objeto realest& formado deobjetos
componentes queintetacaianentre sí para lograr un comportamientored.
-1-
1
Cuando una personauiiliza el estilo orientadoa objetos para programar, debe enfocanre
a los objdos que necesh para lograr el comportamiento deseado. lksde el punto de vista
wmputaüond, un objeto es m estruc(um de dabs y un conjunto de operaciones asociadas a
ella: un númeroenteroesuna
palabra deuna computadora (16 ó 32 bil) y algunas de las
operaciones que se pueden redizar w n números sons u m , restas, etcétera. Por otro lado, una
imagen es un conjuntos de puntosg d i w s o "pixeles", que tienen asociadas una posicicjn enla
pantalla Las operaciones que se pueden hacer am un punto esbo&
de la p a t " (hacer el
punto negro) y escribklo en la pantalla (hacer el punto blanco o de otro color) en una posiüh
especifica,
La w
m
p
W
o
r
a es un recurso que nos permite procesar y guardar información de
manera Mid& cómoda y barata; y nos gYda aresohm problemas que se nos presentan en In
vida diaria. H a c e tan solo veinte años, campuEadoras sendtfas wmu la 18M 7094 era suliaenk
pwa atender a algunas indudrias y unkenidades, como la Universidadde Chicago. Hoy en dia
wntamos con computadoras que tienen mayor potenaa y capacidad de memoria. En 1970 se
empezaron a desarrollar las redes de wmputa&ras, adualmente las comunicaciones
internacionales se redizan a través de mens8jese r h lot disposilivos que integren la red.
En l a s ÚHimas dos décadas se ha dado M gmn desanolb en la creación del hardware.
lo wd hantenido que sopor& las personas encargadas en
la rsalizadón de estatarea. ya que en
muchas ocasiones esta evolución es causante de la r
dtemcih de su plan de&abajo. L
a primer
compubxlomdesarrolladaconstaba
de vrihrulasde vacío y Cawes, dicha computadora se
operaba manu**,
esto es, conectando y desconectandolos cables. Mhs tarde se ocuparon
transistores, resistores y capadores los wales han sido reemplazados rápidamentepor dmbs
inkgmdos. Eldesmtfo del hmhwue se hadado en una linea form
de exponencial.
¿ Fbdemos hacer una i d e M d n comparable del desarrollo del hardware con el del
sofhwe ?
No, no sepuede.En
los irltimos veinte años. hemosaprendido a programaren
lenguaje ensamblador y la mejor manera de utilizar los lenguajes que existen en el mercado
como P
a
s
c
a
l
,Cobol, FORTRAN,C o Lisp, a r a . Mientras los ingenieros de hardmve piensan
en desarrollar sus trabajos en forma de módulos, ayo tam60y poder se incrementan deforma
exponencial. los ingenierosen el desmllo
del soRware construyensusprogramas
como
siempre lo han hecho, sin innovaciones, poniendo
y cambiando instrucciones de
algún lenguaje.
-4-
Cos ingenieros de hardware han dewbierto cum lograr el *do desarrollo de sus
trabajos: fo hacen por medio de módufos. Cuando desarrollanunomejor,
solo Cenenque
cambiar esa paate por el mejor. De esta manera solo se afecta un módulo. La idea es que cada
módulo realize su hbajo de maem independiente sin adectaral exterior, su~ngamosque una
mm-m
necesita ser más
elidente y tos ingenierosde hardmrre dicen, por ejemplo, que
cmMar la ROM actual PM otr& se logra tener dicha eficiencia y en el mercado se tiene la ROM
que hace posible e&; lo úniw que se hace es qMtW
h antiguay colocar la que se necesita, nose
tiene que hacer ningunam
o
d
d
i
f
i
n
.
debido 8 que el cambio de ROM 110 afecta a ninguno de
los obos módulos.
Esto no sucede en el desarrollo del sol\ware, cada día que pasa existe la necesidad de
desarrollar sistemas de saflware que se toman más wmplejj, muchos de eaOsya no es posible
desturokrlos con las hemientas aduales. son de calidad insufldente y es casi imposible su
manejo. El cambio se puede d a r , solo se necesitadar un paso más en el desarrollo delsoffware.
este paso que nos permite un gnm avance en el desarrollo de sistemas es la R
o
g
r
a
m
a
d
b
Mentada a Objetos.
La programaciónMentada aObjetas es una herramienta en la c o M c c i á r ~de sistemas,
permite vdver a r#lirar el soaWare que se ha desanolladoanteriormente y los componenles que
se han ConStnrido, en lugar de las ocasionales llamadas a fundones de alguna librerisc como lo
hacen los programasaduates. A estos mpomntes que se pueden
whw 8 utilizar el número de
veces deseados les llamaremos C.I. de $ol\ware(Circuitos Integrados de Solhare), llamados
de esta maneraparahacer
una anralogía conloscircuitos
integrados construidospor 10s
ingenieros deharhm#e.
Un C.I. de Sollware implementa una
dase de objetos como una dase de psqudaso dase
de atchivsms. Este esunpaquete
de programaciónqueesindependientedeun
trabajo
específico y de gran reutilización en Mwos trabajos. Mejor aún, el programador no tiene que
mar C.l. de Softewam desde que inicia su trabajo, pues se cuenta con C.l.de S d h r m ya
desarrohdos, sob se tiene querevisar wale8 nos sirveny utilizados. La Rognmacibn Orientada
a Ob-
puede llevame a cabo mediade un Iwrguaje de programaci6nconvencional,
agregándole a estos algunas funcionesy restricciones con las cuales se wmplan los principios y
capaddades de esta nueva thcnica de programar. El nuevo lenguaje conserva la eficiencia y
compalíbilidad del lenguaje base, pero además menta cona
ls vmbjas que ofreoe este nuevo
enfoque.
-3-
1.4 Construcción de Sistemas
Latemologia enel campo de la eledrónicaalcanzó avances significativos en muy pocos
&s. Enun codo periodo se diseñaroncomputadorasbastanterápidasensustiemposde
proceso, cuya velocidad, que en algún tiempo se cuantificaba en términos de miaosegundos,
pas6 a ser mucho menor.Esto representó m logro en el diseño delhardware porque tambiénse
diseñaron perifériws capaces de ser congruentes con la capacidad alcanzada por la unidad
central de proceso. Sinembargo,surgióunproblema
seno: el solbme no logró el mismo
desanollo,y por lo tanto. seguía siendo tradicional, principalmente enla organizadón de datosy
sus métodos de acceso; es dear, en comparaci6n con el hardware, éstor seguían siendo c a s i
primilivos,haciendo quela velocidad dela computedora fuera frenada en gran medida
De estamanera. los ingenieros en disefio de
soilware se uiemn precisados a desanollar
nuevosconceptos, como el debases de datos. Este propósito enbe Otras cosas perseguía
aprovechar la velocidad de la amputadom surgiendo así una vwicdad de nuevos arreglos de
datos, acordescon el m
c
e del hardware. AI utilizar bases de dabs en el desarrollos de
gran fiexibiHdadpara
estructurar
regidros de dtdos con longitud variable dentro de una misma base de datos, la eliminación de
informaciónredundante se llevaa cabo con facilidad, se probge la información quese considere
sistemasseobtienengrandes
importante; ya quese
ventajas comoson:adquirir
necesita autorización para su
acceso, existe una amplia posibilidad y
flexibilidad parahacer preguntas no planeadas sobre
el contenido de los datos.así como para la
obtención de reportes y estadísticas sólo con la codificación de algunos comandos de conhi
enlre otras.
Es fácil wmprendera
lsventajas que representa el uso de bates de datos en el desandlo
de sistemas desofbwe, pero io que no resultatan cierto es la supuesta fadlidad para ettrudurlas,
explotarlas, administrarlasy mantenerlas, para que fundonen
conecbaments se necesitade gente
para que las desarrolle, los conocimientos témicos de éstas personas no se alcanza
de un dia para
otro; por el contrario, es necesariala formación de espedalidas del
ramo. Para la
c
a
p
-
creación deun sistema utilizando bases
de datos se necesita de gente especializada
-4-
Otro concepto
que permite el desarrollo de sistemas de una manera m k fácil y mb
accesible para los programadores que no sean ‘expertos
el desmdlo
en
de sistemas es el estilo
de la Programación Orientadaa Obms, cuya importancia es que permite la redefiniciónde los
módulos, de trd manera que los programadores crean subcomponentes en vez de soluciones
completas. A cada módulo se
le asigna la realización de determinada
tarea. con lo cud se reducen
los costos deprognrm;adindebido
a que ya nohayque
volver a hacerlos, sólo hayque
redebnirlos. Los tubcomponentes son contmlados por estandares y pueden ser bdercambiadas a
través de diferentes procedimientos.
Los programadores ya no construyenprogramasenteros a park de funaonesde
bibliotecas, deindfucdones.deexpresiones
espf!ckas quenosofrecen
los lenguajes
convencionales de programación. En lugar de esto, e h s producen componentes de soltware
reutilizables media& la unión de C.I. de SoRware, los que se pueden guardar en librerias para
usar enotros programas.
1.3 Crisis del software
Con el avance de la tecnología en materia de hardwatre. se ha
hecho posible que los
equipos de dmputo se w e h cada día más económicos. Por el contrario, el satlware se ha
encarecido y wn frecuenciase
vuelve d6al deencontrar disponibk ene1mercado.
Es
algunas compaiiicrs distrlWdoras y fabricantesde e@po de
wmputo. han lanzado umwahrias parafusionarsecon otras comps3iías o grupos quese
dedican al desarrollo del solhvare, elevándose asi por esta demanda
los costos de dichosotware.
comddo el hechodeque
Sin importar que e*
fenómeno sea cadavez más grave, muchas personas que cuentan
con recursos han adquirido el dcio de comprar prádicamente cualquier paquete de soRMue
que se les ofrece, aun cuando sabenque harán poco utifización del mismo. si a lo anterior
agregamos quemuchasveces el software que existe en el mefcado no toma en cuenta f a s
necesidadesrealesde
los usuariosquesesuponerecibirán
el senddo; encontramosque
finahnente se compra sin objetivos dams y, por lo tanto, con muy pocas posibitidades deun uso
efectivo de talespaquetes.
Existen empresas quepor nohacer una evaluación seria, compran paquetes que pen
ow
tiempo r e s u b obsoletos o son inwmpaiibies conotros equipos con lo que ésta cuenta Al paso
del tiempo, sucede que la empresa sigue pagando los cortos de manpsnimiento para w i o s
paquetes que no han sido utilizados. Esto se M u c e en un gasto infruduoso y elevado en la
mayoria de los casos. No hw necesidad de que estosuceda si se realiza un estudio preliminar,
no muy tedioso, para demostrar la conveniencia de la adquisición de tal o cual produdo de
soítware. Seguircomprando a ciegas y sinunfinespecifica y costeable, s&o representará
incrementar el presupuesto.
Para la elaboración de pmgrmas a p l i s se consume mucho tiempo de miquina y
kewentemente setienenque
hacer cwtecciones posteriores por no haber aprobado l a s
tiene que ver
o W a e d a s de
procedimientos estándares para que un
sistema sea elaborado bajo estridocontrol de d i d a d y
condidones predefinidas,esto
sin
duda
am la falta
seguridad. Es frecuente que unprogramador inicie laelaboración de un sistema partiendo de una
definidónverbal delanálista o sólo de notas impmuisadas derivadas
de una plsdica informal entre
ambos.
Paraellos es naturdque el progmalor invierta gran pwte de su tiempo haciendo ajustes
de ÚHimahora. que sumados a cada una de las etapas para la elebomcióndel sistema. arrojan un
lapso inconcebible; además, nunca se tienefa certeza de que enel sistema fueron amsideradas
todas a
ls posibles condiciones deproceso a que estará sujeto una vez terminado. Por lo tanto,
no es diricil suponer que cada programahecho a
si al ser sometidos a una prueba integral del
sistem arroje resultados
tan deficientesque obligan nuevamente a múlliplss comedones,
incrementandoaún mQ los tiempos. Fmalmente, cumdo por fin se didamina que el sistema es
fadible de liberarsea p
r
o
d
u
c
c
ó
in
,resulta un hecho que habrá M
aspor inwnsistencias.al operar
bajo
l a s rigurosas condiames reales de los datos, los wales superanpormucho
a las
condicionestriviales considwadas enla definidón d e l sistema
Comopodemos ver en la
1.1 del texto, en la indusbia del soilware el índice de
uentas de sistemas es notablemente malay éste aumenta d a VBZ más. La posibibdad de poner
un sistema en el mercado puede ser cancelada antes de escribir unasola iinea de d i g o , m
esto el usuario se desilusiona y contrarb. seprovocanpérdidas
monetsrias y personal
desapmvechado.S e crea una mala imagen de los programadores. se crea sofkm de baja
calidad, fuera decontrol, canceladones evenhalesy desgracia En la ingeniería dehardwara esto
no sucedeya que el hardwarede hoy en dia escapaz de soportar sistemaSr del mismotipo y m&+.
Los sistemas dislribuidos para llevar a cabo la comunicadcin usaninterfaces, compadibles o no.
-6-
.)-
1
~
I
i
I
El problema real es que los sistemas de sotlmve no están preparados para tundontw
medamente cuando cambian siguna(s) cmdicion(es) con l a s que idos fueron pisneados y
desanollados, la respuesta quepresentan h a d a estos Munbjos no es agradable.
No contamos con sistemas que puedan sobrevivir a los cambios que se
presentar-La figura 1.1muestra una g&
les pudieran
comparaba de costos de softmve, resuitado de una
invesligadrin realizada por una alidna de EE.UU., obteniendo: 4pA de &digo que ya se pago
2% decódigoliberado pero nousado, 19% de wdigo abandonado o
ratrabajado, 3% de wdigo que después de haber sido modificado se usa. y solamente menos
del 2% del wdigo queesliberado(es
decir, puesto en el mercado)se usa Con estos
porcentajespodemos ver que tan ddaente se enwenlra el desarrollo de sollware.
pero noliberado,
fig. 1.1Griticr de costos de software
1-4 Principal enemiga de los sistemas: el wnbio
Los sistemas de computadoras enfrentan el problema del cambio al sistema originad. Es el
adaptar el soihvam a ddwmmados condidonet que e s h en canstante cambio, adaptarse a los
caprichos y necesidades de los usuarios. Es importante hawr una dhrenaa entre los que es un
programa y un sistema de sollware. para ver de que manera afronbn cada uno de eslos el
cambio. Los programas en sumayoria son pequeh. l o s que se adaptan de manera *ida fácil
y no muy costosa a las condiciones de cambio. Para los sistemas de soibare noes tan f & u l
adaptme ya que son l a r g o s , complejos y bágiies;muchas veces no están protegidos para
pruebas externas.fo que provocaque el sistema ya no fundone cwrectamente o deje de hacerlo.
Pwa evctar que los sistemas sean ddados deben crearse defensas.
-7-
6
Para evldar que d s0fh;Uare que sediseña no seaulilizlldo por algunas condidones que
no
fueron previstas cuando se desmllo. hsy que protegerlos, parair midiendo la seguridad de su
de8adlo. así coma la produdividad de cada proqnrmsdor. Existen dos tiposdecambio:
lemporales ypermanentes.Las cambios temporales se identifi#u,porque sólo afectan a la comda
drwnstandal deunprograma; es dear, que despuésde haberse & d a d o , dicho cambio
desaparece, como si nunca hubiera existido. Los cambios permanentes se identilican porque
permaneceránpara unfu4m o un lapso considerable.
Existen eslrategias para enfmtar al cambio entre las que tenemos:
Esb convcnciond estrategia lo que hace es crear elaboradas eslrudum de defensa
para pte\renir por completo al cambio. Crea un sistema de pmtecd6n que pone un límite al
sistema que debe ser rigido, pues noadmi¡ modificaciones de ninguna especie. La manera en
es a B d s de la determinadrin y doarmcntación de los
requerimientosd e l sistema desothare. Los requerimientos se kaducen en espeMcaciones. las
wales son puestas a diswsibn hasta que wmplan con los puntos deseados por la persona que
requiere e¡ sistema Los programadorestoman especikaciones como base pam desardar sus
soluciones las que sondesanolladas.
revisadas y documentadas exhaustivamente como
que se crea el rsistema de defensa
soluciones especificas. Por Ú M m o las soluciones se hnsforman en código y se desmolla el
sistema al que se le hacen pruebas hastaque hrndone correctamente, en wanto esto suceda se
le entrega al diente. De estaforma éde queda satisfecho pues tieneexactamente lo que pidm. Ya
entregado el sistema, si se desea que realice algo más se le comunica al programador, quien
cobnth por este servicio,ya sea adeptandoel sistema actual,o bien reconslruyéndolo.
I
-8-
1.5.4 Ettrategia Suiza
Esta esirategia consiste en
const& un prototipo del sistema el cual se Utiiilza P%ra atraer
la atenaón de las personas interesadasy quienes pueden pagar porlos cambibs necesarios p m
sabisfacer susnecesidades.
Se tienen que redzar diferentes revisiones a los procesosde
sofhmve que son moclificados, pues al fomwv p a & ?del sistema; si
SU funaonamiento no es
correcio tampoco lo será el del sistema Esh esBadegia crea un sistema que acepta todo tipo de
moditidones. Esta knica probablemente puede aplicarseen el desarrollo de solbme, y ha
sido aplicada a varios siszemaS especializados y sumamente complicados. Smalltalk-80 es
uno de
los mejores ejemplos de esta estrategia
Esta estrategiaes
una de las preferidas porque combate el cambiousando
la
combinación de todas
las eshtegias que combatenel cambio. Los dogmas convencionales dela
Ingenieriade SoRware son los de construir sistemas didedes pero p m robustos. circundados
por erpbucarmn de defensas e&icas que las protegen del mbm.Debido a esto. no permite
desandlar skkmas muy complejos. Esta estrategiapreknde wbrk :
1. Que los sistemas hechos tengan un manejo m& fkil empleando algunas fundones que
al tiempo de ejecuah. Esla
hace que se tenga más demanda
de todasaquellas funciones que se realizan al Wnpo de ejecución. El binding dinhico
que es el proceso que realiza la “ 1 p d n de los tipos de dalos dedamdos por el
programador y los que usa el usuario. esta comparación se Ueva a cabo a tiempo de
permitan tener elasti-
ejecución.
2.
Simar quepuedanmodificaase más fatdknente.
sistemas sean más pequeños y más grandes
Para realizaresto,proponeque los
m peso (o ses. más funcionales), los
sisteinas se t
r
a
n
&
m
r
a
r
i
a
n en otros más confortabler Se aplican las
t&cnica8 de
encapsukión que pennite la irrtegradh y reMlitación de los procesos de soRware
desarrotlndos manterioridad.
3.
Los sistemas pueden ser m&;
hermiticot
encapsulándolos como objetos, que
se
#rmpMban a m o una caja negra pwa l i m i los efedos que se producen cuando se
efedúa una pendmción en la detensa estbdica am que wentan los sistemas. El cambio
de unaparte del sistems. no tiene pequé dedarlo en sutotalidad.
-9-
Esta técnica no pretende hacer desapareeer de manera mágica los problemas que se
generan wando nos enfrentanos al cambio, simplemenfa nospropordona nuevas hemientas y
MHIcepfos que pueden ayudar a la produeddn de SOlkAlre y hacer más tolerante el cambio.
Mm8N
1.
W?W@OIC
de:
Encapsuladón es la parte fundamental que nos permite tener las wmbjas que nos
proporcionaesta técnica. SU
wnsiste e n . la redricch que pone a los &dos
del cambio, pues coloca unabarrerade
código en cada uno
de los módulos
desanollados. Todos los accesos a los dabs son manejados por procedimientos, los
codrdar el acceso a éstos. Por el congario. en la
programación commndonalcada procedimiento solo puede U m e a cabo siempre y
cuales fueronpuestospara
cuando los operandosquesemanejandosean
del mismo1spo que los d e d a d o s
en el procedimiento o función.Encapsular es contener dentro de una mismadase a las
propiedades y funcionamientos que representan a un objeto, este concepto es muchas
veces llamado abshcción de d e s o programación modular. Lenguajeswmo Modula-2
y Ada. a diferencia de C y Pascal, soportan este concepto. La meta aquí es separar al
usuario de la implementadón del objeto. el usuario no tiene porque estar enterado de
cómo ei objeto ha sido implementado (usandoun arreglo o lista ligada, por ejemplo).El
usuario sólo puede operar los objetos mediante el uso de mensdes.propordonadot por
la implementación. este esun beneficio obvio, ya que el usuariopuedecambiar
la
implementach de la encapsuladón de un objeto de acuerdoa sus necesidades. En la
Programación Orientadaa Objetos nos es necesario que los operandos sean del mismo
tipo a los declarados en
el procedimiento.
2.
Herenda es ¡a parte más innovadora de las venfajas propcwáon~por esta témica
porqueno to manejan ios lenguajes convenciondes. Los objetos esth organizados
jerárquicamente en
dases. El concepto de herencia se maneja como el que hereda
propiedades o wmportannientos de sus a n c e h s en una esbudura jerárquica. de esta
forma se pueden deducirnuevas propiedades. Esta es una herramienta para la difusión
a
u
t
o
&
c
adel c6digo hacirn l a s dases desarrolladas por diferentes programadores.Los
programadoresno empiezan su tarea sin tener módulos de los wales pueden partir, al
ccmlmio pueden es#ibir una simple instruaión haciendo referencia a algunas de las
dases contenidas enlas libreflas. Cada insbucdón subsecuente describe
cómo la nueva
- 10,
.”
dase difiere de alguna delas existentes en tíbrerias. La idea es
crear sistemas mediante
el uso de módulos, al que se le puedan cambiar
éstor de tal Manera
que
el
fundonamientod e l sistema no se altere. Para que funcione de esta manerason necesarios
!os conceptos de módulo y encapsulamiento (esto es,
el fundonmiento interno de los
módulos no estarelacionado con el funcionamiento del resto delosmódulos).
La
comunicación entre modulos se realiza ade
través
mensajes, enuiados de uno a los otros
y de esta forma st? logra que interacttien. La RogramadónOrientada a Objetos mantiene
estos esquemas.
- 11 ,
-4-
2. ¿POR QUÉ PROGRAMACldN ORIENTADA A OBJETOS?
La p r o g m a d h Orientada a-,jetos m& que unatécnica de codificacih es unah i m
de empaquetamiento de informaah, ofrece una dternaliva a los pmgramcdores de realizar
sistemasdemapror
kinaonalidad y entregárselos al usuario,haciendoqueseincrementa
la
relación entre ellos:.
Esto es lo que marcala s e p d n enbe la Programación Orientada Objetos
a
y la programación convencional.
Binding es el procesode integrach dehmdonalidad,es
algo más qwe aquello.
conoado por 10spriigramadores comoria; “na
máks módulos van a ser combinados
paraproducirunaimagenejecutable,
asigmndo direcciones de memoriaacadamódulo, y
conigiendo las referencias &mas w n las direcciones de memoria corre^. Binding es el
proceso medianteel wid los operandosy los operadores dediferentes tipos se declaran porlos
programadoresy utilizan por los usuarios. Dependiendod
e
lmomento en quese reaiiza el binding
será la IIexibHlidad del lenguaje. Se conocen
diferenZes tipos de Binding cada
uno de ellos tiene
sus venlajas y desventajas.
Se realiza enla maproria de los lenguajes convendonates.
Este tipo de binding se realiza a
tiempo de compilacibn, es decir, owne mientras lor usuarios llevan a cabo la compilación desu
asi el usuwio y las herramientas ulilizadas en su programa son los responsables del
Ebding. E! !S!? de h!!?
?
?
q!!e,
?
e! !!S!!!!?
m
kng!! E
!
!
i*Pd!!
m:!EE$z!E
!
ER !E
figura 2.1 se ejempliffca que con
e& Tpo de binding
existe una relación entre el programador y la
wmputadoraya que hate, realizasus prognunacr.
chdigo,
**
El
E
figura 2.1 Bindingqyrgno
I
~arazón de utilizar binding temprano es para hacer programas robustos, que fundonen
de la mejormaneraposible,
Wando dedetedar
los e m s existentes
wando nohay
compatibilidad de los tipos de operandos dedarados por el programador en el sistema y los
ulilirados por Iw usiunrios. De estaforma se euita que ai enconbar incompadibiiidades de tiposel
programa enejewaón "abwte".
Este fipo de binding se realiza despuhs de que el programa se ha compilado, esto es.8
liempo de ejewcicin.Aquí solo se asoaa el nombre del operando al momento que se le pide, es
dear, al momento de ejecutarel código. Si el mde opemiones, que se enareen
el procedimiento que se ejecuta. se pueden redzar con l a s variables que se han dedmdo. no
existe problema El programador es el responsable del binding,pueses
éI uien dedara los
tipos de ddos a utilizarse, dejando sin
nsponsabiidad al usuario. La firrum 2.2 muestra como se
maneja la mmlnredónde sistemas, enla prognrmadón convendonalse enfatiza la relad6n enbe
P
el programador y su &digo; mientrss que en la Rogramadón Orientada a Objetos enfatiza la
reladnentre los programadoresy los usuarios que owpan SU código.
D
Rgura 2.2 Relación e m programador Y usuuio.
Ambos @os de Binding son diferentes herramientas para diterentes trabajos. El Binding
temprano es ideal para la construcción de programas donde se conocen m anterioridad los
tipos de datos a usar, de esta manera, cuando
no son wmpaliblet
con ios declarados por el
programador, al tiempo de compilación se detedan los errures. El Binding tardío se usa para
wando no se sabe deantemano los tipos de dabs que se van a utilizar, esto se detecta arando el
programa se eje-
y es entonas que seaborta el programa
La Programación Orientada
a Objetos nos ofrece la fadlidad de hacer el binding lo m6s
tarde posible. esto es, wando se eje& el sistema Como se puede obsewar en la figura 2.3, el
binding es el proceso en el que se combinan los componentes de diferentes programadores,
para crear un componentemayor el cual es utilizado por el usuario. Se manejala idea de crear un
programa utilizandoios C.1. de Wtware, quitando alguno de eslos si es necesario, sin afectarel
tundonamientodel resto de programa
”
Fig 2.3 La programaciin Orientada a Objetos m m j a el binding
Existen varias técnicas deempaquetamientodeinfbrmadcin
programadores la creación de unidades de krncionalidadgeneral, cada
que permiten a los’
de éstas puede ser
ocupada enapHcadones espedlictu por el usuario.
Estudiaremos algunas delas técnicas de empaquebmiientopormedio de un ejemplo, et
cual será un plograma que busca
únicas en un
texto.
mabras
- 14-
Esta esunade
las más eficientes tecnologías deempaquetamientode
&go,
inlroduddo por en el sistema operdvo UNK produce didigo pequeño, reutilizable en el que
cada programa diseñado es una
hemmimta de trabajo (le iilamaremos, como se hace en U W
lilgo).
Los filbos se c
o
m
u
n
m
i mediante el uso de conexiones, queton un canal de comunicación
a travis del wal la salida de una
filtro es recibido como la entfada del siguiente.
En el ejemplo que manejarnos, el programa, que lo ejecuta es de sob una linea y esta
fwmado por tres filtros y dos conexiones, su códiigo es:
tr -cs I ’ A-Za-zO-Y ’\ 012’ I sent -u I wc -I
El simbolo I denota untnmslado, los &S términos denotan los fifbos.
€1primer Altro es ir que conuierte los auacteres encontrados enel texto,
con la opción -
cs los caracteres que se encuentran fuera del intenraio a-z, A-2, 0-9 los comriclkr! en el carackr
fin de línea (7012) produciendo una lista de l a s palabras enamhdas en bytes, cada palabra
ocupa una linea esta lista de patabras (la Sd ~ primer
i
filtro) se proporciona programa sort
para realizar el ordenamiento, en este caso sort se ldiliza con la opción -u para eliminar las
palabras duplicadas, produciendo la lista de palabras únicas encontradas enel texto, las wales
sonconedadas y propordonadas como entrada al programa wc @ord counter)quien
se
enauga de amtartas.
Las herramientasproporcionadas como f i h s seencapsulande
manera ordenads
ampliamente documentadasy no requierenvohrersea compilar cuando se reutilizan. Esté método
de empaquetmiiento noes la mejor forma de encapsular kriormación. Pasan bytes a través de las
conenionesy el costo de rea#zar esto es m t p r que el paso de prrr6megOs e m dos subrutinas.
Más importante queel hecho de sólo poder clasificar cadenas debytes, es que no se cuentacon
todos los comandos para la realizaáónde cualquier programa.
Esta técnica usa a
ls bibliotecas de Ntinas y macros. Es la más utilizada por los
progmadores. Las rutinas y macros
están
convencionales,queproporcionanmediospara
hechas en
lenguajes
de
programación
la compilaciónseparadade
las subruthias
almacenadas enlas bibliotecas y para ligar su wdigo wando se ltewn a cabo spkadones.
En el ejemploque manejamos. quizá el lenguaje que deseamos owpar urente con
Amdones para abrir y cenar archivos. leer caracteres e imprimir resultados. El programa que
nosotros hagamos ya no tendría qucr realizar estetrabajo. lasfunciones ocupadas ya realizaron el
bindingwando heron creadas y estos módulos no pueden dilizane de nueva cuenBa porque ya
estan especificados para utilizarse en un
determinado ambiente. y fuera de este es imposible su
uso.
La limitación de no poder
owpar los pm#sdknientos de las librerias podria convertine en
un beneficio, si los pmcedmientos reatizados por el programador se ejecutan más
eiidentemente,aunque el costo quese fene que pagar por éstos es &o. al tratarse de
programasmuy largos.
La t¿cnka de C.t de solbvare es similar al de conexiones y #Iros de lJND(.en muchos de
los trabajos que se realiznn al tiempo de ejecución. pero diferentes en la Gficienda con que se
ejecutan, esta técnica es más rgpida Las elsbucturas de datos son similares a las usadas en las
ndinas de biblidem por lo que son defácil manejo.
Para realizar el ejemplo que hemos venido Irabajando
se utilizó el lenguaje Objedive-C.
- 16-
palabrasUnicas = [Set new]
f* se m a un conjunto=o'
llamado palabrasunicas *f
while(gdWord@uq != EOF 1{ /* lee palabrasa un buffer */
/* se ob(iene la palabraque se procesa */
palsbraAdual=[ ByleArrgr olrsbuf ]
[ palabrasUnicas add: palabrtlAdd 1 /* agrega al conjunta de palabrasUnicas
una
palabra
que
no
se
encuentre
contcnidaaún *f
1;
prinlf("El número de palabras
únicas es W\n'', [ pdabratkticassize I);
I* imprime eltamdo del conjunto de pdabraslkiicas */
Aqui se anexa una libmria que "lime
un par de C.I. de sothmre, #amadaSely By4eAnay.
ByteAmy implementauna d a e de o b j j s que contiene cadenas de bytes, Set implementa una
dase de objetos
de conjuntos, que tienentodas a
ls operadones deconjuntos wmo intcnección, unión. etcétera
fragmento de programa la mayur parte del código es un
programa ordinario esaito en lenguaje C. El cid0 M e y la inslrucdón prinU son insBucdones
Como seobservaeneste
de C. en lo qu(, difieren es enel contenido de /Mmensajes, encerrados en paréntesiscuadrados
(como[set
m).
l n m n e s de este tipo son agregadas al lenguaje C para crear ObjeWe-C.
Las palabras que empiezan con mayusadas son objetos. El primer mensaje del objeto llamado
Set realiza la operación new. que crea un nuevo conjunto*o)
y se le asigna a una variable
i
o
diiamada pdnbraiinicas que #miendr&todatl a s pdabras diferentes enconkadas en el texto y
cuenta con las operaciones caraderislicas de un conjunto- Todos la.C.1.de Soibvare h e la
capacidad de wear ob-s
semejantes a éI, la cual es usada para producir
instancias de dases.
La primer línea hace que el o&je&~
Set produzca un nuew ConEunfO (en Otrrrur paiabras,
creaunanuevainstanciadeladase Sed) y a esta instandale da el nombro de pdabmUnicas. La
segunda línea usala funabn ordinaria enC. getword0 para leer las palabras de unarchivo hasta
que éde termina. guardándolas enun anegio convencional de CataCEeres usados en C. llamado
buf. La tercer línea es
dm expresión de mensaje,
éSta
h a al
ob-
B y t e A m y en donde la
operación str, convierte la palabra que e& en buf en un anegk, de bytes.y lo almacena on una
variable loaal llamada palabraAdual.
La siguiendeMrucdón agrega las palabrasdderentes al conjunto pdabrasuniau, esto se
puede hacer porque los conjuntos no permite dupkacih de elementor. La íunción
prim se
encarga de imprimir et n h e m de palabras dikmdes encontradas. mediante la operación size,
del objeto palabrasUnbs de la dase Sat
- 17,
"..
.-
A..
Esta sdudtin atmm aproximadamente 10 iineas de &
g
o das 6 mostradas, made de
otras 4 líneas de dedaraciones que no
apwecen}. La m a g W de fieas es mucho menor que en
el uso de rutinas de bibliotetx (aproximndmente 100 líneas), pero es mayor que el uso de la
técnica deconexiones y filbos (de una línea). La versih d e l programa usando rutinas de
biMioteca se ejewtn más rspidamente, siguiéndole la de C.L de Soitware y la más l e n t a es la de
mexiones y Albos. Estas &essdudones representantres puntos deVssta diferentes, donde los
programadores podríancombinarlas para solucionar algún problema dela mejor forma posible.
El uso de e n a s de bibliotecas representa unexhmo de l a s soiuaones, el usuario es ei
responsable del binding al escribir cada linea
de código, este m6Wo es muy
cfiderrte,
arando se
ejecutan los programas, sonmuy rápiidos. pero el costo es tambiénmuy alto ya que son programas
muy largos. La técnica de conexiones y fifBas es el o h ex&emo de las solucionesde
empnquetamierdodeinformación,
los programam realizadas con ésta túcnica noson
muy
efidcrdcs. La knica C.I. de Soilwan! aprovecha las ventejas de las otras dos tdcnicas, como la
de conexiones y filbos, m necesita wtlver a compilar sus módulos paravohredos R diizar. Por
ejemplo, los C.I. de SolMare S& y B y t e A m y ya estaban wmpilados y ardrbados antes de ser
ocupados en esteprograma. El binding no o c u ~ ehasta que se va a hacer una aplidón, éda es
compilada,
y finalmente ejewtada Los mismos C.I. de Sallwwe utilizados aquí, sepueden
owpar para cualquier Otra
aplicación, sólo es necesario incluirlos en
el programa.
- 18-
En los sidemas orientados a objetos m se pmenta el pmb&maantwiw. esto se debe a
En esbs sistemas,en vez de tener dos tipos de enWadm que represenbn la k.1Qrmadirn
ysum~,selieneunatolaerr(idmdque~en8aa~,cMta~~~aloquesele
Rama objeto. La encapsuladh es la que permila que los objetos se man y funcionen wmo una
sola unidad, el objetose concibe como un enteen el cual estan encapsdados datos y
procedbnientos.
- 18.
.
.
""
,
.-
.""
__I
--
Por b anterior, un objeto representa tardo a la informacidn como a su manipulmcibn. Los
dabs del objeto se pueden manipular.pero es el
miarmo quien describe y realiza esa
manipuladdn, nopwmite a agentes externos alterar direccerrmnde los va&ms da sus dabs,induso,
un simple acceso para conocer la inlormacih que contiene requiere de su aartwiradón. Esta
caracteristica permite utilizar estos sistemas para realizar srrRware de aplicadiin. en el cud se
requiere ocultar datos e inbmaaon. como: compbdores. siskmas operedivos,ediires, etcétera
..
La manipulaciónde los dados por el objeto mismo es unade las diferenaas existe!nte e w e
este tipo de pmgramad6n y !a pmpramacibn comrenciond. En un sirterna corwenaonal kx datos
se pueden accesar y dawar sin ninguna re;rtriech, sí el programador ad lo dese& por ejemplo,
para ordenar un arreglo de númem, se msulEwt y se intmmbian de lugar los datos como se
requiera sin pedir autorizaciónde ninguntipo.
En los sistemas Mkmtados a objetos, arando se necesita de la mm@ukih de ciertos
datos, se le debe pedir nl objeto del cual forman park que lo hagq el objeb e
j
Wuno de los
proce-S
que tiene impiamenkdos,
en estos sistemas los pr0a-s
se m o w n como
m h d o s . Por ejemplo, diparnos que tenemos un objeb aamado arreglol. en el wail los dabs
son númerosenteros y los méwos para manipularlos son: nmmmmpf para ordenar los dabs
de menor a mqmr y rnayunaeniM para ordenados de mayor a menor. Si quemmor;saber wmo
q
u
e
M
a
’n sus datos ordenados
sanplcnente le pedhiamm al objeto que
ejecutara el mittodo menomayor-
asa?-*,
Los objetos son unidades independienbes,las wales interaduanentre sí al enviar y recibir
mensajes. El obj-
al cual se le envia el mens@ se le h
a receptor de mensaje. El seledor
de mensaje es la parte! en la cual se especilics.que es lo que
se quiere que haga el receptor.
Los mensajes tienen argumentos enlos d e s se espedtica al receptor de mensaje, el selector
demensajeyargumentosadidonales. si to requiere. Por eiempio.el menssje para que el objeto
arreglo1 se ordene deacendentemente seria: ( a r r e ~ Wnnywnrerror)
.
Si se agrega un nuevo mirtodo, llamado sum-,
el cual hará queel objeto amglol se sume OB0
objeto similar, digamos aneglof, la suma seria elemento con elemento,el mensaje para sumar
los objetos sería- (uregbl. semate. m@oi)
. Aqui el receptor de mensaje es ~ s g l o l .
sum& es el setector da mensaje y arreglo2 es un argumento adiidonal necesario para realizar
la acción pedida Debe quedar claro que la notación conecta para los mensajes depende de la
sintaxisespecificada porel lenguaje utilizado. La notación usada aqui
es una m m r a muy general
de escribirlos mensajes.
Cuando se enuía unmensaje, se bloquea a aquel quien lo e d , es decir. se detienen ws
aclivMades hasta que se redba una respuesta del objeto receptor. Generahnente la respuesta
consiste de valores que se pueden utilizar para ##iGbluar con
las a m e s detenidas, o una
respuesta deerror si es que no se pudorealizar r
a
t
i
f
la acción pedida cuando el
valor de respuesta no es importante la mqmría de los lenguafes regresm un agwhdor o
idenUficadwdelobjeto receptor.
El seledor de mensaje sólo indica la acción a reatizar y el código donde se espedfica
cómo realizar las acciones queda determinado por el ot@to receptor. Se ha pletandido hacer
una analogia entre Icu funciones delos lenguajes tmdidonalesy los mensajes. pero el nombre de
una función, además de espedlicar la acción requeridsc determina de manera única la parte de
~#mespondientepara~lat~,snunmensqieelsds~m,daPwminaningun
&¡go,
esta misión esth ellcMlwHdada al o m . En otad palabran. el sekcbr de mensaje
determina qué se debe hacer, m&sno cómo hacerlo. Por ejemplo, consideremos que se tiene
implementada la función m'z cuadrada sscprt enun sidema dab-procedimiento, esle nombre
idenbjiicademaneraú~ta~dQccidiqoquemmpu6alaraizw~denimsrosdapunb
f
l
o
t
a
n
t
e
, en un sistema orientado a objetos el selector de mensajesqrt espedka wdcamante la
opemdón l ó g h la pa&!
del código correspondientela detwminn el receptor d e l mensaje.
-21
-
El objeto receptor de un mensaje, verifica si puede implemenh?la d
n pedida por el
seldor. en una tabla donde se especili#m las cosas que éI sabe realizar. si la búsqueda Ljene
&cito se determina el wdigo correspondiente, esto es, se identyica al método que eje& la
acción pedida en caso wnlrario regresa en respuesta un auho de m o r indicando la
imposibilidadde ejecutarlo que se pide.
La~~~dcIafomrade~arlairrknm~deunobje(oessGmejanteala
desdipadn de una fund6n o un procedimiento en un sistsma de Iwl\warc! dato-pmcedimienb.
Esto reabe el nombre de m h d o en un sistema orientado a objebs y cada uno de ellos se
e j e a h en respuestaa algún mensaje.
Como sucede conun procsdknicnb,un método d e d b e una seamcia de acciones que
deben ejecutarse medante un proasador. Enestos sMemas
u11 m b d o
no puede H a m a r
diredamente a alro m
d
O
D
d
0
, esb como cansewencia de que los métodos, como los dados. no
pueden existir libres e indspcndienlss sino que m c e s i b estar formando parte de un objeto.
a m d o algún método requiere dela ejecua6n de dm mbbdo elnria un mens@ d objeto del cual
forma parte este ú#irno y Wene sus adividades mktdms el m¿todo s0l)CiEado m temrkre de
ejeartane.
web se
de dos cnSoques d-s.
un doque externo y ato inaemo.
EjdGmamente el objeto no es sino una unidad independiente que sabe realizar cosas, l a s wales
ejecuta si se le pide atrav6s de mensajes, pero no se tiene
idea sobre las aahnes que tomapara
cumplir con lo pedido. Por ejemplo, d pedirle al objeto arreglo1 se ordene ascendentemente,
Al
le ve
sabemos que realizadesto, peto no sabemos como lo hace.
Desde el punto de vista interno, el o
w se ve como lo fiace el proCpamador que
i m p l e m e SU
~ c
o
m
a
m
p
t
o
esto
.
r
es,i
se m en defa#e lot pasos necesarios para salisfacer la
acción s o W a Por el lado deadento, se le especiffca el objeto &NI
redzar a
ls cosas, esto
se hace por medio de los métodos.
Quien hace uso de un obj& mantiene un enloquG externo hacia éde y se conoce como
consmidor, porel conlrwio. a quien implements a los objetos se le h
enfoque interno haciahtos.
- 42 -
a proveedor y observa un
At ~ w u t de
o mensajes a Jos wales el
we40 puede responderse
conoce como SU
protodo. por lo tanto una vista adema no es más que el prdocolo dei ohjeto, pero
intemamenb, es m y pweddo a un sistematadidonal.
El ob@ tiene variables que se dicen son plkadaut y cuyo vabr desempsillan el papel de
dab, mierdnu qub los métodos desempaiian el papelde procedimiento, pero esta didhción sólo
se hace ¡-mame*,
e
r
a
g
G
m
a
m
e
n
b el objeto se wrtcibe como un solo enbe.
Las darres a s e m que sus instanch son se-s,
¡a única fwma para diferenciar a
unain~adaatra.asporelvslordesus~~conocidascxwrm~~sde
instancia Los métodos que un objeto tiene para responder a los mensajes eskm espedlicados
en w dase, pw b tando los objetos de una misma dase, responden con el mismo mGtOd0 a un
mensaje remejante. El valor que regresan en respuesta a un mismo mewaje pueda vwiar. de
acuerdo a los valores de sus variabks de instmcia, por ejemplo, d suponemos qus anaglol y
arregla2 son dos arreglos diletendes de númems. y se A enuía a cada uno de ellos el mensaje
para que se ofdenen. la respuesla obtenida no va a ser la misma. dado que se supone que lot
datos acwrtetridosson diferentes.
Cada uno de los o W j s existentes en el sistema es instancia de alguna clase. pues es la
únicaforma deconocer su wmpMtamient0 y propiedades.
- 23 -
La dase mun mdtodo muy parliwlarmedide sl cud es pod&
de ellay es esta la únimfomaen quese pueden agregar ~
mar una instancia
ohms al sisbma
J ~ V O S
Al momento
de crearse un nuevo objeto, generalrmnte, se Malizan sus variables de instancia con unos
valores predeterminados. de no ser as¡ las variables contienen "basura'', es decir valores
imprededbles.
un conjunto de nombres para
redetenciar a las vwhbbs de instancia del receptor del mensaje. PW ejemplo, al emriar en
mensaje mseledor rrrrywnemr al ohjeb ansglol para que se ordene descandenkmente,
los nombres rdemndana los d&s de arreglo1 para poderlo ordertar.
Los -os
3.5 Herenda
espedscadosen
la dase sevalende
Existen dos tipas de herenda:herencia lineal y herenda 110 lineal, esta idtima tambi6n se
conoce a m o herendamidliplc. La herendaheal amside en que una dase sob puede harsdar
cosas de una dase, esto es, una subdase no puede tener mbt de una superdase. Con herencia
múltiple una clase puede
heredar wsas de mhs de una dase.o lo que eslo mhmo, una subdase
puedetenerrrdsdeunasuperdase.
8m el CMlCcIpb de la herencia las danes se manlienen cwno unidades separadas sin
r e l d h n alguna y sin dependar ma de ota La herenda establece, por dearlo ask una reladón
m e ~ l a c u a l e s ~ d e f f n i r n u e w , ~ e n t e r m i n o s ~ d e a t rLaherencia
oya.
permile que se ssknplilique la desaipción de una dase. pues esta 4 e n e l a s cwacterís!icas de
una dase sup61/M, cuya descripción ya se debe de haber hecho. Con esto se
reduce una buena
park de -0.
pues la superdase comparksu código al heredarloa una subdase.
q
u
a
e
s
l instancias de la
Las instancias de la subdare se comportan en fwma simiCar a a
superdase. A d e d s de I n s cosasheredadas, la subdnxe puede agregar n
u
-
mhdos y
vwiabtes que la hará dijlinguible y más especializada con nspecio a la dase de la cual deriua
Porejemplo, supongase que se tiene ensistema
un
oriensado a objetos la dase males,en la cual
tn;r instancias son números reales, puta dase puede tener ku subclases radon.a?s e
bradorrdet que conlienannúmeros racionales e inadondes respedivamente,ademis la date
mciondss puede tener como subdase a enteros y esta dase puede bner corn subdases a
erteroposiliuo y eatemnegaWo. En padicdar fa dase
pwde agregar
mirtodos exdusivos de ella. aparte de conltner las c
aractdm defirridas para las *es de a
ls
cuaJes se ha wiginado. por ejemplo puede sumane. mtdlipli#me. r
e
s
t
a
m
,dhddiie, pwsto que
es posible desde la clase reaks. Rem además puede hacer cosas que las demás dates no
pueden, por ejemplo, puede agregar los mbdos factorialy f i b o n d para calcular el trrdorialy
el numera deb
i
f
o
drespeelivamente.paracualquiera de sus instancias.
En todosistema orientado a o b m existe una dase sin superdase, por lo cual ida es la
que da origen
a todas l a s demás clases y todas herendan SUE c a m " .
Cuando un objeto recibe un mensaje, busca el mbeDd0 correspondiente en la dase de la
cual es instmck si RO lo eMXlQLnbELbusca en In superclase. en In superdase de la superdase y m'
sucesivamente hasta enamtwlo o legar a la dase m&s superior (que no tlene superdase), es
hasta esto momento enel cual se reporta un error para el mensaje recibido.
- 45 -
4. OOPC: PROGRAMACI~N
ORIENTADAA OBJETOS USANDO
LENGUAJE C
En la programación eskudmda nos pregudamos: ic6mo es la transformadon de los
datos? y ¿cubs son las enbadas y salidas?. M
que en la program&
odea
objetos l a s pmgmbs que nos hacemos son ¿a&r
son las cosas con las que tab&@éy?iqd
espero que estas cosas hagan?. Manteniendo ede -que
se puede trabajar en un lenguaje
convendonal y simular estar trabajando en un ambiente orientado a o m , a q u í se muestra eso
utilizando el lemguaje C.
OOPC (Object oliented Rogtammkrg in C) es un meemism para la pmgramdn
orientada a objebs usando el lenguaje C esthdar. No es un lenguaje de pmgramach en sí
mismo.nitampow un prepmcemdor. Mas bien es una colecdbn de convendones y!écnkas de
programación que si se siguen, pueden propordonar los bsnefidorr de los Isnguujes de
progmneción Mientadaa objetos, benefla’os Wet corno: encapsukdh de dab, modul#izaciim
yhennda
AIrmrkdeOOPCseintMducanbrwn#p(osdeia~orientadaaobjGtoten
un conbxto pracrico y sendlo, en vez de complicar las m
a
s usando un nuwO l e n g u a j e y una
nueva sintaxis. OOFC tué desanollado por el proyedo Media Laboratory Meit d e l MIT para
realizar una interfase am el usuario. El uso de tbcnicas de la pmgmmadcin orientada a objetos
hacen al sistema Useilfácil de comprender y moclidi#v.
La “ a s e O W consista del stddvo base 00PC.H. la8 fundorwr; New y
Send,
y una
libreríadelundonesrnmejadoms de menses. Estos irllknos redbcnlolr memajese knrocan los
métodos correspondientes- cada una de las dases tiene un mamjador de mensajes.
-26”
).
El archivo base O6PC.H contiene definiciones comunes para % p o s de datos está.ndar en
O
O
F
C
,
We$ como fiffldones m8nejdoras de mensajes. dedaraciones y d e f b k h e s de
mens@s. Lasin&mCias de objebs se identilican por una reterenCao manejuh de tipo o w ,
definido en 0OpC.H. esta referencia se regresa cada vez que se crea una nueva instancia Se
debe usar este idenf#lcadw cada vez que se quiera hacer referenda al objeto, por ejemplo,
cuando se le emrian mens*s. Cuando se usa d manejadw de lip0 objeto, no es necesario que
la9aplicIIcionesconozcanIne~inbmadelob)eto.
- 47 -
Desgradadamente, OOPC requiere de gran habitldad p m enviar ditmmtes estructuras
deddos s m e R o r a l a m i u n a ~ n o p e m t i t e ~ d g u r r a f u n c i c i n q u e $ e e n # l l r g e d e
verilkw que et bloque este
e-s
para
un
mensaje
dado. Sin embargo la
convención de esdura de mensejes, combinado am !a esbudura de bloques de parirmetros y
resdados, brma una solucián satisfactoria sin tener que usar un prsproceaador. Lat comrench
en la escritura f a d i ¡ ia v
e
d e l código y et cwnpil&dw de C verilica los tipos de d a
campo dentro de los bloques de pwirmebos y resultados.
Un ejemplo:
C#Mn
Superclase
AL
Figura
HLinea
Rectangulo
La jerarquía dedases en la figura4.1 mueslra las superdates y subdases usadas pw el
ejemplo Miorma La dase Radrrnqrlo induye la deCniciÓn de las a m r d e ~ Wde dos
Hlformr, que inplemerrfa el dibujo de una cam, es una subdase de
Rcdangulo. Y usa l a s propiedadesde este para ddnk sus bordes, además
agrega propiedades
para redizar los ojos y la boca (deWdos como keas horkorWes).
esquinas
opuestas.
Los mensajes y métodos con respedo a los bordes de UiForrrm: son heredados de su
superdase ReeEWgrlo;otros mensajes son manejados porlos mhdos locales de MiFonna
En WFC, todos los objetos son subdase de la dase C o n r m o a .
.
/* crea screen *l
screen = New (Screen):
-30-
El ejemplo MForma muestra amo se pueden esaibw procedknientos que maf@ubn
objetos sin conocedos a prevhente. Por ejemplo, la lunción stack-on-top rtansgla objetos
arbhrbs, que comprendanlos mmajes MSQ-tWRlE, MSG-SURy MSQ_MUEYE.
Similarmente la función reditnija-figurns etnia MSG-DRAW a los oben la lista de
display. sinsabernada acerca de los objetos que al# se enarentnur. En realidad se pueden
codifiawy compilar estashciones antes de escribirlas dams de o b m s que manipularan.
Se debe induirel atchivo base O W al principio decada archiuo fuente (S), ademb de
los arellis de propiedadesde
Losarchiws
necesarios pwa bnplsmantar la propiedad de la herencia.
ladase.
Listado 4.2 La cadena de hemcia para la dase Rcrcbrgulo.
- 32 -
.p propordonan los mecankmos
I* archiv0:ligura.p
propi8dadeS de In dase Figura (subdase de Ja dase Common) *I
#indude " m ~ p "
f* heredapropiedades de la clase Coannua */
I*no tiene propiedades locales */
I*
archivo:mmm0n.p
propiedades dela dase Cwnmon*/
I* Common es la dase tope, no es subdarede ninguna otm *f
- 33.
.
" "
-
"
-34,
-
El lklado 4.2 mucdra la eslrudum de dabs Recbangulo_obfect los
OIYH~OSdeesta
eslwdura se induyen de el sreh#o RECTANGILE.P, la primer dedwadikr del ardrhro es otro
ltindude del r#cclivo 8HAPE.H. que con&neIns propiedadesde la superdase de RccEarrgulo.
El listado 4.2 es una selección del archiuo de dehición del objeto Rcdmgrrlo.para
~lacadenadeherendaqwunmensa/enoreconocidos~siuna~aade
RedMptdo no puede reconocer un menseje. la macro Base lo pawá a la superdase. F m
parawr si puede cumprender el mensaje. 8 F@wano puede decodldicar el mensaje. se le pasa
a la dase Common. si esta nu puede comprender el mensaje, seregresa un e m .
-36-
Si un objeto no tiene un m k d o para un mensaje puede heredar el de
SU
superdafe y
producir un resultado. En el método de inicialitadrin. por ejemplo, prknero el objeto hereda el
m h d o de su superclass y luego inicialira
sus propias pmpiedades (dados).
T~ajara~~sdeC,conunenfoqueorientadoa~~tsnerunagnrncantidad
dewdigo~~iaprincipal~tadcestoeslahcrenda~~qucse~etqque
existen muchas COSM en a
ls waks el programador debe
de ser muy cuidadoso para evitar
problemas enel funcionamiento del sistema realizado. PWejemplo. debeponerespecial edendón
en el ambiente de encadenamientoy que l o s parhdros que se pasenai objeto sean amedos.
Ed08 son detaHes que un lenguaje orientado a obj& puede manejar. evhndok al programador
esta tarea La wnt;a)a.de usar un lenguaje convencional es que no requiem que se trabaje y
aprenda un nuew lengwje, y su cridiio es cornpdbh con algunas Iibreriinrr y herramientas ya
establecidas que pueden usarse.
5. LENGUAJES DE PROGRAMACldN ORIENTADA
A OBJETOS
5.1 SMALLTALK-80
El sidema Smslltalk-80 se cwnprpne de Obj8bS que
rcejbirmema@s.
h h W W f h intaradunn d
errviw y
El programador implements un sistema pata describir l o s m8nsajBs que va
a
enviar, édos describen lo que hay que realizar.cuando llegan al receptor.
Los mensajes se describen por -shes,
las wales son seamaas de WZLdGres que
matdiem la s W t d e l lenguaje de pmommch smasllalk-tu). La m p r e s h de un mensaje
describe su receptor,
seledw y arqUmcn(0s. Cuando UM expresh se evalircr. el mensaje que
describe se trasmb a su receptor. Exiden tres tipos de mensajes: unwios. bhwios y dam, a
conlinuen se dan cuatru ejemplos de expresiones que describen un mensajea un objeto :
1. 16raiz2
2. insda+lncfemenQo
3. figura moveTo:
nuwaposidon
4. U r s p l o a t I r r d l C e p u e ~
Los mensajes unarios son aqwrllos sin argumento8 y que tianwr un solo selector (selector
unario). El primer ejemplo es un mensaje UnaQiO con seledor ndzZ que pide al recoplor su raíz
cuadrada
Los mensajes Mnarks son aplellos que lknen un wgumento y un selector (deun c d d e r
o cadcier doble) llamado sekdor Mnnrio.Fbr ejemplo. los símbolos comunes de arihnka (+.-
,*,o
son seledores binados, al igual que algunas operadmes de comparach que se
representan con caráctw doble (S=, <=, >S O ) . El segundo ejemplo es un mensaje binario con
sebdor + y ayo arqumento es irersnento.
- 37 ..
.
,
..d.*
Los mensajes dave sonaquellos
que tienenuno
o más argumendos, donde cada
argumento estaprecedido por una dave (una dave es und
i
d
c
a
d
o
rseguido de dos pl#ltos). El
tercer ejemploes un mensaje dave
con
un solo argumento,con
seledor TO: y
argumento es nueuaposicion. El cwto ejemplo es tambiin un mensajedave, solo que con dos
argumentos: indice y elemento. y wyo seledor consistt3 delas daves a t y put Cuando se haMa
d e l selector de m mens@ daye mvarios argumentos, las palabras dave se cormtenan. Por lo
tanto,
el selector del wwto ejemplo es atput
Los receptores y argumentos enlas enpresiones de mensajes se describen por medio de
nombres de vwiables. los wales se pueden escribircon litsr#les,ya sean enbros o cadena Una
literal de enteros es una sewenaa de dlgitos que puede ser precedida por el signo menos (-) y
una cadena es una secuencia
de caraderes enlre comillas, por ejempkx 'elsiistcma ' .
Cuando se emria un mensaje, 6ste invoca un méWo determinado pw la dare del
receptor. El mitodo i n v o c a d o regresa un resulbsido (que es un objeto). Este resultado puede ser
usado como un receptoro argumento pwa ab0 mensaje.
Un ejemplo donde se usa un mensaje
u
n
& como receptor de a$o mensaje Mlwjo es: 5 hdotJd tdz2 al primer mensaje en este
ejemplo es d seledor unario fadmid m i a d o al objeto 5. p o d e r h n m b ai resulbado de este
mensaje se le e d a el mensaje unario raizf. Un ejemplo de un mensaje binariohaciendo el papel
otro mensaje binario es: ¡
n
i
d
o+ incremento * 2 el resulladodeenuiar el
mensaje + m a ~ r n e n t al
o objm inicio es elreceptorpara e4 mensaje binario * 2.
del receptor de
La evaluación de mensajes unarios dieneprecedendasobre los mensajes binarios y é*s.
a su vez tienen precedenda sobre los mensajes dave, esto quiere dedr que, cuando en una
los unavios semn emriados primem.
postehrmeth h s bbrarios y finalmente lot mensajes dcmre. Se pueden usar paréntesis para
CIhMbjbl el orden de enduadón
o panmedrar explid6amenb el orden de la e v a h a c h .
misma expresión aparezcan b s tres tipos de mensajes.
- 38 -
Una expresión de mensaje en cascada describe una secuencia de mensajes a enuiw al
mismo o b m , consiste de la descripción de un receptor seguido por varios mensajes separados
por puntoy m a c). Por ejemplo en:
se envim cuah mensajes al objeto printer, los seledoma de l o s cuadro mensajes son
nuevdinea escribe:, espada y escribe:, respediuamente. Si no se dlizara la expresión en
cascada. lo anterior se tendria querealizar ulilizando arm eqmsiones de mensajes.
Lafigura6.1.1 muestraelmodeloWiparaunaciase
Nombre de la clate
fig.
5.1.1 Modelo bbico para una ckse
El nombre de la dase debe empezar w n una letra ma$suf4 y los nombres de las
variables de instancia con una letra miniswla Cwno un ejemplo en la !¡gum5.1.2 se muestm el
modelo b6sim para la dase Punto, cuyas instancim representan un punto en un sistema de
wordtanadas de dos dimendones, se Gienen dos wíabks de n
ix que representa la
coordenada horizontaly y que representa la coordenadaverlioal.
Nombre de la dase
~~
?unta
~
Nombres de lasvariables de instanda
X Y
fig. 5.1.2 Modelo básico para la clase Punto
-41
-
Un m h d o consta de tres p e s :
- Un patrónde
mensaje
-Algunasvwiablestempor&les
- Algunas expresiones
Estas partes se separanpor bwmsverticales ( 1). a
ls expresiones se separan por un punta ( .) y la
ÚMma expresión puede ser precedida por una flecha hada arriba ( ), de ser esto Último el
A
mensaje invocador del m b d o h a el valor de esta expresión, en caso contrario simplemente
toma el valor del receptor.
El prnbrindeun mensaje consta de un seledor y nombres para los argumentos. Por
ejemplo en la figura 2, en el método parael teledor+, d p d r h de mensaje es + un-,
las
variables temporales son
sEllllx y sumY, y hay tres expresiones.la idlima precedida por una flecha
hada arriba.
Cuandosetienenseledorescon
argumentos, el patrón demensaje
del midodo
##respondiente contend& además- nombres de argumentos pan referendar los del mensaje
redbido por la in-q
en el ejemplo anterior m se uliliza para referenciar a
purrlotqJerior.
A contkwadón del patrón de mensaje, el método puede contener algunos nombres de
crean. J así lo
requiere.un conjunto de Wablas a#xtsadas por los nombres de variables iumporaks y que soh
variables tempornles entre b#rar:verlicafes. Cuando se ejecuta un nrritDdo se
existen mientras et método esta en ejecución. Despuh de la segunda barra veltical, el mdlodo
contieneuna
searenda deexpresionesseparadaspor
searendalmente durante la ejecución-
- 42 -
puntos, las cualessonevaluadas
Resumiendo loanterior, hay #respasos a seguir cuando la inlstanaa recibe un mensaje:
l . Encon#raraquel método wyo patrón de mensaje tiene
el mismo seledor que el mensaje
recibido y crear un conjunto de variables para referenciar a los argumentos.
2. Crear un conjuntode variables temporales.
3. Ewaluar secuendaknente las ~ r e s i o mdsel midodo cwrespondiensa,
EnUII mbtodo se pueden war las siguiinkts dases de variables:
- Lasvwiables de instanciadel receppM
- La seudovariablese11
- Los argumentos del mensaje
- variables temporales
- Variables de dase
- V a r i a b b globah
self es una seudovarinMe que se encuenkadisponibleen
cualquier m b d o y es
importank porque seusa para hacer refmncin a la instanda receptora del mensaje,en
ejemplo mendonado 8W hacereierencia al o
el
w wnlro. self se considera una seudwariablt
porque SU valor se puede leer como cualquier otra variable, pero su valor no se puede cambiar
mediante expresionesde asignación.
Los nombres para los argumentos y wrriabies tempwaleb se dedaran en el código del
método y sdo existen durante la ejecución de éste, los argumentos al creme a u t o m k ~ ~ ! n t e ,
asumen los valores de los argumentos del mensaje, enbmto qd lasvarhbks bmporales se crean
sin irtiaalizarse( su valor se determinacon asignadones).
-43-
Nombres de las uariabks ti8 clase
~
kktmadul ifhmcwbrz idmkdm3.. .
"
Mensajes y Métodos de dase
fig. 5.1.3 Moddo completo para una clase
-u,
.
.,^
Una dase &
n
evariabks de dase, compartidas por todas las mrtancias. sus nombres se
d e d m en la entrada "Nombres de las variables de Clase", como se observa enel modelo
completo para una dase de la figura 5.1.3. Aun wando sus valores pueden cambiwse medimte
asignaciones. generalmente se &dan wmo constantes. su valor se inieializa mando se m a la
date y porteriomente kuinstancias utilizan este valor sin alterarlo. Por ejemplo* en la figura 5.1.4
se obsenm cómo la variable de dase pi se inicializa con el valor 3.14159, esto se Wiza en el
método que calarlael 6ntade un circulo sin modikcar su walor.
Las variables plobaies las comparten bdos los objetos, sus nombres y vdores estan
contenidos en un dicdoftario global llamado smJ(hlk Por ejemplo, las clases que componen el
sistema son wdores de variablesglobales wyos nombres son los de la date.
Nombre de la Clase
Superdase
Mensajes y M¿todos de dase
Punto
Objed
Mensajes y Mitodos de instancia
circlrioArea I r I
r <-- self radio.
Api*r*r
fig. 5.1.4 Modelo c o d p t o para la clase Punto
-46-
5.1-4 Herencia
La herencia es una de
los conceptos más importanks en un sistema w
e
im a objetos,
por la que es primordial tomarlaen cuenta Sma#taskno permite la herencia midliple (una dase
hereda propiedades de varias dases), sin e m b w nos permite una herencia heal (una dase
hereda propiedades de una sola darse).
Debido a que el modelo básico para unadase no toma en cwwidemd6n la propiedad de
la herenda, las dases se desaiben como si fwsran independientes una de oba En el modelo
completo para una dase de la figura 5.1.3 se toma en cuenta la here-
por b que l a s dases
guardanunaciertarelachenbeellas.
Ladasehereda l a s propiedadesde a q w h dase que se enawnba en la enbada
(krpQtdase, debido a esto la date se considwa como si fuera una m o d i h c h de una dase
superior (la superdase), y a esta que hereda mhdos y variables de instancia. se le llama
subdase.además la subdase puede agregar a lo heredado nuevas variables de inshcia y
métodos propios.
Cuando la instancia redbe un men- se busca
el miitodo awmpondiente primero en
si no se encordro) en los m k d o s heredados de la
superdase. Si aun noseenwenba,se
busca en la superdasede la superdase y así
sucesivamente hasta encontrarlo o hasta legar a una dase que no tenga superdase, si es esto
los de la instancia y posteriormente (S&
úllimo se reporta un error.
La única clase en el sistema queno tiene superdase esObjedt ésta no tiene variables de
instencia y sus métodos lo heredan todas las demás dases. Una cadena de supendase es el
conjunto de dases ligadas por una dacibn de superdase. La enCada Superdase espedlica el
liado inicialde la cadena desuperdaset parala dase.
I
- 47 -
5.1-5 Metadstet
En unsistema orkntado a o b j s aún la dase mhma se considera como un
objeto y por la
tanto debe exis!ir una dase que la describa este Up0 de dase se lama metadase.
La dase, por lo tanto, &ne sus propiasvariabks de instancia.que son las que describen a
sus instancias,y puede responder a mensajes de inicialiración y mod#icu&h. En parliarlar una
dase puede responder al mensaje new para crear una nueva instancia {este mensaje ademds
M a l i z a lasvariables de butwrda),
el objeto Ril se dNza para indicar un valor no inidrdizado.
Generalmente cada dase daza un protocOlo d h n t e para crear sus inslandas
inianlizadas. For ejemplo, en el método correspond(erde al selector + de la dase Punto, (vease
laiigura5.1.2) es:
Una razón importante parah e r metadase esque Uenen un #M/unfo espedal de métodos
para cada clase y mensajes para ¡niidalizar variables de dase y nuevas i n s b c i a s . En la ligm
5.1.3 los Mensajes y métodos de intbrrrd. estan asodados w n la dase, mientras que los
Mensajes y nrbtodos de d u e se asocian con la metadase.
5.1-6 Rutinas prinritivat
La respuestaa algunos mensajes pueden realizarse con
una rutina prim#hnc escrita enel
lenguaje de implementación de la máquina. en vez de evaluar la expresiikr en un método. Los
métodos indican la presencia de tal rutina al induir <prinridhre> antes de la primera expresión,
taks rutinas son muyusadas parainteraduar mlos dispos#ivosde entradn/salida de la máquina.
Un ejemplo de un méWo primitivo es el mensaje new a a
ls dases, el cual regresa una nueva
instanciadel rece*.
new I 1<primitive>
La rulina primitivasiempre produce un res-,
si existen tituaciones en
l a s wales no es
posh producbun resultado, el método conoencha además algunas exprertiones, estas seevaluan
cuanda la rutina no puede responder exhsamente
al mensaje. Par ejemplo, en el mensaje con
seledw + enviado a $maWiiger :
+ unNanmro 1 I <pWHve>
sell error 'error al realizar la suma en 8 m h b g e #
se emrid un reporte de error, si la rutina falla al producir un resultado, esto serla wando, por
ejemplo, el argumento emriado no es un Snsrllinteger.
5-1.7 VariaMes de dase indexadas
Algunos obms licnenun conjunto de variables de Wancia que no timen nombres y qua
solo pueden ser accesudas por mensajes r8mns de indices. Los objebs hdexados se usan para
implementar las dases que representancolecciones,
Mes como arreglos y cadenas de
caraderesEl mensaje que aceeta a estetipode variables tiene setedores
at y atput . Por
ejemplo lista at1 regresa la primer variabk de inshcia indexada de
y lista at4
putelemento almilcena elemento como el valor de la cuarta variable de instanda indexada de
lista Los mensajes at y atpwt invocan rutinas p r i m ¡ ¡ para caqp o ahacemar el valor de la
variable indicada Los mens:pries at y atprt estan delbidos en la dase Object, y por lo tanto,
pueden ser compredidospor todos b s objetos, sin embargo. solo ciertas dasescrean instancias
con variables de instanciaindexadas.
-49-
Ejdsien dos estruduta;tde control:
- La ejecuciónsewenaal de expresiones en mun¿ M o
- El emrb de mensajes quehwo#motros mhdos que evenhtaknswregresanvalms
Todas las &as estructurasde control se basan en o m s ll#nados bloques, que sonuna
secuencia de expresiones.Estas expresiones se delimitan por puntos y puedan estar precedidas
por uno o más identihcadores. los wales se h
a
ncomo los argumentos d e l bloque y se separan
de las expresiones por una barravertscsl. Los bloques estan deiimitadospor cordretes.
En d sistema Smallt;tdk se lienen dos tipos primi#ms de
#wI$o(
: itTme:ilfslse: que
p e m k una s c W h condidand y whileTrue: y vrhilefahe: p m ¡kmdones condidonafes.
Por ejemplo, en :
cok
india <--O ]
Wake: [ indke <-- cola m d ]
se ejecuta la expmsión del primer bloque si el receptor es vcmhdem y se ejecuta el segundo
bloque en caso contrario. El método parawhileTrue: ejecuta repetidamente un bloque m
e
im
el vabr del receptor sea verdadero y en WhikCFdse: se ejemientras d vdor del receptor
sea Wso, ejemplo:
rmdim <= tinrftel w~le~nre:
[ sew proceso: ~ t bat
r
india <" iRdiee + 1 ]
Las clases con variables de instancia Wexadas pueden implemenhr un mensaje con
selector do:que toma un bloque cum0 un argumento y lo ejecuta una vez para cada variable
indewada, un ejemplo del uso de tal mensaje es:
tida do:[ :elsnwlrto(se#proceso: elenrento ]
El mensaje se implcmantnriade la siguiante forms
do: unflloqrre I indice I
indice <" 1.
rmrdice<* SSY dzsl whikTne:
[UrrerOque value: (self at hiice).
indice <-- indice + 1J
-m,
.
*&
El sistemaSma#talk induye descripciones de dasa para object Class, Message,
Compiled"
y Ccmlext cuyas subdases son BlockContexty MeUu~dContext.
Se tiene el
objeto nil que es la
instancia de la dase UndefinedObjed El sistema induye además
des#ipdones de dasequesopor&u~estructurasde
datos. la dase Number e s p d c a el
irnida
protocolo apropiado pam los objetos numéricos y tiene subdases como Flor,t Fraction e
inaeger, de esta ÚHima existen subdases
como SmdHntegers y Largeintegers .
La dase CoUeclion especika elprotodo apmpMdo para representar coleccionesde
objetos,aquí se induyenlas subdases Bag,8St O ~ c d l e d i o nlJnkedLí+z
,
MappedCoHedion, EIortedCdlcrdion,
e IndexedCdledion. Esta ir#krm propordonael
protocolo, para objetos con variablesde instandaindexadas,y tiene l a s subdases 8bhrg y A m .
-51 -
5.2 OBJECTIVE-C
Objectbe-C está considerado como un lenguaje híbrido,
ya que su formación se basa en
un lenguaje de programación orientada a objetos. como es
el lenguaje Smalltalk-80, y enun
lenguaje que mantieneel enfoque tradicional de datos
y procedimientos, como esel lenguaje C.
En éI se agrega un nuevo tipo de dato:
el objeto: y una nueva operación,el mensaje. AI igual que
en Smalltalk-80, en este lenguaje no se hace
la distincibn entre dderentes dases de objetos a
tiempo de compilación. sino que
la verificación se realiza a tiempo de ejecución.
En Objetive-C se trabaja en forma similar
al compilador de C, estoes,seeditanlos
archiis con un editor detexto, se compilan con su compilador, se almacena el código binado
resultante utilizando una libreríay se ligan con un ligado?eshdar. Posteriormente la prueba y
depuración se realiza como normalmente
la realiza el usuario del lenguaje C.
Debido a que Objective-C es un lenguaje de programación híbrido se puede programar
completamente enC. ignorando el enfoque orientado a objetos,o se puede programar siguiendo
más al estilo de Smalltalk-80 que Cde
,una tercer forma de programar es combinar
características
de ambos enfoques.
Los lenguajes orientados a objetos no permiten manipular los datos o la información
directamente, esto se tiene que hacertr&s
a de mensajes, sin embargo enlos lenguajes híbridos
lo anterior puede ignorarse,
y m s a r directamente la información privada de los objetos.
Esto es
lo que hace importante a este tipo
de lenguajes, teóricamentedibiles.
5.2-1 Identifitadores de objeto
Los objetos se pueden manejar mediante
el tipo dedato id, o identificador de objeto, que
permite determinar de manera única
al objeto que se quiere manipular- Estos identificadores se
almacenan en variables localesy se pasan como argumentos en mensajes y llamadas a función,
ademhs de poderse retener en variables de instancia (campos dentro de losy en
objetos)
algunas
otras dases de estruduras de memoria
I
- 52 -
Los objetos quedan determinados por su identificador, pues 6ste contiene su direcci6n
fisica a memoriaLa construcción deid se basa enla dedaracióntypedef de C,para dedarar un
apuntador a estructuras(ios objetos), después de esto
los identificadores de objeto se tratan como
cualquier otro tipo estivldar C
de
.por ejemploel tipo c h a r , int float etcétera.
int contador
I* dedara un entero*I
id Esteobjeto
I* dedara un identificador de objeto
*/
En las intrucciones anteriores se dedaran dos variables, unainl
dey oba
tipo de tipoid, la
variable contador se usará para retener un
valor entero y la variable Esteobjeto para retenerel
identificador para alguna dase de objeto. Una variable id ocupa una cantidad fija de espacio,
pues es de
tamaño fijo, mientras queel espacio ocupado por un
objeto difiere para cada dase.
Un consumidor es aquel que hace uso de un yobjeto
solo sele permitever el identificador
más no al objeto mismo. tiene control sobreel identificador, le puede asignar valores, copiarloy
retenerlo en estructuras permanentes de datos,
tal como puede hacerlo con cualquier
otro tipo de
dato enC.
5-23 Mensajes
Una vez que el objetotieneunidentificadorsepuedehacerusode
éI atravésde
mensajes, los cuales son 6rdenes para queel objeto realice algo, quien emria un mensaje debe
detener sus actividades hasta
recibir una respuestadel receptor.
La acción a realizar queda determinada por aquella pafb del mensaje conocida como
selector de mensaje. El objeto tiene asociada una tabla donde se espedfica las cosas que sabe
realizar,estatablaseconstruyecuando
se define al objeto y no '.esusualquecambie
verificar
dinimicamente. Cuando se recibe un mensaje se hace una busqueda en esta
tablasi para
puede implementarla acción pedidapor elselector de mensaje,si logra identificaral seiedor en
la tabla,obtiene un apuntador a un procedimiento quees el que ejecuta la acción pedida, este
procedimiento se conoce como método
y es el código de una funubn compilada
C. en
- 53 -
Todos los objetosimpfementanlosseledoresdeuna
fbrma esthdar parapoder
centralizar el mecanismo de selección en una función "mensajera", llamada
-msg la wd compila
los mensajes para enviarlos; los argumentos de esta función especifican el identificador id del
objeto receptor.el selector de mensajey argumentos adicionalessi la acción pedidalo requiere,
por ejemplo:
respuesta = -msg(unRelceptor, 'unMensaje", argumentol. argumento2. - - -)
la sintaxis de Smalltalk-80 para
La sintaxis paralosmensajesesunamodificaciónde
hacerla compatible conel lenguaje C. Por ejemplo en la expresión: unConjunto = [ Set new ]
se em's el mensaje unario new al identiticador de objetoSel. para crear un nuevo conjunto,la
respuesta aesto se almacena en
la variable unconjunto.
Las expresiones de mensajes se permiten en aquellas partes tal como se permite hacer
una llamada a función en C, por ejemplo, pueden aparecer como argumentos en llamadas a
funciones:
prim ( 'El tamaño del conjunto es %d \n'. [unConjunto size] );
en expresiones condicionales: ií ( [unConjunto isEmpty])
/* si el conjunto es vaü0 *I
en ados: while not([unConjunto isEmpty]) I* mientras el conjunto tenga elementos*/
o en algunasotras expresiones:
[ unConjunto
size
1;
/* el receptor
una
es
variable
*/
[ algunaFunüon(argumento) size 1
; i* el receptor es una función*/
[ [Set
new]
size 1;
i* el receptormensaje
un
es
*i
Existen mensajes unarios
y mensajesdave. Se consideran mensajes unarios aquellos que
no tienen argumentos
y mensajesdave los que tienen uno
o más argumentos. Ejemplos:
mensaje
seledor
[ unobjeto doThis ]
donis
[ unobjeto doThis:argl]
doThis
1unobjeto do:arglwith:argf ]
do":
argumentos
no tiene
argl
argL arg2
- 54. -..
.
tipo de mensaje
unario
dave
dave
5-2-3 Objeto constructor o fabricante
Al inicio de una aplicadon no se dispone de ninguna
dase de objeto: por lo tanto Io
primero que se tiene que hacer es creados para poder trabajar. La creación de nuevas instancias
se logra al enviar el mensaje new a algun objeto, esto nos enfrenta a un problema aparentemente
grande pues inicialmente no se tienen objetos. Para salvar este problemael programador debe
concebir un objeto inicial para queel cornpilador lo construya y sea puesto en memoria por el
cargador, esto debe hacerse para cada dase existente en el sistema. a este objeto inicial se le
llama objeto consbudor
o fabricante, pués mediante
éI se construyen nuevas instancias,
Los objetos construdoresal recibir el mensaje new crean una instancia de su clase con
variables inicializadas y regresan un identificador id comorespuesta, la semánticaparaeste
mensaje es similar en los distintos sistemas.
El compilador en cierta forma garantiza el
que
código
binario contiene un objeto constructor
por cada una de las distintas dases compiladas.
La única diferencia entre un objeto constructor
y un objeto común esla forma en que se
construyen,entodos
los dem6saspedossonsimilares.
El funcionamientodeambosest6
controlado por el programador. Los nombresde los objetos conadores sealmacenanen
variables globales mediante las wales pueden ser accesados, esto se implementa usando
dedaración extern del lenguaje C.
Las convenciones siguientes se han adoptado
respedo a los nombres de los objetos:
a) El nombre de un objeto
conshdor debe empezar con mayúscula
b) El nombre de un objeto debe describir
la dase de objeto que produce.
c} El nombre de una instancia debe empezar con
minúswla
Considérese a un objeto, llamado
Pluma, de las convendones anteriores se conduye que:
4 Pluma es un objeto fabricador, que
b) produce nuevas instancias la
dedase Pluma
a continuaatinse muestrael uso de este objeto:
extern id Pluma;
id miPluma;
miPluma = pluma new];
- 55 -
la
- 94 -
I
1
Bun
ep-u!
om ap
i!nbu~s!p
alqisod uamy sod-
solsa uasoprrua3rrwp s a r o p so( %youraw ap o p w d anbolqnsapoquap o d w apsodg
X sarqwou sows!w sol X ohpw ows!w la uawdww amp Bun ap soprreisu!m1 anb pas 0
Para poder wear una nueva instancia se deben
wmplir las condiciones siguientes:
4 Debe exisfir el objeto consbudor de
la dase.
b) Debe existirla parte compartida para las instancias.
si no se cumple alguna de ellas no es posible construir
la nueva instancia
Existe un detalle muy importante que hay que tener presente, esto eslaque,
parte compartida de
la instanciay la park privada del objeto constructor son
el mismo bloque de memoria
5.2.6 Mecanismo deherenda
La herencia es una herramienta para organizar, wnstnrir y usar dases reutilizables; sin
esta las dases se podrían
ver como unidades independientes. Conla herencia es posible definir
nuevo soffware. comparandolo conalgo ya conocido, esto implica una gran simpiificación porque
reduce el número decasas que deben especificarse.
La implementación de unadase se describe en un
a
r
c
h
i
v
o
descriptor de dase, que esla
unidad de modularizaaón en un sistema orientado a objetos. éde contiene el nombre para la
nuevadase y el nombre de sudase superior, conocidacomo la superdase. Sin el concepto dela
herenda setendriaquehacerunadescripcióncompletade
descripciónlaproporciona
la dase.con éde# partede la
la superdase, lo cualpermitedefinirunanueva
dase como
modificación de otra
ya existente enel sistema
Por ejemplo. supóngase que se quiere realizar un cornpilador, necesitamos definir una
dase para representarel nombre y la dirección a memoria de cada identiticador, a esta dase
la
llamamosSimbolo y la podemos consbuir como subdase de
ByteAnw que contiene un arreglo
los simbolos, pero ByteAnay nomantiene el vaior
asignado a ellos, porlo tanto, será necesario introducir una variable adicional
la dase
en Simbolo*
esto se hace mediante
la dedaracih:
de bytes,conestosepuedenmanejar
= Simbolo: ByteArray (unsigned int direcdonblemoria)
deestaforma
la dase Simboio contiene todo lode
direccionMemoria
- 57 -
ByteArray más la nueva variable
Las subdasesson una versión especializada de sus superdases.
lo mal implica agregar o
modificar información,pero nunca quitarla.rfsto explica porqué las subdases contienen más cosas
que las superdases. Por ejemplo, mediante Simbolo se identifica a un objeto constructor de
comportamiento similaral condructor ByteArray, pero el espacio requeridopor una instancia de
Simbolo esmayorpuestieneunavariableadicional,
direcdonMemoria estolashace
distinguibles una de
otra
En el a
r
c
h
i
m descriptor de dase se dedaran las variables agregadas a las variables de
instancia heredadas dela superdase, esto determina la organización de la parte privada de las
instancias ai definir un nombrey un tipo para cada una de sus variables;
el espacio para ellas se
asigna a tiempo 'de ejecución.
La subdase no sólo puede diferir
tie lasuperdase por las variables agregadas. sino que
dedara en el archivo
también puedeinduir nuevos métodoso reemplazar los heredados. esto se
descriptor de dase dentro la
dedefinición parala parte compartida de las instancias. Esta
k e a se
crea fisicamente junto con su tabla a tiempo de compilación, pués es aqui donde se les asigna
espacio.
En el archivo descriptor de dase
se dedwan variables y métodostanto de instancias como
de objetos constructores,al compilar la dedaración de una dase
se m a un C.I. de S o h u e que
se puedeJigar dentro de una apticaaón.
La herencia establece un ligadode dases que termina hasta encontrar una que carezca
de superdase, hay una soladase deeste lipo. Por ejemplo, Sirnbolo es subdase de6yteAnay
y ésta a la vez de Array, la cual es subdase deObject que es la úni- dase que no tiene dase
superior, por lo tanto, Object es superdase de todas demk.
las
Las variables dedaradaspara
la subdaseseconcatenan
dedaradaspara la superdase,estaconcatenaciónempiezacon
al finaldelas
variables
la dase suprema Object
Además de heredar las variables de instsnda. la subdase hereda losm h d o s de instanda, por
ejemplo, toda instancia de
la dase Simbolo hereda automáticamente los métodos de
ByteArray;
así mmo los de Array y Object
- 58 *.
Existe una tabla para
la parte compartida que contiene
el nombre y la implementaaón de
los métodos dedarados en
el archivo descriptorde dase, la superdase se encarga de establecer
un ligados610 visible parala función mens@er& esta función
lleva por lo menos dos argumentos,
en el primeroseespecifica
al receptor y en el segundo al selectordemensaje;
el primer
argumento se usa para encontrar los datos
privados del receptor, su parte compartida
y su tabla de
métodos e implementaciones.
Si en la tabla encontrada concuerda el nombre de algún método con
el selector de
mensaje, se identifica una función a ejeaJtar, en
caso contrario se prosigue conla búsqueda enla
tabladelaspartescompartidasde
las superdasesligadas,estocontinúahastaencontrar
el
método requeridoo hasta que noh a p mis superdases en donde buscar, de ser esto uftimo se
reporta un error en donde se especifica que no se comprende
el mensaje.
La herencia en los objetos constructores es similar
al de las instancias,al igual que éstas,
tienen una parte privada
y una parte compartida que es una cadena de subpartes heredadas.
5-2.7 Métodos
En el archivo descriptor de dasc se definen dos tipos de métodos: métodos para
la
instancia y métodos parael objeto constructor de la dase, estos métodos se almacenan en dos
tablas diferentes, la tabla para el objeto fabricante est& en su parte compartiday la tabla de la
instancia se encuentra en la parte privada. Estas partes las construye el compilador al generar
código binario para las deliniciones de los métodos hechospor el programador.
En cada definición de método se indica:
a} Si es un método para
la instancia o un mbtodo para
el objeto fabricante, esto determina en que
tabla se guardará.
b}El nombre delm h d o (el selector), los nombresy tipos delos paámetrosy el tipo de respuesta
que regresa
c}La implementaubndel método. que se escribe
wmo a
lsfunciones ordinarias de
C.
Los métodos y a
ls funciones ordinarias enC. son m y similares en wanto a su definición
pues ambos tienen un nombre, argumentos formales
y una implementaaón independiente, sin
embargo existen algunas diferencias cuanto
en
a su forma de trabajar
- Las funciones sellamandirectamente por su nombre,los métodos se llaman indirectamente por
mensajes.
- Los métodos
deben direccionar
los datos privados del objeto que recibe
el mensaje.
- 58 -
5-2.8 La variable Self
En la definición de los métodos se indica
si éste regresa alguna respuesta
y de quétipo es,
o si por el contrario no regresa ningun vaior. Por lo general los métodos siempre regresan un
valor, dado que se a adoptado la convención de que si el método no tiene nada importante que
enviar regreseel identificador id de la instancia que
lo invoco. esto se hace mediantela variable
self que identificaal objeto queinvocó al método.
Los campos del objeto se describen en la estructura: strud -PRIVATE, en la cual se
induyena
lsvariables de instand4sell se usa implicitamente cada
vez que en el metodo se hace
referenda a una
de estas variables.
5.4.9 Métodos para los objetos fabricantes
Los métodos fabricantes se definen la
demisma forma que
los métodos para las instancias,
la única diferencia es que empiezan con la mama + en vez de la marca
-
que idenZifica a los
métodos de instancia
Cuando semenciona el nombre de algun método que no est& definido en
el archim
descriptor de dase, se supone que éste se hereda.
Por ejemplo el método new lo heredan todos
losobjetosfabricantes,
y estádefinidoen
el archivodescriptordedasepara
Objed a
continuación se muestra su código:
= Objed -
--
+new{
.
id nueva0bjeto;
nuevoObjeto = allocNilBlock ( self -> dsSizlnstance.0);
nuevoObjeto ->¡sa = serk
return (nuevoObjeto);
1
La funciónallocNilBlock le asigna memoriaal nuevo objeto, la cantidad esta especificada
en el primer argumento,y se obtiene medianteel operador tizeof de (2
sized ( strud -PRIVATE
1: /* inicializa.el campo dsSizlnstance*/
- 60 -
Lacantidaddememoria
y el valor paralavariable
¡sa de nuemObjeto quedan
determinados por self. AI compilar una dase se inicializa una variable en la parte privada desu
fabricante con un valor que indica el espacio que requiere para contener
a las variables de
instancia de esa dase.
52.1 O Super
Existen situaciones en las
wales una expresión de mensaje no es suficiente, para resolver
los problemas que se pueden presentar mando se tienen dos mhdos am el mismo nombre,
esto es, un mbtodo es heredadoy el otro es de la propia i n s b a a Por ejemplo, supóngase que
se quiere imprimir un mensajecada vez que se wee un nuem simbolo, esto se a‘-
de hacer
mediantela expresión: + new { printf runMensaje \n7; return [sell new]; }
esto se meteria a un
üdo pues sew aún apunta a el objeto fabricante Simbolo, se trata de
remediar lo anterior enviandoel mensaje a la superdase de Simbolo:
+ new { printf (“unMensaje \a”); return -Array
new]; 1
pero esto hace que el objeto fabricanteSimbolo produzca arreglos de bytesy no símbolos, esta
situación no se puede remediar mediante expresiones ordinarias de mensajes.
La soluüh la da un nuevo mensajero conocido
como super:
+ new { prinU (“unMensaje \n”); return [super new]; 1
Super esurn medio por el cual se cambiael camino que sigueel mensaje al llamar al mensajero
super. Mientras que enel mensajero nomal el primer argumentoes el receptor delmensaje, en
-tnsg
super en el primerargumentose espedfica la estructuracompartidaen la cualse
empezm’a a buscar ai selector. y se determina al objeto receptor del mensaje a través
del valor de
self en el método ermiado paraindagar dentro del registro del objeto que el
envi6
mensaje.
-61 -
5.3 c++
5..3..1 Antecedentes
C++ est6 basado enel lenguaje C,de tal forma que se considera un superconjuntoél.de
y unagrancantidaddeéstees
C++essemejanteallenguajeoriqinalenmuchossentidos
justamente C, pero sus facilidades para definir los tipos de datos son mucho más poderosas,
ademas de soportar abstracción de datos
y ser m b rico en la definición de estos,C++ cuenta con
dases, cada dase induye operaciones en los datos de éSta cuenta con una función llamada
constructor la que se usa para
la weacibn de datos
de una dase, también cuenta con una función
destructor queseencargadedestruirlosdatoscreadosenesta
dasemando ya noson
necesarios. C+*retiene el poder del lenguajeC y flexibilidad parael manejo con la interfaz de
hardware-solbarey sistemas de programación de bajo nivel.
La efiaenu& economía y poder de expresión del lenguaje C se mantienen en C++. Sin
embargo,
C++
provee la plataformaparasoportar
la progmacibn orientadaaobjetos
y
problemas de atto nivel de abstracción. C.++
es un lenguajemás fuerte queADA para la creación
de programasorientadosaobjetos
y es;similaraModula-2ensusimplicidad
y soporte de
modularidad, conservandola eficiencia y mmpactación deC.
C++ es un lenguaje hibrido.Los paradigmas de programación orientada a objetos puede
ser explorados para producir una soluaon
ai problema empleando las facilidades que este estilo
de programar ofrece, adem&C++puede ser tratado como un lenguaje de procedimientos, que
contiene algunas contrucciones adicion&es mejores que
las ofrecidas por C. En la p r a d i a el
software realizado conC++refleja tantolos paradigmas de la programación con procedimientos
como ios paradigmas dela programdn orientada aob@os. Esta duaiidad enC++presenta un
cambio muy especial paralos programadores que empiezan.
No solamente es un nuevo lenguaje
para ser aprendido. también presenta una nueva
adternah para la solución de problemas.
C++ posee caracteristicas de BCPI y Simuia67. La notaah de subdases (derivacibn de
dases) y funciones virtuales se toman
de Simula Lacapacidad para el manejo de operadoresy la
flexibilidad deincluir dedaraáones desdesus primeros puntosde aplicadh son reminicensia de
Algol 68. e++, como otros nuevos lenguajes de programación,representaunaevolución
y
refinamientode algunas delas mejores maderiskas de los lenguajes previosél.a
C++ fue desarrollado por Bjarne
Stroushp porun periodo de 5 d o s en los laboratorios
Bell a principios de 1980. El Dr. stropstrup desarrollo este lenguaje con
el fin de soportar la
escritura de algunos problemas complejos de simulacion
los wales no se podian resolver conla
herramientas que ofrecía Simula67. En Julio de1983, fué probado por primeravez en proyectos
tal maneraque&tefuera
compatible con C.Ya que C++ conserva la integridad de millones de lineas del &digo de C.
mantiene la integridad de las extensivas librerías y herramientas que se han desmollado para
éste, y proporciona un gran incentivo para que los programadores de C aprendan e++.Este
lenguaje se diseño para el desarrollo de software en gran escala reduciendo errores en los
sistemasy proporciona mayores soportes para los esfuerzos de multiprogrwnación.
deprogramacióngrandes.Cuandosediseño
C++.sehizode
El aspedo más significativo del lenguaje C++es su soporte de los paradigmas de
la
programación orientada a objetos.Ofrece: una gran flexibilidad enla solución de problemas así
como la reutitizacióndel sothareque ya se tiene desmollado.
5 - 3 2 Definiciones
5.3.2-1 Secciones de una dase
La construcdondeunadaseen
C++ nossitvede
vehiwlo para la a b s k a d n y
protección de los datos. Las clases tambiin son la unidad bbica que permitela reuiiiizadón det
s o h e . En la construcción de una dase se distinguen 3 secciones:secciÓn privada. sección
protegiday sección pública.
Seccibn pública: Los dabs y ?unciones miembros declaradas en esta secdon pueden
ejearfar al
ser utilizadas por cualquier aplicación. Normalmente las operaciones que se pueden
realizar un sistema estan especificados en esta sección, es exclusivamente por medio de estas
sistemas.
funaones que pueden construir dichos
Sección privada:
Los datos 'y funaonesmiembrosdeclaradasenestasecciónno
pueden ser accesadas fueraella
de
Sección protegida: Los datos; y funciones miembros declaradas en esta secci6n no
pueden ser accesadas fuera de excepto
ella,
por sus subdases.
- 63 -
5.32.2 El operador ::
Este operador se utiliza cuando hacemos la implementau6n del método de una dase y
permite teneracceso del valor de unavariable que se
ha dedarado cornolocal en otro mirtodo.
Las funciones virtudes dan la facilidad de deadir que acción se va a realizar dado el
mensaje quese reciba, ésta decisión
es tomada por el sistema
Los datos de la secd6n p h d a no pueden ser amsados por cualquier otra aplicación,
esta restricciónse puede rompersi dedaramos una dasecomo friend. A
l realizar esta dedwadón
!a dase que fue dedaradacomo amigq ya puede accesar los datos y funciones miembros deia
dase.
El concepto de dase en C++es una extensión del concepto de estructura (struct) de C.
Una dasees un tipo definido porel usuarh.
Por ejemplo:
dass complex(
public:
double re.¡m;
1
;
- 64-
-. . _,..,
,
~
1.5
..
, .-
Hay que notar que dass se ha utilizado en lugar de struck y la etiqueta public se ha
añadido, indicando que todoslos miembro:s dela dase declarados despuisse pueden %ccesar
sin restricción. A menos que esten espedicados como public, los miembros de la dase sólo
pueden ser accesados
por funciones con una relación especial
81 la clase, aquellas funciones que
hacenreferencia a losmiembrosde
ladase y funcionesamigas
(las wales sededaran
anteponiirndolesla palabra friend) dedaraldas dentrodel cuerpo de6sta
Siguiendo conel ejemplo anterior. le añadiremos restricciones de accesolos
a miembros
re e
m
¡ .añadiendo como miembrola dedaración de una función:
dass complex(
double re,im;
public
void puto;
1;
Una dase puede tener miembros que sean kmciones. Dando una
dase del objeto o un
apuntador ala dase delobjeto. Los miembros funcionesse accesm utilizando operadores como
el punto y laflecha (* y ->) del mismo modo quelos miembros dedatos. D e n h del cuerpo de un
miembrofundn se puede hacerreferenda a otra dase de miembros sin utilizar operaciones de
acceso a éstos.
Se definiráput como la salida de un
bato. que es un objetode tipo complejo y se mostrará como
se utiliza
complex ::puto complex es una dase de puf
tipo
main0 {
complex n;
n-put
1;
Notamos que los miembros
re e ¡m se utilizan dentro deput sin operacionesde acceso a
miembros, estos nombres hacen referencia alos miembros de la dase del objeto utilizadopara
accesar la tunción, que en este ejemplo
es n.
- 65 -
En cualquier miembro función, si el miembro de una dase es referido a esta park del
objeto sin un operador deacceso. se entendera queel miembro referido a estaparte del objeto
fueutitizadoparallamar
la función.En
CI
ejemplo, la limada n-puto imprimirk n, dgo no
inicializado que se operó automáticamente
el wal contenía basura.
Se añadiráotro miembro ala funci6n para realizar
la inicializaaón:
dass complex{
double re,m
í ;
public
complex( doubler = O; double i = O 1;
fre=r;kn=i);
void puto;
1
;
Unmiembrofuncióncon
el mismonombredesudase,esun
tipo especial llamado
constructor. Unconstructor se utilizaparainicializarautomáticamentedasedeobjetos.Un
constructor al tomar un argumento define una conversión
del tipo de argumento
al tipo de dase. La
dedaración del constructorcomplejo demuestra ulras dos MLI8cterskas de e++:argumentos
predefinidos por "default" y funciones en línea.
En e++,
los tipos de argumentos se dedaran dentm dela función, en la cual, dentro del
parhntesis, se tiene unalista de argumentos, como dedaraciones prototipo de argumentos dentro
de la propuesta porel estandar ANSI C.Una dedaración de argumento en C*+ tambih puede
especificar unvalor por omisión siendo llamado
a la vez de una función que
W a m si~ la función que
llama emiteargumentos. El constructor wmplep posee valores por default que pueden ser
llamados con 2. 1 ó ningún argumento {los argumentos ausentes son llenados con el valor de
default cero). Puesto que se pueden llamar w n un sólo argumento, éste construdor puede ser
utilizado paraconvertir un sólo operando doble a tipo
un de unadase/dasificaaón del objeto.
- 66 -
El cuerpo dela función parael wrrtnrctor aparecece dentro dela delhición dela dase.
Definiendo unafunción dentro de unadam es una forma de indicarleal cornpilador que deberá
intentar insertar la función dentrodel código objeto en lugar de estar generando una función que
llama. Este proceso es llamado una expansión en línea Para pequeñas fundones. la expansion
el línea se guarda en el tiempo de ejecución de una llamada externa. ahque requiera mucho
espacio de código. Además, porque
la sen&ntica de las funciónes que llaman son preservadas, se
pueden evitar errores que frecuentemente la
enutilización de preprocesadores que simulan
ellla
desarrollolexpansión en tinea. Unaalternativa para especificar una función en linea es utilizar la
palabradave en linea en
la dedaración dela funcirin y definir fa fundtin posteriormente.
de nuevacuenta el main:
Ahora queya se cuenta con un constructor, tornaremos
del constructor
Un objeto n de fpo complejo est& declarado. Puesto que los argumentos
la dedaracibn, los argumenlos por defauRse a z a n . El condrudor
no han sido provistos en
debierá iniadzarse, n-re al primer default del argumenta del mnstrudor y n.im al segundo.
Cuando el miembro de la hmaón n.pld0 es
lqmado,
re e irn en la definidh de
complex ::put#, redefine a n.re e n-¡m. La salida ser&
{O.OO,O.OO).
Ahora se agregará una dedaración de una hlnción
a la dase complex
dass complex{
double re, irn;
public
complex( doubler = O; double i = O );
{re=Kh=i];
void puto;
friend cornptex
operator +(cpmplex. complex);
1;
- 67 I
"
La úttirna dedaraaón en la dase complex dedar& un sobrecargado de el operador +
para tomar dos operandos complejos y regresar un valor complejo. Ai haber estado dedarado
corno friend, de tal forma que tieneacceso a miembrosparticulares del tipo complejo fuera del
mismo miembro existente. Un operador ftlnddn es aquel que puede ser llamado utilizando su
símbolo en notadón normal y así como loa operadores estandar
+.-,*,
%,
1y { ), pueden ser
hechos para aplicarse a la dase del tipode operandos. En estecaso, con la M n i a ó n apropiada
del operadorsuma (+I, la suma de dos objetos complejos, Gl y C2, podrian ser escritos como
Gl +(X!.
Los operandoscomplejospueden
ser utilizados en operaciones aribnktiticas en su
aribnétiws. Esteejemplopodriaextenderse
a una
impiernentaaón en un paquete de aritmsca compleja Usar código podria tener una interlaz de
es!e paquete, a través de funciones de acceso púbiico.
extensión con tipos
de
operandos
El siguienie listado muestra un programa completo en C++excepto por las funciones de libreria
estártdat pt"
dass complw
double re, ¡m;
public:
complex( double r = O; double i = O 1;
{re=cim=i};
void puto;
friend complex
operator +(complex, complex);
1
;
wid complex:: puto {
pinif( "( sg5.21, ?$5.2f)'tn'', re. ¡m );
I;
complex operator +(complexGI, mmpIexG2) I
return compiex(Cl.re + cZ..re,Cl-¡m + C2.im);
1;
/ I argumentos
por
main0 {
defauR
wmplexn;
n.pd0;
/* dase de objesOs declaradas m diferentes nombres para la especificaciónde argumentos
del mnstrudor
*/
complex a = complex( 3,411;
complex b = complex( 3.4.11
;
complex c = 1;
n=a+b+c+42;
n.put0;
1;
La
salida de esie ejemplo es: ( 0.00,O.OO)
(49-O, 8.20 1
- 63 -
5-33 Derivación de dates (Hwenda)
Juntocon los datos privados. miembroshinuones y constructores,lasdaseadanal
programador otra característica poderosa para definir tipos de datos: la derivación de dase o
herencta. un camino para la construcción de una dase
a otra. Una dasede deriuadn puede ser
pasada como una variación de un tipo de base general. A través de funciones virtuales, varios
tipos de derivan de la misma dase base. Una dase base puede declarar fundones miembros
que pueden redefinirse con una variación
de significadospara una dase derivada
El siguiente listado muestra un
ejemplo sendllo de una dase derivada La dasenode es
unalista Ngada deelementos del mismo tipo. Ede contieneunapuntadora
una cadenade
caraderes y un apuntador ai nodo siguiente de la lista. La dase numnode añade un detaile de
información numitrica para el contenido trássico de un nodo. La dase node es muy simple, no
contiene nadaram excepto ía dedaración:
virtual void puto; fa función pat esta declmda para
ser virtual, lo que significa que cada dase derivada puede definirsesucon
propiaversicin de esta
función base.
dass node {
public
char *info;
node *next
node(char *in}
{ info = in; next= NULL 1
;
virtual void puto;
I;
dass numnode: public node{
public:
inl num;
numnode(char *info, int n} : info
{num=n);
void puto;
1;
void node::puto {
1
prinlf( '%\n". info1
;
void numnode ::puto {
printf(
%d\n",
info.
num
);
1
majnQ !
node *npl, *np2;
npl = new node("Fndas'Y;
np2 = new numnode( "Manzanas", 10
1;
npl -> puto;
np2 -> puto;
npl-) next = np2;
np2 -> next = new numnoder Naranjas",lZ);
np2 -> next -> next i new node(iiVetabel");
for(;npl; npl= npl -> n d )
npl -> puto;
-71
-
Ahora se tiene una dase derivad&
{
dass numnode: public node
public:
int num;
nwnnode( char*info, int n): ordo)
{ num = n 1
;
wid
1
;
puto;
node es derivada dela dase base después de los dos puntos seguidosdel nombrede la dase
derivada. La base dela dase e& dedarada p i r b l i lo wal significa que los mienmbms públicos
de la base dela dase pueden seraccesados como si fueran miembros dela clase derivadaPor
ejemplo:
Notamos que m es del tipo derivado pero que info, es un miembro público del tipo de
base público que puede ser
accesado por el operador punto. El miembro de dabs simples
dedarado en la dase derivada esm.
Cuando hay espacio resewadopara un objeto numnode,
debiera tener espacio
p m todos los dabs de la dase base, y espacio adicional para
datos de la
dase derivadaLa primer parte de unobjeto de una dase derivada e-a
'
para un objeto de la
dase de base. Lo que nos trae al constructor nurnnode: un constructor de una dase derivada
debe inicializar la parte de la dase de base así corno también !a par& de la dase derivada El
constructor de la dase derivadaIlamm'a d constructor dela dase base. Los argumentos parala
dasebase e&
dadosdespuésdelasdospuntossiguiendo
la lisiadeargumentos
conatrucior de la date derivada Así un constructor numnode dando losargumentos:
numnodef'lnformacion BaSica",lu);
del
La funcibn main también introduce unn u m operador delC++:new
main0 {
node *npl, *np2;
npl = new nodel "Frutas"J;
np2 = new numnodel"Manzanas",1O );
1
new crea un objeto
del tipo especificado
y regresasu dirección. Siel tipo tiene un contrudor,
Qste
es llamado pava que se iniaalize el n u m objeto weado con los argumentos especificados. La
primeravez que se invoca new crea un nodoy asigna su direccicin al apuntador npl, la segunda
vez crea unnumnode y asigna sudirecdtin ai apuntador np2. La funaonput es accesadaa través
de npl y np2:
main0 {
node *npl, *np2;
npl = new node( "Frutas'?;
np2 = n e w numnode( "Manzanas", 10);
npl -> puto;
np2 -> put#;
La salidaserix
Frutas
Manzanas: 10
Lallamada npl
-> put#accesa la versión
node! :: puto mientrasque np2
->
puto
accesa la versión nurnnode ::puto. Esto se debe a que npl y np2 son apuntadores de
tipo node.
np2 apunta a un objdto creado
como un numnode, donde ¡a versión dela dase derivada deput
two que ser sustituida dentro dela dase debase.
- 73 -
La salida completa para
el listado anteriores:
Frutas
Manzanas: 1U
F&s
Manzanas: 10
Naranjas: 12
Vetabel
Para mostrar como pueden set utilizadas las auactwistic~sde esdos lenguajes, para la
resoluaón de problemas reales, se presenta otro ejemplo: La implementaáón de una tabla de
símbolos, para el compilador de C++.Para claridad de presentaaón debieramos simplificar un
poco. perola esbudura generai de
la soluahn pudiera ser utilizada para
detarrolar una M a de
símbolos para un compiladorC++.
de
El alcance en C++ es bastank diferente ad dmce en C. El alcance en C es
escencialmenteunbloqueestructurado,
esto es.un
nombreestadefinidodesdesuprimer
sparia6n hasta el iinal del bloque enel cualfue definido. La aparicion de un nombre de un bloque
interior oculta todos los nombres con
el mismo identificador definidoen bloques exteriores.Para
el próposito de manejar simbolos,
el archivo mismo puede ser considerado
mmo un bloque. Una
tabladesímbolospara
C puedeimplernentarsecomouna
pila Ai finaldeunbloque,estos
nombres definidos enel bloque se d a e n de la pila Dos caracbristicas de dases relacionadas
w n C++.
funciones miembrosy dases derivadas, danal G++ mucho enriquecimiento dealcance a
la estructura así como al C. El limite alcance de una función miembroes el alcance de la que es
miembro. Por ejemplo:
int i:
dass C {
inl E
fO{ i = 11;
1;
La función miembrof asigna al miembro i de la clase. no a ¡a vaviable global i.
El siguiente fragmento es equivalente
a lo anterior:
int i;
dass G{
int i;
inline fg;
1;
G::fO;{i = 1 1
El alcance de una función miembro puede ser su dase
o no. El alcance de una dase
derivada depende de su dase base.
Por ejemplo:
dass 6 { pubtic int ¡;I; /* miembm dela dase base */
int i;
/* variable con alcance en el archivo */
void go
{
/* variabte local a g */
inti;
dass Dl;public B
{
f(){i=l}
1
;
1;
dass 02:public 6 0 ;
h s dases B. O1 y O2 brmm una dase jerkquica en la cual B es el dcance incluido tanto
de Dly 02. Nhmos que el alcance incluido paraDl no esta al alcance de la función g. De este
modo la hrndcin miembrof de Dlasigna a la de ,i un miembro dela dase base.
del C. a
ls caracieflskas del
alcance original en C++ pueden producir uncomplejo alcance de la estrudura. Se puedemostrar
Encombinación con el bloqueesBucturadoheredado
cómo las características dela programación avanzada del C++pueden ser utilizadas para llevar
a
cabo una soluciónnatural y eficiente B este problema
Como una primera apronimaáón a
la solución del problema, se representan
los tres
elementos de alcance (global dase y funden) m o t a b l a s separadas para que mantengan una
estrudura monoliticamente sencilla Cada tipo de se
tabla
representarivl wmo una dase separada
con funciones miembrospara identificación e inserción de nombre:
dass btab {
public:
name *insert(c
h
*);
name *lookup( char* };
1;
dass dab {
public
name *insert(char* );
1;
name *lookup(char* 1
;
dass Aab {
name *root
public
void *parent
name *insert(char* );
name *lookup( char* 1
;
1;
En cada caso. el argumento para la inserción o función lookup es un apuntador a un
identificador y el vaior que regresa es el nombre de una tabla de simbolos. Para ilustrar este
ejemplo considemos que un nombre va a ser una
etlnrduracon un apuntador
a su identiticadory
posiblemk a cualquier
dm información.
Habiendo parkionado el problema en tres casos separados, se puede implementar
la
semhtica de cada tabla como mas nos convenga. por el momento tendremos que desarrolladas
de maneraheurístia que indica que
la mejor manera de implementar una
dase tablaes como una
list& la tabla globalwmo una simpletabla de hashy la tabla de funcionescomo una tabla de hash
más compleja que guarda
las dicciones del alcance del bloque dentro de
lafunción.
- 76 .", .. .
,
h
L
La tabla global podríaestar estnrdurada de la siguiente manem
dass btabI
static name *t[256 3;
int hash(chW );
public:
name *insert(char*r)
name *lookup(char* );
1gtabie;
Se cuenta con la libertad de cambiar el código de esta implementadón sin afedrv el
código que usamos enla tabla de simbolos. En este punto
se tiene una representaudn completa
paraunalcancedado
pero aúnserepresenta
el alcanceinduido.
Esto sepuedehacer
d e d m d o un miembro encada dase que apunteai alcance induido. Sin embargo,ya que cada
tabla fene un fpo único. este apuntador debe sercapaz de hacer referendaa cualquier tsbla de
los tres tipos de tablas. Por esta
razón. debemos decidir usar un apuntadorlaafunción. que este
puede aceptarla dirección a cualquier fpe de objeto:
dass dab {
public
name *insert(cbW );
1;
name ^lookup(char* 1;
Esta implementadón tienedes\rantajas por a
ls dos siguientes razones. Primero, mientras
el apuntador parent es parte de la implementaüón de cada tipo de tabla. éste debe estar presente
en la parte pública de la definición dedases para queotras tablas puedan accesarla. Segundo, no
hay restricción sobreel tipo de apuntador que debe residir legalmente parent
en
- 77 !
>
Una dternativa podría ser definir una ciase
de tabla genera¡ desde la cual se puedan
derivar las otras:
class tab
proteded:
tab *parent.
1;
dass gtab :public tab { . . . I ;
class dab : public tab{ . . . 1
;
class flab :public tab { . . };
~
Se usa unsegundo Cpo deresltriccibndedatos(ademásde
posición del apuntador parent en una seccion protegida de
los datos privados). La
la dase base, solamente dases
derivadas de tab podrían accesar a ésta. En adicion, puedo que sólo apuntadores a tab o sus
dases (públicas) derivadas pueden ser directamente asignadas a
parent esto daunamayor
garantía de queel valor de parent podría ser legitimo. Una medida adicional de encapsulación
y
seguridadesespecificaruncontrudorparacadatipode
tabia Esta espediimcion podría
asegurar que cada vez que
se crea una nueva tabla hsta estada propiamente inicializad&
dass dab :public tab
i
name *root
public:
”.
dab{tab *tp = agtable)
parent = tp;root = O;
1;
1
Por ejemplo, se definiij c;n constructor de tabla que tenis un solo argumento: un apuntador
a la tabla parent. Si este argumento no se proporciona se usa la tabla global. Guardando la
dirección del alcance actual, utilizamosla variable globalcun-tab para apuntar ala tabla actual.
Este es un apuntadoral tipo de dase
base, el cual permite estar apuntando a cualquiera
de los tres
tipos de tablas, con esto se cuenta con un marco de trabajo
íawrable para nuestra tabla de
simbolosen e++. En wdquier momento, el estadodealcanceconsisteenlastundones
ademis de la tabla global. Las
individuales y lasdasesdetablasenlenguajeensamblador,
relacionesentreestastablasserepresentan
por susapuntadores parent Cuando unnuevo
alcance se lleva a cabo decimos que está entrando en
éI, se crea una nuevadase de tablay se
inicializaéSta con el constructor.Por ejempio,si la dase es derivada la iniciaiizaaón ocurre en
el
alcance dela dase base, ask
current-tab = new dab( base-tab 1;
se puede wear e insertar una nueva
dase de tabla y definir su alcance. Si la dase no es
deriwada,entonces
sus apuntadoresestanen
la tablaglobal{sinhacer
caso dequesea
le>cicamente anidada en una funcion uotra dase). En este caso simplemente se crea una nueva
dase de tabla que podría originar
el constructoral ser invocado con su argumento
por omisión:
current-tab = new dab;
de organizacidn de símbolos durante
la compilaaón, una
En adición a un método general
tabla de símbolos debe dotaral resto del compilador con Ntinas auxiliares para estar trabajando
con símbolos.
Por ejemplo, se quieretenerunarutinageneral
lookup queenconfm6 el nombre
lmce adud. Se empiezacon la tabla
correspondiente dandoel identifieador enel contexto del a
actual y se buscal a s tablas a las que apuntaparent se hace sucesivamente hasta que un nombre
con el argumento del identifitador que
se busca es encontrado. desafortunadamente, no se puede
impfementav este esquema de manera directa porque es imposible determinar desde
la tabla
adual cunent-tab o el apuntador parent el tipo detabla a buscar. Sin conocimientodel tipo de
tabla es imposible inwcar correctamenteal miembro dela función lookup.
Una posible soludbn
a este problemaes insertar en su
propia tabla código que identifique su tipo:
- 79 -
I
d a s tab {
protected:
enum { G,C,F 1type;
tab *parent
1;
La rutina general lookup se puede implementar de
la siguiente manera:
name *
lookup( char *id) {
name an;
for( tab Y = curr-tab; t
t = t ->parent)
switch( &>type){
case G:
n = (( stab "19
->lookup( id1;
break;
case C;
n = ((dab*)t)
->lookup( id);
break;
case F:
n = ((flab *)t)
->lookup( id 1
;
bre&
I
if(n1
return n;
1
return O;
1
Este m h d o noestanmaloeneste
caso enpartiwlar,perosusoiucirinpodría
dificilmente describirse como unasoluciónnatural.Enunasituaciónandogatomadapara
invocación de funcionesmiembros de inserción y unaqueesobligatoriadebajodeeste
Itr
aprovechamiento para que siempre identifique explcitmente la correda función de inserción
antes de la invocación.
La solución queaquí se muestra hace uso de
l a s funáones virhides. Solamente insertando
declaraciones de funciones virtuales en la dase base, podría causar que todas las fundanes de
dase derivadas con e¡ mismo identificadory tipo sean virtuales como:
dass tab {
protected:
tab *parent:
public:
I
virtud name *insert( char 1
:
*
*
virtud name *lookup(char );
Reescribiendola Ntina generalse pueden aprovecharlas ventajas del uso de funcionesvirtuales,
que es muy simple:
name *
lookup(char * )
{
name *n;
fur( tab *t = Mlrr-w;t;
t = t -> parent1
if(n=t->lookup(id))
relum n;
return O;
1;
- 81 ,
.
Aunque t es del tipo apuntador ala tabla base, la invocación dela funaón virtuallookup
puededeteminar al tiempode ejewurjn el tipo de la tablapara
la consultaqueseesta
realizando y entonces invocar la funüiin miembrocorrectaEnunasituaciónsimilarlas
invocaciones se simplifican.Por ejemplo:
wn-tab
-> insert(¡@;
d
u
a
,
lya sea que éste sea global, dase o
insertará un nombre con
el identifimdor id en la taMa a
función.
La interfacepya la tabla de simbolos se muestra enel listado 1 y su implemenhaonen el
listado 2.
Los conceptos que C++ llama dasesy fundones virtuales, en otros lenguajes de programaci6n
orientada a objetos, generalmente son
llmados abstracción dedatos, herenciay métodos.
i
- 82 -
I*
I/
hrchiw, M . h : k d a c t dchWck a i m b o b
*I
Todos los identificadores conla misma ortografía tienenla misma
I/ dirección dentro dela tabla de cadenas enla cual esth almacenados.
dass name {
public:
char *id;
name *next
name (char *S} ( id = S; n&
1
;
-
0;)
dass t a b {
protected:
tab *parent
public:
I/Estas funaones virtuales irían solo cuando son utilizadas ensus
il
versionesdedasesderivadas
virtual name *insert(char *) 0
virtud name *lookup( char *) 0
friend name *lookup) chw * );
1;
dass gtab :public tab {
static name *t[ 256 1
; /I tabla global dehash
int hash( chW );
{ return ( (unsigned) id ) & O x F F ; )
public:
name *insert(char* );
name *lookup(char* );
@abO{parent=Ol
1
;
I
extern gtab gtable;
dass dab :public tab{
:I inicidizaciónde las funcionesmiembrosde
name *root
la dase
public
name *insert(char* );
name *lookup( char* 1;
dab(tab *tp = &@able)
{ parent = tp; root = O;
1
;
1
dass ftab :public tab{
¡I apuntadoresa l a s funcionesde la tabla de hash
name **t
int hash( char id)
return int( in
) 8 0x1t
public:
name *insert( char* );
name *lookup(d\ar* );
ftWtabJCtp)
{ parent =
1;
externtab *wrr-tab;
tp; t = new name*[32];
// alcancede la tabla adual
listada 1.
- 84-
i*
Implemen&uónde fa tabia desimbolos
#indude"tab.h"
extern @ab = gtabo;
extern tab *wn-tab = 8gtable;
*/
r'l tabla global
/I alcanceinicialde
la tabla esglobal
name *
lookup( char *id ) {
I*
Rutina general lookup. Invocación de la función virtud lookup para bus=
el identificador
especificado. la busqueda lermina
hasta que éste es encontrado
*/
name *n;
for( tab M = wn-tab; t t = t ->parent)
if( n = t->lookup( id) )
rehim n;
return O;
1
name *
gtab ::lookup( char* id ) {
I*
Funciones miembros de la tabla gbbai lookup. Busca E( idcntifbdor {que fue pasado como
panmetro] entrelos identificadores que componen
la tabia
*/
for(name *n= t[ hash( id ) 1
; n; n = n->next)
ii( n ->id= id )
return n;
return O;
1
name *
*
gtab :: insert( char id ) {
- 85 -
I*
Tabla de inserción global.
Si el nombre ya se encuentra enla tabla regresa error, en otro caso
el identicador se inserta
*/
if( lookup(id ) )
return O;
name *n = new rime( id );
n -> next = t[ hash( id )
return t[ hash( id) ] = n;
1;
1
name *
dab ::lookup( char * id) {
/*
tabia de la dase lookup.Busca la lista de nombres de dases para
el identificsdor
*/
farfname *n = root n; n = n ->next)
U( n ->id= id )
bresk;
return n;
1
name *
dab ::insert( char
* id 1{
I*
Clase de tabla de inserción.Si el nombre ya esta presente regresaemr. En otro MLTO inserta
el nombre enla cabeza delos miembros de la lists
*/
U( lookup( id 1)
return O;
name *n= new name(id 1;
n ->next = root
return root = n;
1
listado 2
- 86 ,
.-.-
4. BIBLIOGRAFíA
C ~ K
Brad J-
Object-Oriented
Programming-An
Evolutionary
Aproach.
Reading
Addison- W E S I ~i,986.
Mas.:
C.Dewhtrrst Stephen end Kathy T. S
t
& "Out of the C World ComesG++". Computer Language
Magazine,February 1987,29-36.
Goldberg,Adele."Introducingthe
1981.
14-26.
SmaUMk-80system". BYTE Magazine. Vol. 6/No. 8. August
Re~mann.Joseph. "Cinherits inheriranceA Handful of C++tools". Circle magazine. 54-60.
Robson,David."Object-OrientedSoflware
1981.
74-86.
Systems". BYTE Magazine. Vol. 6/No.8. August
S. Wiener,Richard and Lewís J. Phon.
ReadingMass.:Addison-Wesley. 1988.
An Introduction to Objed-Programming and C++.
Thomas. Dave "Object-OrientedProgramming".
228-240.
BYTE Magazine, Vol. 141No.3. March 1989.
Urlocker. Zack. 'Whitewater's Actor: An Lnbodudionto Objed-Oriented ProgrammingConcepts".
Microsoff Systems Joumd March 1989.33-44.
- 87 I
"