El lenguaje de programacin C++

Omer Manuel Salcedo Galvn Universidad Tecnolgica de Bolvar, Colombia osalcedo@unitecnologica.edu.co

Apuntes de las clases de la asignatura de Programacin II.

Cartagena de Indias D.T. y C. 1P2011.

AGRADECIMIENTOS uisiese agradecer !"blicamente !or la reali#acin de estos a!untes $ % &ios como Se'or ( dador de nuestras vidas. % mis )amiliares es!ecialmente *attia, mi se'ora es!osa !or su a!o(o incondicional. %l director del !rograma de +ngeniera de sistemas de la Universidad Tecnolgica de Bolvar Msc. Mois,s uintana !or sus valiosas recomendaciones en el !roceso ense'an#a - a!rendi#a.e. % mis com!a'eros de clases/ motivo !rinci!al en el desarrollo de estos a!untes. 0 en es!ecial a todas las !ersonas 1ue nos ense'an a nunca !erder las es!eran#as. Gracias Totales Omer Salcedo

ndice de contenido
El lenguaje de programacin C++.............................................................................................................1 eneralidades.............................................................................................................................................! Introduccin...........................................................................................................................................! "n poco de #istoria...............................................................................................................................! $Por%ue C++ y no otro lenguaje&..........................................................................................................! Entrando un poco en materia.................................................................................................................' (as all) del #ola mundo..................................................................................................................' Tipos de *aria+les ..........................................................................................................................10 Pala+ras reser*adas.........................................................................................................................10 Estructuras +)sicas del lenguaje.....................................................................................................11 Declaracin de *aria+les............................................................................................................11 Prototipo de ,unciones...............................................................................................................11 Declaracin de ,unciones...........................................................................................................11 Arreglos......................................................................................................................................12 El paradigma de la Programacin -rientada a -+jetos...........................................................................1. Introduccin.........................................................................................................................................1. /a e*olucin del modelo de o+jeto.....................................................................................................1. /as generaciones de los lenguajes de programacin.....................................................................1. /a e*olucin de las metodolog0as de programacin.......................................................................11 El paradigma de la programacin orientada a o+jetos........................................................................12 Tipos a+stractos de datos................................................................................................................12 Comprendiendo el sistema de cosas..........................................................................................12 Propiedades de los tipos a+stractos de datos..............................................................................1! Tipos a+stractos de datos y la -rientacin a o+jetos.................................................................1' Conceptos orientados a o+jetos......................................................................................................1' Clases.........................................................................................................................................1' -+jetos.......................................................................................................................................1' Comportamiento .......................................................................................................................1' (ensajes....................................................................................................................................13 Aterri4ando los conceptos..........................................................................................................13 5e,erencias..........................................................................................................................................20 Clases6 De,inicin7 constructores y destructores.....................................................................................21 Introduccin.........................................................................................................................................21 De,iniciones.........................................................................................................................................21 Entrando en materia.............................................................................................................................21 Declaracin de una clase6...............................................................................................................21 (odi,icadores de acceso.................................................................................................................2. Constructores y destructores...............................................................................................................2. /os constructores............................................................................................................................28 Constructor por de,ecto..................................................................................................................21 Iniciali4acin de o+jetos.................................................................................................................21 9o+recarga de constructores...........................................................................................................22 Constructores con argumentos por de,ecto.....................................................................................2! Constructor copia............................................................................................................................2' .

Destructores.........................................................................................................................................23 5e,erencias...........................................................................................................................................0 Cali,icadores7 Clases y ,unciones amigas.................................................................................................1 Introduccin..........................................................................................................................................1 El cali,icador const...............................................................................................................................1 El cali,icador static...............................................................................................................................8 El apuntador t:is...................................................................................................................................! "sando el apuntador t:is para reali4ar llamadas de operaciones en cascada..................................' ;unciones y clases amigas...................................................................................................................80 ;uncin Amiga...............................................................................................................................80 Clase Amiga....................................................................................................................................81 5e,erencias..........................................................................................................................................82 Asignacin din)mica de memoria............................................................................................................8. Introduccin.........................................................................................................................................8. De,inicin de asignacin din)mica de memoria.................................................................................8. Asignacin din)mica en C...................................................................................................................8. Asignacin din)mica en C++..............................................................................................................81 El operador ne<..............................................................................................................................81 El operador delete...........................................................................................................................82 Caso de estudio6 la clase Pila..........................................................................................................82 Composicin y agregacin de clases...................................................................................................83 5e,erencias..........................................................................................................................................10 9o+recarga de -peradores........................................................................................................................11 Introduccin.........................................................................................................................................11 $=ue es un operador&..........................................................................................................................11 /a so+recarga de operadores...............................................................................................................11 9o+recarga de operadores unarios..................................................................................................12 9o+recarga de operadores +inarios.................................................................................................18 9o+recarga de operadores :aciendo uso de ,unciones amigas.......................................................12 5e,erencias..........................................................................................................................................1! (as so+recargas de -peradores...............................................................................................................1' Introduccin.........................................................................................................................................1' 9o+recargando los operadores de insercin y e>traccin....................................................................1' 9o+recarga del operador de insercin.............................................................................................1' 9o+recarga del operador de e>traccin...........................................................................................1' 9o+recarga del operador de inde>acin...............................................................................................13 9o+recarga de los operadores ne< y delete.........................................................................................13 Caso de estudio6 Arreglos Din)micos.................................................................................................20 5e,erencias..........................................................................................................................................21 #erencia...................................................................................................................................................22 Introduccin.........................................................................................................................................22 ?ecesidad de la :erencia.....................................................................................................................22 #erencia...............................................................................................................................................22 @aria+les y ,unciones miem+ros protected .........................................................................................2! 5e,erencias..........................................................................................................................................2' (as so+re #erencia..................................................................................................................................23 Introduccin.........................................................................................................................................23 8

9inta>is para la deri*acin de clases...................................................................................................23 Constructores de clases deri*adas.......................................................................................................!0 9o+recarga de constructores de clases deri*adas............................................................................!0 Destructores de clases deri*adas.........................................................................................................!0 5ede,inicin de ,unciones en clases deri*adas...................................................................................!1 9uperposicin y so+recarga.................................................................................................................!1 #erencia (Altiple................................................................................................................................!2 5e,erencias..........................................................................................................................................!. E>cepciones.............................................................................................................................................!8 Introduccin.........................................................................................................................................!8 (anejando errores ..............................................................................................................................!8 De,iniendo su comportamiento en tBrminos de una *aria+le lgica...............................................!8 /a macro assert...............................................................................................................................!8 (anejar errores ,uera del conte>to ................................................................................................!1 E>cepciones ........................................................................................................................................!2 /a pala+ra reser*ada t:ro<.............................................................................................................!2 Caracter0sticas de t:ro<.............................................................................................................!! El +lo%ue try catc:..........................................................................................................................!! Eleccin del +uen :andler ..............................................................................................................!3 5eClan4ar una e>cepcin ................................................................................................................'0 E>cepciones est)ndar .....................................................................................................................'0 Especi,icaciones de e>cepciones ...................................................................................................'0 Cuando usar u e*itar las e>cepciones.............................................................................................'1 5e,erencias..........................................................................................................................................'1 Polimor,ismo............................................................................................................................................'2 Introduccin.........................................................................................................................................'2 "pcasting ............................................................................................................................................'2 /lamadas a ,unciones..........................................................................................................................'8 Enlace temprano.............................................................................................................................'8 Enlace Tard0o..................................................................................................................................'8 ;unciones *irtuales .............................................................................................................................'8 E>tensi+ilidad ................................................................................................................................'1 Clases a+stractas .................................................................................................................................'1 5e,erencias..........................................................................................................................................'2 Plantillas de ,unciones y clases................................................................................................................'! Introduccin.........................................................................................................................................'! Programacin genBrica........................................................................................................................'! Plantillas..............................................................................................................................................'! Plantillas de ,uncin............................................................................................................................'' Plantillas de ,uncin con *arios par)metros de plantillas...............................................................'3 Plantillas de clases...............................................................................................................................30 Especiali4acin de plantillas...........................................................................................................31 Plantillas sin tipo de par)metros..........................................................................................................32 5e,erencias..........................................................................................................................................32 Di+lioteca est)ndar de plantillas...............................................................................................................3. Introduccin.........................................................................................................................................3. /a +i+lioteca de plantillas est)ndar.....................................................................................................3. 1

Especi,icaciones +)sicas para el uso de las 9T/.................................................................................3. Clases agrada+les............................................................................................................................3. -+jeto ,uncin................................................................................................................................3. Componentes de la +i+lioteca est)ndar de plantillas...........................................................................38 Principales componentes de la 9T/....................................................................................................38 Contenedores..................................................................................................................................31 std66pairET17T2F........................................................................................................................31 std66listET7...F.............................................................................................................................32 std66*ectorET7...F........................................................................................................................32 std66setET7...F..............................................................................................................................3! std66mapEG7T7...F.......................................................................................................................3' /os iteradores..................................................................................................................................33 iterator y constHiterator..............................................................................................................33 re*erseHiterator y constHre*erseHiterator.................................................................................100 Algoritmos....................................................................................................................................101 5e,erencias........................................................................................................................................108

Generalidades
Introduccin.
El presente Capitulo tiene como o+jeto conte>tuali4ar al lector acerca del lenguaje de programacin C+ +7 tocando algunos aspectos tales como su #istoria7 Importancia7 y los elementos +)sicos del lenguaje.

Un poco de Historia.
El lenguaje de programacin C++ tu*o su nacimiento de la mano de Djarne 9troustrup en los la+oratorios Dell de ATIT en 13'0 donde se desarroll el 9istema -perati*o "?IJ. C++ inicialmente se conci+i como un precompilador de aspectos muy similares al preprocesador de C7 el cual con*ert0a su propio cdigo ,uente KC++L a cdigo ,uente para lenguaje C. para luego ser compilado por un compilador de C est)ndar. Desde 13'0 :asta 1330 :an :a+ido *arios compiladores de C++ KDorland7 Apple7 (ing<7 (icroso,t @isual7 9un 9tudio7 EtcL En la cual las caracter0sticas ,undamentales del lenguaje est)n disponi+les en todos los compiladoresM Pero algunas otras caracter0sticas propias del compilador y de sus ,a+ricantes tales como el uso de li+rer0as Kconio de DorlandL7 di,erencias de sinta>is KPro CNC++ de -racle7 -+jecti*e C de Apple7 Etc.L entre otras7 genera en algunos casos incon*enientes a la :ora de lle*ar un cdigo ,uente de un compilador a otro. Para resol*er el pro+lema de la porta+ilidad entre compiladores7 en 13'3 se ,orm un comitB A?9I lo %ue permiti la estandari4acin del lenguaje a ni*el americano y a mediados del aOo 133' su sinta>is ,ue estandari4ada +ajo la norma I9- a ni*el internacional. Para 133' el lenguaje A?9INI9- C++ ,ue apro+ado y por ende todos los compiladores modernos cumplen las especi,icaciones e>igidas por el est)ndar.

Porque C++ y no otro lenguaje?

Para responder esta pregunta7 de+emos tener en cuenta las principales *entajas %ue presenta el lenguaje C++16 Di,usin6 al ser uno de los lenguajes m)s empleados en la actualidad7 posee un gran nAmero de usuarios y e>iste una gran cantidad de li+ros7 cursos7 p)ginas <e+7 etc. dedicados a Bl. @ersatilidad6 C++ es un lenguaje de propsito general7 por lo %ue se puede emplear para resol*er cual%uier tipo de pro+lema7 desde aplicaciones de consola :asta sistemas cr0ticos incluyendo 9istemas -perati*os. Porta+ilidad6 el lenguaje est) estandari4ado y un mismo cdigo ,uente se puede compilar en di*ersas plata,ormas. E,iciencia6 C++ es uno de los lenguajes m)s r)pidos en cuanto ejecucin.

1 /ujan7 9ergio. C++ Paso a paso. PEn /ineaQ E:ttp6NNgplsi.dlsi.ua.esNRslujanNmaterialesNcppC muestra.pd,F Pcitado en 2011N01N22Q !

#erramientas6 e>iste una gran cantidad de compiladores7 depuradores7 li+rer0as7 etc. 9u sinta>is :a sido tomada como re,erencia para otros lenguajes tales como p:p7 ja*a7 CS entre otros. Esta *entaja permite a+arcar estos lenguajes reduciendo signi,icati*amente su cur*a de aprendi4aje.

C++ es un lenguaje de programacin multiCparadigma7 lo cual permite desarrollar aplicaciones ,undamentadas en los conceptos de la programacin estructurada as0 como aplicaciones ,undamentadas con el paradigma de la programacin orientada a o+jetos7 por lo %ue tam+iBn se considera C++ como un lenguaje :0+rido. Adem)s desde el punto de *ista del paradigma de la programacin orientada a o+jeto es mas *isi+le algunos de sus conceptos tales como la #erencia y el Polimor,ismo.

Entrando un poco en materia Mas all del Hola mundo

A tra*Bs de un cdigo ,uente desarrollado en C++ %ue tiene como o+jeto o+tener el )rea de un circulo conocido su radio se e>pondr)n algunas de las caracter0sticas +)sicas %ue tiene este lenguaje de programacin. El cdigo ,uente se muestra a continuacin6 NNarc:i*o6 areacirculo.cpp NNautor6 -mer 9alcedo EosalcedoTunitecnologica.edu.coF NN*ersion6 1.0 Sinclude EiostreamF Sde,ine PI ..181132218 using namespace stdM int mainKL U ,loat Area7 radioM coutEEVrWVM cinFFradioM AreaWPIXradioXradioM coutEEVareaWVEEAreaEEendlM return 0M Y

'

Desde la linea 1 :asta la l0nea . son lineas de comentarios. "na linea de comentario inicia anteponiendo la +arra inclinada 2 *eces NN esta instruccin le indica al compilador %ue ignore todo cadena de s0m+olos posteriores a NN :asta el ,in de la l0nea. En la linea 1 aparece la instruccin Sinclude EiostreamF esta es una directiva del !re!orcesador. El preprocesador tiene como o+jeto preparar el cdigo ,uente para %ue este sea compilado. /as directi*a del preprocesador son un conjunto de instrucciones %ue permiten al preprocesador7 en el momento de anali4a el cdigo ,uente antes de la ,ase de compilacin real7 reali4a las sustituciones de macros7 inclusin de ,unciones7 o+jetos7 de,iniciones desde otros arc:i*os. Tam+iBn es el responsa+le de la eliminacin de los comentarios. El o+jeti*o de la directi*a Sinclude es insertar arc:i*os e>ternos dentro de nuestro arc:i*o de cdigo ,uente. Estos arc:i*os son conocidos como arc:i*os incluidos7 arc:i*os de ca+ecera o V:eadersV. =ue en nuestro caso el arc:i*o de ca+ecera es iostream.: %ue contiene un conjunto de o+jetos7 macros y ,unciones %ue permiten el manejo e,iciente de la entrada y salida :aciendo uso de los ,lujos de +ytes KstreamsL tales como los o+jetos cin KConsole inL para entrada y cout Kconsole out2 para la salida %ue en por de,ecto son el teclado y la pantalla respecti*amente. En la l0nea 2 aparece otra directi*a del preprocesador Sde,ine PI ..181132218. /a directi*a Sde,ine7 sir*e para de,inir macros. /as macros suministran un sistema para la sustitucin de pala+ras7 con y sin par)metros. En este caso se esta de,iniendo la macro PI con *alor .7181132218. En la l0nea ' la instruccin using namespace stdM tiene como o+jeto e*itar re de,inir o+jetos7 ,unciones7 macros7 etc7 pre*iamente de,inidas al ponerles igual nom+re7 para e*itar esa am+igZedad se cre la ,igura de los es!acios de nombres o names!ace. En este caso :ay un espacio de nom+res llamado std7 en la cual se incluyen las de,iniciones de todas las ,unciones y clases %ue con,orman la li+rer0a est)ndar de C++. En la l0nea 11 entra en escena la ,uncin main7 esta es la ,uncin principal y punto inicial para la ejecucin de un programa escrito en C++7 es an)logo a inicio en algoritmos representados ya sea en seudocdigos o en diagramas de ,lujos. Desde el punto de *ista sint)ctico main es una ,uncin la cual de+e cumplir la siguiente estructura6 ti!o3valor3retorno nombre3)uncion4lista de !arametros25 66sentencias return valor3retorno/ 7 En este caso de main tiene como *alor de retorno int7 %ue en C++ representa el tipo de dato entero Kint de integerL y la ,uncin no presenta par)metros7 claro est)7 %ue esta no es la Anica con,iguracin de la ,uncin main7 ya %ue Bsta puede no retornar *alor y se especi,ica :aciendo uso de la la pala+ra reser*ada *oid as0 como tam+iBn puede reci+ir 2 par)metros K int argc7 c:arXX arg*L el primero se utili4a para contar los argumentos %ue el arc:i*o ejecuta+le puede reci+ir y el segundo los *alores de los argumentos respecti*amente de superar e>itosamente el proceso de compilacin7 enlace y constriccin reali4ado por el compilador. En la l0nea 12 la lla*e U a+re el cuerpo de la ,uncin. En la l0nea 1. se de,inen do *aria+les de nom+res radio y Area de tipo de datos de coma ,lotante K,loatL de )m+ito local para la ,uncin main Kya %ue est)n de,inidas dentro del +lo%ue encerrado por lla*es %ue delimitan el alcance de la ,uncin main. Toda *aria+le declarada por ,uera de main y no de,inida dentro de un +lo%ue de otra ,uncin di,erente se llama *aria+le de )m+ito glo+al o sutilmente *aria+les 3

glo+ales. En la l0nea 20 la instruccin AreaWPIXradioXradioM indica al compilador %ue de+e :acer la multiplicacin Kel operador +inario X representa la multiplicacinL del *alor presente en la *aria+le radio le0da desde el teclado a tra*Bs del uso del o+jeto cin Kl0nea 12L consigo misma y luego con el *alor de la macro PI7 el *alor del resultado se almacena en la *aria+le Area %ue es mostrada por la pantalla a tra*Bs del uso del o+jeto cout Kl0nea 20L. ;inalmente en la l0nea 28 la ,uncin main lle*a al punto de de*olucin del *alor de retorno lo %ue permite el ,in de la ejecucin del programa :aciendo uso de la instruccin return. ;inalmente en la l0nea 21 la lla*e Y cierra el cuerpo de la ,uncin.

Tipos de variables
C++ presenta en su sinta>is algunos tipos de *aria+les ,undamentales7 a sa+er6 *oid7 c:ar7 int7 ,loat y dou+le7 C++ incluye tam+iBn el tipo +ool. Tam+iBn e>isten ciertos modi,icadores7 %ue permiten ajustar ligeramente ciertas propiedades de cada tipoM los modi,icadores pueden ser6 s:ort7 long7 signed y unsigned. Tam+iBn C++ soporta los tipos enumerados7 enum.

Palabras reservadas.
A continuacin se muestran el conjunto de pala+ras reser*adas del lenguaje de programacin C++7 *ale la pena recordar %ue estas pala+ras son de uso e>clusi*o del lenguaje y no pueden ser utili4ada para otros propsitos7 por ejemplo como nom+re de *aria+les6 asm auto +rea[ case catc: c:ar class const continue de,ault delete do dou+le else enum e>tern ,loat ,or ,riend goto i, inline int long ne< operator pri*ate protected pu+lic register return s:ort signed si4eo, static struct s<itc: template t:is t:ro< try typede, union unsigned *irtual *oid *olatile <:ile

10

Estructuras bsicas del lenguaje.

A continuacin se e>ponen algunas estructuras sint)cticas del lenguaje de programacin C++ 27 *istas en el curso de programacin 1 y e>pongo a manera de recordatorio.
Declaracin de aria!les

Psigned\unsigned\longQ tipoHdatos Eidenti,icadorFP7Eidenti,icador2FP7Eidenti,icador.FQ...QM Ejemplos6 signed c:ar cuenta7 cuenta27 totalM unsigned c:ar letrasM c:ar caracter7 inicial7 respuestaM
Prototipo de "unciones

Pe>tern\staticQ EtipoH*alorHretornoF PEmodi,icadoresFQ Eidenti,icadorFKElistaHpar)metrosFLM Ejemplos6 int (ayorKint a7 int +LM int mayorKint7intLM
Declaracin de "unciones

Pe>tern\staticQ EtipoH*alorHretornoF Pmodi,icadoresQ Eidenti,icadorFKElistaHpar)metrosFL U PsentenciasQ Y Ejemplos6 int (ayorKint a7 int +L U i,Ka F +L return aM else return +M Y

2 Po4o7 9al*ador. C++ con clase PEn l0neaQ E:ttp6NNc.conclase.netNF PCitado en 2011N01N22 Q. 11

#rreglos

EtipoF Eidenti,icadorFPEnAmHelemenFQPPEnAmHelemenFQ...QM Ejemplos6 int @ectorP10QM int Ta+laP10QP10QM c:ar Dimension?P8QP11QP2QP'QP11QM

12

El paradigma de la Programacin
Introduccin.

rientada a

bjetos.

El presente cap0tulo tiene como o+jeti*o dar al lector los conceptos ,undamentales del paradigma de la Programacin -rientada a -+jetos KP--L7 partiendo de sus or0genes teniendo en cuenta la generacin de los lenguajes de programacin y su respecti*a e*olucin. 9e e>plorar)n los ,undamentos del modelo de o+jetos7 el an)lisis orientado a o+jetos y el diseOo orientado a o+jetos.

$a e olucin del modelo de o!jeto

