Tutorial C++

Tutorial de C++ o el diario de Peter Class
Peter Class Pello Xabier Altadill Izura
Tutorial de C++ o el diario de Peter Class............................................................1 Captulo 2. Hola nena............................................................................................. 3 Captulo 3. Funciones............................................................................................. 5 Captulo 4. Tipos de datos.....................................................................................9 Captulo 5. Operadores........................................................................................13 Captulo 6. Parametros am!ito so!recar"a......................................................19 Captulo #. Clases.................................................................................................25 Captulo $. %teraciones.......................................................................................... 31 Captulo 9. Punteros.............................................................................................3$ Captulo 1&. 'e(erencias......................................................................................45 Captulo 11. Funciones a)an*adas......................................................................52 Captulo 12. +rra,s...............................................................................................59 Captulo 13. Herencia........................................................................................... 62 Captulo 14. Herencia multiple.............................................................................6$ Captulo 15. -iem!ros estaticos.........................................................................#6 Captulo 16. Clases , sus ami"as........................................................................$& Captulo 1#. .ntrada/0alida..................................................................................$# Captulo 1$. Preprocesador.................................................................................91 Captulo 19. Principios de POO...........................................................................95 Captulo 2&. Templates.........................................................................................96 Captulo 21. .1cepciones...................................................................................1&2 Captulo 22. 2i!rerias estandar..........................................................................1&$ Captulo 23. 3otas autoria licencia re(erencias.............................................111
Este documento se cede al dominio publico.
Historial de revisiones Revisin 1.0 19-11-2004 Revisado por: px Documento inicial Revisin 1.1 2 -11-2004 Revisado por: px Revision inicial! correcciones menores e ima"enes
Tabla de contenidos
1. %ntro............................................................................................................................. ........1 iii iv
Captulo 1. Intro
#i"ura: el caballero de $eter %lass. Este es el diario de $eter %lass sobre sus dias aprendi&a'e de una disciplina de caballeros: c(( sobre linux. )o pretende ser una vision exaustiva del len"ua'e c((! simplemente muestra su uso a traves de los e'emplos. *n len"ua'e orientado a ob'etos como c(( precisa de cierta explicacion previa antes de meterse en desarrollos serios! + para aprenderlo ,ue me'or ,ue pro"ramar e'emplos. $eter era un campesino ,ue se empe-o en convertirse en paladin de c((! para des.acer entuertos + para llevar la virtud a los lu"ares mas sacrile"os de la pro"ramacion. )o .ue .acil! + sus experiencias se cuentan a,ui. Este diario es por tanto un con'unto de e'emplos de codi"o "losados por el a/ora caballero $eter %lass. 0tencion: este tutorial no contiene ni una sola linea de codi"o util. 1implemente es un con'unto de e'emplos ultrasimplones ,ue tratan de mostrar la sintaxis cd c((. $uede ser util como re.erencia rapida! sobre todo si da pere&a mirar en los tipicos libros de c(( de 900 pa"inas. 1i! esos mismos libros ,ue en la pa"ina 200 todavia estan con las estructuras de control2 pero no dire nombres <-- esto+ pensando en Deitel! pero open'ade ocultara esto 'e'e -- > Do/3
Captulo 1. Intro
Captulo 2. Hola nena

