TUTORIAL:

C++

COMO UMA LINGUAGEM DE

PROGRAMAO ORIENTADA A OBJETOS.

Copyrigh ! "##$

Andr Augusto Cesta. aacesta@dcc.unicamp.br Orientadora: Profa Dra Ceclia Mary isc!er "ubira

#$#O"%A&:

'C(( COMO $MA &%)*$A*+M D+ P"O*"AMA,-O O"%+)#ADA A O./+#O0.' Copyrig!t 1 2334

Andr Augusto Cesta. aacesta@dcc.unicamp.br Orientadora: Profa Dra Ceclia Mary isc!er "ubira

P"O*"AMA,-O O"%+)#ADA A O./+#O0

+ste tutorial se prop5e a ensinar programa67o orientada a ob8etos em C((. A maioria dos li9ros n7o apresenta a linguagem nesse conte:to; dando uma aten67o maior para os recursos de C(( do <ue para a metodologia de programa67o. = recomend>9el <ue o leitor ten!a acesso a um desses li9ros 9isto <ue n7o ensinaremos a<ui aspectos considerados b>sicos <ue s7o em geral <uase todos <ue permitem usar C(( como um C mel!orado. ?oc@ pode usar C((; como uma linguagem procedural com recursos a9an6ados; mais uma 9eA n7o isso <ue pretendemos ensinar neste te:to. )a pr>tica de programa67o orientada a ob8etos estaremos atentos em nossos programas para pontos como:

BCompatibilidade; portabilidade. B0eguran6a. B"eusabilidade. B acilidade de integra67o. B acilidade de e:tens7o. B+fici@ncia.

Os tCpicos seguintes nos guiar7o nesses ob8eti9os; mostrando numa cur9a de aprendiAado sua9e; como programar usando orienta67o a ob8etos em C((.

2. C&A00+0 + O./+#O0 $ma classe um tipo definido pelo usu>rio <ue contm o molde; a especifica67o para os ob8etos; assim como o tipo inteiro contm o molde para as 9ari>9eis declaradas como inteiros. A classe en9ol9e; associa; fun65es e dados; controlando o acesso a estes; definBla implica em especificar os seus atributos DdadosE e suas fun65es membro DcCdigoE. $m programa <ue utiliAa uma interface controladora de um motor eltrico pro9a9elmente definiria a classe motor. Os atributos desta classe seriam: temperatura; 9elocidade; tens7o aplicada. +stes pro9a9elmente seriam representados na classe por tipos como float ou long . As fun65es membro desta classe seriam fun65es para alterar a 9elocidade; ler a temperatura; etc. $m programa editor de te:tos definiria a classe par>grafo <ue teria como um de seus atributos uma string ou um 9etor de strings; e como fun65es membro; fun65es <ue operam sobre estas strings. Fuando um no9o par>grafo digitado no te:to; o editor cria a partir da classe par>grafo um ob8eto contendo as informa65es particulares do no9o te:to. %sto se c!ama instancia67o ou cria67o do ob8eto. Classes podem ser declaradas usando a pala9ra reser9ada struct ou a pala9ra reser9ada class; nos e:emplos posteriores entraremos em mais detal!es. As classes do prC:imo tCpico 2.G s7o declaradas com struct por raA5es did>ticas. Fuando c!egarmos em encapsulamento 2.H mostraremos como declarar classes com class e n7o usaremos mais struct no tutorial.

2.2. +0P+C% %CA)DO $MA C&A00+ 0upon!a um programa <ue controla um motor eltrico atra9s de uma sada serial. A 9elocidade do motor proporcional a tens7o aplicada; e esta proporcional aos bits <ue 97o para sada serial e passando por um 5

con9ersor digital analCgico. ?amos abstrair todos estes detal!es por en<uanto e modelar somente a interface do motor como uma classe; a pergunta <ue fun65es e <ue dados membro de9e ter nossa classe; e <ue argumentos e 9alores de retorno de9em ter essas fun65es membro:

"epresenta67o da 9elocidade: A 9elocidade do motor ser> representada por um atributo; ou dado membro; inteiro DintE. $saremos a fai:a de bits <ue precisarmos; caso o 9alor de bits necess>rio n7o possa ser fornecido pelo tipo ; usaremos ent7o o tipo long ; isto depende do con9ersor digital analCgico utiliAado e do compilador.

"epresenta67o da sada serial: O motor precisa con!ecer a sua sada serial; a sua liga67o com o 'motor do mundo real'. 0upon!a uma representa67o em !e:adecimal do atributo endere6o de porta serial; um poss9el nome para o atributo: enderecomotor. )7o se preocupe em saber como usar a representa67o !e:adecimal.

Altera67o do 9alor da 9elocidade: %nternamente o usu>rio da classe motor pode dese8ar alterar a 9elocidade; criaBse ent7o o mtodo D em C(( fun67o membroE: 9oid alteraI9elocidadeDint no9a9EJ . O cCdigo anterior corresponde ao cabe6al!o da fun67o membro; ela definida 8unto com a classe motor; associada a ela. O 9alor de retorno da fun67o 9oid D9alor 9aAioE; poderia ser criado um 9alor de retorno DintE <ue indicasse se o 9alor de 9elocidade era permitido e foi alterado ou n7o era permitido e portanto n7o foi alterado. )7o faA sentido usar; c!amar; esta fun67o membro separada de uma 9ari>9el do tipo motor; mas ent7o por<ue na lista de argumentos n7o se encontra um motorK +ste pensamento reflete a maneira de associar dados e cCdigo Dfun65esE das linguagens procedurais. +m linguagens orientadas a ob8etos o cCdigo e os dados s7o ligados de forma diferente; a prCpria declara67o de um tipo definido pelo usu>rio 8> engloba as declara65es das fun65es inerentes a este tipo; isto ser> e:plicado em 2.G.G. )ote <ue n7o fornecemos o cCdigo da fun67o; isto n7o importante; por !ora a preocupa67o com a interface definida pela classe: suas fun65es membro e dados membro. Apenas pense <ue sua interface de9e ser fle:9el de modo a n7o apresentar entra9es para a cria67o do cCdigo <ue seria feita numa outra etapa. )esta etapa teramos <ue imaginar <ue o 9alor numrico da 9elocidade de9e ir para o con9ersor onde ir> se transformar numa diferen6a de potencial a ser aplicada nos terminais do motor; etc.

$m diagrama simplificado da classe motor com os dados membro e as fun65es membro: L iguraM

+:erccios: 2E&embreBse de algum programa em <ue 9oc@ trabal!ou; cite <ue tipos de classes seriam criadas se esse programa fosse escrito em C((; <ue atributos e <ue fun65es membro estariam associadas a esses ob8etosK +:emplo: '+u trabal!ei em um programa de contas a pagar e contas a receber. 0e esse programa fosse escrito em C(( eu definiria a classe contaIbancaria. Os atributos seriam: saldo; ta:aIdeI8uros; limiteIdeIsa<ue; etc. Min!a op67o seria por represent>Blos como 9ari>9eis do tipo float. ' 'Dentre as fun65es membros desta classe estariam fun65es para efetuar sa<ues; depCsitos e computar 8uros.' 6

2.G. 0#"$C# +M C(( Ob8etos s7o instNncias de uma classe. Fuando um ob8eto criado ele precisa ser inicialiAado; ou se8a para uma Onica classe : +studante de gradua67o podemos ter 9>rios ob8etos num programa: +studante de gradua67o Carlos; %dentifica67o 3P2G2Q; Curso Computa67oJ +studante de gradua67o &uiAa ; %dentifica67o 3PHGP3; Curso +ngen!aria Ci9il... A classe representa somente o molde para a cria67o dos ob8etos; estes sim contm informa67o; 9e8a tCpico classes e ob8etos. L iguraM

2.G.2. A#"%.$#O0 O$ DADO0 M+M."O. +ste e:emplo declara uma struct e em seguida cria um ob8eto deste tipo em main alterando o conteOdo desta 9ari>9el. $ma struct parecida com um record de Pascal; a nossa representa um crculo com os atributos raio; posi67o : ; posi67o y; <ue s7o coordenadas cartesianas. )ote <ue este ob8eto n7o possui fun65es membro ainda.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M struct circulo SSstruct <ue representa um circulo. T float raioJ float :J SSposicoes em coordenadas cartesianas float yJ UJ

9oid mainDE T circulo acJ SScriacao de 9aria9el ; 9e8a comentarios. ac.raioV2W.WJ SSmodificacao de conteudo DatributosE da struct

ac.:V2.WJ SScolocando o circulo em uma posicao determinada ac.yV2.WJ SScolocando o circulo em uma posicao determinada cout LL '"aio:'LLac.raio LLendlJ SS9erificacao dos atributos alterados. cout LL 'X:'LLac.: LL 'Yn'J SS 'Yn'VVendl cout LL 'Z:' LLac.yLL endlJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: "aio:2W X:2 Z:2

Coment>rios: struct circulo SSstruct <ue representa um circulo. T float raioJ float :J SSposicoes em coordenadas cartesianas float yJ UJ +ste cCdigo a declara67o da classe crculo; entre c!a9es 9em os dados membro e as fun65es membro <ue n7o foram apresentadas ainda. A sinta:e para cria67o de ob8etos da classe crculo Dcirculo acJE ; por en<uanto n7o difere da sinta:e para a cria67o de 9ari>9eis do tipo int. O acesso aos dados membro de9e ser feito usando o nome do ob8eto e o nome do dado membro; separados por um ponto: ac.raioV2W.WJ . )ote <ue raio soAin!o n7o faA sentido no programa; precisaBse especificar de <ue ob8eto se dese8a acessar o raio.

Aos <ue programam em C: Os programadores C podem notar algo interessante: 'C(( n7o re<uer a pala9ra struct na declara67o da 9ari>9el; ela se comporta como um tipo <ual<uer: int ; float ...'. Outros programadores <ue n7o !a9iam usado struct pre9iamente em C n7o se preocupem; fa6am apenas os e:erccios deste e:emplo e estar7o aptos a prosseguir.

+:erccios: 2E "epita o mesmo e:emplo sC <ue agora mo9a o crculo alterando as componentes : e y. Pon!a o crculo em DW.W;W.WE atra9s de atribui65es do tipo ac.:V2.WJ mo9a o crculo para D2.W;2.WE. Acompan!e todas as modifica65es da struct atra9s de cout[s.

GE0implifi<ue o programa anterior retirando o atributo raio. ?oc@ pode dar o nome de ponto ou pontoIgeometico para esta classe.

2.G.G. M=#ODO0 O$ $),\+0 M+M."O. C(( permite <ue se acrescente fun65es de manipula67o da struct em sua declara67o; 8untando tudo numa sC entidade <ue uma classe. +ssas fun65es membro podem ter sua declara67o Dcabe6al!oE e implementa67o DcCdigoE dentro da struct ou sC o cabe6al!o DassinaturaE na struct e a implementa67o; cCdigo; fora. +ste e:emplo apresenta a primeira 9ers7o; o prC:imo a segunda 9ers7o Dimplementa67o fora da classeE. +ssas fun65es comp5em a interface da classe. A terminologia usada para design>Blas bastante 9ariada: fun65es membro; mtodos; etc. Fuando uma fun67o membro c!amada; se diA <ue o ob8eto est> recebendo uma mensagem Dpara e:ecutar uma a67oE.

$m programa simples para testes sobre fun65es membro seria o seguinte: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

struct contador SSconta ocorrencias de algo T int numJ SSnumero do contador 9oid incrementaD9oidETnumVnum(2JUJ SSincrementa contador 9oid comecaD9oidETnumVWJUJ SScomeca a contar 9

UJ

9oid mainDE SSteste do contador T contador umcontadorJ umcontador.comecaDEJ SSnao es<ueca dos parenteses; e uma funcao membro e nao atributo] cout LL umcontador.num LL endlJ umcontador.incrementaDEJ cout LL umcontador.num LL endlJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: W 2

Coment>rios: O programa define um ob8eto <ue ser9e como contador; a implementa67o representa a contagem no atributo num <ue um nOmero inteiro. As fun65es membro s7o simples: incrementa adiciona um ao contador em <ual<uer estado e comeca inicialiAa a contagem em Aero.

0inta:e: A sinta:e para declara67o de fun65es membro dentro de uma classe a mesma sinta:e de declara67o de fun65es comuns : tipoderetorno nomedafuncaoDlistaIdeIargumentosE T S^codigo ^S U. A diferen6a <ue como a fun67o membro est> definida na classe; ela gan!o acesso direto aos dados membros; sem precisar usar o 'ponto'; e:emplo umIob8eto.dadomembroJ . &embreBse <ue as c!amadas de fun65es membro 8> se referem a um ob8eto especfico; embora elas se8am definidas de uma forma geral para toda a classe. A sinta:e de c!amada ou acesso _ fun65es membro semel!ante a sinta:e de acesso aos dados membro com e:ce67o dos par@nteses <ue contm a lista de argumentos da fun67o; mesmo <ue a lista se8a 9aAia eles de9em estar presentes: umcontador.incrementaDEJ. Primeiro insereBse o nome do ob8eto e depois a c!amada da fun67o; estes s7o separados por um ponto. Cuidado para n7o es<uecer os par@nteses nas c!amadas de fun65es membro em programas futuros; este um erro bastante comum.

10

Agora o programa mais complicado; porm baseado no e:emplo 2.G.2: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M SSpara cout

struct circulo T float raioJ float :J SSatributo coordenada cartesiana : float yJ SSatributo coordenada cartesiana y

9oid mo9eDfloat d:;float dyE SSfun67o membro ou fun67o membro mo9e T :(Vd:J SSe<ui9ale a :V:(d:J y(VdyJ U

9oid mostraD9oidE SSfun67o membro ou fun67o membro mostra T cout LL '"aio:'LLraio LLendlJ cout LL 'X:'LL: LL endlJ cout LL 'Z:' LLyLL endlJ U UJ

9oid mainDE 11

T circulo acJ SS ^ instancia67o de um ob8eto circulo DcriacaoE ac.:VW.WJ ac.yVW.WJ ac.raioV2W.WJ

ac.mostraDEJ ac.mo9eD2.W;2.WEJ ac.mostraDEJ ac.:V2WW.WJ ac.mostraDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: "aio:2W X:W Z:W "aio:2W X:2 Z:2 "aio:2W X:2WW Z:2

Coment>rios: A fun67o membro mo9e altera as coordenadas do ob8eto. O ob8eto tem suas coordenadas : e y somadas com os argumentos dessa fun67o membro. )ote <ue esta fun67o membro representa uma maneira mais segura; clara; elegante de alterar as coordenadas do ob8eto do <ue acess>Blas diretamente da seguinte forma: ac.:(Vd:J. ac.y(VdyJ. &embreBse <ue ac.:(Vd: uma abre9ia67o para ac.:Vac.:(d:J .

12

Como funcionam no compilador as c!amadas de fun65es membro: = poss9el imaginar <ue as defini65es de fun65es membro ocupam um grande espa6o na representa67o interna dos ob8etos; mas lembreBse <ue elas s7o todas iguais para uma classe ent7o basta manter para cada classe uma tabela de fun65es membro <ue consultada no momento da c!amada . Os ob8etos sC precisam ter uma refer@ncia para esta tabela.

+:erccios: 2E)este mesmo programa; crie uma fun67o para a struct c!amada 'inicialiAa' <ue de9e ter como argumentos um 9alor para :; um para y e outro para o raio; e de9e alterar os atributos inicialiAandoBos com os 9alores passados. ?oc@ pode abstrair o uso dessa fun67o como uma maneira de inicialiAar o ob8eto de uma sC 9eA embora a fun67o o fa6a se<`encialmente. Comente as 9antagens de faA@Blo; comparando com as outras op65es; ten!a sempre em mente a <uest7o de seguran6a <uando a9aliar tcnicas diferentes de programa67o.

GE)o programa anterior; 9erifi<ue <ue nada impede <ue 9oc@ acesse diretamente os 9alores de : ; y e raio e os modifi<ue. Como 9oc@ pode criar um nOmero enorme de fun65es : alteraI:Dfloat aEJ mo9eIraioDfloat drEJ seria dese8>9el <ue somente essas fun65es pudessem modificar :; y e raio. ?oc@ 9er> <ue isso poss9el em encapsulamento 2.H. Por !ora; crie essas fun65es.

HE#este a fun67o membro mo9e com argumentos negati9os; e:emplo ac.mo9eDB2.W;B2.aEJ. O resultado coerenteK

PECrie uma no9a struct <ue representa um ponto; <ue informa65es 9oc@ precisa armaAenarK Fue fun65es seriam Oteis K a6a um programa para testar sua classe.

aEMel!ore a classe contador; defina uma fun67o <ue imprime o contador na tela. 0e 9oc@ esti9esse faAendo um programa para rodar numa interface gr>fica com o usu>rio esta fun67o de imprimir na tela seria a mesmaK Definir uma fun67o <ue retorna uma copia do 9alor atual do contador garante maior portabilidadeK Por <u@K Para aprender a retornar 9alores consulte: 2.G.H.

4E'b> uma tend@ncia em definir o maior nOmero de fun65es membro em uma classe; por<ue nunca se pode pre9er e:atamente o seu uso em programas futuros'. Comente esta frase; tendo em 9ista o conceito de portabilidade. ?oc@ 8> capaA de citar outras medidas <ue tornem suas classes mais port>9eisK &eia o e:erccio anterior.

2.G.H. $),\+0 M+M."O F$+ "+#O")AM ?A&O"+0. At agora sC tn!amos 9isto fun65es membro com 9alor de retorno igual a 9oid. $ma fun67o membro; assim como uma fun67o comum; pode retornar <ual<uer tipo; inclusi9e os definidos pelo usu>rio. 0endo assim; sua c!amada no programa se aplica a <ual<uer lugar onde se espera um tipo igual ou e<ui9alente ao tipo do seu 9alor de retorno; se8a numa lista de argumentos de outra fun67o ; numa atribui67o ou num operador como o cout LL 9aria9elJ

13

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

struct contador SSconta ocorrencias de algo T int numJ SSnumero; posicao do contador 9oid incrementaD9oidETnumVnum(2JUJ SSincrementa contador 9oid comecaD9oidETnumVWJUJ SScomeca a contar; 'reset' int retornaInumD9oidE Treturn numJUJ UJ

9oid mainDE SSteste do contador T contador umcontadorJ umcontador.comecaDEJ SSnao es<ueca dos parenteses; e uma funcao membro nao dado] cout LL umcontador.retornaInumDE LL endlJ umcontador.incrementaDEJ cout LL umcontador.retornaInumDE LL endlJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: W 2 14

2.G.P. $),\+0 D+C&A"ADA0 +X#+")A0 A C&A00+ ; $),\+0 M+M."O CbAMAMA)DO $),\+0 M+M."O. +ste e:emplo apresenta a implementa67o; defini67o; das fun65es fora da declara67o da struct. Alm disso introduA uma no9a fun67o c!amada 'inicialiAa' e fun65es float retornaIraioD9oidEJ e 9oid alteraIraioDfloat aE. %nicialiAa coloca o ponto nas coordenadas passadas como seus argumentos. %ntroduAimos esta fun67o membro a<ui para preparar a e:plica67o sobre construtores dada no prC:imo e:emplo: 2.G.4.

Coment>rios: +m uma declara67o de uma classe normalmente se coloca a declara67o das fun65es membro depois da declara67o dos atributos; porm podemos faAer intercala65es ou adotar <ual<uer ordem <ue nos con9en!a. O programador n7o obrigado a implementar as fun65es membro dentro da declara67o da classe; basta definiBlas e apresentar a implementa67o em separado segundo a sinta:e Dcompil>9elE descrita a seguir: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

struct teste T int :J 9oid alteraI:Dint 9EJ SSsomente definicao implementacao 9em depois; fora da classe UJ

9oid teste::alteraI:Dint 9E T :V9JU SSesta 8a e a implementacao codigo 9oid mainDE T teste aJ SSinstaciacao de um ob8eto a.alteraI:D2WEJ SSc!amada da funcao membro com 9alor 2W <ue sera impresso a seguir cout LL a.:J SSimprimindo o dado membro

15

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa anterior: 2W

Programa e:emplo crculo; mais comple:o baseado no e:emplo de 2.G.G: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M SSpara cout

struct circulo T float raioJ float :J float yJ

9oid inicialiAaDfloat a:;float by;float crEJ 9oid alteraIraioDfloat aEJ float retornaIraioD9oidEJ 9oid mo9eDfloat d:;float dyEJ 9oid mostraD9oidEJ

UJ

9oid circulo::inicialiAaDfloat a:;float by;float crE T :Va:J yVbyJ raioVcrJ 16

9oid circulo::alteraIraioDfloat aE T raioVaJ U

float circulo::retornaIraioD9oidE T return raioJ U

9oid circulo::mo9eDfloat d:;float dyE T :(Vd:J y(VdyJ U

9oid circulo::mostraD9oidE T cout LL '"aio:'LL retornaIraioDE LLendlJ cout LL 'X:'LL: LL endlJ cout LL 'Z:' LLyLL endlJ U

9oid mainDE T circulo acJ ac.inicialiAaDW.W;W.W;2W.WEJ

17

ac.mostraDEJ ac.mo9eD2.W;2.WEJ ac.mostraDEJ ac.:V2WW.WJ ac.alteraIraioD2G.WEJ ac.mostraDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Coment>rios: Obser9e <ue a fun67o membro mostra c!ama a fun67o membro float retornaIraioD9oidE <ue da mesma classe. ica implcito da defini67o de mostra <ue retornaIraioDE se aplica ao mesmo ob8eto instanciado <ue recebeu a c!amada de mostra; ou se8a; n7o necess>rio usar o . na c!amada de retornaIraioDE. +m programas maiores; c!amadas anin!adas de fun65es membro s7o bastante comuns.

Programa67o orientada a ob8etos e interfaces gr>ficas com o usu>rio: +:istem 'libraries' de classes <ue permitem o programador C(( desen9ol9er aplica65es para ambientes como o Microsoft cindodsreg. de uma maneira bastante abstrata; este um e:emplo claro de reuso de cCdigo; afinal o programador n7o precisa saber de detal!es da interface para programar nela.

"esultado do programa: "aio:2W X:W Z:W "aio:2W X:2 Z:2 "aio:2G.W X:2WW.W Z:2

+:erccios: 2E%mplemente outras fun65es do estilo 9oid alteraIraioDfloat aE e float retornaIraioD9oidE para os atributos X e Z. 18

GE a6a um programa simples para testar uma struct <ue representa um mouse e <ue contm a posi67o na tela; os indicadores de estado dos bot5es e os fun67o membros: clicaIbotaoAD9oidEJ mo9eDfloat d:; float dyEJ. )7o preciso faAer a liga67o da struct com a entrada serial; embora o leitor interessado possa encontrar na literatura de C e:emplos de como faA@Blo; esta uma tarefa complicada. 0eu mouse de9e ser capaA de camin!ar para <ual<uer lugar da tela atra9s de c!amadas de fun65es membro; n7o de9e ultrapassar os limites estabelecidos; e de9e indicar se os bot5es est7o pressionados ou n7o atra9s de uma fun67o semel!ante a fun67o mostraD E deste e:emplo. O mouse pode ter de 2 a H bot5es. + 9oc@ pode substituir a fun67o membro mo9eDfloat d:;float dyE por mo9eI:Dfloat d:EJ e mo9eIyDfloat dyEJ

2.G.a. A&*O PA"+C%DO +M $MA &%)*$A*+M P"OC+D$"A& +ste tCpico apresenta uma compara67o entre C(( e Pascal; para tal implementouBse dois programas semel!antes. O programa C(( o programa crculo do tCpico anterior: 2.G.P. O programa em Pascal 9em a seguir: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

P"O*"AM ComparacaoJ TCOMPA"ACAO COM $M P"O*"AMA C((U

#ZP+ CirculoV"+CO"D ::realJ TCOO"D+)ADA0 X + ZU y:realJ r:realJ Tsomente dadosU +)DJ

9ar ac:circuloJ leitura:integerJ

P"OC+D$"+ %nicialiAaD9ar altereme:CirculoJa:;by;cr:realEJ TCO&OCA O C%"C$&O +M D+#+"M%)ADA PO0%CAOU .+*%) altereme.::Va:J

19

altereme.y:VbyJ altereme.r:VcrJ +)DJ

P"OC+D$"+ AlteraI"aioD9ar altereme:CirculoJar:realEJ TA&#+"A O "A%O DO C%"C$&OU .+*%) altereme.r:VarJ +)DJ

$)C#%O) "etornaI"aioDcopieme:CirculoE:realJ .+*%) "etornaI"aio:Vcopieme.rJ +)DJ

P"OC+D$"+ Mo9eD9ar altereme:CirculoJd:;dy:realEJ TMOD+ A0 COO"D+)ADA0 X + Z AC"+0C+)#A)DO DX + DZU .+*%) altereme.::Valtereme.:(d:J altereme.y:Valtereme.y(dyJ +)DJ

P"OC+D$"+ MostraDcopieme:CirculoEJ TMO0#"A O C%"C$&O )A #+&AU .+*%) dritelnD[X:[;copieme.:;[ Z:[;copieme.y;[ ":[;copieme.rEJ +)DJ

.+*%) T#+0#+0U %nicialiAaDac;W.W;W.W;2W.WEJ 20

MostraDacEJ Mo9eDac;2.W;2.WEJ MostraDacEJ ac.::V2WW.WJ AlteraI"aioDac;2G.WEJ MostraDacEJ readDleituraEJ +)D.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: X: W.WWWWWWWWWW+(WW Z: W.WWWWWWWWWW+(WW ": 2.WWWWWWWWWW+(W2 X: 2.WWWWWWWWWW+(WW Z: 2.WWWWWWWWWW+(WW ": 2.WWWWWWWWWW+(W2 X: 2.WWWWWWWWWW+(WG Z: 2.WWWWWWWWWW+(WW ": 2.GWWWWWWWWW+(W2

Coment>rios: C((: As classes em C(( englobam os dados membros e as fun65es membros. Para e:ecutar uma a67o sobre o ob8eto ou relati9a a este basta c!amar uma fun67o membro para este: ac.mostraDEJ A fun67o membro n7o precisa de muitos argumentos; por<ue prCpria da classe e portanto gan!a acesso aos dados membro do ob8eto para ao <ual ela foi associada: float circulo::retornaIraioD9oidE T return raioJ SSten!o acesso direto a raio. U

Pascal: +m Pascal os procedimentos e os dados s7o criados de forma separada; mesmo <ue sC ten!am sentido 8untos. A 8un67o entre os dados e procedimentos se d> atra9s de passagem de parNmetros. )o caso de uma linguagem procedural como Pascal; o <ue normalmente feito se assemel!a ao cCdigo seguinte: Mo9eDac;2.W;2.WEJ . Ac nesse caso um 'record'; mas sem fun65es membro; algo semel!ante ao struct de C Dn7o C((E. Mo9e; acessa os dados do 'record' alterando os campos. O parNmetro passado por refer@ncia e o procedimento definido a parte do registro; embora sC sir9a para aceitar argumentos do tipo Circulo e mo9er suas coordenadas.

21

0eguran6a: +m ambos programas DPascal; C((E o programador pode acessar diretamente os dados do tipo definido pelo usu>rio: ac.::V2WW.WJ DPascalE ou ac.:V2WW.WJ DC((E. ?eremos em 2.H +)CAP0$&AM+)#O maneiras de proibir em C(( este tipo de acesso direto ao dado membro; dei:ando este ser modificado somente pelas fun65es membro. %sto nos garante maior seguran6a e liberdade pois podemos permitir ou n7o o acesso para cada dado membro de acordo com nossa 9ontade.

+fici@ncia: Algum pode argumentar <ue programas <ue usam bastante c!amadas de fun65es podem se tornar pouco eficientes e <ue poderia ser mel!or acessar diretamente os dados de um tipo definido pelo usu>rio ao en9s de passar por todo o trabal!o de cCpia de argumentos; inser67o da fun67o no pil!a; etc. +m 9erdade n7o se perde muito em efici@ncia; e alm disso muitas 9eAes n7o se dese8a permitir sempre o acesso direto aos dados de um tipo definido pelo usu>rio por raA5es de seguran6a. )esse sentido C(( oferece um recurso <ue permite gan!os em seguran6a sem perder muito em efici@ncia; 9e8a: 2.a.G.

+:erccios: 2E?erifi<ue <ue em mainDE 9oc@ pode modificar o atributo : do ob8eto da classe ponto ou crculo da seguinte forma: a.:V2G.GJ . %sto pode n7o ser muito Otil; imagineBse criando uma library <ue implementa a classe ponto e uma srie de fun65es relacionadas; por raA5es de seguran6a 9oc@ gostaria <ue o usu>rio se limitasse ao uso da interface Dfun65es membroE do ob8eto; como faA@Blo ser> e:plicado em 2.H encapsulamento. Por !ora; apenas crie fun65es <ue a8udem a e9itar este tipo de acesso direto.

2.G.4. CO)0#"$#O"+0 Construtores s7o fun65es membro especiais c!amadas pelo sistema no momento da cria67o de um ob8eto. +las n7o possuem 9alor de retorno; por<ue 9oc@ n7o pode c!amar um construtor para um ob8eto. Contrutores representam uma oportunidade de inicialiAar de forma organiAada os ob8etos; imagine se 9oc@ es<uece de inicialiAar corretamente ou o faA duas 9eAes; etc. $m construtor tem sempre o mesmo nome da classe e n7o pode ser c!amado pelo usu>rio desta. Para uma classe string o construtor teria a forma stringDc!ar^ aEJ com o argumento c!ar^ especificado pelo programador. +le seria c!amado automaticamente no momento da cria67o; declara67o de uma string: string aD'#e:to'EJ SSalocacao estatica implica na c!amada do construtor a.mostraDEJ SSc!amada de metodos estatica. +:istem 9aria65es sobre o tema <ue 9eremos mais tarde: 0obrecarga de construtor; 'copy constructor'; como conseguir construtores 9irtuais Da9an6ado; n7o apresentado neste te:toE ; construtor de corpo 9aAio.

O e:emplo a seguir simples; semel!ante aos anteriores; preste aten67o na fun67o membro com o mesmo nome <ue a classe DstructE ; este o construtor: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

22

Rinclude Liostream.!M

struct ponto T float :J float yJ public:

pontoDfloat a;float bEJ SSesse e o contrutor; note a ausencia do 9alor de retorno

9oid mostraD9oidEJ

9oid mo9eDfloat d:;float dyEJ

UJ

ponto::pontoDfloat a;float bE SSconstrutor tem sempre o nome da classe. T :VaJ SSincialiAando atributos da classe yVbJ SScolocando a casa em ordem U

9oid ponto::mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

9oid ponto::mo9eDfloat d:;float dyE T

23

:(Vd:J y(VdyJ U

9oid mainDE T ponto apDW.W;W.WEJ ap.mostraDEJ ap.mo9eD2.W;2.WEJ ap.mostraDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: X:W ; Z:W X:2 ; Z:2

Coment>rios: Dei:aremos para nos aprofundarmos em aloca67o dinNmica e construtores em 2.a.H. Por !ora 9oc@ pode se ater ao uso est>tico de ob8etos. )ote <ue com a defini67o do construtor; 9oc@ obrigado a passar os argumentos deste no momento da cria67o do ob8eto. 0e 9oc@ precisa ter a op67o de n7o passar esses 9alores; as poss9eis solu65es ser7o dadas em H.

+:erccios: 2E?oc@ sabia <ue uma fun67o membro pode c!amar outra fun67o membroK Parta do e:emplo de 2.G.P e crie um construtor <ue c!ama a antiga fun67o inicialiAaDfloat a;float bE passando os argumentos do construtor: pontoDfloat a; float bE T inicialiAaDa;bEJ U )a c!amada de inicialiAaDEfica implcito <ue ela se aplica ao ob8eto cu8o construtor foi c!amado. %sto 9>lido tambm para outras fun65es membro <ue c!amam fun65es membro; ou se8a; n7o necess>rio o operador identificador.inicialiAaDa;bEJ ; 9e8a 2.G.H. +ste e:erccio Otil para mostrar outro recurso de C((; o ponteiro t!is. #!is uma pala9ra reser9ada e dentro de <ual<uer fun67o membro t!is um ponteiro para o ob8eto em <uest7o; ent7o o cCdigo descrito acima poderia tambm assumir a seguinte forma e<ui9alente: 24

pontoDfloat a; float bE T t!isBMinicialiAaDa;bEJ U SS?erifi<ue] = lCgico <ue neste e:emplo t!is n7o tem muita utilidade; mas e:istem casos onde um ob8eto precisa passar seu ponteiro para alguma fun67o <ue o modifica; ou fica possuindo uma refer@ncia para ele; ent7o usaBse t!is. ?eremos outras aplica65es mais adiante.

GE %ntroduAa mensagens no construtor tipo: cout LL 'Ob8eto instanciado.'J introduAa tambm trec!os no seu programa parecidos com: cin MM aJ ; sC para <ue o programa n7o rode todo de uma 9eA; rapidamente. O ob8eti9o acompan!ar 9isualmente a se<`@ncia de cria67o e modifica67o dos ob8etos.

HECrie uma classe reta <ue tem como atributos dois ob8etos da classe ponto. Dica: )7o use construtores; use fun65es do tipo inicialiAaDE; 8> apresentadas. Fuando seu programa ficar pronto acrescente fun67o membros para esta reta tais como inclina67o; coeficiente linear; etc. Para acrescentar construtores leia 2.G.e. +:istem maneiras mais eficientes e compactas de representar uma reta; porm fa6a como foi sugerido; neste caso o ob8eti9o n7o efici@ncia.

2.G.e. CO)0#"$#O"+0 + A*"+*A,-O O programa e:emplo deste tCpico cria uma classe reta com dois dados membro da classe ponto este e:emplo o resultado do e:erccio anterior; com um recurso a mais de C((. C(( permite <ue no construtor da classe reta; 9oc@ c!ame os construtores dos atributos da classe ponto; se 9oc@ n7o o fiAer o compilador acusar> um erro; pois os atributos ponto possuem construtores e eles precisam ser c!amados para <ue a inicialiAa67o se complete de modo correto para o con8unto. Obser9e o cCdigo do construtor da classe reta usado no e:emplo:

retaDfloat :2;float y2;float :G;float yGE:p2D:2;y2E;pGD:G;yGE T SSnada mais a faAer; os construtores de p2 e pG 8a foram c!amados U

p2D:2;y2E e pGD:G;yGE s7o as c!amadas dos construtores da classe ponto; elas de9em ficar fora do corpo TU do construtor; nesta lista separada por 9rgulas 9oc@ de9e inicialiAar todos os atributos. Os tipos b>sicos como int; float; etc podem ser inicialiAados nessa lista.

Por e:emplo se a classe reta ti9esse um atributo inteiro de nome identifica67o; a lista poderia ser da seguinte forma:

retaDfloat :2;float y2;float :G;float yGE:p2D:2;y2E;pGD:G;yGE;identificacaoD2WE T SSnada mais a faAer; os construtores de p2 e pG 8a foram c!amados U 25

seria como se identifica67o ti9esse um construtor <ue tem como argumento seu 9alor.

ou

retaDfloat :2;float y2;float :G;float yGE:p2D:2;y2E;pGD:G;yGE T identificacaoV2WJ SStambem pode; por<ue tipos b>sicos DintE em C(( n7o s7o ob8etos SS portanto nao tem construtores U

$ma outra alternati9a seria usar aloca67o dinNmica para os atributos pontos <ue passariam a ser agora ponteiros para pontos; dei:aremos para discutir este tCpico mais tarde em 2.a.H; mas saiba <ue nesse caso o construtor da classe reta n7o precisaria criar os pontos.

?amos ao e:emplo; <ue no9amente semel!ante aos anteriores; para <ue o leitor preste aten67o somente nas mudan6as; <ue s7o os conceitos no9os; sem ter <ue se esfor6ar muito para entender o programa: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

struct ponto T float :J float yJ SScoordenadas

pontoDfloat a;float bE T :VaJ yVbJ U 26

SSconstrutor

9oid mo9eDfloat d:;float dyE T :(Vd:J y(VdyJ U SSfuncao membro comum

9oid inicialiAaDfloat a;float bE T :VaJ yVbJ U

9oid mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

UJ

struct reta T ponto p2J ponto pGJ retaDfloat :2;float y2;float :G;float yGE:p2D:2;y2E;pGD:G;yGE T SSnada mais a faAer; os contrutores de p2 e pG 8a foram c!amados U

9oid mostraD9oidEJ UJ

9oid reta::mostraD9oidE T p2.mostraDEJ pG.mostraDEJ U

27

9oid mainDE T reta r2D2.W;2.W;2W.W;2W.WEJ SSinstanciacao da reta r2 r2.mostraDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: X:2 ; Z:2 X:2W ; Z:2W

+:erccios: 2E %mplemente um programa <ue use a mesma lCgica do e:emplo anterior para criar uma classe composta de outras . ?oc@ estar> usando agrega67o. Por e:emplo um triNngulo precisa de tr@s pontos para ser definido.

GE$ma implementa67o mais eficiente da classe reta seria feita armaAenando apenas um coeficiente angular e um linear; mas esta reta de9eria ent7o pro9er um construtor <ue aceitasse dois pontos como argumentos. Como 9oc@ n7o aprendeu sobrecarga de construtores Ddefinir 9>rios construtoresE; use sC um construtor <ue tem coeficiente angular e linear como argumentos e implemente esta no9a classe reta sem usar agrega67o agora.

HEDefina uma fun67o membro para a classe reta <ue retorna o ponto de intercess7o com outra reta: ponto reta::intercessaoDreta aEJ. )7o se es<ue6a de tratar os casos degenerados; tais como retas paralelas e coincidentes; use por e:emplo mensagens de erro. ?erifi<ue <ue uma fun67o membro de uma reta recebe outra reta Dmesmo tipoE como argumento. Dentro da fun67o membro os dados membro do argumento a de9em ser acessados do seguinte modo: a.p2.:J Mais tarde; em P.a tratamento de e:ce65es; 9eremos maneiras mel!ores de lidar com esses casos degenerados.

PEDefina uma fun67o membro c!amada mo9e para a classe reta; lembreBse de mo9er os dois pontos 8untos Da inclina67o n7o de9e mudarE.

4EDefina uma fun67o membro 9oid giraDtipo: anguloEJ para a classe reta. +sta fun67o membro recebe um 28

Nngulo como argumento; 9oc@ pode optar por representar o Nngulo em radianos DfloatE ou criar a classe Nngulo Dgraus; minutos; segundosE. "esol9a tambm o problema da escol!a do ponto em torno do <ual a reta de9e ser girada. $se fun65es matem>ticas Dseno cossenoE da library Lmat!.!M.

2.G.Q. D+0#"$#O"+0. An>logos aos construtores; os destrutores tambm s7o fun65es membro c!amadas pelo sistema; sC <ue elas s7o c!amadas <uando o ob8eto sai de escopo ou em aloca67o dinNmica; tem seu ponteiro desalocado; ambas Dconstrutor e destrutorE n7o possuem 9alor de retorno. ?oc@ n7o pode c!amar o destrutor; o <ue 9oc@ faA fornecer ao compilador o cCdigo a ser e:ecutado <uando o ob8eto destrudo; apagado. Ao contr>rio dos construtores; os destrutores n7o tem argumentos. Os destrutores s7o muito Oteis para 'limpar a casa' <uando um ob8eto dei:a de ser usado; no escopo de uma fun67o em <ue foi criado; ou mesmo num bloco de cCdigo. Fuando usados em con8unto com aloca67o dinNmica eles fornecem uma maneira muito pr>tica e segura de organiAar o uso do '!eap'. A importNncia dos destrutores em C(( aumentada pela aus@ncia de 'garbage collection' ou coleta autom>tica de li:o. A sinta:e do destrutor simples; ele tambm tem o mesmo nome da classe sC <ue precedido por f ; ele n7o possui 9alor de retorno e seu argumento 9oid sempre:

fnomedaclasseD9oidE T S^ Codigo do destrutor ^S U

O e:emplo a seguir simples; por<ue mel!orias e e:tens5es sobre o tema destrutores ser7o apresentadas ao longo do te:to: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSdestrutor de uma classe Rinclude Liostream.!M

struct contadorT int numJ contadorDint nE TnumVnJU SSconstrutor 9oid incrementaD9oidE Tnum(V2JU SSfuncao membro comum; pode ser c!amada pelo usuario fcontadorD9oidE Tcout LL 'Contador destruido; 9alor:' LL num LLendlJU SSdestrutor UJ

29

9oid mainDE T contador minutosDWEJ minutos.incrementaDEJ cout LL minutos.num LL endlJ T SSinicio de no9o bloco de codigo contador segundosD2WEJ segundos.incrementaDEJ cout LL segundos.num LLendlJ SSfim de no9o bloco de codigo U minutos.incrementaDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: 2 22 Contador destruido; 9alor:22 Contador destruido; 9alor:G

Coment>rios: )o escopo de main criado o contador minutos com 9alor inicialVVW. Minutos incrementado; agora minutos.numVV2. O 9alor de num em minutos impresso na tela. $m no9o bloco de cCdigo criado. 0egundos criado; instanciado como uma 9ari>9el deste bloco de cCdigo; o 9alor inicial de segundos 2W; para n7o confundir com o ob8eto 8> criado. 0egundos incrementado atingindo o 9alor 22. O 9alor de segundos impresso na tela. 30

inaliAamos o bloco de cCdigo em <ue foi criado segundos; agora ele sai de escopo; apagado; mas antes o sistema c!ama automaticamente o destrutor. ?oltando ao bloco de cCdigo de mainDE; minutos no9amente incrementado. inaliAamos mainDE; agora; todas as 9ari>9eis declaradas em mainDEsaem de escopo; mas antes o sistema c!ama os destrutores da<uelas <ue os possuem. 2.H. +)CAP0$&AM+)#O COM 'C&A00' +ncapsulamento; 'data !iding'. )este tCpico 9amos falar das maneiras de restringir o acesso as declara65es de uma classe; isto feito em C(( atra9s do uso das pala9ras reser9adas public; pri9ate e protected. riends tambm restringe o acesso a uma classe e apresentado em P.2. Considera65es sobre C((:CO)0%D+"A,\+0 C((:2.a; apresenta tambm um recurso de C(( para declarar ob8etos constantes e proteger argumentos de c!amadas de mtodos <ue possam modific>Blos; usando const 2.a.2. )7o mais apresentaremos e:emplos de classes declaradas com struct. #udo <ue foi feito at agora pode ser feito com a pala9ra class ao en9s de struct; incluindo pe<uenas modifica65es. Mas por<ue usar sC class nesse tutorialK A diferen6a <ue os dados membro e fun65es membro de uma struct s7o acess9eis por 'default' fora da struct en<uanto <ue os atributos e mtodos de uma classe n7o s7o; acess9eis fora dela DmainE por 'default'. ?oc@ nem de9e ter se preocupado com isso por<ue usando struct da forma como us>9amos; tudo fica9a acess9el. +nt7o como controlar o acesso de atributos e mtodos em uma classeK 0imples; atra9s das pala9ras reser9adas pri9ate; public e protected. Protected ser> e:plicada em G.2 pois est> relacionada com !eran6a; por !ora 9amos focaliAar nossa aten67o em pri9ate e public <ue <ualificam os dados membro e fun65es membro de uma classe <uanto ao tipo de acesso Donde eles s7o 9is9eisE . Public; pri9ate e protected podem ser 9istos como <ualificadores; 'specifiers'.

Para facilitar a e:plica67o supon!a a seguintes declara65es e<ui9alentes de classes: 2E class ponto T float :J SSdados membro float yJ

public: SS<ualificador 9oid inicialiAaDfloat a; float bE T:VaJ yVbJUJ SSfuncao membro 9oid mo9eDfloat d:; float dyE T:(Vd:J y(VdyJ UJ

UJ

31

a declara67o 2 e<ui9ale totalmente _:

GE class ponto T pri9ate: float :J float yJ

public: SS<ualificador 9oid inicialiAaDfloat a; float bE T:VaJ yVbJUJ 9oid mo9eDfloat d:; float dyE T:(Vd:J y(VdyJ UJ

UJ

<ue e<ui9ale totalmente _:

HE struct ponto T pri9ate: SSse eu nao colocar pri9ate eu perco o encapsulamento em struct. float :J float yJ

public: SS<ualificador 9oid inicialiAaDfloat a; float bE T:VaJ yVbJUJ 9oid mo9eDfloat d:; float dyE T:(Vd:J y(VdyJ UJ

32

UJ

ica f>cil entender essas declara65es se 9oc@ pensar no seguinte: esses <ualificadores se aplicam aos mtodos e atributos <ue 9em apCs eles; se !ou9er ent7o um outro <ualificador; teremos agora um no9o tipo de acesso para os mtodos declarados posteriormente. Mas ent7o por<ue as declara65es s7o e<ui9alentesK = por<ue o <ualificador pri9ate 'default' para class; ou se8a se 9oc@ n7o especificar nada ; at <ue se insira um <ualificador; tudo o <ue for declarado numa classe pri9ate. /> em struct; o <ue default o <ualificador public. Agora 9amos entender o <ue pri9ate e o <ue public: ?amos supor <ue 9oc@ instanciou DcriouE um ob8eto do tipo ponto em seu programa:

ponto meuJ SSinstanciacao

0egundo o uso de <ual<uer uma das defini65es da classe ponto dadas acima 9oc@ n7o pode escre9er no seu programa:

meu.:Va.WJ SSerro ]

;como faAamos nos e:emplos de 2.G ; a n7o ser <ue : fosse declarado depois de public na defini67o da classe o <ue n7o ocorre a<ui. Mas 9oc@ pode escre9er :Va.WJ na implementa67o DdentroE de um mtodo por<ue en<uanto n7o for feito uso de !eran6a; por<ue uma fun67o membro tem acesso a tudo <ue de sua classe; 9e8a o programa seguinte. ?oc@ pode escre9er: meu.mo9eDa.W;a.WEJ ;por<ue sua declara67o Dmo9eE est> na parte public da classe. A<ui o leitor 8> percebe <ue podem e:istir fun65es membro pri9ate tambm; e estas sC s7o acess9eis dentro do cCdigo da classe Doutras fun65es membroE. ?isibilidade das declara65es de uma classe; fora dela e de sua !ierar<uia. ?e8a <ue sC a parte public 9is9el neste caso:

?isibilidade das declara65es de uma classe; dentro dela mesma:

+:erccios: 2E Fual das seguintes declara65es permite <ue se acesse em main somente os mtodos mo9e e inicialiAa; encapsulando todos os outros elementos da classeK Obs.: A ordem das >reas pri9ate e public pode estar 33

in9ertida com rela67o aos e:emplos anteriores.

aE struct ponto T SSse eu nao colocar pri9ate eu perco o encapsulamento em struct. float :J float yJ public: SS<ualificador 9oid inicialiAaDfloat a; float bE T:VaJ yVbJUJ 9oid mo9eDfloat d:; float dyE J T:(Vd:J y(VdyJ UJ UJ

bE class ponto T public: SS<ualificador 9oid inicialiAaDfloat a; float bE T:VaJ yVbJUJ 9oid mo9eDfloat d:; float dyE J T:(Vd:J y(VdyJ UJ pri9ate: float :J float yJ UJ

cE class ponto T public: SS<ualificador 9oid inicialiAaDfloat a; float bE T:VaJ yVbJUJ SSfuncao membro 9oid mo9eDfloat d:; float dyE J T:(Vd:J y(VdyJ UJ float :J 34

SSdados membro float yJ UJ

2.H.2. A#"%.$#O0 P"%?A#+; $),\+0 M+M."O P$.&%C Aplicando encapsulamento a classe ponto definida anteriormente. BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class ponto T pri9ate: SSnao precisaria por pri9ate; em class e default float :J SSsao ocultos por default float yJ SSsao ocultos por default public: SSda<ui em diante tudo e acessi9el.

9oid inicialiAaDfloat a;float bE T :VaJ yVbJ U SSas funcoes de uma classe podem acessar os atributos pri9ate dela mesma.

9oid mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU UJ

9oid mainDE T

35

ponto apJ SSinstanciacao ap.inicialiAaDW.W;W.WEJ SSmetodos public ap.mostraDEJ SSmetodos public U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: X:W ; Z:W

Coment>rios: +ste programa n7o dei:a 9oc@ tirar o ponto de DW;WE a n7o ser <ue se8a c!amada inicialiAa no9amente. ica claro <ue agora; encapsulando : e y precisamos de mais mtodos para <ue a classe n7o ten!a sua funcionalidade limitada. )o9amente: escre9er ap.:V2WJ em main um erro] Pois : est> <ualificada como pri9ate. &eia os e:erccios.

+:erccios: 2E %mplemente os mtodos 9oid alteraI:Dfloat aE ; float retornaI:D9oidE; 9oid mo9e Dfloat d:;float dy EJ .%mplemente outros mtodos <ue ac!ar importantes e:emplo 9oid distanciaDponto aE T return distDX;Z;a.X;a.ZEJ U; onde dist representa o con8unto de opera65es matem>ticas necess>rias para obter a distNncia entre DX;ZE Da.X;a.ZE. ?oc@ pro9a9elmente usar> a funcao s<rDE da 'library' Lmat!.!M <ue define a raiA <uadrada de um float. ?e8a <ue no mtodo distancia; podemos acessar os dados membro X e Z do argumento a; isto permitido por<ue distancia uma fun67o membro da mesma classe de a; embora n7o do mesmo ob8eto; uma maneira de pro9er este tipo de acesso para outras classes dotar a classe ponto de mtodos do tipo float retornaI:D9oidEJ. riends P.2 um tCpico a9an6ado sobre encapsulamento <ue lida com 9isibilidade entre classes distintas. Fuando 9oc@ precisar de outras fun65es matem>ticas Dseno; cosenoE; lembreBse da 'library' Lmat!.!M; sC pes<uisar o manual do compilador ou usar a8uda sens9el ao conte:to para Lmat!.!M ou at mesmo dar uma ol!adin!a na interface dela; no diretCrio das 'libraries'; alias essa uma boa maneira de aprender sobre como implementaBlas.

GE "etorne ao incio deste tCpico e releia as defini65es e<ui9alentes de classes declaradas com struct e com class. "efa6a o programa e:emplo anterior usando struct; use encapsulamento em outros programas <ue 9oc@ implementou.

2.H.G. $M DADO M+M."O = P$.&%C +ste programa uma 9ariante do anterior; a Onica diferen6a <ue Z colocado na parte public da defini67o da classe e acessado diretamente. Alm disso fornecemos a<ui a fun67o membro mo9e; para <ue 9oc@ possa tirar o ponto do lugar.

36

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class ponto T float :J SSsao ocultos por default public: SSda<ui em diante tudo e acessi9el.

pontoDfloat a;float bEJ SSconstrutor tambem pode ser inline ou nao

9oid mostraD9oidEJ 9oid mo9eDfloat d:;float dyEJ float yJ SS^ Z nao e[ mais ocultado

UJ

ponto::pontoDfloat a;float bE T :VaJ yVbJ U 9oid ponto::mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

9oid ponto::mo9eDfloat d:;float dyE T :(Vd:J 37

y(VdyJ U

9oid mainDE T ponto apDW.W;W.WEJ ap.mostraDEJ ap.mo9eD2.W;2.WEJ ap.mostraDEJ ap.yV2WW.WJ ap.mostraDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: X:W ; Z:W X:2 ; Z:2 X:2 ; Z:2WW >rios: Obser9e <ue agora nada impede <ue 9oc@ acesse diretamente y: ap.yV2WW.W; porm ap.:V2W.WW um erro. Obser9e em <ue parte D>reaE da classe cada um desses dados membro foi declarado.

+:erccios: 2ECrie os mtodos float retornaI:D9oidE; 9oid alteraI:Dfloat aEJ <ue de9em ser9ir para retornar o 9alor armaAenado em : e para alterar o 9alor armaAenado em : respecti9amente. Crie tambm as respecti9as fun65es retorna e altera para todos os outros atributos.

2.H.H. COMP%&A)DO $M P"O*"AMA COM ?g"%O0 A"F$%?O0. Compilando um programa di9idido em 9>rios ar<ui9os. )ormalmente os programas C(( s7o di9ididos em ar<ui9os para mel!or organiAa67o e encapsulamento; porm nada impede <ue o programador fa6a seu programa em um sC ar<ui9o. O programa e:emplo da classe ponto de 2.H.2 poderia ser di9idido da seguinte forma:

38

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSAr<ui9o 2 ponto.!; definicao para a classe ponto. class ponto T public: SSda<ui em diante tudo e acessi9el. 9oid inicialiAaDfloat a;float bEJ 9oid mostraD9oidEJ pri9ate: float :J SSsao ocultos por default float yJ SSsao ocultos por default UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSAr<ui9o G ; ponto.cpp ; implementacao para a classe ponto. Rinclude Liostream.!M Rinclude 'ponto.!'

9oid ponto::inicialiAaDfloat a;float bE T :VaJ yVbJ U SSas funcoes de uma classe podem acessar os atributos pri9ate dela mesma.

9oid ponto::mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB 39

SSAr<ui9o H . Programa principal: princ.cpp Rinclude 'ponto.!'

9oid mainDE T ponto apJ SSinstanciacao ap.inicialiAaDW.W;W.WEJ SSmetodos public ap.mostraDEJ SSmetodos public U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Os ar<ui9os com e:tens7o .! indicam !eader files. = costume dei:ar nesses ar<ui9os somente a interface das classes e fun65es para <ue o usu>rio possa ol!>Blo; como numa 'library'. )ote <ue a parte public da classe foi colocada antes da parte pri9ate; isto por<ue normalmente essa parte da defini67o da classe <ue interessa para o leitor. )o nosso caso o Onico ar<ui9o h!eader[ D.!E <ue temos o 'ponto.!' <ue define a classe ponto. Caso as dimens5es de seu programa permitam; opte por separar cada classe em um h!eader file[; ou cada grupo de entidades Dfun65es; classesE relacionadas. O ar<ui9o G 'ponto.cpp' um ar<ui9o de implementa67o. +le tem o mesmo nome do ar<ui9o 'ponto.!' ; embora isto n7o se8a obrigatCrio. = mais organiAado ir formando pares de ar<ui9os '!eader S implementation'. +ste ar<ui9o fornece o cCdigo para as opera65es da classe ponto; da a declara67o: Rinclude 'ponto.!'. As aspas indicam <ue se trata de um ar<ui9o criado pelo usu>rio e n7o uma 'library' da linguagem como Liostream.!M; portanto o diretCrio onde se de9e encontrar o ar<ui9o diferente do diretCrio onde se encontra Liostream.!M. O ar<ui9o H 'princ.cpp' o ar<ui9o principal do programa; n7o costume relacionar seu nome com nomes de outros ar<ui9os como no caso do ar<ui9o G e o ar<ui9o 2. Obser9e <ue o ar<ui9o H tambm declara Rinclude 'ponto.!'; isto por<ue ele faA uso das dos tipos definidos em 'ponto.!' ; porm 'princ.cpp' n7o precisa declarar Rinclude Liostream.!M por<ue este n7o usa diretamente as defini65es de iostream em nen!um momento; caso 'princ.cpp' o fiAesse; o include LiostreamM seria necess>rio. O leitor encontrar> em alguns dos e:emplos seguintes as direti9as de compila67o. Fuando da elabora67o de uma library para ser usada por outros programadores; n7o se es<ue6a de us>Blas:

40

Rifndef M&%0#bIb Rdefine M&%0#bIb SSCodigo Rendif

Rifndef M&%0#bIb Rdefine M&%0#bIb

SSdefina a<ui seu !eader file. SSperceba <ue ')omear<.!' e escrito na direti9a como )OM+A"FIb

Rendif

+ssas direti9as ser9em para e9itar <ue um !eader file se8a includo mais de uma 9eA no mesmo pro8eto. O seu uso se d> da seguinte forma:

Diagrama sugest7o para organiAa67o de programas relati9amente simples: L iguraM

0aber compilar programas di9ididos em 9>rios ar<ui9os muito importante. %sto re<uer um certo esfor6o 41

por parte do programador; por<ue os mtodos podem 9ariar de plataforma para plataforma. Pergunte para um programador e:periente de seu grupo. 0e o seu compilador de lin!a de comando; pro9a9elmente 9oc@ poder> compilar programas di9ididos em 9>rios ar<ui9os usando maiefiles. /> se seu compilador opera num ambiente gr>fico; esta tarefa pode en9ol9er a cria67o de um pro8eto.

2.P. #%PO A.0#"A#O D+ DADO0 #ipo abstrato de dados; #AD; se preocupa em proporcionar uma abstra67o sobre uma estrutura de dados em termos de uma interface bem definida. 07o importantes os aspectos de encapsulamento; <ue mantm a integridade do ob8eto e9itando acessos inesperados; e o fato de o cCdigo estar armaAenado em um sC lugar o <ue cria um programa modific>9el; leg9el; coeso. $ma classe implementa um tipo abstrato de dados.

07o e:emplos de tipos abstratos de dados: 2E $ma >r9ore bin>ria com as opera65es usuais de inser67o; remo67o; busca ...

GE$ma representa67o para nOmeros racionais Dnumerador; denominadorE <ue possua as opera65es aritmticas b>sicas e outras de con9ers7o de tipos.

HE$ma representa67o para Nngulos na forma D*raus; Minutos; 0egundosE. #ambm com as opera65es relacionadas; bem como as opera65es para con9erter para radianos; entre outras.

#ipo abstrato de dados um conceito muito importante em programa67o orientada a ob8eto e por este moti9o logo apresentado neste tutorial. Os e:emplos seguintes s7o simples de9ido ao fato de n7o podermos usar todos os recursos C(( por raA5es did>ticas. De9ido a esta importNncia; a medida em <ue formos introduAindo no9os recursos e:emplificaremos tambm com aplica65es na implementa67o tipos abstratos de dados. 2.P.2. #AD "A,-O #ipo abstrato de dados fra67o. .aseado no conceito de nOmero racional do campo da matem>tica. Algumas opera65es n7o foram implementadas por serem semel!antes _s e:istentes. O e:emplo mais completo se encontra em P.2.G. Por !ora n7o podemos faAer uso de recursos a9an6ados como sobrecarga de operador e templates.

"esumo das opera65es matem>ticas en9ol9idas:

0implifica67o de fra67o: DaSbEVD DaSmdcDa;bEE S DbSmdcDa;bEE E Onde mdcDa;bE retorna o m>:imo di9isor comum de ab.

0oma de fra67o: DaSbE(DcSdEVD Da.d(c.bE S b.d E simplificada.

42

Multiplica67o de fra67o: DaSbE ^ DcSdEV D Da^cE S Db^dE E simplificada.

%gualdade: DaSbEVV DcSdE se a^d VV b^c.

)7o igualdade: DaSbE ]V DcSdE se a^d b^c

Maior ou igual <ue: DaSbEDcSdE se a^d b^c

#Cpicos abordados: Construtores em geral; destrutores; tipo long; criando mtodos de con9ers7o de tipos; mtodos c!amando mtodos do mesmo ob8eto; operador j <ue retorna o resto da di9is7o de dois inteiros.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file para o #AD fracao. SS ile easyfra.!

long mdcDlong n;long dEJ SSma:imo di9isor comum metodo de +uclides.

class fracao T pri9ate: long numJ SSnumerador long denJ SSdenominador public: fracaoDlong t;long mEJ SSconstrutor comum 9oid simplificaD9oidEJ

43

SSdi9isao pelo mdc ffracaoDE T S^ nao faA nada^S U SS)ao e preciso faAer nada.

SSoperacoes matematicas basicas fracao soma Dfracao 8EJ fracao multiplicacaoDfracao 8EJ

SSoperacoes de comparacao int igualDfracao tEJ int diferenteDfracao tEJ int maiorouigualDfracao tEJ

SSoperacoes de input output 9oid mostraD9oidEJ SSe:ibe fracao no 9ideo 9oid criaD9oidEJ SSpergunta ao usuario o 9alor da fracao

SSoperacoes de con9ersao de tipos double con9ertedblD9oidEJ SScon9erte para double long con9ertelngD9oidEJ SScon9erte para long UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementacao para a classe fracao. Rinclude Liostream.!M

44

Rinclude 'easyfra.!'

long mdcDlong n;long dE SSma:imo di9isor comum SSmetodo de +uclides (B HWW anos AC. T if DnLWE nVBnJ if DdLWE dVBdJ d!ile Dd]VWE T long rVn j dJ SSjVMODV"esto da di9isao inteira. nVdJ dVrJ U return nJ U

9oid fracao::simplificaD9oidE T long commdJ commdVmdcDnum;denEJ SSdi9isor comum numVnumScommdJ denVdenScommdJ if DdenLWE T denVBdenJ numVBnumJUJ SSmo9e sinal para cima U

fracao::fracaoDlong t;long mE T numVDtEJ 45

denVDmEJ simplificaDEJ SSc!amada para o mesmo ob8eto. U

fracao fracao::somaDfracao 8E T fracao gDDnum^8.denE(D8.num^denE;den^8.denEJ return gJ U fracao fracao::multiplicacaoDfracao 8E T fracao gDnum^8.num;den^8.denEJ return gJ U

int fracao::igualDfracao tE T return DDnum^t.denEVVDden^t.numEEJ SSfunciona bem mesmo para nao simplificada U

int fracao::diferenteDfracao tE T return DDnum^t.denE]VDden^t.numEEJ U

int fracao::maiorouigualDfracao tE T return DDnum^t.denEMVDt.num^denEEJ U

46

9oid fracao::mostraD9oidE T cout LL 'D' LL num LL 'S' LL den LL 'E'J U

9oid fracao::criaD9oidE T cout LL ')umerador:'J cin MM numJ cout LL 'Denominador:'J cin MM denJ simplificaDEJ U

double fracao::con9ertedblD9oidE T double dblJ dblVDdoubleDnumESdoubleDdenEEJ return dblJ U

SScon9ersao para long long fracao::con9ertelngD9oidE T long lngJ lngVnumSdenJ return lngJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

47

Rinclude Liostream.!M Rinclude 'easyfra.!' SSnossa definicao da classe Rinclude Lstdio.!M mainDE T fracao aDW;2E;bDW;2EJ cout LL ' +ntre com fracao a: 'J a.criaDEJ a.mostraDEJ cout LL ' +ntre com fracao b: 'J b.criaDEJ b.mostraDEJ fracao cDa.somaDbEEJ SScDa(bE cout LL endl LL 'c de a(b:'J c.mostraDEJ cout LL endl LL 'a^b'J cVa.multiplicacaoDbEJ c.mostraDEJ cout LL endl LL 'a(b'J cVa.somaDbEJ c.mostraDEJ cout LL endl LL 'aMVb'J cout LL a.maiorouigualDbEJ cout LL endl LL 'aVVb'J cout LL a.igualDbEJ cout LL endl LL 'a]Vb'J cout LL a.diferenteDbEJ cout LL endl LL 'longDaE 'J

48

cout LL a.con9ertelngDEJ cout LL endl LL 'doubleDaE 'J cout LL a.con9ertedblDEJ return WJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Coment>rios: Obser9e o seguinte cCdigo usado no programa: fracao cDa.somaDbEEJ. O resultado de a.somaDbE uma fra67o; mas n7o criamos um construtor <ue recebe uma fra67o como argumento; como isso foi poss9el no programaK 0imples; a linguagem oferece para as classes <ue 9oc@ cria a cCpia bit a bit. Cuidado com o uso dessa cCpia em con8unto com aloca67o dinNmica; ob8etos poder7o ter cCpias iguais de ponteiros; ou se8a compartil!ar uso de posi65es na memCria. De <ual<uer forma; em W e:plicaremos como redefinir esta cCpia de modo a e9itar situa65es indese8>9eis como a cCpia de ponteiros e em 2.a.H e:plicaremos mel!or os perigos de usar este tipo de cCpia em con8unto com aloca67o dinNmica.

"esultado do programa: +ntre com fracao a: )umerador:P Denominador:G DGS2E +ntre com fracao b: )umerador:a Denominador:H DaSHE c de a(b:D22SHE a^bD2WSHE a(bD22SHE aMVb2 aVVbW a]Vb2 longDaE G doubleDaE G

+:erccios: 49

2E Modifi<ue o tipo fra67o para aceitar as seguintes fun65es membro.

long retornaInumD9oidE Treturn numJU long alteraIdenDfloat aE T denVaJU

Considerando <ue os atributos declarados em pri9ate n7o s7o acess9eis fora da classe; descre9a a utilidade dessas fun65es. +les s7o Oteis se usadas pelas prCprias fun65es membro de fra67oK

^GE %mplemente o tipo abstrato de dados nOmero comple:o com as opera65es matem>ticas inerentes. a6a antes um pro8eto das fun65es membro <ue ser7o implementadas descre9endo tambm as opera65es matem>ticas necess>rias.

^HE Outro tipo abstrato de dados e:tremamente Otil o tipo abstrato de dados string <ue de9e fornecer: copy constructor; opera65es de compara67o D ordem le:icogr>fica E; concatena67o; substring ; entre outras. %mplemente este tipo abstrato de dados; tendo em mente a seguinte pergunta: '?oc@ poderia substituir um tipo fracao ou inteiro usado em uma rotina de ordenacao pela sua implementa67o de string sem faAer grandes modifica65esK'. +ssa pergunta final ser> muito importante <uando come6armos a discutir templates P.H.

PEContinue trabal!ando no #AD fra67o; implemente os mtodos restantes Dmenor <ue; subtra67oE de modo an>logo _s implementa65es fornecidas.

aEPes<uise sobre matriAes em C((. Crie um tipo abstrato de dados matriA <ue suporte atribui65es e leituras de clulas contendo elementos do tipo float. Crie outros mtodos para este tipo abstrato de dados como multiplica67o por uma constante.

2.a. CO)0%D+"A,\+0 C((: )este tCpico iremos e:plicar recursos mais particulares de C((; porm n7o menos importantes para a programa67o orientada a ob8etos na linguagem. Alguns recursos como const <ue est> relacionado com encapsulamento poder7o ser retirados deste tCpico em no9as 9ers5es do tutorial. 2.a.2. CO)0# +ste e:emplo mostra o uso de fun65es const e sua importNncia para o encapsulamento. Const pode <ualificar um parNmetro de fun67o Dassegurando <ue este n7o ser> modificadoE; uma fun67o membro Dassegurando <ue esta n7o modifica os dados membro de sua classeE; ou uma instNncia de ob8etoStipo Dassegurando <ue este n7o ser> modificado.E Os modos de <ualifica67o descritos atuam em con8unto; para assegurar <ue um ob8eto const n7o ser> modificado; C(( sC permite <ue se8am c!amados para este ob8eto fun65es membro <ualificadas como const. Const tambm um <ualificador; 'specifier'.

50

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude Lmat!.!M SSdouble s<rtDdouble :EJ de mat!.! retorna raiA <uadrada do numero SSdouble podDdouble :; double yEJ de mat!.! calcula : a potencia de y

const float k+"OVW.WJ

class ponto T pri9ate: float :J SSsao ocultos por default nao precisaria pri9ate mas e[ bom float yJ SSsao ocultos por default public: SSda<ui em diante tudo e acessi9el em main.

pontoDfloat a;float bE T :VaJ yVbJ U

9oid mostraD9oidE const Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

float distanciaDconst ponto !iE const T return floatD s<rtD 51

D podDdoubleD!i.:B:E;G.WE ( podDdoubleD!i.yByE;G.WE E E EJ SSteorema de Pitagoras U

UJ

9oid mainDE T ponto apDH.W;P.WEJ SSinstanciacao ap.mostraDEJ SSfuncoes membro public const ponto origemDk+"O;k+"OEJ SSdefino ob8eto constante origem.mostraDEJ cout LL 'Distancia da origem:' LL origem.distanciaDapEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: X:H ; Z:P

52

X:W ; Z:W Distancia da origem:a

Coment>rios: Const <ualificando instNncias de ob8etosStipos: const ponto origemDk+"O;k+"OEJ const float k+"OVW.WJ

Const <ualificando fun65es: float distanciaDconst ponto !iE constJ

Const <ualificando argumentos: float distanciaDconst ponto !iE constJ

+:erccios: 2E$se tudo o <ue 9oc@ aprendeu sobre const na classe reta; definida em CO)0#"$#O"+0 + A*"+*A,-O 2.G.e.

2.a.G. $),\+0 %)&%)+ "e<uisitos: 0aber como um programa se comporta na memCria; em termos de c!amadas de fun67o e gerenciamento da pil!a; 'staci'. O <ue s7o fun65es inline: %magine uma c!amada de uma fun67o membro 9oid alteraIraioDfloat aE da classe circulo 8> apresentada; ac.alteraIraioDaE. +sta c!amada en9ol9e a passagem de parNmetros; inser67o da fun67o na pil!a DstaciE; retorno de um 9alor D9oidE; tudo isso representa uma diminui67o da 9elocidade do programa com rela67o a um simples: ac.raioVaJ <ue nesse caso funcionaria muito bem. Ocorre <ue nCs dese8amos usar c!amadas de mtodos; 9imos inclusi9e meios de esconder; encapsular o atributo raio para <ue a Onica alternati9a para alterar seu 9alor se8a atra9s da c!amada de alteraIraioDaE. Por<ue programar desta formaK Por<ue mais seguro; mais prC:imo dos princpios de orienta67o a ob8etos. +m 9erdade POO se caracteriAa por muitas c!amadas de mtodos e uso do '!eap'; >rea de memCria usada pela aloca67o dinNmica. O <ue as fun65es declaradas como inline faAem traduAir a c!amada do mtodo em tempo de compila67o em um e<ui9alente ac.raioV2e.W. e9itando todo o contratempo descrito. +ssa tradu67o do mtodo colocada na se<u@ncia de cCdigo do programa; 9oc@ pode ter 9>rios trec!os <ue c!amariam fun65es; des9iariam o flu:o do programa at o retorno desta; con9ertidos em instru65es simples. Como des9antagem temos o aumento do taman!o do programa; 9isto <ue passar7o a e:istir 9>rias cCpias diferentes da fun67o no programa Duma para cada argumentoE ao en9s de um sC protCtipo de fun67o <ue era colocado na pil!a no momento da c!amada e ent7o tin!a os argumentos substitudos. )os programa anteriores sobre a classe crculo; se a fun67o membro mostra fosse inline !a9eria uma con9ers7o da c!amada interna Ddentro de mostraE de retornaIraioDEem simplesmente ac.raio. Pode !a9er 53

con9ers7o de 9>rias fun65es inline anin!adas; estas con9ers5es s7o seguras; por<ue s7o feitas pelo compilador. )ormalmente 9anta8oso usar inline para fun65es pe<uenas <ue n7o aumentem muito o taman!o do programa ou fun65es onde 9elocidade crucial. A<ui 9ale a con!ecida regra QW:GW; oitenta porcento do tempo do programa gasto em 9inte por cento dos mtodos. Porm o programador n7o precisa se preocupar muito com fun65es inline na fase de desen9ol9imento; este um recurso C(( para aumento de efici@ncia <ue pode muito bem ser dei:ado para o final do pro8eto. 0aiba porm <ue as diferen6as de tempo decorrentes de seu uso s7o sens9eis.

+ste e:emplo e:plora as possibilidades <ue temos para declarar fun65es membro e como declar>Blas para <ue se8am do tipo inline: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

struct ponto T float :J float yJ

9oid inicialiAaDfloat a;float bE T :VaJ yVbJ U SSApesar de nao especificado compilador tenta SSe:pandir c!amada da funcao como inline por<ue esta dentro da definicao da classe.

9oid mostraD9oidEJ SScom certeAa nao e[ inline; e:terna a classe e sem <ualificador. inline 9oid mo9eDfloat d:;float dyEJ SSe[ inline ; prototipo; definicao UJ

9oid ponto::mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

inline 9oid ponto::mo9eDfloat d:;float dyE SSimplementacao; codigo T :(Vd:J y(VdyJ

54

9oid mainDE T ponto apJ ap.inicialiAaDW.W;W.WEJ ap.mostraDEJ ap.mo9eD2.W;2.WEJ ap.mostraDEJ ap.:V2WW.WJ ap.mostraDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Coment>rios: O compilador tenta con9erter a fun67o inicialiAa em inline; embora n7o este8a especificado com a pala9ra reser9ada inline <ue isto para ser feito. +sta uma regra; sempre <ue a fun67o esti9er definida na prCpria classe DstructTUE o compilador tentar> con9ert@Bla em inline. oi dito <ue o compilador tenta por<ue isto pode 9ariar de compilador para compilador; se ele n7o consegue con9erter em inline ; de9ido a comple:idade da fun67o; 9oc@ normalmente a9isado; tendo <ue trocar o lugar da defini67o da fun67o membro. )ote <ue se a fun67o membro implementada fora da classe; tanto o protCtipo da fun67o membro; <uanto a implementa67o de9em 9ir especificados com inline para <ue a con9ers7o ocorra.

"esultado do programa: X:W ; Z:W X:2 ; Z:2 X:2WW ; Z:2

2.a.H. A&OCA,-O D%)lM%CA COM )+c + D+&+#+. )este tCpico ser7o apresentados os recursos de C(( para aloca67o dinNmica de 9ari>9eis de tipos simples e ob8etos; ou se8a; estudaremos a aloca67o de estruturas em tempo de e:ecu67o.

2.a.H.2. PO)#+%"O0; 'PO%)#+"0'

55

+ste e:emplo mostra como trabal!ar com ponteiros para 9ari>9eis de tipos prBdefinidos Dn7o definidos pelo usu>rioE usando ned e delete.

O programa a seguir cria um ponteiro para uma 9ari>9el inteira; aloca memCria para esta 9ari>9el e imprime seu 9alor. BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M 9oid mainDE T int^ aJ SSdeclara um ponteiro para endereco de 9aria9el inteira

aVned intDHEJ SSaloca memoria para o apontado por a; gra9ando neste o 9alor H

cout LL D^aE LL endl J SSimprime o 9alor do apontado por a

delete aJ SSdesaloca memoria U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: H

Diagrama das 9ari>9eis na memCria: L iguraM

56

Coment>rios: 0e a fosse uma struct ou class e ti9esse um dado membro c!amado dd; poderamos obter o 9alor de dd atra9s de D^aE.dd <ue pode ser todo abre9iado em aBMdd onde BM uma seta; ou flec!a <ue 9oc@ pode ler como 'o apontado' no9amente. Os par@nteses em D^aE.dd s7o necess>rios de9ido a preced@ncia do operador . com rela67o ao ^. +sta sinta:e abre9iada ser> bastante usada <uando alocarmos dinamicamente ob8etos.

Obser9a67o: int^ aJ aVned intDHEJ

pode ser abre9iado por:

int^ aVned intDHEJ

2.a.H.G. ?+#O"+0 C"%ADO0 +0#A#%CAM+)#+ O e:emplo a seguir aloca estaticamente; em tempo de compila67o; um 9etor de inteiros com tr@s posi65es. +m seguida; gra9amos as tr@s posi65es e as mostramos na tela: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

9oid mainDE T int amHnJ SSaloca o 9etor de taman!o H; estaticamente

amWnV2J SSatribui a posicao indice W do 9etor

am2nVGJ SSatribui G a posicao indice 2 do 9etor

57

amGnVHJ SSatribui H a posicao indice G do 9etor

cout LL amWn LL ' ' LL am2n LL ' ' LL amGn LL endlJ SSmostra o 9etor U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: 2GH

"esumo da sinta:e de 9etores: int amHnJ SScria um 9etor de inteiros a com tres posicoes; indices uteis de W ate G float bm3nJ SScria um 9etor de float b com no9e posicoes; indices uteis de W ate Q

bmQnVH.2P2a4G3aJ SSgra9a H.2P2a... na ultima posicao do 9etor b

if DbmanVVG.2eE T S^acao^SU J SSteste de igualdade

Diagrama do 9etor:

Perceba <ue a fai:a Otil do 9etor 9ai de W at DnB2E onde n o 9alor dado como taman!o do 9etor no momento de sua cria67o; no nosso caso H. )ada impede <ue 9oc@ gra9e ou leia ndices fora dessa >rea Otil; isso muito perigoso; por<ue fora dessa >rea; o <ue 9oc@ tem s7o outras 9ari>9eis de memCria e n7o o espa6o reser9ado para seu 9etor. = perfeitamente aceit>9el; embora desastroso escre9er em nosso programa amPnVHJ. O compilador calcula o endere6o de memCria da posi67o P com base na posi67o inicial do 9etor e o taman!o do tipo alocado. ApCs calculado o endere6o da posi67o P o 9alor H copiado; apagando o conteOdo anterior]

Coment>rios: )ote <ue n7o estamos usando ponteiros neste e:emplo e por isso <ue o 9etor alocado estaticamente; em tempo de compila67o; tambm por este moti9o <ue o argumento <ue 9ai no lugar do H no cCdigo int amHnJ 58

de9e ser uma e:press7o constante e n7o uma 9ari>9el.

2.a.H.H. COP%A D+ O./+#O0 COM ?+#O"+0 A&OCADO0 +0#A#%CAM+)#+. )o primeiro e:emplo do #AD fra67o 9imos <ue o compilador fornece cCpia bit a bit para ob8etos; alertamos tambm sobre o perigo de usar este tipo de cCpia em con8unto com aloca67o dinNmica. O e:emplo seguinte mostra um caso onde esta cCpia oferecida pelo compilador segura; o tCpico seguinte 2.a.H.P mostra um caso onde esta cCpia n7o segura; leia ambos para ter uma 9is7o geral do assunto: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class 9etorItres T public: int 9etmHnJ SS9etor alocado estaticamente numa classe.

9etorItresDint a;int b;int cE T 9etmWnVaJ 9etm2nVbJ 9etmGnVcJ U SSconstrutor do 9etor

9oid mostraD9oidE T cout LL 9etmWn LL ' ' LL 9etm2n LL ' ' LL 9etmGn LL endlJU SSfuncao membro para mostrar o conteudo do 9etor UJ

9oid mainDE T 9etorItres 92D2;G;HEJ SScriacao de um ob8eto 9etor.

9etorItres 9GD2a;24;2eEJ

59

SScriacao de um ob8eto 9etor.

92.mostraDEJ SSmostrando o conteudo de 92.

9G.mostraDEJ SSmostrando o conteudo de 9G.

9GV92J SSatribuindo ob8eto 92 ao ob8eto 9G.

9G.mostraDEJ SSmostrando 9G alterado.

92.9etmWnVPPJ

92.mostraDEJ SSmostrando o conteudo de 92.

9G.mostraDEJ SSmostrando o conteudo de 9G. U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 2GH 2a 24 2e 2GH PP G H 2GH

60

Coment>rios: Perceba <ue no caso de aloca67o est>tica; <uando o taman!o do 9etor con!ecido em tempo de compila67o a cCpia segura. Por cCpia segura entenda: as posi65es do 9etor s7o copiadas uma a uma e os ob8etos n7o ficam faAendo refer@ncia a um mesmo 9etor; isto pode ser 9isto no resultado do programa; <uando alteramos a cCpia de 92; 92 n7o se altera.

2.a.H.P. ?+#O"+0 C"%ADO0 D%)AM%CAM+)#+ O e:emplo a seguir an>logo ao de 2.a.H.G; mas os 9etores s7o alocados dinamicamente; ou se8a; 9oc@ determina em tempo de e:ecu67o <ual o taman!o do 9etor; Pascal n7o permite isso.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

9oid mainDE T int taman!oJ SSarmaAena o taman!o do 9etor a criar. int^ 9etJ SSponteiro para inteiro ou 9etor de inteiro ainda nao criado

cout LL '+ntre com o taman!o do 9etor a criar'J cin MM taman!oJ

9etVned intmtaman!onJ SSalocando 9etor de 'taman!o' posicoes comecando em amWn

for Dint iVWJiLtaman!oJi((E T cout LL '+ntre com o 9alor da posicao ' LL i LL ':'J cin MM 9etminJ cout LL endlJ U

61

SSloop de leitura no 9etor

for Dint 8VWJ8Ltaman!oJ8((E T cout LL 'Posicao ' LL 8 LL ':' LL 9etm8nLLendlJ U SSloop de impressao do 9etor

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB "esultado do programa: +ntre com o taman!o do 9etor a criarH +ntre com o 9alor da posicao W:2

+ntre com o 9alor da posicao 2:G

+ntre com o 9alor da posicao G:H

Posicao W:2 Posicao 2:G Posicao G:H

Coment>rios: int^ aJ

Declara um ponteiro para inteiro.

aVned intm2WnJ

62

Diferente de ned intD2WEJ os colc!etes indicam <ue para ser criado um 9etor de taman!o 2W e n7o uma 9ari>9el de 9alor 2W como em 2.a.H.2. Ao contr>rio de aloca67o est>tica; o parNmetro <ue 9ai no lugar do 9alor 2W n7o precisa ser uma e:press7o constante.

int^ aJ aVned intm2WnJ

e<ui9ale a forma abre9iada:

int^ aVned intm2WnJ

A fai:a de ndices Oteis do 9etor no9amente 9ai de W at D2WB2E ou DnB2E.

2.a.H.a. COP%A D+ O./+#O0 COM ?+#O"+0 A&OCADO0 D%)AM%CAM+)#+. +ssa determina67o do taman!o do 9etor em tempo de e:ecu67o 9ai tornar a cCpia de ob8etos feita pelo compilador diferente; ele 9ai copiar o ponteiro para o 9etor; ou se8a os ob8etos passam a compartil!ar a estrutura na memCria; o <ue nem sempre pode ser dese8>9el] +:istem maneiras de redefinir esta cCpia feita pelo compilador o <ue 9eremos em W.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class 9etorItres T public: int^ 9etJ SS9etor alocado estaticamente numa classe.

9etorItresDint a;int b;int cE T 9etVned intmHnJ 9etmWnVaJ 9etm2nVbJ 63

9etmGnVcJ U SSconstrutor do 9etor

9oid mostraD9oidE T cout LL 9etmWn LL ' ' LL 9etm2n LL ' ' LL 9etmGn LL endlJU SSfuncao membro para mostrar o conteudo do 9etor UJ

9oid mainDE T 9etorItres 92D2;G;HEJ SScriacao de um ob8eto 9etor.

9etorItres 9GD2a;24;2eEJ SScriacao de um ob8eto 9etor.

92.mostraDEJ SSmostrando o conteudo de 92.

9G.mostraDEJ SSmostrando o conteudo de 9G.

9GV92J SSatribuindo ob8eto 92 ao ob8eto 9G.

9G.mostraDEJ SSmostrando 9G alterado.

92.9etmWnVPPJ

64

92.mostraDEJ SSmostrando o conteudo de 92.

9G.mostraDEJ SSmostrando o conteudo de 9G. U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 2GH 2a 24 2e 2GH PP G H PP G H

Coment>rios: )ote <ue <uando alteramos a cCpia de 92; 92 se altera. %sto ocorre por<ue o 9etor n7o copiado casa a casa como em 2.a.H.H; sC se copia o ponteiro para a posi67o inicial do 9etor; a partir do <ual se calcula os endere6os das posi65es seguintes 9mHnVV^D9(HE.

0obre o te:to acima: 'a partir do <ual se calcula os endere6os das posi65es seguintes'; 9e8a o programa e:emplo: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

9oid mainDE T int^ 9J 9Vned intmHnJ

65

cout LL ^D9(2ELLendlJ SSimprime o li:o contido na memoria de 9m2n

cout LL 9m2n LLendlJ SSimprime o li:o contido na memoria de 9m2n

SS^D9EVV9mWn uma e:pressao sempre 9erdadeira U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 2aG 2aG

Coment>rios: O <ue importante deste e:erccio <ue sC se armaAena a posi67o inicial do 9etor; as outras posi65es s7o calculadas com base no taman!o do tipo alocado e regras de aritmtica de ponteiros. )7o podemos nos estender muito neste tema; leia sobre aritmtica de ponteiros; porm para este tutorial; basta usar os 9etores de forma <ue esta aritmtica fi<ue por conta da linguagem. ?etores alocados dinamicamente e ponteiros s7o a mesma coisa; isto pode ser 9isto nesse programa e:emplo <ue mistura a sinta:e de 9etores e de ponteiros.

2.a.H.4. #AD + A&OCA,-O D%)lM%CA. #ipo abstrato de dados 9etor.

$m dos grandes problemas de trabal!ar com 9etores comuns de C(( D int ^ aJ aVned intm2WnJ amGGnVHJ E <ue fre<`entemente lemos ndices in9>lidos; ou pior gra9amos encima deles. *ra9ar encima de um ndice fora dos limites de um 9etor um erro fre<`ente em programa67o C((. 0aiba <ue faAendo isso 9oc@ pode estar apagando instru65es de outros programas na memCria e outras informa65es importantes] +m alguns casos <uando isso ocorre obtmBse inclusi9e mensagens do sistema operacional a9isando <ue algo est> errado e <ue necess>rio reinicialiAar a m><uina.

Curiosidade: bou9e um caso de 9rus na internet <ue se basea9a no acesso a ndices fora de um 9etor para gra9ar por cima de instru65es do sistema operacional; cCdigo <ue garantisse a sua multiplica67o.

66

Algumas linguagens de programa67o como Pascal e MCdulaBH c!ecam os ndices para <ue n7o se acesse >reas in9>lidas de um 9etor. MCdulaBH fornece inclusi9e os limites dos 9etores simples da linguagem atra9s de c!amadas lastD9etorE ou firstD9etorE . +m C(( tal tipo de c!ecagem pode ser implementada pelo programador como faremos neste e:emplo.

Dica de Programa67o: &embreBse: seu sucesso em programa67o 9ai depender em muito de sua disciplina e organiAa67o ten!a sempre em mente <ue C(( uma linguagem poderosa e <ue se n7o usada corretamente pode criar transtornos e erros n7o percept9eis em testes do programa. )7o c!ecar os ndices de um 9etor em programas grandes como instalar uma bomba relCgio em seu cCdigo; muito pro9>9el <ue em algum instante 9oc@ ou at mesmo outra pessoa usando seu programa se distraia e acabe por escre9er uma rotina <ue acessa um ndice in9>lido de um 9etor; faAendo na maioria das 9eAes o programa fal!ar. A proposta deste e:emplo criar um tipo abstrato de dados 9etor com uma interface fle:9el <ue sir9a para 9>rias aplica65es e possa ser facilmente estendida. +ste e:emplo simples e 9ai ser reapresentado com muitas mel!orias no decorrer do tutorial; dentre elas: 'templates' P.H; 'e:ception !andling' P.a; e a cria67o de uma classe iterador para o 9etorP.2 . A primeira 9ista 9oc@ pode ac!ar <ue este programa n7o oferece muito mais <ue o uso comum de 9etores em C((; mas com as mel!orias <ue apresentaremos; certamente 9oc@ 9ai preferir representar 9etores como tipos abstratos de dados ou #AD[s.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSfile e:9et2.! SS!eader file para classe 9etor const int inicioVWJ

class 9etorT pri9ate: int^ 9J SSeste e[ o 9etor int taman!oJ SStaman!o ma:imo do 9etor; public: 9etor Dint tamEJ SSconstrutor; aloca memCria para o 9etor. 9oid atribuiDint inde:;int 9alorEJ SSaltera uma posicao do 9etor int conteudoDint inde:EJ

67

SSretorna conteudo de posicao do 9etor int ma:imoD9oidEJ SSretorna o maior elemento do 9etor int primeiroD9oidEJ SSprimeiro indice do 9etor int ultimoD9oidEJ SSultimo indice do 9etor f9etorDE Tdelete 9JU SSinline function ou use delete 9mnJ UJ BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SScodigo; implementacao; para o !eader file Rinclude Liostream.!M Rinclude Lstdlib.!M Rinclude 'e:9et2.!'

9etor::9etor Dint tamE T9Vned intmtamnJ taman!oVtamJU

9oid 9etor::atribuiDint inde:;int 9alorE T if Dinde:Ltaman!o oo inde:MVinicioE 9minde:nV9alorJ U

int 9etor::conteudoDint inde:E T if Dinde:MVtaman!o pp inde:LinicioE Tcerr LL ' ora dos limites'J e:itD2EJU return 9minde:nJ U

68

int 9etor::primeiroD9oidE T return inicioJU

int 9etor::ultimoD9oidE T return taman!oB2JU

int 9etor:: ma:imoD9oidE Tint candidatoVinicioJ SScandidato ao ma:imo for Dint iVinicioJiLtaman!oJi((E if D9minM9mcandidatonE candidatoViJ return 9mcandidatonJU BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSprograma pricipal Rinclude Liostream.!M Rinclude 'e:9et2.!'

mainDE T int au:J SSpara ler 9alor a atribuir 9etor meuDaEJ

for Dint iVmeu.primeiroDEJiLVmeu.ultimoDEJi((E T cout LL '+ntre com 9alor da posicao:' LL i LL 'Yn'J cin MM au:J meu.atribuiDi;au:EJ U for Dint 8Vmeu.primeiroDEJ8LVmeu.ultimoDEJ8((E coutLL meu.conteudoD8ELL ' 'J cout LLendl LL 'Ma:imo:' LL meu.ma:imoDEJ

69

return WJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Coment>rios: O mtodo f9etorDE Tdelete 9JU SSuse delete mn9Jdepende do compilador um destrutor; assim como o construtor ele n7o tem 9alor de retorno por<ue c!amado pelo sistema operacional <uando o ob8eto sai de escopo ou <uando 9oc@ desaloca memCria de um ponteiro para o ob8eto. A Onica a67o do destrutor liberar a memCria ocupada pelo atributo 9etor de inteiros Dint ^ 9E da classe 9etor. De um modo geral os destrutores ser9em para 'arrumar a casa' <uando ob8etos s7o desalocados ou saem de escopo. A sinta:e dos mtodos para dele67o de 9etores delete 9J ou delete mn9J podem 9ariar de compilador para compilador; o usu>rio de9e c!ecar <ue sinta:e seu compilador suporta. )ote <ue <uando n7o dispOn!amos do destrutor o programador era obrigado a deletar passo a passo todas as estruturas dinNmicas dos ob8etos <ue saiam de escopo; e:istem tcnicas a9an6adas para obter coleta autom>tica de li:o em C(( baseadas neste ponto.

"esultado do programa: +ntre com 9alor da posicao:W P +ntre com 9alor da posicao:2 a +ntre com 9alor da posicao:G 3 +ntre com 9alor da posicao:H G +ntre com 9alor da posicao:P 2 Pa3G2 Ma:imo:3

Dica de programa67o: 0aiba <ue uma pr>tica bastante Otil na fase de testes de um programa introduAir mensagens informati9as em pontos con9enientes. Fuando trabal!ando com ob8etos tal pr>tica pode ser usada de 9>rios modos; por e:emplo podeBse inserir uma mensagem no destrutor de uma classe para 9erificar <uando os ob8etos s7o eliminados e se s7o eliminados corretamente. 70

+:erccios: 2E )ote <ue os mtodos atribui e conteOdo apresentam estilos diferentes de lidar com ndices fora dos limites do 9etor. $m apresenta uma mensagem de erro e termina o programa. Outro simplesmente n7o e:ecuta a a67o se os parNmetros n7o esti9erem corretos. +scol!a um dos estilos e uniformiAe o programa. Fuando 9oc@ estudar 'e:ception !andling' P.a 9er> maneiras mel!ores de lidar com esses problemas.

GE %mplemente uma fun67o membro c!amada ordena para o tipo abstrato de dados 9etor definido acima. $se <ual<uer algoritmo de ordena67o.

HECrie destrutores para as classes <ue 9oc@ 8> implementou; mesmo <ue elas n7o ten!am atributos <ue usem aloca67o dinNmica. %ntroduAa mensagens tipo cout LL '*oodbye...'J nos destrutores destas classes . Como essas mensagens podem ser OteisK Defina 9>rios n9eis de blocos de cCdigo; faAendo assim com <ue ob8etos saiam de escopo em tempos diferentes e teste seus destrutores.

PEMel!ore o e:erccio anterior introduAindo um nome para o ob8eto. +ste nome de9e ir nas sadas de tela e  nome dado para o construtor como uma string Dc!ar^E. )7o es<ue6a de deletar esta string no destrutor da classe depois de imprimir a mensagem.

aECrie uma fun67o membro de nome preenc!e; <ue inicialiAa todas as posi65es de um 9etor com o 9alor de um de seus argumentos.

4EDefina um programa c!amado grandes <ue implementa o tipo abstrato de dados nOmeros grandes e inteiros; este tipo de9e usar um 9etor do tipo numrico <ue 9oc@ ac!ar con9eniente para representar os algarismos. #al9eA estudar circuitos lCgicos como somadores; etc o a8ude a implementar as <uatro opera65es matem>ticas b>sicas para estes tipo em termos de 'looi a!ead carrier' e outras tcnicas de performance para implementar as opera65es.

eE)ote <ue na aloca67o do 9etor:

9etor::9etor Dint tamE T9Vned intmtamnJ taman!oVtamJU

; n7o c!ecado se o 9alor passado tam maior <ue W; fa6a este teste.

Fuando e:plicarmos 'e:ception !andling' 9oc@ ter> mtodos mel!ores de lidar com esses erros.

2.a.H.e. A&OCA)DO O./+#O0

71

Pula; em ModulaBH 8> s7o alocados. +ste e:emplo mostra como trabal!ar com ponteiros para ob8etos; ned e delete; como alocar memCria e c!amar corretamente os construtores.

Coment>rios: Perceba <ue agora n7o estamos alocando um 9etor de inteiros com tr@s posi65es Dned intmHnE; mas um inteiro <ue contm o 9alor H. ?oc@ pode ler o cCdigo D^aE como: 'O apontado de a'. 0e a fosse uma struct ou class e ti9esse um dado membro c!amado dd; poderamos obter o 9alor de dd atra9s de D^aE.dd <ue pode ser todo abre9iado em aBMdd onde BM uma seta; ou flec!a <ue 9oc@ pode ler como 'o apontado' no9amente. Os par@nteses em D^aE.dd s7o necess>rios de9ido a preced@ncia do operador . com rela67o ao ^.

2.a.P. "+ +"q)C%A o A<ui 9ou ensinar passagem por refer@ncia; lembreBse <ue ob8etos s7o passados por refer@ncia; por<ue eles s7o refer@ncia; ponteiros. +ste tCpico 9ai e:plicar como usar o operador o; tambm c!amado de operador 'endere6o de...'. +ste operador fornece o endere6o; a posi67o na memCria de uma 9ari>9el; de um argumento; etc. 0ua utiliAa67o muito simples; se a uma 9ari>9el inteira; oa retorna um ponteiro para a.

O programa a seguir ilustra a sinta:e do operador: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

9oid mainDE T int aJ aV2WJ int^ pJ pVo aJ D^pEV2HJ cout LL aJ U

72

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

+:plicando o programa passo a passo:

int aJ

Declara uma 9ari>9el inteira com nome a.

aV2WJ

atribui 9alor 2W a 9ari>9el a.

int^ pJ

Declara um ponteiro de 9ari>9el inteira ; o nome do ponteiro p.

pVo aJ

Atribui o 'endere6o de a' ; 'o a' ao ponteiro p.

D^pEV2HJ

Atribui 2H ao 'apontado de p'; 'D^pE '; mas como p aponta para a; a passa de 9alor 2W para 9alor treAe atra9s de p. P um 'alias' para a.

cout LL aJ

%mprime o 9alor esperado <ue treAe.

O programa a seguir usa o operador 'endere6o de' para modificar argumentos; parNmetros de uma fun67o; ou se8a utiliAa passagem por refer@ncia; e<ui9alente ao ?A" de Pascal. &embreBse <ue at agora os argumentos das nossas fun65es sC eram passados por 9alor.

73

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

9oid incrementaDinto aE T a((J U SSprimeira funcao <ue usa passagem por referencia

9oid trocaDinto a;into bE T int au:VaJ aVbJ bVau:J U SSsegunda funcao <ue usa passagem por referencia

9oid mainDE T int i2V2WJ int iGVGWJ incrementaDi2EJ cout LL i2 LL endlJ trocaDi2;iGEJ cout LL i2 LL endlJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 74

22 GW

+:plicando passo a passo: As fun65es criadas no programa; s7o como dissemos; capaAes de alterar seus parNmetros; incrementa ; incrementa seu Onico parNmetro e troca; troca os dois parNmetros inteiros.

2.4. "+CAP%#$&A)DO )este tCpico apresentaremos programas <ue re9isam todos conceitos 8> 9istos e acrescentam mais alguns detal!es da linguagem.

2.4.2. A"*$M+)#O0 D+ &%)bA D+ COMA)DO.

)este tCpico 9amos apresentar um e:emplo <ue usa tudo o <ue foi aprendido at agora e introduA mais alguns outros conceitos. +ste e:emplo um 8ogo de <uebra cabe6a. Pro9a9elmente 9oc@ 8> 9iu um <uebra cabe6a deste tipo; ele c!amado <uebra cabe6a de ti8olos desliAantes. = composto de um tabuleiro DmatriAE <uadrado preenc!ido com pe6as de W at DladorGB2E onde lado a dimens7o de um lado do tabuleiro. A representa67o no programa numrica; mas normalmente esses <uebra cabe6as s7o 9endidos com desen!os pintados sobre as pecas. )o lugar onde de9eria estar a Oltima pe6a dei:aBse um espa6o 9aAio para <ue se possa mo9er as pe6as do tabuleiro. O ob8eti9o colocar todos os ti8olos em ordem; como no es<uema abai:o:

L iguraM 0olucionado]

O <ue um <uebra cabe6a tem a 9er com encapsulamentoK 0imples o 8ogador obrigado a seguir as regras do 8ogo; portanto n7o pode con!ecer todas as opera65es <ue se aplicam ao <uebra cabe6a; e tambm n7o pode acessar sua representa67o interna. ?amos 9er como isso feito usando as pala9ras reser9adas pri9ate e public ; conceitos de agrega67o e reuso de cCdigo de uma classe matriA. Alm disso usamos const para garantir a integridade da matriA do <uebraBcabe6a.

?e8a tambm <ue estamos abordando o tCpico representa67o; n7o raro 9oc@ ter> <ue modelar ob8etos <ue representem algo do mundo real como motor; <uebraBcabe6a; conta banc>ria; circuito eltrico e assim por diante. Outros ob8etos podem ser mais abstratos; e:emplo: >r9ore bin>ria.

Mais sobre as regras: ?oc@ concorda <ue dada uma situa67o onde o espa6o 9aAio se encontra no meio do <uebraBcabe6a dado como e:emplo o usu>rio sC tem P op65esK 07o elas: mo9er para cima Dfun67o membro mo9ecimaE; mo9er para bai:o ; mo9er para a es<uerda ou ent7o para a direita. )ote <ue essas fun65es membro sC trocam pe6as 75

9iAin!as; isso importante pois pro9ado matematicamente <ue algumas trocas de pe6as distantes D'Odd permutations'E podem tornar o <uebraBcabe6a insolO9el. %sto facil de ser 9erificado para um <uebra cabe6a G:G. *arantimos a solu67o do <uebraBcabe6a pelo camin!o in9erso do embaral!amento das pe6as; <ue parte do <uebraBcabe6a solucionado e aplica aleatoriamente se<u@ncias de mo9imentos iguais aos <ue o usu>rio usa para solucionar o 8ogo. A matriA bidimensional representada linearmente D9etorE e as fun65es membro de con9ers7o de ndice linear para colunas eSou lin!as e atribui65es s7o fornecidas; mas somente as necess>rias para o 8ogo .

"ecursos utiliAados: Argumentos de lin!a de comando; fun65es de con9ers7o da stdlib; representa67o linear de uma matriA; const.

Argumentos de lin!a de comando: ?oc@ pode faAer programas <ue aceitem argumentos de lin!a de comandos; resultando em algo e<ui9alente a: dir Sd SSdos format A: SSdos ou ls Bla SSuni:

+sses argumentos podem ficar dispon9eis na c!amada da fun67o main de seu programa como os parNmetros 'argument counter' e 'argument 9alues'; 9e8a trec!o de programa abai:o. 9oid mainDint argc; c!ar ^arg9mnE T...S^use arg9 e argc^S ...U

argc um inteiro arg9 um 9etor de c!ar^ contendo os argumentos passados. DSd ...E arg9 mWn o nome do programa c!amado. A fai:a Otil de arg9alues : arg9m2n...arg9margcB2n

Portanto se argcVVG; temos um Onico argumento de lin!a de comando; dispon9el como string em arg9m2n . a6a alguns testes com o mesma main usada no programa abai:o e alguns cout[s imprimindo os argumentos para entender mel!or o assunto.

Const: /> e:emplificado em 2.a.2

"epresenta67o linear de uma matriA: 76

L iguraM PodeBse representar uma matriA de <ual<uer dimens7o em um 9etor. ?e8a o e:emplo de uma matriA bidimensional de inteiros mostrada no formato indicelinear:9alor armaAenado

?antagem da representa67o linear D9etorE: para referenciar uma posi67o gastaBse somente um inteiro contra dois da representa67o matriA Dlin!a;colunaE. Podemos agora considerar posi65es <ue apontam para outras posi65es; basta interpretar o conteOdo do 9etor como um ndice linear. Des9antagem da representa67o linear D9etorE: necess>rio criar fun65es de con9ers7o de ndice na forma Dlin!a;colunaE para Dndice linearE e de Dndice linearE para DcolunaE ou Dlin!aE. ?e8a as fun65es lin e col e linear do e:emplo seguinte.

un65es de con9ers7o da 0tdlib: A fun67o int atoiDc!ar^ aE con9erte uma string para um inteiro.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Lstdlib.!M

class matriA SS<uebra cabeca de ti8olos desliAantes T pri9ate: int lin!asJ SSnumero de lin!as da matriA int colunasJ SSnumero de colunas na matriA int tamJ SSVlin!as^colunas int ^lcJ SS9etor de taman!o lin!a^colunas representando matriA:W..DtamB2E public: matriADconst int l;const int cEJ SScria matriA &:C

SS<ual<uer uma das funcoes abai:o retorna nil se nao conseguiu int^ linearDconst int lin;const int colEconst J SSind linear a partir de lin!a e coluna int^ colDconst int indlinEconst JSScoluna a partir do indice linear int^ linDconst int indlinEconst J SSlin!a a partir do indice linear

77

int trocaindlinDconst int i;const int 8EJ SSargumentos: G indices lineares SSretorna 2 conseguiu; W nao conseguiu

int atribuiindlinDconst int i;const int 9EJ SSatribui 9 ao indice i SSretorna 2 conseguiu; W nao conseguiu

int^ retornaindlinDconst int iEJ SSretorna conteudo do indice i SSretorna nil se nao conseguiu

int getlD9oidEJ SSretorna numero de lin!as int getcD9oidEJ SSretorna numero de colunas int gettD9oidEJ SSretorna taman!o V lin!as^colunas

fmatriADEJ UJ BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude 'matriA.!'

matriA::matriADconst int l;const int cE SScria matriA T lcVned intml^cnJ SSl;c dimensoes J lc 9etorml^cn lin!asVlJ colunasVcJ tamVlin!as^colunasJ U

int^ matriA::linearDconst int alin;const int acolE const SSind linear a partir de lin!a e coluna T int^ resultVned intJ SS9alor de retorno 78

if D DWLalinE oo DalinLVlin!asE oo DWLacolE oo DacolLVcolunasE E T D^resultEVDalinB2E^colunas(acolJ return resultJ U else return )$&&J U

int^ matriA::colDconst int indlinEconst SScoluna a partir do indice linear T int^ resultVned intJ if D DWLindlinE oo DindlinLVtamE E T D^resultEVDindlin j colunasEJ if DD^resultEVVWE D^resultEVcolunasJ return resultJ U else return )$&&J U int^ matriA::linDconst int indlinEconst SSlin!a a partir do indice linear T int^ resultVned intJ if D DWLindlinE oo DindlinLVtamE E T D^resultEVDintDDindlinB2E S colunasE(2EJ return resultJ U else return )$&&J 79

int matriA::trocaindlinDconst int i;const int 8E SSargumentos: G indices lineares SSretorna 2 conseguiu; W nao conseguiu T int au:J if D DWLiE oo DiLVtamE oo DWL8E oo D8LVtamE E T au:VlcmiB2nJ SSefetua a troca lcmiB2nVlcm8B2nJ SSembora para usuario a matriA 9ai de 2 ate l^c SSpara mim 9ai de o ate l^cB2 lcm8B2nVau:J return 2J SSsucesso U else return WJ SSfal!ou U

int matriA::atribuiindlinDconst int i;const int 9E SSretorna 2 conseguiu; W nao conseguiu T if D DWLiE oo DiLVtamE E T lcmiB2nV9J SSefetua a atribuicao return 2J U else return WJ SSfal!ou U

int^ matriA::retornaindlinDconst int indlinE SSretorna nil se nao conseguiu T

80

int^ resultVned intJ if D DWLindlinE oo DindlinLVtamE E T ^resultVlcmindlinB2nJ return resultJ U else return )$&&J U

int matriA::getlD9oidE SSretorna numero de lin!as T return lin!asJ U

int matriA::getcD9oidE SSretorna numero de colunas T return colunasJ U

int matriA::gettD9oidE SSretorna taman!o T return tamJ U

matriA::fmatriADE T delete lcJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS<uebra cabecas de ti8olos desliAantes 81

Rinclude Liostream.!M SSpara cin cout Rinclude Liomanip.!M SSformatar cout output com MM setdidt!DE Rinclude Lstdlib.!M SSuso randDE em embaral!a Rinclude Lstring.!M SSatoiDE para con9erter argumentos de lin!a de comando Rinclude 'matriA.!'

const int minIladoVGJ SSminimo taman!o lateral do <uebracab. const int tamIpadraoVaJ SStaman!o padrao

class <uebracab SS<uebra cabeca de ti8olos desliAantes T pri9ate:

int 9aAioJ SSindice linear da casa 9aAia int mo9J SSnumero de mo9imentos matriA^ m<cJ SSmatriA interna do <uebra cabecas

public:

<uebracabDconst int ldVtamIpadraoEJ SScria <uebra cabeca; ldVlado 9oid mostraDE constJ SSmostra <uebra cabeca

9oid mo9edirDEJ SSmo9e celula a es< de 9aAio para direita. 9oid mo9ees<DEJ SSanalogo 9oid mo9ebai:oDEJ SSanalogo 9oid mo9ecimaDEJ SSanalogo

9oid embaral!aDEJ SSembaral!a <uebracabeca int tstsolucaoDE constJ SStesta se <uebracabeca esta solucionado int retornaImo9DE T return mo9J U SSretorna numero de mo9imentos

82

f<uebracabDEJ SSdestroi <uebra cabecas UJ

<uebracab::<uebracabDconst int ldE SSargumento padrao desnessario; 8a declarado T int ldcVabsDldEJ SSld copia V 9alor positi9o de ld if DldcLminIladoE ldcVminIladoJ m<cVned matriADldc;ldcEJ SSinicialiAa ob8eto matriA forDint iV2JiLm<cBMgettDEJi((E m<cBMatribuiindlinDi;iEJ SSinitialiAa casas da matriA m<cBMatribuiindlinDm<cBMgettDE;WEJSSatribui Aero a posicao da celula 9aAia 9aAioVm<cBMgettDEJ SSdefine posicao da celula 9aAia mo9VWJ SSsem nen!um mo9imento embaral!aDEJ SSembaral!a <uebracabeca U

9oid <uebracab::mostraDE const SSmostra <uebra cabeca T int i;8J SSlin!a e coluna int^ indJ SS9alor atual forDiV2JiLVm<cBMgetlDEJi((E SSloop das lin!as T SSlin!as forD8V2J8LVm<cBMgetcDEJ8((E SSloop das colunas T SScolunas indVm<cBMlinearDi;8EJ SSresultado tambem e ponteiro if DD^indEVV9aAioE cout LL setdDPELL' 'J SS9aAioVespaco else cout LL setdDPE LL D^m<cBMretornaindlinD^indEEJ SSnao e o 9aAio; mostra conteudo U SScolunas cout LL endlJ SSmudanca de lin!a U SSlin!as 83

cout LL endlJ U

9oid <uebracab::mo9edirDE SSmo9e celula a es< de 9aAio para direita SSespaco mo9e para es<uerda T if D D^Dm<cBMcolD9aAioEEE ]V2E S^nao esta na borda es<uerda^S T m<cBMtrocaindlinD9aAio;9aAioB2EJ mo9((J 9aAioV9aAioB2J U U

9oid <uebracab::mo9ees<DE SSespaco mo9e para direita T if D D^Dm<cBMcolD9aAioEEE]Vm<cBMgetcDE E S^nao esta na borda direita^S T m<cBMtrocaindlinD9aAio;9aAio(2EJ mo9((J 9aAioV9aAio(2J U U

9oid <uebracab::mo9ebai:oDE SSespaco mo9e para cima T if DD^Dm<cBMlinD9aAioEEE]V2E S^nao esta no topo^S T m<cBMtrocaindlinD9aAio;9aAioBDm<cBMgetcDEEEJ SSc!ama funcao pri9ate mo9((J 9aAioV9aAioBDm<cBMgetcDEEJ

84

U U

9oid <uebracab::mo9ecimaDE SSespaco mo9e para bai:o T if DD^m<cBMlinD9aAioEE]Vm<cBMgetlDEE S^nao esta em bai:o^S T m<cBMtrocaindlinD9aAio;9aAio(Dm<cBMgetcDEEEJ mo9((J 9aAioV9aAio(Dm<cBMgetcDEEJ U U

9oid <uebracab::embaral!aDE SSembaral!a <uebracabeca T int i;8J SSloop principal; loop secundario int rJ SSr times forD8VWJ8Lm<cBMgettDEJ8((E T rVDrandDEj m<cBMgetcDEEJ forDiVWJiLrJi((E Tt!isBMmo9edirDEJU SSmo9e r 9eAes rVDrandDEj m<cBMgetlDEEJ forDiVWJiLrJi((E Tt!isBMmo9ebai:oDEJU rVDrandDEj m<cBMgetcDEEJ forDiVWJiLrJi((E Tt!isBMmo9ees<DEJU rVDrandDEj m<cBMgetlDEEJ forDiVWJiLrJi((E Tt!isBMmo9ecimaDEJU U mo9VWJ SSinicialiAa mo9imentos U

int <uebracab::tstsolucaoDE const SStesta se <uebracabeca esta solucionado 85

T int iV2;contV2J d!ileD cont oo DiL Dm<cBMgettDEE E E T if DD^Dm<cBMretornaindlinDiEEEVVDiEE contV2J else contVWJ i((J U return DcontEJ SSiV<ctam esta solucionado 2 G H... GP W U

<uebracab::f<uebracabDE Tif Dm<c]V)$&&E delete m<cJ cout LL ' Fuebra cabeca destruido]Yn'JU SSdestroi <uebracab

mainDint argc;c!ar ^arg9mnE SSargumentos sao declarados a<ui T SSmain int ladocompJ c!ar opcaoJ SSusada em menu como 9aria9el de opcao

if DargcM2E ladocompVatoiDarg9m2nEJ SScon9ertendo argumento de lin!a de comando para inteiro else ladocompVtamIpadraoJ SS9alor default

<uebracab a<uebracabDladocompEJ SScriando <uebracab do T a<uebracab.mostraDEJ cout LL'Yn'J SSmenu de opcoes cout LL' Mo9imentos:' LL a<uebracab.retornaImo9DELL 'Yn'J

86

cout LL' PLB 4BM QCima G.ai:o 00air +embaral!a Yn'J cout LL' "econ!ece se<uencias de comandos: G4Q4GP L+nterMYn'J cout LL' Aceita argumento de lin!a de comando: <uebracab P Dcria <uebracabeca P : PEYn'J cout LL' +ntre comando:'J cin MM opcaoJ SSle opcao do usuario cout LL'Yn'J sditc!DopcaoE SSe:ecuta opcao do usuario T case [+[: case [e[: a<uebracab.embaral!aDEJ breaiJ case [Q[: a<uebracab.mo9ecimaDEJ breaiJ case [G[: a<uebracab.mo9ebai:oDEJ breaiJ case [P[: a<uebracab.mo9ees<DEJ breaiJ case [4[: a<uebracab.mo9edirDEJ breaiJ default: J U SSfim do bloco de codigo do sditc!Bcase if Da<uebracab.tstsolucaoDEE opcaoV[s[J SSsai do loop de menu U d!ile DDopcao]V[0[E oo Dopcao]V[s[EEJ SSloop menu

if Da<uebracab.tstsolucaoDEE Ta<uebracab.mostraDEJ cout LL ' Parabens]Yn'JU else cout LL ' Fuebra cabeca nao solucionado. #ente no9amente]Yn'J return WJ U SSbloco de codigo principal

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

87

Coment>rios: delete mn<cJ +ste destrutor adota uma tcnica diferente para dele67o de 9etores; c!e<ue <ue tcnicas seu compilador suporta.

+:erccios: 2E 0e 9oc@ implementou o 8ogo de <uebraBcabe6a notar> <ue n7o e:iste apagamento da tela; somente 'scroll'. %sto torna o 8ogo um pouco cansati9o por<ue d> para 9er o <uebra cabe6a sendo empurrado para o alto da tela e a no9a representa67o sendo criada na parte de bai:o do 'display'. A raA7o de tal escol!a simples: a fun67o de apagamento de tela do DO0 n7o port>9el para o $)%X e 9ice 9ersa. Descubra a fun67o de C&0 DClear 0creenE do seu ambiente de programa67o e useBa no programa. )uma segunda etapa introduAa cores no programa; 9oc@ pode usar a fun67o mCdulo DnOmero da pe6a ;nOmero de coresE para determinar a cor de uma pe6a.

GE %mplemente outros 8ogos simples. Pense em 8ogos compat9eis com a sua e:peri@ncia. A<ui 97o algumas sugest5es:

0en!a: /ogo bastante con!ecido; o programa cria um cCdigo de n dgitos e m smbolos. Atra9s de c!utes o 8ogador tenta acertar o cCdigo na se<`@ncia. A cada c!ute o programa da dicas dos acertos sendo elas de dois tipos: Acertou o smbolo X 9eAes ou acertou o smbolo e a posi67o Z 9eAes. ?oc@ ter> <ue usar uma fun67o para obter nOmeros aleatCrios; pro9a9elmente rand da 'library' Lmat!.!M. /ogo da 9el!a. 0e 9oc@ n7o con!ece os 8ogos procure obter mais informa65es antes de come6ar a implementaBlos.

aEMel!ore a classe matriA para aceitar nas suas fun65es argumentos do tipo Dlin!a;colunaE e n7o sC ndices lineares.

PE Construa um programa simples <ue recebe argumentos da lin!a de comando e os imprime atra9s de cout. )ormalmente isso <ue de9e ser feito antes de usar um recurso da linguagem pela primeira 9eA; e:perimentaBlo em programas simples. G. b+"A),A G.2. b%+"A"F$%A0 D+ #%PO0 )este tCpico mostraremos como construir !ierar<uias de tipo por generaliAa67o S especialiAa67o. G.2.2. $MA b%+"A"F$%A 0%MP&+0. Construiremos uma !ierar<uia de tipos simples para demonstrar !eran6a pOblica em C((.

Coment>rios: L iguraM O diagrama acima representa a !ierar<uia de classes implementada e foi obtido a partir da 8anela de edi67o 88

de uma ferramenta case para programa67o orientada a ob8etos. A classe ponto <ue est> no topo da !ierar<uia c!amada de classe base; en<uanto <ue as classes pontoIreflete e pontoImo9e s7o c!amadas classes fil!as ou !erdeiras. As classes da !ierar<uia s7o simples; pontoImo9e apresenta a fun67o membro mo9e; 8> 9ista neste tutorial em 2.G.4; pontoIreflete apresenta a fun67o membro DrefleteE <ue in9erte o sinal das coordenadas. Dada a simplicidade das classes o leitor poderia se perguntar; por<ue n7o 8untar as tr@s em uma sC . A pergunta faA sentido; mas e se <uisssemos criar uma classe ponto <ue n7o se mo9esse; apenas refletisse e outra <ue sC se mo9esseK + se <uisssemos pro8etar nosso programa segundo uma !ierar<uia de especialiAa67o S generaliAa67o da classe pontoK O e:emplo mostra como faA@Blo.

beran6a POblica: )a !eran6a pOblica as classes fil!as passam a ter as mesmas fun65es membro public da classe pai; as classes fil!as podem acrescentar fun65es membro; dados membro e at redefinir fun65es membro !erdadas D9eremos mais tardeE. Os atributos da classe pai n7o s7o acess9eis diretamente na classe fil!a a n7o ser <ue se8am <ualificados como protected; 9e8a G.2.G. Por isso <ue se diA <ue as classes fil!as garantem pelo menos o comportamento 'be!a9iour' da classe pai; podendo acrescentar mais caractersticas. Diagrama de acesso; 9isibilidade; de dados membro e fun65es membro de uma classe pai para uma classe fil!a ou !erdeira por !eran6a pOblica: L iguraM Construtores e !eran6a: )o construtor de uma classe fil!a o programador pode incluir a c!amada do construtor da classe pai.

Destrutores e !eran6a: Fuando um ob8eto da classe deri9ada destrudo; o destrutor da classe pai tambm c!amado dando a oportunidade de liberar a memCria ocupada pelos atributos pri9ate da classe pai.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file class ponto T pri9ate: float :J SSsao ocultos por default float yJ SSsao ocultos por default public: SSda<ui em diante tudo e acessi9el. pontoDfloat a;float bEJ 9oid inicialiAaDfloat a;float bEJ

89

float retornaI:D9oidEJ float retornaIyD9oidEJ 9oid alteraI:Dfloat aEJ 9oid alteraIyDfloat bEJ 9oid mostraD9oidEJ UJ

class pontoIreflete:public ponto SSclasse fil!a T pri9ate: SSse 9oce <uer adicionar atributos... public: pontoIrefleteDfloat a; float bEJ 9oid refleteD9oidEJ UJ

class pontoImo9e:public ponto T public: pontoImo9eDfloat a;float bEJ 9oid mo9eDfloat d:;float dyEJ UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementation file Rinclude Liostream.!M Rinclude 'pontos.!'

ponto::pontoDfloat a;float bE T inicialiAaDa;bEJ 90

9oid ponto::inicialiAaDfloat a;float bE T :VaJ yVbJ U

float ponto::retornaI:D9oidE T return :J U

float ponto::retornaIyD9oidE T return yJ U

9oid ponto::alteraI:Dfloat aE T :VaJ U

9oid ponto::alteraIyDfloat bE T yVbJ U

9oid ponto::mostraD9oidE T cout LL 'D' LL : LL ';' LL y LL 'E' LLendlJ U

pontoIreflete::pontoIrefleteDfloat a;float bE:pontoDa;bE TU

9oid pontoIreflete::refleteD9oidE T alteraI:DBretornaI:DEEJ

91

alteraIyDBretornaIyDEEJ U

pontoImo9e::pontoImo9eDfloat a;float bE:pontoDa;bE TU

9oid pontoImo9e::mo9eDfloat d:;float dyE T alteraI:DretornaI:DE(d:EJ alteraIyDretornaIyDE(dyEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'pontos.!'

9oid mainDE T pontoIreflete p2DH.2P;G.2eEJ p2.refleteDEJ cout LL 'P2'J p2.mostraDEJ

pontoImo9e pGD2.W;2.WEJ pG.mo9eD.a;.aEJ cout LL 'PG'J pG.mostraDEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

92

"esultado do programa: P2DBH.2P;BG.2eE PGD2.a;2.aE

beran6a Pri9ate: Ainda n7o foi inserido no tutorial nen!um e:emplo com este tipo de !eran6a; mas o leitor pode e:perimentar mais tarde especificar uma classe !erdeira por !eranca pri9ate como: class !erdeira: pri9ate nomeIclasseIbaseJ ; e notar> <ue as fun65es membro desta classe base sC s7o acess9eis dentro das declara65es da classe fil!a; ou se8a a classe fil!a n7o atende por essas fun65es membro; mas pode us>Blas em seu cCdigo. beran6a pri9ate um recurso <ue 9oc@ precisa tomar cuidado <uando usar. )ormalmente; <uando usamos !eran6a diAemos <ue a classe fil!a garante no mnimo o comportamento da classe pai Dem termos de fun65es membroE ; a !eran6a pri9ate pode in9alidar esta premissa. Muitos programadores usam !eran6a pri9ate <uando ficaria mais elegante; acad@mico; trabal!ar com agrega67o. $ma classe pil!a pode ser construda a partir de uma classe <ue implementa uma lista ligada por agrega67o ou por !eran6a pri9ate. )a agrega67o Da escol!ida em !ierar<uias de implementa67oE a classe pil!a possui um dado membro <ue uma lista ligada.

G.2.G. P"O#+C#+D %gual ao e:emplo um; mas agora tornando os atributos da classe pai acess9eis para as classes fil!as atra9s do uso de protected. Protected dei:a os atributos da classe pai 9is9eis; acess9eis '!ierar<uia abai:o'. Diagramas de acesso; 9isibilidade; de dados membro e fun65es membro de uma classe pai para uma classe fil!a ou !erdeira:

Para uma classe fil!a por !eran6a pOblica:

L iguraM

?isibilidade da classe !erdeira para o restante do programa:

L iguraM

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file class ponto 93

T protected: SS^^^^^a<ui esta a diferenca ^^^^^^ float :J SS9isi9eis !ierar<uia abai:o float yJ SS9isi9eis !ierar<uia abai:o public: SSda<ui em diante tudo e acessi9el. pontoDfloat a;float bEJ 9oid inicialiAaDfloat a;float bEJ float retornaI:D9oidEJ float retornaIyD9oidEJ 9oid alteraI:Dfloat aEJ 9oid alteraIyDfloat bEJ 9oid mostraD9oidEJ UJ

class pontoIreflete:public ponto T pri9ate: SSse 9oce <uer adicionar dados membro encapsulados... public: pontoIrefleteDfloat a; float bEJ 9oid refleteD9oidEJ UJ

class pontoImo9e:public ponto T public:

94

pontoImo9eDfloat a;float bEJ 9oid mo9eDfloat d:;float dyEJ UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementation file Rinclude Liostream.!M Rinclude 'pontos.!'

ponto::pontoDfloat a;float bE T inicialiAaDa;bEJ U

9oid ponto::inicialiAaDfloat a;float bE T :VaJ yVbJ U

float ponto::retornaI:D9oidE T return :J U

float ponto::retornaIyD9oidE T return yJ U

9oid ponto::alteraI:Dfloat aE T :VaJ U

9oid ponto::alteraIyDfloat bE 95

T yVbJ U

9oid ponto::mostraD9oidE T cout LL 'D' LL : LL ';' LL y LL 'E' LLendlJ U

pontoIreflete::pontoIrefleteDfloat a;float bE:pontoDa;bE TU

9oid pontoIreflete::refleteD9oidE T :VB:J SS^^^ protected da esse tipo de acesso aos atributos da classe pai yVByJ U

pontoImo9e::pontoImo9eDfloat a;float bE:pontoDa;bE TU

9oid pontoImo9e::mo9eDfloat d:;float dyE T :V:(d:J SSacesso so na !ierar<uia; no resto do programa nao. yVy(dyJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M

96

Rinclude 'pontos.!'

9oid mainDE T pontoIreflete p2DH.2P;G.2eEJ p2.refleteDEJ cout LL 'P2'J p2.mostraDEJ

pontoImo9e pGD2.W;2.WEJ pG.mo9eD.a;.aEJ cout LL 'PG'J pG.mostraDEJ

U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

G.2.H. "+D+ %)%,-O D+ $),\+0 M+M."O b+"DADA0 . %gual ao e:emplo anterior; mas agora redefinindo a fun67o membro mostra para a classe fil!a ponto reflete.

Coment>rios: )a 9erdade este e:emplo de9eria pertencer ao tCpico de polimorfismo; contudo; nos e:emplos seguintes usaremos tambm redefini65es de fun65es membro; portanto faABse necess>rio introduAiBlo agora. #eremos mais e:plica65es sobre o assunto. $ma classe fil!a pode fornecer uma outra implementa67o para uma fun67o membro !erdada; caracteriAando uma redefini67o 'o9erriding' de fun67o membro. %mportante: a fun67o membro de9e ter a mesma assinatura Dnome; argumentos e 9alor de retornoE; sen7o n7o se trata de uma redefini67o e sim sobrecarga 'o9erloading'. )o nosso e:emplo a classe pontoIreflete redefine a fun67o membro mostra da classe pai; en<uanto <ue a classe !erdeira pontoImo9e aceita a defini67o da fun67o membro mostra dada pela classe ponto <ue sua classe pai.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

97

SS!eader file class ponto T pri9ate: float :J SSsao ocultos por default float yJ SSsao ocultos por default public: SSda<ui em diante tudo e acessi9el. pontoDfloat a;float bEJ 9oid inicialiAaDfloat a;float bEJ float retornaI:D9oidEJ float retornaIyD9oidEJ 9oid alteraI:Dfloat aEJ 9oid alteraIyDfloat bEJ 9oid mostraD9oidEJ UJ

class pontoIreflete:public ponto T pri9ate: SSse 9oce <uer adicionar dados membro public: pontoIrefleteDfloat a; float bEJ 9oid refleteD9oidEJ 9oid mostraD9oidEJ SSredefinicao UJ

class pontoImo9e:public ponto

98

T public: pontoImo9eDfloat a;float bEJ 9oid mo9eDfloat d:;float dyEJ SSesta classe fil!a nao redefine mostra UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementation file Rinclude Liostream.!M Rinclude 'pontos.!'

ponto::pontoDfloat a;float bE T inicialiAaDa;bEJ U

9oid ponto::inicialiAaDfloat a;float bE T :VaJ yVbJ U

float ponto::retornaI:D9oidE T return :J U

float ponto::retornaIyD9oidE T return yJ U

9oid ponto::alteraI:Dfloat aE 99

T :VaJ U

9oid ponto::alteraIyDfloat bE T yVbJ U

9oid ponto::mostraD9oidE T cout LL 'D' LL : LL ';' LL y LL 'E' LLendlJ U

pontoIreflete::pontoIrefleteDfloat a;float bE:pontoDa;bE TU

9oid pontoIreflete::refleteD9oidE T alteraI:DBretornaI:DEEJ alteraIyDBretornaIyDEEJ U

9oid pontoIreflete::mostraD9oidE T cout LL 'X:' LL retornaI:DE LL ' Z:'J cout LL retornaIyDE LL endlJ U SSsomente altera o formato de impressao

pontoImo9e::pontoImo9eDfloat a;float bE:pontoDa;bE TU

9oid pontoImo9e::mo9eDfloat d:;float dyE T

100

alteraI:DretornaI:DE(d:EJ alteraIyDretornaIyDE(dyEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'pontos.!'

9oid mainDE T pontoIreflete p2DH.2P;G.2eEJ p2.refleteDEJ cout LL 'P2'J p2.mostraDEJ

pontoImo9e pGD2.W;2.WEJ pG.mo9eD.a;.aEJ cout LL 'PG'J pG.mostraDEJ

U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: P2X:BH.2P Z:BG.2e PGD2.a;2.aE

+:erccios: 101

2E#este redefini67o de fun67o membro colocando 'cout[s' em fun65es membro da !ierar<uia; tais como: cout LL '"edefinido]'J cout LL 'Original]'J

G.2.P. $MA b%+"A"F$%A D+ &%0#A0 &%*ADA0 . Construiremos sem importar nen!um outro cCdigo; uma !ierar<uia de listas ligadas especialiAadas. $m dos ob8eti9os obter uma implementa67o de lista <ue possa ser reutiliAada para cria67o de pil!as e filas.

L iguraM O desen!o acima foi elaborado segundo metodologia descrita no li9ro 'Ob8ect Oriented Modeling and Design' . A associa67o entre as classes lista e nC uma associa67o do tipo '!as many' en<uanto <ue a associa67o entre a classe lista e as classes lista ultimo e lista ordenada indica !eran6a; uma associa67o do tipo 'is a'. Algumas simplifica65es foram feitas do diagrama original. )o tCpico sobre templates W modificaremos este e:emplo para suportar tipos parametriAados. )o tCpico sobre !ierar<uias de implementa67o G.G usamos a 9ers7o de lista descrita a<ui para criar uma classe <ue implementa uma fila.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rifndef M&%0#bIb Rdefine M&%0#bIb Rinclude Lstdlib.!M Rinclude Liostream.!M SSCriacao de uma !ierar<uia de listas ligadas. SSO elemento da lista e[ um inteiro enum .ooleanT A&0+;#"$+UJ

class noT SSeste e[ o no da lista ligada; so e[ usado por ela pri9ate: int infoJ SSinformacao no^ pro:J SSponteiro para o pro:imo public: noDEJ noDint i;no^ pEJ no^ getIpro:D9oidEJ 9oid setIpro:Dno^ pEJ

102

int getIinfoD9oidEJ 9oid setIinfoDint iEJ no^ dobraD9oidEJ fnoD9oidEJ UJ

class listaT SSesta e[ a lista ligada comum. protected: SS'9isi9el !ierar<uia abai:o' no^ primeiroJ SSprimeiro no da lista; a<ui eu insiro e remo9o. public: listaD9oidEJ .oolean 9aAiaD9oidEconstJ .oolean contemDint elEconstJ 9oid insereIprimeiroDint elemEJ int^ remo9eIprimeiroDEJ 9oid mostraDEconstJ flistaD9oidEJ UJ SSfim classe lista

class listaultimo:public lista T SSessa e a lista util para SSimplementar pil!as e filas. protected: SSprotected e uma opcao outra e[ getIultimoDE e setI... no^ ultimoJ public: listaultimoD9oidEJ 9oid insereIultimoDint elemEJ SSno9a 9oid insereIprimeiroDint elemEJ SSredefinicao int^ remo9eIprimeiroDEJSSredefinicao flistaultimoD9oidEJ SSas operacoes nao redefinidas sao 9alidas. UJ

103

class listaordenada:public lista T SSessa e[ a lista comum com aprimoramentosSespecialiAacoes public: listaordenadaD9oidEJ .oolean contemDint elEconstJ 9oid insereIprimeiroDint elemEJ SSinsere em ordem int^ remo9eIelementoDint elEJ SSremo9e elemento el se e:istir flistaordenadaD9oidEJ UJ

Rendif

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude 'mlist!.!' Rinclude Liostream.!M Rinclude Lstdlib.!M no::noDE Tpro:V)$&&Jcout LL 'bi'JU no::noDint i;no^ pE TinfoViJpro:VpJcout LL 'bi'JU no^ no::getIpro:D9oidETreturn pro:JU 9oid no::setIpro:Dno^ pE Tpro:VpJU int no::getIinfoD9oidE Treturn infoJU 9oid no::setIinfoDint iE TinfoViJU no^ no::dobraD9oidE T if DgetIpro:DEVV)$&&E return ned noDgetIinfoDE;)$&&EJ

104

else return ned noDgetIinfoDE;t!isBMgetIpro:DEBMdobraDEEJ SSrecursi9idade para duplicacao da lista U

no::fnoD9oidE Tcout LL 'bye'JU

lista::listaD9oidE:primeiroD)$&&E TU SSbloco de codigo 9aAio

.oolean lista::9aAiaD9oidEconst T return .ooleanDprimeiroVV)$&&EJ U

.oolean lista::contemDint elE constSSmais rapido <ue iterador T no^ currJ int ContiJ currVprimeiroJ ContiV#"$+J d!ile DDcurr]V)$&&E oo Conti E T if DcurrBMgetIinfoDE]VelE Tif DcurrBMgetIpro:DEVV)$&&E ContiV A&0+J else currVcurrBMgetIpro:DEJU else ContiV A&0+J UJ SSd!ile return .ooleanDcurrBMgetIinfoDEVVelEJ UJ

9oid lista::insereIprimeiroDint elemE T 105

no^ insirameJ if DprimeiroVV)$&&E SSlista 9aAia primeiroVned noDelem;)$&&EJ else T insirameVned noDelem;primeiroEJ primeiroVinsirameJ UJ UJ

int^ lista::remo9eIprimeiroDE T int^ de9ol9ameVned intJ SSreturn no^ tempJ SSto delete if DprimeiroVV)$&&E return )$&&J SSlista 9aAia else T D^de9ol9ameEVprimeiroBMgetIinfoDEJ tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ return de9ol9ameJ UJ UJ

9oid lista::mostraDE const T no^ currJ cout LL 'V'J currVprimeiroJ d!ile Dcurr]V)$&&E T cout LL'D'LLcurrBMgetIinfoDELL'E'LL'B'J

106

currVcurrBMgetIpro:DEJ UJ U

lista::flistaD9oidE T no^ tempJ d!ile Dprimeiro]V)$&&E T tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ UJ U

listaordenada::listaordenadaD9oidE:listaDE TUJ

.oolean listaordenada::contemDint elEconst T no^ currJ .oolean contiV#"$+J currVprimeiroJ d!ile DDcurr]V)$&&E oo contiE T if DcurrBMgetIinfoDELelE currVcurrBMgetIpro:DEJ else contiV A&0+J UJ if DcurrVV)$&&E return A&0+J else return .ooleanDcurrBMgetIinfoDEVVelEJ U 107

9oid listaordenada::insereIprimeiroDint elemE T no^ currVprimeiroJ no^ pre9V)$&&J no^ insirameJ .oolean contiV#"$+J d!ile DDcurr]V)$&&E oo contiE T if DcurrBMgetIinfoDELelemE Tpre9VcurrJ currVcurrBMgetIpro:DEJU else contiV A&0+J UJ insirameVned noDelem;currEJ if Dpre9VV)$&&E primeiroVinsirameJ else pre9BMsetIpro:DinsirameEJ U

int^ listaordenada::remo9eIelementoDint elE T int^ de9ol9ameVned intJ no^ currVprimeiroJ no^ pre9V)$&&J no^ deletemeJ .oolean contiV#"$+J d!ile DDcurr]V)$&&E oo contiE SSac!a lugar onde pode estar el T if DcurrBMgetIinfoDELelE Tpre9VcurrJ currVcurrBMgetIpro:DEJU SSanda else contiV A&0+J UJ

108

if DcurrVV)$&&E return )$&&J SSfim de lista ou 9aAia else SSpode ser o elemento ou ele nao e:iste T if DcurrBMgetIinfoDEVVelE T deletemeVcurrJ if Dpre9VV)$&&E SSlista so com um elemento ou primeiro el primeiroVcurrBMgetIpro:DEJ else T pre9BMsetIpro:DcurrBMgetIpro:DEEJ U D^de9ol9ameEVdeletemeBMgetIinfoDEJ SSso para 9erificar delete deletemeJ return de9ol9ameJ U else return )$&&J U U

listaordenada::flistaordenadaD9oidE Tcout LL '&ista destruida.'JUJ

listaultimo::listaultimoD9oidE:listaDE T ultimoV)$&&J U

9oid listaultimo::insereIultimoDint elemE T 109

no^ insirameJ insirameVned noDelem;)$&&EJ if DultimoVV)$&&E ultimoVinsirameJ SSlista 9aAia else T ultimoBMsetIpro:DinsirameEJ ultimoVinsirameJ UJ if DprimeiroVV)$&&E primeiroVultimoJ SSlista 9aAia U

9oid listaultimo::insereIprimeiroDint elemE SSredefinicao T no^ insirameJ if DprimeiroVV)$&&E SSlista 9aAia T primeiroVned noDelem;ultimoEJ ultimoVprimeiroJ USSlista 9aAia else T insirameVned noDelem;primeiroEJ primeiroVinsirameJ UJ U

int^ listaultimo::remo9eIprimeiroDESSredefinicao T int^ de9ol9ameVned intJ SSreturn no^ tempJ SSto delete if DprimeiroVV)$&&E return )$&&J SSlista 9aAia else T

110

D^de9ol9ameEVprimeiroBMgetIinfoDEJ tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ if DprimeiroVV)$&&E ultimoV)$&&J SS9olta lista 9aAia return de9ol9ameJ UJ U

listaultimo::flistaultimoD9oidE T no^ tempJ d!ile Dprimeiro]V)$&&E T tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ UJ delete ultimoJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude 'mlist!.!' mainDE T listaordenada min!aJ c!ar optionJ SSuse in menu as option 9ariable int elJ SSelemento a inserir int^ receptorJ do T 111

cout LL'Yn'J SSmenu options display cout LL'P:%nsere no primeiro.Yn'J cout LL'":"emo9e no primeiro.Yn'J cout LL'D:"emo9e elemento.Yn'J cout LL'+:+:iste elementoKYn'J cout LL'?:?aAiaKYn'J cout LL'M:Mostra lista.Yn'J cout LL'F:Fuit teste lista.Yn'J cout LL'+ntre comando:'J cin MM optionJ SSreads user option sditc!DoptionE SSe:ecutes user option T case [D[: case [d[: cout LL '+ntre elemento:'J cin MMelJ receptorVmin!a.remo9eIelementoDelEJ if DreceptorVV)$&&E cout LL ')$&&' LL endlJ else cout LL D^receptorE LL endlJ breaiJ case [P[: case [p[: cout LL '+ntre elemento:'J cin MM elJ min!a.insereIprimeiroDelEJ breaiJ case ["[: case [r[: if D]min!a.9aAiaDEE cout LL D^min!a.remo9eIprimeiroDEE LLendlJ else cout LL ')$&&; &ista 9aAia.' LLendlJ

112

breaiJ case [M[: case [m[: min!a.mostraDEJ breaiJ case [+[: case [e[: cout LL '+ntre elemento:'J cin MMelJ cout LL min!a.contemDelEJ breaiJ case [?[: case [9[: cout LL min!a.9aAiaDEJ breaiJ default: J U SSsditc!Bcase code bloci U d!ile DDoption]V[F[E oo Doption]V[<[EEJ SSmenu loop code bloci

return WJ U SSmain code bloci BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Coment>rios: )ote <ue o programa principal sC testa a lista ordenada; em outros programas e:emplo baseados neste 9eremos testes para a listaIultimo.

+:erccios: 2E+:perimente deri9ar Dcriar classes !erdeirasE outras classes lista com propriedades de seu interesse tais como obten67o de sublista.

GE%ntroduAa na classe lista a contagem do nOmero de elementos numa lista.

113

HECrie uma fun67o membro c!amado 9oid remo9eItodosD9oidEJ <ue simplesmente dei:a a lista 9aAia.

^PE0upon!a <ue 9oc@ um programador de uma empresa e te9e <ue implementar a !ierar<uia de listas para seu grupo de desen9ol9imento; segundo uma especifica67o dada pelo seu c!efe. ?oc@ introduAiria as mudan6as sugeridas nos e:erccios anteriores; mesmo sabendo <ue elas n7o esta9am na especifica67oK Fue dificuldade um usu>rio de sua classe lista teria para introduAiBlas caso surgisse a necessidade e 9oc@ n7o ti9esse feitoK Discuta as seguintes maneiras de um programador de seu grupo conseguir o efeito dese8ado de adicionar as sugest5es dos e:erccios anteriores a !ierar<uia: usar !eran6a Dderi9ar uma classe com 9oid remo9eItodosD9oidE E; alterar o cCdigo original; pedir para 9oc@ o programador do cCdigo original mudar a implementa67o. &embreBse <ue pode e:istir mais de um programador usando a 9ers7o original da !ierar<uia de listas.

G.G. b%+"A"F$%A0 D+ %MP&+M+)#A,-O )ossas !ierar<uias de implementa67o em termos de cCdigo D!eran6aE n7o s7o !ierar<uias; usamos delega67o para obter pil!as a partir listas. Agregamos uma lista em nossas classes e usamos esta lista de acordo com a lCgica en9ol9ida. #udo o <ue fiAemos poderia ser feito usando !eran6a pri9ate; o <ue 8ustificaria o ttulo '!ierar<uias de implementa67o'; embora tornasse o nosso te:to menos acad@mico.

G.G.2. %&A A PA"#%" D+ $MA &%0#A "euso de cCdigo de uma lista ligada G.2 para a implementa67o de uma fila atra9s de agrega67o. Para podermos declarar e usar um ob8eto lista na nossa classe fila precisamos con!ecer sua interface. 0abemos <ue nosso ob8eto lista permite inserir em ambas e:tremidades; inicio e fim da lista; mas sC permite remo65es em um e:tremo; o inicio. Como uma fila permite inser65es somente num e:tremo e remo65es nos e:tremo oposto; precisaremos usar nossa lista da seguinte forma: inser67o no final da lista e remo65es no come6o. 0eguem abai:o e:emplos de c!amadas de fun65es membro da classe lista implementada em G.2 para trabal!ar com nOmeros inteiros.

Consideremos uma lista al; s7o 9>lidas as seguintes opera65es:

al.9aAiaDEJ SSretorna se a lista Dfila agoraE esta 9aAia. al.contemDelEJ SSretorna 2 se el pertence a lista e W se el nao pertence a lista. al.insereIultimoDelEJ SSinsere no final da lista Dentrada da filaE. al.insereIprimeiroDelEJ SSnao usaremos na implementacao de fila; usariamos se SSimplementassemos uma pil!a. al.remo9eIprimeiroDEJ SSremo9e no comeco da lista Dsaida da filaE. al.mostraDEJ SSmostra lista Dmostra fila em ordem contraria de insercaoE

Para maiores informa65es consulte tCpico anterior onde definimos esta lista. Por este moti9o n7o 9amos incluir sua defini67o a seguir. 114

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file para a classe fila Rinclude 'mlist!.!' class fila T SSagregacao de uma lista de pri9ate: listaultimo alJ SSa lista public: filaDEJ .oolean 9aAiaDEJ .oolean contemDint elEJ 9oid insereDint elEJ int^ remo9eDEJ 9oid mostraDEJ UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementacao para a classe fila Rinclude 'm<ueue.!' Rinclude 'mlist!.!' fila::filaDETUJ

.oolean fila::9aAiaDE Treturn al.9aAiaDEJU

.oolean fila::contemDint elE Treturn al.contemDelEJU

115

9oid fila::insereDint elE Tal.insereIultimoDelEJU

int^ fila::remo9eDE Treturn al.remo9eIprimeiroDEJU

9oid fila::mostraDE Tal.mostraDEJU

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSprograma principal; testes da classe fila Rinclude 'm<ueue.!' mainDE T fila min!aJ c!ar optionJ SSusada em menu como 9aria9el de opcao int elJ SSelemento a inserir do T cout LL'Yn'J SSopcoes do menu cout LL'%:%nsere.Yn'J cout LL'":"emo9e.Yn'J cout LL'M:Mostra fila.Yn'J cout LL'F:Fuit fila test.Yn'J cout LL'?:?aAiaKYn'J cout LL'C:ContemKYn'J cout LL'+ntre comando:'J cin MM optionJ SSle opcao do usuario sditc!DoptionE SSe:ecuta opcao do usuario T 116

case [%[: case [i[: cout LL '+ntre elemento:'J cin MMelJ min!a.insereDelEJ breaiJ case ["[: case [r[: if D]min!a.9aAiaDEE cout LL D^min!a.remo9eDEE LLendlJ else cout LL ')$&&; fila 9aAia.' LLendlJ breaiJ case [C[: case [c[: cout LL '+ntre elemento:'J cin MMelJ cout LL min!a.contemDelEJ breaiJ case [M[: case [m[: min!a.mostraDEJ breaiJ case [?[: case [9[: cout LL '"esultado:' LL min!a.9aAiaDE LLendlJ breaiJ default: J U SSsditc!Bcase bloco de codigo U d!ile DDoption]V[F[E oo Doption]V[<[EEJ SSloop do menu fim

return WJ

117

U SS bloco de codigo principal BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

H. PO&%MO" %0MO; $),\+0 ?%"#$A%0 .+:istem 9>rios tipos de polimorfismo. )o <ue se refere a ob8etos; ModulaBH apresenta polimorfismos classificados como uni9ersais; e:emplos de polimorfismos do tipo 'adB!oc' e ob8etos podem ser encontrados em outras linguagens como C((.

H.2. O F$+ 0%*)% %CA PO&%MO" %0MO Polimorfismo; do grego: muitas formas. Polimorfismo a capacidade de um operador e:ecutar a a67o apropriada dependendo do tipo do operando. A<ui operando e operador est7o definidos num sentido mais geral: operando pode significar argumentos atuais de um procedimento e operador o procedimento; operando pode significar um ob8eto e operador um mtodo; operando pode significar um tipo e operador um ob8eto deste tipo. H.2.2. 0O."+CA"*A D+ M=#ODO0 ModulaBH n7o oferece este tipo de polimorfismo <ue pode ser considerado com 'adB!oc'. +ste tipo de polimorfismo permitiria a e:ist@ncia de 9>rios procedimentos e mtodos de mesmo nome; porm com assinaturas le9emente diferentes; 9ariando no nOmero e tipo de argumentos. icaria a cargo do compilador escol!er de acordo com as listas de argumentos os procedimentos ou mtodos a serem e:ecutados.

H.2.G. "+D+ %)%,-O D+ $MA $),-O M+M."O PA"A $MA C&A00+ b+"D+%"A .+ste e:emplo 8> foi apresentado em G.2.H. #ambm trataBse de um polimorfismo; pode ser classificado como polimorfismo de inclus7o. H.2.H. 'COPZ CO)0#"$C#O"' A fun67o membro pontoDpontoo aEJ um copy constructor; alm disso tem o mesmo nome <ue pontoDfloat d:;float dyEJ. #al duplica67o de nomes pode parecer estran!a; porm C(( permite <ue eles coe:istam para uma classe por<ue n7o tem a mesma assinatura Dnome(argumentosE. %sto se c!ama sobrecarga de fun67o membro; o compilador sabe distinguir entre esses dois construtores. Outras fun65es membro; n7o sC construtores poder7o ser redefinidas; ou sobrecarregadas para 9>rios argumentos diferentes; esse recurso um polimorfismo do tipo 'adB!oc'.

O <ue interessante para nCs o fato de o argumento do construtor pontoDpontoo aEJ ser da mesma classe para <ual o construtor foi implementado; esse o c!amado 'copy constructor'. +le usa um ob8eto de seu tipo para se inicialiAar. Outros mtodos semel!antes seriam: circuloDcirculoo aEJ mouseDmouseo dEJ. %mplementar copy constructor pode ser muito importante; lembreBse dos problemas com cCpias de ob8etos apresentados em 2.a.H.a.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

118

Rinclude Liostream.!M

struct ponto T float :J float yJ

pontoDfloat a;float bEJ SSconstrutor tambem pode ser inline ou nao

pontoDpontoo aEJ SScopy constructor 9oid mostraD9oidEJ 9oid mo9eDfloat d:;float dyEJ

UJ

ponto::pontoDfloat a;float bE T :VaJ yVbJ U

ponto::pontoDpontoo aE T :Va.:J yVa.yJ U

9oid ponto::mostraD9oidE Tcout LL 'X:' LL : LL ' ; Z:' LL y LL endlJU

9oid ponto::mo9eDfloat d:;float dyE 119

T :(Vd:J y(VdyJ U

9oid mainDE T ponto apDW.W;W.WEJ ap.mostraDEJ ap.mo9eD2.W;2.WEJ ap.mostraDEJ ponto apGDapEJ apG.mostraDEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Coment>rios: Obser9e o cCdigo: ponto::pontoDpontoo aE T :Va.:J yVa.yJ U

+ssa fun67o membro; esse mtodo; pertence a outro ob8eto <ue n7o o argumento a; ent7o para distinguir o atributo : deste ob8eto; do atributo : de a usamos a.: e simplesmente : para o ob8eto local Ddono da fun67o membroE.

+:erccios: 2EO copy constructor usa passagem por refer@ncia; construa uma fun67o <ue troca duas 9ari>9eis inteiras usando passagem por refer@ncia. Analise esse recurso sob a Ctica do assunto encapsulamento. +m <ue casos 120

9oc@ pode afirmar ser seguro usar esse recursoK

GE Defina um copy constructor para o tipo abstrato de dados fra67o apresentado em: 2.P. H.2.P. 0O."+CA"*A D+ $),-O +M C((. +ste tCpico apresenta e:emplos importantes para o estudo do restante do tutorial. 0obrecarga 'O9erloading' de fun67o um tipo de polimorfismo classific>9el como adB!oc. C(( permite <ue fun65es de mesmo nome ten!am parNmetros distintos. +ste e:emplo mostra a sobrecarga da fun67o abs <ue calcula o 9alor absoluto de um nOmero: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file funco9er.! float absDfloat aEJ int absDint aEJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementation file Rinclude 'funco9er.!'

float absDfloat aE T if DaMW.WE return aJ else return BaJ U

int absDint aE T if DaMWE return aJ else return BaJ U

121

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'funco9er.!'

9oid mainDE T int i2J float f2J cout LL absDintDB2WEELLendlJ cout LL absDfloatDB2W.2EELLendlJ f2VB3.2J i2VQ.WJ cout LL absDf2E LL endlJ cout LL absDi2E LL endlJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 2W 2W.2 3.2 Q

Coment>rios: cout LL absDfloatDB2W.2EELLendlJ Perceba <ue <uando c!amamos a fun67o abs para um 9alor DB2W.2E e n7o uma 9ari>9el Dpossui um tipoE; temos <ue faAer a con9ers7o e:plcita para o compilador; por<ue este n7o sabe decidir <ual fun67o c!amar Dpara float ou intE; mesmo estando presente o ponto indicando a casa decimal. Obser9e <ue B2W.2 pode ser double ou float. +n<uanto <ue 2W pode ser long ou int. )o e:emplo P 9eremos sobrecarga de operador; <ue semel!ante a sobrecarga de fun67o. Obser9e <ue os operadores ^ B e at mesmo os operadores de e:tra67o LL MM usados com cout s7o e:emplos de sobrecarga 122

de operadores. +les 8> est7o definidos com a mesma forma para um con8unto restrito de tipos.

+:erccios: 2E Mel!ore este e:emplo para <ue se calcule tambm o 9alor absoluto de nOmeros em tipo long.

GECrie um programa an>logo a este e:emplo sC <ue agora com a fun67o ma: <ue de9e calcular o m>:imo de dois nOmeros.

HECrie um programa an>logo a este e:emplo sC <ue agora com a fun67o mdc <ue de9e calcular o m>:imo di9isor comum de dois nOmeros int ou long.

^PE&embreBse de alguns programas <ue 9oc@ ten!a escrito em <ue se pudesse faAer uso de fun65es sobrecarregadas. Comente de <ue modo tal uso facilitaria tanto a programa67o <uanto a manuten67o de softdare. De algum modo esse uso poderia atrapal!ar o desen9ol9imento do programaK 0e sim de <ue modoK

^aEMude o cCdigo de uma das fun65es abs para calcular o mCdulo do nOmero ele9andoBo ao <uadrado e e:traindo a raiA <uadrada; eliminando assim o sinal. ?oc@ pro9a9elmente 9ai precisar da library Lmat!.!M . )ote <ue o <ue importa para a sobrecarga o cabe6al!o; a assinatura da fun67o e n7o o cCdigo em si.

+ste programa mostra algumas peripcias <ue podemos faAer com sobrecarga de fun65es. ?e8a e:emplo anterior primeiro. BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file funco9er.! float ma:Dfloat a;float bEJ float ma:Dfloat a;float b;float cEJ int ma:Dint a;int bEJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude 'funco9er.!'

float ma:Dfloat a;float bE T 123

if DaMbE return aJ else return bJ U

float ma:Dfloat a;float b;float cE T if DaMbE return ma:Da;cEJ else return ma:Db;cEJ U

int ma:Dint a;int bE T if DaMbE return aJ else return bJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'funco9er.!'

9oid mainDE T cout LL ma:DfloatD2.GE;floatDH.PE;floatDG.2EELLendlJ cout LL ma:DfloatD2.aE;floatD.4aEE LL endlJ cout LL ma:DintD2GE;intD2GWEEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

124

"esultado do programa: H.P 2.a 2GW

H.2.a. 'D+ A$&# A"*$M+)#0'; ?A&O"+0 0$*+0#-O ?alores sugest7o; argumentos padr7o ou 'default arguments'; s7o nomes para um tipo de polimorfismo adB !oc fornecido por C((. Para demonstrar o uso de default 9alues 9amos relembrar o nosso tipo abstrato de dados fra67o de 2.G.2.P. $m de seus construtores tin!a a seguinte forma: fracaoDE TnumVWJ denV2JU SSconstrutor 9aAio;default en<uanto <ue o construtor normal da fra67o tin!a a seguinte forma: fracaoDlong t;long mEJ. 'Default arguments' nos d> a oportunidade de fundir esses dois construtores num sC resultando no seguinte: fracaoDlong tVW;long mV2EJ TnumVtJ denVmJU onde 2 e W s7o 9alores sugest7o para os argumentos.

A instancia67o fracao aD E segundo a<uele Onico construtor cria : DWS2E A instancia67o fracao bD2E segundo a<uele Onico construtor cria: D2S2E A instancia67o fracao cD2;GE segundo a<uele Onico construtor cria: D2SGE

"egras para a cria67o de 'Default arguments': )7o s7o permitidas declara65es do tipo fracaoDlong tVW;long mEJ uma 9eA <ue 9oc@ inseriu um argumento padr7o na lista de argumentos todos a direita deste tambm de9er7o ter seus 9alores sugest7o. +nt7o; por esta regra a Onica alternati9a restante para o tipo fra67o seria fracaoDlong t;long mV2EJ

+:erccios: 2E a6a a modifica67o do tipo abstrato de dados fracao retirando os dois construtores mencionados e substituindo por um Onico. O copy constructor 9oc@ pode dei:ar como est>.

H.2.4. 0O."+CA"*A D+ OP+"ADO" O tipo abstrato de dados fra67o D9ers7o completaE de 2.G.P.P possui 9>rios operadores sobrecarregados. Algumas sobrecargas deste e:emplo en9ol9em o uso da pala9ra c!a9e friends <ue 9oc@ n7o aprendeu ainda; portanto aten!aBse aos e:emplos <ue n7o contm essa pala9ra reser9ada. +:tens7o da classe 9etor de 2.a.H.4 para incluir um iterador. +ste e:emplo 8> apresentado com templates.

#Cpicos abordados: 0obrecarga de operador.

125

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file para classe 9etor: 9et.! Rinclude Liostream.!M Rinclude Lstdlib.!M SSe:itD2E

const int inicioVWJ SSinicio do 9etor

class 9etorT pri9ate: float^ 9J SSpode ser <ual<uer tipo <ue atenda as operacoes L M V int taman!oJ public: 9etor Dint taman!oE J floato operatormn Dint iEJ float ma:imoDEJ SSac!a o 9alor ma:imo do 9etor int primeiroD9oidEJ int ultimoD9oidEJ UJ

9etor::9etor Dint tamE T9Vned floatmtamnJ taman!oVtamJU

int 9etor::primeiro D9oidE Treturn inicioJU

int 9etor::ultimo D9oidE Treturn taman!oB2JU

126

floato 9etor::operatormnDint iE T if DiLW pp iMVtaman!oE Tcout LL ' ora dos limites] +:it program'J e:itD2EJU return 9minJ U

float 9etor:: ma:imoD9oidE Tint candidatoVinicioJ for Dint iVinicioJiLtaman!oJi((E if D9minM9mcandidatonE candidatoViJ return 9mcandidatonJU BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

+:plica67o das opera65es; das fun67o membros do iterador 9etor:

iterador9etorD9etor o 9EJ :Construtor; 8> cria o iterador de 9etor inicialiAandoBo para apontar para o come6o do 9etor.

9irtual int comecaDEJ: %nicialiAa o iterador para o come6o do 9etor.

9irtual int operator]DEJ : ?erifica se a itera67o n7o c!egou no fim do 9etor: 2 indica <ue n7o c!egou; W indica <ue c!egou no fim do 9etor.

9irtual int operator (( DEJ: aA o iterador mo9er adiante uma posi67o.

9irtual float operatorDE DEJ :"etorna o elemento da<uela posi67o do 9etor.

9irtual 9oid operatorV Dfloat entraEJ : Atribui a posi67o atual do 9etor.

int posDEJ : "etorna a posi67o DndiceE do 9etor em <ue o iterador se encontra; n7o 9irtual por<ue n7o faA sentido para um iterador de >r9ore por e:emplo. 127

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSit.! ; ar<ui9o com definicoes do iterador.

class iterador9etor T pri9ate: 9etor 9etorrefJ int posicaoJ public: iterador9etorD9etor o 9EJ int comecaDEJ int operator]DEJ int operator (( DEJ float operatorDE DEJ 9oid operatorV Dfloat entraEJ int posDEJ SSretorna posicao; nf 9irtual p< nf faA sentido pS ar9ore por e:. UJ

int iterador9etor::posDE T return posicaoJ U

int iterador9etor::operator]DE T return posicaoLV9etorref.ultimoDEJ U

128

iterador9etor::iterador9etorD9etor o 9etE:9etorrefD9etE T comecaDEJ U

int iterador9etor::comecaDE T posicaoV9etorref.primeiroDEJ return operator]DEJ U

int iterador9etor::operator ((DE T posicao((J return operator]DEJ U

9oid iterador9etor::operatorVDfloat entraE T 9etorrefmposicaonVentraJ U

float iterador9etor::operatorDE DE T float copiaJ copiaV9etorrefmposicaonJ return copiaJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

129

Programa principal; testes: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M Rinclude '9et.!' Rinclude 'it.!' mainDE T int repeteVWJ int indJ float itemJ 9etor meuDaEJ iterador9etor itmeuDmeuEJ

for Ditmeu.comecaDEJ]itmeuJ((itmeuE T cout LL '+ntre com 9alor da posicao:' LL itmeu.posDE LL 'Yn'J cin MM itemJ itmeuVitemJ U

for Ditmeu.comecaDEJ]itmeuJ((itmeuE coutLL itmeuDELL ' 'J cout LL 'Yn+ntre com o indice da posicao a atualiAar:Yn'J cin MM indJ cout LL '+ntre com o 9alor a incluir:'J cin MM itemJ meumindnVitemJ

for Dint iVmeu.primeiroDEJiLVmeu.ultimoDEJi((E coutLL meuminLL ' 'J cout LLendl LL 'Ma:imo:' LL meu.ma:imoDEJ

130

return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Coment>rios: O significado do operador 9oc@ <ue define; mas recomend>9el dar ao operador um significado prC:imo ao 8> definido na linguagem. Por e:emplo: o operador ( seria Ctimo para representar a concatena67o de dois ob8etos do tipo string. A sinta:e de cada operador fi:a: nOmero de operandos; preced@ncia... O leitor pode aprender mel!or tais regras gra9ando ou relendo os e:emplos de sobrecarga de cada operador e modificandoBos <uando necess>rio.

+:erccios: 2E%mplemente sobrecarga do operador de adi67o para o e:emplo #AD fra67o apresentado em 2.G.2.P

GECrie um #AD string e sobrecarregue o operador ( com o significado de concatena67o.

HE&eia os trec!os onde !> sobrecarga de operador; mas sem uso de friends em 2.G.2.

H.G. C&A00+0 A.0#"A#A0 + CO)C"+#A0 H.G.2. C&A00+ A.0#"A#A %#+"ADO" )este tCpico 9oc@ 9er> <ue podem e:istir classes <ue apenas definem protocolos ou interfaces para o uso e n7o podem ser instanciadas; as classes fil!as <ue !erdam sua interface <ue s7o instanci>9eis. )este e:emplo 9amos repetir o programa de H.2.4; sC <ue iremos incluir uma classe base abstrata para o iterador. O iterador de 9etor definido por !eran6a public da classe base abstrata de iteradores. +sta classe define o protocolo; a interface de iteradores para listas e outras estruturas. Perceba <ue algumas fun65es membro da classe base s7o despro9idas de implementa67o; porm nada impede <ue 9oc@ colo<ue como cCdigo dessas fun65es membro uma mensagem de erro do tipo '+rro; classe base n7o de9e ser instanciada]' ; como foi feito em alguns casos.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSe:9etit4 ; ar<ui9o com definicoes do iterador.

131

class iteradorT SSclasse base abstrata public: int comecaD9oidE Tcout LL '+rro; classe abstrata]'JU float operatorDEDE Tcout LL '+rro; classe abstrata]'J return WJU int operator]D9oidE Treturn WJU int operator ((DE Treturn WJU 9oid operatorVDfloat entraE TJU UJ

class iterador9etor:public iterador T pri9ate: 9etor 9etorrefJ int posicaoJ SSclasse fil!a acrescentando dados membro public: iterador9etorD9etor o 9EJ int comecaDEJ int operator]DEJ int operator (( DEJ float operatorDE DEJ 9oid operatorV Dfloat entraEJ int posDEJ SSretorna posicao; nf 9irtual p< nf faA sentido pS ar9ore por e:. SSesta e[ uma funcao membro acrescentada pela classe fil!a UJ

int iterador9etor::posDE T return posicaoJ 132

int iterador9etor::operator]DE T return posicaoLV9etorref.ultimoDEJ U

iterador9etor::iterador9etorD9etor o 9etE:9etorrefD9etE T comecaDEJ U

int iterador9etor::comecaDE T posicaoV9etorref.primeiroDEJ return operator]DEJ U

int iterador9etor::operator ((DE T posicao((J return operator]DEJ U

9oid iterador9etor::operatorVDfloat entraE T 9etorrefmposicaonVentraJ U

133

float iterador9etor::operatorDE DE T float copiaJ copiaV9etorrefmposicaonJ return copiaJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Os demais ar<ui9os s7o identicos aos do e:emplo sobre 9etores de H.2.4. BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file para classe 9etor Rinclude Liostream.!M Rinclude Lstdlib.!M SSe:itD2E

const int inicioVWJ SSinicio do 9etor

class 9etorT pri9ate: float^ 9J SSpode ser <ual<uer tipo <ue atenda as operacoes L M V int taman!oJ public: 9etor Dint taman!oE J floato operatormn Dint iEJ float ma:imoDEJ SSac!a o 9alor ma:imo do 9etor int primeiroD9oidEJ int ultimoD9oidEJ UJ 134

9etor::9etor Dint tamE T9Vned floatmtamnJ taman!oVtamJU

int 9etor::primeiro D9oidE Treturn inicioJU

int 9etor::ultimo D9oidE Treturn taman!oB2JU

floato 9etor::operatormnDint iE T if DiLW pp iMVtaman!oE Tcout LL ' ora dos limites] +:it program'J e:itD2EJU return 9minJ U

float 9etor:: ma:imoD9oidE Tint candidatoVinicioJ for Dint iVinicioJiLtaman!oJi((E if D9minM9mcandidatonE candidatoViJ return 9mcandidatonJU

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'e:9et4.!' Rinclude 'e:9etit4.!' mainDE T

135

int repeteVWJ int indJ float itemJ 9etor meuDaEJ iterador9etor itmeuDmeuEJ

for Ditmeu.comecaDEJ]itmeuJ((itmeuE T cout LL '+ntre com 9alor da posicao:' LL itmeu.posDE LL 'Yn'J cin MM itemJ itmeuVitemJ U

for Ditmeu.comecaDEJ]itmeuJ((itmeuE coutLL itmeuDELL ' 'J cout LL 'Yn+ntre com o indice da posicao a atualiAar:Yn'J cin MM indJ cout LL '+ntre com o 9alor a incluir:'J cin MM itemJ meumindnVitemJ

for Dint iVmeu.primeiroDEJiLVmeu.ultimoDEJi((E coutLL meuminLL ' 'J cout LLendl LL 'Ma:imo:' LL meu.ma:imoDEJ

return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: +ntre com 9alor da posicao:W G 136

+ntre com 9alor da posicao:2 Ha +ntre com 9alor da posicao:G QG +ntre com 9alor da posicao:H G +ntre com 9alor da posicao:P H G Ha QG G H +ntre com o indice da posicao a atualiAar: W +ntre com o 9alor a incluir:2 2 Ha QG G H Ma:imo:QG

H.G.G. ACOP&AM+)#O D+ M+)0A*+)0 /> dissemos <ue um ob8eto de uma classe fil!a garante no mnimo o comportamento 'be!a9iour' de seu pai. Por este moti9o podemos atribuir um ob8eto da classe fil!a a uma 9ari>9el da classe pai; mas n7o o contr>rio. Acoplamento dinNmico mostrar> <ue poss9el faAer com <ue o compilador e:ecute a implementa67o dese8ada de uma fun67o membro redefinida para classes !erdeiras; mesmo no caso de c!amada de fun67o membro para uma 9ari>9el de um supertipo Dclasse paiE contendo um ob8eto de um subtipo Dclasse fil!aE. %sto nos permitir> construir listas !etorog@neas H.G.P. H.G.G.2. CA0O +0#g#%CO BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class pai T public: 9oid printD9oidE Tcout LL '0ou da classe pai'LLendlJU UJ

137

class fil!o:public pai T pri9ate: public: 9oid printD9oidE Tcout LL '0ou da classe fil!a' LL endlJU UJ

9oid mainDE T fil!o ef2J SSestatica fil!o numero 2 pai ep2J SSestatica pai numero 2 ef2.printDEJ SS9aria9el estatica contendo fil!o ep2.printDEJ SS9aria9el estatica contendo pai ep2Vef2J SS9aria9el estatica do tipo pai contendo fil!o con9ertido no pai ep2.printDEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Diagrama das classes:

A classe fil!a garante no mnimo o mesmo comportamento; 'be!a9iour' <ue a classe pai; podendo acrescentar ou redefinir parte do <ue foi !erdado. Por este moti9o; uma 9ari>9el da classe pai pode receber um ob8eto da classe fil!a; o comportamento da classe pai fica garantido e o restante Do <ue a classe fil!a acrescentouE perdido. /> uma 9ari>9el da classe fil!a n7o pode receber um ob8eto da classe pai; por<ue as fun65es membro acrescentadas passam a n7o faAer sentido.

138

"esultado do programa: 0ou da classe fil!a 0ou da classe pai 0ou da classe pai

+:plica67o do programa; passo a passo: fil!o ef2J

Declara67o de uma 9ari>9el da classe fil!a.

pai ep2J

Declara67o de uma 9ari>9el da classe pai; menor ou igual <uantidade de membros <ue a fil!a.

ef2.printDEJ

Mostra a fun67o da classe fil!a; a <ual pertence ef2 e seu conteOdo.

ep2.printDEJ

Mostra a fun67o da classe de ep2 <ue a classe pai.

ep2Vef2J

Atribui o conteOdo de ef2 a ep2; ou se8a atribui um fil!o a um pai. O fil!o tem os dados membros e fun65es membros acrescentados; descartados e se torna do tipo pai. +ssa con9ers7o irre9ers9el no caso.

ep2.printDEJ

Mostra a fun67o da classe de ep2 <ue a classe pai; a mesma de seu conteOdo.

139

H.G.G.G. D%)lM%CO 0+M ?%"#$A& BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class pai T public: 9oid printD9oidE Tcout LL '0ou da classe pai'LLendlJU UJ

class fil!o:public pai T pri9ate: public: 9oid printD9oidE Tcout LL '0ou da classe fil!a' LL endlJU UJ

9oid mainDE T fil!o ef2J SSestatica fil!o numero 2 pai ep2J SSestatica pai numero 2 pai^ pp2J SSponteiro pai numero 2 ef2.printDEJ SS9aria9el estatica contendo fil!o ep2.printDEJ SS9aria9el estatica contendo pai pp2Voep2J 140

pp2BMprintDEJ SSponteiro de pai;apontando para pai

pp2Voef2J pp2BMprintDEJ SSponteiro de pai apontando para fil!o

ep2Vef2J SS9aria9el estatica do tipo pai contendo fil!o con9ertido no pai ep2.printDEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 0ou da classe fil!a 0ou da classe pai 0ou da classe pai 0ou da classe pai 0ou da classe pai

Coment>rios: )ote <ue a fun67o membro e:ecutada escol!ida de acordo <ue a 9ari>9el e n7o de acordo com o conteOdo desta; da mesma forma <ue no e:emplo anterior.

H.G.G.H. D%)lM%CO COM ?%"#$A& BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class pai T public: 141

9irtual 9oid printD9oidE Tcout LL '0ou da classe pai'LLendlJU UJ

class fil!o:public pai T pri9ate: public: 9irtual 9oid printD9oidE Tcout LL '0ou da classe fil!a' LL endlJU UJ

9oid mainDE T fil!o ef2J SSestatica fil!o numero 2 pai ep2J SSestatica pai numero 2 pai^ pp2J SSponteiro pai numero 2 ef2.printDEJ SS9aria9el estatica contendo fil!o ep2.printDEJ SS9aria9el estatica contendo pai pp2Voep2J pp2BMprintDEJ SSponteiro de pai;apontando para pai

pp2Voef2J pp2BMprintDEJ SSponteiro de pai apontando para fil!o

142

ep2Vef2J SS9aria9el estatica do tipo pai contendo fil!o con9ertido no pai ep2.printDEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 0ou da classe fil!a 0ou da classe pai 0ou da classe pai 0ou da classe fil!a 0ou da classe pai

Coment>rios: Perceba <ue 9irtual faA com <ue a fun67o membro a e:ecutar se8a escol!ida de acordo com o conteOdo da 9ari>9el ou ponteiro e n7o de acordo com o tipo da 9ari>9el ou ponteiro DrepositCriosE. ?irtual n7o tem efeito no uso est>tico de ob8etos; ou se8a a fun67o membro ser> escol!ida de arcordo com o tipo da 9ari>9el DrepositCrioE.

+:erccios: 2E%mplemente em suas classes fun65es membro <ue imprimem uma frase identificando o tipo da classe; por e:emplo: '+u sou a classe conta corrente; especialiAa67o de conta bancaria.'

H.G.H. CO)#A0 .A)Cg"%A0 )este programa e:emplo 9amos definir uma classe abstrata c!amada conta. +sta classe define a interface de contas banc>rias; <ue se constitui das opera65es: deposita; saca; getIsaldo; getI8urosn D8uros <uando saldo est> negati9oE; getI8urosp D8uros <uando o saldo est> positi9oE e computa Dcalcula 8urosE. #odos as fun65es membro s7o '9irtuais' e:ceto destrutor .

Preste aten67o nas especifica65es a seguir elas s7o detal!adas e importantssimas para o entendimento do programa: Da classe base abstrata descrita acima; criamos duas classes concretas com as seguintes propriedades: 2BConta corrente: B)este tipo de conta as computa65es dos 8uros s7o feitas pelo banco diariamente. 143

BPermite ta:a de 8uros diferente para saldos negati9os e positi9os. BPossui um atributo menor <ue Aero c!amado limite. 0a<ues <ue le9em o saldo abai:o deste 9alor s7o recusados. +sta defini67o acima n7o implica <ue o saldo ten!a <ue estar sempre acima de limite. +le sC 9ai para 9alores menores <ue se os 8uros da d9ida o fiAerem e n7o o cliente. BO 9alor de limite definido na cria67o da conta; instancia67o. B ica claro <ue este tipo de conta permite saldos negati9os. . BA ta:a de 8uros para saldo positi9o Aero ou se8a; n7o !> rendimento.

GBPoupan6a: BPossui uma data de ani9ers>rio; sC neste dia <ue se computa 8uros ou se8a mensalmente. BOs 8uros acrescentados s7o referentes ao saldo apCs a Oltima computa67o; isto significa <ue depCsitos intermedi>rios n7o rendem 8uros. B0e !ou9er algum sa<ue <ue n7o se8a no dia da computa67o os 8uros referentes a a<uele m@s s7o cancelados. B0C permitido saldo maior ou igual a Aero.

Outra classe foi criada no programa: a classe data <ue armaAena datas <uais<uer. Por <uest5es de simplicidade a classe data <ue simplesmente uma classe au:iliar foi implementada com o mnimo necess>rio para o funcionamento e demonstra67o do programa. A mel!oria desta classe sugerida como e:erccio.

#Cpicos abordados: un65es membro 9irtual e pure 9irtual. Ob8etos constantes.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file for conta.! SStodas as funcoes recebem uma data por<ue o e:trato presisa disso. const float 8pV.WaJ S^8uros padrao^S const float 9aAioVW.WJ const float 8nuloVW.WJ const float lminVBPWW.WJ

enum .ooleanT A&0+;#"$+UJ typedef float din!J

144

float absDfloat aEJ SSfuncao 9alor absoluto

class dataT SSdefinir outras operacoes elaborar mais pri9ate: int diaJ int mesJ int anoJ public: dataDE TdiaV2JmesV2JanoV3aJU SSdefault constructor; importante para agregacao dataDint d;int m;int aE TdiaVdJmesVmJanoVaJU int getIdiaD9oidE Treturn diaJU int getImesD9oidE Treturn mesJU int getIanoD9oidE Treturn anoJU UJ

const data ddefD2;2;3WEJ SSob8eto constanteJ

class contaT SSpure 9irtual functions in abstract base class protected: din! saldoJ SSesse e[ o din!eiro na conta. float 8urospJ SS8uros pS saldo positi9o float 8urosnJ SS8uros pS saldo negati9o

public: SSpure 9irtual functions in abstract base class conta Ddin! <uantiaV9aAio;float ta:apV8p;float ta:anV8p;data ddVddefEJ 9irtual .oolean computaDdata ddEVWJ SScomputa 8uros da conta 9irtual din! getIsaldoDdata ddEconstVWJ SSretorna conteudo da conta 9irtual float getI8urosnDdata ddEconstVWJ SScriar as respecti9as funcoes set: setI8uros 9irtual float getI8urospDdata ddEconstVWJ 9irtual .oolean depositaDdin! <uantia;data ddEVWJ 145

9irtual din! sacaDdin! <uantia;data ddEVWJ fcontaDETUJ UJ

class contacorrente:public contaT pri9ate: din! limJ SSsa<ues <ue le9am saldo para bai:o deste limite sao blo<ueados. public: contacorrenteDdin! <uantiaV9aAio;float ta:anV8p;din! minVlmin;data ddVddefEJ SSso computa <do neg. .oolean computaDdata ddEJ SSpara esse tipo de conta e[ diario. Dpoupanca mensalE din! getIsaldoDdata ddEconstJ SSretorna conteudo da conta float getI8urosnDdata ddEconstJ SScriar as respecti9as funcoes set: setI8uros float getI8urospDdata ddEconstJ .oolean depositaDdin! <uantia;data ddEJ din! sacaDdin! <uantia;data ddEJ fcontacorrenteDETUJ SSpode deletar de<ue com operacoes sobre conta De:tratoE UJ

class poupanca:public contaT pri9ate: data ani9ersarioJ SSdia do mes <ue a poupanca faA ani9ersario. .oolean computarJ SS2:computar sobre ultimo; W:rendimento perdido; sa<ue din! ultimoJ SSos 8uros sao sobre o 9alor depois da ultima computacao. SSo <ue depositou nao importa; se sacou perdeu rendimento public: poupancaDdin! <uantiaV9aAio;float ta:apV8p;data ddVddefEJ SSmensalmente .oolean computaDdata ddEJ SS .oolean: "endimento nao foi perdidoK din! getIsaldoDdata ddEconstJ SSretorna conteudo da conta float getI8urosnDdata ddEconstJ SScriar as respecti9as funcoes set: setI8uros

146

float getI8urospDdata ddEconstJ .oolean depositaDdin! <uantia;data ddEJ din! sacaDdin! <uantia;data ddEJ fpoupancaDETUJ SSpode deletar de<ue com operacoes sobre conta De:tratoE UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSfile conta.cpp Rinclude 'contaG.!' float absDfloat aE T if DaLW.WE aVBaJ return aJ U

conta::contaDdin! <uantia;float ta:ap;float ta:an;data ddE T saldoVabsD<uantiaEJ 8urospVabsDta:apEJ 8urosnVabsDta:anEJ U

poupanca::poupancaDdin! <uantia;float ta:ap;data ddE: contaD<uantia;ta:ap;8nulo;ddE Tani9ersarioVddJ computarV#"$+J ultimoVabsD<uantiaEJUJ

.oolean poupanca::computaDdata ddE T if Dani9ersario.getIdiaDEVVdd.getIdiaDEE if DcomputarE TsaldoVultimo^8urosp(saldoJreturn #"$+JU 147

else T computarV#"$+J ultimoVabsDsaldoEJ U

return A&0+J U

din! poupanca::getIsaldoDdata ddEconst Treturn saldoJU

float poupanca::getI8urospDdata ddEconst T return 8urospJ U

float poupanca::getI8urosnDdata ddEconst T return 8urosnJ U

.oolean poupanca::depositaDdin! <uantia;data ddE T saldo(VabsD<uantiaEJ return #"$+JU

din! poupanca::sacaDdin! <uantia;data ddE T if DDsaldoBabsD<uantiaEEM9aAioE TsaldoBVabsD<uantiaEJ computarV A&0+J return <uantiaJU else return 9aAioJ U

contacorrente::contacorrenteDdin! <uantia;float ta:an;din! min;data ddE: contaD<uantia;8nulo;ta:an;ddE Tif DminL9aAioE limVminJ else limVBminJU

.oolean contacorrente::computaDdata ddE SSso computo 8uros negati9os.

148

T if DsaldoL9aAioE saldoVsaldo^8urosn(saldoJ else saldoVsaldo^8urosp(saldoJ return #"$+J U

din! contacorrente::getIsaldoDdata ddE const Treturn saldoJU

float contacorrente::getI8urosnDdata ddE const Treturn 8urosnJU

float contacorrente::getI8urospDdata ddE const Treturn 8urospJU

.oolean contacorrente::depositaDdin! <uantia;data ddE T saldo(V<uantiaJ return #"$+J U

din! contacorrente::sacaDdin! <uantia;data ddE T <uantiaVabsD<uantiaEJ if DDsaldoB<uantiaEMlimE T saldoBV<uantiaJ return <uantiaJU else return 9aAioJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

149

SSmain file. Rinclude Liostream.!M Rinclude 'contaG.!'

mainDE T data !o8eD4;2W;3aEJ contacorrente min!accD2HPW.HP;W.2;BaWW.W;!o8eEJ poupanca min!apD2aWW.WW;W.2;!o8eEJ

cout LL '0aldo:' LLmin!acc.getIsaldoD!o8eELLendlJ min!acc.depositaD2W.WW;!o8eEJ cout LL '0aldo apos depositar 2W.WW:'LLmin!acc.getIsaldoD!o8eELLendlJ min!acc.computaD!o8eEJ cout LL '0aldo apos computar:' LLmin!acc.getIsaldoD!o8eELLendlJ min!acc.sacaD2aWW.WW;!o8eEJ cout LL '0aldo apos sacar:' LL min!acc.getIsaldoD!o8eELLendlJ min!acc.computaD!o8eEJ cout LL '0aldo apos computar:' LL min!acc.getIsaldoD!o8eE LLendlJ cout LL '#a:a de 8uros:' LL min!acc.getI8urosnD!o8eELLendlJ cout LL endlJ cout LL 'Agora a poupanca:'J cout LL '0aldo apos criacao:' LL min!ap.getIsaldoD!o8eE LL endlJ cout LL '/uros de saldo positi9o:' LL min!ap.getI8urospD!o8eELL endlJ cout LL 'Computando:' LL endlJ min!ap.computaD!o8eE J cout LL '0aldo apos computa:' LL min!ap.getIsaldoD!o8eE LL endlJ cout LL '"etirando aWW.WW:' LLendlJ min!ap.sacaDaWW.WW;!o8eE J cout LL '0aldo apos retirada:' LL min!ap.getIsaldoD!o8eE LL endlJ cout LL 'Computando:'LLendlJ

150

min!ap.computaD!o8eEJ cout LL '0aldo apos computa:' LL min!ap.getIsaldoD!o8eE LL endlJ cout LL 'Depositando2WW e Computando:'LLendlJ min!ap.depositaD2WW.WW;!o8eEJ min!ap.computaD!o8eEJ cout LL '0aldo apos computa:' LL min!ap.getIsaldoD!o8eE LL endlJ cout LL '"etirando mais do <ue pode:GWWW.WW' LL endlJ min!ap.sacaDGWWW.WW;!o8eEJ cout LL '0aldo apos saca GWWW.WW:' LL min!ap.getIsaldoD!o8eE LL endlJ return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado de teste do programa: 0aldo:2HPW.HP 0aldo apos depositar 2W.WW:2HaW.HP 0aldo apos computar:2HaW.HP 0aldo apos sacar:B2P3.44 0aldo apos computar:B24P.4G4 #a:a de 8uros:W.2

Agora a poupanca:0aldo apos criacao:2aWW /uros de saldo positi9o:W.2 Computando: 0aldo apos computa:24aW "etirando aWW.WW: 0aldo apos retirada:22aW Computando: 0aldo apos computa:22aW Depositando2WW e Computando: 0aldo apos computa:2H4a 151

"etirando mais do <ue pode:GWWW.WW 0aldo apos saca GWWW.WW:2H4a

Coment>rios: Obser9e <ue ob8etos da classe base n7o podem ser criados; 9oc@ n7o pode ter um ob8eto instanciado; mas ela pode ser usada. Declarar um ponteiro: conta^ ; n7o significa criar um ob8eto. +sse ponteiro pode referenciar <ual<uer ob8eto da !ierar<uia Dconta corrente ; poupan6aE ; 9eremos seu uso mais tarde.

Curiosidade: ?e8a a importNncia da cria67o de componentes de softdare seguros; de f>cil modifica67o e reutiliA>9eis: Muitos programas <ue tin!am <ue faAer uma representa67o de datas est7o sendo re9istos de9ido a mudan6a do sculo e outros pro9a9elmente fal!ar7o de9ido a esta mudan6a. 0e8a pela restri67o da fai:a de 9alores de anos com m>:imo em GWWW ou mesmo por outros moti9os <ue n7o le9assem este fator em conta; como a subtra67o entre dois anos distintos e:emplo GWW2 e 2333 armaAenados na forma W2 e 33. O e:erccio a pede <ue 9oc@ mel!ore a classe data apresentada neste e:emplo. Com um pou<uin!o de pes<uisa 9oc@ pode criar meios de c!ecar anos bisse:tos DjPE; meses com nOmeros de dias diferentes e '9iradas' de sculo.

+:erccios: 2E?oc@ seria capaA de usando princpios de agrega67o implementar uma estrutura de armaAenamento Dlista; 9etorE na classe conta e us>Bla para sal9ar as opera65es de modo <ue esta estrutura representasse o e:tratoK De <ue modo esta idia pode ser adaptada para criar estruturas <ue faAem um !istCrico das fun65es membro c!amadas para classes <uais<uerK ?oc@ pode usar este tipo de informa67o da classe de armaAenagem para debugar seus programasK

^GEPor<ue n7o !ou9e preocupa67o de esconder fun65es membro como computaK Algum poderia computar 8uros infinitamente em sua prCpria conta..... Para responder pense no seguinte: $ma pessoa cliente de uma conta ou de um bancoK $m banco mantm uma conta ou uma pessoa mantm uma contaK Monte um diagrama de ob8etos contendo um banco; 9>rias contas ; 9>rias pessoas e as respecti9as associa65es.

HEModifi<ue este programa; implemente outros tipos de contas <ue 9oc@ con!ece.

PEApCs ler o tCpico de tratamento de e:ce65es; adicione 'e:ception !andling' para argumentos in9>lidos tipo min!aconta.depositaDB2W.HE ]

aEModifi<ue a classe data; crie restri65es para datas in9>lidas e outras fun65es membro <ue 8ulgar importantes como: printIdataDE. ?e8a coment>rio neste e:emplo.

H.G.P. &%0#A b+#+"O*q)+A D+ CO)#A0 .A)Cg"%A0.

152

&ista !eterog@nea de contas banc>rias de e:emplo anterior; obten67o do saldo total das contas corrente e poupan6as da lista Dno caso 9etorE.

#Cpicos abordados: 'Dynamic binding'; n7o aborda type casting; 9ai ser abordado num programa mais completo: a simula67o dirigida a e9entos de P.4.G .

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSprograma principal Rinclude Liostream.!M Rinclude 'contaG.!' SSS const int taman!oVHJ mainDE T din! somaVW.WJ contacorrente cc2DaWW.WW;W.2;BPWWEJ SS0A&DO;/$"O0;&%M%#+ )+* contacorrente ccGDaWW.WW;W.2a;BPWWEJ poupanca p2DaWW.WW;W.2EJ SS0A&DO; /$"O0

conta^ l!eterogeneamtaman!onVTocc2;occG;op2UJ SSlista !eterogenea for Dint iVWJiLtaman!oJi((E soma(Vl!eterogeneaminBMgetIsaldoDddefEJ cout LL '#otal armaAenado nas contas:' LL soma LLendlJ return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

+:erccios: 2EMel!ore o e:emplo de lista !eterog@nea dado usando uma lista com 'templates' de P.H.?oc@ de9e definir a lista para trabal!ar com ponteiros de contas.

GE Considere as seguintes declara65es em C((:

153

class # T public: 9irtual 9oid fD9oidE Tcout LL '+stou em #'JU UJ

class 0:public # T public: 9irtual 9oid fD9oidE Tcout LL '+stou em 0'JU UJ

# :J SS9aria9el est>tica 0 yJ SS9aria9el estatica; s de subclasse #^ pJ SSapontador para tipo base t.

e as seguintes in9oca65es de opera65es:

pVo: J pBMfDEJ SSprimeira pVoyJ pBMfDEJ SSsegunda :.fDEJ SSterceira y.fDEJ SS<uarta :VyJ :.fDE SS<uinta "esponda <ual o resultado na tela de cada uma destas c!amadas. P. #sP%CO0 A?A),ADO0 154

#Cpicos a9an6ados apresenta recursos e:tremamente Oteis para programa67o orientada a ob8etos; por isso con9m ler este tCpico somente <uando 9oc@ ti9er uma boa base de programa67o C((. Ad<uira pr>tica. A ordem em <ue os e:emplos s7o apresentados semel!ante a ordem de tCpicos inicial. Como tCpico a9an6ado de +ncapsulamento temos friends; como tCpico a9an6ado de !eran6a temos !eran6a mOltipla; como tCpico a9an6ado de polimorfismo; temos polimorfismo paramtrico. Os demais tCpicos n7o est7o diretamente relacionados com os anteriores.

P.2. "%+)D0 riends permite <ue uma classe toda ou uma fun67o membro acesse atributos encapsulados de outra classe. Por este moti9o; friends representa uma <uebra do encapsulamento e de9e portanto ser usado com muita cautela. )7o raro programadores descobrem <ue o uso de certos princpios de orienta67o a ob8etos e9ita programar usando demasiadamente friends. 0e 9oc@ 9ai aplicar este recurso; analise bem as outras possibilidades; c!e<ue outras abordagens antes. )o9amente nos deparamos com um <ualificador ou 'specifier'; mas este tem uma diferen6a; n7o basta diAer <ue uma classe ou fun67o membro amiga; 'friend'; preciso diAer de <ue classe ela amiga riends muito usado em con8unto com operadores. Operadores s7o fre<uentemente usados para implementar opera65es entre tipos en<uanto <ue fun65es membro comuns s7o mais usadas para passagem de mensagens alterando o estado de um Onico ob8eto; segundo alguns parNmetros; normalmente tipos simples.

P.2.2. $MA C&A00+ P+"M%#%)DO AC+00O A O$#"A 0upon!a <ue 9oc@ est> trabal!ando em con8unto com um colega no desen9ol9imento de um softdare. ?oc@ faA a interface gr>fica en<uanto <ue seu colega est> implementado as classes estritamente usu>rias da interface gr>fica. Como seu colega n7o sabe usar sua interface gr>fica ainda; ele define algumas classes dele como friends de suas classes de cai:as de di>logos e 8anelas. Assim 9oc@ gan!a acesso as defini65es pri9ate e public dele nas suas classes. +le sC precisa perguntar a 9oc@ <uais os nomes das suas classes. Como 9oc@ descon!ece a implementa67o das classes de seu colega; ele define pensando em 9oc@ e tambm por raA5es de portabilidade; fun65es membro <ue retornam os dados membros mais Oteis aos usu>rios das classes. Porm estas fun65es n7o retornam todos os dados membros por<ue alguns ob8etos <ue ele est> definindo s7o estruturas de aloca67o dinNmica como >r9ores e muito difcil pre9er <ue tipo de acesso ser> feito nas estruturas. +ste o tema do e:emplo seguinte; sC <ue n7o iremos definir nen!uma interface gr>fica; 9amos apenas usar cout simulando uma sada de tela mais complicada; como por e:emplo numa cai:a de dialogo. )osso ob8eto n7o define estruturas de aloca67o dinNmica nen!uma; afinal o e:emplo tem <ue ser simples e ob8eti9o.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

class relogio T

155

friend class cai:aIdeImensagemJ SSpermitiu acesso as definicoes pri9ate e public pri9ate: int !oraJ int minutoJ int segundoJ SSatributos pri9ate; encapsulados public: relogioDint !;int m;int sE T!oraV!J minutoVmJ segundoVsJU UJ

class cai:aIdeImensagemT public: 9oid imprimeDrelogio aE T cout LL a.!ora LL ':' LL a.minuto LL ':' LL a.segundo LL endlJ U UJ

9oid mainDE T relogio meurole:D22;HW;2WEJ cai:aIdeImensagem ati9aJ ati9a.imprimeDmeurole:EJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: 22:HW:2W

156

Curiosidade: +:istem 'libraries' em C(( <ue permitem programar em ambientes gr>ficos como o cindods sem saber muitos detal!es. +stas 'libraries' definem ob8etos como cai:as de dialogo; gerenciadores de e9entos; etc. O uso agora diferente do descrito no e:emplo: O programador sC 9ai utiliAar os recursos gr>ficos padr7o definidos pela 'libraries'. Os ob8etos definidos para uso na interface gr>fica s7o agregados ao seu programa e podem ser c!amados de dentro das implementa65es das fun65es membro das suas classes.

+:erccios: ^2EDefina um iterador para a classe lista; assim como foi definido para a classe 9etor em H.2.4. ?oc@ pro9al9elmente ter> <ue usar no65es de classes friends. Como e9itar corromper o estado da lista entre acessos a posi65es e incrementos do iterador alternadosK $ma sugest7o proibir as fun65es membro insere incio; insere Oltimo; en<uanto se faA uso do iterador. +ste um e:erccio a9an6ado. Outra sugest7o deri9ar uma classe a partir da base da !ierar<uia; e para esta classe definir o iterador.

GE$m bom e:emplo de uso de friends o seguinte: supon!a uma classe <ue representa uma reta em tr@s dimens5es; e outra <ue representa um plano. $se friends para criar em uma dessas classes; ou em ambas; um a fun67o membro <ue determina o ponto de interse67o entre uma reta e um plano. 0e 9oc@ gosta de computa67o gr>fica; ent7o e:iste uma srie de tipos abstratos de dados <ue 9oc@ pode definir para construir seus programas em C((. Algum pode argumentar <ue a interse67o descrita acima poderia ser obtida sem o uso de friends; isto por<ue os dados membros das classes usados para calcular a interse67o poderiam ser lidos; obtidos atra9s de fun65es membro do tipo : getI:DEJ. %sto 9erdade; mas em termos de efici@ncia; tal9eA n7o de encapsulamento friends mel!or. +:pli<ue por<ue.

HE ?oc@ se lembra do e:emplo das contas banc>riasK Mel!ore este programa implementado a fun67o de transfer@ncia de <uantias entre contas; 9oc@ ac!a mel!or definiBla como friendK Por<ueK Fuantas contas ela afetaK

PEDefina a classe banco como friend de todas as classes conta banc>ria. Muito bem; dei:e como pri9ate todos os mtodos <ue o dono da conta soAin!o n7o pode c!amar; tais como computa. O banco de9e conter refer@ncias para todas suas contas; as contas de9em ter um nOmero identificador de conta. As opera65es sobre contas de9em ser feitas agora 9ia banco; isto n7o impede <ue as contas atendam a opera65es usuais como deposita; mas elas tem <uer ser pri9ate agora.. ?e8a H.G.H.

P.2.G. OP+"ADO"+0 + "%+)D0 ?amos tomar o e:emplo do tipo abstrato de dados fra67o de 2.P.2 e acrescentar sobrecarga de operador e fun65es friends. ica faltando somente tratamento de e:ce65es <ue sugerido como e:erccio no captulo respecti9o.

#Cpicos abordados: 0obrecarga de operador; 'copy constructor' ;fun65es friends. = uma implementa67o bastante completa e port>9el de um #AD; use como refer@ncia para sinta:e de sobrecarga de operadores.

157

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS+ste programa implementa o tipo fracao. Rifndef O Ib SSdireti9as do compilador Rdefine O Ib

long mdcDlong n;long dE SSma:imo di9isor comum SSmetodo de +uclides T if DnLWE nVBnJ if DdLWE dVBdJ d!ile Dd]VWE T long rVn j dJ SS jVMOD nVdJ dVrJ U return nJ UJ

class fracao T pri9ate: long numJ long denJ public: 9oid simplificaD9oidEJ SSsimplificacao fracaoDfracao otEJ SScopy constructor 158

fracaoDE TnumVWJ denV2JU SSconstrutor 9aAio. fracaoDconst long t;const long mEJ fracaoDconst long tE TnumVtJdenV2JU ffracaoDE TUJ SS)ao precisa faAer nada long getInumD9oidE Treturn numJU long getIdenD9oidE Treturn denJU

SSoperacoes matematicas basicas friend fracao operator( Dconst fracaoo f;const fracaoo 8EJ friend fracao operatorB Dconst fracaoo f;const fracaoo 8EJ friend fracao operator^ Dconst fracaoo f;const fracaoo 8EJ friend fracao operatorS Dconst fracaoo f;const fracaoo 8EJ

SSoperadores de comparacao friend int operatorVV Dconst fracaoo s;const fracaoo tEJ friend int operator]V Dconst fracaoo s;const fracaoo tEJ friend int operatorMV Dconst fracaoo s;const fracaoo tEJ friend int operatorLV Dconst fracaoo s;const fracaoo tEJ friend int operatorM Dconst fracaoo s;const fracaoo tEJ friend int operatorL Dconst fracaoo s;const fracaoo tEJ

SSoperadores de atribuicao fracaoo operatorV Dconst fracaoo tEJ fracaoo operator(V Dconst fracaoo tEJ fracaoo operatorBV Dconst fracaoo tEJ fracaoo operator^V Dconst fracaoo tEJ fracaoo operatorSV Dconst fracaoo tEJ

SSoperadores de input output

159

friend istreamo operatorMM Distreamo ci;fracaoo fEJ friend ostreamo operatorLL Dostreamo co;const fracaoo fEJ

SSoperadores de con9ersao de tipos operator doubleDE constJ operator floatDE constJ operator longDE constJ operator intDE constJ UJ Rendif

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SScodigo para a classe fracao Rinclude Liostream.!M Rinclude Lmat!.!M Rinclude Liomanip.!M Rinclude Lstdio.!M Rinclude 'of.!'

fracao::fracaoDfracao otE SScopy constructor T numVt.numJ denVt.denJ U

9oid fracao::simplificaD9oidE T long commdJ commdVmdcDnum;denEJ SSdi9isor comum 160

numVnumScommdJ denVdenScommdJ if DdenLWE T denVBdenJ numVBnumJUJ SSmo9e o sinal pS cima U

fracaoo fracao::operator(V Dconst fracaoo tE T numVnum^t.den(den^t.numJ denVden^t.denJ simplificaDEJ return ^t!isJ U

fracao::fracaoDconst long t;const long mE T numVtJ denVmJ simplificaDEJ SSt!isBMsimplifica U

fracao operatorS Dconst fracaoo f;const fracaoo 8E T fracao gDf.num^8.den;f.den^8.numEJ g.simplificaDEJ SSesse metodo nao pertence a g; mas ela c!ama SSg.simplificaDEJ isto e[ permitido a<ui mesmo com simplifica SScomo pri9ate. return gJ U

161

fracao operator( Dconst fracaoo f;const fracaoo 8E T fracao gDDf.num^8.denE(Df.den^8.numE;8.den^f.denEJ SSretorna 9aria9el g.simplificaDEJ return gJ U

fracao operatorB Dconst fracaoo f;const fracaoo 8E T fracao gDDf.num^8.denEBDf.den^8.numE;8.den^f.denEJ SSretorna 9aria9el g.simplificaDEJ return gJ U

fracao operator^ Dconst fracaoo f;const fracaoo 8E T fracao gDf.num^8.num;f.den^8.denEJ SSDf.num^8.numESDf.den^8.denE g.simplificaDEJ return gJ U

ostreamo operatorLL Dostreamo co;const fracaoo fE T co LL 'D' LL f.num LL 'S' LL f.den LL 'E'J return coJ U 162

istreamo operatorMM Distreamo ci; fracaoo fE T long gcdi9J SSmel!orar; ler mais sobre cin. ci MM f.num MM f.denJ gcdi9VmdcDf.num;f.denEJ f.numVf.numSgcdi9J f.denVf.denSgcdi9J return ciJ U

int operatorVV Dconst fracaoo s;const fracaoo tE T return DDs.num^t.denEVVDs.den^t.numEEJ SS9e8a operacoes matematicas com fracao U

int operator]V Dconst fracaoo s;const fracaoo tE T return DDs.num^t.denE]VDs.den^t.numEEJ U

int operatorLV Dconst fracaoo s;const fracaoo tE T return DDs.num^t.denELVDs.den^t.numEEJ U

int operatorL Dconst fracaoo s;const fracaoo tE T return DDs.num^t.denELDs.den^t.numEEJ

163

int operatorM Dconst fracaoo s;const fracaoo tE T return DDs.num^t.denEMDs.den^t.numEEJ U

int operatorMV Dconst fracaoo s;const fracaoo tE T return DDs.num^t.denEMVDs.den^t.numEEJ U

fracaoo fracao::operatorV Dconst fracaoo tE SSe<ui9ale a copy constructor T numVt.numJ denVt.denJ return ^t!isJ U

fracaoo fracao::operatorBV Dconst fracaoo tE T numVnum^t.denBden^t.numJ denVden^t.denJ simplificaDEJ return ^t!isJ SSponteiro para o proprio ob8eto Do apontado por t!isE U

fracaoo fracao::operator^V Dconst fracaoo tE T numVnum^t.numJ 164

denVden^t.denJ simplificaDEJ return ^t!isJ U

fracaoo fracao::operatorSV Dconst fracaoo tE T numVnum^t.denJ denVden^t.numJ simplificaDEJ return ^t!isJ U

fracao::operator doubleDE const T double dblJ dblVDdoubleDnumESdoubleDdenEEJ return dblJ U

fracao::operator floatDE const T float fltJ fltVDfloatDnumESfloatDdenEEJ return fltJ U

fracao::operator longDE const T long lngJ lngVnumSdenJ

165

return lngJ U SScon9erte fracao para long

fracao::operator intDE const T int ntgrJ ntgrVintDnumSdenEJ return ntgrJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSprograma principal; testes e demonstracao Rinclude Liostream.!M Rinclude 'of.!' SSdefinicao da fracao Rinclude Lstdio.!M mainDE T c!ar gJ cout LL ' +ntre com fracao a: 'J fracao a;bJ cin MM aJ coutLL 'a'LL a LL 'Yn'J cout LL ' +ntre fracao b:'J cin MM bJ cout LL 'b' LL b LL 'Yn'J fracao cJ cVa(bJ cout LL 'cVa(b ' LL c LL 'Yn'J 166

fracao dDcEJ cout LL 'fracao dDcE'LL d LL endlJ SSe[ o <ue c!amamos de copy constructor cout LL 'a^b ' LL Da^bELL 'Yn'J cout LL 'aBb ' LL DaBbELL 'Yn'J cout LL 'aSb ' LL DaSbELL 'Yn'J cout LL 'aMb ' LL DaMbELL 'Yn'J cout LL 'aLb ' LL DaLbELL 'Yn'J cout LL 'aLVb ' LL DaLVbELL 'Yn'J cout LL 'aMVb ' LL DaMVbELL 'Yn'J cout LL 'aVVb ' LL DaVVbELL 'Yn'J cout LL 'a]Vb ' LL Da]VbELL 'Yn'J cVaJ a^VbJ cout LL 'a^Vb ' LL aLL 'Yn'J aVcJ aSVbJ cout LL 'aSVb ' LL aLL 'Yn'J aVcJ a(VbJ cout LL 'a(Vb ' LL a LL 'Yn'J aVcJ aBVbJ cout LL 'aBVb ' LL aLL 'Yn'J aVcJ cout LL 'longDaE ' LL longDaE LL 'Yn'J cout LL 'doubleDaE ' LL doubleDaE LL 'Yn'J cout LL 'intDaE ' LL intDaE LL 'Yn'J cout LL 'floatDaE ' LL floatDaE LL 'Yn'J cin MM gJ return WJ

167

U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: +ntre fracao a:3 Q aD3SQE +ntre fracao b:3 P bD3SPE cVa(b DGeSQE fraction dDcEDGeSQE a^b DQ2SHGE aBb DB3SQE aSb D2SGE aMb W aLb 2 aLVb 2 aMVb W aVVb W a]Vb 2 a^Vb DQ2SHGE aSVb D2SGE a(Vb DGeSQE aBVb DB3SQE longDaE 2 doubleDaE 2.2Ga intDaE 2 floatDaE 2.2Ga

"esultado do programa: 168

+ntre fracao a:2 G aD2SGE +ntre fracao b:a H bDaSHE cVa(b D2HS4E fraction dDcED2HS4E a^b DaS4E aBb DBeS4E aSb DHS2WE aMb W aLb 2 aLVb 2 aMVb W aVVb W a]Vb 2 a^Vb DaS4E aSVb DHS2WE a(Vb D2HS4E aBVb DBeS4E longDaE W doubleDaE W.a intDaE W floatDaE W.a

+:erccios: 2EDefina um tipo abstrato de dados matriA Ddo campo da matem>ticaE com sobrecarga de operadores <ue permita acessar 9ia ndice linear ou lin!aScoluna <ual<uer elemento da matriA. Defina outras fun65es membro <ue ac!ar importantes. Por !eran6a; construa a classe matriA <uadrada; defina a fun67o membro transposta para esta matriA. Dependendo doas fun65es membro <ue 9oc@ implementar !a9er> bastante trabal!o referente a tratamento de e:ce65es; por e:emplo: matriAes singulares n7o s7o in9ers9eis; e:istem restri65es para a multiplica67o e at mesmo para a soma e subtra67o 9isto <ue as dimens5es nas duas Oltimas opera65es tem <ue ser iguais. 169

P.G. b+"A),A Mt&#%P&A 'beran6a:mOltipla'0e nos e:emplos anteriores tn!amos uma !ierar<uia <ue se comporta9a da seguinte maneira: L iguraM Agora teremos algo como:

L iguraM

L iguraM

ou ent7o: L iguraM

#endo o seguinte significado: A classe !erdeira tem comportamento; 'be!a9iour'; semel!ante ao das duas classes pais.

P.G.2. $M +X+MP&O 0%MP&+0. +ste e:emplo seria sobre como implementar uma !ierar<uia semel!ante a !ierar<uia 2; mas n7o est> pronto ainda . Precisamos de sugest5es sobre e:emplos mais claros <ue um r>dio relCgio ou um +stagi>rio "emunerado. O e:emplo seguinte supre a falta deste; mas o aprediAado mas abrupto.

P.G.G. ?%"#$A& P$.&%C + "+0O&$,-O D+ CO) &%#O0. "eferente ao diagrama !ierar<uia de 9eculos apresentado neste tCpico. O <ue este caso tem de no9o com rela67o ao anterior <ue 9eculo utilit>rio pode !erdar as caractersticas de 9eculo por dois ramos da '!ierar<uia' de !eran6a; como pre9enir os poss9eis conflitos decorrentes deste fatoK 0imples; os pais de 9eculo utilit>rio de9em receber 9eculo Da classe comumE atra9s do <ualificador 9irtual public. +ste e:emplo tambm apresenta a estratgia para resolu67o de conflitos de nomes em !eran6a mOltipla; lembreBse <ue agora as classes pai podem ter nomes; identificadores em comum. )esse caso usamos o operador de resolu67o de escopo :: ; 9e8a os coment>rios. 170

#Cpicos abordados: "esolu67o de conflitos <uando e:iste mais de um camin!o de !eran6a para uma classe pai D9eculoE; c!amada do construtor para essa classe pai nas classes fil!as. "esolu67o de conflitos entre identificadores comuns.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file class 9eiculo T pri9ate: c!ar^ nomeJ SS<ualificacao do 9eiculo int pesoJ SSmassa do 9eiculo int !pJ SSpotencia em !p. public: 9eiculoDc!ar^ n;int p;int !EJ 9oid alteraI!pDint enEJ int retornaI!pD9oidEJ 9oid alteraIpesoDint enEJ int retornaIpesoD9oidEJ UJ

class 9Ipasseio:9irtual public 9eiculo T pri9ate: int 9olIintJ SS9olume interno. public: 9IpasseioDc!ar^ n;int p;int !p;int 9iEJ 9oid alteraI9iDint enEJ int retornaI9iD9oidEJ float pesoIpotD9oidEJ SSrelacao peso potencia. UJ

171

class 9Icarga:9irtual public 9eiculo T pri9ate: int cargaJ SScarga do 9eiculo. public: 9IcargaDc!ar^ n;int p;int !p;int cEJ 9oid alteraIcargaDint enEJ int retornaIcargaD9oidEJ float pesoIpotD9oidEJ SSrelacao peso potencia; 9eiculo carregado UJ

class 9Iutilitario:public 9Ipasseio;public 9Icarga T pri9ate: SS<ual<uer outro atributo unico de 9Iutilitario. public: 9IutilitarioDc!ar^ n;int p;int !p;int 9i;int cEJ float pesoIpotD9oidEJ UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSimplementation file Rinclude 'multiple.!'

9eiculo::9eiculoDc!ar^ n;int p;int !E T nomeVnJ pesoVpJ !pV!J U

9oid 9eiculo::alteraIpesoDint enE T pesoVenJU

int 9eiculo::retornaIpesoD9oidE T return pesoJ U 172

9oid 9eiculo::alteraI!pDint enE T !pVenJ U

int 9eiculo::retornaI!pD9oidE T return !pJU

9Ipasseio::9IpasseioDc!ar^ n;int p;int !p;int 9iE:9eiculoDn;p;!pE T 9olIintV9iJ U

9oid 9Ipasseio::alteraI9iDint enE T 9olIintVenJ U

int 9Ipasseio::retornaI9iD9oidE T return 9olIintJ U

float 9Ipasseio::pesoIpotD9oidE T return floatDretornaIpesoDEESfloatDretornaI!pDEEJ U

9Icarga::9IcargaDc!ar^ n;int p;int !p;int cE:9eiculoDn;p;!pE T cargaVcJ U

9oid 9Icarga::alteraIcargaDint enE T cargaVenJ U

int 9Icarga::retornaIcargaD9oidE T return cargaJ U

float 9Icarga::pesoIpotD9oidE T return floatDretornaIpesoDE(cargaESfloatDretornaI!pDEEJ U

173

9Iutilitario::9IutilitarioDc!ar^ m;int p;int !p;int 9i;int cE:9IcargaDm;p;!p;cE;9IpasseioDm;p;!p;9iE;9eiculoDm;p;!pE T SSo construtor 9eiculoDm;p;!pE declarado a<ui e <ue 9ale; SSos construtores 9eiculoDm;p;!pE !ierar<uia acima sao descartados U

float 9Iutilitario::pesoIpotD9oidE T return 9Icarga::pesoIpotDEJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSmain file Rinclude 'multiple.!' Rinclude Liostream.!M 9oid mainDE T 9Ipasseio 92D'#oyota Corolla';HWW;2HW;HEJ cout LL 92.pesoIpotDELLendlJ 9Iutilitario 9GD'PiciBup A';PWW;2QW;G;PWWEJ cout LL 9G.pesoIpotDELLendlJ cout LL 9G.retornaIpesoDEJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Coment>rios: float 9Iutilitario::pesoIpotD9oidE T return 9Icarga::pesoIpotDEJ U

A fun67o membro pesoIpot est> presente em todas as classes da '!ierar<uia'. )a classe 9eiculo utilitario ela n7o precisa ser reimplementada; basta escol!er se em termos de peso pot@ncia; 9eiculo utilitario de9e se 174

comportar como 9eiculo de carga ou como 9eiculo de passeio. A escol!a do comportamento foi a de 9eiculo de carga; agora o <ue temos a faAer c!amar a fun67o membro pesoIpot de 9eiculo de carga <ue 8> est> implementada; o <ue faAer para distinguir entre a fun67o membro de mesmo nome da classe base 9eiculo de passeioK $saBse o operador de resolu67o de escopo; mas agora acompan!ado do nome da classe base <ue se dese8a acessar: 9Icarga::pesoIpotDEJ. A mesma estratgia adotada para dados membros em conflito: nomeIclasseIpai::dadoImembroIemIconflitoJ ; neste caso os atributos em comum est7o na classe 9eiculo; topo da '!ierar<uia'.

"esultado do programa: G.HWe43 P.PPPPP PWW

+:erccios: 2E Modifi<ue este e:emplo para <ue em 9eculos com capacidade de carga D9Icarga e 9IutilitarioE peso pot@ncia imprima a pot@ncia do 9eculo carregado e tambm a pot@ncia do 9eculo descarregado; bem como a categoria DclasseE do 9eculo.

P.H. PO&%MO" %0MO PA"AM=#"%CO D#+MP&A#+E Polimorfismo paramtrico um recurso bastante Otil para e9itar redundNncia de cCdigo; portanto se trata de um meio de reuso deste. = importante para criar famlias de classes ou fun65es relacionadas. +ste recurso permite por e:emplo definir uma classe matriA Ddo campo da matem>ticaE uma Onica 9eA num '!eader file' e utiliAar esta classe matriA para matriAes de tipo float; tipo int ou long ;etc. = muito importante e e:ist@ncia de um comportamento uniforme entre os tipos <ue ser7o instanciados; por e:emplo se na sua classe matriA 9oc@ usa o operador j; todos os tipos a serem instanciados Dsusbtitudos como tipo usado na matriAE de9em atender da maneira dese8ada a esse operador. +m linguagens orientadas a ob8etos <ue n7o definem sobrecarga de operador DMCdulaBHE surge um problema: supon!a <ue 9oc@ definiu o tipo fra67o e <uer usar em sua matriA de tipos parametriAados tanto o tipo fra67o <uanto o tipo inteiro. Como uniformiAar o comportamento desses tipos no <ue se refere a opera67o de soma usada na classe matriAK $ma solu67o redefinir o tipo inteiro oferecido pela linguagem de modo <ue ele atenda a fun67o membro de mesmo nome usada no tipo fra67o; e:emplo a fun67o somaDno9oIinteiro aEJ.

P.H.2. #AD ?+#O" Modifica67o do programa 9etor de 2.a.H.4 para suportar polimorfismo paramtrico DtemplateE. $ma condi67o para <ue o polimorfismo paramtrico funcione bem : Os tipos <ue s7o substitudos no template de9em se comportar de maneira uniforme para e:emplificar isso 9amos substituir no template da classe 9etor o tipo fra67o com sobrecarga de operadores de P.2.G e o tipo float. oi proposta a implementa67o do tipo abstrato de dados string; uma boa indica67o da <ualidade de sua implementa67o uma substitui67o no template deste e:emplo sem acarretar modifica65es; isto sC 9ale se nessa implementa67o 8> foi feita sobrecarga de operadores Dcompara67o entre stringsE. Dica de implementa67o: 0e 9oc@ dese8a faAer um programa <ue use 'templates' seguir os passos indicados abai:o normalmente l!e poupar> tempo: 175

BDefina os tipos <ue 9oc@ <uer parametriAar um termos de c!amadas de fun65es membro e operadores de nomes e sinta:e iguais DuniformidadeE. Os tipos dos argumentos 97o 9ariar. BConstrua seu programa para operar em um sC destes tipos. B#ermine incluindo as defini65es dos templates no programa e testando para os demais tipos. BCorri8a as e9entuais fal!as de substitui67o.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SStemp9et.! definicao da classe 9etor com template. Rinclude Lstdlib.!M SS!eader file para classe 9etor const int inicioVWJ

templateLclass #M class 9etorT SS# e[ o tipo do elemento do 9etor pri9ate: #^ 9J SSpode ser <ual<uer tipo <ue atenda as operacoes L M V int taman!oJ public: 9etor Dint taman!oE J #o operatormn Dint iEJ # ma:imoDEJ int primeiroD9oidEJ int ultimoD9oidEJ UJ

templateLclass #M 9etorL#M::9etor Dint tamE T9Vned #mtamnJ taman!oVtamJU

templateLclass #M int 9etorL#M::primeiro D9oidE Treturn inicioJU

176

templateLclass #M int 9etorL#M::ultimo D9oidE T return taman!oB2J U

templateLclass #M #o 9etorL#M::operatormnDint iE T if DiLW pp iMVtaman!oE Tcout LL ' ora dos limites]'J e:itD2EJU SSuse e:ception !andling to maie it c!eci bounds for you. return 9minJ U

templateLclass #M # 9etorL#M:: ma:imoD9oidE Tint candidatoVinicioJ for Dint iVinicioJiLtaman!oJi((E if D9minM9mcandidatonE candidatoViJ return 9mcandidatonJU

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'e:9etH.!'

mainDE T 9etorLfloatM meuDaEJ

for Dint iVmeu.primeiroDEJiLVmeu.ultimoDEJi((E T

cout LL '+ntre com 9alor da posicao:' LL i LL 'Yn'J cin MM meuminJ

177

U for Dint 8Vmeu.primeiroDEJ8LVmeu.ultimoDEJ8((E coutLL meum8nLL ' 'J cout LL endl LL 'Ma:imo:' LL meu.ma:imoDEJ return WJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSmain file; programa principal Rinclude Liostream.!M Rinclude 'e:9etH.!' Rinclude 'fractioG.!' Rinclude 'fractioG.cpp' mainDE T 9etorLfractionM meuDaEJ

for Dint iVmeu.primeiroDEJiLVmeu.ultimoDEJi((E T

cout LL '+ntre com 9alor da posicao:' LL i LL 'Yn'J cin MM meuminJ U for Dint 8Vmeu.primeiroDEJ8LVmeu.ultimoDEJ8((E coutLL meum8nLL ' 'J cout LL endl LL 'Ma:imo:' LL meu.ma:imoDEJ return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

178

Coment>rios: 0e 9oc@ substitusse no template do 9etor o tipo fra67o <ue 9amos definido em P.2.G; o resultado seria igual ao apresentado no subBtCpico resultado do programa em coment>rios. %sto sC a ttulo de curiosidade. ?oc@ n7o precisa tentar implementar um tipo fra67o para uso neste template ainda.

"esultado de teste do programa em coment>rios: +ntre com 9alor da posicao:W 2 G +ntre com 9alor da posicao:2 a P +ntre com 9alor da posicao:G 4 2 +ntre com 9alor da posicao:H G Q +ntre com 9alor da posicao:P P G D2SGE DaSPE D4S2E D2SPE DGS2E Ma:imo: D4S2E

"esultado do programa com o tipo float parametriAado: +ntre com 9alor da posicao:W 2.G +ntre com 9alor da posicao:2 G.2 +ntre com 9alor da posicao:G a.H

179

+ntre com 9alor da posicao:H 2.a +ntre com 9alor da posicao:P 2.3 2.G G.2 a.H 2.a 2.3 Ma:imo:a.H

+:erccios: 2ECrie uma fun67o membro troca <ue recebe como argumentos dois ndices do 9etor e faA a troca deles. P.H.G. #+MP&A#+ D+ $),-O #emplate de fun67o ; introduAiremos tipos parametriAados na fun67o mdc <ue calcula o m>:imo di9isor comum tanto para long <uanto para int e outros tipos <ue definam o operador j: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SSe:emplo facil de templates de funcao Rinclude Liostream.!M

templateLclass #M # mdcD# n;# dE SSma:imo di9isor comum SSmetodo de +uclides T if DnLWE nVBnJ if DdLWE dVBdJ d!ile Dd]VWE T # rVn j dJ SStemplate # jVMOD nVdJ dVrJ U return nJ U

9oid mainD9oidE

180

T int aVaJ long bV4J long cVeJ int dV2PJ cout LL 'mdcDa;4EV' LL mdcDa;4E LL 'Yn'J SSint int cout LL 'mdcDG;HEV' LL mdcDG;HE LL 'Yn'J SSint int pp long long cout LL 'mdcD4;eEV' LL mdcDb;cE LL 'Yn'JSSlong long cout LL 'mdcDe;2PEV' LL mdcDc;dE LL 'Yn'J SSlong int SSerro]]]] U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SS?ersao <ue nao produA erro. SSe:emplo facil de templates de funcao Rinclude Liostream.!M

templateLclass #M # mdcD# n;# dE SSma:imo di9isor comum SSmetodo de +uclides T if DnLWE nVBnJ if DdLWE dVBdJ d!ile Dd]VWE T # rVn j dJ SStemplate # jVMOD nVdJ dVrJ U return nJ U

long mdcDlong m;long nEJ SSdefinicao e:ata; long pre9alece sobre int em termos de con9ersao 181

SSnao acrescente int mdcDint a;int bEJ 9oce tera ambiguidades e o compilador nao fara a SScon9ersao

9oid mainD9oidE T int aVaJ long bV4J long cVeJ int dV2PJ cout LL 'mdcDa;4EV' LL mdcDa;4E LL 'Yn'J SSint int cout LL 'mdcDG;HEV' LL mdcDG;HE LL 'Yn'J SSint int pp long long cout LL 'mdcD4;eEV' LL mdcDb;cE LL 'Yn'JSSlong long cout LL 'mdcDe;2PEV' LL mdcDc;dE LL 'Yn'J SSlong int Ou; con9ersao. U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Coment>rios: )a primeira 9ers7o do programa tudo funciona bem; com e:ce67o da Oltima lin!a; ela produA um erro <ue corrigido na segunda 9ers7o do programa. ?amos e:plicar esse erro: Fuando o compilador resol9e; decide; uma c!amada de fun67o ele primeiro tentar ac!ar uma defini67o e:ata dela Dtipos 8> definidosE e:emplo long mdc Dint a;long bEJ. 0e n7o !ou9er nen!uma 9ers7o e:ata o compilador tenta ac!ar uma 9ers7o com tipos paramtricos <ue aceite os tipos da c!amada da fun67o; no caso uma defini67o de template <ue aceitaria seria: templateLclass #2;class #GM #G ma:D#G n;#2 dE ; <ue um tanto perigosa em termos de opera65es entre tipos; por isso tambm n7o foi fornecida. 0e esta tentati9a tambm fal!ar o compilador tenta faAer a con9ers7o implcita do argumento de modo a satisfaAer uma defini67o e:ata; essa con9ers7o n7o pode resultar numa ambiguidade. )a segunda 9ers7o fornecemos uma 9ers7o e:ata: long mdc Dlong a; long bEJ. somente; n7o dei:ando margens para ambiguidades.

+:erccios: 2E $se um programa antigo feito em outra linguagem; ou mesmo em C. #ente identificar as poss9eis substitui65es por tipos paramtricos <ue poderiam ser feitas com sucesso e seguran6a. +m <ue casos outras solu65es seriam mel!ores e mais segurasK Fue solu65esK

182

GEPerceba <ue nada impede <ue 9oc@ c!ame a fun67o mdc para dois argumentos float; o compilador e:ecuta de fato a c!amada e 9ai acusar erro na opera67o j <ue n7o definida para este tipo. Por isso <ue se diA <ue os tipos parametriAados de9em se comportar de maneira uniforme; com opera65es semel!antes. Defina uma fun67o de ordena67o de 9etor; com tipos paramtricos e <ue se baseie na e:ist@ncia em alguns dos operadores L ; M ; LV ; MV ; VV nos tipos usados. Obser9e <ue se <uisssemos usar nosso tipo fracao nesta fun67o teramos <ue definir oDsE operadorDesE relacionalDisE usadoDsE; . Para faAer esta defini67o 9oc@ ter> ler P.2.G.

HE+scre9a uma fun67o troca com tipos parametriAados. ?oc@ de9e usar passagem por refer@ncia para trocar os dois argumentos do mesmo tipo parametriAado <ue s7o passados: 9oid troca D# a;# bEJ

PEMesmo <uando 9oc@ n7o tem um moti9o imediato para utiliAar tipos parametriAados em uma aplica67o faA sentido faA@BloK 0e sim em <ue casosK

P.H.H. b+"A),A + #+MP&A#+0. Modifica67o do programa de listas ligadas de G.2.P para suportar templates. +sta 9ers7o usada em muitos outros e:emplos do tutorial.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rifndef M&%0#bIb Rdefine M&%0#bIb Rinclude Lstdlib.!M Rinclude Liostream.!M SSCriacao de uma !ierar<uia de listas ligadas. SSO elemento da lista e[ um inteiro enum .ooleanT A&0+;#"$+UJ

template Lclass #Mclass noT SSeste e[ o no da lista ligada; so e[ usado por ela pri9ate: # infoJ SSinformacao no^ pro:J SSponteiro para o pro:imo public: noDEJ noD# i;no^ pEJ

183

no^ getIpro:D9oidEJ 9oid setIpro:Dno^ pEJ # getIinfoD9oidEJ 9oid setIinfoD# aEJ no^ dobraD9oidEJ fnoD9oidEJ UJ

template Lclass #Mclass listaT SSesta e[ a lista ligada comum. protected: SS'9isi9el !ierar<uia abai:o' noL#M^ primeiroJ SSprimeiro no da lista; a<ui eu insiro e remo9o. public: listaD9oidEJ listaDconst listaL#Mo lcEJ SScopy constructor. .oolean 9aAiaD9oidEconstJ .oolean contemD# elEconstJ 9oid insereIprimeiroD# elemEJ #^ remo9eIprimeiroDEJ 9oid mostraDEconstJ flistaD9oidEJ UJ SSfim classe lista

template Lclass #Mclass listaultimo:public listaL#M T SSessa e a lista util para SSimplementar pil!as e filas. protected: SSprotected e uma opcao outra e[ getIultimoDE e setI... noL#M^ ultimoJ public: listaultimoD9oidEJ listaultimoDconst listaultimoL#Mo lcEJ SSredefinicao 9oid insereIultimoD# elemEJ SSno9a 9oid insereIprimeiroD# elemEJ SSredefinicao #^ remo9eIprimeiroDEJSSredefinicao 184

flistaultimoD9oidEJ SSas operacoes nao redefinidas sao 9alidas. UJ

template Lclass #Mclass listaordenada:public listaL#M T SSessa e[ a lista comum com aprimoramentos. public: listaordenadaD9oidEJ SSnao definimos copy constructor .oolean contemD# elEconstJ 9oid insereIprimeiroD# elemEJ SSinsere em ordem #^ remo9eIelementoD# elEJ flistaordenadaD9oidEJ UJ

templateLclass #MnoL#M::noDE Tpro:V)$&&Jcout LL 'bi'JU

templateLclass #MnoL#M::noD# i;no^ pE TinfoViJpro:VpJcout LL 'bi'JU

templateLclass #M noL#M^ noL#M::getIpro:D9oidE Treturn pro:JU

templateLclass #M 9oid noL#M::setIpro:Dno^ pE Tpro:VpJU

templateLclass #M # noL#M::getIinfoD9oidE Treturn infoJU

templateLclass #M 9oid noL#M::setIinfoD# iE TinfoViJU

185

templateLclass #M noL#M^ noL#M::dobraD9oidE T if DgetIpro:DEVV)$&&E return ned noL#MDgetIinfoDE;)$&&EJ else return ned noL#MDgetIinfoDE;t!isBMgetIpro:DEBMdobraDEEJ SSrecursi9idade para duplicacao da lista U

templateLclass #M noL#M::fnoD9oidE Tcout LL 'bye'JU SSbye e so para debugar; retire depois de compilado.

templateLclass #M listaL#M::listaD9oidE:primeiroD)$&&E TU SSbloco de codigo 9aAio

templateLclass #M listaL#M::listaDconst listaL#Mo lcE T primeiroVlc.primeiroBMdobraDEJ U

templateLclass #M .oolean listaL#M::9aAiaD9oidEconst T return .ooleanDprimeiroVV)$&&EJ U

templateLclass #M .oolean listaL#M::contemD# elE constSSmais rapido <ue iterador T noL#M^ currJ currVprimeiroJ d!ile DDcurr]V)$&&E oo DcurrBMgetIinfoDE]VelEE T currVcurrBMgetIpro:DEJ UJ return .ooleanDcurrBMgetIinfoDEVVelEJ U

templateLclass #M 9oid listaL#M::insereIprimeiroD# elemE 186

T noL#M^ insirameJ if DprimeiroVV)$&&E SSlista 9aAia primeiroVned noL#MDelem;)$&&EJ else T insirameVned noL#MDelem;primeiroEJ primeiroVinsirameJ UJ UJ

templateLclass #M #^ listaL#M::remo9eIprimeiroD9oidE T #^ de9ol9ameJ SSreturn noL#M^ tempJ SSto delete if DprimeiroVV)$&&E return )$&&J SSlista 9aAia else T D^de9ol9ameEVprimeiroBMgetIinfoDEJ tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ return de9ol9ameJ UJ UJ

templateLclass #M9oid listaL#M::mostraDE const T noL#M^ currJ cout LL 'V'J currVprimeiroJ d!ile Dcurr]V)$&&E T

187

cout LL'D'LLcurrBMgetIinfoDELL'E'LL'B'J currVcurrBMgetIpro:DEJ UJ U

templateLclass #MlistaL#M::flistaD9oidE T noL#M^ tempJ d!ile Dprimeiro]V)$&&E T tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ UJ U

templateLclass #MlistaordenadaL#M::listaordenadaD9oidE:listaL#MDE TUJ

templateLclass #M .oolean listaordenadaL#M::contemD# elEconst T noL#M^ currJ .oolean contiV#"$+J currVprimeiroJ d!ile DDcurr]V)$&&E oo contiE T if DcurrBMgetIinfoDELelE currVcurrBMgetIpro:DEJ else contiV A&0+J UJ if DcurrVV)$&&E return A&0+J else return .ooleanDcurrBMgetIinfoDEVVelEJ 188

templateLclass #M9oid listaordenadaL#M::insereIprimeiroD# elemE T noL#M^ currVprimeiroJ noL#M^ pre9V)$&&J noL#M^ insirameJ .oolean contiV#"$+J d!ile DDcurr]V)$&&E oo contiE T if DcurrBMgetIinfoDELelemE Tpre9VcurrJ currVcurrBMgetIpro:DEJU else contiV A&0+J UJ insirameVned noL#MDelem;currEJ if Dpre9VV)$&&E primeiroVinsirameJ else pre9BMsetIpro:DinsirameEJ U

templateLclass #M #^ listaordenadaL#M::remo9eIelementoD# elE T #^ de9ol9ameJ noL#M^ currVprimeiroJ noL#M^ pre9V)$&&J noL#M^ deletemeJ .oolean contiV#"$+J d!ile DDcurr]V)$&&E oo contiE SSac!a lugar onde pode estar el T if DcurrBMgetIinfoDELelE Tpre9VcurrJ currVcurrBMgetIpro:DEJU SSanda else contiV A&0+J

189

UJ if DcurrVV)$&&E return A&0+J SSfim de lista ou 9aAia else SSpode ser o elemento ou ele nao e:iste T if DcurrBMgetIinfoDEVVelE T deletemeVcurrJ if Dpre9VV)$&&E SSlista so com um elemento ou primeiro el primeiroVcurrBMgetIpro:DEJ else T pre9BMsetIpro:DcurrBMgetIpro:DEEJ U cout LL deletemeBMgetIinfoDELLendlJ SSso para 9erificar D^de9ol9ameEVdeleteBMgetIinfoDEJ delete deletemeJ return de9ol9ameJ U else return )$&&J U U

templateLclass #MlistaordenadaL#M::flistaordenadaD9oidE Tcout LL '&ista destruida.'JUJ

templateLclass #MlistaultimoL#M::listaultimoD9oidE:listaL#MDE T ultimoV)$&&J U

templateLclass #MlistaultimoL#M::listaultimoDconst listaultimoL#Mo lcE T 190

noL#M^ currJ primeiroVultimoV)$&&J SSinicialiAa lista if D]lc.9aAiaDEE T currVlc.primeiroJ d!ile Dcurr]V)$&&E T insereIultimoDcurrBMgetIinfoDEEJ currVcurrBMgetIpro:DEJ U U U

templateLclass #M9oid listaultimoL#M::insereIultimoD# elemE T noL#M^ insirameJ insirameVned noL#MDelem;)$&&EJ if DultimoVV)$&&E ultimoVinsirameJ SSlista 9aAia else T ultimoBMsetIpro:DinsirameEJ ultimoVinsirameJ UJ if DprimeiroVV)$&&E primeiroVultimoJ SSlista 9aAia U

templateLclass #M 9oid listaultimoL#M::insereIprimeiroD# elemE SSredefinicao T noL#M^ insirameJ if DprimeiroVV)$&&E SSlista 9aAia T primeiroVned noL#MDelem;ultimoEJ

191

ultimoVprimeiroJ USSlista 9aAia else T insirameVned noL#MDelem;primeiroEJ primeiroVinsirameJ UJ U

templateLclass #M #^ listaultimoL#M::remo9eIprimeiroDESSredefinicao T #^ de9ol9ameJ SSreturn noL#M^ tempJ SSto delete if DprimeiroVV)$&&E return WJ SSlista 9aAia else T D^de9ol9ameEVprimeiroBMgetIinfoDEJ tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ if DprimeiroVV)$&&E ultimoV)$&&J SS9olta lista 9aAia return de9ol9ameJ UJ U

templateLclass #MlistaultimoL#M::flistaultimoD9oidE T noL#M^ tempJ d!ile Dprimeiro]V)$&&E T tempVprimeiroJ primeiroVprimeiroBMgetIpro:DEJ delete tempJ UJ 192

delete ultimoJ U

Rendif

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude 'mlist!t.!' mainDE T listaultimoLintM min!aJ listaultimoLintM^ copiaJ c!ar optionJ SSuse in menu as option 9ariable c!ar cpyoptJ SScopy option para copia int elJ SSelemento a inserir do T cout LL'Yn'J SSmenu options display cout LL'P:%nsere no primeiro.Yn'J cout LL'":"emo9e no primeiro.Yn'J cout LL'$:%nsere no ultimo.Yn'J cout LL'+:+:iste elementoKYn'J cout LL'?:?aAiaKYn'J cout LL'M:Mostra lista.Yn'J cout LL'C:Copia lista e mostra.Yn'J cout LL'F:Fuit teste lista.Yn'J cout LL'+ntre comando:'J cin MM optionJ SSreads user option sditc!DoptionE SSe:ecutes user option T case [P[:

193

case [p[: cout LL '+ntre elemento:'J cin MMelJ min!a.insereIprimeiroDelEJ breaiJ case ["[: case [r[: if D]min!a.9aAiaDEE cout LL D^min!a.remo9eIprimeiroDEELLendlJ else cout LL ')$&&; &ista 9aAia.' LLendlJ breaiJ case [$[: case [u[: cout LL '+ntre elemento:'J cin MM elJ min!a.insereIultimoDelEJ breaiJ case [M[: case [m[: min!a.mostraDEJ breaiJ case [+[: case [e[: cout LL '+ntre elemento:'J cin MMelJ cout LL min!a.contemDelEJ breaiJ case [?[: case [9[: cout LL min!a.9aAiaDEJ breaiJ case [C[: case [c[: 194

copiaVned listaultimoLintMDmin!aEJ copiaBMmostraDEJ cout LL 'Agora trabal!ando na lista copia.' LL endlJ do T cout LL'Yn'J SSmenu options display cout LL'P:%nsere no primeiro.Yn'J cout LL'":"emo9e no primeiro.Yn'J cout LL'$:%nsere no ultimo.Yn'J cout LL'+:+:iste elementoKYn'J cout LL'?:?aAiaKYn'J cout LL'M:Mostra lista.Yn'J cout LL'F:Fuit teste lista copiaK?olta lista anteriorK.Yn'J cout LL'+ntre comando:'J cin MM cpyoptJ SSreads user option sditc!DcpyoptE SSe:ecutes user option T case [P[: case [p[: cout LL '+ntre elemento:'J cin MMelJ copiaBMinsereIprimeiroDelEJ breaiJ case ["[: case [r[: if D]copiaBM9aAiaDEE cout LL D^copiaBMremo9eIprimeiroDEELLendlJ else cout LL ')$&&; &ista 9aAia.' LLendlJ breaiJ case [$[: case [u[: cout LL '+ntre elemento:'J

195

cin MMelJ copiaBMinsereIultimoDelEJ breaiJ case [M[: case [m[: copiaBMmostraDEJ breaiJ case [+[: case [e[: cout LL '+ntre elemento:'J cin MMelJ cout LL copiaBMcontemDelEJ breaiJ case [?[: case [9[: cout LL copiaBM9aAiaDEJ breaiJ case [F[: case [<[: delete copiaJ breaiJ default: J U SSsditc!Bcase code bloci U d!ile DDcpyopt]V[F[E oo Dcpyopt]V[<[EEJ breaiJ default: J U SSsditc!Bcase code bloci U d!ile DDoption]V[F[E oo Doption]V[<[EEJ SSmenu loop code bloci

return WJ U SSmain code bloci

196

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

+:erccios: 2ECompare esta lista com 'templates' com outras listas implementadas sem tipos paramtricos. Fue 9antagens 9oc@ pode apontar a n9el de independ@ncia entre as partes de um programaK Por<ue importante ma:imiAar esta independ@ncia entre as partes de um programaK Outro e:erccio: Modifi<ue o programa listaL#M para trabal!ar com ponteiros L#^M e9itando a copia de ob8etos grandes 9isando assim maior efici@ncia.

P.H.P. #+MP&A#+0 + A*"+*A,-O $sando o template definido no e:emplo dois criaremos uma classe pil!a e a testaremos de modo an>logo ao <ue foi feito em G.G sC <ue agora com templates e com uma pil!a e n7o fila. mlist!.! n7o ser> copiada; id@ntica a do e:emplo anterior de 'templates'.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude 'mlist!t.!' templateLclass #Mclass pil!a T SSagregacao de uma lista pri9ate: listaL#M alJ SSa lista public: pil!aDEJ .oolean 9aAiaDEJ .oolean contemD# elEJ 9oid insereD# elEJ #^ remo9eDEJ 9oid mostraDEJ UJ

templateLclass #M pil!aL#M::pil!aDETUJ templateLclass #M .oolean pil!aL#M::9aAiaDE Treturn al.9aAiaDEJU 197

templateLclass #M .oolean pil!aL#M::contemD# elE Treturn al.contemDelEJU templateLclass #M 9oid pil!aL#M::insereD# elE Tal.insereIprimeiroDelEJU templateLclass #M #^ pil!aL#M::remo9eDE Treturn al.remo9eIprimeiroDEJU templateLclass #M 9oid pil!aL#M::mostraDE Tal.mostraDEJU

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude 'mpil!at.!' mainDE T pil!aLintM min!aJ c!ar optionJ SSuse in menu as option 9ariable int elJ SSelemento a inserir do T cout LL'Yn'J SSmenu options display cout LL'%:%nsere.Yn'J cout LL'":"emo9e.Yn'J cout LL'M:Mostra pil!a.Yn'J cout LL'F:Fuit pil!a test.Yn'J cout LL'?:?aAiaKYn'J cout LL'C:ContemKYn'J cout LL'+ntre comando:'J cin MM optionJ SSreads user option sditc!DoptionE SSe:ecutes user option T

198

case [%[: case [i[: cout LL '+ntre elemento:'J cin MMelJ min!a.insereDelEJ breaiJ case ["[: case [r[: if D]min!a.9aAiaDEE cout LL D^Dmin!a.remo9eDEEELLendlJ else cout LL ')$&&; pil!a 9aAia.' LLendlJ breaiJ case [C[: case [c[: cout LL '+ntre elemento:'J cin MMelJ cout LL min!a.contemDelEJ breaiJ case [M[: case [m[: min!a.mostraDEJ breaiJ case [?[: case [9[: cout LL '"esultado:' LL min!a.9aAiaDE LLendlJ breaiJ default: J U SSsditc!Bcase code bloci U d!ile DDoption]V[F[E oo Doption]V[<[EEJ SSmenu loop code bloci

return WJ U SSmain code bloci

199

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

+:erccios: 2EDefina outras classes apresentadas em termos de templates; por e:emplo a classe conta . 0upon!a <ue 9oc@ tem <ue faAer um programa <ue usa a classe conta; mas n7o sabe ao certo se 9ai usar o tipo float para representar o din!eiro ou 9ai usar algum outro tipo DdoubleE . $se templates e defina este tipo somente <uanto as opera65es. P.P. M+#AC&A00+0 Metaclasses armaAenam informa65es sobre classes definidas pelo usu>rio e s7o comuns em algumas linguagens de programa67o orientadas a ob8etos. +ssa informa67o armaAenada a c!amada metainforma67o. C(( n7o possui metaclasses; porm e:istem meios de armaAenar alguma metainforma67o; um deles o uso de 9ari>9eis do tipo static <ue guardam informa65es sobre os 9>rios ob8etos de uma mesma classe. A utilidade da metainforma67o 9asta. Por e:emplo um ar<ui9o <ue armaAena uma imagem contm geralmente um cabe6al!o sobre a imagem DnOmero de 'pi:els'; largura; altura; etcE. )uma classe lista; pode ser considerado como metaBinforma67o: o nOmero de elementos; o estado: ordenado ou n7o; etc. +m bancos de dados muito comum se armaAenar metaBinforma67o nos ar<ui9os.

P.P.2. $M #%PO 0%MP&+0 COMO 0#A#%C Fuando se declara um atributo static em uma classe; todos os ob8etos instanciados tem uma refer@ncia para ele Do mesmo atributoE; ou se8a ele pode ser modificado ou lido por fun65es membro de todos os ob8etos desta classe. )o e:emplo a seguir declaramos um atributo static inteiro <ue incrementado <uando o ob8eto criado DconstrutorE e decrementado <uando o ob8eto destrudo. +sse atributo static pode ser de <ual<uer tipo; pode ser at um ob8eto. ?ari>9eis static ser9em para faAer estatsticas sobre uma classe; tambm s7o ade<uadas para tornar informa65es de um ob8eto dispon9eis para outros da mesma classe; elas continuam e:istindo Dconser9am seu 9alorE mesmo <ue n7o !a8a nen!um ob8eto instanciado e n7o destrudo D9i9oE. O programa abai:o mostra como faA@Blo; ali9e representa o nOmero de ob8etos da classe robot criados. ?e8a <ue a declara67o de ali9e segue a pala9ra static.

L iguraM Diagrama do atributo static ali9e; compartil!ado por 9>rios robvs:

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M

200

class robo T pri9ate: float :;yJ static int 9i9osJ SSguarda numero de robos 9i9os. public: roboDfloat :;float yE T9i9os((JU SScria robo 9oid mo9eDfloat d:;float dyE T:(Vd:Jy(VdyJU static int getI9i9osD9oidE Treturn 9i9osJU SS<uantos 9i9os froboD9oidE T9i9osBBJU SSmata robo UJ

int robo::9i9osVWJ SSinicialiAacao da 9aria9el static.

mainDE T cout LL robo::getI9i9osDE LL endlJ robo ^r2Vned roboD2.H;2.PEJ SScria robo 2 robo ^rGJ cout LL r2BMgetI9i9osDE LL 'Yn' J SS2 9i9o rGVned roboDW.W;W.WEJ SScri robo G cout LL r2BMgetI9i9osDE LL 'Yn' J SSG 9i9os delete r2J SSiill robo 2 cout LL robo::getI9i9osDE LL 'Yn' J SS2 9i9o rGBMmo9eD2G.P;GH.GEJ SSmo9endo robo certa distancia. delete rGJ SSmata robo G. SSnen!um robo 9i9o cout LL robo::getI9i9osDE LL endlJ return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

201

"esultado do programa: W 2 G 2 W

Coment>rios: Obser9e o trec!o de cCdigo: int robot::ali9eVWJ perceba <ue 9oc@ de9e inicialiAar o atributo antes da cria67o de <ual<uer ob8eto. +sse tipo de acesso n7o permitido em mainDE; mantendo assim o encapsulamento. Fuando os ob8etos s7o criados eles incrementam ali9e atra9s de seus construtores; e decrementam <uando s7o destrudos. +:iste uma fun67o membro declarada como static: static int getI9i9osD9oidE Treturn 9i9osJU esta fun67o membro tem um tipo de acesso diferente dos outros ; o seguinte trec!o de cCdigo usado em nosso programa permitido: cout LL robo::getI9i9osDE LL endlJ. Perceba <ue getI9i9os c!amado sem o operador . ou BM; isto permitido por<ue getI9i9os um fun67o membro static; opera portanto sobre 9ari>9eis static <ue podem e:istir antes da cria67o do primeiro ob8eto da classe ou <uando nen!um ob8eto est> ati9o.

+:erccios: 2E )o lugar da 9ari>9el inteira declarada como static faca a seguinte declara67o: static armaAenagem 9i9osJ SSguarda numero de robos 9i9os.. %nicialiAe tambm o ob8eto static c!amando seu construtor fora de main. $ma poss9el defini67o para a classe armaAenagem seria: class armaAenagem T pri9ate: int numeroJ public: armaAenagemDE TnumeroVWJU 9oid armaAenagemppDE Tnumero((JU 9oid armaAenagemmmDE TnumeroBBJU int getInumeroDE Treturn numeroJU UJ

)7o se es<ue6a de c!amar os fun67o membros de armaAenagem nos construtores dos robos.

202

GE$se 9ari>9eis static em seus programas para <ue faAem aloca67o dinNmica para controlar o nOmero de ob8etos criados e n7o deletados. $se por e:emplo o ob8eto lista de G.2.P e 9erifi<ue a importNncia desta tcnica para o desen9ol9imento de programas <ue se8am corretos no uso da memCria dinNmica D!eapE; principalmente em C(( <ue n7o fornece coleta autom>tica de li:o. $sar tcnicas deste tipo em MCdulaBH imposs9el por<ue a linguagem n7o suporta construtores e destrutores; porm a coleta autom>tica de li:o; '*arbage Collection' ; 8> faA grande parte do trabal!o para o programador. +m C(( e:istem tcnicas a9an6adas de programa67o para conseguir coleta autom>tica de li:o para alguns tipos; essas tcnicas se baseiam na c!amada de autom>tica de um destrutor <uando um ob8eto sai de escopo; e tambm no uso de 'templates'.

HE +:iste uma linguagem de programa67o c!amada &ogo <ue muito usada no .rasil em escolas de primeiro e segundo grau. )esta linguagem 9oc@ pode programar os mo9imentos na tela de uma tartarugin!a ou cursor. +ste cursor descre9e mo9imentos riscando ou n7o a tela; dentre os mo9imentos descritos est7o crculos; <uadrados e se<u@ncias repetiti9as DloopsE. Modifi<ue seu ob8eto robo para apresentar alguns desses recursos. Crie ent7o um programa <ue l@ de um ar<ui9o te:to instru65es para este ob8eto robo e:ecutar mo9imentos na tela. &ogo foi criada por um cientista de computa67o do M%#.

P.P.G. $M #%PO D+ %)%DO P+&O $0$g"%O $0ADO COMO 0#A#%C #rec!os de um programa com um ob8eto static representando uma lista parametriAada DtemplatesE. A estrutura poderia ser parametriAada de modo a armaAenar informa65es sobre os estados dos demais ob8etos; permitindo <ue eles realiAem algum tipo de intera67o. )este e:emplo 9amos sC armaAenar os mCdulos das distNncia <ue os robos se mo9eram Dfun67o membro mo9eDEE a6a a inclus7o do ar<ui9o <ue define sua estrutura de armaAenamento; 'storage'; no seu pro8eto:

Rinclude 'mlist!t.!'

Crie o atributo static com o encapsulamento dese8ado na defini67o da classe robo. 0e preciso indi<ue o tipo parametriAado:

class facaIestatisticasIsobreImim T pri9ate: static listaLfloatM registroJ SSstorage class public: ...

Acesse o atributo static aonde seu encapsulamento permite atra9s de c!amadas de fun65es membro como: registro.insereIultimoDaEJ

#ente faAer este e:emplo soAin!o; depois confira com o programa a seguir:

203

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Rinclude Liostream.!M Rinclude Lmat!.!M Rinclude 'mlist!t.!'

class robot T pri9ate: float :;yJ SSposicoes static listaLfloatM deltasJSSguarda os passos dados public: robotDfloat a;float bE T :VaJ yVbJ U SScria robo 9oid mo9eDfloat d:;float dyE T :(Vd:J y(VdyJ deltas.insereIprimeiroDs<rtD:^:(y^yEEJ U static 9oid mostraIlistaD9oidE T deltas.mostraDEJ cout LL endlJ U frobotD9oidE TU SSmata robo UJ

listaLfloatM robot::deltasJ SSc!ama o construtor.

204

mainDE T

robot ^r2Vned robotDW.W;W.WEJ SScria robo 2 r2BMmo9eD2;2EJ robot ^rGJ robot::mostraIlistaDEJ SSmostra lista. rGVned robotD2.W;2.WEJ SScria robo G robot::mostraIlistaDEJ SSmostra lista. rGBMmo9eD2W;2WEJ robot::mostraIlistaDEJ SSmostra lista. delete r2J delete rGJ

return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: VD2.P2PG2EB VD2.P2PG2EB VD2a.aa4HEBD2.P2PG2EB

0tatic e fun65es comuns: un65es comuns tambm podem ter 9ari>9eis static e n7o sC ob8etos. )este caso as 9ari>9eis permanecem ati9as durante c!amadas da fun67o.

+:erccios: 2EDefina uma estrutura de dados mais eficiente para busca <ue uma lista; useBa como static no e:emplo acima. aca com <ue os robos atendam ao seguinte fun67o membro: encontraIpro:imoD9oidEJ <ue faA com <ue um robo se mo9a at a posi67o do compan!eiro mais prC:imo dele. Perceba <ue agora 9oc@ tem <ue armaAenar a posi67o de cada robv na estrutura; 8untamente com um identificador deste robv.

205

GEDefina de modo an>logo ao e:erccio anterior fun65es membro como agrupa; <ue faA com <ue os robos se mo9am uma unidade de comprimento em dire67o ao centro de massa do grupo. 0upon!a <ue todos os robos ten!am a mesma massa.

HE?oc@ pode dese8ar armaAenar as informa65es da classe robot em outra classe; <ue computa outros c>lculos; neste caso temos pelo menos duas alternati9as a seguir: aECrie uma classe au:iliar e:terna de armaAenagem e para todos ob8etos robo instanciados passe o ponteiro desta classe au:iliar como argumento do construtor . Assim esses ob8etos poder7o mandar mensagens para esta classe de armaAenagem. +ssas mensagens; c!amadas de fun65es membro; podem ter 9>rios significados; num sentido figurado podemos ter algo parecido com: 'Classe au:iliar; armaAene essa informa67o para mim'. 'Classe au:iliar; me mande uma mensagem da<ui a cinco segundos; estou passando o ponteiro para mim mesmo Dt!isE ' ; etc. As mensagens 9istas desse modo ficam mais interessantes; 9oc@ pode at ac!ar engra6ado; mas muito pr>tico pensar assim. Fuando estudarmos simula65es dirigidas a e9entos em P.4.G 9eremos a importNncia destas trocas de mensagens entre ob8etos. bE$sar friends para <ue a classe de armaAenagem e c>lculo e a classe robot possam interagir.

PE +m alguma classe <ue 9oc@ criou anteriormente defina 9ari>9eis static com o seguinte ob8eti9o: Contar; faAer estatsticas das c!amadas de fun67o membros de classe.

aE$se o <ue foi aprendido sobre 'static 9ariables' no programa contas; o ob8eti9o armaAenar informa65es sobre os mo9imentos de todas as contas num ob8eto static. Para <ue a modifica67o fi<ue a contento 9oc@ pode precisar tornar o e:emplo mais prC:imo da realidade; adicionando no construtor de contas um argumento: nOmero de conta. Comente se 9oc@ usaria aloca67o dinNmica para essa classe de armaAenagem agregada em conta; ou n7o. #en!a em mente a <uest7o do taman!o em bytes do ob8eto.

P.a. #"A#AM+)#O D+ +XC+,\+0 Adicionando tratamento de e:ce65es ao programa 9etor do item P.H.2.

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS!eader file para classe 9etor e:.! Rinclude Liostream.!M

const int inicioVWJ

class e:cecoes9etor T SSto be t!roded public: SSnao ten!o interesse de encapsular por en<uanto. e:cecoes9etorDc!ar^ te:toEJ 206

c!ar^ mensagemJ c!ar^ retornaImensagemD9oidEJ UJ

class e:cecaoalocacao:public e:cecoes9etorT public: e:cecaoalocacaoDc!ar^ te:toEJ UJ

class e:cecaoinstanciacao:public e:cecoes9etorT public: e:cecaoinstanciacaoDc!ar^ te:to;int numEJ int <uantJ SSnumero de elementos com <ue se tentou instanciar 9etor UJ

class e:cecaolimite:public e:cecoes9etorT SSlimite de indice desrespeitado public: e:cecaolimiteDc!ar^ te:to;int ind;int ma:EJ int indiceJ SSarmaAena o indice <ue gerou e:cecao int ma:imoJ SSarmaAena o indice ma:imo SSindice minimo e[ fi:o para este programaVW UJ

e:cecoes9etor::e:cecoes9etorDc!ar^ te:toE T mensagemVte:toJU

c!ar^ e:cecoes9etor::retornaImensagemD9oidE T return mensagemJ U

e:cecaolimite::e:cecaolimiteDc!ar^ te:to;int ind;int ma:E:e:cecoes9etorDte:toE

207

T indiceVindJ ma:imoVma:JU

e:cecaoinstanciacao::e:cecaoinstanciacaoDc!ar^ te:to;int numE:e:cecoes9etorDte:toE T <uantVnumJ U

e:cecaoalocacao::e:cecaoalocacaoDc!ar^ te:toE:e:cecoes9etorDte:toE TU

templateLclass #M class 9etorT SS# e[ o tipo do elemento do 9etor pri9ate: #^ 9J SSpode ser <ual<uer tipo <ue atenda as operacoes L M V int taman!oJ public: 9etor Dint taman!oE J #o operatormn Dint iEJ # ma:imoDEJ int primeiroD9oidEJ int ultimoD9oidEJ UJ

templateLclass #M 9etorL#M::9etor Dint tamE T if DtamL2E t!rod e:cecaoinstanciacaoD'?etores de taman!o L2. 0ao in9alidos.';tamEJ 9Vned #mtamnJ if D9VV)$&&E t!rod e:cecaoinstanciacaoD')ao consegui alocar memoria';tamEJ taman!oVtamJ U

templateLclass #M int 9etorL#M::primeiro D9oidE Treturn inicioJU 208

templateLclass #M int 9etorL#M::ultimo D9oidE Treturn taman!oB2JU

templateLclass #M #o 9etorL#M::operatormnDint iE T if DiLW pp iMVtaman!oE t!rod e:cecaolimiteD' ora dos limites.';i;taman!oEJ return 9minJ U

templateLclass #M # 9etorL#M:: ma:imoD9oidE T int candidatoVinicioJ for Dint iVinicioJiLtaman!oJi((E if D9minM9mcandidatonE candidatoViJ return 9mcandidatonJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SSmain file Rinclude Liostream.!M Rinclude 'e:.!' mainDE T try T int indJ SSindice; usado para atualiAacoes float itemJ SSitem; usado para insercoes no 9etor

209

9etorLfloatM^ meuJ

try T meuVned 9etorLfloatMDaEJ U catc! De:cecaoinstanciacaoo eE T cout LL '+:cecao gerada] O 9etor nao pode ser criado.' LL endlJ cout LL e.retornaImensagemDE LL endlJ cout LL 'O indice in9alido e[:'LL e.<uant LL endlJ cout LL 'O programa sera terminado.' LL endlJ t!rodJ SSfret!rod U catc! De:cecaoalocacaoo eE T cout LL '+:cecao gerada] O 9etor nao pode ser criado.' LL endlJ cout LL e.retornaImensagemDE LL endlJ cout LL 'O programa sera terminado.' LL endlJ t!rodJ U catc! De:cecoes9etoro eE T cout LL '+sta e:cecao nao esta9a pre9ista em nosso codigo.'LLendlJ cout LL 'Pode ser resultado de uma e:tensao na !ierar<uia de e:cecoes.'LLendlJ cout LL e.retornaImensagemDE LL endlJ U

for Dint iVmeuBMprimeiroDEJiLVmeuBMultimoDEJi((E T cout LL '+ntre com 9alor da posicao:' LL i LL 'Yn'J cin MM meuBMoperatormnDiEJ U 210

for Dint 8VmeuBMprimeiroDEJ8LVmeuBMultimoDEJ8((E coutLL D^meuEm8nLL ' 'J

cout LL '+ntre com o indice da posicao a atualiAar:Yn'J cin MM indJ cout LL '+ntre com o 9alor a incluir:'J cin MM itemJ

tryTD^meuEmindnVitemJU catc! De:cecaolimiteo eE T cout LL 'Ya 0ubscripting desconsiderado.'LLendlJ cout LL e.retornaImensagemDE LL endlJ U SSincluir um loop ate obter do teclado 9alores 9alidos.

for Dint iVmeuBMprimeiroDEJiLVmeuBMultimoDEJi((E coutLL D^meuEminLL ' 'J cout LLendl LL 'Ma:imo:' LL meuBMma:imoDEJ

return WJ USStry catc!D...E T cout LL '+:cecoes nao tratadas; fim do programa.'LLendlJ U U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado normal do programa: +ntre com 9alor da posicao:W

211

a.G +ntre com 9alor da posicao:2 a4HG.G +ntre com 9alor da posicao:G 2G.a +ntre com 9alor da posicao:H 2G +ntre com 9alor da posicao:P G.G2 a.G a4HG.G 2G.a 2G G.G2 +ntre com o indice da posicao a atualiAar: W +ntre com o 9alor a incluir:G G a4HG.G 2G.a 2G G.G2 Ma:imo:a4HG.G

"esultado anormal de9ido a ndice in9>lido dado ao programa: +ntre com 9alor da posicao:W G.G +ntre com 9alor da posicao:2 a.3 +ntre com 9alor da posicao:G P.2 +ntre com 9alor da posicao:H 4a.a +ntre com 9alor da posicao:P G.H G.G a.3 P.2 4a.a G.H +ntre com o indice da posicao a atualiAar: 4 +ntre com o 9alor a incluir:P.a 0ubscripting desconsiderado. ora dos limites. G.G a.3 P.2 4a.a G.H 212

Ma:imo:4a.a

"esultado anormal de9ido a fal!a de aloca67o de memCria: +:cecao gerada] O 9etor nao pode ser criado. )ao consegui alocar memoria O indice in9alido e[:a O programa sera terminado. +:cecoes nao tratadas; fim do programa.

"esultado anormal de9ido a numero de elementos do 9etor L 2: +:cecao gerada] O 9etor nao pode ser criado. ?etores de taman!o L2. 0ao in9alidos. O indice in9alido e[:Ba O programa sera terminado. +:cecoes nao tratadas; fim do programa.

+:erccios: 2E %mplemente; adicione tratamento de e:ce65es para o e:emplo de P.2.G. Antes fa6a um le9antamento das e:ce65es <ue podem ser geradas; lembre das restri65es matem>ticas para o denominador em uma di9is7o. &e9e em conta tambm o o9erflod de 9ari>9eis long <ue s7o uma representa67o com nOmero de bits finito da se<uencia dos nOmeros inteiros Dcon8unto k da matem>ticaE. Compare este tratamento com o de outros programas por e:emplo na di9is7o por Aero; <uais as 9antagens <ue 9oc@ pode apontar e des9antagensK

P.4. CO)C&$0\+0 )este tCpico apresentaremos programas mais elaborados dentre eles uma simula67o dirigida a e9entos e uma implementa67o de uma >r9ore bin>ria.

P.4.2. g"?O"+ .%)g"%A. +ste programa implementa uma >r9ore bin>ria e testaBa: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB RincludeLiostream.!M const #"$+V2J const A&0+VWJ 213

class no SSno agregado na classe ar9ore; por raAoes de encapsulamento T pri9ate: int infoJ SSatributo informacao; use template depois... no^ es<J SSsubar9ore es<uerda no^ dirJ SSsubar9ore direita int buscaImaises<D9oidEJ public: noDint aEJ SSsem fil!os noDint a;no^ b;no^ cEJ SScom fil!os int retornaI<uantD9oidEJ no^ insereDint a;into resEJ no^ remo9eDint b;into resEJSSres V resultado DsucessoKE int buscaDint cEJ SSbusca binaria 9oid inIorderDEJ SSparentisada fnoD9oidEJ SSdestrutor da ar9oreSsubar9ore static int <uantJ SSso para testes; pode ser public. UJ

class ar9Ibin T SSencapsula no e redireciona c!amadas de metodos pri9ate: no^ arJ public: ar9IbinD9oidEJ ar9IbinDint aEJ 9oid insereDint a;into resultEJ 9oid remo9eDint b;into resultEJ int buscaDint cEJ SSbusca binaria 9oid inIorderDEJ SSparentisada

214

far9IbinD9oidEJ UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

RincludeLiostream.!M RincludeLstdlib.!M Rinclude'binatree.!'

int no::<uantVWJ SSa<ui eu uso uma 9aria9el static

no::noDint aE TinfoVaJ es<V)$&&J dirV)$&&J<uant((JU

no::noDint a;no^ b;no^ cE SSconstructor TinfoVaJes<VbJdirVcJ<uant((JU

int no::retornaI<uantD9oidE T return <uantJ U

int no:: buscaImaises<D9oidE T if DD^t!isE.es<VVWE return infoJ else return DD^t!isE.es<BMbuscaImaises<DEEJ SSc!amada recursi9a. U

no^ no::insereDint a;into resE T resV2J if Dt!isVV)$&&E return ned noDa;)$&&;)$&&EJ 215

if DaMVinfoE if DdirVV)$&&E dirVned noDa;)$&&;)$&&EJ else dirVD^dirE.insereDa;resEJ else if DaLinfoE if Des<VV)$&&E es<Vned noDa;)$&&;)$&&EJ else es<VD^es<E.insereDa;resEJ return t!isJ SSnao e necessario. UJ

no^ no::remo9eDint b;into resE T int copyJ no^ deleteIau:J no^ returnIau:J SSusado para deletar um no if Dt!isVV)$&&E T resV A&0+J return )$&&J SSar9ore ou subar9ore 9aAia U else SSnot a nill pointer if DbMD^t!isE.infoE D^t!isE.dirVD^t!isE.dirBMremo9eDb;resEJ if DbLD^t!isE.infoE D^t!isE.es<VD^t!isE.es<BMremo9eDb;resEJ if DbVVD^t!isE.infoE SSpreciso deletar a<ui T resV#"$+J if DDD^t!isE.dirVV)$&&E oo DD^t!isE.es<VV)$&&EE SSsem fil!os T delete t!isJ return )$&&J U else if DD^t!isE.es<VV)$&&E SScomo remo9er de lista linear T deleteIau:Vt!isJ

216

returnIau:VDD^t!isE.dirEJ D^deleteIau:E.dirV)$&&J SSe9ita deletar subar9ore delete deleteIau:J return returnIau:J U else if DD^t!isE.dirVV)$&&E SScomo lista linear T deleteIau:Vt!isJ returnIau:VD^t!isE.es<J D^deleteIau:E.es<V)$&&J delete deleteIau:J SSnao es<ueca return returnIau:J U else SSo caso mais complicado T copyVD^t!isE.dirBMbuscaImaises<DEJ infoVcopyJ D^t!isE.dirVD^t!isE.dirBMremo9eDcopy;resEJ U U return t!isJ SSpara muitos casos. U

int no::buscaDint cE T if Dt!is]V)$&&E if DcVVinfoE return cJ else if DcMinfoE return DD^dirE.buscaDcEEJ else return DD^es<E.buscaDcEEJ else return BcJ

217

9oid no::inIorderD9oidE SSpercurso inIorder T if Dt!is]V)$&&E T cout LL 'D' J D^es<E.inIorderDEJ cout LL infoJ D^dirE.inIorderDEJ cout LL 'E'J UJ U

no::fnoD9oidE T if Dt!is]V)$&&E T <uantBBJ if Ddir]V)$&&E delete dirJ SSprimeiro c!ama destrutor depois deleta no if Des<]V)$&&E delete es<J SSo destrutor e c!amado para toda a ar9ore e entao U SSela 9olta deletando os nos U

ar9Ibin::ar9IbinD9oidE T arV)$&&JU

218

ar9Ibin::ar9IbinDint aE T arVned noDaEJU

SSinline 9oid ar9Ibin::insereDint a;into resultE T arVarBMinsereDa;resultEJ U

SSinline 9oid ar9Ibin::remo9eDint a;into resultE T arVarBMremo9eDa;resultEJU

SSinline int ar9Ibin::buscaDint aE T return arBMbuscaDaEJ U

SSinline 9oid ar9Ibin::inIorderD9oidE T arBMinIorderDEJ U

ar9Ibin::far9IbinDE T delete arJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Rinclude Liostream.!M Rinclude 'binatree.!'

mainDE SStesta a ar9ore com menu. T int nJ SSlido para ser inserido ou remo9ido. int flagJ 219

ar9Ibin myItreeJ c!ar optionV[d[J do T cout LL endlJ cout LL ' %B%nsereYn'J cout LL ' "B"emo9eYn'J cout LL ' )B%n Order DPercursoEYn'J cout LLe ' .B.uscaYn'J cout LL ' 0B0airYn'J cout LL ' +ntre opcao:'J cout LL ' Yn'J cin MMoptionJ SSentre a opcao do menu sditc!DoptionE SSe:ecutes user option T case [%[: case [i[: cout LL 'Yn Digite numero a inserir:'J cin MM nJ cout LL 'Yn'J flagV A&0+J myItree.insereDn;flagEJ cout LL 'flag:'LLflag LL endlJ breaiJ case ["[: case [r[: cout LL 'Yn Digite numero a remo9er:'J cin MM nJ cout LL 'Yn'J flagV A&0+J myItree.remo9eDn;flagEJ

220

cout LL 'flag:'LLflag LL endlJ breaiJ case [)[: case [n[: cout LL 'Yn'J myItree.inIorderDEJ cout LL ' ' LL no::<uant LL ':)osYn'J cout LL 'Yn'J breaiJ case [.[: case [b[: cout LL 'Yn Digite numero a ac!ar:'J cin MM nJ cout LL 'Yn'J cout LL ' ' LL myItree.buscaDnEJ cout LL 'Yn'J breaiJ case [0[: case [s[: cout LL 'Yn .Z+ Yn'J breaiJ default: J U SSsditc!Bcase code bloci U d!ile DDoption]V[s[EooDoption]V[0[EEJ cout LL ' )odes:' LL no::<uant LL endlJ return WJ U BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

"esultado do programa: )7o pode ser e:ibido por ser muito e:tenso. 221

P.4.G. 0%M$&A,-O D%"%*%DA A +?+)#O0.

+ste tCpico o Oltimo e o Onico <ue ainda est> sendo editado. +ste e:emplo apresenta uma simula67o dirigida a e9entos. 0imulamos um banco; as 9ari>9eis da simula67o s7o: tempo mdio de entrada de clientes no banco; tempo mdio de atendimento; nOmero de atendentes. A linguagem precursora das atuais linguagens orientadas a ob8etos; 0imula; n7o por acaso foi criada para programar simula65es. +m programa67o orientada a ob8etos estamos fre<uentemente preocupados em modelar entidades; ob8etos; do mundo real; 8ustamente esta a tarefa de uma simula67o. ?oc@ notar> <ue nosso programa principal bastante pe<ueno. Ocorre <ue main usado para apenas inicialiAar os ob8etos e a simula67o; a maioria das a65es ocorre atra9s de c!amadas de fun65es membro entre os ob8etos; isto muito bom; e9itamos ao m>:imo a presen6a de 9ari>9eis locais e passagem por refer@ncia. Clici !ere for Picture O diagrama mostra o cen>rio de nossa simula67o:

)este diagrama est7o presentes as classes com <ue iremos trabal!ar: costumer; cleri; sc!eduler; manager; frontIdoor; geometric. Costumer e cleri s7o subclasses de acti9e; uma classe base abstrata. Manager; costumer; cleri s7o ob8etos reais; e:istiriam no mundo real. 0c!eduler e frontIdoor; geometric n7o s7o ob8etos reis; s7o criados para au:iliar na simula67o. )ossa simula67o do tipo discreta; dirigida a e9entos; em contraposi67o com o tipo contnuo. Ou se8a estaremos atentos; monitorando;e9entos tais como o fato de um cliente entrar no banco ou ser atendido e n7o grandeAas continuas como a 9aA7o de uma bomba !idr>ulica ou a 9elocidade de um motor eltrico. )ossa simula67o dita discreta por<ue os e9entos ocorrem em inter9alos fi:os de tempo e n7o entre eles; o nOmero desses inter9alos escol!ido pelo usu>rio e de9e ser grande com rela67o aos tempos usados na simula67o Dtempo mdio de atendimento; etcE. +stes tempos mdios por serem inteiros de9em ser escol!idos de forma a n7o gerar casos degenerados; ou se8a se 9oc@ estimou <ue em seu banco o tempo de atendimento em geral tr@s 9eAes maior <ue o tempo mdio de entrada de clientes no banco; ent7o prefira uma rela67o do tipo DGeS3E ao en9s de D3SHE; esses tempos continuar7o pe<uenos perto do tempo de durac7o da simula67o: 2WWWW; porm n7o t7o pe<uenos <ue possam ser pouco mmdieresisnnrepresentati9osmmdieresisnn em termos de tempos diferentes <ue podem ocorrer. +ntenda por casos degenerados; casos <ue n7o ser7o capaAes de representar; modelar corretamente o <ue aconteceria em seu banco; fornecendo resultados discrepantes com outras op65es e<ui9alentes Dem termos de propor65esE de 9alores iniciais da simula67o. $m pouco sobre estatstica e probalilidade. ?amos precisar de conceitos de estatstica neste problema. A tempo de atendimento de clientes segue usualmente uma distribui67o geomtrica DlembreBse <ue em estatstica e:istem distribui65es discretas e contnuasE; a nossa discreta. A linguagem sC oferece a distribui67o de nOmeros con!ecida como uniforme ;a<uela em <ue todos nOmeros tem a mesma probabilidade de serem sorteados; ela pode ser gerada por c!amadas a fun67o randDE da mmdieresisnnlibrarymmdieresisnn stdlib.!; randDE gera nOmeros pseudoBaleatCrios na fai:a de W at "A)DIMAX Dn7o se preocupe; "A)DIMAX est> definido na stdlib.! e geralmenteVVHGe4eE. DiAemos <ue randDE gera nOmeros pseudoBaleatCrios por<ue esta fun67o utiliAa uma semente para gerar uma se<u@ncia de nOmeros; esta se<u@ncia de nOmeros pode ser repetida; basta utiliAar a mesma semente. +sta possbilidade de repeti67o ser> importante para realiAar testes do programa; fre<uentemente o programador dese8a repetir o resultado da Oltima e:ecu67o; isto sC poss9el se for fornecida a mesma semente de gera67o dos nOmeros atra9s de uma c!amada a fun67o 9oid srandDunsigned sE ; 8> importada com as 'libraries' <ue 9oc@ utiliAar> na simula67o. 222

eliAmente dispomos de uma maneira de construir um gerador de nOmeros <ue obedecem uma distribui67o geomtrica; a partir de um gerador de nOmeros aleatCrios. A distribui67o uniforme precisa como parametro um 9alor m>:imo; en<uanto <ue a geomtrica precisa de um 9alor mdio. )a distribui67o geomtrica; se um cliente atendido em um tempo mdio de 2W; ent7o podemos diAer <ue se ele ti9er come6ado a ser atendido agora; e:iste em mdia uma c!ance em deA de ele terminar de ser atendido no prC:imo instante. ?amos supor <ue o cliente n7o foi atendido logo no primeiro instante; ent7o e:iste uma c!ance em deA de ele ser atendido no prC:imo instante e assim por diante. As probabilidades s7o iguais e independentes uma das outras. A soma das probabilidades de cada instante completa 2 no tempo mdio de atendimento <ue no caso 2W. Porm isto n7o significa <ue 2W um limite m>:imo; mas apenas a mdia] 0e a probabilidade p de o cliente ser atendido no instante atual pVVD2SmdiaE ent7o a probabilidade de ele n7o ser atendido D2BpE. 0eguindo o raciocnio anterior; a probabilidade de o cliente ser atendido no primeiro ti<ue do relCgio p. A probabilidade <ue o mesmo cliente se8a atendido sC no segundo ti<ue igual a probabilidade de ele n7o ser atendido no primeiro ti<ueVVD2BpE e D^E a probabilidade de ele ser atendido no segundo ti<ueVVp Digual a p para todos os instantes isoladosE. 0eguindo o mesmo raciocnio; a probabilidade de o cliente 9ir a ser atendido sC no terceiro ti<ue D2BpE^D2BpE^p. A formula geral da probabilidade de um cliente esperar t ti<ues en<uanto atendido : p^DD2BpEwDtB2EE. 0upon!a <ue tomamos nV2WW bolas; das <uais pintamos DnSmdiaE de branco e o restante de preto DmdiaLnE. C!amemos de p a probabilidade de se retirar numa Onica tentati9a uma bola branca de nossas n bolas; p igual a D2SmdiaE. A probabilidade do e9ento complementar D2BD2SmdiaEEVVD2BpE. A probabilidade de se obter uma bola branca sC na segunda retirada com reposi67o D2BpE^p; en<uanto <ue sC na terceira retirada D2BpE^D2BpE^p e assim por diante; como no e:emplo anterior. Pois bem; as nossas n bolas podem ser 9istas como os nOmeros da distribui67o uniforme gerada por randDE. Pintar de branco parte das bolas de branco e o restante de preto e<ui9ale a di9idir o inter9alo de W at "A)DIMAX em nOmeros menores <ue D"A)DIMAX(2SmdiaEVVdaysItoIoccur DbrancosE e nOmeros maiores <ue isso DpretosE. 0ortear uma bola e 9erificar a cor e<ui9ale a c!amar randDE e 9er em <ue inter9alo o resultado cai. #emos ent7o o procedimento para obter nOmeros segundo uma distribui67o geomtrica a partir de um gerador de nOmeros aleatCrios. Construiremos uma classe em nosso programa para obter estes nOmeros; ser> a classe geometric. 0ua implementa67o est> no ar<ui9o geometric.cpp.

Clici !ere for Picture

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB SS ile repair.! SSbeader file for costumerBser9ement simulation Rinclude Lstdlib.!M Rinclude Liostream.!M

enum .oolean T A&0+;#"$+UJ SSW ou 2

223

class sc!edulerJ SSclasse nao real class managerJ SSclasse real

SSclass of geometricBdistribution random number generators

class geometricT int geoIma:J SSma:imum 9alue of random number int daysItoIoccurJ SSno. days desired e9ent can occur public: geometricDdouble mean;int ma:EJ int dradDEJ SSreturn ne:t random number .oolean eIagoraD9oidEJ SS9erifica se e agora <ue entra costumer UJ

SSAbstract base class of acti9e ob8ects

class acti9eT acti9e^ ne:tJ SSne:tBob8ect pointer for linied lists public: 9oid setIne:tDacti9e^ pE Tne:tVpJU acti9e^ getIne:tD9oidE Treturn ne:tJU 9irtual 9oid e9entDEVWJ SStrigger sc!eduled e9ent UJ

SSClass for costumer ob8ects

class costumer:public acti9eT sc!eduler^ spJ SSpointer to sc!eduler manager^ mpJ SSpointer to ser9ice manager geometric gJ SSrandom number generator .oolean isIupJ SSstateI9ariable int totIupItimeJ SStempo total de pe 224

int upItimeIstartJ SSstart of most recent upBperiod static double ser9edcostJ SStotal number of ser9ed costumers static double daitedtimeJ SStotal daited time for all costumers public: costumerDdouble mean;int ma:;sc!eduler^ s;manager^ mEJ 9oid e9entDEJ SStime to be ser9ed 9oid ser9edDEJ SSCome baci !ome costumer. DuilledE static double gIser9edcostDE Treturn ser9edcostJU static double gIdaitedtimeDE Treturn daitedtimeJU static int 9i9osJ SSnumero de costumers 9i9os; so pSdebugging fcostumerDE T9i9osBBJU SSso para controle de alocacao dinamica UJ

SSClass for cleri ob8ects

class cleri:public acti9eT sc!eduler^ spJ SSpointer to sc!eduler manager^ mpJ SSpointer to ser9ice manager geometric gJ SSrandom number generator costumer^ doripJ SSpointer to costumer under repair .oolean isIbusyJ SSstate 9ariable int busyItimeIstartJ SSstart of most recent busy period int totIbusyItimeJ SStotal busy time public: cleriDdouble mean;int ma:;sc!eduler^ s;manager^ mEJ 9oid e9entDEJ SStime to complete repair 9oid ser9eDcostumer^ pEJ SSacept dori assigment int busyItimeDEJ SSreturn total busy time UJ

class manager T

225

enum d!o TCO0#$M+"0;C&+"u0;)O)+UJ d!o daitingJ SSiind of ob8ects in <ueue acti9e^ firstJ SSpoints to first ob8ect in <ueue acti9e^ lastJ SSpoints to last ob8ect in <ueue double llsumJ SSline leng!t sum Dsum e9ery tici; d!en dit! costumersE int leng!tJ SScomprimento da fila

SSPri9ate functions for manipulating <ueue

9oid insertIfirstDacti9e^ pE TfirstVlastVpJ pBMsetIne:tDWEJleng!t((JU 9oid insertDacti9e^ pE TlastBMsetIne:tDpEJ pBMsetIne:tDWEJ lastVpJleng!t((JU 9oid remo9eDE TfirstVfirstBMgetIne:tDEJleng!tBBJU

SS9amos percorrer a lista e sortear cleri desocupado cleri^ escol!eIrandomicoD9oidE T SSescol!e randomico int posicaoJ posicaoVDrandDE j leng!tE(2J SS2..leng!t posicao a deletar acti9e^ corrVfirstJ SScorrente; itera sobre lista acti9e^ pre9V)$&&J SSainda nao esta sobre a lista for Dint iVWJiLDposicaoB2EJi((E SSiVlocal do pre9io DW...leng!tB2E T pre9VcorrJ corrVcorrBMgetIne:tDEJ SSdesloca ponteiros na lista U cleri^ retorneVDcleri^E corrJ SStype cast if DlastVVcorrE lastVpre9J if Dpre9VV)$&&E firstVcorrBMgetIne:tDEJ else pre9BMsetIne:tDcorrBMgetIne:tDEEJ 226

leng!tBBJ return retorneJ U SSescol!eIrandomico public: managerDE TfirstVlastVWJ daitingV)O)+Jleng!tVWJllsumVWJU 9oid re<uestIser9iceDcostumer^ pEJ SSser9ice re<uest costumer^ re<uestIdoriDcleri^ pEJ SSdori re<uest 9oid ticiD9oidE T if DdaitingVVCO0#$M+"0E llsum(Vleng!tJU double gIllsumD9oidE T return llsumJU fmanagerDE T d!ile Dfirst]V)$&&E Tacti9e^ au:VfirstJ firstVfirstBMgetIne:tDEJ delete au:JU U UJ

SSClass for sc!eduler class frontIdoorT pri9ate: double mediaJ int ma:imoJ sc!eduler^ spJ manager^ mpJ geometric^ gJ public: 9oid initDdouble mean;int ma:;sc!eduler^ s;manager^ mE T mediaVmeanJ ma:imoVma:J

227

spVsJ mpVmJ gVned geometricDmean;ma:EJ U 9oid sorteiaIcostD9oidE T costumer^ es<uecameJ if DgBMeIagoraDEE es<uecameVned costumerDmedia;ma:imo;sp;mpEJ SSnao se preocupe com delecao; o costumer se pendura nas listas SSDt!isE e 9ai acabar sendo deletado pelo cleri U ffrontIdoorD9oidE T delete gJU UJ

class sc!eduler T int clociJ SSsimulation cloci int calendarIsiAeJ SSsiAe of calendarI<ueue array acti9e^^ calendarJ SSpointer to calendar <ueue array int inde:J SScalendar <ueue array subscript for current time frontIdoor^ fdJ manager^ mJ public: sc!edulerDint sA;frontIdoor^ fdp;manager^ mpEJ int timeDE Treturn clociJU SSreturn time 9oid sc!eduleDacti9e^ p;int delayEJ SSsc!edule e9ent 9oid runDint ticisEJ SSrun simulation fsc!edulerD9oidE T for Dint iVWJiLcalendarIsiAeJi((E T d!ile Dcalendarmin]V)$&&E T 228

acti9e^ au:J au:VcalendarminJ calendarminVcalendarminBMgetIne:tDEJ delete au:J U U U UJ

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SS ile geometrc.cpp SS0ource file for class geometric

Rinclude Lstdlib.!M Rinclude 'repair.!'

Rifndef "A)DIMAX Rdefine "A)DIMAX HGe4e Rendif

SS"A)DICO$)# is number of different 9alues t!at SSrandDE can return

const double "A)DICO$)#VdoubleD"A)DIMAXE(2.WJ

SS%nitialiAe geometricBdistribution ob8ect

geometric::geometricDdouble mean; int ma:E T

229

daysItoIoccurVintD"A)DICO$)#Smean(W.aEJ geoIma:Vma:J U

SS"eturn ne:t geometrically distributed random number

int geometric::dradDE T for Dint iV2JiLgeoIma:Ji((E ifDrandDELdaysItoIoccurE return iJ return geoIma:J U

.oolean geometric::eIagoraD9oidE T return DrandDELdaysItoIoccurEJ SSc!ances de entrar agora pela porta U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SS ile acti9e.cpp SS0ource file for classes costumer and cleri Rinclude Liostream.!M Rinclude 'repair.!'

SS%nitialiAe costumer ob8ect and sc!edule first breaidodn

costumer::costumerDdouble mean;int ma:;sc!eduler^ s;manager^ mE:gDmean;ma:E T spVsJ mpVmJ 230

9i9os((J SScontrole de alocacao dinamica. totIupItimeVWJ isIupV#"$+J spBMsc!eduleDt!is;g.dradDEEJ SSupItimeIstart is not initialiAed !ere but d!en costumers enter in bani U

SS"e<uest ser9ice for disabled costumer

9oid costumer::e9entDE SSentering in t!e bani; start counting dait time T isIupV A&0+J SSnot outside t!e bani upItimeIstartVspBMtimeDEJ mpBMre<uestIser9iceDt!isEJ SSentrou no banco; fica na fila ou 9ai direto ao cai:a U

SS"eturn repaired costumer to ser9ice

9oid costumer::ser9edDE SSmay be iilled; deleted nod. T isIupV#"$+J totIupItime(VspBMtimeDEBupItimeIstartJ daitedtime(VtotIupItimeJ ser9edcost(V2J U

SS%nitialiAe cleri ob8ect and; if possible; get ob8ect[s SS irst dori assignment

cleri::cleriDdouble mean;int ma:;sc!eduler^ s;manager^ mE:gDmean;ma:E T

231

spVsJ mpVmJ totIbusyItimeVWJ doripVmpBMre<uestIdoriDt!isEJ if DdoripVVWE isIbusyV A&0+J else T isIbusyV#"$+J busyItimeIstartVspBMtimeDEJ spBMsc!eduleDt!is;g.dradDEEJ U U

SSComplete repair on current costumerJ if possible get SSned dori assignment

9oid cleri::e9entDE T totIbusyItime(VspBMtimeDEBbusyItimeIstartJ doripBMser9edDEJ SSgra9a estatisticas. delete doripJ SSmata costumer doripVmpBMre<uestIdoriDt!isEJ if DdoripVVWE isIbusyV A&0+J else T isIbusyV#"$+J busyItimeIstartVspBMtimeDEJ spBMsc!eduleDt!is;g.dradDEEJ U U

SSAcept dori assignment

232

9oid cleri::ser9eDcostumer^ pE T doripVpJ isIbusyV#"$+J busyItimeIstartVspBMtimeDEJ SScomeca contar tempo de ocupado spBMsc!eduleDt!is;g.dradDEEJ SSme tire do atendimente da<ui a g.drad tempos U

SS"eturn total busy time

int cleri::busyItimeDE T int tVtotIbusyItimeJ if DisIbusyE t(VspBMtimeDEBbusyItimeIstartJ return tJ U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SS ile manager.cpp SS0ource file for class manager Rinclude Liostream.!M Rinclude 'repair.!'

SSbandle ser9ice re<uest from disabled costumer

9oid manager::re<uestIser9iceDcostumer^ pE T cleri^ <J sditc!DdaitingE T

233

case CO0#$M+"0: insertDpEJ returnJ case C&+"u0: <Vescol!eIrandomicoDEJ SSpega um cleri desocupado <ual<uer; 8a con9erte Dcleri^E if DfirstVV)$&&E daitingV)O)+J <BMser9eDpEJ returnJ case )O)+: daitingVCO0#$M+"0J insertIfirstDpEJ returnJ U UJ

SSbandle dori re<uest from idle cleri

costumer^ manager::re<uestIdoriDcleri^ pE T costumer^ <J

sditc! DdaitingET case CO0#$M+"0: <VDcostumer^E firstJ remo9eDEJ if DfirstVV)$&&E daitingV)O)+J return <J case C&+"u0: insertDpEJ return )$&&J case )O)+: daitingVC&+"u0J 234

insertIfirstDpEJ return )$&&J U return )$&&J U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SS ile sc!edule.cpp SS0ource file for class sc!eduler Rinclude Liostream.!M Rinclude 'repair.!'

SSCreate sc!eduler dit! calendar <ueue !a9ing sA elements

sc!eduler::sc!edulerDint sA;frontIdoor^ fdp;manager^ mngrpE T fdVfdpJ SSarmaAena o frontIdoor pointer mVmngrpJ SSarmaAena o manager pointer clociVWJ calendarIsiAeVsAJ calendarVned acti9e^msAnJ for Dint iVWJiLsAJi((E calendarminVWJ inde:VWJ U

SS0c!edule ob8ect ^p to recei9e e9ent message SSafter delay ticis !a9e elapsed

9oid sc!eduler::sc!eduleDacti9e^ p;int delayE

235

T int tVinde:(delayJ if DtMVcalendarIsiAeE tBVcalendarIsiAeJ pBMsetIne:tDcalendarmtnEJ calendarmtnVpJ U

SS"un simulation for gi9en number of ticis

9oid sc!eduler::runDint ticisE T acti9e^ pJ for Dint iVWJiLticisJi((E T fdBMsorteiaIcostDEJ SSagenda entrada do no9o costumer en<uanto SSnao comecou a me:er em listas ainda; senao corrompe estado mBMticiDEJ SSfaA manager gra9ar estatisticas das listas d!ileDDpVcalendarminde:nE]VWE T calendarminde:nVpBMgetIne:tDEJ pBMe9entDEJ U cloci((J if D((inde:VVcalendarIsiAeE inde:VWJ U U

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

SS ile simula.cpp SSprograma demonstracao para simulacao de clienteBatendente

Rinclude Liostream.!M

236

Rinclude Lstdlib.!M Rinclude 'repair.!'

SSinicialiAando os membros static da classe costumer double costumer::ser9edcostVW.WJ double costumer::daitedtimeVW.WJ int costumer::9i9osVWJ SSpara controle da alocacao dinamica

mainDE T SSdeclaracao de 9aria9eis obtencao de 9alores do usuario unsigned sementeJ SSseed for randDE int numIad8J SSnumero de cleris double mImeanJ SStempo medio entre entradas no estabelecimento double aImeanJ SStempo medio de atendimento

cout LL ')umero de atendentesK'J cin MM numIad8J cout LL '#empo medio de entrada de clientes pela portaK'J cin MM mImeanJ cout LL '#empo medio de ser9ico; atendimentoK'J cin MM aImeanJ cout LL '0emente de numeros randomicosK'J cin MM sementeJ

SS0eed randDEJ set ma:Itime to ten times ma:imum of SSmImean and aImean

srandDsementeEJ int ma:ItimeV2W^intDmImeanMaImeanKmImean:aImeanEJ int iJ

237

SSCria manager e sc!eduler

manager mngrJ frontIdoor criadorJ sc!eduler sc!Dma:Itime(2;ocriador;omngrEJ criador.initDmImean;ma:Itime;osc!;omngrEJ SSinicialiAa criador de costumers SScom as caracteristicas esperadas dos costumers; como nao e construtor; posso SSmodificar as caracteristicas dos costumers durante programa.

SSCria cleris cleri^^ aIlistVned cleri^mnumIad8nJ for DiVWJiLnumIad8Ji((E aIlistminVned cleriDaImean;ma:Itime;osc!;omngrEJ

SS aA sucessi9os loops da simulacaoJ imprime estatisticas cumulati9as SSdepois de cada con8unto de iteracoes completo

c!ar c!J do T SS*et number of ticis for t!is run int durationJ cout LL 'Yn)umber of time stepsK'J cin MM durationJ

SS"un duration

sc!.runDdurationEJ

SSCOMP$#A + %MP"%M+ #+MPO M+D%O D+ %&A Dpor costumerE long tempoImedioVDcostumer::gIdaitedtimeDEESDcostumer::gIser9edcostDEEJ

238

cout LL '#empo medio na fila:' LL tempoImedio LL endlJ

SScomputa e imprime utiliAacao media dos atendentes

double aIfactorV2WW.WSdoubleDsc!.timeDEESdoubleDnumIad8EJ long totIbusyItimeVWJ for DiVWJiLnumIad8Ji((E totIbusyItime(VaIlistminBMbusyItimeDEJ cout LL 'Media da utiliAacao dos atendentes:' LL totIbusyItime^aIfactorLL'jYn'J

double a9llJ SSa9erage costumer line leng!t a9llVmngr.gIllsumDESsc!.timeDEJ cout LL 'Comprimento medio da fila:' LL a9ll LL endlJ

SSDetermine if user dants to do more runs

cout LL 'Clientes ainda nao atendidos:' LL costumer::9i9os LL endlJ SSestes ou estao na fila para serem atendidos; ou se penduraram no SScalendar <ueue; e so para controle da alocacao dinamica.

cout LL 'Continue DZS)EK'J cin MM c!J U d!ile Dc!VV[y[ pp c!VV[y[EJ

delete mnaIlistJ return WJ U

SS"+0$&#ADO0 DO P"O*"AMA; A PA"#%" DO0 ?A&O"+0 %)%C%A%0 DO P"%M+%"O #+0#+ SSD#+0#+ A 0+*$%"E $% ?A"%A)DO $M PA"AM+#"O PO" ?+k + ?+)DO 0+ O SS"+0$&#ADO +"A CO+"+)#+. SS)umero de atendentesK2 239

SS#empo medio de entrada de clientes pela portaKQ SS#empo medio de ser9ico; atendimentoKH SS0emente de numeros randomicosKH2P24 SS SS)umber of time stepsKaWWW SS#empo medio na fila:H SSMedia da utiliAacao dos atendentes:H4.2Pj SSComprimento medio da fila:W.2HQP SSClientes ainda nao atendidos:2 SSContinue DZS)EKy SS SS)umber of time stepsK2WWWW SS#empo medio na fila:P SSMedia da utiliAacao dos atendentes:He.e3HHj SSComprimento medio da fila:W.2aH44e SSClientes ainda nao atendidos:P SSContinue DZS)EKn SS SS)umero de atendentesKG SS#empo medio de entrada de clientes pela portaKQ SS#empo medio de ser9ico; atendimentoKH SS0emente de numeros randomicosKH2P24 SS SS)umber of time stepsKaWWW SS#empo medio na fila:G SSMedia da utiliAacao dos atendentes:2Q.Hj SSComprimento medio da fila:W.WWQQ SSClientes ainda nao atendidos:W SSContinue DZS)EKy SS SS)umber of time stepsK2WWWW

240

SS#empo medio na fila:H SSMedia da utiliAacao dos atendentes:2Q.PWHHj SSComprimento medio da fila:W.WW4Q SSClientes ainda nao atendidos:G SSContinue DZS)EK SS SS)umero de atendentesK2 SS#empo medio de entrada de clientes pela portaK4 SS#empo medio de ser9ico; atendimentoKH SS0emente de numeros randomicosKH2P24 SS SS)umber of time stepsKaWWW SS#empo medio na fila:P SSMedia da utiliAacao dos atendentes:aW.W4j SSComprimento medio da fila:W.H2WP SSClientes ainda nao atendidos:W SSContinue DZS)EKy SS SS)umber of time stepsK2WWWW SS#empo medio na fila:a SSMedia da utiliAacao dos atendentes:a2j SSComprimento medio da fila:W.Ha43HH SSClientes ainda nao atendidos:2 SSContinue DZS)EK SS SS)umero de atendentesK2 SS#empo medio de entrada de clientes pela portaKQ SS#empo medio de ser9ico; atendimentoKa SS0emente de numeros randomicosKH2P24 SS SS)umber of time stepsKaWWW SS#empo medio na fila:22 241

SSMedia da utiliAacao dos atendentes:a3.aPj SSComprimento medio da fila:W.e424 SSClientes ainda nao atendidos:2 SSContinue DZS)EKy BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

ConteOdo:

.ibliografia:

m2n "umbaug!; .la!a M.; Premerlani c.; +ddy . o &orensen c. ;'Ob8ectBOriented Modeling and Design'. Prentice ball; 2332.

mGn .udd. # ;'Classical Data 0tructures %n C(('. AddisonBcesley 233P.

mHn Mitc!el M. ;'Data Abstraction in C(('

mPn *ra!am. ).;'&earning C(('. Mc*"AcBb%&&; 2332.

man 0troustrup. ..; '#!e C(( Programming &anguage'. AddisonBcesley 2332. '#utoriais e e:erccios online sobre C(( e +iffel' Departamento de ci@ncia da computa67o; "oc!ester %nstitute of #ec!nology

242