El an)lisis y diseOo orientado a o+jeto no ,ue generado espont)neamente7 pero si7 de las ceni4as de inconta+les ,allas en los proyectos de so,t<are desarrollados por paradigmas o metodolog0as anteriores. Este paradigma no es una des*iacin radical de los en,o%ues anteriores7 de :ec:o7 se ,undamenta con sus mejores ideas. Por otro lado7 se e>aminar) la e*olucin de las :erramientas de desarrollo de so,t<are para as0 comprender los or0genes y la aparicin de la metodolog0a orientada a o+jetos.

!as generaciones de los lenguajes de programacin

A continuacin se muestran la clasi,icacin de los mas populares lenguajes de programacin en generaciones de acuerdo a las caracter0sticas propias de los lenguajes. Primera generacin K1318C131'L ;-5T5A? I6 E>presiones matem)ticas. A/ -/ 1'6 E>presiones matem)ticas. ;lo<matic6 E>presiones matem)ticas. IP/ @6 E>presiones matem)ticas. 9egunda generacin K1313C1321L ;-5T5A? II6 9u+rutinas7 compilacin separada. A/ -/ 206 Estructura en +lo%ues7 tipos de datos. C-D-/6 descripcin de datos7 manejo de arc:i*os. /isp6 procesamiento de listas7 apuntadores7 recoleccin de +asura Kgarbage collectionL. Tercera generacin K1322C13!0L P/N16 ;-5T5A? + A/ -/ + C-D-/. A/ -/ 2'6 9ucesor riguroso de A/ -/ 20. Pascal6 9ucesor simple de A/ -/ 20. 1.

 9imula6 Clases y a+straccin de datos. /a +rec:a generacional K13!0C13'0L En esta Bpoca se in*entaron nue*os lenguajes de programacin7 pero dB+ilmente soportados. Dentro de ellos *ale la pena destacar6 C6 E,iciente7 para desarrollos pe%ueOos. ;-5T5A? !!6 Primer lenguaje de programacin estandari4ado por la A?9I. Doom de la programacin orientada a o+jetos K13'0C1330L 9malltal[ '06 /enguaje orientado a o+jeto puro. C++6 Deri*ado de C y 9imula. Ada'.6 tipado ,uerteM ,uertemente in,luenciado por Pascal. Ei,ell6 Deri*ado de Ada y 9imula. 9urgimientos de los ,rame<or[s K1330C:oyL @isual Dasic6 Desarrollo ,)cil de inter,a4 gr),ica de usuarios para aplicaciones so+re ]indo<s. ^a*a6 9ucesor de -a[M diseOado para %ue sus aplicaciones sean porta+les. Pyt:on6 /enguaje de script orientado a o+jetos. ^2EE6 ;rame<or[ +asado en ^a*a para desarrollos empresariales. .?ET6 ;rame<or[ +asado en o+jetos de (icroso,t T( En lo sucesi*o de las generaciones7 los di,erentes mecanismos de a+straccin %ue soportan cada lenguaje cam+ian. /os lenguajes de primera generacin ,ueron usados principalmente para desarrollar aplicaciones cient0,icas e ingenieriles. /enguajes como ;-5T5A? I ,ue desarrollado para ayudar al programador a escri+ir ,rmulas matem)ticas li+er)ndolo de las complejidades del lenguaje ensam+lador o cdigo ma%uina. En los lenguajes de segunda generacin se en,ati4a+an en la a+straccin algor0tmica7 para a%uella Bpoca7 las ma%uinas comen4aron a tener mayor potencia de computo y en la econom0a de la industria de la computacin signi,ica %ue una mayor clase de pro+lemas pod0an ser automati4ados7 especialmente los pro+lemas empresariales7 tales como administrar la nmina de una empresa7 o+tener el +alance ,inanciero de esta y de paso imprimirla. Para ,inales de 13207 con la llegada de los transistores y los circuitos integrados el costo de las ma%uinas de computo a ni*el de :ard<are +ajaron dram)ticamente7 reduciendo su tamaOo pero su potencia de computo tu*o un crecimiento e>ponencial7 una serie de grandes pro+lemas pod0a ser resuelto7 pero dic:a solucin demanda+a la manipulacin de mas clases de datos. Entre los lenguajes de programacin de tercera generacin como A/ -/ 207 y posteriormente7 Pascal ,acilitaron esa a+straccin de datos %ue los pro+lemas de la Bpoca demanda+an. A:ora un programador pod0a descri+ir7 el tipo de datos y dejar al lenguaje %ue tomar la mejor decisin a la :ora de la construccin del so,t<are. En la dBcada 13!0 :u+o un ,renes0 en in*estigaciones re,erentes a lenguajes de programacin7 18

resultando la creacin de7 literalmente7 miles de lenguajes7 %ue a su *e4 permit0an desarrollar aplicaciones %ue eran inadecuadas con el uso de lenguajes de programacin anteriores ya %ue ,ueron desarrollados con el ,in de :acerle ,rente a esas limitaciones. En la actualidad muy pocos so+re*i*en. /os lenguajes de programacin orientada a o+jetos tienes un gran interBs de+ido a %ue o,recen el mejor soporte para la descomposicin del so,t<are. El nAmero de lenguajes %ue soportar este paradigma tu*o su m)>ima e>pansin o +oom entre la dBcada de 13'0 y los comien4os de la dBcada de 1330. Desde 1330 pocos lenguajes :an emergido con el respaldo de los ,a+ricantes de :erramientas de programacin comerciales Kpor ejemplo7 ja*a7 C++L. El uso emergente de los ,rame<or[s K^2EE7 .?ETL o,recen una cantidad de componentes y ser*icios %ue simpli,ican las tareas de programacin comunes y corrientes7 o+teniBndose una alta producti*idad y demostrando la di,0cil promesa del reuso de componentes.

!a evolucin de las metodolog"as de programacin

En un principio los lenguajes de programacin presente en la primera y segunda generacin se caracteri4a+an por utili4ar la metodolog0a de la programacin imperati*a. 9u origen es la propia ar%uitectura de @on ?eumann7 %ue consta de una secuencia de celdas KmemoriaL en las cuales se pueden guardar datos e instrucciones7 y de un procesador capa4 de ejecutar de manera secuencial una serie de operaciones K comandosL principalmente aritmBticas y +ooleanas. En general7 un lenguaje imperati*o o,rece al programador conceptos %ue se traducen de ,orma natural al modelo de la m)%uina. El programador tiene %ue traducir la solucin a+stracta del pro+lema a tBrminos muy primiti*os7 cercanos a la m)%uina7 por lo %ue los programas son m)s Vcomprensi+lesV para la m)%uina %ue para el :om+re. Esto es una des*entaja para el programador %ue :ace %ue sea sumamente complicado construir cdigo en lenguaje imperati*o. /o +ueno de este lenguaje es %ue es tan cercano al lenguaje de la m)%uina %ue la e,iciencia en la ejecucin es alt0sima.. Para los lenguajes de tercera generacin soporta+an la metodolog0a de la programacin procedimental /os matem)ticos resuel*en pro+lemas usando el concepto de ,uncin7 la cual se de,ine como una relacin matem)tica la cual7 de acuerdo a los datos %ue reci+e como entrada7 se o+tiene un resultado como salida. 9a+iendo cmo e*aluar una ,uncin7 usando la computadora7 se pueden resol*er autom)ticamente muc:os pro+lemas. Este ,ue el pensamiento %ue lle* a la creacin de los lenguajes de programacin ,uncionales. Adem)s se apro*ec: la posi+ilidad %ue tienen las ,unciones para manipular datos sim+licos7 y no solamente numBricos7 y la propiedad de las ,unciones %ue les permite componer7 creando de esta manera7 la oportunidad para resol*er pro+lemas complejos a partir de las soluciones a otros m)s sencillos. Tam+iBn se incluy la posi+ilidad de de,inir ,unciones recursi*amente. "n lenguaje ,uncional o,rece conceptos %ue son muy entendi+les y relati*amente ,)ciles de manejar. El lenguaje ,uncional m)s antiguo y popular es /I9P7 diseOado por (cCart:y en la segunda mitad de los aOos 10. 9e usa principalmente en Inteligencia Arti,icial. En los '0 se aOadi a los lenguajes ,uncionales la tipi,icacin y algunos conceptos modernos de modulari4acin y polimor,ismo. Programar en un lenguaje ,uncional signi,ica construir ,unciones a partir de las ya e>istentes. Por lo tanto es importante conocer y comprender +ien las ,unciones %ue con,orman la +ase del lenguaje7 as0 como las %ue ya ,ueron de,inidas pre*iamente. De esta manera se pueden ir construyendo aplicaciones cada *e4 m)s complejas. /a des*entaja es %ue est) alejado del modelo de la m)%uina de @on ?eumann y7 por lo tanto7 la e,iciencia de ejecucin de los intBrpretes de lenguajes ,uncionales es peor %ue la ejecucin de los programas imperati*os precompilados8.
. 5I@E5-7 ^essica. #istoria de la Programacin. PEn l0neaQ E:ttp6NN<<<.it.uc.m.esNj*illenaNircNpracticasNestudiosN/enguajesHdeHProgramacion.pd,FPCitado en 2011N01N2'Q 8 5I@E5-7 ^essica. #istoria de la Programacin. PEn l0neaQ

11

Entre los lenguajes de programacin presentes entre la tercera generacin y la +rec:a generacional estos soporta+an la metodolog0a de la programacin modular7 la cual7 pod0an agrupar ,uncionalidades comunes dentro de mdulos. Dajo esta metodolog0a un programa puede no esta compuesto por una Anica parte sino %ue puede estar di*idido en *arias partes %ue interactuan a tra*Bs de llamadas de procedimientos. Cada mdulo tienes sus propios datos7 lo %ue permite a cada mdulo administrar un estado interno %ue puede ser modi,icado a tra*Bs de procedimientos de,inidos dentro del mismo mdulo. Como ejemplos son los programa %ue administra su in,ormacin a tra*Bs de estructuras de datos7 e>isten *arias estructuras de datos tales como arreglos7 listas7 gra,os7 ar+oles7 pilas7 colas7 conjuntos y otrasM los cuales se caracteri4an por tener su propia estructura y sus mBtodos de acceso 1. Algunas des*entajas de este paradigma son6 Creacin y destruccin e>pl0cita7 datos y operaciones desacoplados y poca representacin.

El paradigma de la programacin orientada a o!jetos

El paradigma de la programacin orientada a o+jetos resuel*e *arios de los pro+lemas recientemente mencionados7 en contraste con otras metodolog0as7 se ,undamenta en una red de o+jetos %ue interactAan entre si cada uno conser*ando su propio estado.

Tipos abstractos de datos

Comprendiendo el sistema de cosas

Cuando se emprende un proyecto de desarrollo de so,t<are. El producto ,inal tiene como o+jeto resol*er determinado pro+lema7 %ue generalmente7 son de la *ida real e incluso cotidiana. Como es sa+ido7 los pro+lemas del mundo real pueden ser ne+ulosos el cual se de+e comprender y entenderlo con el ,in de o+tener los detalles y clasi,icarlos de acuerdo a su importancia en la resolucin del pro+lema7 o+teniBndose su propia *ista a+stracta7 o modelo7 Este proceso de modelado se llama abstraccin.

Pro+lema

A+straccin

(odelo +lustracin 8$ 9roceso de %bstraccin

E:ttp6NN<<<.it.uc.m.esNj*illenaNircNpracticasNestudiosN/enguajesHdeHProgramacion.pd,F PCitado en 2011N01N2'Q 1 (_//E57 Peter. Introduction to -+jectC-riented Programming "sing C++. PEn l0neaQ E:ttp6NN<<<.desy.deNgnaN:tmlNccNTutorialNtutorial.:tmlF PCitado en 2011N01N.0Q

12

El modelo de,ine una *ista a+stracta del pro+lema7 lo cual implica %ue la ,idelidad del modelo respecto al pro+lema real depende ,uertemente en el en,o%ue de los aspectos propios del pro+lema el cual presenta el modelo. Esos aspectos son conocidos como las propiedades del pro+lema7 esas propiedades incluyen6 1. /os datos %ue pueden ser a,ectados 2. /as operaciones %ue :an sido identi,icadas Como ejemplo considere un administrador de empleados de una institucin. /as directi*as de la institucin donde usted tra+aja se acercan a usted y le piden %ue desarrolle un programa %ue permita administrar los datos de sus empleados. Dien7 como el pro+lema no :a sido especi,ico7 por ejemplo7 $=ue in,ormacin de los empleados considera las directi*as necesaria& $=ue tareas de+en permitir reali4ar& 9e sa+e %ue los empleados son personas reales %ue se caracteri4an por tener una serie de propiedades7 a continuacin se mencionar)n algunas6 ?om+re estatura ,ec:a de nacimiento cargo color de ca+ello se>o :o++y ?Amero de Identi,icacin Pro,esin

Ciertamente7 algunas de las propiedades mencionadas7 no son necesarias para resol*er el pro+lema de la administracin. En el momento %ue se crea un modelo de+e asegurarse %ue en la seleccin de las propiedades Bstas sean necesarias para cumplir con los re%uerimientos7 %ue en el ejemplo7 solicita la administracin y en termino general el cliente. Estas propiedades se conocen como datos o atributos, estos datos o atri+utos permiten descri+ir7 para el ejemplo7 personas reales a tra*Bs de la a+straccin de empleados. Por supuesto no solo +asta con la pura descripcin7 tam+iBn de+en e>istir operaciones de,inidas por la directi*as de la institucin7 la cual puedan manipular dic:os empleados a+stractos. Tales como crear empleados7 editar los datos de algAn empleado pre*iamente creado o eliminar los datos de un empleado7 as0 como *alidacin de sus datos. Estas operaciones se conocen como m,todos. Para resumir7 la a+straccin permite de,inir de un pro+lema real *arias entidades con sus datos y operaciones. En consecuencia7 esas entidades com+inan datos y operaciones las cuales no est)n desacopladas.
Propiedades de los tipos a!stractos de datos

Con +ase al proceso de a+straccin se o+tienen entidades +ien de,inidas con sus propiedades7 estas entidades de,inen la estructura de datos de un conjunto de elementos. /as estructura de datos pueden ser accedidas por operaciones +ien de,inidas el conjunto de estas operaciones se llaman inter,aces7 y estas son e>portados por la entidad. "na entidad con las propiedades descritas anteriormente se conocen como Tipo A+stracto de Datos TAD K %&T : %bstract &ata T(!eL. /a siguiente ,igura muestra un TAD %ue consiste un conjunto de atri+utos y mBtodos. 9olo los mBtodos son accedidos por ,uera de la TAD y de,inen sus inter,aces. 1!

+lustracin ;$ Un Ti!o %bstracto de &atos

%ipos a!stractos de datos y la &rientacin a o!jetos

/os TAD permiten la creacin de instancias con propiedades +ien de,inidas y comportamientos. En la orientacin a o+jetos los TAD se re,ieren a las clases. Por lo tanto una clase de,ine las propiedades de los o+jetos los cuales son instanciados en un am+iente orientado a o+jetos. /os tipos a+stractos de datos de,inen ,uncionalidades poniendo principal Bn,asis en los datos in*olucrados7 sus estructuras7 sus mBtodos as0 como a>iomas y precondiciones. Consecuentemente7 la programacin orientada a o+jetos es e%ui*alente a decir ` Programacin con TADa6 Com+inando las ,uncionalidades de di,erentes tipos a+stractos de datos para resol*er un pro+lema7 por lo tanto7 las instancias Ko+jetosL de los TAD son din)micamente creados7 usados y destruidos.

Conceptos orientados a objetos

En esta sesin se de,inir)n los principales conceptos de la programacin orientada a o+jetos.
Clases

"na clase es la implementacin de un tipo de datos a+stractos KTADL. En cual se de,inen los atri+utos y los mBtodos %ue implementan la estructura de datos y operaciones del TDA respecti*amente. /as instancias de las clases son llamados o+jetos . En consecuencia7 las clases de,inen las propiedades y el comportamiento de conjuntos de o+jetos.
&!jetos

"n -+jeto es la instancia de una clase7 %ue es identi,icada por su nom+re y de,ine un estado el cual es representado por los *alores de su atri+uto en un tiempo determinado. El estado de un o+jeto cam+ia de acuerdo a la aplicacin de sus mBtodos7 al re,erirse a los posi+les cam+ios de estado de un o+jeto7 estamos :a+lando de su comportamiento.
Comportamiento

El comportamiento de un o+jeto es de,inido por el conjunto de mBtodos los cuales pueden ser aplicados en Bl.

1'

'ensajes

"n mensaje es la solicitud reali4ada a un o+jeto para %ue Bste in*o%ue alguno de sus mBtodos7 por lo tanto un mensaje contiene6 El nom+re del mBtodo /os argumentos del mBtodo.

En consecuencia7 la in*ocacin de un mBtodo es la reaccin causada por la recepcin de un mensajeM esto solo es posi+le si el mBtodo es conocido por el o+jeto.
#terri(ando los conceptos

Con +ase a la a+straccin de la entidad Empleado7 o+ser*aremos como se identi,ican cada uno de los conceptos *istos en esta sesin. Clase6 Empleado %tributos$ nroHid6 int ?om+re 6 c:arX Estatura6 ,loat ;ec:aHnacimiento6 &ate Cargo6 c:arX Pro,esin6 c:arX Metodos$ get?roIdK*oidL6 in setPro,esionKconst c:arXL6*oid getEdadKL6int getCargoKL6c:arX setCargoKconst c:arXL6 *oid Ob.etos$ Empleado emp7 %M Mensa.es$ emp.get?om+reK`Adalu4aLM emp.setPro,esionK`Ingeniero de 9istemasaLM %.getPro,esionKemp.getPro,esionKLLM

13

)e"erencias
D--C# rady et al. -+ject -riented analisys and Design <it: Applications. . Ed.7 200!. AddisonC ]esley. 231 pp. I9D? 0C201C'3111CJ.

20

Clases# $e%inicin& constructores ' destructores.

Introduccin
El presente capitulo tiene como o+jeto dar al lector los conceptos relacionados con la implementacin de los tipos a+stractos de datos %ue7 en el lenguaje de programacin C++7 se conocen como clases KclassL. 9e e>plorar)n los conceptos de atri+utos7 operaciones7 modi,icadores de acceso7 constructores y destructores.

De"iniciones
9al*ador Po4o2 de,ine los conceptos cla*es en la programacin orientada a o+jetos7 con el ,in de conte>tuali4ar al lector acerca de este paradigma de programacin6 9OO6 9iglas de VProgramacin -rientada a -+jetosV. En inglBs se escri+e al re*Bs V--PV. /a idea +)sica de este paradigma de programacin es agrupar los datos y los procedimientos para manejarlos en una Anica entidad6 el o+jeto. Cada programa es un o+jeto7 %ue a su *e4 est) ,ormado de o+jetos %ue se relacionan entre ellos. Ob.eto6 "n o+jeto es una unidad %ue englo+a en s0 mismo datos y procedimientos necesarios para el tratamiento de esos datos. Mensa.e6 El mensaje es el modo en %ue se comunican e interrelacionan los o+jetos entre si. M,todo6 9e trata de otro concepto de P--7 los mensajes %ue lleguen a un o+jeto se procesar)n ejecutando un determinado mBtodo de ese o+jeto. Clase6 "na clase se puede considerar como un patrn para construir o+jetos. +nter)a#6 9e trata de la parte del o+jeto %ue es *isi+le para el resto de los o+jetos. Es decir7 %ue es el conjunto de mBtodos Ky a *eces datosL de %ue dispone un o+jeto para comunicarse con Bl. <erencia6 Es la capacidad de crear nue*as clases +as)ndose en clases pre*iamente de,inidas7 de las %ue se apro*ec:an ciertos datos y mBtodos7 se desec:an otros y se aOaden nue*os. =erar1ua6 De,inicin del orden de su+ordinacin de un sistema clases. 9olimor)ismo6 Propiedad segAn la cual un mismo o+jeto puede considerarse como perteneciente a distintas clases.

Entrando en materia
A continuacin se de,inen las sinta>is en C++ de los conceptos esenciales de clases en la P-- usando el lenguaje de programacin C++

$eclaracin de una clase#

/a sinta>is7 para la declaracin de clases7 se e>presa a continuacin6
2 Po4o7 9al*ador. C++ con clase PEn l0neaQ E:ttp6NNc.conclase.netNF PCitado en 2011N02N0! Q.

21

class >identi)icador de clase? @>$lista de clases base?A 5 >lista de miembros? 7 @>lista de identi)icadores de ob.etos?A/ /a lista de miem+ros ser) en general una lista de operaciones KmBtodosL y atri+utos KdatosL. /os atri+utos se declaran del mismo modo en %ue lo :ac0amos :asta a:ora7 sal*o %ue no pueden ser iniciali4ados. /as operaciones pueden ser simplemente declaraciones de prototipos7 %ue se de+en de,inir aparte de la clase pueden ser tam+iBn de,iniciones. Cuando se de,inen ,uera de la clase se de+e usar el operador de )m+ito V66V. El siguiente ejemplo muestra la declaracin de la clase entero6 class Bntero5 !rivate$ 66atributos int valor/ !ublic$ 66m,todos Bntero sumar4Bntero2/ Bntero restar4Bntero2/ Bntero inv%d42/ void setCalor4int2/ int getCalor42/ 7/ void Bntero$$setCalor4int v2 5 valorDv/ 7 int Bntero$$getCalor425 return valor/7 Bntero Bntero$$sumar4Bntero a2 5 Bntero suma/ suma.setCalor4valorEa.getCalor422/ return suma/ 22

Bntero Bntero$$restar4Bntero a2 5 Bntero resta/ return sumar4a.inv%d422/ 7 Bntero Bntero$$inv%d42 5 Bntero inv/ inv.setCalor4:8Fvalor2/ return inv/ 7 /a clase Entero tiene un miem+ro de tipo de datos o atri+uto llamado valor y cinco operaciones7 una para leerlo KsetCalorL7 uno para mostrarlo KgetCalorL y el resto para e,ectuar operaciones con Bl Ksumar7 restar e inv%dL. ?tese %ue su sinta>is es similar a la del tipo de datos de,inidos por el usuario struct.

Modi%icadores de acceso
/os modi,icadores son elementos del lenguaje %ue se colocan delante de la de,inicin de *aria+les locales7 datos miem+ro7 mBtodos o clases y %ue alteran o condicionan el signi,icado del elemento en la cual cada miem+ro puede tener di,erentes ni*eles de acceso. C++ tiene . modi,icadores de acceso para los miem+ros de las clases a sa+er6 !ublic6 Cual%uier miem+ro pA+lico de una clase es accesi+le desde cual%uier parte donde sea accesi+le el propio o+jeto. !rivate6 /os miem+ros pri*ados de una clase slo son accesi+les por los propios miem+ros de la clase y en general por o+jetos de la misma clase7 pero no desde ,unciones e>ternas o desde ,unciones de clases deri*adas. !rotected6 Con respecto a las ,unciones e>ternas7 es e%ui*alente al acceso pri*ado7 pero con respecto a las clases deri*adas se comporta como pA+lico. Cada una de Bstas pala+ras7 seguidas de V6V7 da comien4o a una seccin7 %ue terminar) cuando se inicie la seccin siguiente o cuando termine la declaracin de la clase. Es posi+le tener *arias secciones de cada tipo dentro de una clase. 9i no se especi,ica nada7 por de,ecto7 los miem+ros de una clase son pri*ados.

Constructores y destructores
En C++7 las clases contienen dos categor0as de mBtodos especiales los cuales son esenciales para el 2.

+uen ,uncionamiento de la clase. Estos son los constructores y los destructores.

!os constructores
/os constructores son mBtodos especiales %ue sir*en para iniciali4ar un o+jeto de una determinada clase al mismo tiempo %ue se declara. /os constructores son especiales por *arios moti*os6 1. Tienen el mismo nom+re %ue la clase a la %ue pertenecen. 2. ?o tienen tipo de retorno7 y por lo tanto no retornan ningAn *alor. .. ?o pueden ser :eredados. 8. Por Altimo7 de+en ser pA+licos7 no tendr0a ningAn sentido declarar un constructor como pri*ado7 ya %ue siempre se usan desde el e>terior de la clase7 ni tampoco como protegido7 ya %ue no puede ser :eredado. 9u sinta>is es6 class >identi)icador de clase? 5 !ublic$ >identi)icador de clase?4>lista de !armetros?2/ ... 7/ >identi)icador de clase?$$>identi)icador de clase?4>lista de !armetros?2 @$ >lista de constructores?A 5 >cdigo del constructor? 7 /a clase Entero7 al aOadir un constructor7 %uedar0a as06 class Bntero5 !rivate$ 66atributos int valor/ !ublic$ 66constructor Bntero4int2/ 66metodos Bntero sumar4Bntero2/ Bntero restar4Bntero2/ Bntero inv%d42/ 28

void setCalor4int2/ int getCalor42/ 7/ Bntero$$Bntero4int v25 valorDv/ 7 G Al desarrollar el constructor este permite reali4ar instancias de o+jetos de tipo Entero siguiendo la siguiente sinta>is6 int main 425 Bntero a4H2/ 66crea un Ob.eto de ti!o entero en el cual su valor inicial es H 7

Constructor por de%ecto

Es un constructor sin par)metros inicialmente creado por el compilador de ,orma autom)tica cuando a la clase no se le de,ine un constructor de manera e>pl0cita. Cuando se crean -+jetos de ,orma local los atri+utos de estos tendr0as *alores al a4ar trayendo `+asuraa %ue :u+iese en la memoria asignada al o+jeto. En cam+io7 si se tratan de o+jetos glo+ales7 dic:os atri+utos se iniciali4ar0an en cero. Para declarar o+jetos usando el constructor por de,ecto o un constructor %ue :ayamos declarado sin par)metros no se de+e usar el parBntesis. Ejemplo6 Bntero gl/ 66Crea un ob.eto de mbito global de ti!o entero el cual su valor inicial es cero int main 425 Bntero a/ 66crea un Ob.eto de mbito local de ti!o entero el cual su valor inicial es desconocido 7