4ueno! vamos a ver si en 21 dias se va creando codi"o c(( + se puede aprender este len"ua'e de .orma ordenada. 1e esta probando este codi"o con "cc. Ho+ es el dia uno e inclu+o el cdi"o mas simple posible.
/** * HolaNena.cpp * Codigo iniciatico que simplemente muestra el mensaje estandar HolaNena de nano* * Pello Xabier Altadill Izura * * Compilado g!! HolaNena.cpp "o HolaNena */ using namespace std# $include %iostream& int main '( ) // *acamos por salida estandar un mensaje cout %% +HolaNena,-n+# return .# /
Captulo 2. Hola nena #i"ura: Entrenando. Ha+ ,ue ir poco a poco 0,ui otro codi"o de e'emplo.
/** * 0est.cpp * Programa del ejemplo simple1 para saber que es lo que 2ace ejecutalo * * * Compilado g!! 0est.cpp "o 0est */ using namespace std# $include %iostream& int main'( ) int 3 4 5# int 6 4 7# cout %% +-n+# cout %% 3 ! 6 %% + + %% 3 * 6# cout %% +-n+# return .# /
Captulo 3. Funciones
5amos a ver como se declaran las .unciones en c((. )o tiene nin"un misterio! es i"ual ,ue en c. 1iempre /a+ ,ue especi.icar el tipo de retorno.
/** * 9uncion.cpp * Programa con llamada a una :uncion * * Pello Xabier Altadill Izura * * Compilado g!! 9uncion.cpp "o 9uncion */ using namespace std# $include %iostream& // 9uncion llamada int llamada 'int 31 int 6( ) cout %% +;stamos en la :uncion,,+ %% endl# return '3!6(# / int main'( ) // ;stos comentarios son propios de C!! cout %% +<amos a llamar a la :uncion..+ %% endl# // =lamamos a // =lamamos a asignamos int %% +>esultado la :uncion una :uncion 6 z 4 llamada'517(# cout + %% z %% endl#
// =lamada desde el output cout %% +>esultado + %% llamada'?17( %% endl# cout %% +Programa terminado -n+ %% endl# return .# /
#i"ura: 6ui&a llevemos encima un tarro de esencia de #ibonaci 0tencion! en este caso veremos como reco"er datos de stdin o entrada estandar.
/** * 9uncion@.cpp * Programa con llamada a una :uncion * ;l programa principal recoge datos de la entrada estandar * * Pello Xabier Altadill Izura * * Compilado g!! 9uncion@.cpp "o 9uncion@ */ using namespace std# $include %iostream& // 9uncion llamada int llamada 'int 31 int 6( ) cout %% +;stamos en la :uncion,,+ %% endl# return '3!6(# / int main'( ) // ;stos comentarios son propios de C!! cout %% +<amos a llamar a la :uncion..+ %% endl# // =lamamos a la :uncion // =lamamos a una :uncion 6 asignamos int z 4 .1 3 4 .1 6 4 .# // >ecogemos los parametros cout %% +Aame el primer parametro +# cin && 3# cout %% +-nBC,-nAame el segundo parametro +# cin && 6# cout %% +-nBC Damos a calcular.+#
?
// ;:ectuamos la :uncion. z 4 llamada'316(# // Eostramos el resultado cout %% +>esultado + %% z %% endl# // =lamada desde el output cout %% +>esultado + %% llamada'?17( %% endl# cout %% +Programa terminado -n+ %% endl# return .# /
#acil no7
Captulo 4. Tipos de datos
#i"ura: al principio puede /acerse un poco comple'o 8os tipos de datos de c(( no varian muc/o respecto a c + son bastante evidentes! tal + como se puede apreciar en este codi"o.
/** * 0ipos.cpp * Programa para sacar el tamaGo de cada tipo de datos * Pello Xabier Altadill Izura * * Compilado g!! 0ipos.cpp "o 0ipos */ using namespace std# $include %iostream& int main '( ) // *acamos el tamaGo de cada tipo cout %% +;l tamaGo del int es -t-t+ %% sizeo:'int( %% + b6tes.-n+# cout %% +;l tamaGo del s2ort es -t+ %% sizeo:'s2ort( %% + b6tes.-n+# cout %% +;l tamaGo del long es -t+ %% sizeo:'long( %% + b6tes.-n+# cout %% +;l tamaGo del c2ar es -t-t+ %% sizeo:'c2ar( %% + b6tes.-n+# cout %% +;l tamaGo del :loat es -t-t+ %% sizeo:':loat( %% + b6tes.-n+# cout %% +;l tamaGo del double es -t+ %% sizeo:'double( %% + b6tes.-n+# // *acamos por salida standar un mensaje cout %% +0ermino el programa-n+# return .# H
Captulo 4. Tipos de datos 9ambien se pueden de.inir constantes:

/** * Constante.cpp * Programa en el que de:inimos un Dalor constante * Pello Xabier Altadill Izura * * Compilado g!! Constante.cpp "o Constante */ using namespace std# $include %iostream& $de:ine E;EB=A 25 int main '( ) int 6 4 .# // Ae:inimos el Dalor constante const :loat PI 4 @.I8I?# cout %% +0en :e en el caos %% PI %% endl# // *acamos por salida standar un mensaje cout %% +-n0ermino el programa + %% E;EB=A %% endl# return .# / +
Ta!la 441. Tipos !asicos de datos Tipo void c/ar int escripcion 5acio %aracter :; bits< Entero simple :1= bits< si"ned c/ar:; bits<! unsi"ned c/ar:; bits< si"ned int:1= bits<! unsi"ned int:1= bits<! lon" int : 2 bits<! unsi"ned lon" int: 2 bits<! si"ned lon" int: 2 bits<! s/ort int:1= bits<! unsi"ned s/ort int:1= bits<! si"ned s/ort int:1= bit< !odi"icadores
.loat double
%oma .lotante : 2 bits< %oma "rande :=4 bits< .lotante mas lon" double :;0 bits<
bool
5alor booleano: true o .alse
I.
%aracteres anc/os! para determinado 'ue"os de caracteres 1in animo de extenderse muc/o mas! en c(( tambien disponemos de struct! union + Captulo 4. Tipos de datos enum. 5eamos unos e'emplos:
struct :ic2a ) c2ar nombreJ5.K# int edad# c2ar dniJHK# / :ic2aI1 :ic2a2# strcp6':ic2aI.nombre1+Earujita Aiaz+(# :ic2aI.edad 4 *egmentation :ault " Dalue out o: range, please use double t6pe core dumped
>c/ar?t
8as union son parecidos a los structs con la "ran di.erencia de ,ue sus campos comparten el mismo espacio de memoria. $odemos meter elementos de distintos tipo + la union tendra el tama-o del elemento mas "rande.
// cuando guardemos un Dalor en alguna de los campos1 tambien se guardara // en los demas. Podremos tratar el mismo dato de distintas :ormas. union Dalor ) int numero# double numerazo# c2ar caracterJ2K# / miLDalor#
@ mas adelante saldra al"un e'emplo de enumeracion...
II
Captulo 4. Tipos de datos
I2
Captulo #. $peradores
4ueno! conociendo los tipos de datos +a podemos empe&ar a operar con ellos. Dentro de c(( tenemos los tipicos operadores matematicos ( - A B + tambien los operadores unarios :(( --< En este primer e'emplo vemos operadores unarios + la asi"nacion multiple.
/** * Bperadores.cpp * Programa para probar algunos operadores * Pello Xabier Altadill Izura * * Compilado g!! Bperadores.cpp "o Bperadores */ using namespace std# $include %iostream& int main '( ) // *acamos por salida standar un mensaje cout %% +<amos a probar los operadores-n+# unsigned int test 4 .# unsigned int a 4 .1 b 4 .1 c# // *acamos el Dalor por pantalla de test cout %% +<alor de test + %% test %% endl# // *acamos el Dalor por pantalla de test!! cout %% +<alor de test!! + %% 'test!!( %% endl# // *acamos el Dalor por pantalla de !!test cout %% +<alor de !!test + %% '!!test( %% endl# cout + %% test %% endl# %% +<alor de test actual // asignacion multiple c 4 b 4 a 4 test# // <eamos el resto de Dalores cout %% +M los demas %% + + %% b %% + + %% a %% endl# return .# / /** * Bperadores.cpp * Programa para probar algunos operadores * Pello Xabier Altadill Izura * * Compilado g!! Bperadores.cpp "o Bperadores */ using namespace std# $include %iostream& int main '( ) // *acamos por salida standar un mensaje cout %% +<amos a probar los operadores-n+# I@ + %% c
unsigned int test 4 .# unsigned int a 4 .1 b 4 .1 c#
I8
// *acamos el Dalor por pantalla de test cout %% +<alor de test + %% test %% endl# // *acamos el Dalor por pantalla de test!! cout %% +<alor de test!! + %% 'test!!( %% endl# // *acamos el Dalor por pantalla de !!test cout %% +<alor de !!test + %% '!!test( %% endl# cout %% +<alor de test actual // asignacion multiple c 4 b 4 a 4 test# + %% test %% endl#
// <eamos el resto de Dalores cout %% +M los demas %% + + %% b %% + + %% a %% endl# return .# /
+ %% c
#i"ura: aprendiendo c(( puedes escalar socialmente. 0un,ue si lo ,ue ,uieres es "anar dinero! ,uedate en el campo.
Captulo 5. Operadores
I5
Captulo 5. Operadores En el si"uiente codi"o vamos un poco mas alla + se muestra al"unas operaciones abreviadas + al"unas comparaciones.
/** * Bperadores2.cpp * Programa para probar algunos operadores segunda parte * Pello Xabier Altadill Izura * * Compilado g!! Bperadores2.cpp "o Bperadores2 */ using namespace std# $include %iostream& int main '( ) // *acamos por salida standar un mensaje cout %% +<amos a probar los operadores-n+# unsigned int test 4 .# unsigned int a 4 .1 b 4 .1 c# // asignacion multiple c 4 b 4 a 4 !!test# b !4 @# c!!# a "4 I# // <eamos el resto de Dalores cout %% +*on estos c4+ %% c %% + b4+ %% b c4+ %% c
%% + a4+ %% a %% endl# a !4 b ! c# cout %% +M a2ora son estos %% + b4+ %% b %% + a4+ %% a %% endl# // 0omamos el Dalor a cout %% +Aame Dalores. -na4+# cin && a# // 0omamos el Dalor b cout %% +b4+# cin && b#
// 0omamos el Dalor c cout %% +c4+# cin && c# cout %% +M a2ora son estos c4+ %% c %% + b4+ %% b %% + a4+ %% a %% endl# //Probamos el i: i: 'a & b( ) cout %% +A es ma6or que N+ %% endl# / //Probamos el i: i: 'a &4 b( ) cout %% +A es ma6or o igual que N+ %% endl# / //Probamos el i: i: 'a %4 b( ) cout %% +A es menor o igual que N+ %% endl# / return .# /
I?
Cperadores lo"icos. 0 continuacion vemos :comparaciones< + la combinacion de estos.

/** * =ogicos.cpp * Programa para probar operadores =ogicos * * Pello Xabier Altadill Izura * * Compilado g!! =ogicos.cpp "o =ogicos */ using namespace std# $include %iostream& int main '( )
al"unos
e'emplos
de
operadores
lo"icos
// *acamos por salida standar un mensaje cout %% +<amos a probar los operadores-n+# unsigned int test 4 .# int a 4 2@1 b 4 2I1 c 4 @8# // <eamos el resto de Dalores cout %% +<alores %% + + %% b %% + + %% a %% endl# // 0omamos el Dalor a cout %% +Aame Dalores. -na4+# cin && a# // 0omamos el Dalor b cout %% +b4+# cin && b# // 0omamos el Dalor c cout %% +c4+# cin && c# cout %% +M a2ora son estos c4+ %% c %% + b4+ %% b %% + a4+ %% a %% endl# // <eamos una sentencia i:"else sencilla i: ','a 44 b(( cout %% +a 6 b no son iguales+ %% endl# else cout %% +a 6 b son iguales+ %% endl# // <eamos otra sentencia i:"else sencilla i: ''a 44 b( OO 'b 44 c(( cout %% +A 6 N son iguales o N 6 C son iguales+ %% endl# else cout %% +ni A 6 N son iguales ni N 6 C son iguales+ %% endl# // Nota. =e6 de Ae Eorgan // ,'A PP N( 44 ,A OO ,N // ,'A OO N( 44 ,A PP ,N return .# / + %% c
Das operadores lo"icos. 9ambien introducimos el operador :<7: ,ue simpli.ica las expresiones pero las /ace un poco ile"ibles. Captulo 5. Operadores
I7
/** * =ogicos2.cpp * Programa para probar operadores =ogicos 2 * * Pello Xabier Altadill Izura * * Compilado g!! =ogicos2.cpp "o =ogicos2 */ using namespace std# $include %iostream& int main '( ) // *acamos por salida standar un mensaje cout %% +<amos a probar los operadores-n+# unsigned int test 4 .# int a 4 2@1 b 4 2I1 c 4 @8# // <eamos el resto de Dalores cout %% +<alores %% + + %% b %% + + %% a %% endl# // 0omamos el Dalor a cout %% +Aame Dalores. -na4+# cin && a# // 0omamos el Dalor b cout %% +b4+# cin && b# // 0omamos el Dalor c cout %% +c4+# cin && c# cout %% +M a2ora son estos c4+ %% c %% + b4+ %% b %% + a4+ %% a %% endl# // <eamos una sentencia i:"else sencilla i: ',a( cout %% +A es :alse 'igual .(+ %% endl# else cout %% +A es true 'distinto de .(+ %% endl# // <eamos una sentencia i:"else sencilla i: ',b( cout %% +N es :alse 'igual .(+ %% endl# else cout %% +N es true 'distinto de .(+ %% endl# // <eamos una sentencia i:"else sencilla i: ',c( cout %% +C es :alse 'igual .(+ %% endl# else cout %% +C es true 'distinto de .(+ %% endl# // *entencia con operador logico o 0;>NA>IB '(Q c 4 'a 44 b(Q. I# cout %% +C es + %% c %% endl# return .# / + %% c
E.-else Entroduciendo esta simple estructura de control:

/** * I:;lse.cpp * Programa para probar I: ;lse anindados * ;n c!! no e3iste la estructura i:"elsi:"else * Pello Xabier Altadill Izura IF
* * Compilado */
g!! I:;lse.cpp "o I:;lse
using namespace std# $include %iostream& int main '( ) // *acamos por salida standar un mensaje cout %% +<amos a probar los operadores-n+# unsigned int test 4 .# int a 4 2@1 b 4 2I1 c 4 @8# // <eamos el resto de Dalores cout %% +<alores %% + + %% b %% + + %% a %% endl# // <eamos una sentencia i:"else sencilla i: 'a &4 b( cout %% +a ma6or o igual que b+ %% endl# else cout %% +a menor que b+ %% endl# // <eamos una sentencia i:"else compleja // nota si dentro de un i: o un else metemos mas de una sentencia1 2a6 que meter ==A< // 6 tambien conDiene meter las llaDes para 2acer un codigo menos con:uso i: 'a &4 b( ) cout %% +a ma6or o igual que b+ %% endl# i: 'a 44 2@( ) cout %% +a igual que 2@+ %% endl# cout %% +terminamos.+ %% endl# / / else ) cout %% +a menor que b+ %% endl# / return .# / + %% c
Captulo %. Para&etros' a&bito' sobrecar(a

El camnio de c(( es lar"o! pero se si"ue avan&ando. 5eamos las .unciones inline! un recurso interesante para me'orar el rendimiento.
/** * Inline.cpp * Programa para probar :unciones Inline * =as :unciones Inline no se compilan como :unciones aparte1 * lo que se 2ace al compilar es aPntilde#adir el contenido de la :uncion 2a6a* donde se se inDoca. Con lo que es muc2o mas rapido de ejecutar * 6 ademas nos da la limpieza de separar el codigo. * * Pello Xabier Altadill Izura * * Compilado g!! Inline.cpp "o Inline */ using namespace std# $include %iostream& // las :unciones en CPP las debemos declarar antes de inDocar // aqui tenemos el prototipo. *i no se pone tendremos ;>>B> de compilador IH
// Aeclaramos la :uncion como inline inline double Calcula 'double a1 double b(# // =og saca un mensaje por pantalla Doid =og'c2ar *mensaje(# // <ariables globales long Dariable 4 ???# c2ar *P>BR>AEA 4 +Rlobales& +# int main '( ) // *acamos por salida standar un mensaje =og'+<amos a probar los operadores+(# unsigned int test 4 .# double a 4 2@1 b 4 2I1 c 4 @8# // 0omamos el Dalor a =og'+Aame Dalores. -na4+(# cin && a# // 0omamos el Dalor b cout %% +b4+# cin && b# cout %% +M a2ora son estos + a4+ %% a %% + global + %% Dariable %% +M el // Probamos la :uncion =og'+<enga Da Damos+(# return .# / /** * Calcula * parametros double a1 double b * deDuelDe double * ;n la implementacion no 2ace :alta DolDer a poner IN=IN;*/ b4+ %% b %%
2.
double Calcula 'double a1 double b( ) a *4 @58?2# b *4@258? ! a# return 'a / b( * Dariable# / /** * =og * parametros c2ar *mensaje * deDuelDe Doid */ Doid =og 'c2ar *mensaje( ) cout %% P>BR>AEA %% mensaje %% endl# /
$aso de parametros 5amos a ver .ormas de pasar parametros.
/** * Parametros.cpp * Programa para probar los parametros de las :unciones 6 * la :orma de aplicar Dalores por de:ecto * * Pello Xabier Altadill Izura * * Compilado g!! Parametros.cpp "o Parametros */ using namespace std# $include %iostream& // las :unciones en CPP las debemos declarar antes de inDocar // aqui tenemos el prototipo. *i no se pone tendremos ;>>B> de compilador double Calcula 'double a1 double b(# // =og saca un mensaje por pantalla Doid =og'c2ar *mensaje 4 +*in Dalor pre:ijado+(# // suma suma dos Dalores int *uma'int a 4 .1 int b 4 .1 int c 4 .(# // <ariables globales long Dariable 4 ???# c2ar *P>BR>AEA 4 +Rlobales& +# int main '( ) // *acamos por salida standar un mensaje =og'+<amos a probar los operadores+(# // =lamada sin parametros =og'(# unsigned int test 4 .# int a 4 2@1 b 4 2I1 c 4 @81 d 4 .# // =lamanda sin parametros d 4 *uma'(# cout %% +M el resultado de la :uncion *uma sin parametros // =lamada con parametros 2I + %% d %% endl#
Captulo 6. Parametros am!ito so!recar"a Captulo 6. Parametros am!ito so!recar"a

d 4 *uma'a1b1c(# cout %% +M el resultado de la :uncion *uma + %% d %% endl#
// Probamos la :uncion =og'+<enga Da Damos+(# return .# / /** * Calcula * parametros double a1 double b * deDuelDe double */ double Calcula 'double a1 double b( ) return 'a / b( * Dariable# / /** * =og * parametros c2ar *mensaje * deDuelDe Doid * NB0A no 2ace :alta DolDer a poner el Dalor pre:ijado */ Doid =og 'c2ar *mensaje( ) cout %% P>BR>AEA %% mensaje %% endl# / /** * *uma * parametros int a1 int b1 int c * deDuelDe int */ int *uma 'int a 4 .1 int b 4 .1 int c 4 .( ) =og'+<amos a Der. ;stamos en suma. +(# // AeDolDemos un Dalor return 'a ! b ! c(# /
1obrecar"a de .unciones 8a sobrecar"a es otro concepto bFsico en la $CC. 0,ui se muestra un boton.
/** * *obrecarga.cpp * Programa para probar la sobrecarga de :unciones * =a sobrecarga es una misma :uncion con distintos parametros* Con la sobrecarga logramos el PB=IEB>9I*EB de clases 6 :unciones * * Pello Xabier Altadill Izura * * Compilado g!! *obrecarga.cpp "o *obrecarga */ 22
using namespace std# $include %iostream& // las :unciones en CPP las debemos declarar antes de inDocar // aqui tenemos el prototipo. *i no se pone tendremos ;>>B> de compilador double Calcula 'double a1 double b(# int Calcula 'int a1 int b(# :loat Calcula ':loat a1 :loat b(# // =og saca un mensaje por pantalla // ;sto proDocaria error de compilador por ambiguedad de sobrecarga //Doid =og'(# // =og saca un mensaje por pantalla // NB0A el Dalor por de:ecto solo se pone en la A;C=A>ACIBN Doid =og'c2ar *mensaje 4 +*in Dalor pre:ijado+(# // suma suma dos Dalores int *uma'int a 4 .1 int b 4 .1 int c 4 .(# // <ariables globales long Dariable 4 ???# c2ar *P>BR>AEA 4 +Rlobales& +# int main '( ) // *acamos por salida standar un mensaje =og'+<amos a probar los operadores+(# // =lamada sin parametros =og'(# unsigned int test 4 .# int a 4 2@1 b 4 2I1 c 4 @81 d 4 .# // =lamanda sin parametros d 4 *uma'(# cout %% +M el resultado de la :uncion *uma sin parametros + %% d %% endl#
// =lamada con parametros d 4 *uma'a1b1c(# cout %% +M el resultado de la :uncion *uma // Probamos la :uncion =og'+<enga Da Damos+(# return .# / /** * Calcula * parametros double a1 double b * deDuelDe double */ double Calcula 'double a1 double b( ) return 'a / b( * Dariable# / /** * Calcula * parametros + %% d %% endl#
:loat a1 :loat b 2@
Captulo 6. Parametros am!ito so!recar"a Captulo 6. Parametros am!ito so!recar"a

* deDuelDe :loat */ :loat Calcula ':loat a1 :loat b( ) return 'a / b( * Dariable# / /** * Calcula * parametros long a1 long b * deDuelDe long */ long Calcula 'long a1 long b( ) return 'a / b( * Dariable# / /** * =og * parametros c2ar *mensaje * deDuelDe Doid */ Doid =og 'c2ar *mensaje( ) cout %% P>BR>AEA %% mensaje %% endl# / /** * *uma * parametros int a1 int b1 int c * deDuelDe int */ int *uma 'int a 4 .1 int b 4 .1 int c 4 .( ) =og'+<amos a Der. ;stamos en suma. +(# // AeDolDemos un Dalor return 'a ! b ! c(# /
El ambito Hasta donde se identi.ica una variable7 $ara saltarnos todas las vallas podemos usar variables "lobales. )o conviene abusar de este tipo de variables.
/** * Rlobales.cpp * Programa para probar Dariables 6 su scope * * Pello Xabier Altadill Izura * * Compilado g!! Rlobales.cpp "o Rlobales */ using namespace std# $include %iostream&
28
// las :unciones en CPP las debemos declarar antes de inDocar // aqui tenemos el prototipo. *i no se pone tendremos ;>>B> de compilador double Calcula 'double a1 double b(# // =og saca un mensaje por pantalla Doid =og'c2ar *mensaje(# // <ariables globales long Dariable 4 ???# c2ar *P>BR>AEA 4 +Rlobales& +# int main '( ) // *acamos por salida standar un mensaje =og'+<amos a probar los operadores+(# unsigned int test 4 .# double a 4 2@1 b 4 2I1 c 4 @8# // 0omamos el Dalor a =og'+Aame Dalores. -na4+(# cin && a# // 0omamos el Dalor b cout %% +b4+# cin && b# cout %% +M a2ora son estos + a4+ %% a %% + global + %% Dariable %%% +M el // Probamos la :uncion =og'+<enga Da Damos+(# return .# / /** * Calcula * parametros double a1 double b * deDuelDe double */ double Calcula 'double a1 double b( ) return 'a / b( * Dariable# / /** * =og * parametros c2ar *mensaje * deDuelDe Doid */ Doid =og 'c2ar *mensaje( ) cout %% P>BR>AEA %% mensaje %% endl# / b4+ %% b %%
Captulo ). Clases
9u primera clase c(( )o /a+ ,ue perder de vista el /ec/o de ,ue c(( es un len"ua'e orientado a ob'etos. 1in animos de volver a explicar ,ue es la $CC! los bene.icios ,ue constitu+e vamos a limitarnos a resumir. *na clase c(( es la representacion de un ob'eto. *n ob'eto es una entidad .ormada por sus atributos + sus metodos. %on el a.an de /acer las cosas ordenadamente! siempre se separa la de.inicion de la clase en un .ic/ero de cabedeceras :extension ./pp! similar al ./ de len"ua'e c< + la implementacion se especi.ica en un .ic/ero cpp. Generalmente las clases c(( tienen el mismo aspecto: se de.inen unos atributos + unos metodos.
25
Captulo 6. Parametros am!ito so!recar"a Entre los metodos se pueden incluir metodos constructores + la destructora. 0demas de eso se puede de.inir si los atributos + clases son publicas! prote"idas + privadas! dependiendo del nivel de encapsulacion ,ue le ,ueramos dar a la clase. 5eamos la representacion del ob'eto coc/e en una clase c((:
/** * Coc2e.2pp * Clase cabecera que de:ine el objeto Coc2e * * Pello Xabier Altadill Izura * * No se compila. */ using namespace std# $include %iostream& class Coc2e ) public Coc2e'(# Coc2e'c2ar *m1int cil1int cab(# SCoc2e'(# Doid arranca'(# Doid detiene'(# Doid acelera'(# priDate c2ar *marca# int cilindrada# int caballos# /#
@ este seria el .ic/ero de implementacion :se puede tener todo en un unico .ic/ero<
/** * Coc2e.cpp * 9ic2ero que implementa la cabecera de la clase Coc2e. * NB HAC; NAAA CBNC>;0B solo es una muestra * * Pello Xabier Altadill Izura*
2?
* Compilar usando
g!! "c Coc2e.cpp*/
// Ha6 que incluir el :ic2ero de cabecera $include +Coc2e.2pp+ // Implementacion de constructor Coc2e Coc2e'( ) cout %% +Coc2e creado.+ %% endl# / // Implementacion de constructor 'con *BN>;CA>RA( Coc2e Coc2e 'c2ar *m1int cil1int cab( )/ // Implementacion de destructor. Ttil para liberar memoria. Coc2e SCoc2e'( ) cout %% +Coc2e destruido.+ %% endl# / // implementaciones de metodos... Doid Coc2e )/ Doid Coc2e Coc2e arranca'(
detiene'( )/ Doid
acelera'( )/
/** * Podemos usar una clase main para 2acer testeos con la clase * NB0A IEPB>0AN0; * Atencion al usar esta clase en otra que 6a tiene :uncion* main1 no se puede tener otra main. */ //int main '( ) //cout %% +=o 2ise,,-n+ %% endl# //return I# ///
$odemos usar clases dentro de otras clases7 si claro. 5eamos la de.inicion de un Gara'e.
/** * Raraje.2pp * Cabecera del objeto Raraje * * ;n este caso inDocamos otro objeto * * Pello Xabier Altadill Izura * * =a cabecera como tal no se compila */ using namespace std# $include %iostream& $include +Coc2e.2pp+ /* 27
Coc2e
Captulo #. Clases
* Ae:inicion de clase Raraje
Captulo #. Clases
*/ class Raraje ) priDate ma3Coc2es# public Raraje'(# Raraje'int ma3Coc2es(# SRaraje'(# int entra'Coc2e coc2e(# int sale'Coc2e coc2e(# bool esta=leno'(# /# int
@ esta seria la implementacion:

/** * Raraje.cpp * Implementacion de Clase Raraje * * Pello Xabier Altadill Izura * Atencion necesitamos el arc2iDo objeto de la clase Coc2e,,, * Compilar con g!! "c Coc2e.cpp * g!! "Uall Raraje.cpp Coc2e.o "o Raraje*/ $include +Raraje.2pp+ /* * Implementacion de clase Raraje */ /** * Constructor por de:ecto */ Raraje Raraje'() cout %% +Raraje.+ %% endl# ma3Coc2es 4 @# / /** * Constructor parametrizado */ Raraje Raraje'int m3( ) ma3Coc2es 4 m3# /
2F
/** * Aestructor */ Raraje SRaraje'()/ /** * entra un coc2e entra en el garaje */ int Raraje entra'Coc2e coc2e( ) cout %% + ;ntra un coc2e.+ %% endl# return .# / /** * sale un objeto coc2e sale del garaje */ int Raraje sale'Coc2e coc2e( ) cout %% + *ale un coc2e.+ %% endl# return .# / /** * esta=lenoQ */ bool Raraje deDuelDe booleano con la respuesta
esta=leno'(
) return :alse# / /** * 6 aqui la :uncion main para 2acer nuestras pruebillas */ int main '( ) cout %% + Creamos un garaje. + %% endl# Raraje garaje 4 Raraje'(# // Creamos un par de Coc2es Coc2e coc2eAzul 4 Coc2e'(# Coc2e coc2e>ojo 4 Coc2e'(# // Eetemos 6 sacamos los coc2es garaje.entra'coc2eAzul(# garaje.entra'coc2e>ojo(# garaje.sale'coc2e>ojo(# /
#unciones o metodos 1etterBGetter $or mania o por costumbre o por,ue asi lo establecen los puristas mas talibanes de la $CC casi nunca se de'a acceder directamente a los atributos de una clase :se de.inen como private< + para acceder a ellos se implementan .unciones setB"et. 8as /erramientas de desarrollo suelen incluir la opcion de "enerar ese codi"o de .orma automati&ada.
2H
Captulo #. Clases Captulo #. Clases
#i"ura: nunca tomes a broma a un desarrollador CC 1in la menor intencion de alimentar la +a tradicional @i/ad entre desarrolladores! mostremos un e'emplo + di"amos de paso ,ue no esta demas de.inir estas .unciones como inline2 cumplimos como pro.esionales pero no perdemos e.icacia. El ob'eto $ERRC
/** * Perro.2pp * Cabecera de la clase Perro con sus :unciones get/set para el atributo edad * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class Perro ) public Perro 'int initialAge(# SPerro'(# int RetAge'( ) return itsAge#/ // inlineQ Doid *etAge 'int age( ) itsAge 4 age#/ // inlineQ Doid =adra'( ) cout %% +Ruau Ruau arrr...-n+#/ // inlineQ priDate itsAge# /# int
@ su implementacion
/** * Perro.cpp * Clase que implementa la clase Perro* @.
* Pello Xabier Altadill Izura * * Compilado g!! Perro.cpp "o Perro*/ $include +Perro.2pp+ Perro Perro'int initialAge( //constructor ) itsAge 4 initialAge# / Perro SPerro'( //destructor ) cout %% + objeto destruido.+ %% endl# / /** * =a :uncion principal1 crea un perro 6 le 2ace ladrar */ int main'( ) bool test 4 :alse# Perro Canelo'5(# Canelo.=adra'(# cout %% +Canelo es un perro cu6a edad es + # cout %% Canelo.RetAge'( %% + aPntilde#os-n+# Canelo.=adra'(# Canelo.*etAge'7(# cout %% +A2ora Canelo es + # cout %% Canelo.RetAge'( %% + aPntilde#os-n+# return .# /
Captulo *. Iteraciones
Eteracion con eti,uetas Es la manera primi"enia de implementar iteraciones pero lo cierto es ,ue el uso de eti,uetas no se recomienda +a ,ue es di.icil de entender + mantener un pro"rama con eti,uetas. 0 ser posible /a+ ,ue evitarlas.
/** * =oop.cpp * * Programa que muestra como usar iteraciones * Pello Xabier Altadill Izura * Compilar g!! =oop.cpp "o =oop */ using namespace std# $include %iostream& // Programa principal int main '( ) cout %% + Hola1 Damos a mostrar un loop + %% endl# @I
Captulo #. Clases
//Inicializamos Dariables int i 4 .# int ma3 4 .# // =e pedimos al usuario que meta el total de iteraciones cout %% + Cuantas Dueltas damosQ +# cin && ma3# // <amos a implementar una iteracion con etiquetas // en general no es recomendable usar etiquetas bucle i!!# cout %% +Contador + %% i %% endl# // si no superamos el tamaPntilde#o ma3imo1 DolDemos a la etiqueta i: 'i % ma3( goto bucle# // :in de programa return .# /
4ucles 4ueno! a/ora en .orma de clase vamos a ver una serie de iteraciones. )o tienen nin"un misterio se implementan como en c! p/p! perl! 'ava! ...
/** * Nucles.2pp * * Clase que muestra distintos tipos de iteraciones * Pello Xabier Altadill Izura */ using namespace std# $include %iostream& class Nucles ) priDate int ma3#
@2
public // Constructor Nucles'(# // Aestructor SNucles'(# // Contructor parametrizado Nucles'int ma3imo(# // Nucle tipo V2ile Doid bucleU2ile'int ma3imo(# // Nucle tipo :or Doid bucle9or'int ma3imo(# // Nucle tipo do V2ile Doid bucleAoU2ile'int ma3imo(# /#
@ a,ui la implementacion
/** * Nucles.cpp * * Clase que muestra distintos tipos de iteraciones * Pello Xabier Altadill Izura * Compilar g!! Nucles.cpp "o Nucles*/ $include +Nucles.2pp+ // Constructor Nucles Nucles'()/ // Aestructor Nucles SNucles'()/ // Contructor parametrizado Nucles Nucles'int ma3imo()/ // Nucle tipo V2ile Doid Nucles bucleU2ile'int ma3imo() int temp 4 .# cout %% + iniciamos el bucle UHI=; temp %% + 6 ma3 + %% ma3imo %% endl# + %%
V2ile 'temp % ma3imo( ) cout %% temp %% + es menor que + %% ma3imo %% endl# temp!!# / / // Nucle tipo :or Doid Nucles bucle9or'int ma3imo()
Captulo $. Iteraciones
int temp 4 .# cout %% + iniciamos el bucle 9B> + %% @@
temp %% + 6 ma3 + %% ma3imo %% endl# :or 'temp4.# temp %
ma3imo# temp!!( ) cout %% temp %% + es menor que + %% ma3imo %% endl# / / // Nucle tipo do V2ile Doid Nucles bucleAoU2ile 'int ma3imo() int temp 4 .# cout %% + iniciamos e bucle temp %% + 6 ma3 + %% ma3imo %% endl# do ) cout %% temp %% + es menor que + %% ma3imo %% endl# temp!!# / V2ile 'temp % ma3imo(# / int main '( ) // Creamos dos instancias de la clase Nucles Nucles ciclador 4 Nucles'(# Nucles cicladorparam 4 Nucles'@8(# // InDocamos los metodos ciclador.buc leU2ile'2@(# cicladorpara m.bucle9or'I .(# ciclador.buc leAoU2ile'5( # return .# / + %%
1>itc/Bcase $or supuesto tenemos el clasico s>itc/-case en c(( En este e'emplo creamos una clase para mostrar el .uncionamiento de un menu de seleccion.
/** * Eenu.2pp * * Clase que especi:ica un menu de seleccion de opciones * que implementaremos con un case * Pello Xabier Altadill Izura */ us in @8
g na me sp ac e st d# $i nc lu de %i os tr ea m& cl as s Ee nu ) pr iD at e int resultado# public // Constructor Eenu'(# // Aestructor SEenu'(# // Eenu tipo case int menu'(# /#
@ su implementacion
/** * Eenu.cpp * * Clase que implementa Eenu.2pp * Pello Xabier Altadill Izura @5
* Compilar g!! Eenu.cpp "o Eenu*/ $include +Eenu.2pp+ // Constructor Eenu Eenu'()/ // Aestructor Eenu SEenu'()/ // Eenu tipo case int Eenu menu'( ) int temp 4 .# // Iniciamos un bucle que no para 2asta que se seleccione // algo distinto de .. do ) cout %% + E;NT *eleccion.+ %% endl# cout %% + I. ;nsalada+ %% endl# cout %% + 2. Cordero + %% endl# cout %% + @. Eerluza + %% endl# cout %% + 8. Pato + %% endl# cout %% + ;lije algo +# cin && temp# // *egun lo elegido sacamos algo. sVitc2 'temp( ) case . cout %% + Nos Damos + %% endl# breaW# case I cout %% + ;stas a dietaQ + %% endl# breaW# case 2 cout %% + <a6a digestion... + %% endl# breaW#
case @ cout %% + Xue sano eres + %% endl# breaW# case 8 cout %% + <a6a :inolis esta 2ec2o + %% endl# breaW# de:ault cout %% + C2ico1 decidete.+ %% endl# temp 4 .# / // end sVitc 2 / V2ile ', @?
temp( # retur n temp# / int main '( ) // Aqui guardaremos el resultado int resultado 4 .# cout %% + <amos a sacar el menu.+ %% endl# // Creamos dos instancias de la clase Eenu Eenu menutero 4 Eenu'(# // InDocamos los metodos resultado 4 menutero.menu'(# cout %% + ;l resultado es return .# / + %% resultado %% endl#
@7
Captulo $. Iteraciones 8ar"o es el camino. 4ueno! aun ,ueda un /uevo por recorrer...
Captulo +. Punteros
8os punteros 0caso creiais ,ue en c(( no /abia punteros7 eso solo ocurre en Hava. 8os punteros no contienen datos! contienen direcciones de memoria. $ara cada tipo de dato /a+ ,ue de.inir un puntero.
/** * Puntero.cpp * * Clase que muestra las direcciones de Dariables * Pello Xabier Altadill Izura * Compilar g!! Puntero.cpp "o Puntero */ using namespace std# $i nc lu de %i os tr ea m& in t ma in '( ) // Creamos Darias Dariables int pruebaInt 4 HH1 prueba2Int# s2o rt pru eba *2o rt 4 @8# c2a @F
r car ac 4 YaY # int *pu nte ro 4 .# int *pu nte roN ueD o# // A2ora las mostramos por pantalla cout %% +<ariable pruebaInt + %% pruebaInt %% endl# cout %% +Aireccion pruebaInt + %% PpruebaInt %% endl %% endl# cout %% +<ariable prueba2Int + %% prueba2Int %% endl# cout %% +Aireccion prueba2Int + %% Pprueba2Int %% endl %% endl# cout %% +<ariable prueba*2ort + %% prueba*2ort %% endl# cout %% +Aireccion prueba*2ort + %% Pprueba*2ort %% endl %% endl# cout %% +<ariable carac carac + %%
carac %% endl# cout %% +Aireccion + %% Pcarac %% endl %% + endl# cout %% +<ariable puntero %% puntero %% endl# // A0;NCIBN1 si el puntero no tiene Dalor dara // *;RE;N0A0IBN 9AT=0 6 la CARA>;EB* de gordo //cout %% +<ariable puntero + %% *puntero %% endl# cout %% +Aireccion puntero endl %% endl# puntero 4 PpruebaInt# cout %% +<ariable puntero + %% puntero %% endl# cout %% +<ariable puntero + %% *puntero %% endl# cout %% +Aireccion puntero + %% Ppuntero %% endl %% endl# return .# / + %% Ppuntero %%
5eamos otro e'emplo...

/** @H
* Puntero2.cpp * * Clase que muestra mas usos de los punteros* Pello Xabier Altadill Izura
8.
* Compilar */
g!! Puntero2.cpp "o Puntero2
using namespace std# $include %iostream& // prototipo de :unciones que implementamos luego int deDuelDe'int *punteroInt1 int entero(# int main '( ) // Creamos Darias Dariables int pruebaInt 4 HH1 prueba2Int# s2ort prueba*2ort 4 @8# c2ar carac 4 YaY# int *puntero 4 .# int *punteroNueDo# // A2ora las mostramos por pantalla cout %% +<ariable pruebaInt + %% pruebaInt %% endl# cout %% +Aireccion pruebaInt PpruebaInt %% endl %% endl# + %% + +
cout %% +<ariable prueba2Int + %% prueba2Int %% endl# cout %% +Aireccion prueba2Int %% Pprueba2Int %% endl %% endl#
cout %% +<ariable prueba*2ort + %% prueba*2ort %% endl# cout %% +Aireccion prueba*2ort %% Pprueba*2ort %% endl %% endl# cout %% +<ariable carac + %% carac %% endl# cout %% +Aireccion carac + %%
Pcarac %% endl %% endl# cout %% +<ariable puntero
+ %% puntero %% endl#
// A0;NCIBN1 si el puntero no tiene Dalor dara // *;RE;N0A0IBN 9AT=0 6 la CARA>;EB* //cout %% +<ariable puntero + %% *puntero %% endl# cout %% +Aireccion puntero + %% Ppuntero %% endl %% endl# puntero 4 PpruebaInt# cout %% +<ariable puntero + %% puntero %% endl# cout %% +<ariable puntero + %% *puntero %% endl# cout %% +Aireccion puntero + %% Ppuntero %% endl %% endl# *puntero 4 @85# cout %% +<ariable puntero + %% puntero %% endl# cout %% +<ariable puntero + %% *puntero %% endl# cout %% +Aireccion puntero + %% Ppuntero %% endl %% endl# // A2ora las mostramos por pantalla cout %% +<ariable pruebaInt + %% pruebaInt %% endl# cout %% +Aireccion pruebaInt PpruebaInt %% endl %% endl# *punteroNueDo 4 deDuelDe'puntero1@8(# cout %% + 0ras llamada cout %% +<ariable puntero + %% endl# cout %% +<ariable puntero + %% punteroNueDo %% endl# + %% + %%
+ %% *punteroNueDo %% endl# cout %% +Aireccion puntero
PpunteroNueDo %% endl %% endl# return .# / int deDuelDe 'int *punteroInt1 int entero( )
Captulo %. Punteros
cout %% +<ariable param. puntero + %% punteroInt %% endl# cout %% +<ariable param. puntero + %% *punteroInt %% endl# cout %% +Aireccion param. puntero + %% PpunteroInt %% endl %% endl# return '*punteroInt( ! entero# /
ne> + delete %on las instrucciones ne> + delete podemos reservar + liberar espacio libre de memoria. 1e utili&an con los punteros :ademas de los ob'etos< + es mu+ necesario liberar siempre la memoria con la
8I
Captulo %. Punteros instruccion delete para evitar memor+ leaIs: espacio de memoria marcados como oIupados pero ,ue +a no se usan por,ue el puntero ,ue les correspondia a/ora apunta a otro lado.
/** * Puntero.cpp * * Clase que muestra la oWupacion/liberacion de memoriacon neV 6 delete * Pello Xabier Altadill Izura * Compilar g!! Puntero.cpp "o Puntero */ using namespace std# $include %iostream& int main '( ) // Creamos Darias Dariables int *pruebaInt 4 neV int# s2ort *prueba*2ort 4 neV s2ort# pruebaInt 4 777# prueba*2ort 4 2@# // A2ora las mostramos por pantalla cout %% +<ariable pruebaInt + %% pruebaInt %% endl# cout %% +Aireccion pruebaInt + %% PpruebaInt %% endl %% endl# cout %% +<ariable prueba*2ort + %% prueba*2ort %% endl# cout %% +Aireccion prueba*2ort + %% Pprueba*2ort %% endl %% endl# // =iberamos la memoria delete pruebaInt# delete prueba*2ort# // Contra la especulacion del sistema 'operatiDo( // DolDemos a oCupar un espacio de memoria int *pruebaInt 4 neV int# s2ort *prueba*2ort 4 neV s2ort# pruebaInt 4 ???# prueba*2ort 4 2I# // quiza tengamos un error1 pero se puede comprobar OO prueba*2ort 44 NT== ( ) i: ' pruebaInt 44 NT==
cout %% +;rror al reserDar memoria+ %% endl# return .# / // A2ora las mostramos por pantalla cout %% +<ariable pruebaInt + %% pruebaInt %% endl# cout %% +Aireccion pruebaInt + %% PpruebaInt %% endl %% endl# cout %% +<ariable prueba*2ort + %% prueba*2ort %% endl# cout %% +Aireccion prueba*2ort + %% Pprueba*2ort %% endl %% endl# return .# /
Cb'etos + punteros 1e pueden crear punteros a ob'etos + atributos ,ue son punteros. 5eamos este e'emplo de una clase llamada Cb'eto:
/** * Bbjeto.2pp * * Clase que muestra distintos tipos de punteros * que se usan con los objetos * * Pello Xabier Altadill Izura */ using namespace std# $include %iostream& // Inicio de la clase class Bbjeto ) priDate int *priDado# public int atributo# 82
// Constructor Bbjeto'(# // Constructor Bbjeto'int atributo(# // Aestructor SBbjeto'(# // Eenu tipo case int deDuelDeAlgo'(# /#
@ su implementacion:
/** * Bbjeto.cpp * * Clase que muestra distintos tipos de punteros * que se usan con los objetos* Pello Xabier Altadill Izura * Compilar g!! Bbjeto.cpp "o Bbjeto*/ $include +Bbjeto.2pp+ // Constructor Bbjeto Bbjeto'() atributo 4 ???# /
Captulo %. Punteros
// Constructor Bbjeto Bbjeto'int atributo() t2is"&atributo 4 atributo# / // Aestructor Bbjeto SBbjeto'()/ // Eenu tipo case int Bbjeto deDuelDeAlgo'() int temp 4
.# return temp# / int main '( ) // Aqui guardaremos el resultado int resultado 4 .# cout %% + <amos a jugar con los objetos.+ %% endl# // Creamos la instancia del objeto puntero Bbjeto objeto 4 Bbjeto'(# //Creamos un puntero a ese objeto1 // pero cuidado1 no asignarle un constructor directamente Bbjeto *objetopuntero# // esto si... objetopuntero 4 Pobjeto# 8@
Captulo %. Punteros
// InDocamos los metodos resultado 4 objeto.deDuelDeAlgo'(#
// BbserDese la di:erencia al acceder al atributo publico cout %% + ;l Dalor de atributo con Bbjeto es + %% objeto.atributo %% endl# cout %% + ;l Dalor de atributo con Bbjeto es / + %% objetopuntero"&atributo %% endl# return .#
88
Captulo 1,. -e"erencias

8as re.erencias *na re.erencia es otra .orma de acceder a un dato! una especie de alias. %ual,uier operacion sobre una re.erencia a.ectara a ese dato al ,ue /ace re.erencia.
#i"ura: sin duda los punteros + las re.erencias .ueron obra de los sarracenos. 5eamos un e'emplo simple:
/** * >e:erencias.cpp * Programa que muestra el uso de re:erencias * * Pello Xabier Altadill Izura * * Compilado g!! >e:erencias.cpp "o >e:erencias */ using namespace std# $include %iostream& int main'( ) // Ae:inimos un dato 6 su re:erencia int numero# int Pre:erenciaNumero 4 numero# // A2i se crea la re:erencia cout %% +<amos a Der que pasa si le asignamos un dato + %% endl#
85
Captulo 1&. 'e(erencias

numero 4 @I@@7# // =os dos mostraran el mismo Dalor cout %% +<alor de numero %% numero %% endl# cout %% +<alor de re:erenciaNumero + %% re:erenciaNumero %% endl# +
// 6 a donde apuntanQ A= EI*EB *I0IB cout %% +Posicion de numero + %% Pnumero %% endl# cout %% +Posicion de re:erenciaNumero + %% Pre:erenciaNumero %% endl# cout %% +Programa terminado -n+ %% endl# return .# /
%on los ob'etos se pueden /acer re.erencias i"ualmente:

Bbjeto miBbjeto# Bbjeto Pre:Bbjeto 4 miBbjeto#
Re.erencias + .unciones 5amos a ver distintas .ormas de pasar re.erencias a una .uncion. %omo en c! podemos pasar parametros por re.erencia + /acer ,ue esos parametros conten"an resultados de una .uncion.
/** * >e:erencia9unciones.cpp * Programa que muestra el uso de re:erencias en las :unciones * * Pello Xabier Altadill Izura * * Compilado g!! >e:erencia9unciones.cpp "o >e:erencia9unciones */ using namespace std# $include %iostream& // IZo :uncion que intercambia dos Dalores Doid e3c2ange 'int *re:a1 int *re:b(# // 2Zo :uncion "sobrecargada" que intercambia dos Dalores Doid e3c2ange 'int Pre:a1 int Pre:b(# int main'( ) // Ae:inimos un dato 6 su re:erencia int a1 b# cout %% +Asignamos Dalores endl# a 4 85# b 4 2I# + %%
cout %% +<alores a4+ %% a %% + b4+ %% b %% endl# cout %% +Hacemos intercambio con e3c2ange'int *re:a1 int *re:b(
+ %%
endl# e3c2ange'Pa1 Pb(# // Con esta llamada inDocamos la primera :uncion,, cout %% +<alores a4+ %% a %% + b4+ %% b %% endl# cout %% +Hacemos + %% endl# 3c2ange'a1
intercambio con e3c2ange'int Pre:a1 int Pre:b(
b(# // Con esta llamada inDocamos la segunda :uncion,, out %% +<alores 8? a4+ %% a %% + b4+ %% b %% endl#

out %% +Programa terminado -n+ %% endl# return .# / // IZo :uncion que intercambia dos Dalores Doid e3c2ange 'int *re:a1 int *re:b( ) int tmp# tmp 4 *re:a# *re:a 4 *re:b# *re:a 4 tmp# / // 2Zo :uncion "sobrecargada" que intercambia dos Dalores Doid e3c2ange 'int Pre:a1 int Pre:b( ) int tmp# tmp 4 re:a# re:a 4 re:b# re:a 4 tmp# /
$asando clases por re.erencia

/** * Rremlin.2pp * * Clase que representa el objeto Rremlin. * BbserDese el @Zo metodo constructor * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class Rremlin ) public Rremlin'(# Rremlin'c2ar *nmb1int ed1 int p(# Rremlin'RremlinP(# // atencion a este constructor SRremlin'(# Doid correr'(# Doid dormir'(# Doid morder'(# int peso# priDate c2ar *nombre# int edad# /#
/** * Rremlin.cpp * * Clase que implementa el objeto Rremlin. * Pello Xabier Altadill Izura * */ 87

$include +Rremlin.2pp+ Rremlin endl# / Rremlin / Rremlin / SRremlin'( ) cout %% +Aaaarg2,-nRremlin destruido.+ %% endl# Rremlin 'c2ar *nmb1int ed1 int p( ) Rremlin'( ) peso 4 I# cout %% +Rremlin creado.+ %%
nombre 4 nmb# edad 4 ed# peso 4 p#
// ;l gremlin corre Doid correr'( ) cout %% +[aja grrrr,, jajaja,+ %% endl# / // ;l gremlin duerme Doid dormir'( ) cout %% +zzz\\\\zzzzz+ %% endl# / // ;l gremlin muerde Doid morder'( ) cout %% +roaar Pntilde#am Pntilde#am+ %% endl# / // Ae:inimos esta :uncion aparte de la clase // Con ella el gremlin come 6 aumenta su atributo peso. Doid comer 'Rremlin *g( ) // InDocamos la mordedura para que coma g"&morder'(# // =e aumentamos @ unidades por comer g"&peso !4 @# / // 9uncion main int main '( ) cout %% +Iniciando programa. + %% endl# // Ae:inimos un gremlin Rremlin tbautista# // 6 lo moDemos por la ciudad tbautista.correr'(# tbautista.morder'(# // Eostramos su peso cout %% +;l gremlin pesa tbautista.peso %% endl# // =e 2acemos comer 8F comer'Ptbautista(# + %%

// Eostramos su peso otra Dez cout %% +;l gremlin pesa a2ora + %% tbautista.peso %% endl# cout %% +9inalizando programa-n + %% endl# return .# /
8a venta'a ,ue lo"ramos al pasar parametros por re.erencia es ,ue a/orramos espacio en memoria +a ,ue sino en cada llamada a una .uncion se /acen copias de los parametros. Esto tambien tiene una desventa'a: si le pasamos a una .uncion el CREGE)08 de un ob'eto :con una re.erencia< en lu"ar de una copia corremos el ries"o de ,ue la .unciona /a"a tri&as nuestro ob'eto + perder el Jori"inalJ :supon"amos ,ue la .uncion esta /ec/a por terceros + no sabemos lo ,ue /ace<. 6ue se puede /acer para salva"uardar nuestros ob'etos7 $unteros constantes Esta es la solucion: pasar punteros constantes. Eso /ara ,ue la .uncion solo ten"a permiso para invocar los metodos constantes de la clase. 1E cambia un poco la clase "remlin para mostrar esto.
/** * Rremlin2.2pp * * Clase que representa el objeto Rremlin. * Con un metodo de:inido como const,, * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class Rremlin ) public Rremlin'(# Rremlin'c2ar *nmb1int ed1 int p(# Rremlin'RremlinP(# // atencion a este constructor SRremlin'(# Doid correr'(# Doid dormir'(# Doid morder'(# // Ae:inimos una :uncion constante c2ar * getNombre'( const# int peso# priDate *nombre# int edad# /# c2ar
@ vemos la implementacion en la ,ue simplemente se puede observar como se prote"e el ob'eto en la .uncion comer:< "racias al uso de punteros constantes.
/** * Rremlin2.cpp * * Clase que implementa el objeto Rremlin. * Pello Xabier Altadill Izura * */ 8H

$include +Rremlin2.2pp+ Rremlin Rremlin'( ) peso 4 I# cout %%
+Rremlin creado.+ %% endl# / Rremlin Rremlin 'c2ar *nmb1int ed1 int p( )
nombre 4 nmb# edad 4 ed# peso 4 p# / Rremlin SRremlin'( ) cout %% +Aaaarg2,-nRremlin
destruido.+ %% endl# / // ;l gremlin corre Doid correr'( ) cout %% +[aja grrrr,, jajaja,+ %% endl# / // ;l gremlin duerme Doid dormir'( ) cout %% +zzz\\\\zzzzz+ %% endl# / // ;l gremlin muerde Doid morder'( ) cout %% +roaar Pntilde#am Pntilde#am+ %% endl# / // 9TNCIBN CBN*0,,, // AeDuelDe el nombre del gremlin c2ar * getNombre'( const ) return nombre# / // Ae:inimos esta :uncion aparte de la clase // Con ella el gremlin come 6 aumenta su atributo peso. Doid comer 'const Rremlin const *g( ) // InDocamos la mordedura para que comaQQ // g"&morder'(# ;>>B> no podemos inDocar una :uncion NB CBN*0AN0;,,, // en cambio si podemos inDocar getNombre cout %% +Nombre+ %% g"&getNombre'( %% endl# / // 9uncion main int main '( ) cout %% +Iniciando programa. + %% endl# 5.

// Ae:inimos un gremlin Rremlin tbautista# // 6 lo moDemos por la ciudad tbautista.correr'(# tbautista.morder'(# // Eostramos su peso cout %% +;l gremlin pesa tbautista.peso %% endl# + %%
// =e 2acemos comer comer'Ptbautista(# // Eostramos su peso otra Dez cout %% +;l gremlin pesa a2ora + %% tbautista.peso %% endl# cout %% +9inalizando programa-n + %% endl# return .# /
5I
Captulo 11. Funciones a.anzadas

1obrecar"a + valores por de.ecto En un clase se pueden sobrecar"ar los metodos + los constructores! e incluso se pueden asi"nar valores por de.ecto a los parametros :como en p/p<. 5eamos el e'emplo del coc/e un poco mas desarrollado.
/** * Coc2e.2pp * Clase que representa un coc2e * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class Coc2e ) priDate c2ar *marca# int cilindrada# int caballos# enum marc2a ) Primera1 *egunda1 0ercera1 Cuarta1 Xuinta1 PtoLEuerto/# public Coc2e'(# Coc2e'int cilindrada1int caballos(# Coc2e'c2ar *marca1int cilindrada1int caballos(# SCoc2e'(# Doid arranca'(# Doid aDanza'int metros 4 5(# // Con Dalor por de:ecto Doid cambiaEarc2a'marc2a mar(# Doid cambiaEarc2a'(# Doid detiene'(# Doid acelera'(# c2ar * getEarca '(# int getCilindrada '(# int getCaballos '(# /#
@ esta su implementacion observense las .unciones sobrecar"adas + los posibles errores ,ue se pueden cometer.
/** * Coc2e.cpp * 9ic2ero que implementa la clase coc2e * * Pello Xabier Altadill Izura * */
$include +Coc2e.2pp+#
// Constructor por de:ecto Coc2e Coc2e'( ) cout %% +Coc2e creado.+ %% endl#
// Constructor sobrecargado CBN <A=B>;* PB> A;9;C0B // si no se establece otra cosa se asignan esos Dalores 52
Captulo 11. Funciones avan)adas
Coc2e
Coc2e 'int cilindrada 4 I...1 int caballos 4 I..( )
t2is"&marca 4 +Cualquiera+# t2is"&cilindrada 4 cilindrada# t2is"&caballos 4 caballos# / // Constructor sobrecargado Coc2e Coc2e 'c2ar *marca1int cilindrada1int caballos( ) t2is"&marca 4 marca# t2is"&cilindrada 4 cilindrada# t2is" &caballos 4 caballos# / // Aestructor Coc2e SCoc2e'( ) cout %% +Coc2e destruido.+ %% endl# / Doid Coc2e Doid Coc2e Doid Coc2e arranca'( )/ detiene'( )/ acelera'( )/
// Eetodo para que el coc2e aDance. ;sta de:inico con un Dalor // por de:ecto '5( por tanto podria inDocarse *IN parametro alguno Doid Coc2e aDanza'int metros( ) cout %% t2is"&marca %% + 2a aDanzado + %% metros %% metros %% endl# / // Eetodo para que el coc2e cambie de marc2a Doid Coc2e cambiaEarc2a'( )/ // Eetodo "sobrecargado" para que el coc2e cambie de marc2a Doid Coc2e cambiaEarc2a'marc2a mar( )/ // Euestra la marca c2ar * Coc2e &marca# / // Euestra la cilindrada int Coc2e getCilindrada '( ) return t2is"&cilindrada# / // Euestra los caballos int Coc2e getCaballos '() return t2is"&caballos# / /** 5@ getEarca '( ) return t2is"
* NB0A IEPB>0AN0; * Atencion al usar esta clase en otra que 6a tiene :uncion* main1 no se puede tener otra main. */ int main '( ) int test 4 .# Coc2e De2iculo 4 Coc2e'+*Woda+1 I.5.1 25.(# cout %% +=o 2ice1 tengo un +%% De2iculo.getEarca'( %% endl#
De2iculo.arranca'(# De2iculo.cambiaEarc2a'(# De2iculo.aDanza'(# // A0;NCIBN,, esto seria una llamada ambigua1 6a que e3iste otro constructor // que se puede asignar sin parametros pq tiene Dalores por de:ecto que es esta // Coc2e Coc2e 'int cilindrada 4 I...1 int caballos 4 I..( 6 c2oca con el constructor // por de:ecto. Noludos, el compilador nos rompera el B>0B sin compasion //Coc2e segundoCoc2e 4 Coc2e'(# return .#
1e puede implementar el constructor de otra manera :sirve para tirarte el rollete "uru! aun,ue te se"uiran pa"ando i"ual de mal<! atencion a la sintaxis.
Coc2e'( marca'+*eat+(1 cilindrada'I2.( )
Coc2e
/#
%op+ constructor Este es un constructor ,ue se puede a-adir a nuestras clases + ,ue sirve para /acer una copia de un ob'eto de esa clase. Existe uno por de.ecto pero es recomendable preocuparse en implementarlo nosotros mismos +a ,ue pueden producirse errores con atributos ,ue son punteros. 5eamos el cop+ de la clase $erro.
/** * Perro.2pp * Clase de cabecera de Perro * * Pello Xabier Altadill Izura * */
using namespace std# $include
%iostream& class Perro ) public Perro 'int initialAge(# // constructor CBPM Perro 'const Perro P(# SPerro'(# // metodos MA implementados int RetAge'( ) return itsAge#/ // automaticamente inline, Doid *etAge 'int age( ) itsAge 4 age#/ // automaticamente inline, int * RetPeso'( ) return peso#/ // automaticamente inline, Doid *etPeso 'int * peso( ) t2is"&peso 4 peso#/ // automaticamente inline, 58
c2ar * Ret>aza'( ) return raza#/ // automaticamente inline, Doid *et>aza 'c2ar * raza( ) t2is"&raza 4 raza#/ // automaticamente inline, c2ar * RetColor'( ) return color#/ // automaticamente inline, Doid *etColor 'c2ar *color( ) t2is"&color 4 color#/ // automaticamente inline, Doid =adra'( ) cout %% +Ruau Ruau arrr...-n+#/ // automaticamente inline, priDate *color# /# int itsAge# int *peso# c2ar *raza# c2ar
@ su implementacion
/** * Perro.cpp * Clase que implementa la clase Perro con constructor cop6 * * Pello Xabier Altadill Izura* * Compilado g!! Perro.cpp "o Perro*/ $include +Perro.2pp+ //constructor Perro Perro'int initialAge( ) itsAge 4 initialAge# cout %% +Creado c2uc2o.+ %% endl# / //cop6"constructor. Atencion Perro Perro'const Perro P perroBrigen( ) itsAge 4 perroBrigen.itsAge# peso 4 neV int# raza 4 neV c2ar# color 4 neV c2ar# color 4 perroBrigen.color# raza 4 perroBrigen.raza# peso 4 perroBrigen.peso# cout %% +Creado c2uc2o con copia+ %% endl# / //destructor Perro SPerro'( ) cout %% + objeto destruido.+ %% endl# / /** * =a :uncion principal1 crea un perro 6 le 2ace ladrar */ int main'( ) int t 4 .# bool test 4 :alse# Perro Canelo'5(# Canelo.*et>aza'+Pastor Dasco+(# // Creamos a =aiWa 2aciendo una copia de canelo Perro =aiWa'Canelo(# cout %% +=aiWa es de raza + # cout %% =aiWa.Ret>aza'( %% endl# =aiWa.*et>aza'+*oDietica+(# Canelo.=adra'(# 55
cout %% +Canelo es un perro cu6a edad es Canelo.=adra'(# Canelo.*etAge'7(#
+ # cout %% Canelo.RetAge'( %% + aPntilde#os-n+#
cout %% +A2ora Canelo es + # cout %% Canelo.RetAge'( %% + aPntilde#os-n+# cout %% +=aiWa es de raza + # cout %% =aiWa.Ret>aza'( %% endl# return .#
1obrecar"ando operadores 9odo un clasico de c((. $odemos sobrecar"ar operadores matematicos para nuestras clases. 8a sintaxis seria al"o asi: retorno operator(( :parametros< retorno operator- :parametros< 5eamos un e'emplo con la clase %ontador en la ,ue sobrecar"amos operadores de pre.i'o.
/** * Contador.2pp * Clase que muestra la sobrecarga de operadores matematicos * * Pello Xabier Altadill Izura */
using namespace std# $include %iostream& class int Dalor# public
Contador ) priDate Contador'(#
Contador'int Dalor(# SContador'(# Contador'const Contador P(# int getContador '( const ) return Dalor#/ // inline Doid setContador 'int Dalor( ) t2is"&Dalor 4 Dalor#/ // inline Doid operator!! '(# // operador P>;9I[B !!contador Doid operator"" '(# // operador P>;9I[B ""contador Doid operator!!'int(# // operador *T9I[B 'post:i3( contador!! Doid operator""'int(# // operador *T9I[B 'post:i3( contador"Contador operator!'const Contador P(# // operador ! bool esCero'( ) return 'Dalor 44 .(#/ // inline
/#
@ su implementacion
/** * Contador.cpp * :ic2ero que implementa la clase contador * * Pello Xabier Altadill Izura*/
$include +Contador.2pp+
// Constructor
5?
Contador endl# /
Contador'( ) Dalor 4 .# cout %% +Contador creado,+ %%
// Constructor con Dalor Contador Contador'int Dalor( ) t2is"&Dalor 4 Dalor# cout %% +Contador creado con Dalor inicial / Contador / Contador / // *obrecarga de operador unario !! P>;9I[B !!operador Doid Contador +incrementando Dalor de contador !!Dalor# / // *obrecarga de operador unario "" P>;9I[B ""operador Doid Contador +decrementando Dalor de contador ""Dalor# / // *obrecarga de operador unario !! *T9I[B operador!! Doid Contador %% +incrementando Dalor de contador Dalor!!# / // *obrecarga de operador unario "" *T9I[B operador"Doid Contador 'int( ) cout %% +decrementando Dalor de contador Dalor""# / // operador ! Contador Contador operator"" + %% Dalor %% endl# operator!! 'int( ) cout + %% Dalor %% endl# operator"" '( ) cout %% + %% Dalor %% endl# operator!! '( ) cout %% Contador'const Contador P original( ) Dalor 4 original.Dalor# SContador'( ) cout %% +Contador destruido,+ %% endl# + %% Dalor %% endl#
+ %% Dalor %% endl#
operator!'const Contador P tmp( ) return
Contador'Dalor ! tmp.getContador'((# / int main '( ) int i# 57
// Ae:inimos un contador Contador contador# Contador EegaContador'I?F7(# Contador resultado# cout %% +<alor de contador %% contador.getContador'( %% endl# // ;stablecemos un Dalor inicial contador.setContador'I5(# cout %% +<alor de contador + %% contador.getContador'( %% endl# cout %% +<alor de megacontador + %% EegaContador.getContador'( %% endl# // 6 lo usamos como controlador de un V2ile V2ile ', contador.esCero'(( ) ""contador# / contador.setContador'I...(# cout %% +<alor actual de contador + %% contador.getContador'( %% endl# cout %% +<alor actual de megacontador + %% EegaContador.getContador'( %% endl# resultado 4 contador ! EegaContador# cout %% +<alor de resultado de la suma + %% resultado.getContador'( %% endl# return .# +
5F
Captulo 12. Arra/s

0rra+s 1e dice arra+s o arre"los7 en .in. En c(( podemos de.inir + usar los arra+s casi como en %. 0demas tenemos la venta'a de poder crear arra+s de ob'etos. 5eamos un pro"rama en c(( ,ue 'ue"a con los arra+s:
/** * Arra6;jemplo.cpp * Clase que inicializa 6 maneja algunos arra6s * * Pello Xabier Altadill Izura * * Compilado g!! Arra6;jemplo.cpp "o Arra6;jemplo */ using namespace std# $include %iostream& // 9uncion principal int main '( ) // Aeclaramos dos arra6s de enteros de I5 elementos J...I8K int arregloIJI5K1 arreglo2JI5K# int i# // Iniciamos todos los componentes con el Dalor . // a2orramos tiempo con una asignacion multiple :or ' i 4 . # i % I5 # i!! ( ) // recorremos de . a I8 arregloIJiK 4 arreglo2JiK 4 .# / // Aeclaramos mas arra6s 6 los iniciamos arra6=ongsJ5K 4 ) 771 @@1 I51 2@1 I.I /# long
// =o recorremos 6 Demos sus componentes por pantalla // Atencion,, esto nos recorreria mas de lo necesario //:or ' i 4 . # i % sizeo:'arra6=ongs( # i!! ( ) // para sacar el Dalor real int tamanoLreal 4 sizeo:'arra6=ongs(/sizeo:'arra6=ongsJ.K(# :or ' i 4 . # i % tamanoLreal # i!! ( ) cout %% +Dalor de componente + %% i %% + / // =o mismo1 pero nos es necesario poner el tamaPntilde#o si 6a lo especi:icamos // al iniciar el arra6 c2ar arra6C2arsJK 4 ) YAY1 YsY1 YiY1 YmY1 YoY1 YDY/# // nota un arra6 de c2ars 4 es un string c2ar nombreJK 4 +Isaac+# cout %% +Eostrando arra6 de caracteres.+ %% endl# tamanoLreal 4 sizeo:'arra6C2ars(/sizeo:'arra6C2arsJ.K(# :or ' i 4 . # i % tamanoLreal # i!! ( ) cout %% +Dalor de componente + %% i %% + + %% arra6C2arsJiK %% endl# + %% arra6=ongsJiK %% endl#
Captulo 12. *rra+s

5H
/ // ;numeraciones podemos combinarlas con arra6s enum Aias );ne1 9eb1 Ear1 Abr1 Ea61 [un1 [ul1 Ago1 *ep1 Bct1 NoD1 Aic1 =osEeses/# // A cada enumeracion le corresponde un numero1 si no se especi:ica1 // la numeracion ira incremental ;ne4.1 9eb4I1 Ear421..1=osEeses4I2 //Podemos declarar el siguiente arra61 donde =osEeses nos da la longitud I2 int dias=ibresJ=osEesesK 4 )21 81 ?1 21 51 81 I.1 I51 I.1 @1 81 I./# Aias tmpAia# :or 'i 4 .# i % =osEeses# i!!( ) tmpAia 4 Aias'i(# cout %% +Aias libres +%% tmpAia %% + 4+ %% dias=ibresJiK %% endl# / // 02e Eatri3,,, Damos a de:inir arra6s multidimensionales int t2eEatri3J5KJ@K 4 ) )@1?1F/1 )H1H1H/1 ).1I1./1 )?1?1?/1 )@1I1I//# // Para recorrerlo ponemos un :or doble int j# :or 'i 4 .# i%5 # i!!( ) :or 'j 4 .# j% @# j!!( ) cout %% + matri3J+ %% i %% +KJ+ %% j %%+K 4 + %% t2eEatri3JiKJjK %% endl# / / return .# /
0rra+s de ob'etos 5amos a ver un e'emplo de arra+s de ob'etos. 1e crea el ob'eto Robot + con el se .ormara un e'ercito de robots.
/** * >obot.2pp * Clase que de:ine el objeto >obot * * Pello Xabier Altadill Izura * */ class >obot ) priDate c2ar *nombre# public >obot'c2ar *nombre 4 +Nestor"5+( ) t2is"&nombre 4 nombre# / S>obot'(# >obot'const >obot P(#
Captulo 12. *rra+s

c2ar *getNombre'( const ) return nombre#/ Doid 2ablar'c2ar *te3to(# Doid eDolucionar'(# Doid matar'>obot Dictima(# /#
?.
Esta es la implementacion.
/** * >obot.cpp * 9ic2ero que implementa la clase >obot. <amos a crear un arra6 de robots * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& $include +>obot.2pp+ // Aestructor >obot S>obot'( )/ // Constructor copia >obot >obot'const >obot P robotBrigen( ) nombre 4 neV c2ar# nombre 4 robotBrigen.getNombre'(# cout %% +Copia creada, Nzzzz. Ee llamo / // 9uncion para que el robot 2able Doid >obot *te3to( ) cout %% nombre %% + dice / // 9uncion para que el robot eDoluciones Doid >obot eDolucionar'( 2ablar'c2ar +%% nombre %%endl#
+ %% te3to %% endl#
) 2ablar'+He sacado nueDas conclusiones. Aebeis morir. +(# / // ;l robot mata Doid >obot matar'>obot Dictima(
) 2ablar'+Euere,, mVa2a2a2a2aaa+(# / // 9uncion principal
Captulo 12. *rra+s

int main '( ) int tam 4 .1 i# // Creamos el primer robot >obot primer>obot 4 >obot'+Tnidad central+(# >obot primerNestor 4 >obot'(# // <amos a crear un ejercito de robots >obot ejercitoAelEalJ2.K# // M un arra6 de PTN0;>B* a robots >obot *robobsoletosJ2.K#
?I
// Ae:inimos un puntero a un robot >obot *rarito# tam 4 sizeo:'ejercitoAelEal(/sizeo:'ejercitoAelEalJ.K(# // Con un :or Damos 2aciendo copias :or ' i 4 .# i % tam# i!!( ) ejercitoAelEalJiK 4 >obot'primerNestor(# / // Tno de ellos Da a eDolucionar ejercitoAelEalJI2K.eDolucionar'(# primer>obot.2ablar'+Atencion,, un unidad de T*> 2a eDolucionado. *e trata de...+(# primer>obot.2ablar'ejercitoAelEalJI2K.getNombre'((# ejercitoAelEalJI2K.matar'primer>obot(# // Creamos el robot rarito rarito 4 neV >obot'+CalDin+(# rarito"&2ablar'+[eje1 todaDia e3isto 6o.+(# // Eetemos dos nueDos robots en el arra6 robobsoletosJ5K 4 rarito# rarito 4 neV >obot'+*2eldon+(# robobsoletosJ?K 4 rarito# // 2acemos una llamada desde el componente del arra6 de punteros robobsoletosJ?K"&matar'ejercitoAelEalJI2K(# return .# /
Captulo 13. Herencia

8a /erencia %omo bien se sabe la /erencia no se reparte: se descuarti&a. 4romas aparte! la /erencia constitu+e una de las /erramientas mas poderosas del culto CC. 1i una clase /ereda de la otra! lo ,ue /ereda son todos sus atributos + metodos. 0demas de /eredarlos puede sobreescribirlos! tanto los constructores-destructores como los metodos convencionales. 5eremos un e'emplo claro ,ue resume lo ,ue se puede /acer + los e.ectos de la /erencia $or un lado vemos la clase "enerica ve/iculo + su descendiente: el coc/e. 8a clase 5e/iculo
/** * <e2iculo.2pp * Clase que de:ine el objeto De2iculo * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& enum tipoLcombustible ) XT;>B*;NB1 CANNANI*1 RI>A*B=1 RA*BI=1 ARTA1 P=T0BNIB /# class <e2iculo ) protected int cilindrada# tipoLcombustible combustible# c2ar *marca# public <e2iculo'(# ?2
<e2iculo'c2ar *marca(# <e2iculo'int cilindrada1 tipoLcombustible combustible1 c2ar *marca(# S<e2iculo'(# <e2iculo'const <e2iculo P(# Doid arrancar'(# Doid moDer'int metros(# // metodo tipo Dirtual1 util cuando de:inamos PTN0;>B* M >;9;>;NCIA* a De2iculo Dirtual Doid cla3on'( const ) cout %% +%clase De2iculo& Eec"meeec,, XueQ meeec, Xue de queQ meec,+ %% endl# / c2ar *getEarca'( const )return t2is"&marca#/ tipoLcombustible getCombustible'( const )return t2is"&combustible#/ int getCilindrada'( const )return t2is"&cilindrada#/ /#
?@
Captulo 13. Herencia @ su implementacion...

/** * <e2iculo.cpp * 9ic2ero que implementa la clase De2iculo * * Pello Xabier Altadill Izura * * Compilacion g!! "c <e2iculo.cpp*/ $include +<e2iculo.2pp+ // Constructor <e2iculo <e2iculo'( ) cout %% +%clase De2iculo& <e2iculo creado+ %% endl# / // Constructor <e2iculo <e2iculo'c2ar *marca( ) t2is"&marca 4 marca# cout %% +%clase De2iculo& <e2iculo creado con parametro marca marca %% endl# / // Constructor con Dalores iniciados <e2iculo <e2iculo'int cilindrada1 tipoLcombustible combustible1 c2ar *marca( cilindrada'cilindrada(1 combustible'combustible(1 marca'marca( ) cout %% +%clase De2iculo& <e2iculo creado con Dalores + %% endl# cout %% +%clase De2iculo& cilindrada + %% cilindrada %% endl# cout %% +%clase De2iculo& combustible + %% combustible %% endl# cout %% +%clase De2iculo& marca + %% marca %% endl# / // Aestructor <e2iculo S<e2iculo'( ) cout %% +%clase De2iculo& <e2iculo destruido+ %% endl# / // Constructor copia de De2iculo <e2iculo <e2iculo'const <e2iculo P De2iculoBrigen( )/ // Arrancamos el De2iculo Doid <e2iculo arrancar'( ) cout %% +%clase + %%
De2iculo& arrancando De2iculo. Nrruum,,+ %% endl# /

// EoDemos el De2iculo unos metros Doid <e2iculo moDer'int metros( ) cout %% +%clase
De2iculo& moDiendo De2iculo + %% metros %% + metros+ %% endl# ?8
El coc/e! /erencia de 5e/iculo

/** * Coc2e.2pp * Clase que de:ine el objeto Coc2e1 2ijo de De2iculo1 sePntilde#or del capitalismo* * Pello Xabier Altadill Izura * */ $include +<e2iculo.2pp+ class Coc2e public <e2iculo ) protected caballos# c2ar *motor# public // Atencion constructor pasando parametros por de:ecto estilo guru // pero inDocando a su clase padre Coc2e'( <e2iculo'+Audi+( ) cout %% +%clase coc2e& Coc2e destruido inDocando al constructor De2iculo+ %% endl# / // Constructor que sobreescribe al de De2iculo, Coc2e'c2ar *marca(# // Constructor Coc2e'int cilindrada1 tipoLcombustible combustible1 c2ar *marca(# // Constructor Coc2e'int caballos1 c2ar *motor( ) t2is"&caballos 4 caballos# t2is"&motor 4 motor# cout %% +%clase coc2e& Coc2e construido con caballos 6 motor+ %% endl# / // Aestructor SCoc2e'(# // Constructor copia Coc2e'const Coc2e P(# // Eetodo sobreescrito Doid arrancar'(# // metodo que sobreescribe al Dirtual Doid cla3on'( const# // getter/setter int getCaballos'( const )return t2is" &caballos#/ // inline c2ar *getEotor'( const )return t2is" &motor#/ // inline /# int
@ su implementacion
/** ?5

* * * * * * * Coc2e.cpp 9ic2ero que implementa la clase Coc2e Pello Xabier Altadill Izura Compilacion g!! "c <e2iculo.cpp g!! Coc2e.cpp <e2iculo.o "o Coc2e*/
$include +Coc2e.2pp+ // Constructor de coc2e que sobreescribe Coc2e Coc2e'c2ar *marca( ) cout %% +%clase coc2e& Coc2e construido con marca endl# / // Constructor de coc2e Coc2e Coc2e'int cilindrada1 tipoLcombustible combustible1 c2ar *marca( ) cout %% +%clase coc2e& Coc2e construido con parametros+ %% endl# / // Aestructor de coc2e Coc2e SCoc2e'( ) cout %% +%clase coc2e& Coc2e destruido+ %% endl# / // Constructor copia de Coc2e Coc2e Coc2e'const Coc2e P coc2eBriginal( ) marca 4 neV c2ar# marca 4 coc2eBriginal.getEarca'(# cout %% +%clase coc2e& Copia de coc2e+ %% endl# / // metodo sobreescrito Doid Coc2e arrancar '( ) cout %% +%clase coc2e& NBBE, pam, pam, pret + %% marca %%
pret pret... pam, pret pret+ %% endl# /

// metodo que sobreescribe al Dirtual Doid Coc2e cla3on'( const ) cout %% +%clase coc2e&
EBBBBBC,, Eecagon tus muelas EBC"EBBBC,,+ %% endl# / // 9uncion principal int main '( ) // Creamos Darios coc2es. <eremos que al ser objetos 2eredados // se inDocaran los constructores1 copias1 6 destructores de la clase // padre <e2iculo Coc2e mibuga 4 Coc2e'(# Coc2e tucarro 4 Coc2e'mibuga(# ??
// probando constructor sobrescrito se inDocan los dos, Coc2e tequi 4 Coc2e'+Al:al:a >omero+(# // podemos inDocar los metodos del padre 6 usar sus atributos cout %% +=a marca de mi buga es + %% mibuga.getEarca'( %% endl# mibuga.arrancar'(# // InDocando metodo sobreescrito solo se inDoca el del coc2e. tucarro.arrancar'(# arrancar'(#
// M si queremos inDocar el metodo del padreQQ tequi.<e2iculo
// Creamos otro De2iculo con puntero a un CBCH; <e2iculo *De2iculo 4 neV Coc2e'+=anbor[ini+(# // ;sto inDocara el metodo de De2iculo1 el de la clase PAA>; De2iculo" &arrancar'(# De2iculo"&moDer'@(# // A2ora queremos inDocar el cla3on1 pero a cual de los metodos // se inDocara1 al del Coc2e o al de la clase De2iculoQ al 2aber // de:inido el metodo cla3on como Dirtual1 se inDocara el metodo correcto // que es el del coc2e 'De2iculo es un puntero a coc2e(. De2iculo"&cla3on'(# return .# /
C*9$*9 8a salida de la e'ecucion de %oc/e.cpp seria:

%clase De2iculo& <e2iculo creado con parametro marca Audi %clase coc2e& Coc2e destruido inDocando al constructor De2iculo %clase De2iculo& <e2iculo creado %clase coc2e& Copia de coc2e %clase De2iculo& <e2iculo creado %clase coc2e& Coc2e construido con marca Al:al:a >omero =a marca de mi buga es Audi %clase coc2e& NBBE, pam, pam, pret pret pret... pam, pret pret %clase coc2e& NBBE, pam, pam, pret pret pret... pam, pret pret %clase De2iculo& arrancando De2iculo. Nrruum,, %clase De2iculo& <e2iculo creado %clase coc2e& Coc2e construido con marca =anbor[ini %clase De2iculo& arrancando De2iculo. Nrruum,, %clase De2iculo& moDiendo De2iculo @ metros %clase coc2e& EBBBBBC,, Eecagon tus muelas EBC"EBBBC,,
?7
Captulo 14. Herencia &ultiple

8a /erencia multiple *na de las oportunidades ,ue nos o.rece el len"ua'e c(( es la posibilidad de ,ue un ob'eto ten"a la /erencia de mas de una clase2 esta venta'a .ue considerada por los desarrolladores de Hava como una pe"a + la ,uitaron! e incluso /a+ desarrolladores de c(( ,ue pre.ieren evitar este tipo de /erencia +a ,ue puede complicar muc/o la depuracion de pro"ramas $ara ilustrar un caso de /erencia multiple /emos de.inido la superclase Habitante2 de ella /eredan dos clases distintas: Humano :,ue /ablan< + 0nimal :,ue matan<. 0/ora ,ueremos de.inir un ente ,ue tiene propiedades de esas dos clases: Dilitar! +a ,ue el militar /abla + ademas mata. %omo podemos de.inirlo7 con una /erencia multiple. 5amos la de.inicion de la superclase o clase padre Habitante )otas de la lo"ia $CC %onviene de.inir todos los metodos de un clase como const siempre ,ue en el metodo no se modi.i,uen los atributos. 9u resistencia es inutil. unete a nosotros o muere. De.inir metodos como const le .acilitara el traba'o al compilador + al pro"ramador. )ota el codi"o necesita revision + testeo
/** * Habitante.2pp * Clase que de:ine el objeto 2abitante * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class Habitante ) priDate c2ar *nombre# int
edad# public Habitante'(# Dirtual SHabitante'(# Habitante'const Habitante P(# Dirtual Doid dormir'(# // setter/getter o accessors Dirtual c2ar *getNombre'( const ) return t2is"&nombre#/ // inline Dirtual Doid setNombre'c2ar *nombre( ) t2is"&nombre 4 nombre# / // inline Dirtual int get;dad'( const ) return t2is"&edad#/ // inline Dirtual Doid set;dad'int edad( ) t2is"&edad 4 edad# / // inline /#
@ su implementacion
/** * Habitante.cpp
?F
Captulo 14. Herencia multiple

* Programa que implementa la clase 2abitante * * Pello Xabier Altadill Izura * Compilacion g!! "c Habitante.cpp * */ $include +Habitante.2pp+ // Constructor Habitante Habitante'( ) cout %% +"clase 2abitante" Habitante construido.+%% endl# / // Aestructor Habitante SHabitante'( ) cout %% +"clase 2abitante" Habitante +%% t2is"&getNombre'( %% + destruido.+%% endl# / // constructor copia Habitante Habitante'const Habitante P original( ) nombre 4 neV c2ar# original.getNombre'(# / // metodo dormir Doid Habitante dormir'( ) cout %% +"
clase 2abitante" zzzzz\\\\zzzzz zzz+ %% endl# /
Humano 8a clase Humano! ,ue /ereda de Habitante

/** * Humano.2pp * Clase que de:ine el objeto 2umano * * Pello Xabier Altadill Izura * */ $include +Habitante.2pp+ // 2ereda atributos 6 metodos de la superclase Habitante class Humano public Humano'(# Dirtual SHumano'(# Humano'const Humano P(# Dirtual Doid ?H public Habitante ) priDate c2ar *idioma#
4. Herencia multiple
2ablar'c2ar *bla( const# // setter/getter o accessors Dirtual c2ar *getIdioma'( const ) return t2is" &idioma#/ // inline Dirtual Doid setIdioma'c2ar *idioma( ) t2is"&idioma 4 idioma# / // inline
/#
@ su implementacion
/** * Humano.cpp * 9ic2ero que implementa el objeto 2umano * * Pello Xabier Altadill Izura * */
$include +Habitante.2pp+
// Constructor Humano Humano'( ) cout %% +"clase Humano" Humano construido.+%% endl#
// Aestructor Humano SHumano'( ) cout %% +"clase Humano" Humano +%% t2is"&getNombre'( %% + destruido.+%% endl#
// constructor copia Humano Humano'const Humano P original( ) idioma 4 neV c2ar# idioma 4 original.getIdioma'(#
// metodo 2ablar Doid Humano 2ablar'c2ar *bla( const ) cout %% +"clase Humano"+ %% t2is" &getNombre'( %% + dice + %% bla %% endl#
0nimal 8a clase 0nimal! ,ue /ereda de Habitante
/** * Animal.2pp * Clase que de:ine el objeto Animal * * Pello Xabier Altadill Izura *

*/ $include +Habitante.2pp+ // 2ereda atributos 6 metodos de la superclase Habitante class Animal public Habitante ) priDate
int patas# public Animal'(# Dirtual SAnimal'(# Animal'const Animal P(# Dirtual Doid matar'( const# // setter/getter o accessors Dirtual int getPatas'( const ) return t2is"&patas#/ // inline Dirtual Doid setPatas'int patas( ) t2is"&patas 4 patas# / // inline /#
@ su implementacion
/** * Animal.cpp * Programa que implementa la clase Animal * * Pello Xabier Altadill Izura * Compilacion g!! "c Animal.cpp * */ $include +Animal.2pp+ // Constructor Animal Animal'( ) cout %% +"clase Animal" Animal construido.+%% endl# / // Aestructor Animal SAnimal'( ) cout %% +"clase Animal" Animal +%% t2is"&getNombre'( %% + destruido.+%% endl# / // constructor copia Animal Animal'const Animal P original( )/ // metodo matar Doid Animal matar'( const ) cout %% +"clase Animal"+ %% t2is"
&getNombre'( %% + Eatar, Eatar, Eatar, + %% endl# /
7I
8a /erencia multiple3 0,ui esta la clase Dilitar! ,ue /ereda de Humano + 0nimal.
/** * Eilitar.2pp * Clase que de:ine el objeto Eilitar * * Pello Xabier Altadill Izura * */ // Herencia multiple de Humano 6 Animal class Eilitar ) //1 public Humano ) c2ar *rango# public
public Animal
priDate
Eilitar'(#

SEilitar'(# Eilitar'const Eilitar P(# // sobrescribe metodos Doid matar'( const# Doid 2ablar'c2ar *bla( const# // un metodo poco probable entre cualquier uni:ormado... Doid razonar'( const# // setter/getter o accessors c2ar *get>ango'( const ) return t2is"&rango#/ Doid set>ango'c2ar *rango( ) t2is"&rango 4 rango#/ /#
@ su implementacion
/** * Eilitar.cpp * Programa que implementa la clase Eilitar * * Pello Xabier Altadill Izura * Compilacion g!! "c Habitante.cpp * g!! "c Humano.cpp * g!! "c Animal.cpp * g!! Eilitar.cpp Habitante.o Humano.o Animal.o "o Eilitar */ $include +Eilitar.2pp+ // Constructor Eilitar Eilitar'( ) cout %% +"clase Eilitar" Eilitar construido.+%% endl# / // Aestructor Eilitar SEilitar'( ) cout %% +"clase Eilitar" Eilitar +%% t2is"&getNombre'( %% + destruido.+%% endl# / // constructor copia Eilitar Eilitar'const Eilitar P original( ) cout %% +"clase Eilitar" Eilitar copia creada.+%% endl# / // metodo razonar Doid Eilitar razonar'( const ) cout %% +" clase Eilitar"+ %% t2is"&getNombre'( %% + ;rror B<;>9=BU + %% endl# 7@
// metodo 2ablar Doid Eilitar 2ablar'c2ar *bla( const ) cout %% +"clase Eilitar"+ %% t2is"&get>ango'( %% + + %% t2is"&getNombre'( %% + dice + cout %% bla %% endl#
// metodo matar Doid Eilitar matar'( const ) cout %% +"clase Eilitar"+ %% t2is"&get>ango'( %% + Eatar, + %% endl# cout %% +"clase Eilitar" *omos... agresores por la paz + %% endl#
// Aqui 2aremos multiples
pruebas... int main '( ) return .#
75
Captulo 1#. !ie&bros estaticos

6uereis ver un miembro no estatico7 : < 3-- nota docbooI: ,uitar c/orradas antes de publicar -->< 5ariablesB#unciones estaticas Dentro de las clases podemos de.inir atributos + metodos estaticos. 9ienen de particular ,ue son accesibles sin necesidad de de.inir una clase + ,ue su valor es E8 DE1DC en todas los ob'etos ,ue se va+an creando de una clase. Es como una variable "lobal de una clase. %on este e'emplo se ve su uso! + de paso se revisa el tema de punteros a .unciones. :si! /as leido bien<.
/** * *oldado.2pp * Clase que de:ine el objeto soldado muestra el uso de Dariables estaticas * 6 metodos estaticos. 0odo lo estatico escapa del ambito de la clase 6 puede * ser inDocado desde el e3terior * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class *oldado ) public // constructores *oldado'(# *oldado'c2ar *nombre1 int unidad(# // destructor S*oldado'(# // copia *oldado'*oldado const P(# // get/set c2ar *getNombre '( const ) return t2is"&nombre# / Doid setNombre 'c2ar *nombre( ) t2is"&nombre 4 nombre# / int getTnidad '( const ) return t2is"&unidad# / Doid setTnidad 'int unidad( ) t2is"&unidad 4 unidad# / Doid matar'( const# Doid darBrden 'c2ar *orden( const# // metodo que toma como parametro una :uncion Doid ejecutaAccion ' Doid '*accion( 'int1int((# static int 0otal*oldados# // Dariable estatica, static int 0otalNalas# // Dariable estatica, // 9unciones estaticas static int get0otal*oldados '( ) return 0otal*oldados# / static int get0otalNalas '( ) return 0otalNalas# /
Captulo 15. ,iem!ros estaticos

priDate c2ar *nombre#
int unidad# /#
7?
@ su implementacion. 1e recomienda probar + e'ecutar para comprobar el .uncionamiento de las variables estaticas.
/** * *oldado.cpp * Programa que implementa la clase *oldado * * Pello Xabier Altadill Izura * Compilacion g!! *oldado.cpp "o *oldado */ $include +*oldado.2pp+ // Constructor *oldado *oldado'( nombre'+>6an+(1 unidad'I.I( )
0otal*oldados !4 I# 0otalNalas!!# cout %% +*oldado + %% nombre %% + construido. Tnidad + %% unidad %% endl# / // Constructor parametrizado *oldado *oldado'c2ar *nombre1 int unidad( ) 0otal*oldados!!# 0otalNalas!!# t2is"&nombre 4 nombre# t2is"&unidad 4 unidad# cout %% +*oldado + %% nombre %% + *oldado construido.+ %% endl# / // Aestructor *oldado S*oldado'( ) 0otal*oldados""# cout %% +*oldado +%% t2is"&getNombre'( %% + destruido.+%% endl# / // constructor copia *oldado *oldado'const *oldado P original( ) nombre 4 neV c2ar# nombre 4 original.getNombre'(# cout %% +"clase *oldado" *oldado copia creada.+%% endl# / // metodo matar Doid *oldado const ) matar'(

0otalNalas""# cout %% t2is"&getNombre'( %% + Eatar es lo mio + %% endl# cout %% +Norn to Will. paz. ;s por la dualidad de Cant+ %% endl# / // metodo darBrden Doid *oldado *orden( const ) darBrden'c2ar
77
cout %% +>ecluta patoso,+ %% endl# cout %% t2is"&getNombre'( %% + unidad + %% t2is" &getTnidad'( %% + ordena +# cout %% orden %% endl# / // metodo ejecutaAccion *oldado ejecuta la :uncion que se le pasa como parametro Doid
ejecutaAccion ' Doid '*accion( 'int1int(( ) accion'517(# cout %%
+>ecluta patoso,+ %% endl# / // A0;NCIBN IEPB>0AN0; HAM XT; A;9INI> ; INICIA> =A* <A>IAN=;* ;*0A0ICA *I NB // el compilador nos puede poner pegas int *oldado 0otal*oldados 4 .# int *oldado 0otalNalas 4 .# // Ae:inimos una :uncion ajena a la clase desde la cual accederemos // a la Dariable estatica1 con lo que se demuestra que la Dariable estatica // esta :uera de la +capsula+ de la clase. Doid recuento*oldados'Doid(# // de:inimos otra :uncion esta para pasarsela como parametro a un metodo de la clase Doid carga 'int balas1 int granadas(# // :uncion principal // Aqui 2aremos multiples pruebas... int main '( ) int i1 resp# // creamos los soldados *oldado pelotonJI.K# *oldado HanWs 4 *oldado'+HanWs+1I.5(# // de:inicion de puntero de :uncion '*:uncion( 'int1 int( 4 carga# Doid
// *i 2a6 mas de una :uncion carga sera la que tenga los mismos parametros // 6 el mismo tipo de retorno // llamamos a la :uncion recuento recuento*oldados'(# pelotonJ.K.darBrden'+0odos en :ormacion.+(# pelotonJ2K.darBrden'+Canta el colacao,+(# // recorremos los I. soldados 6 2acemos algo dependiendo de la entrada // *i matamos unos cuantos modi:icaremos la Dariable de 0otal*oldados

:or 'i 4 .# i % I. # i!!( ) cout %% +;lije . o cualquier otro numero endl# cin && resp# i: 'resp 44 .( ) // matamos al soldado pelotonJiK.S*oldado'(# / else ) pelotonJiK.matar'(# // tiramos una bala / + %%
7F
// InDocamos el metodo estaticoQ // es un acceso AI>;C0B sin necesitar un objeto de:inido resp 4 *oldado get0otal*oldados'(# cout %% +Cuantos quedanQ + %% resp %% endl# ///:or // accedemos directamente a Dariable estatica cout %% +0otal balas antes de recarga + %% *oldado 0otalNalas %% endl#
// 2acemos una recarga HanWs.ejecutaAccion':uncion(# // llamamos a la :uncion recuento recuento*oldados'(# return .# / // implementacion de la :uncion recuento // muestra el numero de soldados. Podemos acceder AI>;C0AE;N0; a la Dariable statica Doid recuento*oldados '( ) cout %% +Cuantos soldados quedan DiDosQ + %% endl# cout %% +;n total + %% *oldado 0otal*oldados %% + soldados+%% endl# cout %% +EunicionQ + %% endl# cout %% +;n total + %% *oldado / // :uncion que carga municion del peloton Doid carga 'int balas1 int granadas( ) cout %% +Cargando balas *oldado granadas / + %% balas %% endl# get0otalNalas'( %% + balas+ %% endl#
0otalNalas !4 balas # cout %% +Cargando + %% granadas %% endl#
4ueno! + con esto +a son dos semanas dandole al c(( + aprendiendo su abc...
7H
Captulo 1%. Clases / sus a&i(as

%lases dentro de %lases *na clase puede ser el atributo de otra clase. 5eamos como metemos la clase soldado dentro del tan,ue! esta seria la cabecera:
/** * 0anque.2pp * Clase que de:ine el objeto 0anque . ;l objeto tanque estara lleno* de Bbjeto soldados1 lo que nos sirDe para demostrar el uso de clases * como atributos1 etc.. * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& $include +*oldado.2pp+ class 0anque ) public // constructores 0anque'(# 0anque'c2ar *nombre1 int pro6ectiles1*oldado soldado(# // destructor S0anque'(# // copia 0anque'0anque const P(# // get/set c2ar *getNombre '( const ) return t2is"&nombre# / Doid setNombre 'c2ar *nombre( ) t2is"&nombre 4 nombre# / int getPro6ectiles '( const ) return t2is" &pro6ectiles# / Doid setPro6ectiles 'int pro6ectiles( ) t2is"&pro6ectiles 4 pro6ectiles# / *oldado get*oldado '( const ) return t2is"&soldado# / Doid set*oldado '*oldado soldado( ) t2is"&soldado 4 soldado# / Doid aDanzar'int metros( const# Doid disparar'(# priDate c2ar *nombre# int pro6ectiles# *oldado soldado# /#
@ su implementacion: $1
/** * 0anque.cpp * Programa que implementa la clase 0anque * * Pello Xabier Altadill Izura * Compilacion g!! 0anque.cpp "o 0anque
Captulo 16. Clases + sus ami"as
*/ $include +0anque.2pp+ // Constructor 0anque 0anque'( nombre'+*upertanque+(1 pro6ectiles'I.(1 soldado'*oldado'(( ) cout %% +"clase + %% pro6ecti
0anque" 0anque + %% nombre %% + construido. Pro6ectiles /
// Constructor parametrizado 0anque 0anque'c2ar *nombre1 int pro6ectiles1 *oldado soldado( ) t2is"&nombre 4 nombre# t2is"&pro6ectiles 4 pro6ectiles# t2is"&soldado 4 soldado# cout %% +" clase 0anque" + %% nombre %% + 0anque construido. Pro6ectiles + %% pro6ect / // Aestructor 0anque S0anque'( ) cout %% +"clase 0anque" 0anque +%% t2is"&getNombre'( %% + destruido.+%% endl# / // constructor copia 0anque 0anque'const 0anque P original( ) nombre 4 neV c2ar# nombre 4 original.getNombre'(# cout %% +" clase 0anque" 0anque copia creada.+%% endl# / // metodo aDanzar Doid 0anque &getNombre'( %% + aDanzando / // metodo disparar Doid 0anque disparar'() i: 'pro6ectiles & .( ) pro6ectiles""# cout %% +"clase 0anque"+ %% t2is"&getNombre'( %% +NBBBBE,,+ %% endl# / else ) cout %% +"clase 0anque"+ %% t2is"&getNombre'( %% + No queda municion.+ %% endl# / / // :uncion principal // Aqui 2aremos multiples pruebas... int main '( ) int i1 resp# // creamos los 0anques 0anque tanqueta 4 0anque'(# FI aDanzar'int metros( const ) cout %% +"clase 0anque"+ %% t2is" + %% metros %% + m.+ %%
// podemos sacar lso datos del soldado asi cout %% +;l nombre del soldado es 'tanqueta.get*oldado'((.getNombre'(%% endl# tanqueta.aDanzar'5(# tanqueta.disparar'(# tanqueta.get*oldado'(.matar'(# return .# /
+ %%
.riend: /aciendo ami"os Dediante la palabra reservada .riend podemos declara relaciones de con.ian&a entre clases + permitir ,ue una clase ami"a pueda acceder a los atributos + metodos privados de esa clase. 5eamos el e'emplo con la $luma + la Espada. 8a pluma vence a la espada pero ademas la declara como ami"a por,ue es asi de enrollada. 5eamos la declaracion de $luma:
/** * Pluma.2pp * Clase que de:ine el objeto pluma1 un objeto que sirDe para escribir * * Pello Xabier Altadill Izura * */
using namespace std# $include
%iostream& class Pluma
) public Pluma'(# Pluma'c2ar *tipo1 c2ar *usuario(# SPluma'(# Pluma'Pluma const P(# // A0;NCIBN,,, de:inimos la clase ;*PAAA como :riend // por tanto desde ella se podra acceder a los elementos P>I<AAB* de la Pluma :riend class ;spada# c2ar *get0ipo'( const ) return t2is"&tipo#/ c2ar *getTsuario'( const ) return t2is"&usuario#/
priDate // metodo para escribir con la pluma Doid escribe 'c2ar *te3to( )cout %% +escribo con la pluma + %% te3to %% endl#/ Doid test'( ) cout %% +Eega :uncion priDada de Pluma,+ %% endl#/
c2ar *tipo# c2ar *usuario#
/#
/** * Pluma.cpp * Programa que implementa la clase Pluma * * Pello Xabier Altadill Izura * Compilacion g!! "c Pluma.cpp*/
$include +Pluma.2pp+ F2
// Constructor Pluma Pluma'(
tipo'+tinta c2ina+(1 usuario'+Nertrand >ussel+( ) cout %% +Pluma
construida.+ %% endl# / // Constructor Pluma Pluma'c2ar *tipo1 c2ar *usuario( ) t2is"&tipo 4 tipo# t2is"&usuario 4 usuario# cout %% +Pluma construida de tipo + %% tipo %% endl# / // Aestructor Pluma SPluma'( ) cout %% +Pluma destruida.+ %% endl# / // Constructor copia Pluma Pluma'Pluma const P original( ) tipo 4 neV c2ar# tipo 4 original.tipo# /
@ a/ora la declaracion de la Espada

/** * ;spada.2pp * Clase que de:ine el objeto ;spada1 un objeto quesirDe para matar * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& class ;spada ) public ;spada'(# ;spada'c2ar *tipo(# S;spada'(# ;spada';spada const P(# // desde este metodo accederemos a la // parte priDada de la pluma Doid usarPluma 'c2ar *te3to(# c2ar *get0ipo'( const ) return t2is"&tipo#/ priDate /# c2ar *tipo#
/** F@
* * * * * *
;spada.cpp Programa que implementa la clase ;spada Pello Xabier Altadill Izura Compilacion g!! "o ;spada Pluma.o ;spada.cpp*/
$include +;spada.2pp+ $include +Pluma.cpp+ tipo'+Watana+( ) cout %% +;spada construida.+ %% endl#
// Constructor ;spada ;spada'(
// Constructor ;spada ;spada'c2ar *tipo( ) t2is"&tipo 4 tipo# cout %% +;spada construida de tipo + %% tipo %% endl#
/ // Aestructor ;spada S;spada'( ) cout %% +;spada destruida.+ %% endl#
// Constructor copia ;spada ;spada';spada const P original( ) tipo 4 neV c2ar# tipo 4 original.tipo#
// metodo desde el que accedemos a Pluma Doid ;spada usarPluma'c2ar *te3to( ) // implementamos una pluma 6... Pluma plumilla 4 Pluma'(# // 6 a2ora accedemos a sus miembros priDados atributos ... cout %% +=a pluma es tipo + %% plumilla.tipo %% endl# cout %% +M su usuario es + %% plumilla.usuario %% endl# plumilla.escribe'te3to(# // e incluso a sus metodos, plumilla.test'(#
// :uncion principal int main '( ) int
i# ;spada tizona 4 ;spada'+mandoble+(# // inDocamos un metodo que accedere a la zona priDada de la clase tizona.usarPluma'+jaja uso la pluma a mi antojo+(# return .#
F8
8a .uncion ami"a $odemos declarar una .uncion como ami"a + nos dara acceso a 9CDC a traves de ese .uncion. $ara ilustrar esto de.inimos las clases %/ico + %/ica en un unico .ic/ero
/** * C2icoC2ica.cpp * Clase que de:ine el objeto C2ico 6 C2ica. C2ico tiene una :uncion llamada * esNoDio que dentro de c2ica la declaramos como :riend6 le dara acceso a todo * * Pello Xabier Altadill Izura * Compilacion g!! "o C2icoC2ica C2icoC2ica.cpp */ using namespace std# $include %iostream& class C2ico ) public // constructor C2ico'( nombre'+>omeo+( )/ // constructor C2ico'c2ar *nombre( ) t2is"&nombre 4 nombre#/ // destructor SC2ico'( )/ // constructor copia C2ico'C2ico const P origen( ) nombre 4 neV c2ar# nombre 4 origen.nombre# / // desde este metodo accederemos a la // parte priDada de la clase c2ica Doid esNoDio'(# c2ar *getNombre'( const ) return t2is"&nombre#/ priDate c2ar *nombre# /#
class C2ica ) public // constructor C2ica'( nombre'+[ulieta+(1 edad'2@(1 coe:icienteInteligencia'I8.(1 medidas'+H5"?."H5+( ) / // destructor SC2ica'( )/ // constructor copia C2ica'C2ica const P origen( ) nombre 4 neV c2ar# nombre 4 origen.nombre# / // Aqui de:inimos un metodo :riend e3terno // que tendra acceso a toda la clase c2ica :riend Doid C2ico esNoDio'(# // otra opcion seria declara C2ico como :riend // :riend class C2ico# F5
priDate Doid pensar'( ) cout %% +esto6 pensado...+ %% endl# / Doid entrarHabitacion'( ) cout %% +esto6 entrando en la 2abitacion...+ %% endl# / c2ar *nombre# int edad# int coe:icienteInteligencia#
c2ar *medidas# /#
// implementacion de la :uncion del c2ico esNoDio Doid esNoDio'( ) C2ica nesWa 4 C2ica'(#
C2ico
nesWa.entrarHabitacion'(# cout %% +Con esta :uncion entro en todo, + %% endl# cout %% +Aime tu edad real c2ica + %% nesWa.edad %% endl# cout %% +M tu coe:iciente intelectual + %% nesWa.coe:icienteInteligencia %% endl# cout %% +joder1 me parece que no te gustara el :utbol.+ %% endl#
// :uncion principal1 para las pruebas int main '(
) int i# C2ico mutiWo 4 C2ico'(# // Damos a Der si llamamos a esNoDio... mutiWo.esNoDio'(# return .# /
F?
Captulo 1). 0ntrada12alida

Entrada + salida 0 vueltas con el .lu'o :cin cout<! vamos a ver un uso mas extendido del /abitual. De paso conoceremos al"unas de las trampas ,ue nos esperan con los .lu'os! sobre todo por el tema de bu..ers. 5eamos este e'emplo comentado
/** * 9lujos.cpp * Programa para mostrar el uso de :lujos * * Pello Xabier Altadill Izura * Compilacion g!! "o 9lujos 9lujos.cpp */ using namespace std# $include %iostream& // Aisponemos de Darios :lujos // cin para la entrada de distintis tipos de datos 'std input( // cout para la salida de distintos tipos de datos 'std output( // cer para la salida de errores 'std error( // clo para la salida de errores 6 redireccion a :ic2eros tipo log // cin utiliza bu::ers 6 nos podemos lleDar sorpresas al recoger datos // si el usuario no los mete bien. Por ejemplo si se pide una palabra 6 se meten // dos1 la siguiente Dez que se pida otro dato se tomara el que se 2abia metido, // lo podemos eDitar con cin.ignore // 9uncion principal int main '( ) unsigned int i# c2ar nombreLapellidosJ25K# c2ar lineaJF.K# int entero# c2ar caracter# // A0;NCIBN // 2a6 que tener cuidado con los strings. prueba a meter nombre 6 apellido // 6 Deras que el string solo se llena 2asta el primer espacio en blanco1 // o incluso para a la siguiente Dariable i 6 el programa casca. cout %% +Eete tu nombre 6 tu apellido resalao nombreLapellidos %% endl# // con esta llamada eDitamos que se tome en cuenta las sobras cin.ignore'2551Y-nY(# // ;ntrada multiple, cout %% +Eete una palabra 6 un numero entero+ %% endl# cin && nombreLapellidos && entero# cout %% +;l te3to + %% nombreLapellidos %% + 6 el entero + %% entero %% endl# // e3plicacion && es un operador que se puede sobrecargar como 2emos Disto // anteriormente la e3presion cin && nombreLapellidos deDuelDe otro objeto iostream // 6 se podria reescribir asi 'cin && nombreLapellidos( && entero# // cin.get'string1tamaPntilde#o( para recoger string completos cout %% + Eete un string largo con espacios. + %% endl# cin.getline'linea1F.(# cout %% +resultado + %% linea %% endl# F7 + %% endl# cin + %%
&& nombreLapellidos# cout %% +0u nombre 6 apellidos
Captulo 1#. -ntrada./alida

// 2a6 Deces que puede interesar ignorar un numero de caracteres 2asta llegar al :inal // de la linea1 para eso podemos usar la :uncion cin.ignore'7.1Y-nY(# en lugar de -n // podemos usar cualquier caracter de terminacion que nos interese. // no 2a6 que olDidar que cin es un bu::er. Xue pasa si solo queremos leer un caracter // sin tener que YsacarloY del bu::erQ podemos usar cin.peeW'( 6 si queremos meter // un caracter podemos usar cin.putbacW'Y.Y( "meteria un . en el bu::er de cin // cin.get'( tomando un unico caracter. *i metemos mas imprimira todos // puede usarse parametrizado cin.get'caracter( cout %% +<ete metiendo caracteres. termina con un .+ %% endl# V2ile ' 'caracter 4 cin.get'(( ,4 ;B9( ) i: ' cin.peeW'( 44 Y.Y ( ) cout %% +nos Damos+ %% endl# breaW# / cout %% caracter# / cin.ignore'2551Y-nY(# return .#
En este otro se /abla mas de cout
/** * 9lujosBut.cpp * Programa para mostrar el uso de :lujos de *A=IAA * * Pello Xabier Altadill Izura * Compilacion g!! "o 9lujosBut 9lujosBut.cpp */
using namespace std# $include %iostream&
// cout tambien utiliza bu::ers 6 nos podemos lleDar sorpresas al recoger datos // aunque si queremos tirar de la cadena ejecutamos cout %% :lus2#
// 9uncion principal int main '( ) unsigned int i# c2ar nombreLapellidosJ25K# c2ar lineaJF.K# int entero# c2ar caracter# c2ar :raseJK 4 +Clatu Derata nictu-n+# // si en cin teniamos get aqui tenemos put // mandamos un saludo cout.put'YCY(.put'YaY(.put'YiY(.put'Y3Y(.put'YoY(.put'Y-nY(# // Damos a mostrar una linea

entero 4 strlen':rase(# // con esto la mostramos entera cout.Vrite':rase1entero(# // con esto... no cout.Vrite':rase1 'entero"5((# cout %% + a2ora con :ormato + %% endl# // Damos a ponerla con cierto :ormato Vidt2 6 :ill cout.Vidt2'@.(# // esto mete espacios en blanco equiDalente 4 setV'@.( FF
cout %% :rase %% endl# cout.Vidt2'5.(# // esto DuelDe a meter espacios cout.:ill'Y&Y(# // 6 esto >;==;NA los ;*PACIB* cout %% :rase %% endl# // ;stableciendo el estado de cout con set: // alineacion set:'ios le:t( 6 set:'ios rig2t( // 2a6 mas1 para inDestigar ios s2oVbase1 ios internal1 etc... cout.set:'ios rig2t(# entero 4 ???#
// podemos alterar la base con dec1 oct 6 2e3 cout %% +entero 2e3adecimal alineado a la derec2a + %% 2e3 %% entero %% endl# return .# /
#ic/eros en c(( C/ si! podemos mane'ar .ic/eros de entradaBsalida con las clases mas std. veamos unos e'emplos! metidos dentro de un ob'eto. Es bastante me'orable.
/** * 9ic2ero.2pp * Clase que de:ine el objeto 9ic2ero1 un objeto quesirDe gestionar un :ic2ero * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& $include %:stream& // atencion 2a6 que incluir esto enum tipoL:ic2ero ) ;N0>AAA1 *A=IAA1 APP;NA /# class 9ic2ero ) public 9ic2ero'(# 9ic2ero'c2ar *nombre1 tipoL:ic2ero tipo(# S9ic2ero'(# 9ic2ero'9ic2ero const P(# c2ar *getNombre'( const ) return t2is"&nombre#/ // operaciones sobre :ic2eros int cerrar '( const# // cierra el :ic2ero c2ar leer'( const# // lee del :ic2ero Doid escribir 'c2ar lineaJ255K( const# // escribe linea
priDate // esta :uncion decide que tipo de :ic2ero iniciar Doid inicializa9ic2ero'(# tipoL:ic2ero tipo# c2ar *nombre# o:stream *saliente# i:stream *entrante# /#
@ su implementacion.
/** FH
* 9ic2ero.cpp * Programa que implementa la clase 9ic2ero * * Pello Xabier Altadill Izura * Compilacion g!! "o 9ic2ero 9ic2ero.cpp * */
$include +9ic2ero.2pp+ nombre'+test.t3t+(1 tipo';N0>AAA( )
// Constructor 9ic2ero 9ic2ero'(
inicializa9ic2ero'(# cout %% +9ic2ero construido.+ %% endl#
// Constructor 9ic2ero 9ic2ero'c2ar *nombre1 tipoL:ic2ero tipo( ) t2is"&nombre 4 nombre# t2is"&tipo 4 tipo# inicializa9ic2ero'(# cout %% +9ic2ero construido con nombre + %% nombre %% endl#
// Aestructor 9ic2ero S9ic2ero'( ) cout %% +9ic2ero destruido.+ %% endl#
// Constructor copia 9ic2ero 9ic2ero'9ic2ero const P original( ) nombre 4 neV c2ar# nombre 4 original.nombre#
/ cerrar '( const ) i:
// cierra el :ic2ero int 9ic2ero
't2is"&tipo 44 .( ) entrante"&close'(# / else ) saliente"&close'(# / return .#
/ leer '( const
// lee linea del :ic2ero c2ar 9ic2ero
) return entrante"&get'(#
H.
// escribir sobre el :ic2ero Doid 9ic2ero const ) saliente"&Vrite'linea1255(# /
escribir 'c2ar lineaJ255K(
// esta :uncion decide que tipo de :ic2ero iniciar Doid 9ic2ero inicializa9ic2ero'( ) sVitc2 't2is"&tipo( )
case . cout %% +tipo ;N0>AAA+ %% endl# entrante 4 neV i:stream't2is"&nombre(# breaW# case I cout %% +tipo *A=IAA+ %% endl# saliente 4 neV o:stream't2is"&nombre(# breaW# case 2 cout %% +tipo APP;NA+ %% endl# saliente 4 neV o:stream't2is"&nombre1ios +nada+ %% endl# breaW# / / // :uncion principal1 en la que de paso Demos // PA>AE;0>B* de linea de comandos int main 'int argc1 c2ar **argD( ) int i# c2ar temp# c2ar lineaJ255K# // Damos a reDisar los argumentos que se 2an pasado al programa :or 'i4.# i%argc# i!!( ) cout %% +argumento '+ %% i %% +( / 9ic2ero :ic2ero 4 9ic2ero'+prueba.t3t+1APP;NA(# cout %% +escribe algo para aPntilde#adir al :ic2ero cout %% +2as puesto :ic2ero.cerrar'(# +# cin.getline'linea1255(# + %% argDJiK %% endl# app(# breaW# de:ault cout %%
+ %% linea %% endl# :ic2ero.escribir'linea(#
// le6endo de :orma directa. =eemos el parametro que 2a6amos pasado i:stream leer'+prueba.t3t+(# // abrimos el :ic2ero leer.open'+prueba.t3t+(# // recorremos el :ic2ero 6 mostramos contenido V2ile ' leer.get'temp( ( ) // esto indica el :inal cout %% temp# / // cerramos el :ic2ero leer.close'(# return .# /
Captulo 1*. Preprocesador

El preprocesador %uando se compila un pro"rama de c(( previamente se /ace un preprocesamiento en el ,ue se revisan determinadas variables de preprocesador. %on ellas lo ,ue se consi"ue es ,ue el compilador modi.i,ue el codi"o .uente del pro"rama antes de crear el e'ecutable. 5amos varios usos utiles.
HI

/** * Preprocesador.cpp * Programa c!! que muestra el uso del preprocesador. * * Pello Xabier Altadill Izura * Compilacion g!! "o Preprocesador Preprocesador.cpp * */ // include se utiliza para poder utilizar codigo e3terno1 // generalmente las librerias standar o nuestras propias librerias using namespace std# $include %iostream& // =as Dariables de preprocesador sirDen para que el compilador 2aga ciertas // modi:icaciones en el codigo :uente $de:ine PI @.I8I5 $de:ine NA0EAN +Nruce Ua6ne+ $de:ine EI*0;>X +9elipe Ronzalez+ $de:ine >;<;=A> $de:ine NT99;> 255 // podemos de:inir 9TNCIBN;*1 aunque sin complicarlas 6a que di:iculta // la depuracion 6 se pasa el tipado de Dariables por el arcoltriun:o $de:ine PB>C;N0A[;'a1b( 'a*b(/I.. // Ruardias de inclusion // ;structura condicional para eDitar multiples inclusiones // =a siguiente structura comprueba si NB se 2a de:inido la Dariable 9*0>;AE $i:nde: 9*0>;AE // si no se 2a de:inido1 la de:inimos $de:ine 9*0>;AE $include %:stream& $endi: // :in de condicion // macro de comillas $de:ine Vrite'3( cout %% $3 %% endl# int main '( ) int i 4 @85# :loat Dar 4 8.?7# c2ar bu::erJNT99;>K# // automaticamente el compilador traduce bu::erJ255K + %% PI %% + ten :e en el caos+ %% endl#
$i:de: PI cout %% +;l Dalor PI es $else
H2
Captulo 1$. Preprocesador

cout %% +PI no esta de:inido...+ %% endl# $endi: // a2ora miramos una Dariable de preprocesador que no esta asi en este caso no se reDelamos quien es NA0EAN... $i:de: >;<;=A> cout %% +Natman realmente se trata de NA0EAN %% endl# $endi: // con esta orden eliminamos la Dariable $unde: >;<;=A> // 6 este es el e:ecto >;<;=A> $i:de: + %% // 6
cout %% +EisterX realmente es $endi:
+ %% EI*0;>X %% endl#
cout %% +Dar * PI 4 + %% 'Dar * PI( %% endl# // mostramos la llamada a la :uncion cout %% +Porcentaje I5] de +%% i %% + es + %% PB>C;N0A[;'i1I5( %% endl# // llamada a la macro. Atencion1 conDertira EI*0;>XQ Vrite'Ha6 que Der que lujo Derdad EI*0;>X(# return .# /
Dacros para depuracion Disponemos de al"unas variables de macro ,ue .acilitan la depuracion asi como de la .uncion assert. 5eamos el uso
/** * Aepurador.cpp * Programa c!! que muestra el uso del preprocesador para depurar * * Pello Xabier Altadill Izura * Compilacion g!! "o Aepurador Aepurador.cpp * */ // include se utiliza para poder utilizar codigo e3terno1 // generalmente las librerias standar o nuestras propias librerias using namespace std# $include %iostream& // // // // // Aisponemos LLAA0;LL LL0IE;LL LL=IN;LL LL9I=;LL de estas Dariables de macro prede:inidas1 mu6 utiles para depurar. sustitu6e esa Dariable por la :ec2a sustitu6e esa Dariable por la 2ora sustitu6e esa Dariable por la linea de programa sustitu6e esa Dariable por el nombre del :ic2ero del programa
// de:inimos la Dariable A;NTR para actiDar la depuracion $de:ine A;NTR H@
// 6 mostramos el uso de assert'(1 su disponibilidad dependera del compilador. // cuando inDocamos la :uncion assert1 si lo que tiene como parametro es 0>T;

// no 2abra problema pero si es :alse saltara un codigo de depuracion que le digamos $i:nde: A;NTR $de:ine A**;>0'3( $else $de:ine A**;>0'3( i: ', '3(( ) - cout %% +error detectado1 :allo + %% $3 %% +-n+# - cout %% + linea+ %% LL=IN;LL %% + del :ic2ero + %% LL9I=;LL %% +-n+# / $endi: // :uncion principal para las pruebas main '( ) int i 4 @85# :loat Dar 4 8.?7# cout %% +2ola 2o6 es A**;>0'i&5(# cout %% +;ste es el :ic2ero +;stamos en la linea return .# / + %% LL9I=;LL %% endl# cout %% + %% LLAA0;LL %% endl# int
+ %% LL=IN;LL %% endl# A**;>0'i44.(#
H8
Captulo 1+. Principios de P$$

$ro"ramacion orientada a ob'etos Es probable ,ue te to,ue /ablar con ami"uetes ,ue pro"raman en la len"ua de Dordor :visualbasic< o "ente ,ue pro"rama en c o.uscado! o lo ,ue es peor! desconocidos ,ue te dicen ,ue Jpro"ramanJ en H9D82 estos intercambios de experiencias! esas a.irmaciones sobre rendimientos de e'ecucion pueden /acer tambalearse los cimientos de tu .e en la $CC. Gracias a estas anotaciones rescatamos del olvido las excelencias de la $CC + nos armamos de ar"umentos ante los /ere'es ,ue nos sal"an al paso con listados de codi"o en ristre.
K
Encapsulacion: los detalles de implementacion estan ocultos. Esto reduce ,ue se reprodu&can errores cuando se /acen cambios. 1e .acilita enormementa la interaccion entre otros ob'etos encapsulados +a ,ue no tienen ,ue conocer los detalles de uso. Herencia: este mecanismo es una de las claves de la CC$. 9odos los atributos! metodos! pro"ramaciones contenidas en una clase pueden /eredarse + extenderse a otras clases .acilitando la reutili&acion de codi"o. %ual,uier cambio se propa"a en toda la 'erar,uia de clases + nos vuelve a a/orrar traba'o /aciendo un sistema mas .acil de mantener. $olimor.ismo:"racias a el .acilitamos la ampliacion del sistema +a ,ue en lu"ar de crear codi"o por cada tipo de dato lo podemos a"rupar todo en uno utili&ando la sobrecar"a de .unciones. El cop+paste puede parecer lo mismo! pero a la /ora de cambiarBmantener un sistema se acaban metiendo muc/as /oras! cosa ,ue con la $CC evitas.
4ueno! ima"inemos ,ue ,ueremos desarrollar un sistema utili&ando la orientacion a ob'etos. LM$or donde se empie&a7 Esta serNa una aproximacin: 9odo pro+ecto comien&a con una descripcion ,ue encierra entre sus lineas los re,uerimientos del sistema. Es el momento de tomar un subra+ador + abrir el tercer o'o2 lo primero ,ue debemos /acer es identi.icar ob'etos potenciales ,ue .ormaran el dise-o + es tan .acil como buscar sustantivos :nombres! cosas<. 0 veces no resulta tan obvio +a ,ue los ob'etos pueden mani.estarse de diversas maneras:
K K K K K K
%osas Entidades externas :personas! ma,uinas o incluso otros desarrollos< Eventos :%a&o o &u&e&o :O< Roles 8u"ares Cr"ani&aciones :dpto! division<
Debemos acotar los ob'etos en un dominio cerrado + ser capaces de identi.icar lo ,ue esos ob'etos son! saben + /acen. $artiendo de la identi.icacion de ob'etos se puede ir desarrollando un dise-o de clases usando simbolos o len"ua'es uni.icados tales como *D8. 0un,ue realmente no /a+ ,ue .or&arse! la $CC no es mas ,ue otra .orma mas de abordar un problema2 puede ,ue el dise-o CC te sal"a por instinto. )o es de extra-ar ,ue un pro"ramador con a-os de experiencia acaba recurriendo a desacoplar cada ve& mas sus modulos + a recurrir a patrones de so.t>are sin darse cuenta. 8o ,ue no se puede ne"ar es el au"e de la $CC viendo la proli.eracion de len"ua'es CC! o su adaptacion para tener las venta'as de su punto de vista :Hava! p/p! p+t/on! perl!... son len"ua'es JrecientesJ< 0 veces puedes liarte al tratar de distin"uir clase + ob'eto2 esta cita del pro.eta resuelve las dudas: Dientras ,ue un ob'eto es una entidad ,ue existe en el tiempo + en el espacio! una clase representa solo una abstraccion!Jla esenciaJ del ob'eto si se puede decir asi. Grad+ 4ooc/
H5
Captulo 1%. Principios de POO
#i"ura: la incesante bus,ueda del santo "rial... En .in! estas anotaciones :eu.emismo de 9P0$0< sirven para acordarse de por,ue c(( puede ser una /erramienta util.
Captulo 2,. Te&plates

Gracias a c(( podemos de.inir clases-plantilla: son clases $0R0DE9REQ048E1 por lo "eneral entidades abstractas ,ue se pueden concretar en al"o mas concreto. El e'emplo mas claro es de las estructuras de datos tradicionales: $ilas! 8istas! %olas! etc.. Esas estructuras pueden contener distintos tipos de datos: enteros! strin"s! ob'etos!... Debemos reescribir la lo"ica de cada estructura para cada tio de dato7 )C3 $odemos de.inir una clase plantilla para la 8ista! la cola! la pila etc! + lue"o simplemente invocarlas especi.icando el tipo de dato. 0si de .acil.
H?
#i"ura: un caballero de la orden de los 9emplates 5eamos este /orrible e'emplo de lista :atencion a la complicadilla sintaxis<
/** * =ista.2pp * Clase que de:ine una estructura de datos lista Renerica * * Pello Xabier Altadill Izura */ using namespace std# $include %iostream& // Asi es como declaramos una clase plantilla // template %class nombreLgenerico& class NombreClase template %class R;N;>ICB& class =ista ) public
H7
Captulo 2&. Templates

// Constructor =ista'(# // Constructor =ista'R;N;>ICB elemento(# // Constructor copia =ista'=ista const P(# // Aestructor S=ista'(# // agregar elemento Doid agregar'=ista *nodo(# // se mueDe 2asta el siguiente dato =ista* siguiente'(# // comprueba si e3iste un elemento bool e3iste'R;N;>ICB dato(# // comprueba si e3iste un elemento R;N;>ICB getAato'( ) return t2is"&dato#/ priDate // un elemento que apunta a otra lista1 asi sucesiDamente =ista *ladealao# // el dato es del tipo R;N;>ICB R;N;>ICB dato# /#
@ su implementacion
/** * =ista.cpp * Programa que implementa la clase de =ista generica * * Pello Xabier Altadill Izura * Compilacion g!! "c =ista.cpp * */ $include +=ista.2pp+ // ;n la implementacion debemos detallar el tipo de dato1 // especi:icando todo el tema de plantilla1 o sea que en lugar // de poner =ista delante de cada :uncion debemos poner 0BAB // el c2urro siguiente // template %class R;N;>ICB& =ista%R;N;>ICB& nombre9uncion // Constructor template %class R;N;>ICB& =ista%R;N;>ICB& =ista'( )
ladealao 4 .# //dato 4 .# cout %% +NueDa lista creada.+ %% endl# /

// Constructor template %class R;N;>ICB& =ista%R;N;>ICB& =ista'R;N;>ICB elemento( ) ladealao 4 .# dato 4 elemento# cout %% +NueDa lista creada. Aato inicial dato %% endl# / HF + %%
// Constructor copia template %class R;N;>ICB& =ista%R;N;>ICB& =ista'=ista const P original( ) ladealao 4 neV =ista# ladealao 4 original.ladealao# dato 4 original.dato# / // Aestructor template %class R;N;>ICB& =ista%R;N;>ICB& S=ista'( ) /
// agregar elemento A= =B>B con donde se pone el retonno template %class R;N;>ICB& Doid =ista%R;N;>ICB& agregar'=ista *nodo( ) nodo"&ladealao 4 t2is# ladealao 4 .# / // se mueDe 2asta el siguiente dato template %class R;N;>ICB& =ista%R;N;>ICB&* =ista%R;N;>ICB& siguiente'( ) return ladealao# / //=ista template %class R;N;>ICB& =ista%R;N;>ICB& siguiente'(# // comprueba si e3iste un elemento template %class R;N;>ICB& bool =ista%R;N;>ICB& e3iste'R;N;>ICB dato( ) return :alse# /
*sando la lista @ a/ora de.inimos una clase llamada )ombre. %rearemos una lista de nombres. Este es la de.inicion
/** * Nombres.2pp * Clase que de:ine los nombres. No es mas que unacoba6a para probar el template * * Pello Xabier Altadill Izura */ // ;sta clase la usaremos en el template1 no 2a6 que de:inir nada en especial class Nombre ) public // Constructor Nombre'( nombre'+[ezabel+( )/ // Constructor Nombre'c2ar *nombre( ) t2is"&nombre 4 nombre# / // Constructor copia Nombre'Nombre const P(# // Aestructor SNombre'()/ HH

// agregar elemento c2ar* getNombre'( const ) return t2is"&nombre#/ priDate // el dato c2ar *nombre# /#
@ su implementacion + los e'emplos de uso de plantillas

/** * Nombres.cpp * Programa que implementa la clase nombres 6 utilza los templates* para crear una lista de nombres. * * Pello Xabier Altadill Izura * Compilando g!! "o Nombre =ista.o Nombre.cpp */ $include +Nombre.2pp+ $include +=ista.2pp+ // Constructor copia Nombre Nombre'Nombre const P original( ) nombre 4 neV c2ar# nombre 4 original.getNombre'(# / // 9uncion principal para las pruebas int main '( ) // Asi es como se implementan objetos con clases plantilla =ista%Nombre& listanombres#

=ista%Nombre& *tmp1 *:inal# Nombre test 4 Nombre'+Prince+(# // podemos de:inir =istas de cualquier tipo basico =ista%int& listaenteros# // guardamos la posicion inicial# :inal es un puntero1 le pasamos la direccion :inal 4 Plistanombres# // Damos a crear unos cuantos NBAB* 6 los aPntilde#adimos tmp 4 neV =ista%Nombre&# tmp"&agregar':inal(# :inal 4 tmp# // otra mas... tmp 4 neV =ista%Nombre&# tmp" &agregar':inal(# :inal 4 tmp# // otra mas... tmp 4 neV =ista%Nombre&# tmp" &agregar':inal(# :inal 4 tmp#
I..
// 6 a2ora recorremos la lista Plistanombres# V2ile 'tmp( )
tmp 4
cout %% tmp"&getAato'(.getNombre'( %% endl# tmp 4 tmp" &siguiente'(# / return .# /
Es un tema comple'o pero util.
I.I
Captulo 21. 03cepciones

%apturando excepciones 8as excepciones son un mecanismo de c(( para capturar errores ,ue se producen en tiempo de e'ecucion. *n pro"rama puede estar bien /ec/o pero por causas exo"enas pueden producirse errores. Dediante este sistema /acemos ,ue el codi"o sea muc/o mas RC4*19C.
/** * ;3cepciones.cpp * codigo que muestra como capturar e3cepciones 6 eDitarque el programa * :inalice inesperadamente. * * Pello Xabier Altadill Izura * */ using namespace std# $include %iostream& $include %:stream& $include %stde3cept& // programa principal1 para las pruebas int main '( ) int i# :loat :lotante# c2ar *palabra# c2ar bu::erJ5K# i:stream :ic2eroIne3istente# // para capturar e3cepciones debemos crear un bloque tr6"catc2 // que englobe algun momento problematico o critico del programa // tr6 ) codigo# / catc2'0ipoAe;rror( ) codigoLcorrector# / // lo 2abitual suele ser alguna situacion que dependa de la e3istencia // o no de un :ic2ero1 la entrada de datos de un usuario1 etc.. // ;l programa no puede controlar lo que le meten1 pero puede estar // preparado para el error1 reconducir la ejecucion 6 corregir la situacion tr6 ) // inicio del bloque. Preparamos una serie de putadas... cout %% +Eete lo primero que se te ocurra1 distinto de :loat && :lotante# c2ar * bu:: 4 neV c2arJI........K# :ic2eroIne3istente.open'+EotorAeAgua.t3t+(# :ic2eroIne3istente.getline'bu::er1255(# :ic2eroIne3istente.close'(# / catc2'std badLallocP errorLmemoria( ) cout %% +;rror de asignacion+ %% errorLmemoria.V2at'( %% endl# / // podemos seguir capturando catc2 'std e3ceptionP stde3c( ) // este es el tipo de error que se espera // 6 entre llaDes metemos el codigo que se ejecuta en caso de error. cout %% +;rror general1 mensaje + %% stde3c.V2at'( %% endl# / + %% endl# cin
I.2
return I# /
Excepciones personali&adas *na clase puede de.inir sus propias excepciones. *n mecanismo mu+ util para malos usos de los ob'etos. De.inimos la clase coc/e + preparamos el codi"o para capturar posibles .allos debidos a la .alta de combustible.
/** * Coc2e.2pp * Ae:inicion de la clase coc2e1 en la que se muestra eluso de e3cepciones * * Pello Xabier Altadill Izura * */ $include%iostream& class Coc2e ) public Coc2e'(# Coc2e'c2ar *m1int cil1int cab1 int litros(# SCoc2e'(# Doid arranca'(# Doid ec2aCombustible'(# Doid detiene'(# Doid acelera'(# priDate c2ar *marca# int
cilindrada# int caballos# int litrosCombustible# /# // clase e3clusiDa para e3cepciones. // Nota la podemos de:inir A;N0>B de la Clase coc2e1 como un atributo EA* class ADeria ) public // constructor ADeria'( mensaje'+;rror+( )/ // constructor con mensaje ADeria'c2ar *mensaje( )
Captulo 21. -0cepciones

t2is"&mensaje 4 mensaje# / c2ar* dimeXuePasa'( ) return t2is"&mensaje# /# priDate c2ar *mensaje# /# I.@
Captulo 21. -0cepciones @ la implementacion

/** * Coc2e.cpp * Implementacion de la clase coc2e1 en la que semuestra el uso de e3cepciones * * Pello Xabier Altadill Izura * Compilacion g!! "o Coc2e Coc2e.cpp*/ $include +Coc2e.2pp+ Coc2e endl# / Coc2e Coc2e 'c2ar *m1int cil1int cab1 int litros( ) Coc2e'( ) cout %% +Coc2e creado.+ %%
marca 4 m# cilindrada 4 cil# caballos 4 cab# litrosCombustible 4 litros# cout %% +Coc2e creado.+ %% endl# / Coc2e endl# / // el coc2e arranca Doid Coc2e arranca'( ) // si no 2a6 combustible ;XC;PCIBN, i: SCoc2e'( ) cout %% +Coc2e destruido.+ %%
'litrosCombustible 44 .( ) t2roV ADeria'(# / litrosCombustible""# cout %% +Arrancando %% endl# / // el coc2e se detien Doid Coc2e %% +Aeteniendo coc2e + %% endl# / // el coc2e acelera Doid Coc2e acelera'( ) i: 'litrosCombustible 44 .( ) t2roV ADeria'+No puedo acelerar sin combustible+(# / cout %% +Acelerando / N>>>>>TEEEEmmmmmmmm2,, + %% endl# brummm, +
detiene'( ) cout
I.8
// :uncion principal para pruebas int main '( ) int i# Coc2e buga'+*eat+125.1I@..1.(# Coc2e tequi'+Audi+12?.1I5..1I(# // Damos a arrancar el coc2e pero si algo :alla // capturamos la e3cepcion tr6 ) buga.arranca'(# / catc2 'ADeria e3cepcion( ) cout %% +;3cepcion. [ar que no puedo. + %% endl# / // arracamos el tequi tequi.arranca'(# // proDocamos la e3cepcion 6 la capturamos mostrando la e3plicacion. tr6 ) buga.acelera'(# / catc2 'ADeria e3cepcion( ) cout %% +[ar que no puedo. + %% e3cepcion.dimeXuePasa'( %% endl# / return .# /
I.5
Captulo 21. -0cepciones #i"ura: el control de excepciones nos proporciona mas robuste&.
I.?
I.7
Captulo 22. 4ibrerias estandar

8a libreria estandar de c((... 8a sintaxis de inclusion de librerias puede variar se"un la version + la plata.orma del compilador c((. $uede ser asi:
... using namespace std# $include %iostream& ...
C mas simple:
... using namespace std# $include %iostream& ...
$ero! LM,ue narices es eso del namespace7 %on eso de namespace lo ,ue /acemos es declarar un &ona concreta para variables! ob'etos! etc.
... int contador# // Dariable global // de:inimos el espacio de nombres :reedomia namespace :reedomia ) int contador# / // de:inimos el espacio de nombres libertonia namespace libertonia ) int acumulador# int contador# / // Damos a probar int main '( ) // asi utilizariamos la Dariable del espacio :reedomia :reedomia contador 4 .# // 6 asi la otra1 la global contador 4 .# // XT; PA*A *I no lo especi:icamosQ e:ectiDamente tendremos // seremos unos ambiguos // 6 si somos unos Dagos 6 no queremos especi:icar el espacio de nombres // en cada uso de la DariableQQ // metemos la directiDa using using namespace libertonia# acumulador 4 .# // pero B[B esto seguiria siendo ambiguo contador 4 .# // using como declaracion.
I.F
Captulo 22. 1i!rerias estandar

// Pero que pasa si lo que realmente queremos es quitar esa ambiguedad // 6 a:irmar que en adelanta Damos a utilizar la Dariable de determinado namespaceQ // ;*0B se 2aria asi using libertonia contador# // a2ora si1 esto seria correcto contador 4 .# /
0 lo ,ue ibamos: al i"ual ,ue en c! en c(( tenemos una libreria base para desarrollar aplicaciones. 0,ui se /ec/a un rapido vista&o a todas ellas.
$include %iostream& =ibreria basica de entrada/salida. Imprescindible. $include %string&
8ibreria para el mane'o de strin" con las .unciones mas usuales como strcp+! strncp+! strlen! strcat! strncat! incluso las ,ue sirven para buscar dividir un strin" en toIens.
$include %time&
8ibreria para escribir .ec/as! con distintas opciones. $odemos sacar la .ec/a del momento + separar los valores de dia! /ora! minuto! etc..
$include %stdlib&
Ctra libreria basica! ,ue contiene .unciones como los conversores de ascci-inte"er atoi! al"oritmos de ordenacion de arre"los como ,sort.. 5eamos el listado ,ue contiene las librerias del ambito estandar.
K K K K K K K K K K K
iostream : entrada + salida iomanip : manipuladores de entradaBsalido con ar"umentos .stream : .lu'os de arc/ivos sstream : .lu'os de cadenas :tipo c((< strstream : .lu'os de cadenas :tipo c< vector : contenedor para crear vectores list : contenedor para crear listas de,ue : contenedor para una cola de extremo doble map : contenedor para "rupo de pares :id!valor< strin" : cadenas 8ibrerias de c. Estan versioneadas para la libreria estandar de c(( las si"uientes: cstdlib! cstdio! cerrno! cassert! cstdar"! cstrin"! ctime! csi"nal! cstdde.! cset'mp! cmat/! clocale! climits! c.loat + cct+pe.
Cperadores de bits: Ctra opcion mas de c((

P ANA O B> I.H
^ e3clusiDe B> S complement
Captulo 22. 1i!rerias estandar
#i"ura: pro"ramar es como cocinar Existen mas librerias standar + lo ,ue es me'or! librerias mu+ potentes disponibles para desarrollar pro"ramas mas comple'os: creacion de inter.aces de ventanas! comunicaciones! etc.. El estilo 0 la /ora de escribir codi"o se pueden tomar muc/as costumbres + vicios ,ue no .acilitan la "eneracion de un estilo claro. De todas .ormas! dentro de un mismo pro+ecto seria me'or mantener un mismo estilo. )o debe ser una preocupacion! +a ,ue existen pro"ramas para .ormatear el codi"o .uente! meter espacios tabulaciones! saltos de linea! etc. Captulo 22. 1i!rerias estandar
II.
Captulo 23. 5otas' autoria' licencia' re"erencias

Ta!la 2341. Pala!ras reser)adas de c++ Palabras reser.adas' deben estar en &inusculas asm auto bool breaI case catc/ c/ar class const const?cast continue de.ault delete do double d+namic?casts else enum extern explicit .alse .loat .or .riend "oto i. inline int lon" mutable namespace ne> operator private protected public re"ister reinterpret?cast return s/ort si"ned si&eo. static static?class struct s>itc/ template t/is t/ro> true tr+ t+pede. t+peid union unsi"ned usin" virtual void volatile >c/ar?t >/ile El testimonio de este diario .ue reco"ido por el aprendi& $ello Pabier 0ltadill E&ura de boca del propio $eter %lass. Das alla de la tradicion oral se compuso este documento utili&ando 8+P! mas tarde docbooI a pelo con blue.is/ sobre un P-evian cop+le.t edition. 1e "eneraron distintos .ormatos. El codi"o .ue probado utili&ando "cc en un vie'o sistema sa'on llamado red/at + tambien en su version del anticristo :bloods/ed c(( para >indo>s<2 en cual,uier caso se /a tratado de respetar la sintaxis acordada en los ultimos 0)1Econcilios2 cual,uier mal .uncionamiento puede encubrir un compilador /eretico! + debe ir a la /o"uera sin mas contemplaciones. $eter %lass puede estar mu+ e,uivocado en sus a.irmaciones + ro"amos ,ue se noti.i,uen .allos! errores de concepto + patadas en "eneral! pueden diri"irse a >>>.pello.in.o para lan&ar sus maldiciones. Este documento tiene licencia %reative %ommons. 8ee + di.unde.
Re.erencias
K K K
c(( en 21 dias 0)1E-%$$ %$$ para pro"ramadores! de Herbert 1c/ildt
Este documento tiene licencia %reative %ommons. 8ee + di.unde.
11#
Captulo 23. 2otas autoria licencia re(erencias
Hasta otra33 0"radecimientosBEsIerraI: 0ndoniri 1c/ildt-en liburua u&tea"atiI. Et&uliIo di&ut e"unen baten.
II2

Tutorial C++

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Tutorial C++

Enviado por

Direitos autorais:

Formatos disponíveis

Tutorial de C++ o el diario de Peter Class

Peter Class Pello Xabier Altadill Izura

Captulo 2. Hola nena

Captulo 4. Tipos de datos

Captulo 4. Tipos de datos 9ambien se pueden de.inir constantes:

5alor booleano: true o .alse

@ mas adelante saldra al"un e'emplo de enumeracion...

Captulo 4. Tipos de datos

unsigned int test 4 .# unsigned int a 4 .1 b 4 .1 c#

// <eamos el resto de Dalores cout %% +M los demas %% + + %% b %% + + %% a %% endl# return .# /

Cperadores lo"icos. 0 continuacion vemos :comparaciones< + la combinacion de estos.

E.-else Entroduciendo esta simple estructura de control:

g!! I:;lse.cpp "o I:;lse

Captulo %. Para&etros' a&bito' sobrecar(a

$aso de parametros 5amos a ver .ormas de pasar parametros.

Captulo 6. Parametros am!ito so!recar"a Captulo 6. Parametros am!ito so!recar"a

Captulo 6. Parametros am!ito so!recar"a Captulo 6. Parametros am!ito so!recar"a

g!! "c Coc2e.cpp*/

@ esta seria la implementacion:

Captulo #. Clases Captulo #. Clases

temp %% + 6 ma3 + %% ma3imo %% endl# :or 'temp4.# temp %

5eamos otro e'emplo...

g!! Puntero2.cpp "o Puntero2

Pcarac %% endl %% endl# cout %% +<ariable puntero

+ %% *punteroNueDo %% endl# cout %% +Aireccion puntero

Captulo 1,. -e"erencias

Captulo 1&. 'e(erencias

%on los ob'etos se pueden /acer re.erencias i"ualmente:

intercambio con e3c2ange'int Pre:a1 int Pre:b(

Captulo 1&. 'e(erencias

$asando clases por re.erencia

Captulo 1&. 'e(erencias

nombre 4 nmb# edad 4 ed# peso 4 p#

Captulo 1&. 'e(erencias

Captulo 1&. 'e(erencias

+Rremlin creado.+ %% endl# / Rremlin Rremlin 'c2ar *nmb1int ed1 int p( )

nombre 4 nmb# edad 4 ed# peso 4 p# / Rremlin SRremlin'( ) cout %% +Aaaarg2,-nRremlin

Captulo 1&. 'e(erencias

Captulo 11. Funciones a.anzadas

// Constructor por de:ecto Coc2e Coc2e'( ) cout %% +Coc2e creado.+ %% endl#

Captulo 11. Funciones avan)adas

Coc2e 'int cilindrada 4 I...1 int caballos 4 I..( )

Captulo 11. Funciones avan)adas

/** * Perro.2pp * Clase de cabecera de Perro * * Pello Xabier Altadill Izura * */

using namespace std# $include

Captulo 11. Funciones avan)adas

Captulo 11. Funciones avan)adas

cout %% +Canelo es un perro cu6a edad es Canelo.=adra'(# Canelo.*etAge'7(#

+ # cout %% Canelo.RetAge'( %% + aPntilde#os-n+#

using namespace std# $include %iostream& class int Dalor# public

Contador ) priDate Contador'(#

Captulo 11. Funciones avan)adas

Contador'( ) Dalor 4 .# cout %% +Contador creado,+ %%

operator!'const Contador P tmp( ) return

Contador'Dalor ! tmp.getContador'((# / int main '( ) int i# 57

Captulo 11. Funciones avan)adas

Captulo 12. Arra/s

Captulo 12. *rra+s

Captulo 12. *rra+s

) 2ablar'+Euere,, mVa2a2a2a2aaa+(# / // 9uncion principal

Captulo 12. *rra+s

Captulo 13. Herencia

Captulo 13. Herencia @ su implementacion...

De2iculo& arrancando De2iculo. Nrruum,,+ %% endl# /

C9$9 8a salida de la e'ecucion de %oc/e.cpp seria:

c2ar tipo# c2ar usuario#