(niciali)acin de objetos
En C++ las *aria+les de tipos +)sicos como int7 c:ar o ,loat son o+jetos. En C++ cual%uier *aria+le Ku o+jetoL tiene7 al menos un constructor7 el constructor por de,ecto7 incluso a%uellos %ue son de un tipo +)sico. 9lo los constructores de las clases admiten iniciali4adores. Cada iniciali4ador consiste en el nom+re del atri+uto a iniciali4ar7 seguida de la e>presin %ue se usar) para iniciali4arla entre parBntesis. /os iniciali4adores se aOadir)n a continuacin del parBntesis cerrado %ue encierra a los par)metros del constructor7 antes del cuerpo del constructor y separado del parBntesis por dos puntos V6V. Por ejemplo la implementacin del constructor6 21

Bntero$$Bntero4int v25 valorDv/ 7 =uedar0a as06 Bntero$$Bntero4int v2$valor4v2 5 7

*obrecarga de constructores
/os constructores son ,unciones7 y por ende en C++7 tam+iBn pueden de,inirse *arios ,unciones con el mismo nom+re Ken nuestro caso constructoresL para cada clase7 es decir7 el constructor puede so+recargarse. /a Anica limitacin Kcomo en todos los casos de so+recargaL es %ue no pueden declararse *arios constructores con el mismo nAmero y el mismo tipo de argumentos. Por ejemplo7 es posi+le agregar un constructor adicional a la clase Entero %ue simule el constructor por de,ecto6 class Bntero5 !rivate$ 66atributos int valor/ !ublic$ 66constructores Bntero4int2/ Bntero42/ 66m,todos Bntero sumar4Bntero2/ Bntero restar4Bntero2/ Bntero inv%d42/ void setCalor4int2/ int getCalor42/ 7/ Bntero$$Bntero4int v25 valorDv/ 7 Bntero$$Bntero42$valor4I257 66iniciali#a en cero el valor del entero en caso de 1ue no se use el otro constructor 22

Constructores con argumentos por de%ecto

Tam+iBn pueden asignarse *alores por de,ecto a los argumentos del constructor7 de este modo se reduce signi,icati*amente el nAmero de constructores necesarios. /a asignacin se reali4a en la de,inicin del constructor El ejemplo muestra la clase Entero :aciendo uso de un constructor el cual tiene su Anico argumento por de,ecto y este *alor es igual a cero.

class Bntero5 !rivate$ 66atributos int valor/ !ublic$ 66constructor Bntero4intDI2/ 66m,todos Bntero sumar4Bntero2/ Bntero restar4Bntero2/ Bntero inv%d42/ void setCalor4int2/ int getCalor42/ 7/ Bntero$$Bntero4int v25 valorDv/ 7 9i la ,uncin main es la siguiente6 Entero glM int main 425 Bntero a/ cout>>gl.getCalor42>>J , J>> a.getCalor42>>endl/ 7 /a salida ,uera esta6 070

2!

ba %ue al no reali4ar las instancias de los o+jetos con *alores7 el compilador los iniciali4a de acuerdo a la de,inicin del los argumentos por de,ecto presente en la de,inicin del constructor7 el cual es cero.

Constructor copia
"n constructor de este tipo crea un o+jeto a partir de otro o+jeto e>istente. Estos constructores slo tienen un argumento7 %ue es una re,erencia a un o+jeto de su misma clase. En general7 los constructores copia tienen la siguiente ,orma para sus prototipos6 ti!o3clase$$ti!o3clase4const ti!o3claseK2/ b para su implementacin6 ti!o3clase$$ti!o3clase4const ti!o3claseK ob.25 >cdigo del constructor? 7 El ejemplo muestra la clase Entero :aciendo uso de un constructor con argumento por de,ecto y la implementacin del constructor de copia. class Bntero5 !rivate$ 66atributos int valor/ !ublic$ 66constructores Bntero4intDI2/ Bntero4const Bntero K2/ 66constructor co!ia 66m,todos Bntero sumar4Bntero2/ Bntero restar4Bntero2/ Bntero inv%d42/ void setCalor4int2/ int getCalor42/ 7/ Bntero$$Bntero4int v25 valorDv/ 7 2'

66im!lementacin del constructor co!ia Bntero$$Bntero4const BnteroK ob.25 valorDob..valor/ 7 El siguiente ejemplo muestra el uso del constructor copia6 int main 42 5 Bntero a4L2/ cout>>a.getCalor42>>endl/ Bntero bDa/ 66uso !or de)ecto del constructor co!ia cout>>b.getCalor42>>endl/ Bntero c4b2/ 66uso eM!lcito del constructor co!ia. cout>>c.getCalor42>>endl/ cin.get42/ return I/ 7

Destructores
/os destructores son mBtodos especiales %ue sir*en para eliminar un o+jeto de una determinada clase. El destructor reali4ar) procesos necesarios cuando un o+jeto termine su )m+ito temporal7 por ejemplo li+erando la memoria din)mica utili4ada por dic:o o+jeto o li+erando recursos usados7 como ,ic:eros7 dispositi*os7 etc. Al igual %ue los constructores7 los destructores tam+iBn tienen algunas caracter0sticas especiales6 Tam+iBn tienen el mismo nom+re %ue la clase a la %ue pertenecen7 pero tienen el s0m+olo c delante. ?o tienen tipo de retorno7 y por lo tanto no retornan ningAn *alor. ?o tienen par)metros. ?o pueden ser :eredados. De+en ser pA+licos7 no tendr0a ningAn sentido declarar un destructor como pri*ado7 ya %ue siempre se usan desde el e>terior de la clase7 ni tampoco como protegido7 ya %ue no puede ser :eredado. ?o pueden ser so+recargados7 lo cual es lgico7 puesto %ue no tienen *alor de retorno ni par)metros7 no :ay posi+ilidad de so+recarga. Cuando se de,ine un destructor para una clase7 Bste es llamado autom)ticamente cuando se a+andona el )m+ito en el %ue ,ue de,inido. Esto es as0 sal*o cuando el o+jeto ,ue creado din)micamente con el operador ne<7 ya %ue en ese caso7 cuando es necesario eliminarlo7 :ay %ue :acerlo e>pl0citamente usando el operador delete. 23

En general7 los destructores tienen la siguiente ,orma para sus prototipos6 ti!o3clase$$Nti!o3clase42/ b para su implementacin6 ti!o3clase$$Nti!o3clase425 >cdigo del destructor? 7

)e"erencias
P-d-7 9al*ador. C++ con clase P5ecurso disponi+le en En l0neaQ E:ttp6NNc.conclase.netNF PCitado en 2011N02N0!Q.

.0

Cali%icadores& Clases ' %unciones amigas.

Introduccin.
El presente capitulo tiene como o+jeti*o dar al lector los conceptos relacionados con algunos cali,icadores de C++ tales como const y static7 tam+iBn se a+ordar)n los conceptos de clases y ,unciones amigas7 as0 como el uso del apuntador t:is.

El cali"icador const
Es un principio de +uenas practicas de programacin identi,icar %ue o+jetos necesitan ser modi,ica+les y cuales nos. /a pala+ra reser*ada const permite especi,icar %ue un o+jeto no es modi,ica+le y %ue cual%uier intento de modi,icarlo7 resulte en un error de compilacin. Ejemplo6 const <ora medio3dia48;,I,I2/ Declara un o+jeto constante medioHdia de tipo #ora y es iniciali4ado con 12600600. Cuando se aplica el cali,icador const a un o+jeto de una clase7 C++ des:a+ilita todas las operaciones %ue son miem+ros de la clase a no ser %ue la operacin tam+iBn :alla sido declarada como const. Ademas el compilador no permite %ue las operaciones declaradas como const puedan modi,icar atri+utos de la clase. Para ilustrar con un ejemplo7 se tendr) en cuenta la de,inicin del la clase #ora6 class #oraU pri*ate6 int :orasM int minutosM int segundosM pu+lic6 *oid set#orasKintLM *oid set(inutosKintLM *oid set9egundosKintLM int get#orasK*oidLM int get(inutosK*oidLM int get9egundosK*oidLM #ora sumarK#oraLM #ora restarK#oraLM int a(inutosKLM

.1

int a9egundosKLM *oid mostrar/ocalKLM *oid mostrar(ilitarKLM #oraKintW07intW07intW0LM YM 9uponga %ue se desea usar una ,uncin llamada siguiente#oraK#oraIL cuyo o+jeti*o es a*an4ar una :ora el o+jeto de tipo #ora el cual es pasado por par)metro6 *oid siguiente#oraK#oraI :LU :.set#orasK:.get#orasKL+1LM Y A:ora en la ,uncin main se declaran dos o+jetos de tipo #ora en la %ue se de,ine uno de ellos como constante6 int mainKL U const #ora medioHdiaK127070LM NNmedioHdia7 declarado constante #ora otraK1!7070LM siguiente#oraKotraLM NN-G otra.mostrar(ilitarKLM NN1'600600 siguiente#oraKmedioHdiaLM NNError in*alida iniciali4acin de re,erencia de tipos medioHdia.mostrar(ilitarKLM NNError los mBtodos no declarados como const son descartados return 0M Y El primer error ocurre de+ido a %ue se esta tratando de pasar por re,erencia un o+jeto %ue esta de,inido como const7 recuerde %ue cuando un par)metro de una ,uncin es pasado por re,erencia7 Bste Altimo puede ser modi,icado en el cuerpo de la ,uncin lo cual ese intento para un o+jeto declarado como const no esta permitido generando un error de compilacin. Para resol*er este pro+lema la Anica solucin ser0a %uitar el cali,icador const en la declaracin de la *aria+le7 o a+stenerse de modi,icar el o+jeto. El segundo error ocurre al llamar una operacin del o+jeto %ue no esta declarado como const7 recuerde %ue a los o+jetos declarados como const7 C++ des:a+ilita todas las operaciones %ue son miem+ros de la clase %ue no :alla sido declarada con ese cali,icador. Para :a+ilitar el uso de operaciones para los o+jetos declarados como const estos de+en ser cali,icados como constante en la de,inicin de la clase. Es altamente recomendado %ue las operaciones tanto de salida KgettersL como las de impresin K!rintL sean cali,icadas con const. Para nuestro ejemplo la de,inicin de la clase #ora7 teniendo en cuenta la cali,icacin seria la siguiente6

.2

class #oraU pri*ate6 int :orasM int minutosM int segundosM pu+lic6 *oid set#orasKintLM *oid set(inutosKintLM *oid set9egundosKintLM int get#orasK*oidL const M NN mBtodo get7 normalmente declarada como const int get(inutosK*oidL const M NN mBtodo get7 normalmente declarada como const int get9egundosK*oidL const M NN mBtodo get7 normalmente declarada como const #ora sumarK#oraLM #ora restarK#oraLM int a(inutosKLM int a9egundosKLM *oid mostrar/ocalKL const M NN mBtodo de impresion7 normalmente declarada como const *oid mostrar(ilitarKL const M NN mBtodo de impresion7 normalmente declarada como const #oraKintW07intW07intW0LM YM /a implementacin de los mBtodos cali,icados ser0a la siguiente6 int #ora66get#orasKL const Ureturn :orasMY int #ora66get(inutosKL const Ureturn minutosMY int #ora66get9egundosKL const Ureturn segundosMY *oid #ora66mostrar(ilitarKL const U K:orasE10L&coutEEV0VEE:orasEEV6V6coutEE:orasEEV6VM KminutosE10L& coutEEV0VEEminutosEEV6V6coutEEminutosEEV6VM KsegundosE10L& coutEEV0VEEsegundosEEendl6coutEEsegundosEEendlM ..

Y *oid #ora66mostrar/ocalKL const U K:orasE10L&coutEEV0VEE:orasEEV6V6K:orasF12L&coutEE:orase12EEV6V6coutEE:orasEEV6VM KminutosE10L& coutEEV0VEEminutosEEV6V6coutEEminutosEEV6VM KsegundosE10L& coutEEV0VEEsegundos6coutEEsegundosM K:orasF12L&coutEEV P(VEEendl6coutEEV A(VEEendlM Y Teniendo el cuenta tanto la ,unciones main como siguiente#oraK#oraIL y la correcta cali,icacin de las operaciones constantes7 la salida esperada para estas ,unciones es6 *oid siguiente#oraK#oraI :LU :.set#orasK:.get#orasKL+1LM Y int mainKL U const #ora medioHdiaK127070LM NNmedioHdia7 declarado constante #ora otraK1!7070LM siguiente#oraKotraLM NN-G otra.mostrar(ilitarKLM NN1'600600 medioHdia.mostrar(ilitarKLM NN12600600 return 0M Y

El cali"icador static
Ciertos miem+ros de una clase pueden ser declarados como static. /os miem+ros static tienen algunas propiedades especiales. En el caso de los datos miem+ro static slo e>istir) una copia %ue compartir)n todos los o+jetos de la misma clase. Al consultar el *alor de ese dato desde cual%uier o+jeto de esa clase se o+tendr) siempre el mismo resultado7 y si es modi,icado7 se modi,icar) para todos los o+jetos. Por ejemplo7 para la de,inicin de la clase #ora6 .8

class #oraU pri*ate6 int :orasM int minutosM int segundosM pu+lic6 *oid set#orasKintLM *oid set(inutosKintLM *oid set9egundosKintLM int get#orasK*oidL const M NN mBtodo get7 normalmente declarada como const int get(inutosK*oidL const M NN mBtodo get7 normalmente declarada como const int get9egundosK*oidL const M NN mBtodo get7 normalmente declarada como const #ora sumarK#oraLM #ora restarK#oraLM int a(inutosKLM int a9egundosKLM *oid mostrar/ocalKL const M NN mBtodo de impresion7 normalmente declarado como const *oid mostrar(ilitarKL const M NN mBtodo de impresion7 normalmente declarado como const #oraKintW07intW07intW0LM YM 9i %uisiBsemos sa+er cuantos o+jetos de tipo #ora :an sido instanciados en la ejecucin de un programa7 ser0a necesario tener un atri+uto %ue ,uera compartido por todos los o+jetos de esa clase7 de tal manera %ue pudiese lle*ar la cuenta del nAmero de o+jetos instanciados. Entonces para resol*er esa in%uietud :a+r0a %ue agregar un nue*o atri+uto de tipo entero llamado nroInstancias7 lo cual para %ue sea compartido por todos los miem+ros de la clase7 este de+e ser declarado de la siguiente ,orma6 static int nroInstanciasM ?ote %ue la pala+ra reser*ada static precede la declaracin del tipo de dato. Es necesario declarar e iniciali4ar los miem+ros static de la clase7 esto es por dos moti*os. El primero es %ue los miem+ros static de+en e>istir aun%ue no e>ista ningAn o+jeto de la clase7 declarar la clase no crea los datos miem+ro est)ticos7 en necesario :acerlo e>pl0citamente. El segundo es por%ue no lo :iciBramos7 al declarar o+jetos de esa clase los *alores de los miem+ros est)ticos estar0an inde,inidos7 y los resultados no ser0an los esperados. /a ,orma de iniciali4ar el atri+uto est)tico Ky en general cual%uier atri+uto est)ticoL es el siguiente6 .1

int #ora66nroInstanciasW0M En el caso de la operaciones miem+ro static7 estas no pueden acceder a los miem+ros de los o+jetos7 slo pueden acceder a los datos miem+ro de la clase %ue sean static7 ademas7 las operaciones declaradas static no pueden ser declaradas como const. Para nuestro ejemplo se desarrolla un mBtodo %ue muestre el nAmero de instancias7 su de,inicin en la clase #ora ser0a 6 static int get?roInstanciasKL M Con +ase a lo anterior7 la de,inicin e implementacin de los atri+utos y mBtodos est)ticos en la clase #ora seria6 class #oraU pri*ate6 int :orasM int minutosM int segundosM NNatri+utos declarados static static int nroInstanciasM pu+lic6 f NNmetodos declarados static static int get?roInstanciasKL M YM NNiniciali4acin de un atri+uto est)tico int #ora66 nroInstanciasW0M NNimplementacin del mBtodo est)tico static int #ora66get?roInstanciasKL Ureturn nroInstanciasMY #ora66#oraKint :7 int m7 int sL U set#orasK:LM set(inutosKmLM set9egundosKsLM NNcuenta las instancias creadas .2

nroInstancias++M Y 9i la ,uncin main es la siguiente6 int mainKL U #ora :17:27:.M coutEE#ora66get?roInstanciasKLEEendlM return 0M Y la salida es .. /os mBtodos declarados como static suelen ser usados con su nom+re completo7 incluyendo el nom+re de la clase y el operador de )m+ito K66L.

El apuntador t*is
Es un apuntador %ue tiene asociado cada o+jeto y %ue apunta a si mismo. Ese a se puede usar7 y de :ec:o se usa7 para acceder a sus miem+ros. Ejemplo6 teniendo en cuenta la de,inicin de la clase Entero6 class EnteroU pri*ate6 int *alorM pu+lic6 Entero sumarKEnteroLM Entero restarKEnteroLM Entero in*AdKLM *oid set@alorKintLM int get@alorKL constM EnteroKintW1LM EnteroKconst EnteroILM REnteroKLM YM .!

/os constructores implementados de la siguiente ,orma6 Entero66EnteroKint *alL U *alorW*alM Y Entero66EnteroKconst EnteroI nL U *alorWn.*alorM Y #aciendo uso del apuntador t:is7 pueden ser reimplementados as06 Entero66EnteroKint *alorL U t:isCF*alorW*alorM Y Entero66EnteroKconst EnteroI nL U KXt:isL.*alorWn.*alorM Y

+sando el apuntador t,is para reali)ar llamadas de operaciones en cascada.

-tro uso del apuntador t:is es con el ,in de reali4ar llamadas de operaciones miem+ros en cascada7 es decir7 in*ocar mAltiples operaciones en la misma sentencia. Ejemplo6 en la de,inicin de la clase #ora7 es necesario reescri+ir las operaciones set#orasKintL7 set(inutosKintL y set9egundosKintL7 todas con *alor de retorno #oraI7 con el ,in de :a+ilitar las llamadas de operaciones en cascada6

.'

class #oraU pri*ate6 int :orasM int minutosM int segundosM pu+lic6 #oraI set#orasKintLM #oraI set(inutosKintLM #oraI set9egundosKintLM f YM #oraI #ora66set#orasKint :L U t:isCF:orasW:M return Xt:isM NN:a+ilita la cascada Y #oraI #ora66set(inutosKint mL U i,KmFW20L KXt:isL.minutosW13M else i,KmE0L t:isCFminutosW0M else KXt:isL.minutosWmM return Xt:isM Y #oraI #ora66set9egundosKint sL U i,KsFW20L segundosW13M else i,KsE0L segundosW0M else segundosWsM return Xt:isM Y .3

9i la ,uncin main es esta6 int mainKL U #ora :M :.set#orasK12L.set(inutosK.0L.set9egundosK12LM NNllamada de operaciones en cascada :.mostrar(ilitarKLM :.set#orasK1LM :.mostrar/ocalKLM return 0M Y /a salida esperada es6 126.0612 016.0612 A(

+unciones y clases amigas. -uncin .miga

"na ,uncin amiga de una clase es una ,uncin7 generalmente declarada e implementada por ,uera del )m+ito de la clase7 en la cual7 esta puede acceder a los miem+ros7 tanto pA+lico como pri*ados7 de la clase. Ejemplo6 para la clase Entero7 cuya de,inicin es6 class EnteroU pri*ate6 int *alorM pu+lic6 Entero sumarKEnteroLM Entero restarKEnteroLM Entero in*AdKLM *oid set@alorKintLM int get@alorKLM EnteroKintW1LM EnteroKconst EnteroILM REnteroKLM 80

YM 9e desea desarrollar una ,uncin llamada establecer4BnteroK, int2 de tipo void %ue permita7 esta+lecer el *alor del o+jeto reci+ido como par)metros7 al estilo del manejo de las estructuras en el lenguaje C7 sin :acer uso de los mBtodos de entrada y salida de la clase entonces es necesaria declararla ,riend en la de,inicin de la clase tal como se muestra a continuacin6 class EnteroU pri*ate6 int *alorM pu+lic6 ,riend *oid esta+lecerKEnteroI7 intLM NNdeclaracin de la ,uncin amiga NNmBtodos f YM NNimplementacin de la ,uncin amiga *oid esta+lecerKEnteroI n7 int *L U n.*alorW*M NNacceso a los miem+ros pri*ados del o+jeto Y NNimplementacin de los mBtodos f El uso de la ,uncin amiga no di,iere de las dem)s ,unciones7 por ejemplo7 note su uso en la ,uncin main. int mainKLU Entero aM esta+lecerKa71LM coutEE ` el *alor de a es aEEa.get@alorKLEEendlM NNmuestra 1 Y

Clase .miga
9e dice %ue una clase A es amiga de una clase D cuando esta ultima puede acceder a los miem+ros7 tanto pA+lico como pri*ados7 de la clase A.

81

/a amistad entre clases es otorgada mas no tomada7 es decir %ue si la clase A es amiga de la clase D y la clase D es amiga de la clase C7 esto no %uiere decir %ue la clase C sea amiga de la clase A7 ya %ue para ello de+e e>istir un contrato entre la clase A y C respecti*amente. Para declara %ue todos los miem+ros de la clase A son amigos de la clase D de+e declararse en la de,inicin de la clase D la siguiente sentencia6 ,riend class A Ejemplo6 note la de,inicin de la clase ;ec:a6 class ;ec:aU pri*ate6 int diaM int mesM int agnioM #ora :oraM static int dias>mesP12QM pu+lic6 ;ec:aKint7int7int7#oraLM NNdia7 mes7 aOo7 :ora ;ec:aI setDiaKintLM ;ec:aI set(esKintLM ;ec:aI setAgnioKintLM +ool esDisiestoKLM int contarDiasKconst ;ec:aILM string mostrar;ormaCortaKL constM string mostrar;orma/argaKL constM NNdeclaracin de la clase #ora como amiga de la clase ;ec:a ,riend class #oraM YM

)e"erencias
DEITE/ #. (. I DEITE/ P. ^. C++6 :o< to program. 2 edicion. Prentice #all7 I9D?6 0C1.C211210C.. ?e<^ersey. 200'.

82

.signacin dinmica de memoria.

Introduccin.
El presente capitulo tiene como o+jeti*o dar al lector los conceptos relacionados con la asignacin din)mica de memoria7 primero en el predecesor Klenguaje CL as0 como en C++. 9e e>plorar) el uso de los operadores de C++ ne< y delete7 tam+iBn se a+ordar)n los conceptos de composicin de clases.

De"inicin de asignacin din,mica de memoria

/a asignacin din)mica de memoria es una caracter0stica de C y C++. /e permite al usuario crear tipos de datos y estructuras de cual%uier tamaOo de acuerdo a las necesidades %ue se tengan en la solucin del pro+lema por computadora.

#signacin din,mica en C
/a ,uncin malloc es empleada comAnmente para intentar `tomara una porcin contigua de memoria. Esta de,inida como6 *oid XmallocKsi4eHt si4eLM /o anterior indica %ue regresar) un apuntador del tipo *oid X7 el cual es el inicio en memoria de la porcin reser*ada de tamaOo si4e. 9i no puede reser*ar esa cantidad de memoria la ,uncin regresa un apuntador nulo o ?"// Dado %ue *oid X es regresado7 C asume %ue el apuntador puede ser con*ertido a cual%uier tipo. El tipo de argumento si4eHt esta de,inido en la ca+ecera stdde,.: y es un tipo entero sin signo. Por lo tanto6 c:ar XcpM cp W Kc:ar XL mallocK100LM Intenta o+tener 100 +ytes y asignarlos a la direccin de inicio a cp. Es usual usar la ,uncin si4eo,KL para indicar el nAmero de +ytes7 por ejemplo6 int XipM ip W Kint XL mallocK100 X si4eo,KintL LM El compilador de C re%uiere :acer una con*ersin del tipo. /a ,orma de lograr la coercin KcastL es usando Kc:ar XL y Kint XL7 %ue permite con*ertir un apuntador *oid a un apuntador tipo c:ar e int respecti*amente. #acer la con*ersin al tipo de apuntador correcto asegura %ue la aritmBtica con el apuntador ,uncionar) de ,orma correcta. Es una +uena pr)ctica usar si4eo,KL aAn si se conoce el tamaOo actual del dato %ue se re%uiere7 ya %ue de esta ,orma el cdigo se :ace independiente del dispositi*o Kporta+ilidadL. /a ,uncin si4eo,KL puede ser usada para encontrar el tamaOo de cual%uier tipo de dato7 *aria+le o estructura. 9implemente se de+e proporcionar uno de los anteriores como argumento a la ,uncin. 8.

Por lo tanto6 int iM struct C--5D U,loat >7y74YM struct C--5D XptM si4eo,KintL7 si4eo,KiL7 si4eo,Kstruct C--5DL y si4eo,KptL son tam+iBn sentencias correctas. En el siguiente ejemplo se reser*a memoria para la *aria+le ip7 en donde se emplea la relacin %ue e>iste entre apuntadores y arreglos7 para manejar la memoria reser*ada como un arreglo. Por ejemplo7 se pueden :acer cosas como6 mainKL U int Xip7 iM ip W Kint XL mallocK100 X si4eo,KintL LM ipP0Q W 1000M ,or KiW0M iE100M ++iL scan,KVedV7ip++LM Y E>isten dos ,unciones adicionales para reser*ar memoria7 calloc42 y realloc42. /os prototipos son dados a continuacin6 *oid XcallocKsi4eHt nmem+7 si4eHt si4eLM *oid XreallocK*oid Xptr7 si4eHt si4eLM Cuando se usa la ,uncin mallocKL la memoria no es iniciali4ada Ka ceroL o +orrada. 9i se %uiere iniciali4ar la memoria entonces se puede usar la ,uncin calloc. /a ,uncin calloc es computacionalmente un poco m)s cara pero7 ocasionalmente7 m)s con*eniente %ue malloc. 9e de+e o+ser*ar tam+iBn la di,erencia de sinta>is entre calloc y malloc7 ya %ue calloc toma el nAmero de elementos deseados Knmem+L y el tamaOo del elemento Ksi4eL7 como dos argumentos indi*iduales. Por lo tanto para asignar a 100 elementos enteros %ue estBn iniciali4ados a cero se puede :acer6 int XipM ip W Kint XL callocK1007 si4eo,KintL LM /a ,uncin realloc intenta cam+iar el tamaOo de un +lo%ue de memoria pre*iamente asignado. El nue*o tamaOo puede ser m)s grande o m)s pe%ueOo. 9i el +lo%ue se :ace m)s grande7 entonces el contenido anterior permanece sin cam+ios y la memoria es agregada al ,inal del +lo%ue. 9i el tamaOo se :ace m)s pe%ueOo entonces el contenido so+rante permanece sin cam+ios. 9i el tamaOo del +lo%ue original no puede ser so+redimensionado7 entonces realloc intentar) asignar un nue*o +lo%ue de memoria y copiar) el contenido anterior. Por lo tanto7 la ,uncin de*ol*er) un nue*o apuntador Ko de *alor di,erente al anteriorL7 este nue*o *alor ser) el %ue de+er) usarse. 9i no puede ser reasignada nue*a memoria la ,uncin realloc de*uel*e ?"//. 9i para el ejemplo anterior7 se %uiere reasignar la memoria a 10 enteros en *e4 de 100 apuntados por ip7 88

se :ar)6 ip W Kint XL realloc K ip7 10Xsi4eo,KintL LM la ,uncin )ree li+era la memoria asignada por cual%uiera de las ,unciones de asignacin pre*iamente mencionadas. El prototipo de la ,uncin ,ree se muestra a continuacin6 *oid ,ree K*oidX ptrLM 9i se desea li+erar la memoria asignada al apuntador ip se :ar)6 i,KipgW?"//L ,reeKipLM

#signacin din,mica en C++

El C cl)sico proporciona ,ormas espec0,icas de solicitar al compilador %ue reser*e yNo inicie espacio de tamaOo ar+itrario en el montn. Tam+iBn dispone de ,ormas para re:usarlo cuando ya no se considera necesario. 9on las ,unciones de li+rer0a malloc7 calloc7 realloc y ,ree. C++ mantiene Kpor compati+ilidadL las ,ormas cl)sicas7 pero introduce cuatro nue*os operadores6 ne<7 delete7 ne< P Q y delete P Q7 %ue no solo crean y re:Asan espacio de ,orma m)s cmoda y e,iciente7 sino %ue incluso pueden crear o+jetos persistentes. /os dos primeros se utili4an para o+jetos de cual%uier tipo7 mientras %ue ne< P Q y delete P Q se usan con matrices.

El operador ne/
El operador ne< Kpala+ra cla*e C++L proporciona espacio de almacenamiento persistente7 similar pero superior a la ,uncin de /i+rer0a Est)ndar malloc. Este operador permite crear un o+jeto de cual%uier tipo7 incluyendo tipos de,inidos por el usuario7 y de*uel*e un puntero Kdel tipo adecuadoL al o+jeto creado. 9inta>is6 P66Qne< PEempla4amientoFQ EtipoF PKEiniciali4acinFLQ P66Qne< PEempla4amientoFQ KEtipoFL PKEiniciali4acinFLQ P66Qne< PEempla4amientoFQ EtipoFPEnAmeroHelementosFQ P66Qne< PEempla4amientoFQ KEtipoFLPEnAmeroHelementosFQ El operador opcional 66 est) relacionado con la so+recarga de operadores. /o mismo se aplica a empla4amiento. /a iniciali4acin7 si aparece7 se usar) para asignar *alores iniciales a la memoria reser*ada con ne<7 pero no puede ser usada con arreglos. /as ,ormas tercera y cuarta se usan para reser*ar memoria para arreglos din)micos. /a memoria reser*ada con ne< ser) *)lida :asta %ue se li+ere con delete o :asta el ,in del programa7 aun%ue es aconseja+le li+erar siempre la memoria reser*ada con ne< usando delete. 9e considera una pr)ctica muy sospec:osa no :acerlo. 9i la reser*a de memoria no tu*o B>ito7 ne< de*uel*e un puntero nulo7 ?"//. /as di,erencias de ne< con las ,unciones malloc y calloc de las li+rer0as C tradicionales comportan una 81

clara *entaja a ,a*or de la primera6 malloc y calloc de*uel*en un puntero a *oid7 mientras %ue ne< de*uel*e un puntero con,ormado al tipo espec0,ico del o+jeto creado. malloc y calloc simplemente reser*an memoria Kcalloc la iniciali4a a 0L7 mientras %ue ne< construye el o+jeto7 lo %ue :ace %ue este operador estB estrec:amente relacionado con los constructores cuando se aplica a clases. ne< y delete pueden ser so+recargados como el resto de los operadores7 lo %ue comporta ciertas *entajas adicionales. ;ec:aX p,Wne< ;ec:aP.0QM Asigna din)micamente memoria al apuntador p, de tipo ;ec:a o+teniendo un arreglo de .0 o+jetos de tipo ,ec:a.

Ejemplos6

El operador delete
El operador delete se usa para li+erar la memoria din)mica reser*ada con ne<. 9inta>is6 P66Qdelete PEe>presinFQ P66QdeletePQ PEe>presinFQ /a e>presin ser) normalmente un puntero7 el operador deletePQ se usa para li+erar memoria de arreglos din)micos. Es importante li+erar siempre usando delete la memoria reser*ada con ne<. E>iste el peligro de pBrdida de memoria si se ignora esta regla. Cuando se usa el operador delete con un puntero ?"//7 no se reali4a ninguna accin. Esto permite usar el operador delete con punteros sin necesidad de preguntar si es nulo antes. De todos modos7 es +uena idea asignar el *alor 0 a los punteros %ue no :an sido iniciali4ados y a los %ue :an sido li+erados. Tam+iBn es +ueno preguntar si un puntero es nulo antes de intentar li+erar la memoria din)mica %ue le ,ue asignada. Ejemplo6 ;ec:aX p,Wne< ;ec:aP.0QM f i,Kp,gW?"//L delete p,M

Caso de estudio# la clase Pila

"na pila KstacO en inglBsL es una lista ordinal o estructura de datos en la %ue el modo de acceso a sus elementos es de tipo /I;- Kdel inglBs Past +n Qirst Out7 Altimo en entrar7 primero en salirL %ue permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el )rea de 82

in,orm)tica de+ido a su simplicidad y ordenacin impl0cita de la propia estructura. En el paradigma de la Programacin -rientada a -+jetos la Pila puede de,inirse como un Ti!o %bstracto de &atos la cual tiene como atri+utos un arreglo ,inito de tamaOo n y cuatro operaciones a sa+er6 meter6 agrega un elemento a la cima de la pila. sacar6 %uita el elemento %ue esta en la cima de la pila. estaPlena6 indica si la pila :a superado el m)>imo nAmero de elementos %ue puede almacenar. estaCacia6 indica si la pila no tiene elementos. En C++ la de,inicin de este Ti!o %bstracto de &atos se muestra a continuacin6 class PilaU pri*ate6 int tamM int XcontenidoM int indM pu+lic6 PilaKintLM RPilaKLM *oid meterKintLM int sacarKLM +ool esta@aciaKLM +ool esta/lenaKLM YM En la de,inicin del arreglo de tamaOo ,inito n7 se :ace uso de la asignacin din)mica de memoria con el ,in de usar un uso e,iciente de la memoria Kni un +it mas7 ni un +its menosL de acuerdo a las necesidades o re%uerimientos de la aplicacin. En el constructor se :ace uso del operador ne<7 para crear un arreglo de tipo int de tamaOo n6 Pila66PilaKint nLU i,KnF0L tamWnM else tamW10M contenidoWne< intPtamQM indW0M Y 8!

En el destructor se :ace el uso del operador delete7 con el ,in de li+erar la memoria asignada por ne<6 Pila66RPilaKL U i,KcontenidogW?"//L delete contenidoM Y /a implementacin de las dem)s operaciones de la clase Pila K meter, sacar, estaPlena, estaCaciaL se muestran a continuacin6 *oid Pila66meterKint *L U i,Kesta/lenaKLL coutEEVla pila esta llenaVEEendlM else U contenidoPindQW*M ind++M Y Y int Pila66sacarKLU int *WC1M i,Kesta@aciaKLL coutEEVla pila esta *aciaVEEendlM else U *WcontenidoPindC1QM indCCM Y return *M Y +ool Pila66esta@aciaKLU return KindC1E0L&true6,alseM Y 8'

+ool Pila66esta/lenaKL U return KindWWtamL&true6,alseM Y

Composicin y agregacin de clases

En el paradigma de la Programacin -rientada a -+jetos7 Para modelar o+jetos complejos7 no +astan los tipos de datos +)sicos %ue pro*een los lenguajes6 enteros7 reales y secuencias de caracteres. Cuando se re%uiere componer o+jetos %ue son instancias de clases de,inidas por el desarrollador de la aplicacin7 tenemos dos posi+ilidades6 Por @alor6 Es un tipo de relacin est)tica7 en donde el tiempo de *ida del o+jeto incluido esta condicionado por el tiempo de *ida del %ue lo incluye. Este tipo de relacin es comAnmente llamada Composicin Kel -+jeto +ase se construye a partir del o+jeto incluido7 es decir7 es VparteNtodoVL. Por 5e,erencia6 Es un tipo de relacin din)mica7 en donde el tiempo de *ida del o+jeto incluido es independiente del %ue lo incluye. Este tipo de relacin es comAnmente llamada Agregacin Kel o+jeto +ase utili4a al incluido para su ,uncionamientoL. "n Ejemplo7 :aciendo uso de un diagrama de clases del /enguaje "ni,icado de (odelado K"(/L7 es el siguiente6

En donde se destaca %ue6 "n AlmacBn posee Clientes y Cuentas Klos rom+os *an en el o+jeto %ue posee las re,erenciasL. Cuando se destruye el -+jeto AlmacBn tam+iBn son destruidos los o+jetos Cuenta asociados7 en cam+io no son a,ectados los o+jetos Cliente asociados. /a composicin Kpor @alorL se destaca por un rom+o relleno. /a agregacin Kpor 5e,erenciaL se destaca por un rom+o transparente.

/a ,lec:a en este tipo de relacin indica la na*ega+ilidad del o+jeto re,erencial. Cuando no e>iste este tipo de particularidad la ,lec:a se elimina. En C++ podemos de,inir el modelo mostrado en el diagrama de clases anterior de la siguiente ,orma6

83

class AlmacenU pri*ate6 Cuentas cuentasP100QM NNcomposicin de cuentas por *alor KcomposicinL ClienteX clientesP100QM NNcomposicin de clientes por re,erencia KagregacinL pu+lic6 *oid registrarClienteKClienteXLM Cuentas darCuentasKClienteXLM NN otros mBtodos YM

)e"erencias
TE^EDA7 #Bctor. (anual de C C Asignacin din)mica de memoria y Estructuras din)micas Pen /ineaQ E:ttp6NN<<<.,ismat.umic:.m>Nmn1NmanualNnode10.:tmlFPCitado en 2011N02N13Q dAT-5 9ystems. Curso C++ C -perador ne< Pen /ineaQ E:ttp6NN<<<.4ator.comNCppNE8H3H20.:tmFPCitado en 2011N02N13Q P-d-7 9al*ador. C++ con clase Pen /ineaQ E:ttp6NNc.conclase.netNcursoN&capW01.+FPCitado en 2011N02N13Q 9A/I?A97 Patricio. #itsc:,eld7 ?ancy. "(/ C modelo del clases. Pen /ineaQ E:ttp6NN<<<.dcc.uc:ile.clNRpsalinasNumlNmodelo.:tmlFPCitado en 2011N02N13Q

10

*obrecarga de
Introduccin.

peradores.

El presente capitulo tiene como o+jeti*o dar al lector los conceptos relacionados con la so+recarga de operadores7 :aciendo Bn,asis en los operadores de tipo unario y +inarios. 9e identi,icar)n los operadores %ue pueden ser so+recargados. 9e e>plorar) el uso de la pala+ra reser*ada de C++ operator7 as0 como las di,erentes tBcnicas de so+recarga.

-ue es un operador?
"n operador es un s0m+olo K+7 C7 X7 N7 etcL %ue tiene una ,uncin prede,inida Ksuma7 resta7 multiplicacin7 etcL y %ue reci+e sus argumentos de manera in,ija7 en el caso de tener 2 argumentos Ka operador +L7 o de manera pre,ija o post,ija7 en el caso de tener uno solo Koperador a 7 o +ien7 a operadorL. En CNC++ e>isten una gran *ariedad de operadores7 %ue se pueden agrupar de la siguiente manera6 -peradores aritmBticos -peradores relacionales -peradores lgicos -peradores a ni*el de +it K+it<ise operatorsL -peradores especiales

$a so!recarga de operadores
En C++ el principio de la so+recarga no solo se aplica a ,unciones7 sino tam+iBn a los operadores7 esto permite e>tender el signi,icado de los operadores a los tipos de,inidos por el usuario. De este modo7 un programador puede proporcionar su propio operador de una clase por la so+recarga del operador integrado para reali4ar algAn c)lculo espec0,ico cuando el operador se utili4a con los o+jetos de esa clase. Para so+recargar los operadores se pueden :acer uso de *arias tBcnicas las cuales se conocer)n en el siguiente apartado. /a siguiente lista muestra los operadores en C++ %ue pueden ser so+recargados6 + R ++ +W EEW C g CC CW FFW X 7 EE NW PQ N W FF eW KL e E WW hW CF h F I EW gW IW CFX \ FW II \W ne< \\ XW delete

11

*obrecarga de operadores unarios

"n operador unario7 es a%uel %ue es aplicado a un operando. 9on ejemplos de ellos el operador lgico de negacin KgL7 los operadores de incremento y decremento K++7CCL ya sea en modo pre,ijo y post,ijo7 entre otros. /a sinta>is para so+recargar un operador unario es la siguiente6 En la de,inicin de la clase6 EtipoF operatorEoperador unarioFKLM b en su implementacin6 EtipoF Eidenti,icador de claseF66operatorEoperador unarioFKLU NNCuerpo de la implementacin Y ?ormalmente el EtipoF es la clase para la %ue estamos so+recargando el operador. ?tese %ue en la de,inicin del mBtodo este lle*a la pala+ra reser*ada operator y7 por ser unario7 en la mayor0a de los casos no tiene par)metros ya %ue el proceso se aplica so+re las propiedades de la clase. Como ejemplo o+ser*e la de,inicin de la clase Entero6 class EnteroU pri*ate6 int *alorM pu+lic6 Entero sumarKEnteroLM Entero restarKEnteroLM Entero in*AdKLM *oid set@alorKintLM int get@alorKLM EnteroKintW1LM EnteroKconst EnteroILM REnteroKLM YM 9i se desea so+recargar el operador ++ en pre,ijo7 entonces en la de,inicin de la clase podemos de,inir la so+recarga del operador ++ de la siguiente ,orma6 En la de,inicin de la clase Entero6

12

class EnteroU pri*ate6 int *alorM pu+lic6 Entero operator ++KLM NNso+recarga del operador incremento en pre,ijo NNotros mBtodos ... YM (ientras su implementacin es6 Entero Entero66operator ++KL U ++*alorM return Xt:isM Y Al so+recargar el operador de incremento pre,ijo podemos usarlo de la siguiente ,orma6 int main KL U Entero aM ,orKa.set@alorK0LM a.get@alorKL E 11 M ++aL coutEEa.get@alorKLEEendlM return 0M Y En el caso de la so+recarga del operador incremento pos,ijo7 es necesario %ue se le de,ina un par)metro de tipo int con el ,in de di,erenciarlo del operador incremento pre,ijo. Como ejemplo o+ser*e su de,inicin en la clase Entero6 class EnteroU pri*ate6 int *alorM pu+lic6 Entero operator ++KLM NNoperador incremento pre,ijo Entero operator ++KintLM NNoperador incremento pos,ijo NNotros mBtodos YM (ientras %ue su implementacin es6 1.

Entero Entero66operator ++Kint aL U *alor++M return Xt:isM Y ?tese %ue el par)metro no es usado7 esto solo se :ace con el ,in de e*itar un error sint)ctico cuando se tratase de so+recargar am+os operadores sint)cticamente similares. De igual manera ocurre al so+recargar el operador de decremento tanto en modo pre,ijo como post,ijo.

*obrecarga de operadores binarios

Para so+recargar operadores +inarios K+7C7X7N7e7 Etc.L7 su sinta>is no di,iere del caso de la so+recarga de los operadores unarios7 la di,erencia es %ue7 en la mayor0a de los casos7 reci+e como par)metro7 un o+jeto de la misma clase. 9u sinta>is en la de,inicin de la clase es6 EtipoF operatorEoperador +inarioFKEtipoFLM b en su implementacin6 EtipoF operatorEoperador +inarioFKEtipoF Eidenti,icadorFLU NNimplementacin del cuerpo del mBtodo Y Como ejemplo se *a a so+recargar el operador + con el ,in de reali4ar la adicin entre dos o+jetos de tipo Entero6 class EnteroU pri*ate6 int *alorM pu+lic6 Entero operator ++KLM NNoperador incremento pre,ijo Entero operator ++KintLM NNoperador incremento pos,ijo Entero operator + KEnteroLM NNso+recarga del operador +inario + NNotros mBtodos ... YM "na ,orma de implementar la so+recarga del operador +inario + puede ser la mostrada a continuacin6 Entero Entero66operator +KEntero eL U return sumarKeLM Y

18

-tro operador %ue es muy Atil so+recargar es el de asignacin KWL cuya implementacin en la clase Entero es la siguiente6 EnteroI Entero66operatorWKconst EnteroI eL U i,Kt:isgWIeL Y return Xt:isM Y #ay %ue tener en cuenta la posi+ilidad de %ue se asigne un o+jeto a si mismo. Por eso se compara el puntero t:is con la direccin del par)metro7 si son iguales es %ue se trata del mismo o+jeto7 y no de+emos :acer nada. Esta es una de las situaciones en las %ue el puntero t:is es imprescindi+le. Con +ase a los operadores +inarios so+recargados para la clase Entero7 se pueden escri+ir e>presiones de la siguiente ,orma6 int main KL U Entero aK1L7+K2L7cM cWa++M coutEEc.get@alorKLEEendlM NNmuestra . return 0M Y Tam+iBn es posi+le so+recargar los operadores lgicos como7 por ejemplo los de comparacin KWW7 E7 FL. En el ejemplo se muestra la implementacin de la so+recarga del operador de comparacin menor %ue KEL para la clase Entero. +ool Entero66operatorEKEntero eL U i,K*alorEe.get@alorKLL return trueM else return ,alseM Y Al so+recargar los operadores lgicos7 esto permite %ue los o+jetos puedan ser utili4ados en sentencias condicionales7 u otras %ue :agan uso operaciones lgicas. El siguiente ejemplo :ace uso del operador menor %ue KEL so+recargado6 U set@alorKe.*alorLM

11

int main KL U Entero limK11LM ,orKEntero iK0LMiElimMi++L coutEEi.get@alorKLEEendlM return 0M Y

*obrecarga de operadores ,aciendo uso de %unciones amigas

Tam+iBn es posi+le reali4ar el proceso de so+recarga de operadores usando ,unciones amigas. -+ser*e como ejemplo la implementacin de la so+recarga del operador i :aciendo uso de una ,uncin amiga de la clase Entero6 class EnteroU pri*ate6 int *alorM pu+lic6 ,riend Entero operatorCKEntero7EnteroLM NNde,inicin de la ,uncin amiga NNotros mBtodos ... YM NNImplementacin de la ,uncin amiga Entero operator C KEntero a7 Entero +L U return a.restarK+LM Y ?tese es %ue necesario de,inir los dos argumentos en el caso de la so+recarga de los operaciones +inarios y un argumento en el caso de los operadores unarios de+ido a %ue la ,uncin amiga no :ace parte de la clase. Aun cuando la so+recarga se reali4 utili4ando una ,uncin amiga7 su uso no di,iere de los casos anteriores7 por ejemplo note su uso en la ,uncin main6 int main KL U Entero limK11LM ,orKEntero iK0LMiElimMi++L coutEEKCKlimCiLL.get@alorKLEEendlM return 0M Y

12

)e"erencias
P-?97 5amn. Curso de C C -peradores. P5ecurso disponi+le en /0neaQ E:ttp6NNlaurel.datsi.,i.upm.esNRrponsNpersonalNtra+ajosNcursoHcNnode88.:tmlF PCon Acceso 2011N02N2!Q. P-d-7 9al*ador. C++ con clase Pen /ineaQ E:ttp6NNc.conclase.netNFPCitado en 2011N02N13Q

1!

Mas sobrecargas de
Introduccin.

peradores

El presente capitulo tiene como o+jeti*o e>tender al lector los conceptos relacionados con la so+recarga de operadores7 :aciendo Bn,asis en los operadores de e>traccin e insercin de ,lujos KstreamL. 9e mencionara la de,inicin de la so+recarga de operadores especiales como PQ7 ne< y delete.

.o!recargando los operadores de insercin y e/traccin

/as clases pueden ser adaptadas para %ue sus o+jetos puedan ser e>tra0dos de un ,lujo de entrada KinputL e insertados de un ,lujo de salida KoutputL. /a clase std$$istream de,ine el operador de e>traccin para los tipos +)sicos de datos como int7 c:ar7 ,loat7 dou+le7 +ool7 Etc. /a clase std$$ostream de,ine el operador de insercin para los tipos +)sicos de datos.

*obrecarga del operador de insercin

Es posi+le e>tender la ,uncionalidad del operador de insercin KEEL para los tipos a+stractos de datos de tal ,orma %ue si est) instanciado un o+jeto ob. de la clase MiClase7 la e>presin6 cout>>ob./ (uestre la in,ormacin rele*ante del o+jeto ob. Kpor ejemplo sus propiedades u otro mensaje de,inido por el usuarioL por la salida Ksea pantalla u otra pre*iamente especi,icadaL. En la sentencia cout>>ob. el o+jeto cout7 por ser de la clase ostream7 usa el mBtodo miem+ro o!erator>> de,inido en la clase ostream7 Este operador reci+e dos operandos a sa+er ostreamK y MiClaseK. Para reali4ar la accin re%uerida es necesario so+recargar el operador EE :aciendo uso de ,unciones amigas cuya de,inicin dentro de la clase MiClase es de la siguiente6 ,riend ostreamI operatorEEKostreamI7 const (iClaseIL M 9u implementacin o+edece la siguiente sinta>is6 ostreamI operatorEEKostreamI salida7 const (iClaseI o+jLU NNsentencias return salidaM Y

*obrecarga del operador de e0traccin

Es posi+le e>tender la ,uncionalidad del operador de e>traccin KFFL para los tipos a+stractos de datos de tal ,orma %ue si tenga instanciado un o+jeto ob. de la clase MiClase7 la e>presin6 1'

cin??ob./ E>trae7 de la entrada est)ndar7 la in,ormacin rele*ante del o+jeto ob. de acuerdo a un ,ormato pre*iamente esta+lecido. En la sentencia cin??ob. el o+jeto cin7 por ser de la clase istream7 usa el mBtodo miem+ro o!erator?? de,inido en la clase istream7 Este operador reci+e dos operandos a sa+er istreamK y MiClaseK. Para reali4ar la accin re%uerida es necesario so+recargar el operador FF :aciendo uso de ,unciones amigas cuya de,inicin dentro de la clase MiClase es de la siguiente6 ,riend istreamI operatorFFKistreamI7 (iClaseIL M ?ote %ue am+os argumentos son pasados por re,erencia de tal ,orma %ue7 dentro del cuerpo de la ,uncin7 puedan ser editados las propiedades del o+jeto de nuestra clase. /a implementacin de la ,uncin presenta la siguiente sinta>is6 istreamI operatorEEKistreamI entrada7 (iClaseI o+jLU NNsentencias return entradaM Y

.o!recarga del operador de inde/acin

Es posi+le so+recargar el operador de inde>acin PQ7 es muy Atil para acceder a o+jetos %ue se encuentran dentro de arreglos n - dimensionales. Este solo acepta ser so+recargado como mBtodo de la claseM por ende su de,inicin dentro de la clase o+edece la siguiente sinta>is6 EtipoHde*F operator PQKconst EtipoFI LM (ientras %ue su implementacin es6 EtipoHde*F EclaseF66operator PQKconst EtipoFI LU NNsentencias Y "n o+jeti*o de so+recargar este operador es con el ,in de e*itar accesos ilegales o des+ordamientos cuando se acceden a arreglos de o+jetos de la clase7 la cual se le esta e>tendiendo la ,uncionalidad del operador.

.o!recarga de los operadores ne0 y delete

Tam+iBn es posi+le so+recargar los operadores ne< y delete con el o+jeti*o darle alguna comportamiento especial a los o+jetos de la clase la cual se de,ine la so+recarga de estos operadores. 9u sinta>is en la de,inicin de la clase como mBtodos de Bsta se de,inen a continuacin6 *oidX operator ne<Ksi4eHt tLM *oidX operator ne<PQKsi4eHt tLM *oid deleteK*oidX >LM NNClase Xo+jW new ClaseM NNClase Xo+jW new ClasePnQM NNdelete o+jM 13

*oid deletePQK*oidX >LM

NNdeletePQ o+jM

9u implementacin no di,iere de las implementaciones de los mBtodos de la clase.

Caso de estudio1 #rreglos Din,micos

En las ciencias de la computacin7 un arreglo din)mico es una estructura de datos7 de acceso aleatorio y tamaOo *aria+le %ue permite agregar o %uitar elementos. En el paradigma de la programacin orientada a o+jetos este puede de,inirse como un Tipo A+stracto de Datos el cual como atri+utos tendr0a un apuntador :acia el tipo de datos y un nAmero %ue indica la longitud de esteM como operaciones +)sicas se de,ine6 agregar4v$ ti!o26 agrega el *alor * al ,inal del arreglo 1uitar4!$ entero26 %uita del arreglo el *alor u+icado en la posicin p getCalor4!$entero2$ de*uel*e el *alor almacenado en la posicin p setCalor4!$entero,v$entero2 esta+lece * como el *alor u+icado en la posicin p del arreglo. Entre otras. En C++ es posi+le de,inir el TAD mencionado anteriormente como una Clase la cual7 su inter,a4 es puesta a continuacin6 class ArregloDinamicoU pri*ate6 intX arregloM int longitudM NNtamaOo del arreglo pu+lic6 ArregloDinamicoKintW0LM RArregloDinamicoKLM *oid set@alorKint7intLM NN*alor7 posicin *oid agregarKintLM NNagrega el *alor al ,inal del arreglo *oid %uitarKintLM NN%uita el *alor u+icado la posicin del arreglo int get@alorKintL constM NNda el *alor segAn la posicin int get/ongitudKL constM NNde*uel*e la longitud del arreglo *oid set/ongitudKintLM NNreasigna el tamaOo del arreglo ArregloDinamico operator +Kconst ArregloDinamicoILM NNconcatena dos arreglos NNso+recarga de los operadores de e>traccin e insercin de ,lujos ,riend istreamI operatorFFKistreamI7 ArregloDinamicoILM ,riend ostreamI operatorEEKostreamI7 const ArregloDinamicoILM YM

20

-+ser*e la implementacin de las ,unciones amigas %ue so+recargan los operadores de e>traccin e insercin de ,lujos6 ostreamI operator EEKostreamI salida7 const ArregloDinamico IaLU salidaEEVUVM ,orKint iW0MiEa.get/ongitudKLMi++L salidaEEa.get@alorKiLEEKKiEa.get/ongitudKLC1L&V7V6VYVLM return salidaM Y /a salida KcoutL es una arreglo de la ,orma Ua7+7c7d7e7...7nY siendo cada uno de los elementos enteros. (ientras %ue la entrada KcinL es de la ,orma Ua7+7c7d7e7...7nY siendo cada uno de los elementos enteros6 istreamI operatorFFKistreamI entrada7 ArregloDinamico IaLU c:ar cM int *alorM a.set/ongitudK0LM entradaFFcM i,KcWWjUjL U entradaFF*alorFFcM i,KcgWj7jIIcgWjYjL entrada.clearKiosH+ase66+ad+itLM else a.agregarK*alorLM Y Y return entradaM Y /a implementacin de los dem)s mBtodos se descri+e a continuacin6
ArregloDinamico::ArregloDinamico(int n) { longitud=0; if(n>0) { longitud=n;

<:ileKcgWjYjLU

21

arreglo= new int[longitud]; for(int i=0;i<longitud;i++) arreglo[i]=0; } }

ArregloDinamico::~ArregloDinamico() { delete arreglo; }

void ArregloDinamico::agregar(int v) { if(longitud>0) { int* arreglotemp=new int[longitud+1]; for(int i=0;i<longitud;i++) arreglotemp[i]=arreglo[i]; arreglotemp[longitud]=v; delete arreglo; arreglo= new int[longitud+1]; for(int i=0;i<=longitud;i++) arreglo[i]=arreglotemp[i]; delete arreglotemp; } else { arreglo= new int[1]; arreglo[0]=v; } longitud++; }

22

void ArregloDinamico::quitar(int p) { if(p>=0&&p<longitud) { int* arreglotemp=new int[longitud-1]; int t=0; for(int i=0;i<longitud;i++) { if(i!=p) { arreglotemp[t]=arreglo[i]; t++; } } delete arreglo; arreglo= new int[longitud-1]; for(int i=0;i<longitud-1;i++) arreglo[i]=arreglotemp[i]; delete arreglotemp; longitud--; } }

void ArregloDinamico::setValor(int p, int v) { if(p>=0&&p<longitud) arreglo[p]=v; }

int ArregloDinamico::getValor(int p) const { if(p>=0&&p<longitud) return arreglo[p];

2.

return -1; }

int ArregloDinamico::getLongitud() const { return longitud; }

ArregloDinamico ArregloDinamico::operator+(const ArregloDinamico &otro) { ArregloDinamico suma(longitud+otro.getLongitud()); for(int i=0; i<(longitud+otro.getLongitud());i++) { if(i<longitud) suma.setValor(i,getValor(i)); else suma.setValor(i,otro.getValor(i-longitud)); } return suma; }

void ArregloDinamico::setLongitud(int n) { int *temp; if(n>0) { temp=new int[n]; for(int i=0;i<n;i++) { if(i<longitud) temp[i]=getValor(i); else temp[i]=0;

28

} longitud=n; delete arreglo; arreglo=new int[longitud]; for(int i=0;i<longitud;i++) arreglo[i]=temp[i]; delete temp; } else if(n==0) { delete arreglo; longitud=0; } }

)e"erencias
D5-GGE?7 ;ran[. C++ Annotations. P5ecurso disponi+le E:ttp6NNsource,orge.netNprojectsNcppannotationsN F PCon Acceso 2011N02N2!Q. en /0neaQ

P-d-7 9al*ador. C++ con clase Pen /ineaQ E:ttp6NNc.conclase.netNFPCitado en 2011N02N13Q

21

Herencia
Introduccin
El presente cap0tulo tiene como o+jeti*o dar al lector los conceptos relacionados con la #erencia de clases7 se de,inen los conceptos de clases +ases y clases deri*adas7 tam+iBn se de,ine el concepto de clase +ase a+stracta y jerar%u0a de clases.

2ecesidad de la *erencia
9egAn ^a*ier arc0a7 RPa mente Sumana clasi)ica los conce!tos de acuerdo a dos dimensiones$ !ertenencia ( variedadT. 9e puede decir %ue el Qord Qiesta es un tipo de cocSe K*ariedad o7 en inglBs7 una relacin del tipo is aL y %ue una rueda es parte de un cocSe Kpertenencia o una relacin del tipo Sas aL. Antes de la llegada de la :erencia7 en C ya se :a+0a resuelto el pro+lema de la pertenencia mediante las estructuras7 %ue pod0an ser todo lo complejas %ue se %uisiera. Con la :erencia7 se consigue clasi,icar los tipos de datos KabstraccionesL por *ariedad7 acercando as0 un paso m)s la programacin al modo de ra4onar :umano.

Herencia
"na caracter0stica principal de C++ es la :erencia. Dajo esta caracter0stica es posi+le crear clases7 las cuales son deri*adas de otras clases7 por ende este incluye de ,orma autom)tica los miem+ros de los padres mas los suyos7 por ejemplo7 supngase %ue se *an a desarrollar una serie clases %ue representen pol0gonos tales como 5ect)ngulo7 Triangulo7 Etc. Estos Altimos tienen propiedades comunes tales como6 per0metro7 )rea7 largo7 anc:o. Esto puede ser representado en el mundo de las clases con una clase llamada 9olgono en la cual se deri*an dos mas6 Triangulo y Uectngulo. /a clase 9olgono contienen los miem+ros %ue son comunes para am+os tipos de pol0gonos. En nuestro caso6 anc:o y alto. Uectngulo y Triangulo ser0an sus clases deri*adas7 con caracter0sticas %ue son di,erentes de un tipo de pol0gono a otro. r),icamente podemos e>presar dic:a caracter0stica de la siguiente ,orma6

22

/a :erencia7 segAn ^a*ier arc0a7 es entendida como una caracter0stica de la programacin orientada a o+jetos y m)s concretamente del C++7 %ue permite de,inir una clase modi,icando una o m)s clases ya e>istentes. Estas modi,icaciones consisten :a+itualmente en aOadir nue*os miem+ros Katri+utos u operacionesL7 a la clase %ue se est) de,iniendo7 aun%ue tam+iBn se puede rede,inir *aria+les o ,unciones miem+ro ya e>istentes. /a clase de la %ue se parte en este proceso reci+e el nom+re de clase base7 y la nue*a clase %ue se o+tiene se denomina clase derivada. ksta a su *e4 puede ser clase +ase en un nue*o proceso de deri*acin7 iniciando de esta manera una jerarqua de clases. De ordinario las clases +ase suelen ser m)s generales %ue las clases deri*adas. Esto es as0 por%ue a las clases deri*adas se les suelen ir aOadiendo caracter0sticas7 en de,initi*a atri+utos y operaciones %ue di,erencian7 concretan y particulari4an. En algunos casos una clase no tiene otra utilidad %ue la de ser clase +ase para otras clases %ue se deri*en de ella. A este tipo de clases +ase7 de las %ue no se declara ningAn o+jeto7 se les denomina clases base abstractas K%BC, %bstract Base ClassL y su ,uncin es la de agrupar miem+ros comunes de otras clases %ue se deri*ar)n de ellas. Por ejemplo7 se puede de,inir la clase veSculo para despuBs deri*ar de ella cocSe7 bicicleta7 avin7 etc.7 pero todos los o+jetos %ue se declaren pertenecer)n a alguna de estas Altimas clasesM no :a+r) *e:0culos %ue sean slo *e:0culos. /as caracter0sticas comunes de estas clases Kcomo un atri+uto %ue indi%ue si est) parado o en marc:a7 otro %ue indi%ue su *elocidad7 la ,uncin de arrancar y la de ,renar7 etc.L7 pertenecer)n a la clase +ase y las %ue sean particulares de alguna de ellas pertenecer)n slo a la clase deri*ada Kpor ejemplo el nAmero de platos y piOones7 %ue slo tiene sentido para una +icicleta7 o la ,uncin em+ragar %ue slo se aplicar) a los *e:0culos de motor con *arias marc:asL.

3aria!les y "unciones miem!ros protected

"no de los pro+lemas %ue aparece con la :erencia es el del control del acceso a los datos. $Puede una ,uncin de una clase deri*ada acceder a los datos pri*ados de su clase +ase& En principio una clase no puede acceder a los datos pri*ados de otra7 pero podr0a ser muy con*eniente %ue una clase deri*ada accediera a todos los datos de su clase +ase. Para :acer posi+le esto7 e>iste el tipo de dato protected. Este tipo de datos es pri*ado para todas a%uellas clases %ue no son deri*adas7 pero pA+lico para una clase deri*ada de la clase en la %ue se :a de,inido la *aria+le como protected. Por otra parte7 el proceso de :erencia puede e,ectuarse de dos ,ormas distintas6 siendo la clase +ase public o private para la clase deri*ada. En el caso de %ue la clase +ase sea public para la clase deri*ada7 Bsta :ereda los miem+ros public y protected de la clase +ase como miem+ros public y protected7 respecti*amente. Por el contrario7 si la clase +ase es private para la clase deri*ada7 Bsta :ereda todos los datos de la clase +ase como private. /a siguiente ta+la puede resumir lo e>plicado en los dos Altimos p)rra,os. Para el caso de las Tipos a+stractos de datos 9olgono7 Triangulo y Uectngulo es posi+le representarlos en C++ como sigue a continuacin6 class PoligonoU protected6 int <idt:7 :eig:tM pu+lic6 2!

*oid setH*alues Kint a7 int +L U <idt:WaM :eig:tW+MY YM class 5ectangulo6 pu+lic PoligonoU pu+lic6 int area KL U return K<idt: X :eig:tLM Y YM class Triangulo6 pu+lic PoligonoU pu+lic6 int area KL U return K<idt: X :eig:t N 2LM Y YM int main KL U 5ectangulo rectM Triangulo trglM rect.setH*alues K871LM trgl.setH*alues K871LM cout EE rect.areaKL EE trgl.areaKL EE endlM Y

)e"erencias
A5ClA7 ^a*ier Et al. Aprenda C++ como si ,uera en primero. "ni*ersidad de na*arra . 9an 9e+astian C EspaOa7 a+ril de 133'. 9-"/Ik7 ^uan. C++ /anguage Tutorial. PEn l0neaQE:ttp6NN<<<.cplusplus.comNdocNtutorialNF PCon acceso 2011N01N01Q

2'

Mas sobre Herencia

Introduccin
El presente capitulo tiene como meta pro,undi4ar al lector los conceptos relacionados con la #erencia de clases. 9e de,ine algunas tBcnicas de implementacin de los constructores y mBtodos para las clases deri*adas7 tam+iBn se de,ine el concepto de #erencia mAltiple.

.inta/is para la deri acin de clases

/a ,orma general de declarar clases deri*adas es la siguiente6 class EclaseHderi*adaF 6 Ppu+lic\pri*ateQ E+ase1F P7Ppu+lic\pri*ateQ E+ase2FQ UYM 9e puede o+ser*ar %ue para cada clase +ase se pueden de,inir dos tipos de acceso7 pu+lic o pri*ate. 9i no se especi,ica ninguno de los dos7 por de,ecto se asume %ue es pri*ate. pu+lic6 los miem+ros :eredados de la clase +ase conser*an el tipo de acceso con %ue ,ueron declarados en ella. pri*ate6 todos los miem+ros :eredados de la clase +ase pasan a ser miem+ros pri*ados en la clase deri*ada.

De momento se declaran las clases +ase como pu+lic7 al menos %ue e>ista la utilidad de :acerlo como pri*adas. Como ejemplo o+ser*e la de,inicin de las clases 9olgono7 Triangulo y Uectngulo6 class PoligonoU protected6 int <idt:7 :eig:tM pu+lic6 PoligonoKintW07intW0LM RPoligonoKLM int areaKLM *oid setH*alues Kint a7 int +LM YM A continuacin se de,ine la clase Uectngulo como deri*ada de 9olgono6 class 5ectangulo6 pu+lic PoligonoU pu+lic6 5ectanguloKintW07intW0LM R5ectanguloKLM int areaKLM 23

YM Tam+iBn se de,ine la clase Uectngulo como deri*ada de 9olgono6 class Triangulo6 pu+lic PoligonoU pu+lic6 TrianguloKintW07 intW0LM RTrianguloKLM int areaKLM YM

Constructores de clases deri adas

Cuando se crea un o+jeto de una clase deri*ada7 primero se in*oca al constructor de la clase o clases +ase y a continuacin al constructor de la clase deri*ada. 9i la clase +ase es a su *e4 una clase deri*ada7 el proceso se repite recursi*amente. /gicamente7 si no se :an de,inido los constructores de las clases7 se usan los constructores por de,ecto %ue crea el compilador. 9u sinta>is es la siguiente6 EclaseHderi*adaF66EclaseHderi*adaFKElistaHdeHpar)metrosFL 6EclaseH+aseFKElistaHdeHpar)metrosFL UY 9i el constructor de la clase +ase 9olgono esta implementado de la siguiente ,orma6 Poligono66PoligonoKint a7 int +LU setH*aluesKa7+LM Y 9e puede implementar el constructor de la clase deri*ada Uectngulo como sigue a continuacin6 5ectangulo665ectanguloKint a7int +L6PoligonoKa7+LUY

*obrecarga de constructores de clases derivadas

Por supuesto7 los constructores de las clases deri*adas tam+iBn pueden so+re cargarse7 podemos crear distintos constructores para di,erentes iniciali4aciones posi+les7 y tam+iBn usar par)metros con *alores por de,ecto.

Destructores de clases deri adas

Cuando se destruye un o+jeto de una clase deri*ada7 primero se in*oca al destructor de la clase deri*ada7 si e>isten o+jetos miem+ro a continuacin se in*oca a sus destructores y ,inalmente al destructor de la clase o clases +ase. 9i la clase +ase es a su *e4 una clase deri*ada7 el proceso se repite recursi*amente. Al igual %ue pasa+a con los constructores7 si no :emos de,inido los destructores de las clases7 se usan los destructores por de,ecto %ue crea el compilador. !0

Por ejemplo si se de,ine el destructor de la clase Poligono como sigue a continuacin6 Poligono66RPoligonoKLU coutEEVllamada al destructor6 PoligonoVEEendlM Y A:ora si se de,ine el destructor de la clase Triangulo como sigue a continuacin6 Triangulo66RTrianguloKLU coutEEVllamada al destructor6 TrianguloVEEendlM Y 9i la ,uncin main es la siguiente6 int mainU Triangulo tM Y /a salida es la siguiente6 llamada al destructor6 Triangulo llamada al destructor6 Poligono

)ede"inicin de "unciones en clases deri adas

En una clase deri*ada se puede de,inir una ,uncin %ue ya e>ist0a en la clase +ase7 esto se conoce como VoverridingV7 o superposicin de una ,uncin. /a de,inicin de la ,uncin en la clase deri*ada oculta la de,inicin pre*ia en la clase +ase. En caso necesario7 es posi+le acceder a la ,uncin oculta de la clase +ase mediante su nom+re completo. /a sinta>is es la siguiente6 PEo+jetoF.QEclaseH+aseF66EmBtodoFM Por ejemplo si el mBtodo )rea de la clase Pol0gono tiene la siguiente implementacin6 int Poligono66areaKLUreturn <idt: X :eig:tMY Es posi+le superponer el mBtodo )rea para la clase Triangulo como se muestra a continuacin6 int Triangulo66areaKLUreturn <idt: X :eig:tN2MY Por ende si declaramos un o+jeto trig de tipo Triangulo este o+jeto tendr0a dos de,iniciones del mBtodo )rea6 Triangulo66areaKL y Poligono66areaKL.

.uperposicin y so!recarga.
Cuando se superpone una ,uncin7 se ocultan todas las ,unciones con el mismo nom+re en la clase !1

+ase. A:ora +ien7 no es posi+le acceder a ninguna de las ,unciones superpuestas de la clase +ase7 aun%ue tengan distintos *alores de retorno o distinto nAmero o tipo de par)metros. Todas las ,unciones superpuesta KoverridedL de la clase +ase :an %uedado ocultas7 y slo son accesi+les mediante el nom+re completo. Por ejemplo si el mBtodo )rea de la clase Pol0gono tiene la siguiente implementacin6 int Poligono66areaKLUreturn <idt: X :eig:tMY Es posi+le superponer el mBtodo )rea para la clase Triangulo como se muestra a continuacin6 int Triangulo66areaKLUreturn Poligono66areaKLN2MY 9i se declara un o+jeto trig de la clase Triangulo7 cuando se in*oca trig.areaKL estamos in*ocando al mBtodo Triangulo66areaKL por lo tanto trig.areaKL es e%ui*alente a6 trig.Triangulo66areaKL 9i se desea acceder al mBtodo de la clase +ase el cual ,ue superpuesto lo podemos :acer de la siguiente ,orma6 trig.Poligono66areaKL

Herencia '4ltiple.
9egAn Druce Ec[el7 El concepto +)sico de la :erencia mAltiple K#(L suena +astante simple6 puede crear un nue*o tipo :eredando de m)s una una clase +ase. /a sinta>is es e>actamente la %ue espera7 y en la medida en %ue los diagramas de :erencia sean simples7 la #( puede ser simple tam+iBn. 9al*ador Po4o de,ine la sinta>is de la #erencia mAltiple como sigue a continuacin6 EclaseHderi*adaFKElistaHdeHpar)metrosFL 6 EclaseH+ase1FKElistaHdeHpar)metrosFL P7 EclaseH+ase2FKElistaHdeHpar)metrosFLQ UY A continuacin se muestra un ejemplo de deri*acin mAltiple6 class ClaseA U pu+lic6 ClaseAKL 6 *alorAK10L UY int dar@alorKL const U return *alorAM Y protected6 int *alorAM YM

!2

class ClaseD U pu+lic6 ClaseDKL 6 *alorDK20L UY int dar@alorKL const U return *alorDM Y protected6 int *alorDM YM class ClaseC 6 pu+lic ClaseA7 pu+lic ClaseD U pu+lic6 int dar@alorKL const U return ClaseA66 dar@alorKL+ ClaseD66 dar@alorKLMY YM 9i la ,uncin main es la siguiente6 int mainKLU ClaseC cM coutEEc. dar@alorKLEEendlM Y /a salida es .0.

)e"erencias
ECGE/7 Druce. T:in[ing in C++7 @olume 16 Introduction to 9tandard C++ K2nd EditionL. Prentice #all. ?^7 "9A. 2000. 9-"/Ik7 ^uan. C++ /anguage Tutorial. PEn l0neaQE:ttp6NN<<<.cplusplus.comNdocNtutorialNF PCon acceso 2011N01N01Q P-d-7 9al*ador. C++ con clase Pen /ineaQ E:ttp6NNc.conclase.netNFPCitado en 2011N02N13Q

!.

E0cepciones
Introduccin
El presente capitulo tiene como o+jeto dar al lector los conceptos relacionados con en manejo de e>cepciones en C++. Partiendo desde el manejo de errores en tiempo de diseOo como en tiempo de ejecucin7 se conocer)n *arias tBcnicas partiendo desde el manejo de seOales en su predecesor K/enguaje CL :asta el uso correcto de la tripleta t:ro<7 try7 catc: en el lenguaje C++.

'anejando errores
#ay *arias ,ormas posi+les para manejar errores en nuestras aplicaciones. A continuacin se mencionan algunas tBcnicas.

$e%iniendo su comportamiento en t1rminos de una variable lgica.

9egAn #ayet 7 la manera mas simple para manejar errores es de,iniendo el comportamiento errneo en tBrminos de una *aria+le lgica. Ejemplo la siguiente ,uncin *eri,ica %ue el re%uerimiento se cumpla7 de lo contrario interrumpe la aplicacin6 *oid *eri,icar K +ool re%uerimiento7 const std 6 6 string I msg W `el re%uerimiento ,alloa L U using namespace stdM i,Kg re%uerimientoL U cerr EE msg EE endl M e>it K1LM Y Y De tal ,orma %ue en cual%uier implementacin se pueda *eri,icar el cumplimiento algAn re%uerimiento como se muestra a continuacin6 int mainKLU int aW120M *eri,icarK a E100 7 `*alor ,uera de rangoa L M Y

!a macro assert
E>iste una ,uncin est)ndar Kde CL para :acer este tipo de *eri,icaciones7 la macro assert. Cuya de,inicin se muestra a continuacin6 *oid assertKint testL M Esta comprue+a la condicin jtestj y dependiendo del resultado7 puede a+ortar el programa. 9e trata de !8

una macro %ue se e>pande como una sentencia Vi,V7 si jtestj se e*alAa como cero7 la macro a+orta el programa y muestra el siguiente mensaje en stderr6 Assertion ,ailed6 EcondicinF7 ,ic:ero Enom+re de ,ic:eroF7 line EnAmero de l0neaF El nom+re de arc:i*o y el nAmero de l0nea corresponden con el arc:i*o y l0nea en la %ue est) la macro. Por ejemplo el siguiente cdigo ,uente6 Sinclude EcassertF int main K L U +ool dW ,alse M assert KdLM Y Produce una descripcin m0nima de lo %ue pas y sale6 assert6 assert.cpp686 int mainKL6 Assertion jdj ,ailed. Cancelado Ese comportamiento ,rente errores puede estar +ien en ,ase de desarrollo del programa7 pero no en ,ase de release7 :ay %ue pre*er cuando es posi+le un procesamiento en linea de las errores. En pr)ctica7 separar el caso de ,ase de debug de ,ase `normala 6 Sinclude EcassertF f +ool dM f Si,de, DED" assert KdLM Selse NN Pre*er el procesamiento de error g Sendi,

Manejar errores %uera del conte0to

9i7 dentro de la ,uncin o del mBtodo en %ue se produce el error se tiene todo lo necesario para manejar el error y salir `+iena no :ay pro+lemas. 9i no es el caso y %ue se tiene %ue salir del conte>to para manejar el error7 :ay *arias maneras de :acerlo en C 6 1. A,ectar un cdigo de nuestro error al *alor de regreso a la ,uncin y propagar este cdigo a ni*eles en %ue el procesamiento es posi+le 6 Sde,ine E55H(A//-C 1 ... !1

i, KgK,WmallocK1000si4eo,Kdou+leLLL return E55H(A//-CM 2. "sar un sistema de cdigos glo+al7 %ue pro*ee por ejemplo C a tra*Bs de errno y perror. arc:i*oW ,open K `datos.t>ta 7 a r a L M i,Kgarc:i*oL U perror K `Error tratando de a+rir el arc:i*o datos.t>ta L M return m1M Y /as ,unciones est)ndar7 en caso de error7 ponen la *aria+le glo+al errno7 y perror imprime el te>to m)s la descripcin del errno. .. enerar una seOal desde el programa ,rente a un error y escri+ir los mecanismos para manejarlos6 Sinclude Esignal.:F int raise K int sig LM (anejado con6 *oid sigHcatc:er K int signum L U ... Y int main K L U NN catc: signal signal K sig 7 sigHcatc:er L M ... raise K 9I E55@A/ L M Y

E/cepciones
En C++7 el mecanismo est)ndar para el manejo de errores es el de e>cepciones6 en caso de errores al momento de la ejecucin7 y %ue no se puede corregir localmente7 la idea es7 en lugar de salir de la ,uncin en %ue estamos7 se lan4a por ,uera del conte>to un mensaje de alerta y esperar %ue algo en otra parte del cdigo lo pueda manejar.

!a palabra reservada t,ro/

Para el en*0o de mensajes %ue se esperan manejar por ,uera del conte>to7 se de,ine o+jetos %ue `lan4ara Ke>cepciones6 se puede tomar de cual%uier tipoL y la pala+ra reser*ada t:ro< nos permite emitirlos6 9upngase %ue los o+jetos de la clase #elp(e son los %ue *an a lan4ar en el momento %ue se presente !2

una e>cepcin7 la de,inicin de esta clase se muestra a continuacin6 class #elp(e U string messageM pu+lic6 #elp(e K const string Is L 6 message K s L U Y M const stringI get(essage K L U return messageM Y YM 9i en la ,uncin *alidar tiene como o+jeto *eri,icar algAn re%uerimiento y se desea manejar el error por ,uera de su conte>to esta puede de,inirse de la siguiente ,orma6 *oid *alidar K +ool + L U i,Kg+L U t:ro< K #elp(e K `Estoy en un pro+lemagg a L L M Y Y
Caracter5sticas de t*ro0

la pala+ra reser*ada t:ro< tiene las siguientes caracter0sticas6 1. ActAa como un return7 en el sentido de %ue regresa un *alor7 el o+jeto acompaO)ndolo. 2. E,ectAa el cleanup de las *aria+les locales de la ,uncin en %ue se encuentra. .. ?o regresa al ni*el superior en la pila Ka la llamada de la ,uncinL sino en un lugar especial de la memoria para manejar e>cepciones. 8. En*iar) pre,erentemente o+jetos espec0,icos al error encontrado. 1. Puede o no tomar parBntesis.

El blo2ue tr' catc,

Conocido el mecanismo para lan4ar e>cepciones7 es necesario *er el mecanismo %ue permite asociar una e>cepcin a un procesamiento. Ejemplo7 el cdigo 6 *alidar K ,alse L M enera dic:a e>cepcin o+teniendo la siguiente salida Ku otra dependiendo del compiladorL6 Terminate called a,ter t:ro<ing an instance o, n#elp(en A+ort En cual%uier lugar del cdigo de la llamada de la ,uncin7 se puede de,inir un +lo%ue try %ue se prepara a reci+ir e>cepciones6

!!

try U ... *alidar K,alseL M Y El +lo%ue try e*ita salir de la ,uncin en %ue est) este +lo%ue 6 el procesamiento de los errores puede estar de,inido en este ni*el. El +lo%ue try est) seguido por uno o *arios +lo%ues catc: %ue est)n espec0,icos a la e>cepcin generada dentro del +lo%ue try6 try U *alidar K,alseL M Y catc: K int i L U Y cout EE `la *ida siguea EE endl M /a pala+ra reser*ada catc:7 seguida de un tipo t y de un identi,icador id7 de,ine un +lo%ue donde se *a a manejar una e>cepcin id de tipo t. Para el caso espec0,ico7 aun genera la siguiente salida Ku otra dependiendo del compiladorL6 Terminate called a,ter t:ro<ing an instance o, n#elp(en A+ort A:ora si el catc: maneja o+jetos de tipo #elp(e6 try U *alidar K,alseL M Y catc: K #elp(e : L U c o u t EE `#ola escuc:B tu mensajea EE `oa aEE: . get(essage K L EE a oa a EE endl M Y 9igue `normalmentea a la salida del +lo%ue catc:. ()s generalmente7 se puede tener algo como 6 try U ... Y catc: KE>ceptionType1 e>1 LU ... Y catc: KE>ceptionType2 e>2 LU ... Y catc: KE>ceptionType. e>. LU ... !'

Y ... Y catc: KE>ceptionType? e>? LU ... Y Ese mecanismo es interesante por%ue 6 1. 9epara +ien el cdigo normal del cdigo encargado de manejar los errores7 2. Permite dejar cual%uier cdigo de ni*el superior en la pila manejar esas errores7 .. /impia correctamente al ni*el de la ,uncin en %ue se in*oca la e>cepcin.

Eleccin del buen ,andler

?o se necesita correspondencia per,ecta entre el tipo de la e>cepcin lan4ada y el tipo de recepcin por catc:7 por ejemplo las clases deri*adas est)n puestas en correspondencia Kre,erenciaN*alorL. -+ser*e la de,inicin de la clase Please#elp(e6 class Please#elp(e 6 pu+lic #elp(e U pu+lic6 Please#elp(e Kconst string Is L 6 #elp(e KsL U Y M YM El t:ro< con un Please#elp(e est) manejado en un catc: para #elp(e. Por ejemplo7 si la ,uncin *alidar es la siguiente6 *oid *alidar K +ool + L U i,Kg+L U t:ro< Please#elp(e K `Estoy en un pro+lemagg a L M Y Y b si el el +lo%ue try C catc: maneja o+jetos de tipo #elp(e6 try U *alidar K,alseL M Y catc: K #elp(e : L U cout EE `#ola escuc:B tu mensajea EE ` oa aEE: . get(essage K L EE a oa a EE endl M Y Entonces la salida es la siguiente6 #ola escuc:B tu mensaje `Estoy en un pro+lemagga De+ido a %ue un o+jeto de tipo Please#elp(e es un o+jeto de tipo #elp(e.

!3

Es posi+le :acer un :andler %ue agarre toda e>cepcin generada en el try 6 try U *alidar K,alseL M Y catc: K . . . L U cout EE `:a ocurrido una e>cepcin a EE endlM Y Eso puede ser Atil cuando :ay %ue separar el procesamiento de los errores en dos partes 6 una parte genBrica %ue puede incluir li+eracin de memoria7 por ejemploM una parte especi,ica %ue est) procesada en un segundo tiempo.

3e4lan)ar una e0cepcin

Para implementar ese mecanismo de procesamiento en *arios tiempos7 se necesita propagar la e>cepcin en di,erentes ni*eles6 por eso7 se usa otra *e4 la pala+ra reser*ada t:ro<7 %ue reClan4a la e>cepcin :acia ni*eles superiores7 try U *alidar K ,alseL M Y catc: K . . . L U coutEEarelan4ando la e>cepcionaM t:ro< M Y

E0cepciones estndar
El lenguaje C++ pro*ee clases para e>cepciones7 %ue se puede usar gracias a la inclusin del arc:i*o de ca+ecera Ee>ceptionF Todas :eredan de la clase e>ception7 %ue contiene un mensaje a %ue se puede acceder por el mBtodo <:atKL. @arias clases :eredan de e>ception6 1. logic3error 6 errores intercepta+les en la ,uncin %ue lan4a la e>cepcin. 2. runtime3error 6 errores intercepta+les slo en el momento de la ejecucin Kpor ,uentes e>ternas6 ,alta de memoria. . . L .. ios$$)ailure 6 errores en la manipulacin de iostreams. Todas esas su+clases se construyen con un mensaje string.

Especi%icaciones de e0cepciones
Al escri+ir cdigo %ue ser) usado por terceros7 puede ser muy Atil especi,icar cuales son las e>cepciones %ue :ay %ue esperar de las ,unciones7 o mBtodos de las clases desarrolladas7 Ejemplo6 *oid procesarK L t:ro< K #elp(e 7 Please#elp(e L U NN... Y '0

9igni,ica %ue :ay %ue esperar de esa ,uncin e>cepciones de tipo #elp(e y Please#elp(e. (ientras %ue6 *oid , K L M signi,ica7 por de,ault7 %ue la ,uncin puede emitir cual%uiera e>cepcin7 y *oid , K L t:ro< K L M signi,ica %ue la ,uncin no *a a emitir ninguna e>cepcin.

Cuando usar u evitar las e0cepciones

Cuando se puede e*itar usar e>cepciones6 En e*entos as0ncronos7 En errores %ue se podr0an tratar localmente7 En programas con imperati*os ,uertes en tBrminos de tamaOo del cdigo o+jeto7 En destructores. En Constructores7 Para reintentar llamadas a ,unciones %ue ,allan7 Para intentar otra cosa al lugar de la ,uncin %ue ,alla7 Para compartir el procesamiento de las errores entre *arias capas de tratamiento.

Cuando se puede usar e>cepciones

)e"erencias
#AbET. ^.D. Programacin a*an4ada en C++ C E>cepciones7 Centro de in*estigacion en (atematicas. (e>ico Pen /ineaQE<<<.cimat.m>NRj+:ayetNC/A9E9NP5- 5A(ACI-?NslidesNclase1!.pd,F PCon acceso el 2011N02N13Q. P-d-7 9al*ador. C++ con clase Pen /ineaQ E:ttp6NNc.conclase.netNFPCitado en 2011N02N13Q

'1

Polimor%ismo
Introduccin
El presente capitulo tiene como o+jeto dar al lector un concepto ,undamental en el paradigma de la programacin orientada a o+jetos tal como es el polimor,ismo. 9e a+ordaran temas relacionados como la con*ersin :acia la clase +ase Ku!castingL7 las llamadas a ,unciones por enlace temprano como por enlace tard0o7 las ,unciones *irtuales e introduccin al concepto de clase +ase a+stracta.

Upcasting
"na caracter0stica muy importante de la :erencia es la relacin particular entre la clase +ase y sus clases deri*adas %ue :ace %ue una re,erencia a una instancia de una clase deri*ada puede `estar *istaa sin pro+lema como una re,erencia a una instancia de la clase +ase. Por ejemplo o+ser*e las de,iniciones de las clases Poligono7 5ect)ngulo y Triangulo6 class PoligonoU protected6 int <idt:7 :eig:tM pu+lic6 PoligonoKintW07intW0LM *oid setH*alues Kint a7 int +LM int get]idt:KLM int get#eig:tKLM std66string get?ameKLM YM class 5ectangulo6 pu+lic PoligonoU pu+lic6 5ectanguloKint7intLM int area KLM std66string get?ameKLM YM

'2

class Triangulo6 pu+lic PoligonoU pu+lic6 TrianguloKint7 intLM int area KLM std66string get?ameKLM YM Es posi+le de,inir una ,uncin llamada di+ujar cuyo o+jeto es di+uja un pol0gono en la li+rer0a gr),ica J7 en el cual reci+e como par)metro por re,erencia un o+jeto de tipo Poligono *oid di+ujarKconst PoligonoI pLU f Y 9i la ,uncin main es la siguiente6 int mainKLU Triangulo tK172LM di+ujarKtLM Y El uso de la ,uncin di+ujar7 reci+iendo como par)metro un o+jeto de tipo Triangulo7 es completamente *)lido. Este mecanismo es lgico ya %ue todos los mBtodos KpA+licosL %ue est)n e*entualmente llamados dentro de la ,uncin desde un o+jeto de tipo Poli ono est)n disponi+les7 por de,inicin7 para o+jetos de tipo Trian ulo. El u!casting es la ra4n de peso %ue permite elegir :erencia so+re composicin6 en unos casos es posi+le %uerer manipular re,erencias a o+jetos de una clase deri*ada como si ,ueran re,erencias a o+jetos de la clase `genBricaa. El u!casting en termino general se aplica en asignaciones de re,erencias o apuntadores7 por ejemplo6 int main KL U 5ectangulo rectM Triangulo trglM Poligono IrW rectM Poligono XtWItrglM rCFsetH*aluesK871LM tCFsetH*aluesK871LM Y @ale la pena aclarar %ue cuando se usa una re,erencia a la clase +ase7 al in*ocar un mBtodo este aplica el comportamiento de,inido para la clase +ase por ejemplo si en la en las siguientes sentencias6 '.

Triangulo trglM Poligono ItW trglM t.get?ameKLM Aun%ue la clase Triangulo tenga de,inido un mBtodo get?ameKL7 El compilador llamar) a priori7 al mBtodo de,inido en la clase Poligono K+aseL7 de+ido a %ue es la Anica es *isi+le en tiempo de compilacin. En C++ :ay un mecanismo %ue permite reali4ar u!casting pero conser*ando de una manera u otra la `memoriaa de %ue *enimos de una clase deri*ada particular7 y entonces llamar los mBtodos de Bsta7 este mecanismo se llama ,unciones *irtuales.

$lamadas a "unciones
/as llamadas a ,unciones pueden :acerse de dos ,ormasM ya sea en tiempo de compilacin Kearl( bindingL o en tiempo de ejecucin Klate bindingL

Enlace temprano
C++ por de,ecto7 en tiempo de compilacin7 traduce las llamadas a la ,unciones por cdigo o+jeto con la direccin memoria de la ,uncin a llamar7 de tal ,orma %ue :ar) el programa ir a ejecutar las instrucciones de esa ,uncin en particular Kcon los argumentos dadosL7 Este proceso se conoce como Enlace temprano Kearl( bindingL ante esto no :ay eleccin posi+le7 es una y una sola ,uncin %ue ser) in*ocada6 Eso e>plica el comportamiento del programa al llamar un mBtodo despuBs de un upcasting6 Triangulo trglM Poligono ItW trglM t.get?ameKLM NNllama el de poligono7 a priori.

Enlace Tard"o
A:ora7 conceptualmente7 la Anica manera de poder llamar al mBtodo de correcto despuBs de reali4ar un u!casting ser) resol*iendo la llamada al mBtodo7 no en tiempo de compilacin sino en tiempo de ejecucin7 este mecanismo se conoce como Enlace Tard0o Klate bindingL. Eso implica %ue el programa pueda *eri,icar de %ue tipo se est) tratando realmente Ksea el mBtodo de la clase +ases o una de sus deri*adasL. #asta a:ora no tenemos lo su,iciente7 pero el C++ pro*ee lo necesario para :acerlo.

+unciones irtuales
Para poder llamar a alguna ,uncin en enlace tard0o7 se necesita usar7 en la clase +ase7 la pala+ra reser*ada *irtual con la declaracin de la ,uncin so+re la %ue %ueremos llamar en enlace tard0o. Ejemplo7 si se desea llamar en tiempo de ejecucin el mBtodo get?ameKL7 entonces en la de,inicin de la clase Pol0gono KClase +aseL7 de+emos anteponer la pala+ra reser*ada *irtual en la de,inicin del mBtodo get?ameKL %uedando de la siguiente ,orma6 '8

class PoligonoU protected6 int <idt:7 :eig:tM pu+lic6 PoligonoKint7intLM *oid setH*alues Kint a7 int +LM int get]idt:KLM int get#eig:tKLM *irtual std66string get?ameKLM YM Eso :ar) %ue toda llamada a get?ameKL7 dentro de una clase deri*ada %ue lo de,ine7 a partir de una re,erencia a Poligono o+tenida por u!casting7 llamar) al mBtodo get?ameKL de la clase deri*ada.

E0tensibilidad
/a E>tensi+ilidad es uno de los importantes +ene,icios del polimor,ismo ya %ue si tengo una parte del programa escrita en tBrminos de una *ersin genBrica de mis o+jetos Kpor ejemplo7 en tBrminos de la clase +aseL7 es posi+le7 sin pro+lema escri+ir *ersiones especiali4adas de la clase +ase Ka tra*Bs de clases deri*adasL y usarlas en esta parte del cdigo7 sin reali4arle cam+ios a este ultimo. En ese aspecto no es necesario sa+er cuales son las deri*adas7 ya %ue el cdigo de,inido con los mecanismos adecuados seguir) ,uncionando.

Clases a!stractas
E>iste en C++ la posi+ilidad de Con*ertir de una clase en clase a+stracta7 o sea %ue no pueda ser implementada o instanciada. Para eso7 es su,iciente declarar una de sus ,unciones *irtuales como ,uncin *irtual pura7 aOadiendo a su declaracin un `W0a . Ejemplo6 class ;igura U pu+lic 6 *irtual int getArea KL W 0M YM /os mBtodos *irtuales puros o+ligan a implementar *ersiones de esos mBtodos en las clases deri*adas con el ,in de ,acilitar las siguientes practicas de programacin6 -,rece una manera de separar aAn mas inter,a4 de implementacin7 esta *e4 a tra*Bs de *arias clases Kclases a+stractasNclases `normalesaL. -,rece una manera de o+ligar los %ue *an a :eredar las clases %ue ,unciones implementar. '1

)e"erencias
#AbET. ^.D. Programacin a*an4ada en C++ C #erencia7 Centro de in*estigacin en (atem)ticas. (B>ico Pen /ineaQ E<<<.cimat.m>NRj+:ayetNC/A9E9NP5- 5A(ACI-?NslidesNclase1..pd,F PCon acceso el 2011N02N13Q. #AbET. ^.D. Programacin a*an4ada en C++ C Polimor,ismo7 Centro de in*estigacin en (atem)ticas. (B>ico Pen /ineaQE<<<.cimat.m>NRj+:ayetNC/A9E9NP5- 5A(ACI-?NslidesNclase18.pd,F PCon acceso el 2011N02N13Q.

'2

Plantillas de %unciones ' clases

Introduccin
El presente capitulo tiene como o+jeto dar al lector los conceptos relacionados con la programacin genBrica7 as0 como los mecanismos %ue permiten implementarlo en el lenguaje de programacin C++ como son las plantillas7 aplicado tanto en ,unciones como clases.

Programacin gen6rica
/a programacin genBrica! es un paradigma de programacin el cual permite desarrollar +i+liotecas sean de ,unciones o clases e,icientes y reutili4a+le. Este paradigma ,ue desarrollado por primera *e4 por Ale>ander 9tepano* y Da*id (usser. /a programacin genBrica tu*o su mayor B>ito cuando las +i+liotecas de plantillas est)ndar KStandard Tem!late Pibrar( C STPL pas a ser parte del est)ndar A?9INI9- C++7 desde entonces la programacin genBrica :a sido utili4ada con el ,in de desarrollar un sin numero de +i+liotecas genBricas. /a programacin genBrica :ace re,erencia a las caracter0sticas de determinados lenguajes %ue permite7 desarrollar un sin nAmero de aplicaciones de di,erentes dominios tratando en lo posi+le utili4ar un conjunto de li+rer0as %ue se ajusten al dominio de la aplicacin sin necesidad de reescri+irlas. Por ejemplo7 en C++7 una plantilla es una rutina en la %ue algunos par)metros son cali,icados por un tipo de *aria+le. /a generacin de cdigo en C++ depende de los tipos de concreto7 la plantilla est) especiali4ada para cada com+inacin de tipos de argumentos %ue se producen en algunas instancias.

Plantillas
#ayet en su curso de programacin a*an4ada en C++ a,irma %ue6 `#asta a:ora7 las :erramientas %ue *imos K:erencia7 composicin7 polimor,ismoL7 permiten la reutili4acin de cdigo o+jetoM los patrones Ko tem!latesL permiten reutili4ar cdigo ,uente en otros conte>tos %ue el para %ue esta+a diseOadoa'. En nuestras aplicaciones es muy comAn reescri+ir ,unciones %ue tienen la misma ,uncionalidad pero con di,erentes argumentos6 Por ejemplo para el diseOo de una calculadora se de,inen las ,unciones6 int sumarKint7intLM ,loat sumarK,loat7 ,loatLM int sumarKint7 ,loatLM ,loat sumarK,loat7 intLM Con el ,in de sumar dos argumentos sean de tipo int o tipo ,loat respecti*amente7 como o+ser*a la ,uncin sumar7 para los cuatro casos7 pueden de,inirse7 en tBrminos generales de la siguiente ,orma6
! eneric Programming. Indiana "ni*ersity. P5ecurso disponi+le en linea QE:ttp6NN<<<.genericCprogramming.orgNF Pcon acceso 2011N08N2.Q ' #AbET. ^.D. Programacin a*an4ada en C++ C Plantillas7 Centro de in*estigacin en (atem)ticas. (B>ico Pen /ineaQE:ttp6NN<<<.cimat.m>NRj+:ayetNC/A9E9NP5- 5A(ACI-?NslidesNclase12.pd, FPCon acceso el 2011N02N13Q.

'!

sumarKa7+LU return a++MY -+ser*e %ue los argumentos a y + pueden pertenecer a dominios di,erentes pero la ,uncin se cumplir) siempre y cuando se de,ina7 para am+os argumentos la operacin + Entonces7 en C++7 se puede resumir las cuatro operaciones sumar en una sola :aciendo uso de una plantilla de ,uncin.

Plantillas de "uncin
"na plantilla de ,uncin son ,unciones especiales %ue operan con tipos de datos genBricos7 esto permite crear un conjunto de ,unciones cuya ,uncionalidad puede ser adoptada por mas de un tipo de dato o clases sin so+recargar la ,uncin para cada tipo o clase %ue reci+a como argumentos. En C++7 se puede lograr7 :aciendo uso de par)metros de plantillas. "n par)metro de plantilla es una clase de par)metros especiales %ue pueden ser usados para pasarles un tipo de datos como argumentos. /as plantillas de ,uncin pueden usar esos par)metros como si ,uesen *aria+les de ,unciones normales. /a sinta>is para declarar una plantilla de ,uncin con sus par)metros de plantilla es la siguiente6 template Eclass identi,ierF ,unctionHdeclarationM template Etypename identi,ierF ,unctionHdeclarationM 9i se %uiere %ue la ,uncin sumar pueda operar con tipos de datos genBricos se puede de,inir su prototipo de la siguiente ,orma6 template Etypename tipoF tipo sumarKtipo7tipoLM (ientras %ue su implementacin se puede e>presar de la siguiente ,orma6 template Etypename tipoF tipo sumarKtipo a7 tipo +LU return a++M Y 9u uso no di,iere de cual%uier otra ,uncin7 por ejemplo7 o+ser*e su uso en la ,uncin main con di,erentes tipos de datos6 int mainKLU coutEEsumarK17 2LEEendlM NNmuestra . coutEEsumarK1.07 1.1LEEendlM NNmuestra 2.1 coutEEsumarKstringKVaVL7 stringKV+VLLEEendlM NNmuestra a+ return 0M Y En el ejemplo se o+ser*a %ue se :a de,inido e implementado una ,uncin con ti!o como su par)metro de plantillas7 este par)metro de plantillas representa un tipo %ue no :a sido especi,icado K,orma impl0citaL. En este conte>to7 la ,uncin sumar retorna la suma de dos par)metros de tipos aun ''

desconocidos. 9i se desea utili4ar la plantilla de ,uncin para un tipo espec0,ico7 se puede e>plicitar el tipo de dato para la plantilla de acuerdo a la siguiente sinta>is. ,unctionHname EtypeF KparametersLM Por ejemplo7 si se desea usar la plantilla de ,uncin para %ue sus par)metros sean de tipo int se puede usar de la siguiente ,orma6 int mainKLU int >W17 yW2M int 4WsumarEintFK>7yLM return 0M Y

Plantillas de %uncin con varios parmetros de plantillas

El ejemplo de la plantilla de ,uncin sumar de,inida anteriormente solo puede utili4ar para usarse con par)metros del mismo tipo7 para el diseOo de la calculadora7 resol*er0an la de,inicin y uso de las siguientes ,unciones6 int sumarKint7intLM ,loat sumarK,loat7 ,loatLM (as no resol*er0an la de,inicin y su posterior uso de las restantes ,unciones a sa+er6 int sumarKint7 ,loatLM ,loat sumarK,loat7 intLM Entonces para resol*er este pro+lema7 se puede rede,inir la plantilla de ,uncin de tal ,orma %ue se puedan usar *arios tipos como sigue a continuacin6 template Etypename T7 typename "F T sumarKT7 "LM (ientras %ue su implementacin se puede e>presar de la siguiente ,orma6 template Etypename T7 typename "F T sumarKT a7 " +LU return a++M Y En este caso7 la plantilla de ,uncin tiene dos par)metros de plantillas de di,erentes tipos y retorna el tipo de dato de,inido por el primer par)metro de plantilla. 9u uso puede ser de ,orma impl0cita o e>plicita tal como se muestra a continuacin6 sumarK171.2LM sumarEint7,loatFK171.2LM

'3

De ,orma impl0cita una plantilla de ,uncin con dos par)metros de plantillas ET7"F7 puede comportarse en una plantilla de ,uncin con un mismo tipo de dato si TW".

Plantillas de clases
Tam+iBn e>iste la posi+ilidad de implementar plantillas de clases7 es decir clases %ue tengan7 como miem+ros7 atri+utos o mBtodos %ue usen par)metros de plantillas como tipos. Por ejemplo7 note el uso de una clase Pareja cuyo o+jeti*o es o+tener una dupla de cual%uier clase genBrica. 9u de,inicin se muestra a continuacin6 template Eclass TF class Pareja U pri*ate6 T aM T +M pu+lic6 ParejaKT7TLM T getAKLM T getDKLM YM (ientras %ue la implementacin de sus mBtodos se muestran a continuacin6 template Eclass TF ParejaETF66ParejaKT a17 T a2L6 aKa1L7+Ka2LUY template Eclass TF T ParejaETF66getAKLU return aMY template Eclass TF T ParejaETF66getDKLU return +MY /a clase Pareja se :a de,inido con el ,in de almacenar dos elementos de cual%uier clase o tipo de datos K*ale la pena recordar %ue en C++ los tipos de datos son clasesL. Para su uso es necesario e>plicitar el tipo de dato o clase. ?ote los siguientes ejemplos6 ParejaEintF miHparK172LM NNpar ordenado de tipo int ParejaEdou+leF dparK2.078.2LM NNpar ordenado de tipo dou+le ParejaEPersonaF parKp7%LM NNpar ordenado de Personas ParejaE+oolF logicHparKtrue7,alseLM NNpar ordenado de +ool

30

Especiali)acin de plantillas
Es posi+le de,inir di,erentes implementaciones para una plantilla cuando reci+a un tipo espec0,ico *0a par)metros de plantillas. Por ejemplo7 se de,ine una plantilla de clases llamada Dato7 cuyo o+jeti*o es almacenar cual%uier tipo de datos6 NN Plantilla de clase6 template Eclass TF class Dato U T elementoM pu+lic6 Dato KT argL UelementoWargMY T incrementar KL Ureturn ++elementoMY YM Es posi+le especiali4ar la plantilla de clases Dato7 de tal ,orma %ue cuando el tipo de dato %ue reci+e el par)metro de plantilla sea c:ar7 estB presente un mBtodo llamado ma(us42 cuyo o+jeto es o+tener la letra mayAscula del elemento. NN Especiali4acin de la plantilla de clase6 template EF class Dato Ec:arF U c:ar elementoM pu+lic6 Dato Kc:ar argL UelementoWargMY c:ar mayus KLU i, KKelementoFWjajLIIKelementoEWj4jLL elemento+WjAjCjajM return elementoM Y YM ?ote el uso de la pala+ra reser*ada template sin tipo de par)metros en la ca+ecera de la clase7 de+ido a %ue este se de,ine de ,orma e>plicita Kc:arL. -+ser*e sus respecti*os usos en la siguiente ,uncin main6 int main KL U DatoEintF myint K!LM DatoEc:arF myc:ar KjjjLM cout EE myint.incrementarKL EE `7a EE myc:ar.mayusKL EE endlM 31

Plantillas sin tipo de par,metros

Es posi+le iniciali4ar los par)metros de plantillas sea con un tipo de dato7 clase u *alor *)lido7 de tal ,orma %ue pueden usarse plantillas sin par)metros de plantillas. Por ejemplo note la iniciali4acin de la ca+ecera de la plantilla de clase Pareja. template Eclass TWintF class Pareja U pri*ate6 T aM T +M pu+lic6 ParejaKT7TLM T getAKLM T getDKLM YM /a siguiente ,uncin main muestra la declaracin o+jetos usando la plantilla de clase Pareja sin par)metros6 int mainKL U ParejaE,loatF miHparK172LM ParejaEF parK.78LM NNPlantilla sin par)metros7 por de,ecto int f Y

)e"erencias
9-"/Ik7 ^uan. C++ /anguage Tutorial. PEn l0neaQE:ttp6NN<<<.cplusplus.comNdocNtutorialNF PCon acceso 2011N01N01Q

32

5iblioteca estndar de plantillas

Introduccin
El presente capitulo tiene como o+jeti*o dar una introduccin y posterior uso so+re un gran conjunto de estructuras de datos y algoritmos los cuales con,orman las Di+lioteca est)ndar de plantilla KStandard Tem!late Pibrar( i STPL. 9e e>ploraran los elementos de la li+rer0a 9T/ de acuerdo a su ,uncionalidad.

$a !i!lioteca de plantillas est,ndar

/a +i+lioteca de plantillas est)ndar son un conjunto de +i+liotecas %ue constan de contenedores7 algoritmos genBricos7 iteradores7 o+jetos ,unciones7 asignadores7 adaptadores y estructuras de datos. /os algoritmos y las estructuras de datos usadas dentro del a +i+lioteca son a+stractos7 en el sentido de %ue estos pueden ser usados7 pr)cticamente7 con cual%uier tipo de datos.

Especi"icaciones !,sicas para el uso de las .%$ Clases agradables

"na clase agrada+le Knice classL es cual%uier clase la cual cumpla con los siguientes re%uerimientos6 1L Constructor de copia 2L -perador de asignacin .L -perador de igualdad 8L -perador de desigualdad /a sinta>is de su de,inicin se muestra a continuacin6 class ?iceU pu+lic6 ?iceKconst ?ice ICopyLM ?ice IoperatorW Kconst ?ice ICopyLM +ool operatorWW Kconst ?ice IparamL constM +ool operatorgW Kconst ?ice IparamL constM YM Para el uso de las 9T/ es recomenda+le %ue las clases la cual *an a manipular cumplan los re%uisitos de la clases agrada+les. Aun%ue actualmente la +i+lioteca de plantillas tiene de,inido los operadores relacionales KWW7 gW7 E7 EW7 F7 FWL lo ideal es %ue se de,inan de acuerdo al conte>to de nuestras clases.

bjeto %uncin
Es un o+jeto de una clase %ue tiene de,inido el operador de llamada a ,uncin KoperatorKLL7 por ejemplo7 3.

o+ser*e la de,inicin de la siguiente clase6 class less U pu+lic6 less Kint *L 6 *al K*L UY +ool operator KL Kint *L U return * E *alM Y pri*ate6 int *alM YM Esta clase permite sa+er si un o+jeto o *alor de ,uncin es menor %ue el entero el cual contiene. Por ejemplo note su uso en la ,uncin main6 int mainKLU less menorH%ueK1LM int 4W1M i,KmenorH%ueK4LL NNuso del operador de llamada a ,uncin coutEEael numero es menor %ue 1aEEendlM Y

Componentes de la !i!lioteca est,ndar de plantillas

/a 9T/ se puede considerar como una +i+lioteca de componentes de so,t<are7 se de,ine por componente de so,t<are un conjunto de o+jetos7 ,unciones7 etc generalmente precompilados con inter,aces +ien de,inidas y listos para ser usados en di,erentes conte>tos. /a 9T/ esta compuesta por 1 componentes principales6 1L Contenedores6 -+jetos %ue permiten administras otros o+jetos. 2L Algoritmos6 procedimiento computacional %ue opera so+re di,erentes contenedores. .L Iteradores6 algoritmos de accesos aplicados so+re contenedores. 8L -+jetos ,uncin6 clases %ue tienen de,inido el operador de llamada a ,uncin. 1L Adaptadores6 Permiten encapsular un componente para o,recer otras inter,aces.

Principales componentes de la .%$7

Es muy importante elegir una clase de la 9T/ %ue estB de acuerdo con lo %ue se necesita. Ciertas
3 Gios[era7 Introduccin a la 9T/ en C++ Precurso disponi+le en lineaQE:ttp6NNes.[ios[ea.netN,a%N.12'CintroduccionCaClaC stlCenCcCstandardCtemplateCli+raryFPcon acceso6 2011N01NQ

38

estructuras son m)s e,icaces %ue otras para acceder a memoria o en tBrminos de reasignacin de memoria cuando se :acen importantes. El desa,0o de esta parte consiste en presentar las *entajas y des*entajas de cada una de ellas. Pre*iamente es necesario tener algunas nociones de di,icultad. 9ea n el tamaOo de un contenedor. "n algoritmo es llamado lineal Ken O4n2L si su tiempo de calculo es proporcional a n. Igualmente7 un algoritmo puede ser instant)neo KO482L7 logar0tmico O4log4n22, polinomial O4nVO27 e>ponencial O4e4n227 etc... Para resumir7 a continuacin la lista de di,icultades en orden creciente de la proporcin de tiempo de c)lculo6 O482 O4log4n22 O4n2 O4nVO2 O4e4n22

Contenedores
A continuacin se da una +re*e re*isin de los contenedores mostrando el interBs7 principalmente a la di,icultad de acceso K+As%uedaL a un dato almacenado en un contenedor y a la di,icultad para insertar un dato.
std11pair8%9:%;<

"n par es una estructura conteniendo dos elementos e*entualmente de tipos di,erentes. Ciertos algoritmos de la 9T/ Kpor ejemplo ,indL de*uel*en pares Kposicin del elemento encontrado y un +ooleano %ue indica si :a sido encontradoL. Di,icultad6 insercin y acceso en -K1L #include <pair> // en la prctica este include es sobreentendido ya que implcitamente //se hace cuando utilizamos <vector>, <set> ... #include <iostream> #include <string> int main(){ std::pair<int,std::string> p = std::make_pair(5,"pouet"); std::cout << p.first << ' ' << p.second << std::endl; return 0; } 31

std11list8%:...<

/a clase list pro*ee una estructura genBrica de listas enla4adas pudiendo e*entualmente contener repeticiones. Di,icultad Insercin Kal inicio o ,in de listaL6 -K1L DAs%ueda6 -KnL en general7 -K1L para el primer y el ultimo esla+n Este ejemplo muestra cmo insertar los *alores 8717871 en una lista y cmo mostrar su contenido6 #include <list> #include <iostream> int main(){ std::list<int> mi_lista; mi_lista.push_back(4); mi_lista.push_back(5); mi_lista.push_back(4); mi_lista.push_back(1); std::list<int>::const_iterator lit (mi_lista.begin()),lend(mi_lista.end()); for(;lit!=lend;++lit) std::cout << *lit << ' '; std::cout << std::endl; return 0; }
std11 ector8%:...<

/a clase *ector es muy similar a la de array de C. Todos los elementos contenidos en el *ector est)n contiguos en memoria7 lo %ue permite acceder inmediatamente a cual%uier elemento. /a *entaja de *ector comparada a la de array de C es su capacidad a reasignarse autom)ticamente en caso de %ue sea necesario7 por ejemplo durante un pus:H+ac[. 9in em+argo al igual %ue el array cl)sico7 el operador PQ Anicamente puede acceder a una casilla si :a sido asignada pre*iamente Ksi no se produce un error de segmentacinL. Di,icultad6 Acceso -K1L Insercin6 -KnL al inicio del *ector KpopH+ac[L7 -K1L al ,inal del *ector Kpus:H+ac[L. En los dos 32

casos puede ocurrir una reasignacin. ?o :ay %ue ol*idar %ue una reasignacin de memoria es costosa en tBrminos de tiempo de c)lculo. As07 si el tamaOo de un *ector es conocido de antemano7 en lo posi+le :ay %ue crearlo directamente con este tamaOo. Ejemplo6 Sinclude E*ectorF #include <iostream> int main(){ std::vector<int> mi_vector; mi_vector.push_back(4); mi_vector.push_back(2); mi_vector.push_back(5); // para recorrer un vector podemos utilizar los iteradores o los //ndices for(std::size_t i=0;i<mi_vector.size();++i) std::cout << mi_vector[i] << ' '; std::cout << std::endl; std::vector<int> v(5,69); // crea el vector 69,69,69,69,69 v[0] = 5; v[1] = 3; v[2] = 7; v[3] = 4; v[4] = 8; return 0; }
std11set8%:...<

/a clase set permite descri+ir un conjunto ordenado y sin repeticin de elementos. Pre*iamente es necesario parar este orden como par)metro template un o+jeto ,uncin. Por de,ecto7 el o+jeto ,uncin std66less K+asado en el operador EL es utili4ado7 lo %ue e%ui*ale a tener un conjunto de elementos clasi,icados del m)s pe%ueOo al m)s grande. Concretamente7 +asta con implementar el operador E de una clase o una estructura de tipo T para poder de,inir un std66setETF. Adem)s7 el tipo T de+e disponer de un constructor *ac0o TKL. 3!

Di,icultad6 -KlogKnLL para la +As%ueda e insercin. E,ecti*amente7 la estructura std66set saca partido del orden so+re T para construir una estructura de )r+ol roja y negra7 lo %ue permite la +As%ueda logar0tmica de un elemento #include <set> #include <iostream> int main(){ std::set<int> s; // equivale a std::set<int,std::less<int> > s.insert(2); // s contiene 2 s.insert(5); // s contiene 2 5 s.insert(2); // el repetido no es insertado s.insert(1); // s contiene 1 2 5 std::set<int>::const_iterator sit (s.begin()), send(s.end()); for(;sit!=send;++sit) std::cout << *sit << ' '; std::cout << std::endl; return 0; } Atencin6 el eliminar o agregar un elemento en un std66set *uel*e in*alido a sus iteradores. ?o se de+e modi,icar un std66set en un +ucle ,or +asado en sus iteradores.
std11map8=:%:...<

"n map permite asociar una cla*e a un dato. El map toma al menos dos par)metros templates6 el tipo de la cla*e G el tipo del dato T Al igual %ue std66set7 el tipo G de+e ser ordenado Keste orden puede ser pasado como .er par)metro template7 std66lessEGF por de,ectoL y7 el tipo T solo impone tener un constructor *ac0o. Di,icultad6 -KlogKnLL para la +As%ueda e insercin. En e,ecto7 la estructura std66map saca partido del orden so+re T para construir una estructura de )r+ol rojo y negro7 lo %ue permite una +As%ueda logar0tmica de un elemento. Atencin6 el eliminar o agregar un elemento en un std66map *uel*e in*alido a sus iteradores. ?o se 3'

de+e modi,icar un std66map en una +ucle ,or +asada en sus iteradores. Atencin6 el :ec:o de acceder a una cla*e *0a el operador PQ inserta esta cla*e Kcon el dato TKLL en el map. Por ello7 el operador PQ no es adaptado para *eri,icar si una cla*e est) presente en el map7 es necesario utili4ar el mBtodo ,ind. Adem)s no asegura la constancia del map Ka causa de las potenciales insercionesL y por lo tanto no puede ser utili4ado en un const std66map. Ejemplo6 #include <map> #include <string> #include <iostream> int main(){ std::map<std::string,unsigned> map_mes_idx; map_mes_idx["enero"] = 1; map_mes_idx["febrero"] = 2; std::map<std::string,unsigned>::const_iterator mit (map_mes_idx.begin()); std::map<std::string,unsigned>::const_iterator mend(map_mes_idx.end()); for(;mit!=mend;++mit) std::cout << mit->first << '\t' << mit->second << std::endl; return 0; }

!os iteradores
En la seccin anterior se o+ser* %ue los iteradores permiten recorrer ,)cilmente una estructura de la 9T/. "n iterador recuerda un poco la nocin de puntero7 pero no es una direccin. A continuacin se o+ser*an cuatro iteradores cl)sicos de la 9T/. Estos son de,inido para todas las clases de la 9T/ dic:as anteriormente Kentre ellas por supuesto std66pairL
iterator y const>iterator

"n iterador Ky un constHiteratorL permite recorrer un contenedor de inicio a ,in. "n constHiterator contrariamente a un iterator7 da acceso Anicamente para la lectura del elemento deseado. As07 un recorrido con constHiterator no produce cam+ios en el contenedor. Es por ello %ue un contenedor `consta puede ser recorrido por constHiterators pero no por iterators. 33

En general7 cuando se de+e elegir entre iterators y constHiterators7 siempre :ay %ue pre,erir los constHiterators ya %ue estos *uel*en la seccin de cdigo a la cual sir*en m)s genBrica Kaplica+le a los contenedores const o no constL +eginKL6 de*uel*e un iterador %ue apunta al primer elemento endKL6 de*uel*e un iterador %ue apunta justo despuBs del ultimo elemento ++6 Permite incrementar el iterador :aciBndolo pasar al elemento siguiente. #include <list> #include <iostream> const std::list<int> crear_lista(){ std::list<int> l; l.push_back(3); l.push_back(4); return l; } int main(){ const std::list<int> mi_lista(crear_lista()); std::list<int>::const_iterator lit2 (mi_lista.begin()), lend2(mi_lista.end()); for(;lit2!=lend2;++lit2) std::cout << *lit2 << ' '; std::cout << std::endl; return 0; }
re erse>iterator y const>re erse>iterator

Ejemplo6

El principio de re*erseHiterator y constHre*erseHiterator es similar a los iterators y constHiterator pero el recorrido se :ace en el sentido opuesto. "tili4amos6 r+eginKL 6 de*uel*e un iterador %ue apunta :acia el Altimo elemento 100

 rendKL 6 de*uel*e un iterador %ue apunta justo antes del primer elemento CC 6 permite disminuir el re*erseHiterator :aciBndolo pasar al elemento precedente. #include <set> #include <iostream> int main(){ std::set<unsigned> s; s.insert(1); // s = {1} s.insert(4); // s = {1, 4} s.insert(3); // s = {1, 3, 4} std::set<unsigned>::const_reverse_iterator sit (s.rbegin()), send(s.rend()); for(;sit!=send;++sit) std::cout << *sit << std::endl; return 0; } ... muestra6 8 . 1

.lgoritmos
/a +i+lioteca est)ndar de plantillas o,rece una *ariedad di*ersas de algoritmos. Estos estan presentes en el arc:i*o de ca+ecera EalgorithmF los cuales se mencionan a continuacin106 operaciones sobre secuencias6 for_each Aplica una ,uncion so+re un rango Kplantilla de ,uncinL find Dusca un *alor dentro del rango Kplantilla de ,uncinL find_if Dusca un elemento dentro del rango Kplantilla de ,uncinL find_end Dusca la ultima su+secuencia dentro del rango Kplantilla de ,uncinL find_first_of Dusca la primer registro de un *alor dentro de un rango Kplantilla de ,uncinL
10 C++ 5e,erence i Algorit:ms Precurso disponi+le en lineaQ<:ttp6NN<<<.cplusplus.comNre,erenceNalgorit:mNFPcon acceso6 2011N01N01Q

101

adjacent_find Duscar la igualdad de elementos adyacentes en el rango Kplantilla de ,uncinL count Cuenta las apariciones de un *alor dentro de un rango Kplantilla de ,uncinL 5etorna un numero de elementos los cuales cumplen cierta condicin Kplantilla de count_if ,uncinL mismatch De*uel*e la primera posicin en la cual dos rangos di,ieren Kplantilla de ,uncinL equal Comprue+a si los elementos en dos rangos son iguales Kplantilla de ,uncinL search Dusca su+secuencias en el rango Kplantilla de ,uncinL search_n Dusca la sucesion de *alores iguales dentro de un rango Kplantilla de ,uncinL Operaciones de modificacin de secuencias6 copy Copia un rango de elementos Kplantilla de ,uncinL copy_backward Copia rango de elementos :acia atr)s Kplantilla de ,uncinL swap Intercam+ia los *alores de dos elementos Kplantilla de ,uncinL swap_ranges Intercam+ia los *alores de dos rangos Kplantilla de ,uncinL iter_swap Intercam+ia el *alor de un rango mediante iteradores Kplantilla de ,uncinL transform Aplica la ,uncin a un rango Kplantilla de ,uncinL replace 5empla4a un *alor dentro de un rango Kplantilla de ,uncinL replace_if 5empla4a un *alor de acuerdo a una condicin Kplantilla de ,uncinL replace_copy Copia rango de sustitucin de *alores Kplantilla de ,uncinL replace_copy_if Copia rango de sustitucin de *alores Kplantilla de ,uncinL fill /lena un rango con *alores Kplantilla de ,uncinL fill_n /lena un rango con *alores Kplantilla de ,uncinL generate enera *alores para un rango Kplantilla de ,uncinL generate_n enera *alores por secuencias Kplantilla de ,uncin L remove 5emue*e *alores de un rango Kplantilla de ,uncinL remove_if 5emue*e *alores de un rango Kplantilla de ,uncinL remove_copy Copia un rango remo*iendo los anteriores *alores Kplantilla de ,uncinL remove_copy_if Copia un rango remo*iendo los anteriores *alores Kplantilla de ,uncinL unique 5emue*e *alores duplicados Kplantilla de ,uncinL unique_copy Copia un rango sin *alores repetidos Kplantilla de ,uncin L reverse In*ierte un rango de *alores Kplantilla de ,uncinL reverse_copy Copia un rango in*ertido Kplantilla de ,uncinL rotate 5ota los elementos dentro de un rango Kplantilla de ,uncinL rotate_copy Copia un rango rotado Kplantilla de ,uncinL random_shuffle 5eorgani4a los elementos de ,orma aleatoria Kplantilla de ,uncin L partition Di*ide un rango en dos Kplantilla de ,uncinL stable_partition Di*ide un rango en dos ordenamiento esta+le Kplantilla de ,uncinL Ordenamiento6 sort -rdena los elementos dentro de un rango Kplantilla de ,uncinL 102

stable_sort partial_sort partial_sort_copy nth_element

-rdena los elementos manteniendo el orden de e%ui*alencia Kplantilla de ,uncinL -rdena parcialmente los elementos dentro de un rango Kplantilla de ,uncinL Copia un rango ordenado parcialmente Kplantilla de ,uncinL -rdena los elementos dentro de un rango Kplantilla de ,uncinL

Busqueda Binario Koperaciones so+re rangos ordenadosL6 lower_bound 5etorna un iterador del limite in,erior Kplantilla de ,uncinL upper_bound 5etorna un iterador del limite in,erior Kplantilla de ,uncinL equal_range -+tiene su+rangos de iguales elementos Kplantilla de ,uncinL binary_search Prue+a si un *alor esta dentro de un rango ordenado Kplantilla de ,uncinL Merge Koperaciones so+re rangos ordenadosL6 merge Com+inan datos ordenados Kplantilla de ,uncinL inplace_merge Com+inan datos de *arios rangos ordenados Kplantilla de ,uncinL includes Prue+a si un rango ordenados incluye otra serie ordenada Kplantilla de ,uncinL set_union "ne dos rangos ordenados Kplantilla de ,uncinL set_intersection Intercepta dos rangos ordenados Kplantilla de ,uncinL set_difference -+tiene la di,erencia de dos rangos ordenados Kplantilla de ,uncin L -+tiene la di,erencia simetrica de dos datos ordenados Kplantilla de set_symmetric_difference ,uncinL Heap6 push_heap pop_heap make_heap sort_heap

(ete elementos dentro de un rango Kplantilla de ,uncinL 9aca elementos dentro de un rango Kplantilla de ,uncinL Crea un mont0culo dentro de un rango Kplantilla de ,uncin L -rdena los elementos dentro de un mont0culo Kplantilla de ,uncinL

Min ma!6 min 5eturna el menor de dos argumentos Kplantilla de ,uncinL ma! 5etorna el mayor de dos argumentos Kplantilla de ,uncinL min_element 5etorna el menor elemento dentro de un rango Kplantilla de ,uncinL ma!_element 5etorna el menor elemento dentro de un rango Kplantilla de ,uncinL le!icographical_compare Compara le>icogr),icamente dos argumentos Kplantilla de ,uncin L ne!t_permutation Trans,orma los datos a una pr>ima permutacin Kplantilla de ,uncinL prev_permutation Trans,orma los datos a una pr>ima permutacin Kplantilla de ,uncinL

10.

)e"erencias
9-"/Ik7 ^uan. C++ /anguage Tutorial. PEn l0neaQE:ttp6NN<<<.cplusplus.comNdocNtutorialNF PCon acceso 2011N01N01Q. C++ 5e,erence i Algorit:ms PEn lineaQ <:ttp6NN<<<.cplusplus.comNre,erenceNalgorit:mNFPcon acceso6 2011N01N01Q. Gios[era7 Introduccin a la 9T/ en C++ PEn lineaQE:ttp6NNes.[ios[ea.netN,a%N.12'CintroduccionCaC laCstlCenCcCstandardCtemplateCli+raryFPcon acceso6 2011N01N01Q

108