LivroCpp-2nd-novatec

Programa¸cão Orientada a Objeto com C++ 2 edição

André Duarte Bueno, UENF-LENEP-LDSC http://www.lenep.uenf.br/~bueno email: [email protected] 25 de setembro de 2007

Copyright(C) 2003-2007 da Novatec Editora Ltda. ´ proibida a reprodu¸ca Todos os direitos reservados e protegidos pela Lei 5.988 de 14/12/1973. E õ desta obra, mesmo parcial, por qualquer processo, sem prévia autoriza¸ca õ, por escrito, do autor e da Editora.

Editor: RUBENS PRATES Capa: CAMILA MESQUITA Revis˜ ao: PATRIZIA ZAGNI ´ DUARTE BUENO Editora¸ca õ eletrˆ onica: ANDRE Revis˜ ao técnica desta edi¸ca õ: TIAGO RIBEIRO SCHAEWER [M.Sc, Doutorando] TIAGO CALIMMAN [Mestrando] IRINEU SILVA [Mestrando] ALLAN GALANTE [M.Sc.] GIOVANNI COLONESE [M.Sc.] ISBN: XX-XXXX-XXX-X

NOVATEC EDITORA LTDA. Rua Cons. Moreira de Barros, 1084 Conj. 01 02018-012 S˜ ao Paulo, SP Brasil Tel.: +55 11 6959-6529 Fax: +55 11 6950-8869 E-mail: [email protected] Endere¸co: www.novateceditora.com.br

Este livro foi desenvolvido no LDSC/LENEP/UENF Laboratório de Desenvolvimento de Software Cient´ıfico - LDSC http://www.lenep.uenf.br/~ldsc do Laboratório de Engenharia e Explora¸caõ de Petr´ oleo - LENEP http://www.lenep.uenf.br da Universidade Estadual do Norte Fluminense - Darcy Ribeiro - UENF http://www.uenf.br

2

Sum´ ario I

Filosofia e Modelagem Orientada a Objeto

49

1 Introdu¸ c˜ ao ` a Programa¸ c˜ ao 1.1 Programas e softwares . . . . . . . . . . . . . . . . . . . . 1.1.1 O que é um programa, um software? . . . . . . . . 1.2 Defini¸caõ de software propriet´ ario e software livre . . . . . 1.2.1 Defini¸caõ e caracter´ısticas do software propriet´ ario 1.2.2 Defini¸caõ e caracter´ısticas do software livre . . . . 1.2.3 Exemplos de softwares livres e propriet´ arios . . . . 1.3 Tipos de interface de um programa/software . . . . . . . . 1.3.1 Um programa sem interface (kernel numérico) . . . 1.3.2 Um programa com interface via linha de comando 1.3.3 Um programa com interface em modo texto . . . . 1.3.4 Um software com interface em modo gráfico . . . . 1.4 Que tipo de software devo desenvolver? . . . . . . . . . . 1.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . 1.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

51 51 51 52 52 52 54 54 55 55 56 57 58 59 59

2 Introdu¸ c˜ ao ` a Programa¸ c˜ ao Orientada a Objeto – POO 2.1 Entendendo os objetos . . . . . . . . . . . . . . . . . . . . . 2.2 Exemplo de objeto . . . . . . . . . . . . . . . . . . . . . . . 2.3 O conceito de objeto (ou instância) . . . . . . . . . . . . . . 2.4 Breve histórico da programa¸caõ orientada a objeto . . . . . 2.4.1 Vis˜ ao desorganizada e vis˜ ao estruturada versus visão 2.4.2 Vantagens da POO . . . . . . . . . . . . . . . . . . . 2.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . 2.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . orientada a objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . .

61 61 62 63 63 64 66 66 66

3 Conceitos B´ asicos de Orienta¸ c˜ ao a Objeto – OO 3.1 Abstra¸caõ . . . . . . . . . . . . . . . . . . . . . . . 3.2 Encapsulamento e oculta¸caõ . . . . . . . . . . . . . 3.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . 3.4 Atributos (propriedades e vari´ aveis) . . . . . . . . 3.5 Métodos (fun¸co˜es, opera¸co˜es e servi¸cos) . . . . . . 3.6 Heran¸ca . . . . . . . . . . . . . . . . . . . . . . . . 3.7 Polimorfismo . . . . . . . . . . . . . . . . . . . . . 3.8 Outros conceitos u ´ teis . . . . . . . . . . . . . . . . 3.9 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . 3.10 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

69 69 70 72 73 73 74 75 76 79 80

3

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

´ SUMARIO

4 4 Modelagem Orientada a Objeto 4.1 Introdu¸caõ à modelagem . . . . . . . . . . . . . . . . . . . . . . 4.1.1 O que é um modelo? . . . . . . . . . . . . . . . . . . . . 4.1.2 Tipos e exemplos de modelos . . . . . . . . . . . . . . . 4.1.3 Por que usamos modelos? . . . . . . . . . . . . . . . . . 4.2 Introdu¸caõ à modelagem orientada a objeto . . . . . . . . . . . 4.2.1 O que é a modelagem orientada a objeto? . . . . . . . 4.2.2 Quando surgiu a modelagem orientada a objeto? . . . 4.2.3 Quais as vantagens da modelagem orientada a objeto? . 4.3 O que é a UML? . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.1 As diferentes vis˜ oes da UML e os respectivos diagramas 4.3.2 Os elementos da UML . . . . . . . . . . . . . . . . . . . 4.3.3 Os estereótipos da UML2 . . . . . . . . . . . . . . . . . 4.4 Programas para modelagem orientada a objeto . . . . . . . . . 4.4.1 O programa Dia . . . . . . . . . . . . . . . . . . . . . . 4.4.2 O programa umbrello . . . . . . . . . . . . . . . . . . . 4.4.3 O programa Visual-Paradigm . . . . . . . . . . . . . . . 4.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . 4.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

81 81 81 82 82 84 84 84 85 85 85 88 89 93 93 94 96 96 97

5 Engenharia de Software 5.1 O que é e quais s˜ ao os objetivos da engenharia de software? . 5.2 Breve histórico da engenharia de software . . . . . . . . . . . 5.3 Caracter´ısticas dos modelos de engenharia de software . . . . 5.3.1 Modelo seq¨ uencial linear . . . . . . . . . . . . . . . . . 5.3.2 Modelo iterativo . . . . . . . . . . . . . . . . . . . . . 5.3.3 Modelo baseado em prototipagem . . . . . . . . . . . 5.3.4 Modelo RAD – Rapid Application Development . . . 5.3.5 Modelo incremental . . . . . . . . . . . . . . . . . . . 5.3.6 Modelo espiral . . . . . . . . . . . . . . . . . . . . . . 5.3.7 Modelo TMO – Tecnologia de Modelagem de Objetos 5.3.8 Modelo UP – Unified Process . . . . . . . . . . . . . . 5.3.9 Modelo XP – eXtreme Programming . . . . . . . . . . 5.4 O modelo selecionado . . . . . . . . . . . . . . . . . . . . . . 5.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . 5.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

99 99 100 101 101 102 102 102 102 102 103 103 104 105 106 106

6 Etapas para o Desenvolvimento de um Software 6.1 Concep¸caõ – especifica¸caõ . . . . . . . . . . . . . . . . . . . 6.1.1 Casos de uso do software – cen´ arios . . . . . . . . . 6.1.2 Diagrama de casos de uso . . . . . . . . . . . . . . . 6.1.3 Senten¸cas para casos de uso . . . . . . . . . . . . . . 6.2 Elabora¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.1 An´ alise de dom´ınio . . . . . . . . . . . . . . . . . . . 6.2.2 Identifica¸caõ de pacotes – assuntos . . . . . . . . . . 6.2.3 Diagrama de pacotes – assuntos, módulos . . . . . . 6.2.4 Senten¸cas para pacotes . . . . . . . . . . . . . . . . . 6.2.5 Montagem de prot´ otipo da interface do software . . 6.2.6 Defini¸caõ de cronogramas, prazos, custos, contratos 6.3 AOO – An´ alise Orientada a Objeto . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

109 110 111 111 113 114 115 116 116 117 117 118 119

Novatec - Programa¸caõ Orientada a Objeto com C++

. . . . . . . . . . . .

André Duarte Bueno

´ SUMARIO 6.4

6.5

6.6

6.7

6.8

6.9

5

AOO – Modelo estrutural . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.1 Identifica¸caõ de classes . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.2 Identifica¸caõ de atributos . . . . . . . . . . . . . . . . . . . . . . . 6.4.3 Identifica¸caõ de métodos . . . . . . . . . . . . . . . . . . . . . . . . 6.4.4 Diagrama de classes . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.5 Identifica¸caõ de associa¸co˜es . . . . . . . . . . . . . . . . . . . . . . 6.4.6 Diagrama de classes com associa¸co˜es . . . . . . . . . . . . . . . . . 6.4.7 Classe de associa¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.8 Identifica¸caõ de agrega¸co˜es e composi¸co˜es . . . . . . . . . . . . . . 6.4.9 Diagrama de classes com agrega¸co˜es e composi¸co˜es . . . . . . . . . 6.4.10 Identifica¸caõ de heran¸cas . . . . . . . . . . . . . . . . . . . . . . . 6.4.11 Diagrama de classes com heran¸cas . . . . . . . . . . . . . . . . . . 6.4.12 Identifica¸caõ de classes abstratas e classes de interface . . . . . . . 6.4.13 Restri¸co˜es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.14 Realiza¸co˜es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.15 Dependências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.16 Identifica¸caõ de objetos . . . . . . . . . . . . . . . . . . . . . . . . 6.4.17 Diagrama de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.18 Diagrama de estrutura composta . . . . . . . . . . . . . . . . . . . 6.4.19 Resumo dos diagramas do modelo estrutural . . . . . . . . . . . . 6.4.20 Itera¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . AOO – Modelo dinˆ amico . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5.1 Identifica¸caõ de eventos e mensagens . . . . . . . . . . . . . . . . . 6.5.2 Diagrama de seq¨ uência – eventos e mensagens . . . . . . . . . . . . 6.5.3 Diagrama de comunica¸caõ – colabora¸caõ . . . . . . . . . . . . . . 6.5.4 Identifica¸caõ dos estados assumidos pelo objeto . . . . . . . . . . . 6.5.5 Diagrama de máquina de estado . . . . . . . . . . . . . . . . . . . 6.5.6 Identifica¸caõ de atividades . . . . . . . . . . . . . . . . . . . . . . . 6.5.7 Diagrama de atividades . . . . . . . . . . . . . . . . . . . . . . . . 6.5.8 Diagrama de tempo . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5.9 Diagrama de intera¸caõ geral . . . . . . . . . . . . . . . . . . . . . . 6.5.10 Resumo dos diagramas do modelo dinâmico . . . . . . . . . . . . . 6.5.11 Itera¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Projeto do sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.1 Defini¸caõ da interface de programa¸caõ – API . . . . . . . . . . . . 6.6.2 Sele¸caõ da implementa¸caõ de controle . . . . . . . . . . . . . . . . 6.6.3 Sele¸caõ das plataformas a serem suportadas . . . . . . . . . . . . . 6.6.4 Sele¸caõ das bibliotecas externas . . . . . . . . . . . . . . . . . . . . 6.6.5 Sele¸caõ da biblioteca gr´ afica a ser utilizada – GDI . . . . . . . . . 6.6.6 Sele¸caõ do ambiente de desenvolvimento integrado – IDE . . . . . Projeto orientado a objeto – POO . . . . . . . . . . . . . . . . . . . . . . 6.7.1 Diagrama de componentes . . . . . . . . . . . . . . . . . . . . . . . 6.7.2 Diagrama de implanta¸caõ – execu¸caõ . . . . . . . . . . . . . . . . . Implementa¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8.1 Antes de iniciar a implementa¸caõ . . . . . . . . . . . . . . . . . . . 6.8.2 Roteiro para montar o c´ odigo inicial do programa com o Umbrello 6.8.3 Dicas para implementa¸caõ da interface gráfica . . . . . . . . . . . Teste de software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.9.1 Por que testar? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

119 119 120 121 122 123 124 125 125 126 126 128 128 130 130 130 130 131 131 131 132 133 133 134 137 138 139 143 143 146 146 146 146 148 149 150 150 151 152 152 157 159 160 161 161 161 162 162 163


´ SUMARIO

6

6.10

6.11

6.12 6.13

II

6.9.2 Equipe de teste . . . . . . . . . . . . . . . . . . . . . 6.9.3 Metodologia de teste . . . . . . . . . . . . . . . . . . 6.9.4 Senten¸cas para teste de software . . . . . . . . . . . Documenta¸caõ do programa . . . . . . . . . . . . . . . . . . 6.10.1 Itens a serem documentados . . . . . . . . . . . . . . 6.10.2 Cart˜ oes CRC . . . . . . . . . . . . . . . . . . . . . . 6.10.3 Dicionário de classes . . . . . . . . . . . . . . . . . . Manuten¸caõ e reuso de software . . . . . . . . . . . . . . . . 6.11.1 Senten¸cas e dicas para conseguir o reuso de software 6.11.2 Senten¸cas para aumentar o empacotamento . . . . . 6.11.3 Senten¸cas para conseguir o reuso de classes . . . . . 6.11.4 Senten¸cas para conseguir o reuso de métodos . . . . 6.11.5 Senten¸cas para montagem de bibliotecas . . . . . . 6.11.6 Senten¸cas para montagem de framework . . . . . . 6.11.7 Senten¸cas para facilitar a extensão de um programa 6.11.8 Senten¸cas para programa¸caõ em grande escala . . . Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

POO usando C++

. . . . . . . . . . . . . . . . . .

163 163 166 168 168 172 172 173 173 173 173 174 175 175 176 176 177 177

181

7 Introdu¸ c˜ ao ao C++ 7.1 Um pouco de história . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Exemplos de aplica¸co˜es em C++ . . . . . . . . . . . . . . . . . . . . 7.3 O que é o Ansi C++? . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4 Quais as novidades e vantagens de C++ em rela¸caõ a C? . . . . . . 7.5 Quais os tipos de programas em C++ . . . . . . . . . . . . . . . . . 7.6 Diferen¸cas de nomenclatura – POO e C++ . . . . . . . . . . . . . . 7.7 Editar, pré-processar, compilar, linkar, debugar e otimizar . . . . . . 7.8 Layout de um programa orientado a objeto em C++2 . . . . . . . . 7.8.1 Arquivo de projeto . . . . . . . . . . . . . . . . . . . . . . . . 7.8.2 Arquivo de cabe¸calho da classe – CNomeClasse.h . . . . . . . 7.8.3 Arquivo de implementa¸caõ da classe – CNomeClasse.cpp . . . 7.8.4 Arquivo de implementa¸caõ da fun¸caõ main() – programa.cpp 7.9 Senten¸cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.10 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.11 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

183 183 184 185 185 186 186 187 189 189 189 190 191 192 193 193

8 Conceitos b´ asicos de C++ 8.1 Sobre a sintaxe de C++ . . . . . . . . . . . . . . . . . 8.2 Palavras-chave do C++ . . . . . . . . . . . . . . . . . 8.3 Nome dos objetos – identificadores . . . . . . . . . . . 8.3.1 Conven¸caõ para nomes de objetos . . . . . . . 8.4 Declara¸co˜es . . . . . . . . . . . . . . . . . . . . . . . . 8.4.1 Exemplos de declara¸co˜es e defini¸co˜es2 . . . . . 8.5 Defini¸co˜es . . . . . . . . . . . . . . . . . . . . . . . . . 8.6 Introdu¸caõ à fun¸caõ main() . . . . . . . . . . . . . . . 8.7 Introdu¸caõ à entrada e sa´ıda de dados com cin e cout 8.7.1 Usando cout . . . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

195 195 198 199 199 199 200 200 201 201 202


. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .


´ SUMARIO . . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

203 205 205 206 206 207 208 208 210 213 214 215 216

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

217 217 217 221 222 224 225 225 225 228 229 229 230 231 233 235 235 236 236 238 239 239 240 240

10 Namespace 10.1 O que é um namespace? . . . . . . . . . . . . . . . . . . . . 10.2 Utilizando o espa¸co de nomes da biblioteca-padr˜ ao – std:: 10.3 Mudando escopo com using . . . . . . . . . . . . . . . . . . 10.4 Protótipo para declarar e definir um namespace . . . . . . . 10.5 Namespaces anˆ onimos . . . . . . . . . . . . . . . . . . . . . 10.6 Namespaces – uso avan¸cado2 . . . . . . . . . . . . . . . . . 10.6.1 Compondo namespace com using2 . . . . . . . . . . 10.6.2 Namespace aninhado2 . . . . . . . . . . . . . . . . . 10.6.3 Usando vari´ aveis est´ aticas em um namespace2 . . . 10.7 Senten¸cas para namespace . . . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

243 243 244 244 245 247 248 248 248 248 249

8.8 8.9

8.10 8.11 8.12 8.13 8.14 8.15

8.7.2 Usando cin . . . . . . . . . . . . . . . . Introdu¸caõ ` as diretrizes de pré-processador . . 8.8.1 Usando #ifdef..#endif . . . . . . . . Introdu¸caõ ` as estruturas de controle . . . . . . 8.9.1 Usando for . . . . . . . . . . . . . . . . 8.9.2 Usando while e fun¸co˜es da biblioteca de Introdu¸caõ aos operadores de C++ . . . . . . . 8.10.1 Usando operadores de C++ . . . . . . . Introdu¸caõ as fun¸co˜es . . . . . . . . . . . . . . Declara¸co˜es e escopo . . . . . . . . . . . . . . . Senten¸cas para conceitos b´ asicos de C++ . . . Resumo do cap´ıtulo . . . . . . . . . . . . . . . Exerc´ıcios . . . . . . . . . . . . . . . . . . . . .

7 . . . . . . . . . . . . . . . . . . . . . . . . . C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9 Tipos 9.1 Introdu¸caõ ao conceito de tipos . . . . . . . . . . . . 9.2 Uso de tipos predefinidos de C++ . . . . . . . . . . 9.2.1 Uso de sufixos para os tipos predefinidos2 . . 9.2.2 Uso avan¸cado dos tipos predefinidos2 . . . . . 9.2.3 Senten¸cas para uso de tipos predefinidos . . . 9.3 Uso de tipos do usu´ ario . . . . . . . . . . . . . . . . 9.3.1 Introdu¸caõ aos vetores no estilo de C . . . . . 9.3.2 Introdu¸caõ ` as estruturas . . . . . . . . . . . 9.3.3 Introdu¸caõ ` as uni˜ oes . . . . . . . . . . . . . . 9.3.4 Introdu¸caõ ` as enumera¸co˜es . . . . . . . . . . 9.3.5 Introdu¸caõ ` as classes . . . . . . . . . . . . . . 9.4 Usando tipos definidos em bibliotecas – STL . . . . 9.4.1 Introdu¸caõ ` a classe . . . . . . . . . 9.4.2 Introdu¸caõ ` a STL e ` a classe . . . . 9.5 Manipulando tipos . . . . . . . . . . . . . . . . . . . 9.5.1 Criando apelidos – typedef . . . . . . . . . 9.5.2 Obtendo o tipo de tamanho – size_t() . . . 9.5.3 Obtendo o tamanho dos objetos – sizeof() . 9.5.4 Identificando o tipo do objeto – typeid()2 . 9.6 Vantagem da tipifica¸caõ forte do C++ . . . . . . . . 9.7 Senten¸cas para tipos . . . . . . . . . . . . . . . . . . 9.8 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . 9.9 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . .


. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .


´ SUMARIO

8

10.8 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 10.9 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 11 Classes 11.1 Protótipo para declarar e definir classes . . . . . . . . 11.2 Encapsulamento em C++ utilizando o especificador de 11.3 Classes e escopo . . . . . . . . . . . . . . . . . . . . . 11.4 Classes e diretrizes de pré-processador . . . . . . . . . 11.5 Classes – Uso avan¸cado2 . . . . . . . . . . . . . . . . . 11.5.1 Classes abstratas2 . . . . . . . . . . . . . . . . 11.5.2 Classes de interface2 . . . . . . . . . . . . . . . 11.5.3 Classes encapsulamento e robustes de c´ odigo2 . 3 11.5.4 Classes aninhadas . . . . . . . . . . . . . . . . 11.5.5 Classes do tipo POD3 . . . . . . . . . . . . . . 11.5.6 Classes do tipo trivial3 . . . . . . . . . . . . . . 11.6 Senten¸cas para classes . . . . . . . . . . . . . . . . . . 11.7 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . 11.8 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . acesso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

251 251 252 253 253 254 254 255 255 256 257 257 258 259 259

12 Atributos 12.1 Protótipo para declarar e definir atributos 12.2 Atributos de objeto . . . . . . . . . . . . . 12.3 Atributos de classe – static . . . . . . . 12.4 Atributos constantes – const . . . . . . . 12.5 Atributos – uso avan¸cado2 . . . . . . . . . 12.5.1 Atributos mutantes – mutable2 . . 12.5.2 Atributos vol´ ateis – volatile3 . . 12.6 Senten¸cas para atributos . . . . . . . . . . 12.7 Resumo do cap´ıtulo . . . . . . . . . . . . 12.8 Exerc´ıcios . . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

261 261 262 263 265 266 266 267 267 268 268

13 M´ etodos 13.1 Introdu¸caõ aos métodos de C++ . . . . . . . . . 13.2 Protótipo para declarar e definir métodos . . . . 13.3 Declara¸caõ de um método . . . . . . . . . . . . . 13.4 Defini¸caõ de um método . . . . . . . . . . . . . . 13.5 Retorno de um método . . . . . . . . . . . . . . . 13.6 Parâmetros dos métodos . . . . . . . . . . . . . . 13.6.1 Passagem dos parˆ ametros por c´ opia . . . 13.6.2 Passagem dos parˆ ametros por referência 13.6.3 Passagem dos parˆ ametros por ponteiro . . 13.6.4 Parâmetros predefinidos – inicializadores . 13.7 Métodos normais . . . . . . . . . . . . . . . . . . 13.8 Métodos constantes – const . . . . . . . . . . . . 13.9 Métodos est´ aticos – static . . . . . . . . . . . . 13.10Métodos em linha – inline . . . . . . . . . . . . 13.11Métodos – uso avan¸cado . . . . . . . . . . . . . . 13.12Senten¸cas para métodos . . . . . . . . . . . . . . 13.13Resumo do cap´ıtulo . . . . . . . . . . . . . . . . 13.14Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

269 269 270 271 272 273 273 274 274 275 277 278 281 284 286 290 290 292 292

. . . . . . . . . .

. . . . . . . . . .


. . . . . . . . . .


´ SUMARIO 14 Sobrecarga de M´ etodos 14.1 Protótipo para sobrecarga de métodos . . . . . . . 14.2 Como implementar a sobrecarga de métodos . . . 14.3 Sobrecarga de métodos – conceitos avan¸cados2 . . 14.3.1 Acessibilidade x visibilidade: como é feita executado . . . . . . . . . . . . . . . . . . . 14.4 Senten¸ca para sobrecarga de métodos . . . . . . . . 14.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . 14.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . .

9

. . . .

297 297 298 298

15 Ponteiros, Referˆ encias e Gerenciamento de Mem´ oria 15.1 Protótipo para declarar e definir ponteiros e referências . . . . . . . . . . . . . 15.2 Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3 Cria¸caõ e uso de objetos dinˆ amicos com ponteiros . . . . . . . . . . . . . . . . . 15.3.1 O operador new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3.2 O operador delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4 Ponteiro this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.5 Ponteiros const e ponteiros para const . . . . . . . . . . . . . . . . . . . . . . 15.5.1 Ponteiro para um objeto constante . . . . . . . . . . . . . . . . . . . . . 15.5.2 Ponteiro constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.5.3 Ponteiro constante para um objeto constante . . . . . . . . . . . . . . . 15.6 Referências (&) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.6.1 Diferen¸cas entre referência e ponteiro . . . . . . . . . . . . . . . . . . . . 15.6.2 Referências para ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . 15.7 Conceitos b´ asicos de gerenciamento de memória2 . . . . . . . . . . . . . . . . . 15.7.1 Entendendo o uso de new/delete com vetores . . . . . . . . . . . . . . 15.7.2 Alinhamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.7.3 D´ uvidas freq¨ uentes no uso de new, delete e gerenciamento de memória2 15.8 Senten¸cas para ponteiros, referências e gerenciamento de memória . . . . . . . 15.9 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.10Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

299 299 300 301 302 302 304 305 305 306 306 306 308 308 308 308 308 310 312 313 314

16 M´ etodos Construtores e Destrutores 16.1 Introdu¸caõ aos métodos construtores e destrutores . 16.2 Protótipo para construtores e destrutores . . . . . . 16.3 Construtor default T() . . . . . . . . . . . . . . . . . 16.4 Inicializa¸caõ dos atributos da classe nos contrutores 16.5 Construtor de c´ opia T(const T& obj) . . . . . . . . 16.5.1 Construtor de c´ opia e objetos dinâmicos . . . 16.6 Quando o objeto é constru´ıdo/destru´ıdo . . . . . . . 16.6.1 Ordem de constru¸caõ dos atributos . . . . . . 16.6.2 Ordem de destrui¸caõ dos atributos . . . . . . 16.6.3 Constru¸caõ de objetos globais est´ aticos . . . 16.7 Construtor e ambig¨ uidade . . . . . . . . . . . . . . . 16.8 Construtor e destrutor – conceitos avan¸cados2 . . . . 16.8.1 Construtor e ambig¨ uidade . . . . . . . . . . . 16.8.2 Construtor e interface . . . . . . . . . . . . . 16.9 Senten¸cas para construtores e destrutores . . . . . . 16.10Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . 16.11Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

315 315 316 317 318 319 323 325 326 327 328 329 329 330 331 332 334 335

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . do . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . método a . . . . . . . . . . . . . . . . . . . . . . . .

295 . 295 . 295 . 297

. . . . . . ser . . . . . . . .


. . . . . . . . . . . . . . . . . . a sele¸caõ . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .


´ SUMARIO

10 17 Heran¸ ca 17.1 Protótipo para heran¸ca simples . . . . . . . . . . . . . . 17.2 Como implementar a heran¸ca simples . . . . . . . . . . 17.3 Especificador de heran¸ca . . . . . . . . . . . . . . . . . . 17.4 Diferen¸ca entre heran¸ca p´ ublica e privada . . . . . . . . 17.5 Mudando a visibilidade em heran¸cas com using . . . . . 17.6 Chamando construtores da classe-base explicitamente . 17.7 Redeclara¸caõ de método ou atributo na classe-derivada . 17.8 Senten¸cas para heran¸ca . . . . . . . . . . . . . . . . . . 17.9 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . 17.10Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

337 337 338 339 341 341 342 342 344 345 346

18 Heran¸ ca M´ ultipla 18.1 Protótipo para heran¸ca m´ ultipla . . . . . . . . . . . . . . . . . 18.2 Como implementar a heran¸ca m´ ultipla . . . . . . . . . . . . . . 18.3 Resolvendo ambig¨ uidade em heran¸ca m´ ultipla com using . . . 18.4 Heran¸ca m´ ultipla com base comum . . . . . . . . . . . . . . . . 18.5 Ordem de cria¸caõ e destrui¸caõ dos objetos em heran¸cas . . . . 18.6 Heran¸ca m´ ultipla virtual . . . . . . . . . . . . . . . . . . . . . 18.7 Ordem de cria¸caõ e destrui¸caõ dos objetos em heran¸ca m´ ultipla 18.8 Senten¸cas para heran¸ca m´ ultipla . . . . . . . . . . . . . . . . . 18.9 Exemplo de heran¸ca simples e heran¸ca m´ ultipla . . . . . . . . . 18.10Análise dos erros emitidos pelo compilador2 . . . . . . . . . . . 18.11Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . 18.12Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . virtual . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

347 347 347 349 349 351 352 353 355 357 359 361 361

19 Polimorfismo 19.1 Métodos n˜ ao virtuais . . . . . . . . . . . 19.2 Métodos virtuais . . . . . . . . . . . . . 19.2.1 Senten¸cas para métodos virtuais 19.3 Como implementar o polimorfismo . . . 19.3.1 Senten¸cas para polimorfismo . . 19.4 Métodos virtuais puros . . . . . . . . . 19.5 Métodos virtuais sobrecarregados . . . . 19.6 Exemplo completo com polimorfismo . . 19.7 Resumo do cap´ıtulo . . . . . . . . . . . 19.8 Exerc´ıcios . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

363 363 365 366 367 369 369 369 370 378 379

. . . . . . . .

381 . 381 . 382 . 383 . 383 . 384 . 385 . 386 . 386

20 Friend 20.1 Introdu¸caõ ao conceito de friend . 20.2 Protótipo para friend . . . . . . . 20.3 Classes friend . . . . . . . . . . . 20.4 Métodos friend . . . . . . . . . . 20.5 Fun¸co˜es globais friend . . . . . . 20.6 Senten¸cas para friend . . . . . . . 20.7 Resumo do cap´ıtulo . . . . . . . . 20.8 Exerc´ıcios . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .


. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .


´ SUMARIO

11

21 Sobrecarga de Operador 21.1 Introdu¸caõ ` a sobrecarga de operador . . . . . . . . . . . 21.2 Operadores que podem ser sobrecarregados . . . . . . . 21.3 Protótipo para sobrecarga de operador . . . . . . . . . . 21.4 Sobrecarga de operador como fun¸caõ friend . . . . . . 21.5 Sobrecarga de operador como método membro da classe 21.6 Exemplo prático de sobrecarga de operador . . . . . . . 21.7 Como sobrecarregar ++ e -- . . . . . . . . . . . . . . . . 21.8 Como sobrecarregar new2 . . . . . . . . . . . . . . . . . 21.8.1 Como sobrecarregar new dentro de uma classe2 . 21.9 Senten¸cas para sobrecarga de operador . . . . . . . . . . 21.10Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . 21.11Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

387 387 388 388 389 390 391 396 396 397 398 400 401

22 Entrada e Sa´ıda 22.1 Introdu¸caõ ` a entrada e sa´ıda de dados com C++ 22.1.1 Streams buferizadas . . . . . . . . . . . . 22.2 Biblioteca de entrada e sa´ıda . . . . . . . . . . . 22.3 A classe ios_base . . . . . . . . . . . . . . . . . 22.4 A classe . . . . . . . . . . . . . . . . . 22.5 A classe . . . . . . . . . . . . . . . . . 22.5.1 Senten¸cas para . . . . . . . . . 22.6 A classe . . . . . . . . . . . . . . . . . . . 22.6.1 Senten¸cas para . . . . . . . . . . . 22.7 A classe . . . . . . . . . . . . . . . . . 22.7.1 Senten¸cas para . . . . . . . . . 22.8 A classe . . . . . . . . . . . . . . . . . 22.9 Entrada e sa´ıda – uso avan¸cado . . . . . . . . . . 22.9.1 Como criar e usar um manipulador . . . . 22.9.2 A classe locale2 . . . . . . . . . . . . . . 22.9.3 Usando facets 2 . . . . . . . . . . . . . . . 22.10Senten¸cas para stream . . . . . . . . . . . . . . . 22.11Resumo do cap´ıtulo . . . . . . . . . . . . . . . . 22.12Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

403 403 404 404 405 411 414 415 415 416 417 421 422 423 423 424 427 428 428 429

. . . . . . . . . . . .

431 . 431 . 431 . 436 . 439 . 441 . 441 . 443 . 444 . 444 . 446 . 446 . 447

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

23 Entrada e Sa´ıda com Arquivos de Disco 23.1 Introdu¸caõ ao acesso a disco . . . . . . . . . . . . . . . . . . . . 23.2 A classe . . . . . . . . . . . . . . . . . . . . . . . . . 23.3 Armazenando e lendo objetos . . . . . . . . . . . . . . . . . . . 23.4 Redirecionamento de entrada e sa´ıda . . . . . . . . . . . . . . . 23.5 Entrada e Sa´ıda com Arquivos de Disco - Uso Avan¸cado . . . 23.5.1 Posicionando ponteiros de arquivos2 . . . . . . . . . . . 23.5.2 Acessando a impressora e a sa´ıda auxiliar2 . . . . . . . . 23.5.3 Arquivos de disco bin´ arios2 . . . . . . . . . . . . . . . . 23.5.4 Executando e enviando comandos para outro programa2 23.6 Senten¸cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23.7 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . 23.8 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . .



. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

´ SUMARIO

12 24 A Classe 24.1 Introdu¸caõ às strings . . . . . . . . . . . . . 24.2 Métodos de . . . . . . . . . . . . . 24.2.1 Construtores e destrutor . . . . . . . . 24.2.2 Iteradores . . . . . . . . . . . . . . . . 24.2.3 Manipula¸caõ do tamanho da string . 24.2.4 Operadores de acesso . . . . . . . . . 24.2.5 Atribui¸caõ e concatena¸caõ . . . . . . . 24.2.6 Inser¸caõ, remo¸caõ, substitui¸caõ, c´ opia 24.2.7 Compara¸caõ . . . . . . . . . . . . . . 24.2.8 Substrings . . . . . . . . . . . . . . . . 24.2.9 Pesquisa . . . . . . . . . . . . . . . . . 24.3 Exemplos de uso de . . . . . . . . . 24.4 Senten¸cas para strings de C++ . . . . . . . . 24.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . 24.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

449 449 450 450 451 451 452 452 453 453 454 454 455 459 460 460

25 Convers˜ oes 25.1 Protótipo para convers˜ oes . . . . . . . . . . . . . . . 25.2 Necessidade de convers˜ ao . . . . . . . . . . . . . . . 25.3 Construtor de convers˜ ao . . . . . . . . . . . . . . . . 25.4 Operador de convers˜ ao - cast . . . . . . . . . . . . . 25.5 Convers˜ ao explicita nos construtores com explicit . 25.6 Convers˜ ao est´ atica com static_cast<> . . . . . . . 25.7 Convers˜ ao dinâmica com dynamic_cast<> . . . . . . 25.7.1 dynamic_cast<> e referências . . . . . . . . . 25.8 Convers˜ ao com const_cast<> . . . . . . . . . . . . . 25.9 Convers˜ ao com reinterpret_cast<> . . . . . . . . 25.10Senten¸cas para convers˜ oes . . . . . . . . . . . . . . . 25.11Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . 25.12Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

461 461 462 463 464 465 466 466 468 468 468 469 470 470

26 Exce¸ co ˜es 26.1 Introdu¸caõ às exce¸co˜es . . . . . . . . . . . . . . . . . 26.2 Protótipo para exce¸co˜es . . . . . . . . . . . . . . . . 26.3 Conceitos b´ asicos de exce¸co˜es . . . . . . . . . . . . . 26.3.1 try . . . . . . . . . . . . . . . . . . . . . . . 26.3.2 throw . . . . . . . . . . . . . . . . . . . . . . 26.3.3 catch . . . . . . . . . . . . . . . . . . . . . . 26.4 Exce¸co˜es-padr˜ ao . . . . . . . . . . . . . . . . . . . . 26.5 Seq¨ uencia de execu¸caõ . . . . . . . . . . . . . . . . . 26.5.1 Seq¨ uencia de execu¸caõ sem exce¸caõ . . . . . . 26.5.2 Seq¨ uencia de execu¸caõ com exce¸caõ . . . . . 26.6 Como fica a pilha (heap) . . . . . . . . . . . . . . . . 26.7 Exce¸co˜es n˜ ao tratadas . . . . . . . . . . . . . . . . . 26.8 Exce¸co˜es - Uso avan¸cado . . . . . . . . . . . . . . . . 26.8.1 Exce¸caõ para new2 . . . . . . . . . . . . . . . 26.8.2 Controlando entrada com exce¸co˜es2 . . . . . 26.8.3 Adotando uma pol´ıtica para uso de exce¸co˜es2 26.9 Senten¸cas para exce¸co˜es . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

473 473 474 475 476 476 477 478 478 479 479 479 482 483 483 484 486 486


. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .


´ SUMARIO

13

26.10Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488 26.11Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488 27 Templates ou Gabaritos 27.1 Introdu¸caõ aos templates (gabaritos) . . . . . . . . . . . . . . . . 27.2 Fun¸co˜es templates . . . . . . . . . . . . . . . . . . . . . . . . . . 27.2.1 Protótipo para fun¸co˜es templates . . . . . . . . . . . . . . 27.2.2 Instˆ ancias de fun¸co˜es template e dedu¸caõ de argumentos 27.2.3 Declara¸caõ expl´ıcita de fun¸caõ template . . . . . . . . . . 27.2.4 Resolvendo problemas de convers˜ oes . . . . . . . . . . . . 27.2.5 Sobrecarga de fun¸caõ template . . . . . . . . . . . . . . . 27.2.6 Fun¸caõ template com objeto est´ atico . . . . . . . . . . . 27.3 Classes templates ou tipos paramétricos . . . . . . . . . . . . . . 27.3.1 Protótipo para classes template . . . . . . . . . . . . . . 27.3.2 Regras gerais para classes template . . . . . . . . . . . . . 27.3.3 Argumentos pré-definidos em classes templates . . . . . . 27.4 Senten¸cas para templates . . . . . . . . . . . . . . . . . . . . . . 27.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . 27.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

491 492 492 492 493 494 495 495 496 496 496 497 500 503 505 505

28 Templates - Uso Avan¸ cado 28.1 Fun¸co˜es template uso avan¸cado . . . . . . . . . . . . . . . . 28.1.1 Especializa¸caõ de fun¸co˜es template . . . . . . . . . . 28.1.2 Fun¸co˜es expandidas em tempo de compila¸caõ . . . . . 28.1.3 Usando typename com templates . . . . . . . . . . . . 28.1.4 Mapeando fun¸co˜es template utilizando especializa¸co˜es 28.1.5 Fun¸co˜es template e friend . . . . . . . . . . . . . . . 28.2 Classes template uso avan¸cado . . . . . . . . . . . . . . . . . 28.2.1 Templates dentro de uma classe template . . . . . . . 28.2.2 Especializa¸caõ de classes templates . . . . . . . . . . . 28.2.3 Instanciando fun¸co˜es e classes template2 . . . . . . . . 28.3 Uso de export com templates3 . . . . . . . . . . . . . . . . . 28.4 Senten¸cas para uso avan¸cado de templates . . . . . . . . . . . 28.5 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . 28.6 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

507 507 507 509 510 511 513 513 513 517 518 520 520 522 522

29 Implementando Associa¸ co ˜es em C++ 29.1 Introdu¸caõ ` as associa¸co˜es em C++ . . 29.2 Associa¸caõ sem atributo . . . . . . . . 29.3 Associa¸caõ com atributo . . . . . . . . 29.4 Resumo do cap´ıtulo . . . . . . . . . . 29.5 Exerc´ıcios . . . . . . . . . . . . . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

523 523 523 524 525 525

30 As Classes , e as Fun¸ co ˜es Matem´ aticas de 30.1 Introdu¸caõ ` a biblioteca de C . . . . . . . . . . . . . . . . . . . . 30.1.1 Fun¸coes de . . . . . . . . . . . . . . . . . . . . . . . . . . 30.1.2 Exemplos de uso de . . . . . . . . . . . . . . . . . . . . . 30.2 Introdu¸caõ ` a classe . . . . . . . . . . . . . . . . . . . . . . . . 30.2.1 Métodos de . . . . . . . . . . . . . . . . . . . . . . . . 30.2.2 Exemplo de uso de . . . . . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

527 527 527 529 530 530 532

. . . . .

. . . . .

. . . . .

. . . . .


. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .


´ SUMARIO

14 30.2.3 Resumo da classe fornecida pela biblioteca padr˜ ao 30.3 Introdu¸caõ à classe . . . . . . . . . . . . . . . . . . . . . . 30.3.1 Métodos de . . . . . . . . . . . . . . . . . . . . . 30.3.2 Exemplos de uso da classe . . . . . . . . . . . . . 30.3.3 Exemplo de uso de com 2 . . . . . . . . . 30.4 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.5 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

III

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

Introdu¸c˜ ao a STL

. . . . . . .

532 534 535 535 537 539 539

541

31 Introdu¸ c˜ ao a Biblioteca Padr˜ ao de Gabaritos de C++ - STL 31.1 O que é a STL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.1.1 Caracter´ısticas da STL . . . . . . . . . . . . . . . . . . . . 31.1.2 Componentes da STL . . . . . . . . . . . . . . . . . . . . 31.2 Introdu¸caõ aos containers . . . . . . . . . . . . . . . . . . . . . . 31.2.1 Container’s seq¨ uencias . . . . . . . . . . . . . . . . . . . . 31.2.2 Container’s associativos . . . . . . . . . . . . . . . . . . . 31.2.3 Container’s adaptativos . . . . . . . . . . . . . . . . . . . 31.2.4 Métodos e operadores comuns aos diversos container’s . . 31.2.5 Métodos válidos apenas para os container’s seq¨ uenciais . 31.2.6 Typedef´s comuns aos diversos containers2 . . . . . . . . 31.3 Introdu¸caõ aos iteradores - iterators . . . . . . . . . . . . . . . 31.3.1 Tipos de iteradores . . . . . . . . . . . . . . . . . . . . . . 31.3.2 Opera¸co˜es comuns com iteradores2 . . . . . . . . . . . . . 31.4 Iteradores - Uso avan¸cado2 . . . . . . . . . . . . . . . . . . . . . 31.4.1 Iteradores de inser¸caõ . . . . . . . . . . . . . . . . . . . . 31.5 Senten¸cas para STL e iteradores . . . . . . . . . . . . . . . . . . 31.6 Fun¸caõ predicado . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.7 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . 31.8 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

543 543 544 544 545 545 546 547 547 547 548 549 549 550 552 552 554 555 555 555

32 Os Containers Sequˆ enciais , , 32.1 A classe container . . . . . . . . . . . . . . . 32.1.1 Construtores e destrutor . . . . . . . . . . . . . 32.1.2 Iteradores de . . . . . . . . . . . . . 32.1.3 Referências e acesso . . . . . . . . . . . . . . . 32.1.4 Operadores . . . . . . . . . . . . . . . . . . . . 32.1.5 Capacidade e redimensionamento . . . . . . . . 32.1.6 Inser¸caõ, dele¸caõ e atribui¸caõ . . . . . . . . . . 32.1.7 Operadores sobrecarregados . . . . . . . . . . . 32.1.8 Exemplo de . . . . . . . . . . . . . . 32.1.9 Senten¸cas para . . . . . . . . . . . . 32.2 A classe container . . . . . . . . . . . . . . . . 32.2.1 Construtores e destrutor . . . . . . . . . . . . . 32.2.2 Operadores . . . . . . . . . . . . . . . . . . . . 32.2.3 Referência e acesso . . . . . . . . . . . . . . . . 32.2.4 Inser¸caõ, mistura e ordena¸caõ . . . . . . . . . . 32.2.5 Remo¸caõ e c´ opia u ´ nica . . . . . . . . . . . . . . 32.2.6 Exemplo de . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

557 557 558 559 560 561 561 561 562 562 564 565 565 566 566 566 567 568


. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .


´ SUMARIO 32.2.7 Senten¸cas para . 32.3 A classe container . . 32.3.1 Construtores e destrutor 32.3.2 Exemplo de . . 32.4 Resumo do cap´ıtulo . . . . . . 32.5 Exerc´ıcios . . . . . . . . . . . .

15 . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

571 571 572 572 573 574

33 Os Containers Adaptativos , e 33.1 A classe container . . . . . . . . . . . . . . . . . . . . . . 33.1.1 Métodos de . . . . . . . . . . . . . . . . . . . . . . 33.1.2 A listagem da classe . . . . . . . . . . . . . . . . . 33.1.3 Exemplo de . . . . . . . . . . . . . . . . . . . . . . 33.2 A classe container . . . . . . . . . . . . . . . . . . . . . . 33.2.1 Métodos de . . . . . . . . . . . . . . . . . . . . . . 33.2.2 A listagem da classe . . . . . . . . . . . . . . . . . 33.2.3 Exemplo de . . . . . . . . . . . . . . . . . . . . . . 33.3 A classe container . . . . . . . . . . . . . . . . 33.4 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . 33.5 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

577 577 578 578 579 580 581 581 582 582 583 583

, e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

585 585 585 586 586 586 587 587 587 588 589 589 589 590 590 590 590 591 593 594 594 594

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

597 598 598 598 598 599 600

34 Os Containers Associativos , 34.1 A classe . . . . . . . . . . 34.2 A classe container . . . . . 34.2.1 Contrutores e destrutor . 34.2.2 Trocas . . . . . . . . . . . 34.2.3 Inser¸caõ e dele¸caõ . . . . 34.2.4 Pesquisa e contagem . . . 34.2.5 Operadores . . . . . . . . 34.2.6 Exemplo de . . . . 34.3 A classe container . 34.3.1 Contrutores e destrutor . 34.3.2 Operadores . . . . . . . . 34.4 A classe container . . . . . 34.4.1 Construtores e destrutor . 34.4.2 Operadores . . . . . . . . 34.4.3 Inser¸caõ e dele¸caõ . . . . 34.4.4 Pesquisa e contagem . . . 34.4.5 Exemplo de . . . . 34.4.6 Senten¸cas para . . 34.5 A classe container . 34.6 Resumo do cap´ıtulo . . . . . . . 34.7 Exerc´ıcios . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

35 Programa¸ c˜ ao Gen´ erica 35.1 Introdu¸caõ ` a programa¸caõ genérica . . . . . . . . . . . 35.2 Classifica¸caõ das fun¸co˜es genéricas . . . . . . . . . . . 35.2.1 Classifica¸caõ quanto ` a modifica¸caõ do container 35.2.2 Classifica¸caõ quanto ` a categoria dos iteradores 35.2.3 Classifica¸caõ quanto ` as opera¸co˜es realizadas . . 35.3 Fun¸co˜es genéricas . . . . . . . . . . . . . . . . . . . . . Novatec - Programa¸caõ Orientada a Objeto com C++

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .


´ SUMARIO

16 . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

600 600 601 601 602 602 603 604 604 605 606 606 607 612 612 613

36 Objetos Fun¸ co ˜es da STL 36.1 Introdu¸caõ aos objetos fun¸co˜es da STL . . . . . . . . . . . . . . . . . . . 36.1.1 Fun¸co˜es un´ arias . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.1.2 Fun¸co˜es bin´ arias . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.2 Objetos fun¸co˜es fornecidos pela STL . . . . . . . . . . . . . . . . . . . . 36.2.1 Fun¸co˜es aritméticas . . . . . . . . . . . . . . . . . . . . . . . . . 36.2.2 Fun¸co˜es de compara¸caõ . . . . . . . . . . . . . . . . . . . . . . . 36.2.3 Fun¸co˜es l´ ogicas . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.3 STL - Uso Avan¸cado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.3.1 O adaptador bin2nd() . . . . . . . . . . . . . . . . . . . . . . . . 36.3.2 Os adaptadores not1(),not2() . . . . . . . . . . . . . . . . . . . 36.3.3 Os adaptadores - men_fun(), men_fun_ptr() e men_fun_ref() . 36.3.4 Extendendo a STL - especializa¸caõ para std::swap . . . . . . . 36.4 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.5 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

615 615 615 616 616 616 617 618 629 629 629 629 630 630 631

35.4 35.5 35.6 35.7

IV

35.3.1 Preenchimento . . . . . . . . . . . . . 35.3.2 Compara¸caõ . . . . . . . . . . . . . . 35.3.3 Remo¸caõ . . . . . . . . . . . . . . . . 35.3.4 Troca . . . . . . . . . . . . . . . . . . 35.3.5 Misturar/Mesclar/Inverter . . . . . . . 35.3.6 Pesquisa . . . . . . . . . . . . . . . . . 35.3.7 Ordena¸caõ . . . . . . . . . . . . . . . 35.3.8 Classifica¸caõ . . . . . . . . . . . . . . 35.3.9 Transforma¸caõ . . . . . . . . . . . . . 35.3.10 Matem´ aticos . . . . . . . . . . . . . . 35.3.11 Opera¸co˜es matemáticas com conjuntos 35.3.12 Ordena¸caõ de pilhas - heapsort . . . . Exemplos de uso das fun¸co˜es genéricas . . . . Senten¸cas para c´ odigo genérico . . . . . . . . Resumo do cap´ıtulo . . . . . . . . . . . . . . Exerc´ıcios . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

Apˆ endices

A Diretrizes de Pr´ e-Processador A.1 Fase de pré-processamento . . . . . . . . . A.2 Inclusão de arquivos . . . . . . . . . . . . A.3 Compila¸caõ condicional . . . . . . . . . . A.3.1 #define . . . . . . . . . . . . . . . A.3.2 #ifdef . . . . . . . . . . . . . . . A.3.3 #ifndef . . . . . . . . . . . . . . . A.3.4 #undef . . . . . . . . . . . . . . . A.3.5 #if . . . . . . . . . . . . . . . . . A.3.6 #ifdef...else . . . . . . . . . . . A.3.7 #if...else . . . . . . . . . . . . . A.3.8 #if...#elif...#elif...#endif . A.4 Macros . . . . . . . . . . . . . . . . . . . . A.4.1 Macros pré-definidas . . . . . . . .

637 . . . . . . . . . . . . .

. . . . . . . . . . . . .


. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

639 639 639 640 640 640 641 641 641 642 642 643 643 643


´ SUMARIO A.5 A.6 A.7 A.8

Instru¸co˜es de guarda . . Senten¸cas para diretrizes Resumo do cap´ıtulo . . Exerc´ıcios . . . . . . . .

17 . . . . . . . . . . . de pré-processador . . . . . . . . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

644 645 645 645

´ B Conceitos Uteis Para Programa¸ c˜ ao em C B.1 Especificador de classe de armazenamento - tempo de vida . B.2 Especificador de linkagem . . . . . . . . . . . . . . . . . . . B.2.1 Uso de extern . . . . . . . . . . . . . . . . . . . . . B.3 Modificadores de acesso . . . . . . . . . . . . . . . . . . . . B.4 Escopo das vari´ aveis . . . . . . . . . . . . . . . . . . . . . . B.5 Senten¸cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.6 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . . . B.7 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

647 647 648 649 652 653 654 655 655

C Operadores C.1 Introdu¸caõ aos operadores . . . . . . . . . . . . . . . . . C.1.1 Operadores aritméticos (+,-,*,/,%) . . . . . . . C.1.2 Operadores de atribui¸caõ (=) . . . . . . . . . . . C.1.3 Operadores compostos (+=, -=, *=, /=) . . . . C.1.4 Operadores relacionais (>, >=, <, <=, ==, !=) C.1.5 Operadores l´ ogicos (&&, ||, !, ==, !=) . . . . C.1.6 Operadores de bits (&, |) . . . . . . . . . . . . . C.1.7 Operador condicional (?) . . . . . . . . . . . . . C.1.8 Operador incremento (++) e decremento (--) . . C.1.9 Operador v´ırgula (a,b) . . . . . . . . . . . . . . C.1.10 Operador módulo (%) . . . . . . . . . . . . . . . C.1.11 Operador new . . . . . . . . . . . . . . . . . . . . C.1.12 Operador delete . . . . . . . . . . . . . . . . . . C.1.13 Operador typedef . . . . . . . . . . . . . . . . . C.1.14 Operador sizeof . . . . . . . . . . . . . . . . . C.1.15 Operador size_t . . . . . . . . . . . . . . . . . . C.1.16 Operador de resolu¸caõ de escopo (::) . . . . . . C.2 Senten¸cas para operadores . . . . . . . . . . . . . . . . . C.3 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . . . C.4 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

657 658 658 659 659 659 660 661 662 662 663 663 664 664 664 664 664 664 665 665 665

D Estruturas de Controle D.1 Introdu¸caõ ` as estruturas de controle . . . . . . . . . . . . . . . . . . . . D.2 Estruturas condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . D.2.1 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D.2.2 if.....else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D.2.3 if......else if......else if......else . . . . . . . . . . . D.2.4 switch....case . . . . . . . . . . . . . . . . . . . . . . . . . . . D.2.5 express~ ao_condicional? a¸ c~ ao_verdadeira : a¸ c~ ao_falsa; D.3 Estruturas de repeti¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . . D.3.1 for ( in´ ıcializa¸ c~ ao ; condi¸ c~ ao ; a¸ c~ ao2 ) a¸ c~ ao1; . . . . . D.3.2 while (condi¸ c~ ao) {a¸ c~ ao;}; . . . . . . . . . . . . . . . . . . . . D.3.3 do {a¸ c~ ao} while (condi¸ c~ ao); . . . . . . . . . . . . . . . . . . D.3.4 break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

667 667 668 668 668 669 669 671 671 671 672 673 673


. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .


´ SUMARIO

18 D.3.5 continue . . . . . . . . . . . . D.4 Senten¸cas para estruturas de controle . D.5 Resumo do cap´ıtulo . . . . . . . . . . D.6 Exerc´ıcios . . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

674 675 675 676

E Fun¸ co ˜es - Uso Avan¸ cado E.1 A fun¸caõ main() e a entrada na linha de comando E.2 Processando parˆ ametros de main() com getopt() E.3 Fun¸co˜es recursivas . . . . . . . . . . . . . . . . . . E.4 Uso de elipse ... em fun¸co˜es . . . . . . . . . . . . E.5 Senten¸cas para fun¸co˜es . . . . . . . . . . . . . . . . E.6 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . E.7 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

677 677 678 679 680 681 682 682

F Ponteiros - Uso Avan¸ cado F.1 Opera¸co˜es com ponteiros (+/-) . . F.2 Ponteiro void* . . . . . . . . . . . F.3 Ponteiro para ponteiro . . . . . . . F.4 Convers˜ ao de ponteiros . . . . . . . F.5 Utilizando auto_ptr . . . . . . . . F.6 Ponteiro de fun¸caõ . . . . . . . . . F.7 Ponteiros para métodos e atributos F.8 Ponteiros em hierarquias . . . . . . F.9 Senten¸cas para ponteiros . . . . . . F.10 Resumo do cap´ıtulo . . . . . . . . F.11 Exerc´ıcios . . . . . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

685 685 686 687 688 688 691 692 693 694 695 695

G Estruturas, Uni˜ oes, e Enumera¸ co ˜es G.1 Estruturas - struct . . . . . . . . . . . . . . . . . . G.1.1 Protótipo para declarar e definir estruturas . G.1.2 Estruturas e fun¸co˜es . . . . . . . . . . . . . . G.1.3 Estruturas aninhadas . . . . . . . . . . . . . G.1.4 Senten¸cas para estruturas . . . . . . . . . . . G.2 Uni˜ oes - union . . . . . . . . . . . . . . . . . . . . . G.2.1 Protótipo para declarar e definir uniões . . . G.3 Enumera¸co˜es - enum . . . . . . . . . . . . . . . . . . G.3.1 Protótipo para declarar e definir enumera¸co˜es G.3.2 Senten¸cas para enumera¸co˜es . . . . . . . . . . G.4 Resumo do cap´ıtulo . . . . . . . . . . . . . . . . . . G.5 Exerc´ıcios . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

697 697 697 698 699 699 700 700 701 701 704 705 705

H Vetores e Matrizes - Arrays H.1 Introdu¸caõ aos vetores e matrizes de C . . H.2 Como criar e usar vetores unidimensionais H.3 Como criar e usar matrizes bidimensionais H.4 Exemplo de uso de vetores e matrizes . . H.5 Resumo do cap´ıtulo . . . . . . . . . . . . H.6 Exerc´ıcios . . . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

707 707 707 708 708 713 713

I

. . . .

. . . .

. . . .

. . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . da classe . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

Gloss´ ario


. . . .

. . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . .

. . . . . .

. . . . . . . . . . .

. . . . . .

. . . . . .

715 André Duarte Bueno

´ SUMARIO

19

J Links Para Sites em C++ J.1 Bookmark . . . . . . . . . . . . . . . . . . . . . . . J.2 HOWTO - Como fazer . . . . . . . . . . . . . . . . J.3 Sites UML . . . . . . . . . . . . . . . . . . . . . . J.4 Sites C++ . . . . . . . . . . . . . . . . . . . . . . J.4.1 Ambientes de desenvolvimento . . . . . . . J.4.2 Compiladores . . . . . . . . . . . . . . . . . J.4.3 Exemplos . . . . . . . . . . . . . . . . . . . J.4.4 Tutoriais . . . . . . . . . . . . . . . . . . . J.4.5 FAQ . . . . . . . . . . . . . . . . . . . . . . J.4.6 Usu´ arios avan¸cados de C++ . . . . . . . . J.5 Sites STL - Standart Template Library . . . . . . . J.6 Sites Programa¸caõ multiplataforma (GNU/Linux) J.6.1 Software Livre . . . . . . . . . . . . . . . . J.6.2 Portabilidade . . . . . . . . . . . . . . . . . J.6.3 Software multiplataforma . . . . . . . . . . J.6.4 Auditoria e profiler . . . . . . . . . . . . . . J.6.5 CVS . . . . . . . . . . . . . . . . . . . . . . J.6.6 Documenta¸caõ . . . . . . . . . . . . . . . . J.7 Sites Cluster e Programa¸caõ Paralela . . . . . . . J.8 Sites Bibliotecas . . . . . . . . . . . . . . . . . . . J.8.1 Bibliotecas e ferramentas . . . . . . . . . . J.8.2 Programa¸caõ cient´ıfica . . . . . . . . . . . . J.9 Sites Grupos . . . . . . . . . . . . . . . . . . . . . J.10 Sites Revistas . . . . . . . . . . . . . . . . . . . . . J.11 Livros de C++ . . . . . . . . . . . . . . . . . . . . J.12 Fedora . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

727 727 727 728 729 729 729 730 730 730 730 731 731 731 732 732 732 733 733 733 734 734 735 735 736 736 736

K Arquivos de Cabe¸ calho K.1 Introdu¸caõ aos arquivos de cabe¸calho . . . . . K.2 Entrada e sa´ıda (streams) . . . . . . . . . . . K.3 Strings de C++ . . . . . . . . . . . . . . . . . K.4 STL . . . . . . . . . . . . . . . . . . . . . . . K.4.1 Containers da STL . . . . . . . . . . . K.4.2 Objetos fun¸co˜es e algoritmos genéricos K.4.3 Matem´ aticos, numéricos . . . . . . . . K.5 Tratamento de erro, exce¸co˜es . . . . . . . . . K.6 Utilit´ arios . . . . . . . . . . . . . . . . . . . . K.7 Bibliotecas de C . . . . . . . . . . . . . . . . K.7.1 . . . . . . . . . . . . . . . K.7.2 . . . . . . . . . . . . . . . . K.7.3 . . . . . . . . . . . . . . . . K.7.4 . . . . . . . . . . . . . . . K.7.5 Diversos . . . . . . . . . . . . . . . . K.8 Unix, GNU/Linux . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

737 737 737 738 738 738 739 739 739 739 739 740 741 742 742 743 744

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

L Licen¸ ca P´ ublica Geral GNU 745 L.1 Introdu¸caõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745 L.2 Licen¸ca p´ ublica geral GNU condi¸co˜es para c´ opia, distribui¸caõ e modifica¸caõ . . . 746 L.3 Como aplicar estes termos aos seus novos programas . . . . . . . . . . . . . . . . 750 Novatec - Programa¸caõ Orientada a Objeto com C++


20


´ SUMARIO


Lista de Figuras 1

Por onde come¸car? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

1.1 1.2 1.3

Em (a) programa de reconstru¸caõ tridimensional, em (b) o programa Octave. . . 56 Programa com interface em modo texto e mecanismos de recupera¸caõ. . . . . . . 57 Programas com interface gr´ afica. . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3.1 3.2 3.3 3.4

O processo de abstra¸caõ. . . O que você vê? . . . . . . . Um rel´ oogio e um cachorro. Uma hierarquia de rel´ ogios.

. . . .

70 71 72 75

4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9

Modelos da realidade – a planta de uma casa. . . . . . . . . . . . . . . . . . . . . Relacionamento dos diagramas estruturais da UML. . . . . . . . . . . . . . . . . Relacionamento dos diagramas dinâmicos da UML. . . . . . . . . . . . . . . . . . Elementos da UML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Outros elementos da UML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . O programa dia manipulando uma estrutura UML com representa¸co˜es de classes. A tela do programa Umbrello: Um diagrama de componentes. . . . . . . . . . . . A tela do programa umbrello – um diagrama de classes. . . . . . . . . . . . . . . A tela do programa Visual-Paradigm – um diagrama de caso de uso. . . . . . . .

83 87 88 89 89 94 95 95 96

5.1

Etapas de desenvolvimento de um software e os documentos gerados. . . . . . . . 107

6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 6.10 6.11 6.12 6.13 6.14 6.15 6.16

Diagrama de caso de uso – um caso de uso geral. . . . . . . . . . . . . Diagrama de caso de uso – calcular área fun¸caõ. . . . . . . . . . . . . Diagrama de caso de uso: analisar resultados (uso de generaliza¸caõ). . Diagrama de caso de uso – Analisar várias fun¸co˜es (uso de inclus˜ ao). . Diagrama de caso de uso – entrada de dados errada (uso de extensão). Elabora¸caõ e an´ alise de dom´ınio (adaptado de [Pressman, 2002]). . . . Interface gr´ afica e eventos. . . . . . . . . . . . . . . . . . . . . . . . . . Diagrama de classes – representando classes. . . . . . . . . . . . . . . . Diagrama de classes – representando associa¸co˜es. . . . . . . . . . . . . Diagrama de classes – representando classes de associa¸caõ. . . . . . . . Diagrama de classes – representando agrega¸co˜es. . . . . . . . . . . . . Diagrama de classes – representando heran¸cas. . . . . . . . . . . . . . Classe de interface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diagrama de objetos – representando objetos e instâncias. . . . . . . . Diagrama de seq¨ uência – elementos. . . . . . . . . . . . . . . . . . . . Diagrama de seq¨ uência – montando uma prova. . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

21

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

112 112 113 113 114 116 118 122 124 126 127 128 129 131 135 136

22

LISTA DE FIGURAS 6.17 6.18 6.19 6.20 6.21 6.22 6.23 6.24 6.25 6.26 6.27 6.28 6.29 6.30 6.31 6.32 6.33

Diagrama de seq¨ uência – seq¨ uência para c´ alculo da área de uma fun¸caõ. . . . . Diagrama de comunica¸caõ – montando uma prova. . . . . . . . . . . . . . . . . Diagrama de comunica¸caõ – seq¨ uência para c´ alculo da área de uma fun¸caõ. . . Diagrama de máquina de estado – um aluno. . . . . . . . . . . . . . . . . . . . Diagrama de máquina de estado – estados do objeto simulador. . . . . . . . . . Diagrama de máquina de estado: Estados compostos do objeto simulador. . . . Diagrama de máquina de estado – estados concorrentes do objeto simulador. . Em (a) o prot´ otipo de um diagrama de atividades. Em (b) o diagrama de atividades de um método de binariza¸caõ. . . . . . . . . . . . . . . . . . . . . . . . . Diagrama de atividades – método do Trap´ ezio para c´ alculo da área. . . . . . . Diagrama de atividades – uso de raios de nata¸caõ. . . . . . . . . . . . . . . . . A tela do programa Dev C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . A tela do programa kdevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . A tela do programa qt-designer. . . . . . . . . . . . . . . . . . . . . . . . . . . . Diagrama de componentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diagrama de implanta¸caõ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cart˜ oes CRC: – cClasse, responsabilidade, colabora¸caõ. . . . . . . . . . . . . . Exerc´ıcio – modelagem sistema aeroporto. . . . . . . . . . . . . . . . . . . . . .

. . . . . . .

136 137 138 140 140 140 141

. . . . . . . . . .

144 145 145 154 155 156 159 160 172 179

7.1

Seq¨ uência de montagem de um programa. . . . . . . . . . . . . . . . . . . . . . . 188

8.1 8.2

Diagrama mostrando entrada e sa´ıda de dados em C++. . . . . . . . . . . . . . . 203 Compilando e executando programas no shell. . . . . . . . . . . . . . . . . . . . . 205

9.1

Tipos predefinidos de C++ e suas dimensões (32 bits). . . . . . . . . . . . . . . . 218

12.1 Como ficam os objetos do tipo CTeste e CEndereco na memória. . . . . . . . . . 263 12.2 Como ficam os objetos na mem´ oria quando a classe tem atributos est´ aticos. . . . 265 13.1 A classe CPessoa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 13.2 Como ficam os métodos inline. . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 13.3 A classe CPonto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 15.1 15.2 15.3 15.4

Ilustra¸caõ da cria¸caõ e uso de ponteiros. . . . . . . . Como declarar e usar um ponteiro. . . . . . . . . . . Consumo real de mem´ oria de um vetor de inteiros. . Desperd´ıcio de mem´ oria em fun¸caõ do alinhamento.

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

300 301 309 310

16.1 Por que devemos criar um construtor de c´ opia. . . . . . . . . . . . . . . . . . . . 323 17.1 Heran¸ca simples: CPonto e CCirculo. . . . . . . . . . . . . . . . . . . . . . . . . 338 18.1 18.2 18.3 18.4 18.5 18.6 18.7 18.8 18.9

Heran¸ca m´ ultipla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 Como ficam os objetos b1, b2 e d em uma heran¸ca m´ ultipla. . . . . . . . . . . . . 348 Heran¸ca m´ ultipla com classe base comum. . . . . . . . . . . . . . . . . . . . . . . 350 Como ficam os objetos b0, b1, b2 e d em uma heran¸ca m´ ultipla com base comum.351 Seq¨ uência de constru¸caõ e destrui¸caõ dos objetos em uma heran¸ca. . . . . . . . . 351 Heran¸ca m´ ultipla virtual. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 Como ficam os objetos b0, b1, B2 e d em uma heran¸ca m´ ultipla com base virtual.353 Heran¸ca m´ ultipla normal e virtual. . . . . . . . . . . . . . . . . . . . . . . . . . 354 Hierarquia de classes CPonto, CCirculo, CElipse, CCirculoElipse. . . . . . . . . 357



Lista de Figuras

23

19.1 Ilustra¸caõ do funcionamento da liga¸caõ dinâmica. . . . . . . . . . . . . . . . . . . 366 19.2 Hierarquia CPessoa, CAluno, CFuncionario, CAlunoFuncionario. . . . . . . . . 371 22.1 Diagrama UML da biblioteca de manipula¸caõ de entrada e sa´ıda. . . . . . . . . . 406 23.1 Sa´ıda gerada pelo programa gnuplot. . . . . . . . . . . . . . . . . . . . . . . . . . 445 26.1 Hierarquia de exce¸co˜es-padrao. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479 26.2 Seq¨ uência de execu¸caõ sem exce¸caõ (a) e com exce¸caõ (b). . . . . . . . . . . . . . 480 30.1 Pequena hierarquia de métodos numéricos (solver e integral numérica de fun¸co˜es do tipo polinômios). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540 31.1 31.2 31.3 31.4

Diagrama UML da biblioteca padr˜ ao de C++. . . . . . . . . . . . Container’s seq¨ uenciais - , , . . . . . . . . Container’s associativos - , , , . Exemplos de métodos presentes em alguns containers. . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

544 545 546 549

32.1 32.2 32.3 32.4

Métodos Métodos Métodos Métodos

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

558 560 566 572

disponibilizados para . que retornam iteradores. . . . . . disponibilizados para . . . disponibilizados para . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

33.1 Métodos disponibilizados para . . . . . . . . . . . . . . . . . . . . . . . . 577 33.2 A classe funciona como uma interface de acesso a , ou . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578 33.3 Métodos disponibilizados para . . . . . . . . . . . . . . . . . . . . . . . . 580 34.1 Métodos disponibilizados para . . . . . . . . . . . . . . . . . . . . . . . . . 586 34.2 Métodos disponibilizados para . . . . . . . . . . . . . . . . . . . . . . 588 34.3 Métodos disponibilizados para . . . . . . . . . . . . . . . . . . . . . . . . . 589 H.1 As sa´ıdas do programa de binariza¸caõ. . . . . . . . . . . . . . . . . . . . . . . . . 714



24


Lista de Figuras


Lista de Tabelas 6.1

Exemplo de caso de uso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

7.1 7.2

Diferen¸cas na nomenclatura da POO e de C++. . . . . . . . . . . . . . . . . . . 186 Extensões usuais dos arquivos nas diferentes plataformas. . . . . . . . . . . . . . 188

8.1 8.2 8.3

Palavras chaves do ANSI C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 Conven¸caõ para nomes de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . 199 Exemplos de declara¸co˜es e defini¸co˜es. . . . . . . . . . . . . . . . . . . . . . . . . . 200

9.1

Tipos predefinidos e intervalos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

17.1 Acesso herdado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340 19.1 Métodos com liga¸caõ est´ atica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 19.2 Métodos com liga¸caõ dinˆ amica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 21.1 Operadores que podem ser sobrecarregados. . . . . . . . . . . . . . . . . . . . . . 388 22.1 22.2 22.3 22.4

Flags para o método setf(). . . . . . . . . . . . . . Manipuladores da classe . . . . . . . . . . Caracteres de escape. . . . . . . . . . . . . . . . . . . Informa¸co˜es fornecidas pelo método locale.name().

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

407 412 414 425

23.1 Modos de abertura do método open(). . . . . . . . . . . . . . . . . . . . . . . . . 432 23.2 Modos de prote¸caõ do método open() (atributos de arquivo). . . . . . . . . . . . 432 23.3 Manipuladores seekdir para os métodos seekp() e seekg(). . . . . . . . . . . . . 433 31.1 Métodos e operadores comuns a todos os containers. . . . . . . . . . . . . . . . . 548 31.2 Iteradores e métodos dos containers sequenciais. . . . . . . . . . . . . . . . . . . 550 31.3 Typedef´s comuns aos diversos containers. . . . . . . . . . . . . . . . . . . . . . . 551 C.1 Precedência dos operadores.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658

F.1 Convers˜ ao de ponteiros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688

25

26


Lista de Programas


Listings 1 Exemplo de uma listagem (Listing). . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–00/List–1–ExemploDeListing.out . . . . . . . . . . . . . . . . . . . 7.1 Exemplo b´ asico: Arquivo de cabe¸calho da classe. . . . . . . . . . . . . . . . . . 7.2 Exemplo b´ asico: Arquivo de implementa¸caõ da classe. . . . . . . . . . . . . . . 7.3 Exemplo b´ asico: Arquivo de implementa¸caõ da fun¸caõ main(). . . . . . . . . . ../listagens/Cap–07/Programa.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1 Usando sa´ıda para tela, nova linha, tabula¸caõ e beep. . . . . . . . . . . . . . . . ../listagens/Cap–08/novaLinha–tab–beep.out . . . . . . . . . . . . . . . . . . . . . . 8.2 Declara¸caõ de objetos e uso de cin e cout. . . . . . . . . . . . . . . . . . . . . 8.3 Usando diretrizes de pré-processador: #ifdef. . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/UsandoDiretrizesDePre–Processador–ifdef.out . . . . . . . . . . 8.4 Usando for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/UsandoFor.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5 Usando for encadeado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/UsandoForFor.out . . . . . . . . . . . . . . . . . . . . . . . . . . 8.6 Usando while: Calculando a potência. . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/UsandoWhile.out . . . . . . . . . . . . . . . . . . . . . . . . . . 8.7 Usando os operadores de compara¸caõ, incremento, decremento, e os operadores compostos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/UsandoOperadoresDeComparacao.out . . . . . . . . . . . . . . . 8.8 Fun¸caõ cubo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/funcao.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.9 Fun¸caõ com void. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/funcao–retorno–void.out . . . . . . . . . . . . . . . . . . . . . . 8.10 Fun¸caõ em linha: volume esfera. . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/funcao–parametro–const.out . . . . . . . . . . . . . . . . . . . . 8.11 Exemplo de uso da biblioteca . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–08/funcao–randomico.out . . . . . . . . . . . . . . . . . . . . . . . . 9.1 Usando os tipos pré-definidos de C++. . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–09/UsandoOsTiposPre–Definidos.out . . . . . . . . . . . . . . . . . 9.2 Diferen¸cas no uso de inteiro com sinal (signed) e sem sinal (unsigned). . . . . ../listagens/Cap–09/signed–unsigned.out . . . . . . . . . . . . . . . . . . . . . . . . . 9.3 Verificando os limites dos tipos pré-definidos de C++. . . . . . . . . . . . . . . ../listagens/Cap–09/LimitesDosTiposPre–Definidos–32.out . . . . . . . . . . . . . . 9.4 Usando struct. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–09/Struct.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.5 Usando union. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–09/Union.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

. . . . . . . . . . . . . . . . .

45 45 190 191 192 192 202 203 204 206 206 207 207 207 207 208 208

. . . . . . . . . . . . . . . . . . . .

209 210 210 211 211 211 212 212 212 213 218 219 220 221 222 222 226 227 228 228

28

Lista de Programas 9.6 Exemplo preliminar de defini¸caõ de classe do usuário. . . . . . . . . . . . . . . . 229 ../listagens/Cap–09/Complex.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 9.7 Exemplo preliminar de uso da classe de C++. . . . . . . . . . . . . . . 232 ../listagens/Cap–09/String.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 9.8 Exemplo preliminar de uso da classe da biblioteca STL. . . . . . . . . 234 ../listagens/Cap–09/vector–1.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 9.9 Usando sizeof(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 ../listagens/Cap–09/sizeof.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 9.10 Usando typeid(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 ../listagens/Cap–09/typeid.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 10.1 Definindo e usando um namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . 245 ../listagens/Cap–10/namespace.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 10.2 Usando using para colocar fun¸co˜es no mesmo escopo. . . . . . . . . . . . . . . . 246 ../listagens/Cap–10/using.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 10.3 Usando vari´ aveis est´ aticas em um namespace. . . . . . . . . . . . . . . . . . . . . 248 ../listagens/Cap–10/namespace–e–static.out . . . . . . . . . . . . . . . . . . . . . . . . 249 12.1 Usando atributos de objeto em uma classe. . . . . . . . . . . . . . . . . . . . . . 262 ../listagens/Cap–12/UsandoAtributosDeObjeto.out . . . . . . . . . . . . . . . . . . . . 263 13.1 Passando parˆ ametros por valor, referência e ponteiro. . . . . . . . . . . . . . . . . 276 ../listagens/Cap–13/PassandoParametrosPorValorReferenciaPonteiro.out . . . . . . . 277 13.2 Classe com atributo e método normal. . . . . . . . . . . . . . . . . . . . . . . . . 279 ../listagens/Cap–13/class–atributo–metodo–normal.out . . . . . . . . . . . . . . . . . 280 13.3 Classe com método const. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 ../listagens/Cap–13/class–atributo–metodo–const.out . . . . . . . . . . . . . . . . . . 283 13.4 Classe com atributo e método est´ atico. . . . . . . . . . . . . . . . . . . . . . . . . 284 ../listagens/Cap–13/class–atributo–metodo–static.out . . . . . . . . . . . . . . . . . . 286 13.5 A classe CPonto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 13.6 Implementa¸caõ da classe CPonto. . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 13.7 Usando métodos e atributos de uma classe. . . . . . . . . . . . . . . . . . . . . . 289 ../listagens/Cap–13/ProgCPonto.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 15.1 Usando ponteiros para criar e usar objetos dinâmicos. . . . . . . . . . . . . . . . 303 ../listagens/Cap–15/ProgCPontoDinamico.out . . . . . . . . . . . . . . . . . . . . . . 303 15.2 Usando referências. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 ../listagens/Cap–15/referencia.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 15.3 Entendendo o alinhamento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 ../listagens/Cap–15/sizeof–e–alinhamento.out . . . . . . . . . . . . . . . . . . . . . . . 309 16.1 Usando construtor default e de c´ opia. . . . . . . . . . . . . . . . . . . . . . . . . 320 ../listagens/Cap–16/class–construtor–copia.out . . . . . . . . . . . . . . . . . . . . . . 322 16.2 Problemas com a falta do construtor de c´ opia em objetos com atributos dinâmicos.324 ../listagens/Cap–16/ObjDinamico.out . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 16.3 Ordem de constru¸caõ dos atributos de um objeto. . . . . . . . . . . . . . . . . . . 327 ../listagens/Cap–16/OrdemConstrucao.out . . . . . . . . . . . . . . . . . . . . . . . . 327 16.4 Objetos est´ aticos globais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328 ../listagens/Cap–16/ObjEstatico.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 16.5 Erro ao definir o construtor default e um construtor sobrecarregado com inicializadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 ../listagens/Cap–16/construtor–ambiguidade.out . . . . . . . . . . . . . . . . . . . . . 329 16.6 Construindo objetos ou declarando fun¸co˜es? . . . . . . . . . . . . . . . . . . . . . 330 ../listagens/Cap–16/DeclaracaoEConstrucao–Ambiguidade.out . . . . . . . . . . . . . 331



Lista de Programas

29

16.7 Construtor e interface: erro na passagem de parˆ ametros. . . . . . . . 16.8 Construtor e interface: erro na passagem de parˆ ametros corrigidos. . 17.1 A classe CCirculo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.2 Implementa¸caõ da classe CCirculo. . . . . . . . . . . . . . . . . . . . 17.3 Usando especificador de acesso e de heran¸ca. . . . . . . . . . . . . . ../listagens/Cap–17/especificador–heranca.out . . . . . . . . . . . . . . . . 17.4 Usando using em heran¸cas. . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–17/UsandoUsingEmHerancas.out . . . . . . . . . . . . . 17.5 Redeclara¸caõ de método ou atributo na classe-derivada. . . . . . . . ../listagens/Cap–17/herancaERedeclaracao.out . . . . . . . . . . . . . . . 18.1 Seq¨ uência de constru¸caõ e destrui¸caõ em heran¸ca m´ ultipla virtual. ../listagens/Cap–18/herancaMultiplaVirtual.out . . . . . . . . . . . . . . 18.2 A classe CElipse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.3 Implementa¸caõ da classe CElipse. . . . . . . . . . . . . . . . . . . . 18.4 Usando as classes CPonto, CCirculo e CElipse. . . . . . . . . . . . . ../listagens/Cap–18/UsandoCPontoCCirculoCElipse.out . . . . . . . . . . 18.5 A classe CCirculoElipse. . . . . . . . . . . . . . . . . . . . . . . . . 18.6 Implementa¸caõ da classe CCirculoElipse. . . . . . . . . . . . . . . . ../listagens/Cap–18/CCirculoElipse.out . . . . . . . . . . . . . . . . . . . 19.1 Exemplo de uso do polimorfismo. . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–19/Polimorfismo.out . . . . . . . . . . . . . . . . . . . . 19.2 A classe CPessoa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.3 Implementa¸caõ da classe CPessoa. . . . . . . . . . . . . . . . . . . . 19.4 A classe CAluno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.5 Implementa¸caõ da classe CAluno. . . . . . . . . . . . . . . . . . . . . 19.6 A classe CFuncionario. . . . . . . . . . . . . . . . . . . . . . . . . . 19.7 Implementa¸caõ da classe CFuncionario. . . . . . . . . . . . . . . . . 19.8 A classe CAlunoFuncionario. . . . . . . . . . . . . . . . . . . . . . . 19.9 Implementa¸caõ da classe CAlunoFuncionario. . . . . . . . . . . . . 19.10Testando a heran¸ca m´ ultipla. . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–19/Heranca–Multipla–a.out . . . . . . . . . . . . . . . . 20.1 Usando classes friend. . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–20/classes–friend.out . . . . . . . . . . . . . . . . . . . . 20.2 Usando métodos friend. . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–20/metodo–friend.out . . . . . . . . . . . . . . . . . . . . 20.3 Usando fun¸co˜es globais friend. . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–20/funcaoGlobal–friend.out . . . . . . . . . . . . . . . . 21.1 A classe CPonto com sobrecarga de operador. . . . . . . . . . . . . . 21.2 Implementa¸caõ da classe CPonto com sobrecarga de operador. . . . . 21.3 Usando a sobrecarga de operador. . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–21/TesteCPontoComSobrecarga.out . . . . . . . . . . . . 21.4 Sobrecarregando new em uma classe. . . . . . . . . . . . . . . . . . . ../listagens/Cap–21/sobrecarregando–new.out . . . . . . . . . . . . . . . . 22.1 Formata¸caõ b´ asica da sa´ıda de dados. . . . . . . . . . . . . . . . . . ../listagens/Cap–22/FormatacaoBasicaDaSaidaDeDados.out . . . . . . . . 22.2 Formata¸caõ da sa´ıda de dados usando o método setf(). . . . . . . . ../listagens/Cap–22/Usando–setf.out . . . . . . . . . . . . . . . . . . . . . 22.3 Formata¸caõ da sa´ıda de dados usando a classe . . . . . . . ../listagens/Cap–22/Usando–iomanip.out . . . . . . . . . . . . . . . . . . Novatec - Programa¸caõ Orientada a Objeto com C++

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

331 331 338 339 340 341 341 342 343 344 354 355 357 358 358 359 359 360 360 368 368 371 371 372 373 374 374 375 375 376 377 383 383 384 384 384 385 391 392 394 395 397 398 408 409 410 411 412 413


30

Lista de Programas 22.4 Contando n´ umero de linhas, palavras e caracteres. . . . . . . . . . . . . . . . . ../listagens/Cap–22/ContandoNumeroLinhasPalavrasCaracteres.out . . . . . . . . . 22.5 Controle de entrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–22/controleEntrada.out . . . . . . . . . . . . . . . . . . . . . . . . . 22.6 Usando sstream (ostringstream e istringstream). . . . . . . . . . . . . . . . ../listagens/Cap–22/Usando–sstrean.out . . . . . . . . . . . . . . . . . . . . . . . . . 22.7 Usando a classe locale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–22/UsandoLocale.out . . . . . . . . . . . . . . . . . . . . . . . . . . 22.8 Usando facets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–22/UsandoFacets.out . . . . . . . . . . . . . . . . . . . . . . . . . . 23.1 Uso de stream de disco (ifstream e ofstream). . . . . . . . . . . . . . . . . . ../listagens/Cap–23/Usando–fstream.out . . . . . . . . . . . . . . . . . . . . . . . . . 23.2 Lendo um arquivo com dados e coment´ arios. . . . . . . . . . . . . . . . . . . . ../listagens/Cap–23/Usando–fstream–com–comentario.out . . . . . . . . . . . . . . . 23.3 Leitura e grava¸caõ de objetos simples usando read() e write(). . . . . . . . . ../listagens/Cap–23/LeituraGravacaoDeObjetos.out . . . . . . . . . . . . . . . . . . 23.4 Usando redirecionamento de arquivo. . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–23/Usando–Redirecionamento.out . . . . . . . . . . . . . . . . . . . 23.5 Usando read(), write() e seekg(). . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–23/Usando–seekg–seekp.out . . . . . . . . . . . . . . . . . . . . . . 23.6 Executando e enviando comandos para um outro programa (com ). ../listagens/Cap–23/Usando–pstream.out . . . . . . . . . . . . . . . . . . . . . . . . 24.1 Usando a classe de C++. . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–24/Usando–string.out . . . . . . . . . . . . . . . . . . . . . . . . . . 24.2 Usando os métodos de pesquisa da classe string de C++. . . . . . . . . . . . . ../listagens/Cap–24/Usando–string–pesquisa.out . . . . . . . . . . . . . . . . . . . . 24.3 Usando as classes e sstream para executar comandos do shell. . . . . ../listagens/Cap–24/interfaceShell.out . . . . . . . . . . . . . . . . . . . . . . . . . . 25.1 Mostrando a necessidade de convers˜ oes. . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–25/necessidadeConversao.out . . . . . . . . . . . . . . . . . . . . . 25.2 Usando construtor com explicit. . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–25/Usando–explicit.out . . . . . . . . . . . . . . . . . . . . . . . . . 25.3 Usando dynamic_cast e typeid. . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–25/Usando–dynamic–cast.out . . . . . . . . . . . . . . . . . . . . . 26.1 Exce¸co˜es: Divis˜ ao por zero. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–26/DivisaoPorZero.out . . . . . . . . . . . . . . . . . . . . . . . . . 26.2 Exce¸co˜es: Divis˜ ao por zero com controle simples. . . . . . . . . . . . . . . . . . ../listagens/Cap–26/DivisaoPorZero–ComControleSimples.out . . . . . . . . . . . . . 26.3 Exce¸co˜es: Divis˜ ao por zero com exce¸co˜es. . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–26/DivisaoPorZero–ComExcecoes.out . . . . . . . . . . . . . . . . . 26.4 Exce¸co˜es e desempilhamento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–26/Excecoes–Desempilhamento.out . . . . . . . . . . . . . . . . . . 26.5 Usando set_unexpected() e set_terminate(). . . . . . . . . . . . . . . . . . ../listagens/Cap–26/TesteListaExcecoes.out . . . . . . . . . . . . . . . . . . . . . . . 26.6 Exce¸caõ para new. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–26/Excecoes–new.out . . . . . . . . . . . . . . . . . . . . . . . . . . 26.7 Usando exce¸co˜es para controle de entrada e sa´ıda. . . . . . . . . . . . . . . . . ../listagens/Cap–26/Excecoes–ControleEntradaSaida.out . . . . . . . . . . . . . . . . 27.1 Defini¸caõ de classe template com argumentos pré-definidos . . . . . . . . . . .


. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

419 420 420 421 423 423 425 426 427 427 434 435 435 436 437 438 440 441 442 443 445 446 455 457 457 458 458 459 462 463 465 465 467 468 473 473 474 474 475 476 481 481 482 483 483 484 484 485 500


Lista de Programas

31

27.2 Defini¸caõ dos métodos da classe template com argumentos pré-definidos. 27.3 Usando a classe template com argumentos pré-definidos. . . . . . . . . . ../listagens/Cap–27/Usando–ClasseTemplateComArgumentosPre–Definidos.out 28.1 Exemplo de fun¸caõ expandida em tempo de compila¸caõ. . . . . . . . . . . ../listagens/Cap–28/FuncaoExpandidaEmTempoDeCompilacao.out . . . . . . . 28.2 Fun¸caõ potência expandida em tempo de compila¸caõ. . . . . . . . . . . . ../listagens/Cap–28/FuncaoExpandidaEmTempoDeCompilacao–potencia.out . 28.3 Exemplo de mapeamento de tipo com templates. . . . . . . . . . . . . . . ../listagens/Cap–28/MapeamentoDeTipo.out . . . . . . . . . . . . . . . . . . . 28.4 Problema na chamada a métodos template. . . . . . . . . . . . . . . . . . ../listagens/Cap–28/ProblemaNaChamadaAMetodosTemplate.out . . . . . . . ../listagens/Cap–28/TemplatesComErro.out . . . . . . . . . . . . . . . . . . . . 28.5 Defini¸caõ de classe template com template adicional. . . . . . . . . . . . 28.6 Implementa¸caõ dos métodos da classe template com template adicional. 28.7 Uso de classe template com template adicional. . . . . . . . . . . . . . . ../listagens/Cap–28/Usando–TemplateComTemplateAdicional.out . . . . . . . 28.8 Exemplo: Instanciando fun¸co˜es e classes template. . . . . . . . . . . . . . ../listagens/Cap–27/InstanciandoFuncoesEClassesTemplate.out . . . . . . . . . 29.1 Associa¸caõ com atributo de liga¸caõ. . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–29/associacoes.out . . . . . . . . . . . . . . . . . . . . . . . . 30.1 Usando fun¸co˜es matemáticas de . . . . . . . . . . . . . . . . . . . ../listagens/Cap–30/Usando–cmath.out . . . . . . . . . . . . . . . . . . . . . . 30.2 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–30/UsandoComplex.out . . . . . . . . . . . . . . . . . . . . . . 30.3 A classe da biblioteca padr˜ ao. . . . . . . . . . . . . . . . . . . 30.4 Exemplo descritivo da classe . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–30/ExemploDescritivoDaClassebitset.out . . . . . . . . . . . . 30.5 Usando com , criando uma matriz de bits. . . . . . . . ../listagens/Cap–30/Usando–bitset–vector.out . . . . . . . . . . . . . . . . . . . 31.1 Usando insert_iterator e fun¸caõ predicado. . . . . . . . . . . . . . . . . ../listagens/Cap–31/insertIterator.out . . . . . . . . . . . . . . . . . . . . . . . 32.1 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–32/Usando–vector.out . . . . . . . . . . . . . . . . . . . . . . 32.2 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–32/Usando–list.out . . . . . . . . . . . . . . . . . . . . . . . . 32.3 Usando com as fun¸co˜es genéricas (algoritmos genéricos). . . . . . ../listagens/Cap–32/Usando–list–2.out . . . . . . . . . . . . . . . . . . . . . . . 32.4 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–32/Usando–deque.out . . . . . . . . . . . . . . . . . . . . . . . 33.1 A classe container . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.2 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–33/Usando–stack.out . . . . . . . . . . . . . . . . . . . . . . . 33.3 A classe container . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.4 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–33/Usando–queue.out . . . . . . . . . . . . . . . . . . . . . . . 34.1 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–34/Usando–set.out . . . . . . . . . . . . . . . . . . . . . . . . 34.2 Usando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–34/Usando–map.out . . . . . . . . . . . . . . . . . . . . . . . Novatec - Programa¸caõ Orientada a Objeto com C++

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

501 501 502 509 509 509 510 512 513 513 514 514 514 515 516 516 518 519 524 525 529 529 532 532 533 535 537 537 538 553 554 563 563 568 569 569 571 573 573 578 579 580 581 582 582 587 588 591 593


32

Lista de Programas 35.1 Usando sort(), find(), find_if(), fill(). . . . . . . . . . . . . . . . . . . . ../listagens/Cap–35/Usando–sort–find–find if–fill.out . . . . . . . . . . . . . . . . . . 35.2 Usando sort() e copy() para ordenar linhas de texto. . . . . . . . . . . . . . . ../listagens/Cap–35/ordenandoTexto.out . . . . . . . . . . . . . . . . . . . . . . . . . 35.3 Usando copy() para copiar dados de um arquivo de disco para um . . ../listagens/Cap–35/dadosParaVector.out . . . . . . . . . . . . . . . . . . . . . . . . 35.4 Usando com algoritmos genéricos: Cálculo da mediana. . . . . . . . . ../listagens/Cap–35/CalculoMediana.out . . . . . . . . . . . . . . . . . . . . . . . . . 35.5 Usando generator_n() para gerar uma série de dados. . . . . . . . . . . . . . ../listagens/Cap–35/TCSeries.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.1 Usando divides<>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–36/divides.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.2 Usando multiplies<>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–36/multiplies.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36.3 Criando e usando uma classe fun¸caõ. . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Cap–36/CriandoEUsandoClasse–funcao.out . . . . . . . . . . . . . . . . 36.4 Usando fun¸co˜es genéricas e objetos da STL. . . . . . . . . . . . . . . . . . . . . A.1 Pré-processamento: Usando #ifdef..else. . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–A/if–else.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.2 Pré-processamento: Usando #if..else. . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–A/if–else3.out . . . . . . . . . . . . . . . . . . . . . . . . . . . A.3 Pré-processamento: Usando macros pré-definidas. . . . . . . . . . . . . . . . . . ../listagens/Apendice–A/Macros.out . . . . . . . . . . . . . . . . . . . . . . . . . . . B.1 Classe Autixliar Cteste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.2 Fun¸caõ e escopo A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.3 Fun¸caõ e escopo B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–B/escopo–a.out . . . . . . . . . . . . . . . . . . . . . . . . . . B.4 Usando modificadores de acesso. . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–B/const.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . C.1 Usando os operadores de compara¸caõ, incremento, decremento, e os operadores compostos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–C/comparacao.out . . . . . . . . . . . . . . . . . . . . . . . . C.2 Usando os operadores l´ ogicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . C.3 Usando os operadores de bits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–C/RepresentandoInteirosCom–bits.out . . . . . . . . . . . . . C.4 Usando operador de incremento. . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–C/incremento.out . . . . . . . . . . . . . . . . . . . . . . . . . C.5 Usando operador módulo % e operador tern´ ario ? . . . . . . . . . . . . . . . . . ../listagens/Apendice–C/while3.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . D.1 Usando switch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–D/switch.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . D.2 Usando while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–D/while2.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . D.3 Usando do..while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–D/do–while.out . . . . . . . . . . . . . . . . . . . . . . . . . . D.4 Usando break, continue, do..while, e switch. . . . . . . . . . . . . . . . . . ../listagens/Apendice–D/break–e–continue.out . . . . . . . . . . . . . . . . . . . . . E.1 Fun¸caõ main() e a entrada na linha de comando. . . . . . . . . . . . . . . . . . ../listagens/Apendice–E/entradalinhacomando.out . . . . . . . . . . . . . . . . . . .


. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

607 608 609 609 610 610 610 611 611 612 617 617 617 617 618 619 620 642 642 642 643 644 644 650 650 651 651 652 652

. . . . . . . . . . . . . . . . . . .

659 660 661 661 662 662 663 664 664 670 670 672 673 673 673 674 675 677 678


Lista de Programas

33

E.2 Processando parˆ ametros de main() com getopt(). . . . . . . . . . . . . . . . . ../listagens/Apendice–E/main–getopt.out . . . . . . . . . . . . . . . . . . . . . . . . E.3 Fun¸caõ recursiva: c´ alculo do fatorial. . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–E/funcao–recursiva.out . . . . . . . . . . . . . . . . . . . . . . E.4 Usando elipses (...) : fun¸caõ média. . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–E/UsoDeElipse.out . . . . . . . . . . . . . . . . . . . . . . . . F.1 Ponteiro de ponteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–F/ponteiro–de–ponteiro.out . . . . . . . . . . . . . . . . . . . F.2 Comparando o uso de vetores est´ aticos de C, dinâmicos de C++, com auto_ptr de C++ e da stl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–F/auto–ptr.out . . . . . . . . . . . . . . . . . . . . . . . . . . F.3 Usando ponteiro de fun¸caõ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–F/ponteiroDeFuncao.out . . . . . . . . . . . . . . . . . . . . . F.4 Ponteiro para métodos da classe. . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–F/PonteiroParaMetodo.out . . . . . . . . . . . . . . . . . . . . F.5 Ponteiro em hierarquias e offset. . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–F/offset.out . . . . . . . . . . . . . . . . . . . . . . . . . . . . F.6 Usando operador de endere¸co (&) e sizeof(). . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–F/endereco–sizeof.out . . . . . . . . . . . . . . . . . . . . . . . G.1 Usando estruturas aninhadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–G/EstruturasAninhadas.out . . . . . . . . . . . . . . . . . . . G.2 Usando enumera¸co˜es: Um calend´ ario. . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–G/Enumeracoes–dia.out . . . . . . . . . . . . . . . . . . . . . G.3 Usando enumera¸caõ anonima. . . . . . . . . . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–G/enumeracaoanonima.out . . . . . . . . . . . . . . . . . . . . ../listagens/Apendice–H/Formatos–PBM–PGM . . . . . . . . . . . . . . . . . . . . . H.1 Usando arrays: Um programa de binariza¸caõ. . . . . . . . . . . . . . . . . . . . Lista de programas


. . . . . . . .

678 679 680 680 681 681 687 687

. . . . . . . . . . . . . . . . . .

689 690 691 691 692 693 693 693 694 694 699 699 702 703 703 704 709 709


34


Pref´ acio


Agradecimentos Gostaria de agradecer aos amigos e companheiros que em algum momento e de alguma forma contribu´ıram para o desenvolvimento deste livro. Do LENEP - Laborat´ orio de Engenharia e Explora¸c˜ ao de Petr´ oleo da UENF - Universidade Estadual do Norte Fluminense Darcy Ribeiro, Antonio A. G. Carrasquilla, Viatcheslav Priimenko (Slava), George Mitrofanov, Luiz O. E. dos Santos, Pavel Bedrikovetsky, Themis Carageorgos, Adolfo Puime, Severiano Ribeiro, Jorge Triguis, Marilia Barbosa, Victor Hugo, Eliane Souza, Roseane Miss´ agea, Geraldo Loures, Sérgio Oliveira, Carlos Dias, Fernando Moraes, Bena Rodrigues, Alexandre Servulo, Luciano Botelho, Marcos Pinheiro, Pedro Mesquita, Cristofer, Debora Mendon¸ca, Eliézer Freire, Sidna Abreu, Ana Pacheco, Kenedy Tavares, Verlaine Pereira, Remilson Rosa, e Marco Ceia. Da UFSC - Universidade Federal de Santa Catarina, Paulo C. Philippi, Roberto Lamberts, José A. B. da Cunha Neto, Celso Fernandes, Saulo Guths, Vicente Nicolau, Amir de Oliveira, Fabiano Wolf, Lu´ıs Hegele, Paulo Facin, Rodrigo Surmas, Carlos Ortiz, Carlos Paghi, Diego Silva, Geziel de Oliveira, Henrique de Gaspari, Jaison Meiss e Rodrigo Hoffmann. Da PUC, Nathan Mendes, Luis Moura. Da UFRN, Adriano Santos, Aldomar Pedrini. Da UPFE, F´ abio Magnani. Da UEZO, Vania Estrela, Alfredo Boente, Rosana Pinheiro. Da ANP, Sérgio Almeida (Biotita). Da ESSS, Marcos Damiani, Clovis Maliska. E os amigos extrangeiros, Jean F. Daian, Liang Zhirong. Aos alunos das disciplinas de ”Programa¸c˜ ao Orientada a Objeto com C++”, ”Programa¸c˜ ao Pr´ atica”, ”Software Livre” e ”An´ alise de Imagens Aplicada”, pelas constantes sugest˜ oes apresentadas. Ao pessoal da Revista do Linux, que publicou no CD dessa publica¸c˜ ao, edi¸c˜ ao 33, a ”Apostila de Programa¸c˜ ao Orientada a Objeto com C++”, um embri˜ ao da primeira edi¸c˜ ao. Ao Rubens Prates, editor da Novatec, e sua equipe Marcelo Ferreira Paiva e Patrizia Zagni. Aos desenvolvedores do GNU/Linux a idéia do software livre. Ao GUFSC, o grupo de usu´ arios de software livre da UFSC. Em especial ao Ricardo, que me enviou uma lista de termos sobre software livre. Quero fazer um agradecimento especial a este pessoal maravilhoso que tive a oportunidade de conhecer em eventos como a Conferência Internacional de Software Livre, o CONISLI, o LATINOWARE e em pequenos eventos de divulga¸c˜ ao do software livre, e que tem defendido e lutado pelo software livre no Brasil: Cesar Brod, Rubens Queiros, Sulamita Garcia, Isabel Valverde, Timoty Ney, John Maddog Hall, Lucas Santos, Rafael Peregrino, Sérgio Amadeo, Rogério Santana, Julio Cezar Neves, Augusto Campos, Pablo Dall’Oglio, Piter Punk, Walter Pinheiro, Djalma Valois. A PETROBRAS, Guilherme Castro, Farid S. Schecaira, José Ten´ orio, pelo constante apoio as atividades de pesquisa desenvolvidas no setor de geo-inform´ atica do LENEP (LDSC). Nos u ´ ltimos anos adquirimos dezenas de livros e equipamentos computacionais com recursos de projetos de pesquisa apoiados pela PETROBRAS, FAPERJ, FENORTE e CNPq. As pessoas que ajudaram na revis˜ ao desta segunda edi¸c˜ ao, Tiago Schaewer, Tiago Calimman, Irineu Silva, Allan Galante, Giovanni Colonese, Tiago Camara, Tayne Martins, Vitor Seraphim. Ao meu amigo de infˆ ancia, Luiz Alberto Alano. Aos meus sobrinhos e sobrinhas, Alessandra, Andréa, Adroaldo, Alissa, Patricia, Angela, Isabel, Ana Paula, Gabriel, Beatriz, Manoela e Gustavo, que representam o futuro. Finalmente, gostaria de dedicar esta segunda edi¸c˜ ao ` a minha esposa F´ atima e minhas filhas J´ ulia e Sofia. No momento em que escrevo esta dedicat´ oria estou ausente. Pe¸co a J´ ulia e Sofia desculpas pela minha ausência, na sua infˆ ancia, quando fazia doutorado, e na sua adolescência, entre 13 e 16 anos quando fazia, nos fins de semana e a noite, esta segunda edi¸c˜ ao.

35

36


Pref´ acio


Pref´ acio da Segunda Edi¸ c˜ ao S˜ ao muitas e constantes as inova¸co˜es no mundo da inform´ atica, quando do lan¸camento da primeira edi¸caõ algumas tecnologias ainda estavam amadurecendo; como a UML, a STL, o cvs, a programa¸caõ com software livre. Atualmente a UML est´ a na sua vers˜ ao 2, a STL é bastante conhecida e utilizada, o uso do cvs se consolidou e o desenvolvimento de software livre n˜ ao para de crescer, se tornando prática usual. J´ a em nossa primeira edi¸caõ procuramos fazer um livro moderno, conceitos de C foram movidos para o fim do livro, acrescentamos no¸co˜es gerais de UML e uma metodologia de desenvolvimento de software. Abordamos conceitos de programa¸caõ para software livre, STL e asicos de o uso de ferramentas atuais como cvs, JAVA DOC e doxygen. Além de conceitos b´ programa¸caõ paralela. Recentemente, a Borland realizou um estudo completo sobre a rotina de um desenvolvedor, identificando aspectos positivos e negativos. Dentre os aspectos positivos destacou-se a necessidade de constante evolu¸caõ tecnol´ ogica, a capacidade criativa e a satisfa¸caõ do desenvolvedor ao produzir um produto de software que resolva os requisitos apresentados. Na lista de ´ıtens negativos est˜ ao a falta de tempo para pesquisa, estudo e atualiza¸caõ de seus conhecimentos. Esta segunda edi¸caõ atende muitas destas solicita¸co˜es, pois traz para você, de uma forma resumida e didática os u ´ ltimos conceitos de POO com UML 2 e C++, as mais recentes bibliotecas, dicas e truques de C++. Esta segunda edi¸caõ tem como objetivos: • Incluir diversas revis˜ oes e corre¸co˜es. • Descrever a UML 2 e um modelo de engenharia de software que inclui conceitos de UP e XP. • Incluir inova¸co˜es de C++ (como as do TC1), da STL, de programa¸caõ com software livre e programa¸caõ paralela. • Ser mais did´ atica, incluindo maior n´ umero de exemplos e exerc´ıcios. • Definir as disciplinas alvo. • Atra´ır programadores de C, Fortran, Delphi, Java, e C#, em fun¸caõ do sucesso e da robustes de C++. Finalmente, gostariamos de dizer que nos u ´ ltimos quatro anos, fizemos uma pesquisa e sele¸caõ criteriosa do que h´ a de mais recente e u ´ til para o desenvolvimento de software multiplataforma utilizando C++. 37

38

Pref´ acio

Revis˜ oes e Inova¸c˜ oes Veja a seguir a lista de revis˜ oes e inova¸co˜es desta segunda edi¸caõ. • Todos os cap´ıtulos foram revisados e atualizados em detalhe. • Todas as listagens foram testadas em diferentes plataformas, incluindo 32 e 64 bits, utilizando a mais recente vers˜ ao do compilador da GNU, o g++ vers˜ ao 4.x. • A parte I: foi inteiramente reorganizada e reescrita considerando UML 2.x. Os diagramas foram gerados usando os programas dia e umbrello. Diversos diagramas novos foram acrescentados. Incluimos novos exemplos e vários exerc´ıcios. • A parte II: foi ampliada considerando as u ´ ltimas inova¸co˜es de C++, o TC1 - ”Technicun Corrigendum 1”, além de dezenas de novos exemplos. • A parte III: incluimos novos exemplos da STL e dicas avan¸cadas de STL. • A parte IV: incluimos as u ´ ltimas vers˜ oes dos softwares da GNU (autoconf, automake e libtool ). Foram adicionadas descri¸co˜es de novos programas, incluindo oreport, calgrind, ddd, cervisia, subversion, cvs avan¸cado, ssh, entre outros. • A parte V: foi reescrita e bastante ampliada, inclui diversos exemplos novos. • A parte VI: é nova e contém cap´ıtulos sobre bibliotecas usuais como Magick++, Boost, Blitz++. Incluimos uma introdu¸caõ a programa¸caõ com interfaces gráficas usando a mais recente vers˜ ao da biblioteca Qt, a Qt 4. • A parte VII: foi totalmente revisada, novos exemplos, novos exerc´ıcios, e novos links foram acrescentados.



Pref´ acio da Primeira Edi¸ c˜ ao A elabora¸caõ deste livro teve como princ´ıpio a reunião dos conceitos de programa¸caõ orientada a objeto com C++ pelo próprio autor, uma espécie de resumo particular. O objetivo era organizar os conceitos de C++ e criar uma apostila de consulta r´ apida, em que a sintaxe de C++ fosse apresentada de forma suscinta e direta. Como o interesse pela programa¸caõ orientada a objeto cresceu substancialmente, diversos bolsistas, mestrandos e doutorandos do LMPT - Laboratório de Meios Porosos e Propriedades Termof´ısicas, site em http://www.lmpt.ufsc.br, solicitaram-me a realiza¸caõ de cursos r´ apidos abordando C++. Durante a apresenta¸caõ desses cursos, foram identificadas as maiores dificuldades dos alunos, o que levava a revisão e amplia¸caõ da apostila. Com o passar dos anos, a linguagem C++ evoluiu e centenas de conceitos novos lhe foram ` medida que C++ adicionados (exce¸co˜es, templates, STL - Standard Template Library). A evolu´ıa, a apostila também necessitava de modifica¸co˜es. Em 1999 comecei a desenvolver um software utilizando as ferramentas de software livre da GNU, o que me levou a incluir descri¸co˜es dessas ferramentas na apostila. Em setembro de 2002, a vers˜ ao 0.4 da ”Apostila de Programa¸ca õ Orientada a Objeto com C++” foi distribu´ıda no CD-ROM da Revista do Linux (edi¸caõ 33). Diversos leitores me enviaram sugest˜ oes e me incentivaram a transformar a apostila em livro. Foi nesta ocasião que entrei em contato com a Editora Novatec. De setembro de 2002 a junho de 2003, fiz centenas de revisões, corre¸co˜es e atualiza¸co˜es. A estrutura do livro foi reorganizada, o que torna mais fácil sua leitura. Diversos cap´ıtulos foram totalmente reescritos e novos exemplos foram inclu´ıdos. Todos os cap´ıtulos de programa¸caõ multiplataforma com software livre foram ampliados e atualizados com as mais novas vers˜ oes das ferramentas da GNU. Foi adicionada uma parte que aborda o uso de cluster de computadores e processamento paralelo (com exemplos). Um curso de C++ é longo, e a experiência mostrou que inici´ a-lo com modelagem e depois abordar conceitos de C n˜ ao funciona. Perde-se a rela¸caõ de objeto conceitual (modelagem) com objeto da linguagem C++. O curso torna-se confuso. Como o n´ umero de conceitos novos é grande, ao chegar ` a parte interessante de C++, polimorfismo e STL, o aluno já n˜ ao tinha mais capacidade de aprendizado. Por este motivo, todos os conceitos relativos à linguagem de programa¸caõ C foram inseridos nos apêndices. Procurei montar cada cap´ıtulo de forma que cada um possa ser consultado para aprendizado dos conceitos de C++, bem como para relembrar o prot´ otipo e a sintaxe de C++. Normalmente a sintaxe é apresentada no in´ıcio do cap´ıtulo e inclui indicadores para as se¸co˜es onde s˜ ao detalhados. Desta forma, o livro é também uma boa referência de C++. Atualmente esta obra é utilizada como livro-texto da disciplina Programa¸caõ Orientada a Objeto com C++, ministrada no LENEP - Laborat´ orio de Engenharia e Explora¸ca õ de Petr´ oleo da UENF - Universidade Estadual do Norte Fluminense Darcy Ribeiro.

39

40

Pref´ acio

Quem deve comprar este livro? Segundo [Meyers, 2005], C++ é uma linguagem de programa¸caõ multiplataforma, é uma confedera¸caõ de linguagens, suportando programa¸caõ procedural, orientada a objeto, funcional, genérica e técnicas de meta programa¸caõ. C++ suporta diferentes estilos de programa¸caõ, e, ao aprender C++ você estar´ a apto a trabalhar em um conjunto de empresas de software. • O autor de C++, Bjarne Stroustrup, afirma que ”é melhor come¸car a programar diretamente em C++” [Bjarne, 1999]. Ou seja, se você n˜ ao sabe se deve come¸car a programar com C ou C++, siga a dica do autor da linguagem C++ e inicie diretamente com C++. • Programadores de C e Fortran que desejam aprender a usar os conceitos de orienta¸caõ a objeto e tem curiosidade por C++. Programadores de Java que querem aprender conceitos avan¸cados, como sobrecarga de operador, heran¸ca-m´ ultipla, templates e STL. • Se você quer aprender UML 2.x. • Se você quer conhecer em detalhes a sintaxe de C++. • Se você quer aprender a usar a STL, seus iteradores, containers e algoritmos genéricos. • Se você é novo no mundo do software livre, ou usuário do GNU/Linux e tem interesse em fazer programas para esta plataforma. • Se você tem interesse em aprender a desenvolver softwares multiplataforma. Isto é, softwares para Windows, GNU/Linux, Mac OS X, SUN Solaris, Unix, etc. • Se você quer aprender os conceitos de programa¸caõ paralela usando m´ ultiplas-threads e m´ ultiplos-processos. • Se você já programa em C++ e quer atualizar seus conhecimentos. • Se você quer fazer suas próprias bibliotecas. • Se você quer aprender a usar novas bibliotecas, como Magick++, Common C++, Boost, Blitz++, Matpack, GSL e Qt 4. Enfim, se você quer crescer, aprender conceitos e idéias novas.

Pr´ e-requisitos A leitura do presente livro n˜ ao requer nenhum pré-requisito. Entretanto, para um melhor acompanhamento dos assuntos da Parte ?? - Programa¸caõ Multiplataforma com Software Livre, é aconselh´ avel um conhecimento prévio de software livre e alguma experiência com GNU/Linux. Você obtém material sobre software livre no s´ıtio da “Disciplina de Software Livre”, veja ´ıtem disciplinas no endere¸co http://www.lenep.uenf.br/~bueno.

Site de aux´ılio a professores e alunos Professores e alunos poder˜ ao consultar o site das disciplinas, ”Programa¸ca õ Orientada a Objeto com C++”, ”Programa¸ca õ Pr´ atica com C++” e ”Processamento Paralelo e Distribu´ıdo”, dispon´ıveis no endere¸co http://www.lenep.uenf.br/~bueno (selecione o ´ıtem disciplinas). Também disponibilizamos um site para a disciplina ”Software Livre”, o mesmo inclui conceitos relacionados ao uso de softwares livres, ferramentas e programas da GNU e do GNU/Linux. Novatec - Programa¸caõ Orientada a Objeto com C++


Pref´ acio

41

Alguns exemplos práticos de programas relacionados a área de an´ alise e processamento de imagens ser˜ ao inclu´ıdos no site da disciplina ”An´ alise e Processamento de Imagens”.

Disciplinas Alvo A nova estrutura do livro é mais did´ atica, foi montada de modo a fornecer a você um livro que possa ser utilizado como livro texto das seguintes disciplinas: • Introdu¸caõ a Programa¸caõ Orientada a Objeto e UML. • C++ e STL. • Programa¸caõ Multiplataforma e Programa¸caõ com Software Livre (GNU/Linux). • Introdu¸cao a Programa¸caõ Paralela e Distribu´ıda. • Cobre ainda o uso de algumas bibliotecas GPL e programa¸caõ gráfica com Qt 4. Did´ atica Este livro tem uma diferen¸ca did´ atica e conceitual muito clara em rela¸caõ a grande maioria dos livros programa¸caõ orientada a objeto e programa¸caõ em C++. Historicamente os livros de programa¸caõ usam uma abordagem estruturada - v´ıcio dos velhos tempos. Os mesmos iniciam direta ou indiretamente com estruturas de controle, fun¸co˜es, arrays, vetores e ponteiros, ou seja, iniciam com os conceitos b´ asicos de linguagens estruturadas - como C e Fortran. Isto se explica em boa parte porque seus autores - pelo menos a maioria - come¸cou a desenvolver programas quando n˜ ao existia programa¸caõ orientada a objeto. Outro problema comum na maioria dos livros de programa¸caõ é tratar o leitor como um ”quase idiota”. • Dezenas de livros repetem o mesmo conceito e as mesmas frases várias vezes. • O mesmo exemplo de c´ odigo é listado dezenas de vezes, e a cada nova apresenta¸caõ apenas pequenas inova¸co˜es s˜ ao apresentadas. O livro fica enorme e com pouco conte´ udo. • Misturam o desenvolvimento de um assunto com dezenas de dicas alheias ao conceito que esta sendo apresentado, distraindo o leitor. • Alguns livros perdem muito tempo com os conceitos b´ asicos - fáceis de aprender. E dedicam pouco espa¸co para os conceitos mais dif´ıceis. O leitor tem a impressão de que aprendeu o necess´ ario, quando ainda falta muito a aprender. Este livro é claramente diferente. O livro trabalha com conceitos de orienta¸caõ a objeto desde os primeiros cap´ıtulos. De uma maneira geral cada cap´ıtulo apresenta um conceito, abordando sua concep¸caõ teórica e prática, indo do mais fácil (usu´ arios iniciantes) ao mais dif´ıcel (usu´ arios avan¸cados). Ou seja, você leitor é tratado com respeito e seriedade. Novatec - Programa¸caõ Orientada a Objeto com C++


42

Sobre o livro

Did´ atica e estilo de apresenta¸ c˜ ao Quando poss´ıvel, a apresenta¸caõ dos conceitos segue uma didática pré-definida. Por exemplo, na parte de UML os conceitos s˜ ao apresentados na seguinte ordem: • Conceito geral. – Exemplo e ilustra¸caõ/figura. • Como o conceito é aplicado em orienta¸caõ a objeto (formalismo). – Descri¸caõ formal do conceito aplicado a orienta¸caõ a objeto. – Exemplo e ilustra¸caõ/figura. – Conceitos correlatos. • Exemplo real. – Exemplo e ilustra¸caõ/figura.

Sobre o livro O livro est´ a dividido nas seguintes partes: • Parte I - Filosofia e Modelagem Orientada a Objeto: Destina-se a transmitir os conceitos b´ asicos de POO - Programa¸caõ Orientada a Objeto, a idéia, a filosofia e a nomenclatura utilizada. Veremos alguns exemplos de objetos, os mecanismos b´ asicos e os conceitos-chave da POO; a modelagem orientada a objeto utilizando a UML - Unified Modelling Language; como montar os diagramas de uma AOO - An´ alise Orientada a Objeto, utilizando a UML. Apresenta as etapas de desenvolvimento de um programa: a concep¸caõ, a elabora¸caõ, a an´ alise orientada a objeto, o projeto do sistema, o projeto orientado a objeto, a implementa¸caõ e o teste; a manuten¸caõ e a documenta¸caõ. • Parte II - POO Utilizando C++: Apresenta a sintaxe de C++. Tipos pré-definidos de C++, tipos do usu´ ario e tipos da STL - Standard Template Library. Como declarar, definir e utilizar classes, objetos, atributos e métodos. Como implementar a heran¸ca simples, a heran¸ca m´ ultipla, a utiliza¸caõ de polimorfismo, a sobrecarga de operadores, a convers˜ ao de tipos, e os tipos genéricos (templates). Apresenta a entrada e a sa´ıda de dados com as classes , , e . Como realizar opera¸co˜es com arquivos de disco utilizando as classes , e . Apresenta um grupo de classes-padr˜ ao de C++. A classe de strings-padr˜ ao de C++, a , a classe para tratar n´ umeros complexos e a classe . • Parte III - Introdu¸ c˜ ao ` a STL: Apresenta a STL, uma biblioteca de objetos em C++. Descrevem-se os conceitos b´ asicos de containers e iteradores. Você aprenderá a utilizar um para vetores, para listas duplamente encadeadas, que representa uma fila, que representa uma pilha (como em uma calculadora HP), que é uma fila com duas extremidades e classes containers para tratamento de conjunto de dados com chaves, , , e . O uso de algoritmos genéricos e fun¸co˜es objeto. Novatec - Programa¸caõ Orientada a Objeto com C++


Sobre o livro

43

• Parte IV: Programa¸ c˜ ao Multiplataforma com Software Livre: Uma introdu¸caõ aos comandos de shell do GNU/Linux, programas u ´ teis como ftp, telnet, ssh. Descreve conceitos de programa¸caõ multiplataforma. Apresenta as ferramentas de programa¸caõ com software livre, cobrindo emacs, gcc/g++, make, automake, autoconf, libtool, gdb, oes com cvs, cervisia, ddd, documenta¸caõ com JAVA DOC e doxygen, controle de vers˜ subversion, e programas como diff, patch e indent. • Parte V: Cluster de Computadores e Processamento Paralelo: Apresenta os conceitos e os diferentes tipos de clusters de computadores. Uma introdu¸caõ ao processamento paralelo. As diferentes formas de processamento paralelo incluindo: i) a utiliza¸caõ de máquinas com mais de um processador (SMP); ii) a utiliza¸caõ de processamento distribu´ıdo em um cluster com OpenMosix, e as vantagens e desvantagens da utiliza¸caõ de bibliotecas, como PVM - Paralel Virtual Machine e MPI - Message Passing Interface. A programa¸caõ com m´ ultiplos-processos e com m´ ultiplas-threads é apresentada com exemplos práticos. Os resultados de tempo de processamento de um cluster real são apresentados. • Parte VI: Bibliotecas: S˜ ao apresentadas algumas bibliotecas GPL, como Magick++, Common C++, Boost, Blitz++, Matpack, GSL e Qt 4. • Parte VII: Apˆ endices: Descreve conceitos gerais de programa¸caõ em C/C++, como: diretrizes de pré-processador, classes de armazenamento e modificadores de acesso, operadores, estruturas de controle, fun¸co˜es, ponteiros, referências, estruturas, uniões e enumeraço˜es. Nos apêndices s˜ ao apresentados ainda um gloss´ ario de C++, arquivos de cabe¸calho e a licen¸ca geral da GNU, a GPL. ´ imAo longo da apresenta¸caõ dos temas, s˜ ao inclu´ıdos exemplos de programas completos. E portante que você compile os programas e verifique o seu funcionamento.

Como fazer download dos arquivos fonte As listagens dos programas est˜ ao dispon´ıveis em: • http://www.novateceditora.com.br/downloads.php • http://www.lenep.uenf.br/~bueno/LivroCpp Usu´ arios do Windows devem baixar o arquivo com a extensão .zip e usuários do GNU/Linux, Mac OS X, Unix, o arquivo com a extensão .tar.gz. Ap´ os fazer o download do arquivo com as listagens você deve descompactar os arquivos e a seguir ler o arquivo LEIAME.html (ou LEIAME.pdf). O mesmo contém instru¸co˜es detalhadas para compila¸caõ e instala¸caõ dos exemplos do livro. Também foi disponibilizado um arquivo ERRATA.html, que inclui uma lista de erros encontrados ap´ os a impressão do livro.

Como compilar e testar os programas Na Parte II do livro, iremos apresentar os primeiros programas em C++. Mas antes disto, na se¸caõ 6.6.6, veremos diversas IDEs - Interfaces de Desenvolvimento de Software em C++. De forma que o usu´ ario poder´ a selecionar o tipo de IDE que mais lhe agrada, tanto no Windows quanto no GNU/Linux. Novatec - Programa¸caõ Orientada a Objeto com C++


44

Como ler este livro

Dica: se você tem pressa em instalar uma IDE a dica é: usuários do GNU/Linux devem instalar o pacote de desenvolvimento da GNU, o gcc/g++. Usu´ arios do Windows podem instalar o programa DevC++, dispon´ıvel em http://www.bloodshed.net/dev/.

Como ler este livro Para facilitar a leitura do livro, alguns t´ıtulos têm um c´ odigo informando a prioridade deste. Este formato foi adotado para permitir a leitura do livro por programadores iniciantes, intermedi´ arios e avan¸cados. • T´ıtulo - Iniciante/B´ asico N´ıvel b´ asico para iniciantes na programa¸caõ orientada a objeto com C++. Os t´ıtulos de se¸caõ no formato Titulo2 e Titulo3 n˜ ao devem ser lidos por iniciantes na programa¸caõ em C++. Os t´ıtulos de n´ıvel 2 e 3 podem incluir referências a conceitos que ainda n˜ ao foram apresentados e s´ o devem ser lidos por quem tem experiência em C++ ou em uma segunda leitura do livro. • T´ıtulo2 - Intermedi´ ario N´ıvel intermedi´ ario. Leitura aconselhada para quem já conhece C++ e quer se aperfei¸coar. • T´ıtulo3 - Avan¸cado N´ıvel avan¸cado. Se você j´ a programa a algum tempo em C++ e quer aperfei¸coar seus conhecimentos, leia os t´ıtulos de n´ıvel 3, que abordam aspectos com os quais você ir´ a se deparar ap´ os ter feito alguns programas. Também foram acrescentadas dicas gerais, dicas de desempenho e dicas para evitar erros (bugs), utilizando a seguinte nota¸caõ: Dica: Ao longo dos cap´ıtulos s˜ ao apresentadas algumas dicas. O objetivo das dicas é ressaltar algum aspecto da linguagem C++ ou algum comando ou programa externo. Desempenho: S˜ ao dicas de como aumentar o desempenho de seus programas. Bugs: Cuidados para evitar a presen¸ca de bugs em seus programas. Para que o aluno possa fixar os conceitos, apresenta-se ao longo do texto prot´ otipos, exemplos e listagens de programas. Prot´ otipo: Define a sintaxe de uso de determinado comando ou programa (aparece em it´ alico). Defini¸co˜es e descri¸co˜es de fun¸co˜es/métodos/comandos aparecem como no exemplo abaixo: comando Explica a utilidade do comando/programa. Op¸caõ

Descri¸caõ

op¸caõ1

...descri¸caõ...

op¸caõ2

...descri¸caõ...

Exemplos: Novatec - Programa¸caõ Orientada a Objeto com C++


Experiência do autor

45

Exemplos textuais podem ser apresentados como nesta frase. /* Os exemplos embutidos no texto tem a linha de comando em fonte fixa n~ ao s~ ao programas completos, s~ ao partes de programas. Apenas ilustram determinada caracter´ ıstica da linguagem e sua sintaxe. Os exemplos de c´ odigo fonte s~ ao apresentados em fonte fixa.*/ int x = 2; Comandos embutidos no texto usam fonte normal, it´ alico e negrito, e a sa´ıda aparece indentada, com fonte fixa em it´ alico, como abaixo. libtool –mode=compile g++ -c List-15-2-TCirculo.cpp mkdir .libs g++ -c List-15-2-TCirculo.cpp -fPIC -DPIC -o .libs/List-15-2-TCirculo.o g++ -c List-15-2-TCirculo.cpp -o List-15-2-TCirculo.o >/dev/null 2> &1

In´ umeras listagens de programas completos e testados foram inclu´ıdos no livro. Cada programa é documentado, assim, o leitor entender´ a o significado de cada linha. Veja a seguir, um exemplo de listagem que apresenta um programa funcional em C++, o tradicional “Ol´ a Mundo”. Logo a seguir apresenta-se a sa´ıda. Listing 1: Exemplo de uma listagem (Listing). /* * @ c o p y r i g h t ( C ) Andre Duarte Bueno # include < iostream > int main () { std :: cout << " Ol´ a mundo !\ n " ; return 0; }

@file

List -1 - E x e m p l o D e L i s t i n g . cpp */

Ol´ a mundo !

Senten¸ cas: • Senten¸cas s˜ ao regras, exemplos e defini¸co˜es curtas e diretas. • Se você encontrar termos desconhecidos dê uma olhada no gloss´ ario. • 2 Senten¸ca de n´ıvel 2 é recomentada para quem já conhece C++ e quer se aperfei¸coar. • 3 Senten¸ca de n´ıvel 3 é recomendada para programadores avan¸cados. • Algumas senten¸cas podem incluir extrato de c´ odigo, como abaixo. // Coment´ arios em C++ iniciam com //

Por onde come¸ car? A Figura 1 mostra um diagrama onde você pode identificar a melhor seq¨ uencia de leitura deste livro. Novatec - Programa¸caõ Orientada a Objeto com C++


46


<> Profissional <> Estudante

<>

Biblioteca STL

Básico

Filosofia POO

+28,29,30,31,32,33 +5,6,7,8,9,10,11,24,26 +A,C,D

+1,2

Modelagem OO << C++>> +3,4

Intermediário << C++>> +12,13,14,15,17,18,19,20,25 +B,E,G

Avançado

Classes

+16,20,21,22,23,27, +F

+2,3,4,9,10,11,12,14,19,21

debug +41

Documentação +44

Herança +2,3,4,15,16,17

Associações

Controle Versões

+2,3,4,20

+47

<> Profissional Multiplataforma

Ferramentas +4,35,36,37,38,40,41,42,44,47

Multiplataforma +4,34,45,46

Pr.Paralelo +48,49,50,51

Portabilidade +45,46

Figura 1: Por onde come¸car?




47

Experiˆ encia do autor Ao longo dos u ´ ltimos anos, o autor trabalhou no desenvolvimento de diversos softwares, alguns destes softwares s˜ ao apresentados no Cap´ıtulo 1 - Introdu¸caõ à Programa¸caõ. Dica de estudo: Ap´ os terminar de ler cada cap´ıtulo, fa¸ca uma breve revis˜ ao dos conceitos apresentados. Dedique 5 minutos para dar uma folheada r´ apida no cap´ıtulo que leu, revendo os principais conceitos. Quando chegar em casa, dedique de 30-50 minutos para rever o que foi visto em aula (ou o que foi lido), fixando os conceitos.

Errata Nos esfor¸camos ao máximo para fornecer a você um livro de primeira qualidade. Entretanto, atividades de revis˜ ao e testes, parecem nunca serem suficientes. Se encontrar erros, omissões, entre em contato com [email protected]. Antes entretanto, aconselha-se dar uma olhada na se¸caõ errata. • http://www.lenep.uenf.br/~bueno/LivroCpp, veja arquivo Errata.html Errata.html.

Contatando o autor Embora tenha sido realizado um esfor¸co enorme no sentido de se fazer um bom livro de programa¸caõ orientada a objeto com C++, a extensão do livro e a sua abrangência, tornam dif´ıcel a sua manuten¸caõ (inclus˜ ao de novos conceitos). Neste sentido, se você tiver dicas, sugest˜ oes, e exemplos para melhoria deste livro, favor entrar em contato com:

Prof. André Duarte Bueno. Software Enginering, Image Analysis and Processing Petroleum Engineering and Exploration Laboratory Science and Technology Center North Fluminense State University Rodovia Amaral Peixoto, km 163, Avenida Brenand S/N CEP 27925-310 - Imboassica - Macaé - RJ - Brasil e-mail: [email protected] http://www.lenep.uenf.br/~bueno Site do LENEP - Laboratório de Engenharia e Explora¸caõ de Petr´ oleo http://www.lenep.uenf.br



48

Programa¸caõ Orientada a Objeto com C++

LISTINGS


Parte I

Filosofia e Modelagem Orientada a Objeto

49

Cap´ıtulo 1

Introdu¸c˜ ao ` a Programa¸ c˜ ao Neste primeiro cap´ıtulo apresentaremos o conceito de software (se¸caõ 1.1), o que é um programa, um software (se¸caõ 1.1.1), as diferen¸cas entre o software livre e o software propriet´ ario (se¸caõ 1.2). Além disso, apresentaremos diferentes tipos de interface dos programas (se¸caõ 1.3), kernel numérico (se¸caõ 1.3.1), linha de comando (se¸caõ 1.3.2), modo texto (se¸caõ 1.3.3) e gráfica (se¸caõ 1.3.4). Discutiremos também qual tipo de software você deve desenvolver (se¸caõ 1.4). Finalizaremos o cap´ıtulo com um resumo e alguns exerc´ıcios.

1.1

Programas e softwares

O objetivo de um programa de computador é facilitar a vida do usuário, aumentar sua produtividade, principalmente para a realiza¸caõ de tarefas repetitivas e também para possibilitar uma comunica¸caõ e intera¸caõ com o mundo de forma mais efetiva, r´ apida e globalizada. J´ a é poss´ıvel a um usu´ ario de computador escrever documentos, montar planilhas, fazer gráficos e apresenta¸co˜es, enviar e receber mensagens e arquivos, fazer transa¸co˜es banc´ arias com seguran¸ca, montar projetos de engenharia, navegar na internet, ouvir m´ usicas, ver filmes e realizar diversas outras atividades de rotina e de lazer. Numa passagem r´ apida, podemos citar programas do dia a dia como o Office (Power Point, Excel, Word), OpenOffice (Impress, Calc, Write), Internet Explorer, Firefox, E-mail, Orkut, Players, programas t´ıpicos de servidores, como SSH, Telnet, FTP, programas especialistas de engenharia (Octave, Gnuplot, Matlab, Scilab, Autocad) e programas para o desenvolvimento de software (g++, make, gdb, ddd, cvs, cervisia, kdevelop, glade). Como podemos ver, temos à nossa disposi¸caõ centenas de softwares e programas, livres e propriet´ arios, com as mais variadas interfaces e formas de uso.

1.1.1

O que ´ e um programa, um software?

Software ou programa de computador é uma seq¨ uência de instru¸co ˜es a serem seguidas e/ou executadas, na manipula¸ca õ, redirecionamento ou modifica¸ca õ de um dado/informa¸ca õ ou acontecimento. Quando um software est´ a escrito usando instru¸co ˜es que podem ser executadas diretamente por um processador dizemos que est´ a escrito em linguagem de m´ aquina. O dispositivo mais conhecido que disp˜ oe de um processador é o computador. Existem outras m´ aquinas program´ aveis, como telefone celular, m´ aquinas de automa¸ca õ industrial, calculadora, etc. Um programa é feito usando Linguagens de Programa¸ca õ. [Wikipedia, 2007]. 51

˜ DE SOFTWARE PROPRIETARIO ´ 1.2. DEFINIC ¸ AO E SOFTWARE LIVRE

52

Eu prefiro uma defini¸caõ mais simples, como: conjunto de instru¸co˜es l´ ogicas, em linguagem de máquina, utilizadas para realiza¸caõ de tarefas de nosso cotidiano por intermédio de um computador. Formalmente n˜ ao existe diferen¸ca entre o conceito de software e programa. Mas particularmente uso o termo software, para um programa com interface gráfica amig´ avel e documenta¸caõ disponibilizada. Costumo usar o termo programa para um sistema que tem uma interface pobre e n˜ ao tem documenta¸caõ (ou é mal documentado); Observe que essa é uma diferencia¸caõ de que gostamos de fazer, embora outros autores tenham suas pr´ oprias defini¸co˜es.

1.2

Defini¸c˜ ao de software propriet´ ario e software livre

A seguir, ser˜ ao apresentadas a defini¸caõ e as caracter´ısticas dos softwares propriet´ arios e dos softwares livres. Veja maiores detalhes nas referências: • [Comunidade-GNU, 1996, http://www.fsl.org, 2004, Comunidade-Software-Livre, 1996]. • [Anais, 2000, Queiroz, 2002, Amadeo., 2003].

1.2.1

Defini¸c˜ ao e caracter´ısticas do software propriet´ ario

Veja a seguir as principais caracter´ısticas do software propriet´ ario: • Segundo a referência [Wikipedia, 2007], ”o software propriet´ ario é um conceito criado por empresas de software com a inten¸caõ de proteger o seu produto de qualquer tipo de altera¸caõ. Sua licen¸ca pro´ıbe a distribui¸caõ ou c´ opia sem a autoriza¸caõ do propriet´ ario”. • Possui licen¸ca propriet´ aria, n˜ ao podendo ser copiado em outros computadores, pois o usuário compra uma licen¸ca de uso para um computador e sistema espec´ıfico. ´ desenvolvido por empresas comerciais como Microsoft, Borland etc. • E • N˜ ao pode ser modificado, uma vez queo c´ odigo-fonte n˜ ao é distribu´ıdo. • Possui suporte oficial, geralmente bem documentado.

1.2.2

Defini¸c˜ ao e caracter´ısticas do software livre

Veja a seguir as principais caracter´ısticas do software livre: • Garante ao usuário plenas liberdades de uso, acesso e modifica¸caõ do c´ odigo-fonte, c´ opia e publica¸caõ de vers˜ oes modificadas. A defini¸caõ completa de software livre pode ser encontrada em http://www.gnu.org/philosophy/free-sw.html. • A licen¸ca GPL é a licen¸ca de software livre mais utilizada no mundo, mas existem outras licen¸cas de software livre, como: BSD, LGPL, Artistic Licence, CC. A caracter´ıstica é que qualquer trabalho derivado de um software livre obrigatoriamente deve permanecer livre. Uma descri¸caõ da GPL pode ser obtida em http://www.gnu.org/licenses/gpl.html e no Apêndice L – Licen¸ca P´ ublica Geral GNU. • Desenvolvido a partir do movimento pelo software livre, o qual surgiu na década de 1970 em conseq¨ uência da crescente press˜ ao recebida para a ado¸caõ de softwares propriet´ arios e assinaturas de tratados de n˜ ao-divulga¸caõ. O movimento ganhou for¸ca a partir da década Programa¸caõ Orientada a Objeto com C++


˜ DE SOFTWARE PROPRIETARIO ´ 1.2. DEFINIC ¸ AO E SOFTWARE LIVRE

53

de 1980 com o projeto GNU, que libertava os usuários dos sistemas UNIX propriet´ arios. O GNU consolidou-se na década de 1990 como um sistema operacional completo e funcional, atingindo uma qualidade técnica comparável a` dos melhores sistemas operacionais propriet´ arios. Em 1998 surgiu a Iniciativa Open Source 1 (código aberto), grupo desmembrado do movimento pelo software livre em 1998 que rejeita a luta pela liberdade na utiliza¸caõ do software. Seu objetivo é disseminar a idéia de que o c´ odigo-fonte esteja dispon´ıvel e que as modifica¸co˜es sejam permitidas, gerando, assim, programas melhores. Apesar disso, esse grupo costuma recomendar a utiliza¸caõ da licen¸ca GPL, que representa melhor o esp´ırito do software livre. Isto torna os dois grupos cooperativos, do ponto de vista de cria¸caõ de softwares. • Na maioria dos casos n˜ ao possui suporte oficial (mas existem exce¸co˜es como o RedHat Enterprise, da RedHat, e o SUSE Linux Enterprise, da Novell). • Nem sempre é bem documentado. Veja a seguir outros termos utilizados no mundo do software livre. O que ´ e GNU? Acrˆ onimo para ”GNU, n˜ ao é UNIX”. GNU é o nome de um sistema operacional completo e compat´ıvel com UNIX escrito em 1983 por Richard Stallman e in´ umeros hackers da comunidade de software livre espalhados pela internet. O GNU é totalmente livre, ou seja, ele fornece as quatro liberdades b´ asicas do software livre: liberdade de uso, modifica¸caõ, c´ opia e publica¸caõ de vers˜ oes modificadas. O que ´ e Linux? Clone livre do kernel do UNIX, escrito a partir do zero por Linus Torvalds, que contou com a ajuda de um grupo de programadores espalhados pela internet (isto é, o Linux é somente um kernel). Foi projetado para estar em conformidade com o POSIX e com a Single Unix Specification. O que ´ e GNU/Linux? ´ o sistema operacional GNU totalmente livre que utiliza o Linux como kernel; sendo a E variante mais conhecida do sistema GNU. Em resumo, Linux é um kernel, e n˜ ao um sistema operacional. Apesar de ”Linux” ser comumente utilizado em referência ao sistema operacional GNU/Linux, devemos evitar este uso equivocado por quest˜ oes de clareza técnica e de crédito ao projeto GNU, que forneceu o seu sistema operacional para ser adaptado ao kernel Linux. Sempre que quisermos falar deste sistema operacional, devemos usar o termo GNU/Linux. Desta forma, estaremos levando adiante os ideais do software livre que est˜ ao representados no projeto GNU. Nota: uma descri¸caõ detalhada da licen¸ca GPL pode ser vista no Apêndice L – Licen¸ca P´ ublica Geral GNU. Dicas e referências para migrar para software livre est˜ ao dispon´ıveis no , [GuiaLivre, 2004]. 1 C´ odigo aberto: express˜ ao utilizada para indicar que vocˆ e pode ver o c´ odigo-fonte do programa. Entretanto, nada pode ser dito a respeito das condi¸co ˜es sob as quais o c´ odigo-fonte se encontra. Existem programas de c´ odigo aberto que n˜ ao s˜ ao livres, pois o usu´ ario, dependendo da licen¸ca, pode ser proibido de alterar e publicar o c´ odigo.



54

1.3. TIPOS DE INTERFACE DE UM PROGRAMA/SOFTWARE

1.2.3

Exemplos de softwares livres e propriet´ arios

• Exemplo de sistemas operacionais propriet´ arios: – Windows – Mac OS X – Unix • Exemplo de sistemas operacionais livres: – GNU/Linux – Free-BSD • Exemplos de programas propriet´ arios: – Microsoft Office – Internet Explorer – Borland Builder C++ • Exemplos de programas livres – GPL (equivalentes): – OpenOffice – Firefox – Kdevelop, Glade, Qt Designer J´ a sabemos o que é um software e as diferen¸cas entre software livre e software propriet´ ario. Também vimos alguns exemplos de programas. Veremos a seguir os diferentes tipos de interface de um programa.

1.3

Tipos de interface de um programa/software

A interface de um programa é a forma como ele interage com o usuário. Embora estejamos, na maior parte do tempo, utilizando programas com interface gráfica, ainda temos, muitas vezes, de utilizar programas com interface em modo texto. Usu´ arios avançados de Unix e GNU/Linux preferem utilizar programas neste modo, alegando conseguirem melhor produtividade. Nesta se¸caõ apresentaremos quatro tipos de interface de programas: • Um programa sem nenhum tipo de interface – kernel numérico (veja se¸caõ 1.3.1) . • Um programa com interface via linha de comando (veja se¸caõ 1.3.2). • Um programa com interface em modo texto (veja se¸caõ 1.3.3). • Um software com interface em modo gr´ afico (veja se¸caõ 1.3.4). Nosso objetivo é apresentar as caracter´ısticas e as diferen¸cas entre esses programas, além de apresentar o n´ıvel de complexidade da sua interface. Programa¸caõ Orientada a Objeto com C++



1.3.1

55

Um programa sem interface (kernel num´ erico)

De uma maneira geral, um kernel numérico é um programa sem nenhum tipo de interface com o usuário, sendo utilizado para realiza¸caõ de algum processamento de dados. Veja as caracter´ısticas de um programa do tipo kernel numérico: • N˜ ao tem interface com o usu´ ario (entradas e sa´ıdas). • Tem como objetivo realizar algum processamento, geralmente um processamento pesado, ou a realiza¸caõ de tarefas bem espec´ıficas. • Uma documenta¸caõ simplificada pode ou n˜ ao estar disponibilizada. Veja a seguir um exemplo de programa do tipo kernel numérico em C++. A classe TRotulador3D é usada para separar e identificar os objetos presentes em uma imagem binarizada. Para tanto, é utilizado um algoritmo de rotulagem dos pixels da imagem. Neste exemplo n˜ ao existe nenhuma intera¸caõ com o usu´ ario; o arquivo com a imagem imagem.pbm é carregado do disco em (1), a rotulagem é realizada em (2) e o resultado é armazenado em disco com o nome rotulada.pgm em (3). Veremos na se¸caõ ?? outros exemplos de programas do tipo kernel numérico. Nota: n˜ ao se preocupe em entender o programa, o objetivo é mostrar que neste exemplo n˜ ao temos intera¸caõ com o usu´ ario. // Exemplo de rotulagem de imagens 3D #include #include int main(int argc, char* argv[]) { TRotulador3D rot("imagem.pbm"); // (1) Cria rotulador e carrega imagem rot.Go(); // (2) Executa rotulagem rot.Write("rotulada.pgm"); // (3) Salva resultado em disco return 0; }

1.3.2

Um programa com interface via linha de comando

Um programa pode ser desenvolvido de forma a receber a entrada do usuário utilizando a linha de comando. Como exemplo, temos os programas dir e ls, os quais podem receber parˆ ametros opcionais e s˜ ao utilizados para visualiza¸caõ dos arquivos de um determinado diret´ orio. Observe que neste caso j´ a existe algum tipo de intera¸caõ entre o usuário e o programa. Veja as caracter´ısticas de um programa com interface via linha de comando: • A passagem dos parˆ ametros é feita na chamada do programa, via linha de comando. • Os parˆ ametros podem ser opcionais como em ls -lah, dir /w . Para ver as op¸co˜es do programa ls, abra um terminal e digite ls - -help ou man ls. • A sa´ıda de dados é opcional, pode ser para tela, para um arquivo de disco ou para outro dispositivo. • Este tipo de programa permite o uso de redirecionamentos (exemplo: ls > saida.txt), uso de pipes (ex: ls | sort) (veja se¸caõ 23.4). Veremos exemplos de programas com interface via linha de comando nas se¸co˜es E.1 e E.2. Programa¸caõ Orientada a Objeto com C++


56


1.3.3

Um programa com interface em modo texto

Um programa com interface em modo texto inclui entrada e sa´ıda de dados usando uma interface simplificada (teclado e monitor). Veja a seguir as caracter´ısticas de um programa com interface neste modo: • Apresenta interface simplificada, em modo texto. • As entradas s˜ ao executadas via teclado e as sa´ıdas, usando a tela, geralmente por meio de um terminal. • Muito utilizado em servidores, em programas para manuten¸caõ do sistema, em programas cient´ıficos, em engenharia e em sistemas antigos (legados). O programa de reconstru¸caõ tridimensional, ilustrado na Figura 1.1(a), é um exemplo de programa com interface em modo texto, o qual cria uma imagem 3D a partir de dados medidos em imagens 2D. O programa inicia mostrando valores-padr˜ ao a serem utilizados na reconstru¸caõ e um menu simplificado, no qual o usu´ ario pode selecionar uma das seguintes op¸co˜es: iniciar a reconstru¸caõ, modificar os valores a serem utilizados ou abandonar o programa. Observe que, depois de selecionar a op¸caõ ”Valores corretos, iniciar reconstru¸caõ.....(r)”, cada etapa executada pelo programa é mostrada na tela, indicando que a mesma foi conclu´ıda. Na Figura 1.1(b), é apresentada a tela inicial do programa Octave, utilizado para a realiza¸caõ de c´ alculos t´ıpicos de métodos numéricos. No exemplo, o Octave é utilizado para somar dois vetores. Para maiores detalhes do programa Octave, consulte o site http://www.gnu.org/ software/octave/. Ao longo deste livro apresentaremos dezenas de exemplos de programas com interface em modo texto.

Figura 1.1: Em (a) programa de reconstru¸caõ tridimensional, em (b) o programa Octave.

(a) Programa de reconstru¸ca õ 3D.

(b) Programa octave.

Um programa com interface em modo texto e mecanismo de recupera¸ c˜ ao O programa do grafo de conex˜ ao serial, apresentado na Figura 1.2, é utilizado para determinar a permeabilidade de rochas usando representa¸co˜es 3D (imagens tridimensionais). Sua Programa¸caõ Orientada a Objeto com C++



57

entrada é a imagem gerada pelo programa de reconstru¸caõ (veja Figura 1.1(a)). Observe ainda na Figura 1.2 que o programa também tem uma interface em modo texto semelhante ao programa de reconstru¸caõ, mas apresenta alguns diferenciais interessantes: • Salva valores parciais da simula¸caõ em disco. • Permite o rein´ıcio do programa ap´ os queda de energia. • N˜ ao repete a simula¸caõ de imagens j´ a processadas (trabalha com lista de imagens). Essas caracter´ısticas s˜ ao bastante u ´ teis em programas de engenharia, programas cient´ıficos e programas que envolvam o processamento de grandes quantidades de dados. O sistema de rein´ıcio é bastante simples: a máquina é programada para iniciar automaticamente o programa quando for reiniciada. O programa lê o arquivo com a lista de imagens a serem processadas, verifica quais j´ a foram processadas, e ent˜ ao reinicia a simula¸caõ da imagem que estava sendo processada quando a energia caiu.

Figura 1.2: Programa com interface em modo texto e mecanismos de recupera¸caõ.

1.3.4

Um software com interface em modo gr´ afico

O software Anaimp apresentado na Figura 1.3(a) é um software educativo para an´ alise de imagens e que possui interface em modo gráfico. Veja a seguir as caracter´ısticas de um software com interface em modo gráfico: • Tem programa para instala¸caõ automatizada. • Tem interface gr´ afica e amig´ avel (menus, botões, diálogos, barra de tarefa e de status). • Tem previs˜ ao de impressão, possibilidade de desenho das imagens, sistema de controle dos processamentos (exemplo: visualiza¸caõ passo a passo dos processos realizados). • Tem manual do usu´ ario. Infelizmente o programa Anaimp n˜ ao foi finalizado, uma vez que, por utilizar uma biblioteca gráfica propriet´ aria que foi descontinuada – a OWL da Borland –, decidimos abandonar o desenvolvimento do programa Anaimp e posteriormente constru´ı-lo utilizando bibliotecas GPL, como a Qt. Na se¸caõ ??, veremos diversos exemplos de uso da biblioteca Qt 4, utilizada para a montagem de programas com interface gráfica. Um exemplo de software profissional e completo com este tipo de interface é o Imago (veja Figura 1.3(b)), . O Imago é exemplo de software nacional, premiado, desenvolvido numa parceria da ind´ ustria (Petrobras) com a universidade (UFSC) e a empresa ESSS.



58

1.4. QUE TIPO DE SOFTWARE DEVO DESENVOLVER?

Figura 1.3: Programas com interface gráfica.

(a) O software Anaimp.

1.4

(b) O software Imago.

Que tipo de software devo desenvolver?

Bem, agora que você j´ a conhece as principais diferen¸cas entre o software propriet´ ario e o software livre e os diferentes tipos de interface com o usuário, você precisa responder quest˜ oes como: • Devo desenvolver software propriet´ ario ou software livre? • Devo desenvolver software com interface em modo texto ou em modo gráfico? Devo desenvolver software propriet´ ario ou software livre? A resposta para esta quest˜ ao n˜ ao é f´ acil. Você ter´ a de analisar os prós e contras de cada modelo, e ent˜ ao escolher o modelo de desenvolvimento de software que mais se aproxima de seu perfil. Como sou defensor do modelo de software livre, aconselho a leitura das seguintes referências: • O que é a filosofia do SL? [Comunidade-GNU, 1996, http://www.fsl.org, 2004] • Porque usar SL? [Queiroz, 2002] • Quem paga pelo SL?[Comunidade-Software-Livre, 1996, Amadeo., 2003] Devo desenvolver software com interface em modo texto ou em modo gr´ afico? Esta resposta é mais f´ acil. Se o programa é um programa cient´ıfico, que envolve c´ alculos/processamentos pesados e que tem pouca necessidade de intera¸caõ com o usuário, você pode usar uma interface em modo texto. No entanto, se o programa requer uma intera¸caõ constante com o usuário, a op¸caõ correta é o software com interface em modo gráfico. Dica: tente montar o programa usando os conceitos profissionais da engenharia de software, pois viabilizam o desenvolvimento de softwares complexos e facilitam a migra¸caõ de um programa com interface em modo texto para interface em modo gráfico. Programa¸caõ Orientada a Objeto com C++


1.5. RESUMO DO CAPÍTULO

1.5

59

Resumo do cap´ıtulo

Neste primeiro cap´ıtulo aprendemos o conceito de software, de programa e as diferen¸cas entre o software livre e o software propriet´ ario. Ademais, foi colocada a quest˜ ao sobre o que desenvolver: software propriet´ ario ou software livre. Vimos que um programa de computador pode ter diferentes tipos de interface e que um kernel numérico é um programa sem interface. Um programa em linha de comando, por sua vez, recebe seus parˆ ametros na chamada do programa e pode ou n˜ ao apresentar uma sa´ıda na tela do computador. Um programa em modo texto, como o Octave, apresenta uma interface simplificada, em modo texto, e é utilizado por usuários experientes. J´ a os softwares mais ”amig´ aveis” contam com interface gr´ afica com menus, botões e diálogos que facilitam seu uso. No próximo cap´ıtulo apresentaremos uma breve introdu¸caõ à programa¸caõ orientada a objeto. Dica: embora o computador possibilite uma intera¸caõ mais universal, seja por meio de um jogo de xadrez pela internet com pessoas de qualquer parte do mundo, seja por meio da cria¸caõ e desenvolvimento de sua própria ”tribo”, n˜ ao deixe de apreciar e viver a vida na sua comunidade. Aprenda a conciliar estes dois universos.

1.6

Exerc´ıcios

1. Explique com suas palavras o que é um programa e porque desenvolvemos programas de computador? 2. Quais as principais diferen¸cas entre sistemas operacionais livres e propriet´ arios? 3. Porque devemos ler a licen¸ca de um software quando o instalamos? 4. Você já deve ter utilizado um navegador para fazer o download de arquivos pela internet (como o Firefox/Explorer), mas existem programas em modo texto, como o FTP (veja se¸caõ ??) e o Wget (http://www.gnu.org/software/wget/wget.html), que também s˜ ao utilizados para fazer download de arquivos. Descreva quais as vantagens e desvantagens dos programas em modo gr´ afico e dos programas em modo texto. 5. Qual a vantagem de um programa que pode ser reinicializado automaticamente pelo sistema? 6. Um programa escrito por você pode usar componentes fornecidos por um programa livre como o OpenOffice Impress? E se o programa fosse o Microsoft Word, você poderia utilizar componentes do Microsoft Word em seu programa? 7. Um sistema de engenharia gera uma quantidade enorme de dados, sendo necess´ ario fazer 100 gr´ aficos. Estes gr´ aficos podem ser mais rapidamente feitos em uma planilha como o OpenOffice Calc ou em programas em modo texto como o Gnuplot (http: //www.gnuplot.info/)? 8. Quais as aplica¸co˜es e vantagens de programas do tipo kernel numérico? 9. Quais os programas com interface via linha de comando que você costuma utilizar? 10. Fa¸ca um breve histórico de programas novos e antigos utilizados na sua área de estudo. Além de perquisar na internet, converse com professores e profissionais antigos; tente entender as transforma¸co˜es que têm ocorrido no mundo da inform´ atica. Programa¸caõ Orientada a Objeto com C++


60


1.6. EXERCÍCIOS


Cap´ıtulo 2

Introdu¸c˜ ao ` a Programa¸ c˜ ao Orientada a Objeto – POO Neste cap´ıtulo apresentaremos uma se¸caõ sobre como entendemos os objetos (se¸caõ 2.1), um exemplo de objeto (se¸caõ 2.2) e em seguida o conceito de objeto (se¸caõ 2.3). Veremos ainda um breve histórico da programa¸caõ orientada a objeto (se¸caõ 2.4), uma compara¸caõ desta versus a vis˜ ao desorganizada e a visão estruturada (se¸caõ 2.4.1), e as vantagens da programa¸caõ orientada a objeto (se¸caõ 2.4.2). Nota: em nossas aulas, sempre utilizamos exemplos de objetos reais e abstratos. Primeiro falamos de um exemplo real, mais f´ acil de entender, e depois de algum exemplo abstrato. Este procedimento did´ atico é adotado ao longo deste livro.

2.1

Entendendo os objetos

Para explicar os conceitos b´ asicos de orienta¸caõ a objeto, costumo usar primeiramente os objetos que est˜ ao na sala de aula: cadeiras, mesas, computadores, projetor, cabos de energia e de rede, tomadas, lˆ ampadas, pincel, quadro, apagador. Uma pergunta que sempre fa¸co é: ”como uma crian¸ca vê uma sala de aula?” ”uma cadeira?”. O objetivo desta pergunta é relembrar como aprendemos a entender o mundo em que vivemos. Entendemos o mundo por meio de classifica¸co˜es e associa¸cões. Estamos o tempo todo classificando, identificando os atributos (propriedades) e fun¸co˜es (a¸co˜es, métodos) que determinado objeto é capaz de realizar. Na maioria dos casos conseguimos encaixar o objeto numa classe pré-existente. Em alguns casos o objeto n˜ ao é exatamente do mesmo tipo, mas é uma varia¸caõ, uma evolu¸caõ ou adapta¸caõ de um objeto conhecido. Assim, para uma crian¸ca, uma cadeira é um objeto cuja fun¸caõ é ser utilizada para se sentar. Neste sentido, uma cadeira de uma sala de aula, de um restaurante, ou até mesmo um sofá é um tipo de cadeira. Rapidamente a crian¸ca come¸ca a fazer outras classifica¸co˜es sobre as ”cadeiras”, como, ”cadeira branca”, ”cadeira com apoio para bra¸co”, ”cadeira com rodinhas”. Identificamos assim diversos atributos do objeto cadeira. Estes atributos (propriedades ou caracter´ısticas) s˜ ao utilizados para diferenciar uma cadeira da outra, criando eventualmente subgrupos, mas o conceito essencial de objeto para se sentar permanece. Segundo [Guedes, 2004], ”sempre que precisamos compreender um conceito novo, criamos uma nova classe para este conceito e determinamos que todo objeto com as mesmas caracter´ısticas desta classe é um exemplo, uma instância dela”. Vamos a um exemplo: ao ver pela 61

62

2.2. EXEMPLO DE OBJETO

primeira vez um SkySurf, você automaticamente o associa ao Surf e a esportes como AsaDelta. Neste caso, criamos um conceito novo baseado na composi¸caõ de conceitos já conhecidos. Outro exemplo: uma célula PVT. Possivelmente você vai perguntar que raio de objeto é esta tal célula PVT? Uma célula PVT é um equipamento utilizado em engenharia de petr´ oleo para determinar propriedades do ´ oleo baseando-se em an´ alises de Press˜ ao, Volume, Temperatura, ou seja, é um equipamento de medi¸caõ. Observe que é um conceito novo, um equipamento totalmente desconhecido. Nosso cérebro precisa criar este novo conceito, criando uma nova classe de objetos. Agora que já sabemos – mesmo que basicamente – a forma como identificamos e classificamos os objetos, vamos apresentar um exemplo de objeto e a seguir o conceito de objeto.

2.2

Exemplo de objeto

Veja a seguir um exemplo de objeto do mundo real e a an´ alise de algumas de suas caracter´ısticas. Concluiremos que a programa¸caõ orientada a objeto é baseada em conceitos que já conhecemos.

Um rel´ ogio Retire o seu rel´ ogio do pulso e comece a analisá-lo. Verifique que ele é um objeto real, que lhe d´ a algumas informa¸co˜es como hora, data e dia da semana e que tem cronˆ ometro e alarmes. Essas informa¸co˜es s˜ ao atributos que s˜ ao manipulados pelo rel´ ogio, ou seja, um objeto tem atributos. O rel´ ogio também tem botões, como um botão de ilumina¸cão, um botão para selecionar o atributo a ser visto, um botão para acertar a hora. Podemos dizer que o acionamento desses botões corresponde a um evento, uma mensagem enviada para o objeto solicitando que determinada fun¸caõ do rel´ ogio seja executada. Logo, um objeto tem fun¸co ˜es (métodos). Além dos botões, o rel´ ogio também tem uma caixa externa e uma pulseira, ou seja, um objeto rel´ ogio é composto de outros objetos. Um objeto pode ser formado a partir de um conjunto de objetos que s˜ ao agregados/agrupados. Falamos de um rel´ ogio moderno, com alarmes e cronˆ ometros; mas um rel´ ogio antigo s´ o informava a hora; de um rel´ ogio de bolso evoluiu-se para rel´ ogios de pulso, para rel´ ogios de parede, para rel´ ogios com alarmes, com cronˆ ometros etc., ou seja, um objeto pode evoluir e esta evolu¸ca õ est´ a associada a uma heran¸ca, uma hierarquia. Apesar de todas essas informa¸co˜es, a informa¸caõ principal do rel´ ogio é a hora certa. Visto que o rel´ ogio n˜ ao é uma máquina perfeita, ele pode atrasar. Neste caso, o dono do rel´ ogio utiliza a informa¸caõ de um rel´ ogio-padrão, com a hora certa, para acertar a hora. Nesse exemplo, um objeto homem interagiu com o objeto rel´ ogio, logo, podem existir intera¸co ˜es entre os objetos. Uma informa¸caõ de um rel´ ogio-padrão (a hora certa) foi usada para acertar outro rel´ ogio. Observe que um objeto também pode acessar diretamente informa¸co˜es de outros objetos. Você também sabe que existe uma f´ abrica de rel´ ogios e que nela est˜ ao as informa¸co˜es para se construir o rel´ ogio. Veremos que uma classe é uma fábrica de objetos, e é na classe que se encontram as informa¸co ˜es de como montar o objeto. Os conceitos discutidos neste exemplo, atributos, eventos, métodos, agrega¸caõ, heran¸ca, classes, além da abstra¸caõ, s˜ ao os conceitos b´ asicos da POO e já s˜ ao nossos conhecidos. Os mesmos ser˜ ao detalhados no Cap´ıtulo 3– Conceitos Básicos de Orienta¸caõ a Objeto. Programa¸caõ Orientada a Objeto com C++


ˆ 2.3. O CONCEITO DE OBJETO (OU INSTANCIA)

2.3

63

O conceito de objeto (ou instˆ ancia)

Objetos s˜ ao coisas do mundo real ou imaginário que podemos, de alguma forma, identificar, como uma pedra, uma caneta, um copo ou uma fada. Segundo [Rezende, 2002], um objeto pode ser uma entidade externa, coisas, unidades organizacionais, lugares, estruturas. • Um objeto possui determinadas propriedades que o caracterizam e que s˜ ao armazenadas nele mesmo. Suas propriedades s˜ ao chamadas de atributos e s˜ ao utilizadas para identificar o estado do objeto. • O objeto interage com o meio e, em fun¸caõ de excita¸co˜es que sofre, realiza determinadas a¸co˜es que alteram o seu estado (seus atributos). Observe que os atributos do objeto n˜ ao s˜ ao est´ aticos, pois sofrem altera¸co˜es com o tempo. Para a AOO (An´ alise Orientada a Objeto), um objeto é uma entidade u ´ nica que re´ une atributos e métodos, ou seja, re´ une as propriedades do objeto e os métodos respons´ aveis pela realiza¸caõ de opera¸co˜es sobre o objeto (as rea¸co˜es ` as excita¸co˜es que sofre). Nota: por conven¸caõ, o nome dos objetos é escrito como em RioDasOstras (e n˜ ao ”Rio das Ostras” ou ”Rio das Ostras”).

2.4

Breve hist´ orico da programa¸c˜ ao orientada a objeto

As linguagens de programa¸caõ de primeira gera¸caõ eram bastante r´ usticas, de baixo n´ıvel (como o Assembler), e obrigavam o programador a conhecer em excesso as caracter´ısticas do hardware que estava usando. Um programa se dirigia para um equipamento espec´ıfico, era extremamente complexo de desenvolver, e n˜ ao podia ser utilizado em outras máquinas. N˜ ao era poss´ıvel reaproveitar os c´ odigos desenvolvidos. Com o passar dos anos, desenvolveram-se novas linguagens de programa¸caõ, que foram desvinculando os programas do hardware, de tal forma que um mesmo c´ odigo poderia ser compilado e executado em diferentes plataformas. Entre as linguagens de segunda gera¸caõ, podemos citar Fortran e Algol. Estas linguagens proporcionaram um grande avan¸co no desenvolvimento do software. Observe que persistiam dois problemas: o executável ainda era espec´ıfico e n˜ ao existia reaproveitamento de c´ odigo. Enquanto o desenvolvimento de hardware se dava a passos largos, o desenvolvimento de softwares estava atrasado cerca de 20 anos. As linguagens de programa¸caõ de terceira gera¸caõ, como C e Pascal, s˜ ao linguagens procedurais, que permitem o uso de programa¸ca õ estruturada, na qual as fun¸co˜es manipulam os dados, mas n˜ ao têm uma liga¸caõ ´ıntima com eles. O enfoque é a implementa¸caõ de módulos de programas que s˜ ao desenvolvidos utilizando metodologias como bottom-up ou top-down. Com o desenvolvimento das técnicas de programa¸caõ estruturada, o problema da falta de reaproveitamento de c´ odigo diminuiu, pois foram desenvolvidas bibliotecas que podiam ser reaproveitadas. Para uma descri¸caõ completa das técnicas de programa¸caõ estruturada, consulte [Martin and McClure, 1993, Sonerviile, 1993, Pressman, 2002]. Mesmo com o surgimento dos primeiros modelos de engenharia de software e das técnicas de programa¸caõ estruturada, as equipes de desenvolvimento sempre tiveram enormes problemas para o desenvolvimento de seus programas. Tinham de partir praticamente do zero para o desenvolvimento de um programa ou reaproveitar muito pouco os c´ odigos e bibliotecas já desenvolvidos. Para solucionar o problema do reduzido reaproveitamento dos c´ odigos, definiu-se melhor a idéia da Programa¸caõ Orientada a Objeto. A POO n˜ ao é nova; sua formula¸caõ data de 1960, Programa¸caõ Orientada a Objeto com C++


64

´ ˜ ORIENTADA A OBJETO 2.4. BREVE HISTORICO DA PROGRAMAC ¸ AO

mas passou a ser efetivamente utilizada a partir da década de 1990, de modo que todas as grandes empresas de inform´ atica têm desenvolvido os seus softwares utilizando a POO. A programa¸caõ orientada a objeto é diferente da programa¸caõ estruturada. Nela, fun¸co˜es e dados est˜ ao juntos, formando o objeto. Essa abordagem cria uma nova forma de analisar, projetar e desenvolver programas; uma forma mais abstrata e genérica, que permite maior reaproveitamento dos c´ odigos e facilita a sua manuten¸caõ. Observe que a POO n˜ ao é somente uma nova forma de programar, mas uma nova forma de pensar um problema, utilizando conceitos do mundo real e n˜ ao conceitos computacionais. Por exemplo: o usuário final ver´ a todos os ´ıcones e janelas da tela como objetos e associará a manipula¸caõ desses objetos visuais ` a manipula¸caõ dos objetos reais que eles representam. Um ´ıcone impressora representar´ a a impressora de seu sistema computacional e permitirá a execu¸caõ de impressão, a sele¸caõ do tamanho da p´ agina, entre outras opera¸co˜es realizadas com esse objeto. Na modelagem orientada a objeto, o conceito de objeto deve acompanhar todo o ciclo de desenvolvimento do software. Ela também inclui uma nova nota¸caõ e exige do analista/programador o conhecimento desta (diagramas). Em resumo, ”A essência do desenvolvimento orientado a objeto é a identifica¸caõ e a organiza¸caõ de conceitos da aplica¸caõ, tendo como pe¸ca b´ asica de todo desenvolvimento o conceito ´ um modo de pensar natural e universal e n˜ de objeto. E ao uma técnica de programa¸caõ”. [Blaha and Rumbaugh, 2006]. As linguagens de programa¸caõ mais modernas permitem que um programa seja compilado e executado em diferentes plataformas. Em alguns casos, o código binário do programa pode ser executado em diferentes plataformas, sem necessidade de recompila¸caõ e com grande reaproveitamento de c´ odigo. Atualmente existem centenas de bibliotecas cuidadosamente desenhadas para dar suporte aos programadores menos sofisticados, de modo que estes podem montar seus programas unindo as bibliotecas externas com alguns objetos que criaram, ou seja, podem montar suas aplica¸co˜es rapidamente, contando com módulos pré-fabricados. O paradigma da POO é, como veremos a seguir, uma resposta eficiente a uma série de problemas da área de desenvolvimento de software. ´ Veremos exemplos de bibliotecas externas na se¸caõ ?? – Bibliotecas Uteis.

2.4.1

Vis˜ ao desorganizada e vis˜ ao estruturada versus vis˜ ao orientada a objeto

Esta se¸caõ apresenta três formas de desenvolvimento de um programa simples, o qual realiza a integra¸caõ numérica de uma fun¸caõ parabólica. Mesmo n˜ ao entendendo nada de métodos numéricos, você deve ler esse exemplo; o que importa é o conceito abordado. Especifica¸caõ: quero desenvolver um programa que realize a integra¸caõ numérica da equa¸caõ de uma par´ abola y = a + b.x + c.x2 , no intervalo que vai de limiteInferior a limiteSuperior, usando 100 subintervalos (numeroPontos = 100). Vis˜ ao desorganizada O programador desorganizado come¸ca imediatamente a desenvolver o seu programa. Cria um arquivo u ´ nico no qual define as vari´ aveis, a fun¸caõ e finalmente inclui o c´ odigo para realizar a integra¸caõ pelo método de Simpson (porque é o que ele conhece e domina). Os nomes das vari´ aveis s˜ ao v1 (o valor de y), v2 (o a da equa¸caõ), v3 (o b), v4 (o c), v5 (ele n˜ ao utiliza, mas deixa definida). Define ainda s1, s2, s3 e s4 (vari´ aveis utilizadas pelo método de integra¸caõ). Programa¸caõ Orientada a Objeto com C++


´ ˜ ORIENTADA A OBJETO 2.4. BREVE HISTORICO DA PROGRAMAC ¸ AO

65

O programa funcionar´ a; o programador ent˜ ao dar´ a um nome como prog1 e o armazenar´ a num diret´ orio qualquer. Depois de um mês, ele j´ a n˜ ao se lembra mais do nome do programa e de onde o guardou, e agora precisa desenvolver um programa de integra¸caõ para uma outra fun¸caõ. Bem, come¸ca tudo de novo, pois, mesmo que localize o arquivo, n˜ ao se lembrará do que significa v1, v2 etc. Vis˜ ao estruturada Na visão estruturada o programador se preocupa em dividir/separar as fun¸co˜es. Em um arquivo prog.cpp, o usu´ ario inclui as bibliotecas-padrão do sistema que utilizará. O usuário declara fun¸co˜es globais, uma para c´ alculo da fun¸caõ parabólica y = f(x) = a + b.x + c.x2 ;, e outra para c´ alculo da integral com o nome AreaSimpson(f, limiteInferior, limiteSuperior, numeroPontos);. Uma fun¸caõ principal main() é encarregada da entrada de dados, da chamada da fun¸caõ AreaSimpson(f, limiteInferior, limiteSuperior, numeroPontos); e da sa´ıda dos resultados. Observe que, com uma vis˜ ao estruturada, o programa apresentar´ a alguma organiza¸caõ. Vis˜ ao orientada a objeto Na visão orientada a objeto todo o desenvolvimento do software é feito de forma diferente. A inten¸caõ nunca é a de resolver um problema u ´ nico e imediato. 1. Especifico com clareza o que quero: resolver uma integra¸caõ numérica de uma equa¸caõ genérica por qualquer método. 2. Elaboro melhor o problema, estudando materiais relacionados ao programa a ser desenvolvido, lendo alguns livros de matemática e métodos numéricos relacionados ao tema. 3. Em seguida, fa¸co uma an´ alise para identificar os objetos e seus relacionamentos. Ao olhar um livro de métodos numéricos, descubro que existe um conjunto de métodos que podem ser utilizados para resolver o problema. As equa¸co˜es podem ser as mais diversas poss´ıveis, mas possuem algumas caracter´ısticas em comum. A fun¸caõ parabólica obedece à forma y = f(x). Com rela¸caõ aos métodos numéricos, ela identifica os métodos mais conhecidos: Trap´ ezio, Simpson e Gauss, que possuem em comum atributos como limiteInferior, limiteSuperior, numeroPontos e o intervalo dx. Assim, identificam-se alguns objetos: i) um objeto genérico de integra¸caõ numérica, um objeto de integra¸caõ por Simpson, outro por Trap´ ezio e outro por Gauss; ii) um objeto fun¸caõ da forma y = f(x), que tem os atributos y, x; e- iii) um método de c´ alculo que executa a fun¸caõ em si. O objeto integra¸caõ deve receber o objeto fun¸caõ e realizar a integra¸caõ dessa fun¸caõ. 4. Antes de iniciar o desenvolvimento do programa, o programador deve considerar as caracter´ısticas da linguagem que vou utilizar e do hardware que est´ a dispon´ıvel. Devo revisar a an´ alise desenvolvida considerando o hardware e a linguagem de programa¸caõ escolhida. 5. Agora sim, come¸co a escrever o programa, que utiliza uma nota¸caõ uniforme. 6. Finalmente o programa é testado e os erros (bugs) s˜ ao eliminados. 7. N˜ ao me esque¸co de documentar tudo o que foi feito, para que possa reaproveitar o programa em uma outra ocasi˜ ao. A documenta¸caõ também ajuda nas etapas de teste e manuten¸caõ. 8. O programa final é armazenado em um repositório, podendo ser facilmente localizado, reaproveitado e/ou extendido. Programa¸caõ Orientada a Objeto com C++



66

2.4.2

Vantagens da POO

Comparando a visão desorganizada e a vis˜ ao estruturada com a visão orientada a objeto, podemos identificar as seguintes vantagens da POO: • Os objetos s˜ ao representa¸co˜es de conceitos j´ a conhecidos. • Os objetos, as fun¸co˜es e as vari´ aveis têm nomes claros e precisos. • Os objetos se relacionam da forma esperada, de modo que um programador iniciante ter´ a uma visão facilitada do programa. • Os diagramas desenvolvidos na etapa de an´ alise facilitam o entendimento de todo o programa (os diagramas ser˜ ao apresentados no Cap´ıtulo 6 – Etapas para o Desenvolvimento de um Programa). • O programa é documentado, facilitando o reaproveitamento dos c´ odigos desenvolvidos. • O trabalho desenvolvido é gravado como uma biblioteca de objetos em um local adequado (normalmente um reposit´ orio). Para desenvolvedores, programadores, analistas ou gerentes, as vantagens da POO podem ser resumidas a: • Gerentes – maior velocidade e menores custos no desenvolvimento do programa. • Analistas e desenvolvedores – processo de modelagem mais simples, com maior reaproveitamento de c´ odigos e facilidade de manuten¸caõ. • Programadores – aumento da produtividade.

2.5


Neste cap´ıtulo vimos que C e Pascal s˜ ao linguagens procedurais, de terceira gera¸caõ, e que a linguagem C++ pode ser considerada uma linguagem de quinta gera¸caõ. Destacamos que a programa¸caõ orientada a objeto é mais natural e organizada que a programa¸caõ estruturada e ficamos conhecendo as vantagens da POO, como a maior velocidade e o aumento da produtividade no desenvolvimento de sistemas complexos. Passamos a entender o conceito de objeto e vimos que os conceitos utilizados na POO s˜ ao nossos conhecidos. No Cap´ıtulo 3 – Conceitos Básicos de Orienta¸caõ a Objeto, aprenderemos os conceitos de abstra¸caõ, encapsulamento, objeto, heran¸ca e polimorfismo. Depois, no Cap´ıtulo 4 – Modelagem Orientada a Objeto, analisaremos a vantagem do uso de modelos, o histórico e o uso da UML Veremos ainda a evolu¸caõ histórica do ciclo de desenvolvimento de um software no Cap´ıtulo 5 – Engenharia de software. Finalmente, no Cap´ıtulo 6– Etapas para o desenvolvimento de um software, descrevemos todo o ciclo de desenvolvimento de um software

2.6

Exerc´ıcios

1. Procure na internet material que compare a programa¸caõ estruturada e a programa¸caõ orientada a objeto. Fa¸ca um resumo comparativo. 2. Diga, com suas palavras, as principais diferen¸cas entre a visão estruturada e a visão orientada a objeto. Programa¸caõ Orientada a Objeto com C++


2.6. EXERCÍCIOS

67

3. Quais as desvantagens da POO? 4. Quando estiver dentro de um carro, procure identificar quais s˜ ao os objetos agregados (que fazem parte do carro). 5. Pense num carro de 40 anos atr´ as. Quais as principais diferen¸cas em rela¸caõ a um carro atual? 6. Para um objeto impressora, quais s˜ ao seus atributos? Quais s˜ ao seus métodos? 7. Releia a se¸caõ 2.2 – Exemplo de objeto e verifique que os conceitos apresentados – objetos, atributos, fun¸co˜es, composi¸caõ, evolu¸caõ, heran¸ca, intera¸co˜es – s˜ ao conceitos que já conhecemos, ou seja, a orienta¸caõ a objetos já faz parte de nosso dia-a-dia. Você concorda com esta afirma¸caõ? 8. Diga com suas palavras o que é um objeto? 9. Quando estiver em casa, fa¸ca uma an´ alise dos atributos e das fun¸co˜es dos objetos: sofá, televisor, mesa, cadeira, escrivaninha, torneira etc. 10. Para cada grupo de objetos ou de palavras a seguir, identifique as caracter´ısticas em comum e depois suas diferen¸cas: • Pasta, mala, mochila. • Cadeira, poltrona, sof´ a. • Carro, caminh˜ ao, trator. • Winchester, zip drive, CD-RW, DVD-RW, pen-drive. 11. Separe alguns objetos reais e procure identificar seus atributos, funcionalidades e como os mesmos interagem com outros objetos.



68


2.6. EXERCÍCIOS


Cap´ıtulo 3

Conceitos B´ asicos de Orienta¸c˜ ao a Objeto – OO A Orienta¸caõ a Objeto (OO) tem uma série de conceitos-chave que auxiliam as pessoas a delinearem claramente um problema e a identificarem os objetos e seus relacionamentos. Neste cap´ıtulo descreveremos alguns conceitos b´ asicos de OO: abstra¸caõ (se¸caõ 3.1), encapsulamento e oculta¸caõ (se¸caõ 3.2), classes (se¸caõ 3.3), atributos (propriedades/vari´ aveis) (se¸caõ 3.4), métodos (fun¸co˜es/opera¸co˜es/servi¸cos) (se¸caõ 3.5), heran¸ca (se¸caõ 3.6) e polimorfismo (seçaõ 3.7). Ao final, ser˜ ao apresentados outros conceitos u ´ teis (se¸caõ 3.8).

3.1

Abstra¸c˜ ao

No dicion´ ario Aurélio, abstra¸caõ significa considerar isoladamente coisas que est˜ ao unidas, ou seja, partimos do enfoque global de um determinado problema e procuramos separar os elementos fundamentais e coloc´ a-los de uma forma mais próxima da solu¸caõ. A idéia da abstra¸caõ é identificar os elementos essenciais de um problema e suas propriedades fundamentais, separando ocorrências e atributos acidentais (isolando detalhes menos importantes). Para a an´ alise orientada a objeto, abstra¸caõ é o processo de identifica¸caõ dos objetos e seus relacionamentos. Ela permite ao analista concentrar-se no que um objeto é e faz, sem se preocupar como ele o faz. A abstra¸caõ se d´ a em diferentes n´ıveis: inicialmente, abstrai-se o objeto; em seguida, procuramos identificar seus atributos e funcionalidades. De um conjunto de objetos, cria-se um conjunto de classes relacionadas, geralmente uma hierarquia ou um assunto. Por exemplo: em nossa sala de aula temos um interruptor e lˆ ampadas. Todos sabemos que o interruptor é o objeto a ser acionado para que a lˆ ampada acenda/apague. Existe uma clara rela¸caõ entre o interruptor e a lˆ ampada. Juntamente com os fios e o disjuntor eles formam o sistema de ilumina¸ca õ. Observe as Figuras 3.1 (a) e 3.1 (b). Qual imagem é mais confusa? Em 3.1(a), est˜ ao representados elementos do sistema de ilumina¸caõ, do sistema de telefonia, do cluster e os computadores da sala. A Figura 3.1(b) é mais simples, pois eliminamos os detalhes que n˜ ao s˜ ao importantes, deixando apenas os elementos essenciais ao sistema de ilumina¸caõ. A partir da Figura 3.1(b), podemos identificar mais claramente os objetos do sistema de ilumina¸caõ. 69

˜ 3.2. ENCAPSULAMENTO E OCULTAC ¸ AO

70

Observe que podemos ver o interruptor e a lˆ ampada como sendo um objeto u ´ nico ou como dois objetos que se relacionam. Outra percep¸caõ importante: nossa vis˜ ao natural. Nossos conceitos b´ asicos enfocam os objetos e n˜ ao os sistemas dos quais fazem parte. Por exemplo: focamo-nos no objeto lˆ ampada, no objeto interruptor, e n˜ ao no sistema de ilumina¸caõ. Finalmente é importante destacar que uma boa abstra¸caõ do sistema é conseguida ap´ os várias itera¸co˜es, muita an´ alise e um pouco de experiência. Figura 3.1: O processo de abstra¸caõ.

Quadro de distribuição

Quadro de distribuição lâmpada

servidor

lâmpada

interruptor

lâmpada

lâmpada

interruptor

caixa de atividades sistema telefonico A0

(a)

(b)

No exemplo da Figura 3.1 identificamos os seguintes objetos: • Quadro de distribui¸caõ • Fios • Interruptor • Lˆ ampadas

3.2

Encapsulamento e oculta¸c˜ ao

Todos os equipamentos que utilizamos s˜ ao altamente encapsulados. Tome como exemplo seu monitor de computador. Ele tem um pequeno conjunto de botões que lhe permitem manipular os atributos do objeto monitor que s˜ ao de seu interesse, como: ligar/desligar, controlar o brilho, o contraste, a resolu¸caõ. Mas você sabe que o funcionamento do objeto monitor é extremamente complexo e que, ao mudar a resolu¸caõ, uma série de atributos internos s˜ ao processados e alterados. Um monitor CRT tem um tubo de raios cat´ odicos, dezenas de fios, placas internas, resistores, capacitores e uma infinidade de dispositivos elétricos que est˜ ao ocultos, encapsulados, escondidos do usuário; ou seja, o encapsulamento separa o que é vis´ıvel (p´ ublico) do que é oculto (protegido/privado). Na Figura 3.2, temos a imagem de dois monitores: em (a) a visão de um usuário comum; em (b) a vis˜ ao de um engenheiro eletricista. A vis˜ ao de cada um é diferente, depende de suas especialidades. Observe que os engenheiros eletricistas fizeram um bom trabalho de encapsulamento, deixando acess´ıvel apenas o que é de nosso efetivo interesse. Programa¸caõ Orientada a Objeto com C++


˜ 3.2. ENCAPSULAMENTO E OCULTAC ¸ AO

71

Figura 3.2: O que você vê?

(a) A vis˜ ao do usu´ ario.

(b) A vis˜ ao do engenheiro.

Exemplos: • Um computador é um objeto extremamente complexo, mas para o usuário o que importa é o teclado, o monitor de v´ıdeo, o DVD, o mouse e o gabinete. • Ao utilizar um software como o OpenOffice, a forma de uso é a mesma, seja em um Windows com Pentium IV ou em um GNU/Linux com AMD Athlon 64. Os elementos invis´ıveis do computador (placa-mãe, processador e memória) e do sistema operacional n˜ ao alteram a forma de uso do programa. • As propriedades f´ısicas de um determinado material de constru¸caõ (telha) e os métodos de c´ alculo de suas propriedades (resistência à compressão, condutividade térmica etc.). Aqui, a telha é o objeto, as propriedades s˜ ao seus atributos e o c´ alculo de suas propriedades s˜ ao os métodos. Para o usu´ ario o que interessa s˜ ao as propriedades conhecidas, e n˜ ao as equa¸co˜es, as vari´ aveis intermedi´ arias e a forma de c´ alculo, pois isto fica escondido. Para a an´ alise orientada a objeto, encapsulamento é o ato de esconder do usuário informa¸co˜es que n˜ ao s˜ ao de seu interesse. O objeto atua como uma caixa preta, que realiza determinada opera¸caõ, mas o usu´ ario n˜ ao sabe, e n˜ ao precisa saber, exatamente como é feita; ou seja, o encapsulamento envolve a separa¸caõ dos elementos vis´ıveis de um objeto dos invis´ıveis. Os elementos vis´ıveis formam a interface de acesso ao objeto. Veja a seguir um exemplo: • Em um programa que calcula a ´ area da curva normal, o c´ alculo interno pode ser realizado por um polinômio que aproxima a ´ area da normal ou pela integra¸caõ numérica da equa¸caõ da normal. A decis˜ ao de qual método de c´ alculo ser´ a utilizado é realizada pelo objeto TNormal em fun¸caõ de um atributo interno, o limiteErro. O usuário externo cria o objeto TNormal, informa o limite de erro e solicita o c´ alculo da área. O usuário n˜ ao sabe qual método de c´ alculo ser´ a utilizado, pois isto fica escondido. A vantagem do encapsulamento surge quando ocorre a necessidade de se modificar um programa existente. Por exemplo: você pode modificar todas as opera¸co˜es invis´ıveis de um objeto (os sistemas internos), para melhorar o desempenho dele, sem se preocupar com o resto do programa. Como estes métodos n˜ ao s˜ ao acess´ıveis ao resto do sistema, eles podem ser modificados sem causar efeitos colaterais. Programa¸caõ Orientada a Objeto com C++


72

3.3. CLASSES

Segundo [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006], ”o encapsulamento evita que um programa se torne t˜ ao interdependente que uma pequena modifica¸caõ tenha um efeito de propaga¸caõ grave”. [Pressman, 2002] lembra que ”os detalhes internos de implementa¸caõ dos dados e procedimentos s˜ ao ocultados do mundo exterior (oculta¸caõ de informa¸caõ). Isso reduz a propaga¸caõ de efeitos colaterais quando ocorrem modifica¸co˜es”. Segundo [Parga, 2006], ”como conseq¨ uência do encapsulamento temos uma diminui¸caõ consider´ avel do n´ıvel de acoplamento entre as classes que fazem parte do sistema. O n´ıvel de acoplamento é avaliado pela interdependência entre os c´ odigos de duas ou mais classes, ou seja, o quanto o funcionamento de uma determinada classe é afetado por altera¸co˜es em uma outra classe que interaja com ela. O encapsulamento permite a implementa¸caõ de uma abstra¸caõ com a separa¸caõ clara entre a interface com o usuário e a implementa¸caõ”.

3.3

Classes

Quando falamos de classes, lembramo-nos de classes sociais, de classes de objetos da natureza, de hierarquias (por exemplo, a classe dos animais vertebrados). De um modo geral, uma classe descreve um grupo de objetos com os mesmos atributos e comportamentos, além dos mesmos relacionamentos com outros objetos. Veja a seguir alguns exemplos de classes: • Cachorros – buldogue, pastor alem˜ ao, vira-lata. • Rel´ ogios – de ponteiro, digital, com alarmes, com cronˆ ometros, com calculadoras. A classe contém a descri¸caõ da forma do objeto; é um molde para a cria¸caõ do objeto, é uma fábrica de objetos. Uma classe também é um tipo definido pelo usuário. Para a an´ alise orientada a objeto, uma classe é um conjunto de c´ odigos de programa¸caõ que incluem a defini¸caõ dos atributos e dos métodos necess´ arios à cria¸caõ de um ou mais objetos. Grady Booch [Booch, 1986], diz que ”um objeto é uma entidade concreta que existe no tempo e no espa¸co, uma classe representa apenas uma abstra¸caõ, a essência do objeto”. [Blaha and Rumbaugh, 2006] lembra que ”qualquer escolha de classe é arbitrária e depende da aplica¸caõ”. No exemplo da Figura 3.3 apresentamos um rel´ ogio e um cachorro. Podemos associar a estes dois objetos uma classe e uma classe Cachorro. Figura 3.3: Um rel´ oogio e um cachorro.



´ 3.4. ATRIBUTOS (PROPRIEDADES E VARIAVEIS)

3.4

73

Atributos (propriedades e vari´ aveis)

Podemos relacionar alguns atributos (propriedades) a todo objeto. No exemplo do rel´ ogio, podemos relacionar a hora e a data. Uma cadeira pode ser branca ou preta, ter apoio para os bra¸cos, ter rodinhas. Um monitor de computador pode ter 15”, 17”, 19” ou 21” (polegadas) e sua resolu¸caõ máxima em pixels pode ser 1024x768, 1280x1024, 1600x1280; ou seja, todo objeto tem seus próprios atributos, propriedades. Os atributos do objeto s˜ ao utilizados para diferenciar os objetos e para identificar o estado do objeto. Na programa¸caõ orientada a objeto, os atributos s˜ ao definidos na classe e armazenados de forma individual ou coletiva pelos objetos. • Quando um atributo é individual (ou de instância), ele é armazenado no objeto. Exemplo: A hora de um rel´ ogio. Cada rel´ ogio tem uma hora, que pode ou n~ ao estar certa. • Quando um atributo é compartilhado entre todos os objetos de uma classe, ele é armazenado nela e é conhecido como atributo coletivo ou de classe. Este tipo de atributo define uma caracter´ıstica de toda classe. Exemplo: Um contador de rel´ ogios criados. • Quando um atributo n˜ ao muda nunca, ele é denominado constante. Exemplo: O n´ umero constante pi = 3.1415... Veremos na se¸caõ 6.4.2 como identificar os atributos usando AOO, e na se¸caõ 6.4.4, como representar os atributos usando UML. No Cap´ıtulo 12 – Atributos, veremos como implementar os conceitos de atributos em C++.

3.5

M´ etodos (fun¸c˜ oes, opera¸c˜ oes e servi¸cos)

Podemos relacionar determinados comportamentos, fun¸co˜es, opera¸co˜es, a¸co˜es e rea¸co˜es a um objeto. Veja a seguir alguns exemplos: • Um autom´ ovel tem o comportamento de se locomover. • Uma edifica¸caõ tem a fun¸caõ de dar abrigo. • Um equipamento de medi¸caõ é utilizado para realizar medidas. • Um computador processa os programas, realizando as opera¸co˜es codificadas. • Um meio poroso permite o fluxo de massa. Na an´ alise orientada a objeto, as fun¸co˜es, opera¸co˜es e os comportamentos dos objetos s˜ ao descritos pelos métodos, os quais também servem para manipular e alterar os atributos do objeto (alteram o estado do objeto). Em um programa orientado a objeto os est´ımulos s˜ ao representados por eventos. Por exemplo: um evento ocorre quando o usu´ ario clica o mouse sobre o ´ıcone impressora, o qual envia uma mensagem para o objeto impressora solicitando a impressão do arquivo selecionado. O método Imprimir() recebe o nome do arquivo a ser impresso, realiza a impressão do mesmo Programa¸caõ Orientada a Objeto com C++


74

3.6. HERANCA ¸

e ent˜ ao retorna um flag indicando que a opera¸caõ de impressão terminou com sucesso ou falhou. Observe que o objeto impressora é representado na tela por seu ´ıcone. Na maioria dos programas, um item de menu é usado para acessar um diálogo com propriedades do objeto impressora. Podemos dizer que um método é uma opera¸caõ realizada sobre um objeto e é descrito por uma classe. Um método é a implementa¸caõ de uma opera¸caõ. S˜ ao elementos de um método: • Retorno – todo método retorna um objeto ap´ os sua execu¸caõ. • Nome – o nome de um método deve identificar com clareza o que ele faz. • Parˆ ametros – s˜ ao as vari´ aveis e objetos passados para o método para realiza¸caõ de suas tarefas. Veremos na se¸caõ 6.4.3 como identificar os métodos usando AOO, e na se¸caõ 6.4.4, como representar os métodos usando UML. No Cap´ıtulo 13 – Métodos, veremos como implementar os métodos em C++. Veremos também, na se¸caõ 3.6, que, numa hierarquia de classes, métodos com a mesma assinatura podem apresentar comportamento polim´ orfico. Observe ainda que todos os objetos criados a partir de uma mesma classe-base compartilham os métodos da classe.

3.6

Heran¸ca

A heran¸ca est´ a relacionada ` as hierarquias e ` as rela¸co˜es entre os objetos. No dia-a-dia, quando se fala de heran¸ca, refere-se ` a transferência de propriedades de um pai aos seus filhos, ou seja, aquilo que é do pai passa a ser do filho. ´ comum ainda o dito popular ”puxou o pai”, que significa que o filho tem as mesmas E caracter´ısticas do pai. De uma maneira geral, as pessoas sabem que o filho assemelha-se ao pai, mas n˜ ao s˜ ao a mesma pessoa. Além disso, o filho apresenta determinadas caracter´ısticas diferentes de seu pai. Veja a seguir outros exemplos: • Um processador Pentium IV tem preservadas todas as caracter´ısticas do Pentium III, mas acrescentou mais mem´ oria cache (a mem´ oria cache já existia, mas foi ampliada). Alguns modelos apresentam a tecnologia de Hyper-Threading que antes n˜ ao existia. • Uma placa-m˜ ae nova apresenta a interface USB; trata-se de uma novidade que antes também n˜ ao existia. Na an´ alise orientada a objeto, heran¸ca é o mecanismo em que uma classe-filha herda automaticamente todos os atributos e métodos de sua classe-pai (classe-base). Heran¸ca é a propriedade de podermos criar classes que se ampliam a partir de defini¸co˜es b´ asicas. De classes mais simples e genéricas para classes mais complexas e espec´ıficas. A heran¸ca permite criar classes-filhas implementando apenas os métodos e atributos que se diferenciam da classe-pai. A maior vantagem do uso do conceito de heran¸ca est´ a associada à compreensão de que os objetos que fazem parte da heran¸ca têm o mesmo comportamento, possibilitando um maior reaproveitamento de c´ odigo com conseq¨ uente aumento da seguran¸ca. Existem dois tipos de heran¸ca: Programa¸caõ Orientada a Objeto com C++


3.7. POLIMORFISMO

75

• Heran¸ ca simples – ocorre quando uma classe herda as propriedades de uma u ´ nica classe-pai. • Heran¸ ca m´ ultipla1 – ocorre quando uma classe tem mais de um pai. Exemplo: heran¸ca de comportamento; muitas vezes dizemos que um menino herdou o jeito engra¸cado do tio e é estudioso como o pai, ou seja, o menino herdou caracter´ısticas comportamentais de mais de uma pessoa. Antecipando um pouco nosso estudo, veja na Figura 3.4 como representamos pela UML o conceito de heran¸ca. Observe que evolu´ımos de um rel´ ogio que s´ o tem hora para um rel´ ogio com hora e data. A seguir temos um rel´ ogio com hora, data e cronˆ ometro. O nosso modelo mais moderno tem embutido uma calculadora. Observe que temos heran¸ca-m´ ultipla, uma vez que o rel´ ogio com calculadora é uma mistura de um rel´ ogio com uma calculadora. Figura 3.4: Uma hierarquia de rel´ ogios. Relogio

Calculadora

+hora: int

RelogioData RelogioCalculadora +hora: int +data: int

+hora: int +data: int +tempoCronometro +calculadora: void

RelogioDataCronometro +hora: int +data: int +tempoCronometro

Na Figura 6.12 a classe-base é Rel´ ogio. Esta possui um atributo, a hora, e dois métodos usados para ler a Hora() ou acertar a Hora(int horaCerta). A classe Rel´ ogioAlarme é herdeira de Rel´ ogio, recebendo automaticamente os atributos e métodos definidos em Rel´ ogio. Ademais, esta acrescenta o atributo horaAlarme, alarmeAtivo e os métodos para ler e definir a hora em que o alarme deve tocar. Veremos na se¸caõ 6.4.10 como identificar heran¸cas usando AOO, e, na se¸caõ 6.4.11, como representar heran¸cas usando UML. No Cap´ıtulo 17 – Heran¸ca, veremos como implementar heran¸cas em C++, e no Cap´ıtulo 18 – Heran¸ca M´ ultipla, como implementar heran¸ca m´ ultipla. Nota: os termos classe-pai e classe-base s˜ ao sinˆ onimos. O termo superclasse indica a classe mais b´ asica de uma hierarquia. J´ a o termo classe-filha é sinˆ onimo de classe-derivada.

3.7

Polimorfismo

A palavra polimorfismo significa muitas formas e representa o fato de uma determinada caracter´ıstica (por exemplo, a potência do motor do ve´ıculo) ser diferente para cada filho (tipo de ve´ıculo). Quem j´ a andou de Volks e de Mercedes sabe bem a diferen¸ca. 1A

heran¸ca m´ ultipla ´ e utilizada em C++ (n˜ ao sendo dispon´ıvel em Java).



´ 3.8. OUTROS CONCEITOS UTEIS

76

Na natureza, o conceito de polimorfismo é inerente ao processo de desenvolvimento; os seres evoluem, modificam-se. Por exemplo: o homo-sapiens é uma evolu¸caõ de seus ancestrais e tem atributos melhorados e atributos novos. Em suma, estamos partindo de um objeto mais simples e evoluindo, mas os conceitos do objeto-pai continuam a existir nos objetos descendentes, mesmo que tenham sofrido modifica¸co˜es, aperfei¸coamentos e tenham assumido novas formas (polimorfismo). Para a AOO, polimorfismo é o processo de redefini¸caõ dos métodos nas classes-derivadas. Os métodos da classe-base s˜ ao reescritos para realizarem as mesmas tarefas de uma forma mais especializada. O conceito de polimorfismo é fundamental para a an´ alise orientada a objeto; sua aplica¸caõ se fundamenta no uso de uma superclasse, por meio da qual vamos desenvolver nossa hierarquia de classes. Por exemplo: em um programa de simula¸caõ numérica utilizado para calcular a área de uma fun¸caõ, pode-se ter a evolu¸caõ dos métodos de integra¸caõ. Do método do Trap´ ezio para o método de Simpson, para o método de Gauss. O método de Simpson é uma evolu¸caõ do método do Trap´ ezio; seu algoritmo de c´ alculo é um pouco mais complexo, mais especializado, e apresenta resultados mais precisos. No Cap´ıtulo 19 – Polimorfismo, veremos como implementar o polimorfismo em C++.

3.8

Outros conceitos u ´ teis

Apresenta-se aqui, brevemente, outros conceitos relacionados à programa¸caõ orientada a objeto. Ao longo do livro estes conceitos ser˜ ao reapresentados e detalhados com exemplos. Todos estes conceitos s˜ ao suportados por C++, alguns deles s˜ ao suportados por Java. Associado ao conceito de objeto temos os conceitos de instância, identidade, persistência e delega¸caõ: Instˆ ancia ´ um outro nome que se d´ E a ao objeto e que, geralmente, refere-se a um objeto espec´ıfico. Identidade ´ uma propriedade que permite identificar univocamente um objeto. Os objetos se distinE guem por sua própria existência, sendo distintos mesmo que todos os seus atributos sejam iguais, ou seja, existe um u ´ nico identificador para cada objeto. Em C++ o endere¸co do objeto é seu identificador. Persistˆ encia ´ o tempo de vida de um objeto, podendo ser temporário ou permanente: temporário E quando ele s´ o existe durante a execu¸caõ do programa. Por exemplo: um objeto pode ser criado com new e destru´ıdo com delete; permanente quando ele é armazenado em um meio f´ısico, como o disco r´ıgido. A vantagem dos objetos permanentes (persistentes) é que eles podem ser acessados por mais de um programa, pelo mesmo programa em uma outra ocasião, ou como um depósito de dados (banco de dados). Delega¸ c˜ ao ´ o mecanismo pelo qual um objeto transfere a execu¸caõ de uma tarefa para outro. E Veja a seguir outros conceitos relacionados ` a idéia de classe: Tipifica¸ c˜ ao As classes representam os tipos de dados definidos pelo usuário. A tipifica¸caõ é a capacidade de o sistema distinguir as diferentes classes e resolver as convers˜ oes. Veremos os Programa¸caõ Orientada a Objeto com C++



77

conceitos de tipos em C++ no Cap´ıtulo 9 – Tipos. Os conceitos de convers˜ oes ser˜ ao vistos no Cap´ıtulo 25 – Convers˜ oes. Classifica¸ c˜ ao Os objetos com a mesma estrutura de dados e com os mesmos métodos s˜ ao agrupados em uma classe. Todo objeto contém uma referência impl´ıcita à sua classe e sabe a qual classe pertence (identidade). Classes abstratas Uma classe é abstrata quando n˜ ao é completa e n˜ ao pode criar objetos, podendo surgir naturalmente ou pela migra¸caõ de métodos das classes-derivadas para uma classe-base (genérica). Uma classe abstrata costuma ser uma classe de interface. Veremos os conceitos de classes no Cap´ıtulo 11 – Classe. Protocolo ´ o conjunto de métodos p´ E ublicos da classe que podem ser acessados pelo usuário, o conjunto de mensagens a que o objeto responde. O protocolo pode ser definido por uma classe de interface. Classes de interface Interfaces s˜ ao classes abstratas que contêm apenas métodos puros (n˜ ao podem criar objetos). S˜ ao utilizadas para mostrar ao usuário a forma de acesso aos objetos. Veremos as classes de interface na se¸caõ 11.5.2. Responsabilidades Pode-se incluir na descri¸caõ da classe as suas responsabilidades – pequenas frases que descrevem as obriga¸co˜es do objeto. Também podemos incluir a descri¸caõ das colabora¸co˜es (veja na se¸caõ 6.10.2 o uso dos cartões CRC – Classe/Responsabilidade/Colaboradores). Veja a seguir informa¸co˜es adicionais sobre heran¸cas: Nomes de classe Em uma fam´ılia, os filhos e netos compartilham os nomes de seus ancestrais; da mesma forma, em uma hierarquia de classes, os nomes devem ser significativos, semelhantes e esclarecedores. Superclasse Uma superclasse é a classe-base de uma hierarquia de classes; é a classe mais alta na hierarquia (é a origem da ´ arvore). Veremos como implementar heran¸ca em C++ no Cap´ıtulo 17 – Heran¸ca. Compartilhamento As técnicas orientadas a objeto facilitam o compartilhamento de c´ odigo por meio do conceito de heran¸ca. Além do maior compartilhamento do c´ odigo, a an´ alise orientada a objeto reduz a codifica¸caõ em fun¸caõ da maior clareza dos diagramas desenvolvidos. Veja a seguir informa¸co˜es adicionais sobre métodos: Assinatura A assinatura de um método é seu nome, a ordem e o tipo de seus parˆ ametros. Observe que o tipo de retorno n˜ ao faz parte da assinatura. Programa¸caõ Orientada a Objeto com C++


78


Liga¸ c˜ ao est´ atica/dinˆ amica Liga¸caõ é o processo de identificar a posi¸caõ dos métodos a serem executados. Na liga¸caõ est´ atica, o endere¸co dos métodos é definido durante a compila¸caõ do programa. Na liga¸caõ dinâmica, o endere¸co dos métodos é definido somente durante a execu¸caõ do programa. Sobrecarga de m´ etodos: O conceito de sobrecarga de um método esta associado a preserva¸caõ do nome do método, mesmo que este receba tipos ou n´ umero de parˆ ametros diferentes. Por exemplo, um método Soma() poderia realizar a soma de n´ umeros inteiros ou flutuantes, sem a necessidade de se criar SomaInt() e SomaFloat(). Com o conceito de sobrecarga o programador tem de aprender a usar um n´ umero menor de métodos, tendo um aumento de seu desempenho (veremos no Cap´ıtulo 14 - Sobrecarga de Métodos, como implementar sobrecarga de métodos). Sobrecarga de operador Algumas linguagens de programa¸caõ permitem a sobrecarga dos operadores, isto é, um operador + (soma) poderia ser reescrito para os diferentes tipos de objetos criados. Por exemplo: o programador pode definir um operador + que vai atuar sobre n´ umeros complexos. Veremos como implementar sobrecarga de operador em C++ no Cap´ıtulo 21 – Sobrecarga de operador. Cancelamento ´ a substitui¸caõ de um método da classe-base por outro na classe-derivada. Pode ocorE rer com os seguintes objetivos: cancelamento para extensão (amplia¸caõ das tarefas que eram realizadas), cancelamento para restri¸caõ (quando a tarefa n˜ ao é mais necess´ aria), cancelamento para otimiza¸caõ (quando se deseja aumentar o desempenho), cancelamento por conveniência (quando o cancelamento pode ser conveniente por um motivo qualquer; deve ser evitado pois os métodos n˜ ao devem ser substitu´ıdos com a finalidade de terem um comportamento diferente do esperado). Veja a seguir outros conceitos u ´ teis: Friend (ou amizade) Um desconhecido n˜ ao tem acesso ` a sua casa, aos seus bens pessoais. Um amigo pode entrar na sua casa e fazer uso de alguns objetos. A programa¸caõ orientada a objeto funciona da mesma forma. Você pode criar objetos diferentes e informar que um objeto A é amigo do objeto B, podendo acessar determinadas funcionalidades de B. Veremos a implementa¸caõ do conceito de amizade no Cap´ıtulo 20 – Friend. Ponteiros Em C/C++, um ponteiro é um objeto pequeno que aponta para outro objeto (que pode ser grande). Ponteiros s˜ ao muito utilizados em C/C++ e ser˜ ao vistos em detalhes no Cap´ıtulo 15 – Ponteiros, Referências e Gerenciamento de Mem´ oriae no Apêndice F – Uso Avan¸cado de Ponteiros. Referˆ encias C++ acrescentou o conceito de referências, um tipo de apelido que substitui em grande parte o uso de ponteiros (veja como usar referências em C++ no Cap´ıtulo 15 – Ponteiros e referências). Convers˜ oes Em um programa real é comum a necessidade de se converter um objeto de um tipo para Programa¸caõ Orientada a Objeto com C++



79

outro. Por exemplo: um determinado método espera receber como parˆ ametro um n´ umero flutuante, mas o programador passou um n´ umero inteiro. Neste caso, o n´ umero inteiro vai ser convertido para flutuante. Veremos como implementar convers˜ oes em C++ no Cap´ıtulo 25 – Convers˜ oes. Templates O conceito de template est´ a associado ao uso de programa¸cão genérica, a qual é extensivamente utilizada na STL – Standard Template Library. Veja os conceitos de templates no Cap´ıtulo 27 – Templates (ou Gabaritos). A STL ser´ a vista a partir do Cap´ıtulo 31 – Introdu¸caõ ` a Biblioteca Padr˜ ao de Gabaritos de C++ (STL). Exce¸ co ˜es O problema de erros em programas e sua solu¸caõ sempre foi complicado. O uso cada vez mais intenso de interfaces elaboradas e a necessidade de se terminar o projeto em tempo limitado provocam a ocorrência de um n´ umero cada vez maior de erros em programas. Veremos como implementar solu¸co˜es para tratamento de erros utilizando os conceitos de exce¸co˜es no Cap´ıtulo 26 – Exce¸co˜es. Modularidade Um programa pode ser desenvolvido utilizando-se módulos que podem ser compilados separadamente. Um módulo costuma ser constru´ıdo a partir de um conjunto de classes relacionadas (geralmente um assunto). Em C++ os assuntos são empacotados com o uso da palavra-chave namespace; também é usual separar a defini¸caõ das classes de sua implementa¸caõ (arquivos .h e .cpp). Pacotes Um pacote é um conjunto de classes mais fortemente relacionadas entre s´ı. Costumam fazer parte do mesmo assunto. Evento Um evento pode ser um est´ımulo provocado por um sistema externo ou interno. Um evento provoca a mudan¸ca do estado de um objeto, representa uma a¸caõ que ocorre em determinado tempo e tem dura¸caõ zero. Atividade Uma atividade é uma opera¸caõ que demora um determinado tempo para ser executada. Sinergia Os conceitos da an´ alise orientada a objeto apresentam um efeito de sinergia (soma de qualidades), em que a soma dos diversos conceitos da AOO implicam em um resultado mais positivo que o esperado.

3.9


Neste cap´ıtulo aprendemos alguns conceitos b´ asicos de OO, como a idéia da abstra¸caõ, que consiste em simplificar os sistemas eliminando detalhes, ou ent˜ ao o conceito de encapsulamento ou ocultamento da informa¸caõ cujo objetivo é simplificar o objeto, permitindo ao usuário ver apenas o que ser´ a efetivamente utilizado. Vimos ainda exemplos reais e imaginários de classes e objetos, com suas propriedades e funcionalidades. Relembramos o conceito de heran¸ca e tivemos uma idéia do conceito de polimorfismo. No final do cap´ıtulo vimos um conjunto de conceitos que ser˜ ao melhor descritos ao longo do livro. Programa¸caõ Orientada a Objeto com C++


3.10. EXERCÍCIOS

80

Apresentaremos, no Cap´ıtulo 4 – Modelagem Orientada a Objeto, o que é um modelo e porque usamos modelos, o que é a UML e quais seus diagramas. Veremos no Cap´ıtulo 5 – Engenharia de Software, o que é, quais as caracter´ısticas e alguns modelos conhecidos de engenharia de software. No Cap´ıtulo 6 – Etapas para o Desenvolvimento de um Programa, ser´ a apresentada em detalhes uma metodologia para desenvolvimento de programas orientados a objeto usando os diagramas da UML.

3.10

Exerc´ıcios

1. Descreva, com suas palavras, os conceitos de: abstra¸caõ, classe, heran¸ca, atributos e métodos. 2. Fale das vantagens de se usar o conceito de encapsulamento. 3. Descreva, de forma objetiva, as diferen¸cas entre classe, objeto e heran¸ca. 4. Descreva o que os objetos em cada uma das listas abaixo têm em comum (caracter´ısticas e a¸co˜es em comum). • prateleira, estante, armário; • moto-serra, faca, tesoura, estilete, machado; • prego, parafuso, pino rebite; • carro, caminh˜ ao, trator, motocicleta; • televisão, monitor, display de cˆ amera digital, display de filmadora. 5. Nas aplica¸co˜es a seguir s˜ ao utilizadas estruturas de suporte. Para cada uma delas, fa¸ca uma lista de caracter´ısticas que sejam importantes e explique a importˆ ancia de cada caracter´ıstica para a aplica¸caõ. • Estrutura met´ alica de um edif´ıcio. • Estrutura met´ alica de um avi˜ ao. • Estrutura met´ alica de uma plataforma de petr´ oleo. 6. Descreva as principais caracter´ısticas do paradigma de orienta¸caõ a objeto. 7. Fa¸ca uma r´ apida revis˜ ao dos termos descritos neste cap´ıtulo. Observe que s˜ ao termos conhecidos, que você provavelmente j´ a utilizou, ou seja, a orienta¸caõ a objetos usa termos e conceitos conhecidos, facilitando seu entendimento e uso. 8. Porque devemos usar o conceito de abstra¸caõ sempre que temos de tratar um problema complexo?



Cap´ıtulo 4

Modelagem Orientada a Objeto Neste cap´ıtulo apresentaremos uma introdu¸caõ à modelagem (se¸caõ 4.1): o que é um modelo (se¸caõ 4.1.1), porque usamos modelos para representar a realidade (se¸caõ 4.1.3), e quais s˜ ao os tipos de modelos (se¸caõ 4.1.2). Em seguida veremos uma introdu¸caõ ` a modelagem orientada a objeto (se¸caõ 4.2): o que é a modelagem que tem como foco principal o conceito de objeto (se¸caõ 4.2.1), quando a modelagem orientada a objeto surgiu (se¸caõ 4.2.2) e quais suas vantagens (se¸caõ 4.2.3). Veremos também o que é a UML – Linguagem de Modelagem Unificada (se¸caõ 4.3), suas diferentes visões (se¸caõ 4.3.1), seus diagramas (se¸cão 4.3.1), seus elementos (se¸caõ 4.3.2) e seus estereótipos (se¸caõ 4.3.3). No final do cap´ıtulo veremos alguns softwares utilizados para modelagem orientada a objeto (se¸caõ 4.4), como os softwares dia (se¸caõ 4.4.1), umbrello (se¸caõ 4.4.2), e Visual-Paradigm – VP (se¸caõ 4.4.3).

4.1

Introdu¸ c˜ ao ` a modelagem

Apresenta-se nesta se¸caõ o que é um modelo, tipos e exemplos e a raz˜ ao pela qual usamos modelos.

4.1.1

O que ´ e um modelo?

• Um modelo é uma representa¸caõ da realidade; é uma liga¸caõ, uma ponte entre conceitos teóricos e observa¸co˜es [Aris, 1978]. • O desenvolvimento de um modelo envolve o uso do conceito de abstra¸caõ, a visão do todo e de suas partes. • Adaptando [Bender, 1978], podemos dizer que no desenvolvimento de um modelo devemos: i) formular as idéias precisamente [com clareza]; ii) ser concisos no uso da linguagem; e iii) identificar bibliotecas e sistemas dispon´ıveis. • Segundo [Bender, 1978], ”A teoria é util para obter conclusões gerais dos modelos simples. Computadores s˜ ao u ´ teis para obter conclusões espec´ıficas de modelos mais complexos”. • Alguns modelos s˜ ao focados em aspectos estruturais, como um projeto das funda¸co˜es e da estrutura de um edif´ıcio. Outros modelos s˜ ao focados na dinâmica e no comportamento do sistema, como, por exemplo, um modelo da dinâmica de um sistema de comportas 81

˜ A ` MODELAGEM 4.1. INTRODUC ¸ AO

82

(canal do Panamá), ou do funcionamento de um motor de combust˜ ao. O uso de diferentes modelos estruturais/comportamentais nos permite ver os sistemas de diferentes formas; cada modelo, cada ator, fornece-nos vis˜ ao/detalhamento de uma parte do sistema, [Sonerviile, 1993].

4.1.2

Tipos e exemplos de modelos

Veja a seguir alguns exemplos de modelos utilizados pelo homem. Colocamos uma classifica¸caõ n˜ ao-rigorosa indicando ser um modelo estrutural/dinâmico: • Modelos estruturais – Maquetes (maquete de uma casa, de um autom´ ovel). – Mapas (mapa das ruas de uma cidade). – Projetos (projeto de uma casa). – Modelos matemáticos (equa¸co˜es diferenciais, fun¸co˜es, exemplo: y = f(x) = a + b.x ). – Modelos multiescala (miniaturas, modelos reduzidos). • Modelos dinâmicos – Modelos f´ısicos/qu´ımicos/biol´ ogicos (exemplo: a equa¸caõ do movimento retil´ıneo uniforme). – Modelos numéricos (exemplo: método de integra¸caõ por Simpson). – Algor´ıtmos/fluxogramas (s˜ ao diagramas utilizados para representar a dinâmica de determinado sistema). Nota: de modo geral, um modelo matemático M1 pode ser utilizado em diferentes áreas, como a F´ısica, a Qu´ımica, a Biologia. Isto é, um mesmo conjunto de equa¸co˜es podem ser utilizadas para representar diferentes problemas [Aris, 1978, Bender, 1978].

4.1.3

Por que usamos modelos?

O problema da linguagem, a necessidade de linguagens universais A engenharia civil utiliza com freq¨ uência modelos simplificados da realidade, como, por exemplo, plantas de edif´ıcios e casas. As plantas s˜ ao utilizadas por permitirem o entendimento de como a obra deve ficar depois de pronta; é o modelo utilizado pelo engenheiro (ou arquiteto) para se comunicar com o propriet´ ario, bem como com o mestre de obra. Assim, a planta viabiliza a troca de informa¸co˜es entre todos os envolvidos no projeto. Veja na Figura 4.1 três tipos de plantas usadas pelos engenheiros: uma fachada, uma planta baixa e uma planta isométrica. Cada uma destas plantas procura destacar determinadas caracter´ısticas da casa. A fachada tem como objetivo mostrar como ficar´ a a frente da casa; a planta baixa, a disposi¸caõ dos ambientes da casa; a planta isométrica, como ser˜ ao dispostos os encanamentos de um banheiro. As plantas utilizadas pelo engenheiro/arquiteto têm como objetivo mostrar a estrutura e o funcionamento da casa e s˜ ao utilizadas universalmente. Um engenheiro brasileiro, por exemplo, pode utilizar uma planta feita por um arquiteto russo para construir a casa de um indiano na China. Com rela¸caõ ao desenvolvimento de software, o uso de uma linguagem universal, como a UML e como a C++, facilita a troca de informa¸co˜es e c´ odigos entre os desenvolvedores. Programa¸caõ Orientada a Objeto com C++


˜ A ` MODELAGEM 4.1. INTRODUC ¸ AO

83

Figura 4.1: Modelos da realidade – a planta de uma casa. pia chuveiro

X vaso

Banheiro Quarto

Quarto

Planta isometrica do banheiro

Cozinha Sala

Varanda

Fachada

(a) Fachada

Planta Baixa

(b) Planta Baixa

O problema do custo Usamos modelos para reduzir custos. Antigamente, um carro novo era desenvolvido utilizandose prot´ otipos em tamanho real, a um custo muito elevado e com poucas varia¸co˜es e testes. Na prática, boa parte dos testes era feita pelos próprios propriet´ arios. Atualmente, um carro é feito valendo-se de modelos de computador, em um programa CAD, reduzindo consideravelmente o custo do desenvolvimento de novos modelos. Os modelos do carro s˜ ao testados em simuladores. O problema da escala (conceito de escala) A maquete de uma casa é um modelo reduzido da casa, em uma outra escala. A vantagem do uso de modelos em escalas reduzidas é seu baixo custo. Por exemplo: o teste da performance aerodinâmica de um carro, como um f´ ormula 1, é normalmente feito em um tunel de vento com modelos reduzidos. Com rela¸caõ ao desenvolvimento de um software, a quest˜ ao da escala est´ a associada ao crescimento do software. A cada vers˜ ao novos recursos s˜ ao adicionados, e o uso de modelos permite a previs˜ ao antecipada do crescimento do software. Nota: quando um modelo n˜ ao muda ao modificarmos a escala do problema, dizemos que o mesmo é invari´ avel com rela¸caõ ` a escala [Aris, 1978]. Outras vantagens do uso de modelos • Maior facilidade para testar uma entidade f´ısica antes de lhe dar uma forma final. Programa¸caõ Orientada a Objeto com C++


˜ A ` MODELAGEM ORIENTADA A OBJETO 4.2. INTRODUC ¸ AO

84

• Maior facilidade na comunica¸caõ entre as diversas pessoas envolvidas (pela utiliza¸caõ de nota¸caõ uniforme). • Redu¸caõ da complexidade dos sistemas. • Possibilidade de testar o sistema em escalas reduzidas.

4.2

Introdu¸ c˜ ao ` a modelagem orientada a objeto

Agora que você já sabe a importˆ ancia dos modelos, vamos apresentar uma introdu¸caõ à modelagem orientada a objeto: o que é, quando surgiu e quais s˜ ao suas vantagens.

4.2.1

O que ´ e a modelagem orientada a objeto?

Reveja a imagem da Figura 3.2; a vis˜ ao do usuário é diferente da visão do engenheiro. Da mesma forma, a vis˜ ao de cada um dos participantes de um grupo de desenvolvimento de software é diferente. Para que nossa linguagem de comunica¸caõ seja uniformizada, precisamos utilizar a mesma base de informa¸co˜es, os mesmos conceitos. Paradigmas de programa¸caõ tradicionais, como o paradigma de programa¸caõ estruturada, ensinam-nos uma nova linguagem (centenas de conceitos novos e seus relacionamentos). Todos os programadores devem entender e utilizar esta nova linguagem. Contudo, a modelagem orientada a objeto elimina a necessidade de se aprender uma nova linguagem, pois a mesma é baseada em conceitos que já conhecemos – os objetos e seus relacionamentos. Isto ocorre porque, na modelagem orientada a objeto, os modelos da realidade s˜ ao desenvolvidos tendo como fonte de inspira¸caõ os objetos. Segundo [Sonerviile, 1993], ”a modelagem orientada a objeto é baseada na oculta¸caõ de informa¸co˜es, nos objetos e seus relacionamentos”. A modelagem orientada a objeto e os diagramas da UML – Linguagem de Modelagem Unificada – s˜ ao criados e utilizados para permitir a todos os programadores uma visão uniforme do sistema que vai ser desenvolvido (da mesma forma que o projeto de uma casa). A modelagem orientada a objeto é um instrumento fundamental para o desenvolvimento de programas com qualidade.

4.2.2

Quando surgiu a modelagem orientada a objeto?

Segundo [Fowler and Scott, 2000], os métodos de an´ alise e projeto orientado a objetos surgiram entre 1988 e 1992, destacando-se: i) o enfoque em projetos recursivos de Sally Shlaer e Steve Mellor; ii) os trabalhos de Coad e Yourdan, [Coad and Yourdon, 1993]; iii) os cartões CRC de Beck e Cunningham (1989); iv) as técnicas de Booch, [Booch, 1986]; v) o método TMO - Técnica de Modelagem de Objetos, de [Rumbaugh et al., 1994]; e vi) os casos de uso de Ivar Jacobson. No in´ıcio existiam vários métodos de modelagem orientada a objeto, e uma disputa para ver qual seria o padr˜ ao. Em 1997, o grupo de gerenciamento de objetos, conhecido como OMG – Object Management Group, adotou a UML como linguagem-padr˜ ao, o que provocou um impulso na aceita¸caõ da UML. Em outras palavras, a UML foi desenvolvida para unificar a nota¸caõ utilizada no desenvolvimento de softwares orientados a objeto. Hoje em dia a UML é utilizada universalmente para modelagem de software orientado a objeto, bem como para modelagem de sistemas em geral; ou seja, você pode usar UML para fazer seus softwares ou para auxiliar no desenvolvimento de projetos de engenharia. Programa¸caõ Orientada a Objeto com C++


´ A UML? 4.3. O QUE E

4.2.3

85

Quais as vantagens da modelagem orientada a objeto?

Segundo [Pressman, 2002], a modelagem orientada a objeto apresenta algumas vantagens inerentes: • Reuso de componentes do programa. • Desenvolvimento mais r´ apido e com melhor qualidade. • Facilidade de manuten¸caõ, adapta¸caõ e amplia¸caõ. Veremos a seguir o que é a UML, suas vis˜ oes, seus diagramas, elementos e estereótipos.

4.3

O que ´ e a UML?

A UML é o padr˜ ao utilizado para o desenvolvimento de modelos de software orientados a objeto. Como foi desenvolvida depois da TMO com a participa¸caõ de Rumbaugh, alguns diagramas utilizados na TMO foram preservados (mas ocorreram algumas altera¸co˜es). A UML estendeu a TMO acrescentando novas funcionalidades e novos diagramas, destacando-se os casos de uso. A TMO é descrita brevemente na se¸caõ 5.3.7. Segundo [Fowler and Scott, 2000], o c´ odigo é o meio preciso e detalhado, e a linguagem natural é muito imprecisa; UML seria ent˜ ao o meio termo. • A UML é uma linguagem visual que usa a idéia ”uma imagem vale mais do que mil palavras”. • A UML é uma linguagem de modelagem independente de processo. • A UML é dinˆ amica; inova¸co˜es e ajustes s˜ ao acrescentados a cada nova vers˜ ao. • A UML é o padr˜ ao da ind´ ustria para modelagem de software orientado a objeto. • A UML é extens´ıvel, podendo ser adaptada às suas necessidades.

4.3.1

As diferentes vis˜ oes da UML e os respectivos diagramas

A seguir s˜ ao apresentadas as diferentes visões da UML e os respectivos diagramas: • Vis˜ ao do modelo do usu´ ario – mostra a visão do usuário do sistema, sendo descrita principalmente pelos casos de uso. – Diagrama de caso de uso (veja se¸caõ 6.1.2). • Vis˜ ao do modelo estrutural – mostra a estrutura do sistema (equivale ao modelo de objetos do método TMO). – Diagrama de pacotes (veja se¸caõ 6.2.3). – Diagrama de classes, atributos, métodos (veja se¸caõ 6.4.4), associa¸co˜es (veja se¸caõ 6.4.6), agrega¸co˜es (veja se¸caõ 6.4.9), heran¸cas (veja se¸caõ 6.4.11), e dependências (veja se¸caõ 6.4.15). – Diagrama de objetos (veja se¸caõ 6.4.17). – Diagrama de estrutura composta (veja se¸caõ 6.4.18). Programa¸caõ Orientada a Objeto com C++



86

• Vis˜ ao do modelo dinˆ amico – mostra a dinˆ amica e o comportamento do sistema, sua intera¸caõ com o usu´ ario e com sistemas externos (equivale ao modelo dinˆ amico e funcional do método TMO).

– Diagrama de seq¨ uência (eventos e mensagens) (veja se¸caõ 6.5.2). – Diagrama de comunica¸caõ/colabora¸caõ (veja se¸caõ 6.5.3). – Diagrama de máquina de estado (estados do objeto) (veja se¸caõ 6.5.5). – Diagrama de atividades (detalha as fun¸co˜es/métodos) (veja se¸caõ 6.5.7). – Diagrama de tempo (veja se¸caõ 6.5.8).

• Vis˜ ao de implementa¸ c˜ ao – mostra aspectos estruturais do sistema relacionados às necessidades de implementa¸caõ (equivale em parte ao projeto do sistema do método TMO).

– Diagrama de componentes (veja se¸caõ 6.7.1).

• Vis˜ ao do modelo de ambiente – mostra o ambiente-alvo e as necessidades para se colocar o sistema em funcionamento.

– Diagrama de implanta¸caõ (veja se¸caõ 6.7.2).

Veja na Figura 4.2 o relacionamento dos diagramas estruturais da UML. No exemplo apresentamos um sistema para simula¸caõ de um reservatório de petróleo ou de um po¸co. O diagrama de pacotes é o mais geral e representa todo o sistema. O diagrama de componentes inclui dentro dele os componentes do sistema (sub-sistemas, bibliotecas e módulos). No exemplo inclu´ımos um componente biblioteca de simula¸caõ. O diagrama de classes mostra as classes, seus atributos, métodos e o relacionamento entre as classes. Por fim, a estrutura interna de uma classe pode ser representada em um diagrama de estrutura composta (inclu´ımos o diagrama de estrutura composta da classe SimPoco). Observe que estamos partindo do geral e descendo para o espec´ıfico, de uma visão macroestrutural, para uma visão microestrutural. Da mesma forma, a dinˆ amica do sistema também é representada por diferentes diagramas (veja Figura 4.3). O caso de uso representa a vis˜ ao mais simples da dinâmica do sistema, a visão do usu´ ario. Os diagramas de seq¨ uência e de comunica¸caõ ilustram a intera¸caõ entre os pacotes, os módulos e os objetos. Observe no diagrama de comunica¸cão que o usuário cria um simulador, seleciona uma fun¸caõ e um objeto de integra¸caõ e em seguida solicita o c´ alculo da área da fun¸caõ a ser realizado pelo objeto de integra¸caõ (veja Figura 6.17 e 6.19). O diagrama de máquina de estado (veja Figura 6.20) ilustra os estados de um objeto. Na Figura 6.20, o objeto integral est´ a recebendo a fun¸caõ, recebendo dados e calculando a integral. O diagrama de atividades, por sua vez, detalha o funcionamento de um método, a descri¸caõ de uma atividade espec´ıfica. A Figura 4.3 mostra o diagrama de atividades para o método do Trap´ ezio, respons´ avel pelo c´ alculo da área de uma fun¸caõ (veja exemplo mais detalhado na Figura 6.25). Programa¸caõ Orientada a Objeto com C++



87 <> Diagrama de pacotes <> <>

<> Diagrama de componentes

Biblioteca matemática

Biblioteca estatística <>

Biblioteca Simulação

<> Diagrama de classes

Simulador

SimReservatorio

SimPoco

<> Diagrama de estrutura composta

funcao: TFuncao integral: IntTrapezio

Simulação

Figura 4.2: Relacionamento dos diagramas estruturais da UML.




88

<> Diagrama de casos de uso

Calcular área função

<> Diagrama de comunicação

Ator função

Ator simulador integral

<> Diagrama de máquina de estado

recebendo função

recebendo dados

calculando integral (área)

<> Diagrama de atividades enquanto x
faz x=xmin, Area=f(x).dx/2

x=x+dx y=f(x) Area=Area+y.dx

x>xmax

Area=Area+f(x).dx/2

Figura 4.3: Relacionamento dos diagramas dinâmicos da UML.

4.3.2

Os elementos da UML

Veja na Figura 4.4 um esbo¸co dos elementos da UML e observe que a UML tem um conjunto de elementos, como classe (ativa, inativa), gabarito/template, interface, pacote, componente, estado, nota, etiqueta, restri¸caõ, dependência, associa¸caõ, generaliza¸caõ, agrega¸caõ/composi¸caõ, realiza¸caõ, colabora¸caõ, intera¸caõ, estereótipos etc. Veja na Figura 4.5 outros elementos utilizados pela UML, cujos elementos ser˜ ao explicados em detalhes no Cap´ıtulo 6 – Etapas para o Desenvolvimento de um Programa. Programa¸caõ Orientada a Objeto com C++



89

Componentes UML do programa dia dependência

Classe

Classe

generalização

nota

associação

{restrição} agregação realização

pequeno pacote caso de uso

pacote

observação implementação Componente

objeto mensagem

note

receptáculo dissipador de evento

Fonte de evento

Ator

tempo vida

atividade estado

início

ramo

fim

bifurcação

estereótipo

Figura 4.4: Elementos da UML.

Figura 4.5: Outros elementos da UML. Notação UML para associações, agregação, composição, generalização, implementação, observação e receptáculo, fonte e dissipador de eventos, restrição, dependência, interface.

Tipos de mensagens <>

papel de B nb associação

{restrição}

chamada

<> generalização

papel de A na

<> dependência

<>

agregação papel de A na

papel de B nb

<> implementação

recursiva interface simples

Receptáculo

composição

enviar/send papel de A na

papel de B nb

Observação

Dissipador de Evento

Fonte de Evento

retorno

Ícone de classe. controle

4.3.3

limite

entidade

um ramo

Os estere´ otipos da UML2

Lembre-se que esta é uma se¸caõ de n´ıvel 2 e s´ o deve ser lida em uma segunda leitura do livro ou por usu´ arios experientes. Os estereótipos s˜ ao apresentados nos diagramas da UML dentro de < <> > e s˜ ao utilizados para estender as funcionalidades da UML ou para indicar alguma propriedade de um elemento da UML. Veja a seguir alguns exemplos de estereótipos. Programa¸caõ Orientada a Objeto com C++



90 Estere´ otipos para classes: persistente A classe é armazenada em disco ou em uma base de dados.

entity Representa uma classe que tem forte intera¸caõ com o sistema, recebendo e fornecendo dados [entidade]. boundary Representa uma classe de contorno, utilizada para intera¸caõ do sistema com elementos externos. Por exemplo, a classe que faz o acesso à impressora [contorno]. control Classe utilizada para controle de alguma atividade. Muitas vezes é utilizada uma classe < > entre uma classe < > e o sistema [controle]. interface Indica uma classe abstrata que tem apenas métodos puros. A UML inclui ´ıcones especiais para indicar interfaces. bind Especifica os tipos utilizados em uma especializa¸caõ. friend A classe-fonte tem acesso ` a classe-alvo [amigo]. instanceOf Indica uma instância do alvo (usado em rela¸co˜es entre classes e objetos) [instˆ ancia de]. instantiate A classe-fonte cria objetos da classe-alvo. refine Indica ser mais detalhado/refinado [refina]. use Indica dependências de uso [uso]. become Indica ser o mesmo objeto mas com rela¸co˜es diferentes (em um estado diferente). call O fonte chama o alvo [chama]. copy Indica ser uma c´ opia independente [copia]. acess Indica acesso [acesso]. Programa¸caõ Orientada a Objeto com C++



91

Estere´ otipos para atributos: const O atributo é constante, n˜ ao muda. crescente O atributo é um valor crescente. decrescente O atributo é um valor decrescente. Estere´ otipos para m´ etodos: const O método n˜ ao altera os atributos do objeto [constante]. sequencial O método n˜ ao aceita acesso concorrente; o acesso deve ser seq¨ uencial. concorrente O método aceita acesso concorrente (processamento paralelo). guarded O acesso concorrente é permitido, e o controle do acesso aos atributos internos é controlado pelo próprio objeto. alt Indica uma alternativa; é usado em estruturas de controle [alternativa]. opt Indica item opcional [opcional]. loop Indica um looping [la¸co]. Estere´ otipos para mensagens: create A mensagem solicita a cria¸caõ de um objeto [criar]. destroe A mensagem solicita a destrui¸caõ de um objeto [destruir]. call A mensagem chama determinado método [chamar]. return Representa uma mensagem de retorno [retornar]. send Representa o envio de um sinal [enviar]. Programa¸caõ Orientada a Objeto com C++



92 Estere´ otipos para associa¸ co ˜es: implicita A associa¸caõ est´ a impl´ıcita. ordenada A associa¸caõ requer dados ordenados. modific´ avel A associa¸caõ pode ser modificada. crescente A associa¸caõ deve ser crescente. constante A associa¸caõ deve ser constante. Estere´ otipos para heran¸ cas: implementation Implementa métodos da classe-base [implementa].

complete A classe completa a hierarquia; a hierarquia est´ a completa [completa]. incomplete A hierarquia est´ a incompleta, faltam classes [incompleta]. Estere´ otipos para processamento paralelo/distribu´ıdo: processo Representa um processo do sistema. thread Representa uma thread do sistema. par Indica processamento paralelo. Estere´ otipos para caso de uso: extende Indica uma extensão de um caso de uso [estende]. include Indica uma inclus˜ ao de um caso de uso [inclui]. generalize Indica uma generaliza¸caõ de um caso de uso [generaliza]. Antes de apresentarmos em detalhes os diagramas da UML, vamos olhar rapidamente alguns programas que podem ser utilizados para gerar os diagramas, assim você poder´ a desenhar os diagramas enquanto lê o livro. Programa¸caõ Orientada a Objeto com C++


4.4. PROGRAMAS PARA MODELAGEM ORIENTADA A OBJETO

4.4

93

Programas para modelagem orientada a objeto

Existem diversos programas para desenho dos diagramas da UML, entre os quais podemos citar: • Rational Rose – é um pacote profissional que, além da montagem dos diagramas, per´ um pacote pago, dispon´ıvel para mite simultaneamente a implementa¸caõ dos c´ odigos. E diversas plataformas no endere¸co http://www.rational.com. • With Class – é um pacote profissional, que, além da montagem dos diagramas, per´ um pacote pago, dispon´ıvel para mite simultaneamente a implementa¸caõ dos c´ odigos. E diversas plataformas no endere¸co http://www.microgold.com/index.html. • Dia – o modelador dia é muito simples de usar, é software livre e ser´ a descrito na se¸caõ 4.4.1. Pode ser obtido em http://www.gnome.org/gnome-office/dia.shtml. • Umbrello – o modelador umbrello também é muito simples de usar, é software livre e ser´ a descrito na se¸caõ 4.4.2. Pode ser obtido em http://uml.sourceforge.net/index.php. • Visual Paradigm – pacote profissional, com vers˜ ao livre. Ser´ a descrito na se¸caõ 4.4.3.

4.4.1

O programa Dia

Parte dos diagramas UML apresentados neste livro foram criados utilizando-se o programa dia, um software livre utilizado para a cria¸caõ dos mais diversos tipos de diagramas. Veja a seguir uma lista com alguns dos diagramas deste programa: • AADL, Cibernética, Circuitos, equipamentos cisco, engenharia civil, engenharia elétrica, engenharia qu´ımica, EML, ER, fluxograma, cronograma, estrutura funcional, Gane e Sarson, GRAFCET, Lader, l´ ogica, mapa isométrico, Miscelâneas, MSE, pneumático/hidráulico, rede, rede Jackson, rede KAOS, SADT/IDEF0, SDL, Sybase e, por fim, UML. A tela do programa dia é ilustrada na Figura 4.6. Observe que a lista de componentes UML ` esquerda vemos a janela de controle do dia. Observe, na parte superior, est´ a selecionada. A ´ıcones gerais como: sele¸caõ, aproximar, mover, caixa, elipse, poligono, bezier, linha, arco, zig-zag, polilinha, curva Bézier e inser¸caõ de figura. No meio da tela de controle temos os elementos da UML, como: classe, modelo, texto, dependência, interface, heran¸ca, associa¸caõ, agrega¸caõ, implementa¸caõ, restri¸caõ, pacote, ator, caso de uso, linha de vida, objeto, mensagem, componente, observa¸caõ, recept´ aculo, fonte e dissipador de eventos, n´ o, estereótipo, estado, atividade, remo, bifurca¸caõ e transa¸caõ. Finalmente, na parte de baixo da tela de controle do dia temos: cor de frente e de fundo, espessura da linha, tipo da linha e formato das pontas (setas). Veja nas Figuras 4.4 e 4.5 um esbo¸co dos elementos da UML disponibilizados pelo programa dia, o qual pode ser obtido no endere¸co http://www.gnome.org/gnome-office/dia.shtml. N˜ ao é nosso objetivo abordar a utiliza¸caõ desse programa, e um pequeno manual dele poder´ a ser obtido em http://www.lysator.liu.se/~alla/dia/ e http://www.togaware.com/ linuxbook/dia.html. Programa¸caõ Orientada a Objeto com C++


94


Figura 4.6: O programa dia manipulando uma estrutura UML com representa¸co˜es de classes.

4.4.2

O programa umbrello

O programa umbrello é um modelador UML distribu´ıdo juntamente com o KDE nas diversas ´ um programa f´ distribui¸co˜es GNU/Linux. E acil de usar e que tem a vantagem de gerar o c´ odigo dos programas a partir do diagrama de classes. O c´ odigo pode ser exportado e importado para as seguintes linguagens:

• C++, Actionscript, Ada, IDL, Java, JavaScript, Pascal, Perl, PHP, Python, Ruby, SQL, TCL, XMLschema.

Veja na Figura 4.7 a tela do modelador umbrello mostrando um diagrama de componente, e na Figura 4.8, um diagrama de classes. No site http://uml.sourceforge.net/index.php, você pode baixar o umbrello, cujo manual j´ a est´ a dispon´ıvel em português. . Se você usa GNU/Linux, abra um terminal e digite umbrello. A seguir vá em Ajuda>Manual do modelador UML umbrello (ou simplesmente pressione F1).

Dica: no programa umbrello, quando modelar uma associa¸caõ, indique na linha da associa¸caõ o nome do papel. Programa¸caõ Orientada a Objeto com C++



95

Figura 4.7: A tela do programa Umbrello: Um diagrama de componentes.

Figura 4.8: A tela do programa umbrello – um diagrama de classes. Programa¸caõ Orientada a Objeto com C++



96

Nota: veremos na se¸caõ 6.8.2 como montar o c´ odigo inicial do programa com o Umbrello.

4.4.3

O programa Visual-Paradigm

O Visual-Paradigm, ilustrado na Figura 4.9, é uma interface de modelagem UML propriet´ aria. Pode estar integrado a alguns sistemas de desenvolvimento como o Eclipse/IBM, JBuilder, NetBeans/Sun, entre outros. O Visual-Paradigm tem uma vers˜ ao aberta para uso individual e n˜ ao profissional (vers˜ ao com recursos limitados). Também tem uma vers˜ ao standard aberta para comunidade acadêmica, com licen¸ca válida por um ano. Para obter uma c´ opia do Visual-Paradigm acesse o site http: //www.visual-paradigm.com/.

Figura 4.9: A tela do programa Visual-Paradigm – um diagrama de caso de uso.

4.5


Neste cap´ıtulo aprendemos que um modelo é uma descri¸caõ simplificada e reduzida da realidade cuja vantagem est´ a associada ao seu baixo custo e ao uso de uma linguagem universal. Vimos que os modelos (estruturais ou dinˆ amicos) podem ser utilizados para nos ajudar a solucionar os mais variados problemas da engenharia. Aprendemos que a idéia da modelagem orientada a objeto é desenvolver modelos tendo como foco o conceito de objeto. A modelagem orientada a objeto surgiu ao longo dos anos de 1980 e ficou madura nos anos de 1990 com o surgimento da UML, um sistema de modelagem que Programa¸caõ Orientada a Objeto com C++


4.6. EXERCÍCIOS

97

unificou as antigas nota¸co˜es. No final do cap´ıtulo vimos o que s˜ ao e como obter programas modeladores como o dia e o umbrello. No Cap´ıtulo 5 – Engenharia de software, veremos os conceitos b´ asicos de engenharia de software e uma descri¸caõ de modelos e processos utilizados para o desenvolvimento de sistemas de softwares. Dica: todos os diagramas da UML aceitam a inclus˜ ao de notas, as quais s˜ ao utilizadas para adicionar qualquer tipo de descri¸caõ a respeito do modelo que est´ a sendo desenvolvido, ou para detalhar algum aspecto que possa estar confuso. Nota: conceitos b´ asicos de modelagem s˜ ao encontrados nas referências [Aris, 1978, Bender, 1978, da Silva Neto and Neto, 2005].

4.6

Exerc´ıcios

1. Descreva, com suas palavras, o que é e para que servem os modelos. 2. Descreva, com suas palavras, o que é um paradigma. 3. Cite exemplos de modelos (estruturais e dinâmicos). 4. Qual a diferen¸ca entre a vis˜ ao estrutural e a visão dinˆ amica? 5. Instale em seu computador uma ferramenta de modelagem (exemplo: umbrello) e leia o manual do software instalado. 6. Monte alguns exemplos de diagramas utilizando a ferramenta de modelagem escolhida. 7. A Figura 4.3 mostra um diagrama de atividades para c´ alculo da área de uma fun¸caõ. O diagrama usa uma vari´ avel x que é comparada com xmax. Troque o uso de x pelo uso de um contador i. 8. Comente a defini¸caõ de modelo matemático de [Bender, 1978], ”Um modelo matemático é uma abstra¸caõ, simplificada, uma constru¸caõ matemática relacionada à parte de uma realidade, sendo criada com um prop´ osito particular”. Como reescrevê-la considerando aspectos computacionais?



98


4.6. EXERCÍCIOS


Cap´ıtulo 5

Engenharia de Software Neste cap´ıtulo apresentaremos os conceitos b´ asicos de engenharia de software e uma descriçaõ de modelos e processos utilizados para o desenvolvimento de sistemas de softwares. Iniciaremos com a defini¸caõ do que é e quais s˜ ao os objetivos da engenharia de software (se¸caõ 5.1). Em seguida, apresentaremos um breve histórico da engenharia de software (se¸caõ 5.2) e suas caracter´ısticas gerais (se¸caõ 5.3). Apresentaremos ent˜ ao os diferentes modelos: • Modelo seq¨ uencial linear (se¸caõ 5.3.1). • Modelo iterativo (se¸caõ 5.3.2). • Modelo baseado em prototipagem (se¸caõ 5.3.3). • Modelo RAD – Rapid Application Development (se¸caõ 5.3.4). • Modelo incremental (se¸caõ 5.3.5). • Modelo espiral (se¸caõ 5.3.6). • Modelo TMO (se¸caõ 5.3.7). • Modelo UP (se¸caõ 5.3.8). • Modelo XP (se¸caõ 5.3.9). Finalizaremos apresentando o modelo selecionado (se¸caõ 5.4). Nota: na literatura especializada, esses modelos s˜ ao tratados como ”modelos”, ”técnicas” ou ”processos”. Usei o nome uniforme de modelos, uma vez que a palavra técnica se refere à aplica¸caõ prática dos modelos, depois de estes terem sido testados e consolidados. J´ a a palavra ”processo” se refere a uma seq¨ uência espec´ıfica. Como a apresenta¸caõ neste cap´ıtulo é breve e simplificada, a palavra ”modelo” é mais adequada.

5.1

O que ´ e e quais s˜ ao os objetivos da engenharia de software?

A engenharia de software estuda e desenvolve modelos para o desenvolvimento de softwares considerando as caracter´ısticas b´ asicas de um sistema de engenharia, isto é, conceitos como 99

´ 5.2. BREVE HISTORICO DA ENGENHARIA DE SOFTWARE

100

especifica¸caõ, an´ alise, projeto, testes, documenta¸cão, execu¸caõ e controle. Inclui ainda itens como an´ alises de custo, divisão e montagem de equipes, automatiza¸caõ de processos etc. Um dos objetivos b´ asicos da engenharia de software é gerar softwares com qualidade. A Norma Qualidade de Software (ISO/IEC 9126: NBR 13596) inclui as seguintes defini¸co˜es: • Funcionalidade – satisfaz as necessidades. • Confiabilidade – é imune a falhas. • Usabilidade – é f´ acil de usar. • Eficiˆ encia – é r´ apido. Segundo [Teles, 2006], o relat´ orio The Chaos Report identificou que mais de 70% dos projetos de software falhamem raz˜ ao de fatores como: • consomem mais recursos do que o planejado. • consomem mais tempo do que o planejado. • n˜ ao entregam o combinado. • todos os ´ıtens acima. Outro aspecto interessante é que apenas 67% das funcionalidades prometidas s˜ ao entregues. Das funcionalidades implementadas, 45% nunca s˜ ao utilizadas e 19% raramente o s˜ ao, ou seja, cerca de 64% de todo c´ odigo escrito n˜ ao é utilizado. Fica evidente a necessidade de melhoria da comunica¸caõ, principalmente com o cliente, mas também entre os membros da equipe de desenvolvimento. Esses dados demonstram a necessidade de se adotar um modelo de engenharia de software que se adapte de forma mais eficiente aos novos tempos e à sua equipe de desenvolvimento. Nas próximas se¸co˜es apresentaremos um breve histórico da engenharia de software e vários modelos utilizados ao longo dos u ´ ltimos anos, incluindo os recentes UP e XP.

5.2

Breve hist´ orico da engenharia de software

Os primeiros modelos de engenharia de software foram desenvolvidos para linguagens estruturadas, como C e Fortram, e s˜ ao apresentadas em detalhes nas referências [Martin and McClure, 1993, Sonerviile, 1993, Pressman, 2002]. Com o surgimento da programa¸caõ orientada a objetos, desenvolveram-se os primeiros métodos de modelagem orientada a objetos, os quais foram idealizados e aperfei¸coados por autores como Coad, Yourdan, Grady Boock, James Rumbaugh, Blaha, Premerlani, Eddy, Lorensen e Ivar Jacobsen. Cada um desses autores desenvolveu uma metodologia de modelagem diferente. Posteriormente, os métodos de Boock, Rumbaugh e Jacobsen foram unificados na UML – Unified Modeling Language ou linguagem de modelagem unificada, descrita na se¸caõ 4.3. Apresentaremos na se¸caõ 5.3 alguns conceitos relacionados a diferentes modelos, metodo´ importante destacar que existem logias, técnicas e processos de engenharia de software. E diversos modelos de engenharia de software; cada analista, programador, equipe de desenvolvimento deve escolher o modelo que mais se adapta às suas necessidades e às suas próprias caracter´ısticas. Segundo [Fowler and Scott, 2000], ”n˜ ao existe um processo ideal; a defini¸caõ do melhor modelo depende do tipo de software e do tamanho da equipe de desenvolvimento”. Programa¸caõ Orientada a Objeto com C++


5.3. CARACTERÍSTICAS DOS MODELOS DE ENGENHARIA DE SOFTWARE

5.3

101

Caracter´ısticas dos modelos de engenharia de software

Uma an´ alise r´ apida dos diferentes modelos de engenharia de software nos leva ao entendimento de que todos seguem os paradigmas b´ asicos da engenharia, isto é, conceitos como especifica¸caõ, an´ alise, projeto, testes, documenta¸cão, execu¸caõ e controle, e que as diferen¸cas de um modelo em rela¸caõ ao outro se devem às especificidades das equipes e dos sistemas a serem desenvolvidos. Apresenta-se aqui uma lista de conceitos que s˜ ao comuns aos diferentes modelos de engenharia de software e ao próprio senso comum, [Teles, 2006]: • Necessidade de planejamento. • Defini¸caõ clara e simplificada dos requisitos do sistema. • Necessidade de comunica¸caõ constante entre os membros da equipe de desenvolvimento e com os clientes. • Execu¸ca õ do projeto com compartilhamento de responsabilidades (reuni˜ oes constantes e objetivas, compartilhamento de c´ odigo, fazer primeiro o que é essencial). • Quando identificado um problema (um bug, uma falta de padroniza¸caõ), tentar resolvê-lo o mais rapidamente poss´ıvel. • Controlar os sistemas desenvolvidos (inclui teste dos modelos, algoritmos e softwares desenvolvidos, elimina¸caõ dos bugs). • Dividir as equipes de desenvolvimento em grupos compactos, coesos; aliar experiência e mocidade. • Manter as pessoas atualizadas com a realiza¸caõ de cursos, a leitura de artigos e livros. Desta forma, os desenvolvedores poder˜ ao, pela refatora¸caõ ou reengenharia, atualizar os c´ odigos e algoritmos. • Segundo [Pressman, 2002], ”independente do seu dom´ınio de enfoque, a engenharia de software abrange uma cole¸caõ de métodos descendentes (top-down) e ascendentes (botonup)”.

5.3.1

Modelo sequ ëncial linear

O modelo seq¨ uencial linear é um dos modelos mais antigos[Pressman, 2002] e envolve a execu¸caõ consecutiva das seguintes atividades: • An´ alise, projeto, codifica¸caõ e teste. Existem varia¸co˜es do modelo seq¨ uencial linear. [Solter and Kleper, 2005] cita o modelo Stagewise Model, o qual inclui: • Planejamento, desenvolvimento, implementa¸caõ, teste de integra¸caõ, teste de subsistema e avalia¸caõ. Entre os problemas do modelo seq¨ uencial linear est´ a a dificuldade do cliente em definir com clareza as especifica¸co˜es do sistema. Programa¸caõ Orientada a Objeto com C++


102


5.3.2

Modelo iterativo

Em 1970 surgiu o modelo iterativo, o qual consiste em realizar revisões ap´ os cada etapa do modelo seq¨ uencial linear. • An´ alise->revisão, projeto->revis˜ ao, codifica¸caõ->revisão e teste->revisão.

5.3.3

Modelo baseado em prototipagem

Segundo [Pressman, 2002], o modelo baseado em prototipagem consiste em criar um prot´ otipo do programa ap´ os a etapa de especifica¸caõ do sistema. Ainda de acordo com [Pressman, 2002], na prática o prot´ otipo é descartado, sendo necess´ ario construir uma vers˜ ao reprojetada. Outro problema deste modelo é que o cliente ao ver o prot´ otipo acha que o sistema est´ a quase pronto. O próprio programador pode achar que este é o melhor caminho.

5.3.4

Modelo RAD – Rapid Application Development

O modelo RAD consiste em repetir ciclicamente todas as atividades do modelo seq¨ uencial. A cada ciclo de 60 e 90 dias, desenvolve-se um módulo diferente que é agregado ao sistema. ´ adequado para aplica¸co˜es em que seus subsistemas possam ser desenvolvidos completaE ´ inadequado para sistemas que envolvam novas mente dentro do per´ıodo de 60 a 90 dias. E tecnologias (exemplo: centros de pesquisa, laboratórios de universidades).

5.3.5

Modelo incremental

O modelo incremental mistura os modelos seq¨ uencial, de prototipagem e RAD. Por exemplo: no primeiro ciclo de montagem cria-se um n´ ucleo do sistema com funcionalidades b´ asicas. Novas funcionalidades s˜ ao inclu´ıdas a cada ciclo. Note que a cada ciclo o sistema deve estar operacional. Este modelo é adequado para equipes pequenas e para centros de pesquisa (nos quais o n´ umero de pessoas envolvidas no projeto varia constantemente).

5.3.6

Modelo espiral

Em 1988, Barry W. Boehm apresentou o Spiral Method, que consiste em executar todas as atividades de forma iterativa, o que implica na constante revisão das atividades anteriormente realizadas. A vantagem deste modelo é sua simplicidade, sendo simples de aprender e de utilizar. A dificuldade est´ a em definir o tempo ideal para realiza¸caõ de cada ciclo. Observe que é um modelo iterativo e incremental. No modelo espiral as primeiras vers˜ oes podem constar apenas do papel, e vers˜ oes incrementais s˜ ao desenvolvidas ao longo de cada ciclo. Segundo [Pressman, 2002], ”é um modelo realista para o desenvolvimento de sistemas e softwares de grande porte”. As etapas a serem desenvolvidas em cada ciclo s˜ ao: • Comunica¸caõ com o cliente • Planejamento • An´ alise de risco • Engenharia Programa¸caõ Orientada a Objeto com C++



103

• Constru¸caõ e libera¸caõ • Avalia¸caõ pelo cliente A seguir ser´ a apresentado o modelo TMO, um dos primeiros modelos espec´ıficos para o desenvolvimento de software orientado a objeto.

5.3.7

Modelo TMO – Tecnologia de Modelagem de Objetos

A TMO (ou OMT em inglês) é um dos modelos de modelagem orientada a objeto que fizeram mais sucesso. A TMO possui três modelos: • Modelo de objetos – a estrutura do sistema é modelada através da constru¸caõ do diagrama de classes (inclui classes, atributos, métodos, associa¸co˜es, agrega¸co˜es, heran¸cas, e dependências). • Modelo dinˆ amico – a dinˆ amica do sistema, sua intera¸caõ com os usuários é modelada através dos diagramas de seq¨ uência (eventos e mensagens), de comunica¸caõ e de máquina de estado. • Modelo funcional – a dinˆ amica das funcionalidades dos objetos é modelada pelo diagrama de atividade (detalha as fun¸co˜es/métodos do objeto). Os três modelos s˜ ao ortogonais, ou seja, complementam-se, e a maior importˆ ancia de um em rela¸caõ ao outro dependerá do tipo de programa desenvolvido. A TMO é discutida em detalhes em [Rumbaugh et al., 1994]. Veremos a seguir um breve resumo de duas metodologias mais recentes, a UP – Rational Unified Process, e a XP – eXtreme Programming.

5.3.8

Modelo UP – Unified Process

Desenvolvida pela Rational Software, uma subsidiária da IBM, o modelo UP foi criado pela mesma equipe que desenvolveu a UML. Entre as caracter´ısticas do modelo pode-se citar: ´ uma metodologia que permite atualiza¸caõ e refinamento constante. • E • Inclui um conjunto de programas e ferramentas utilizados por toda a equipe de desenvolvimento. • Cada processo é um fluxo de trabalho individual. • Como os programas e ferramentas s˜ ao pagos e caros, n˜ ao é adequado para pequenas empresas. Veja a seguir as etapas do UP: • Concep¸ c˜ ao – defini¸caõ do escopo do projeto, prazos, custos. • Elabora¸ c˜ ao – na elabora¸caõ realiza-se um estudo mais detalhado sobre o sistema a ser elaborado (o quê e como). • Constru¸ c˜ ao – montar um plano para a etapa de constru¸caõ que é realizada ciclicamente. Isto é, para cada caso de uso ou subsistema, realizam-se as atividades de an´ alise, projeto, codifica¸caõ, teste e integra¸caõ. Programa¸caõ Orientada a Objeto com C++


104


• Transi¸ c˜ ao – envolve a corre¸caõ de erros (bugs) e pode incluir otimiza¸co˜es. • Itera¸ c˜ ao – consiste em repetir as etapas anteriores. Observe que cada etapa de UP pode incluir uma ou mais itera¸co˜es e, em cada itera¸caõ, executase (com maior ou menor ênfase) todas as atividades da engenharia de software: levantamento de requisitos, an´ alise, projeto, implementa¸caõ, testes e implanta¸caõ. ´ importante lembrar que UP é uma framework; cada equipe e cada projeto podem ser E customizados de forma diferente. Por exemplo: projetos pequenos podem trabalhar somente com concep¸caõ, elabora¸caõ e transi¸caõ. Projetos maiores podem ter mais fases. Você encontra maiores detalhes sobre UP em [Kruchten, 2003].

5.3.9

Modelo XP – eXtreme Programming

O eXtreme Programming, conhecido como XP, foi desenvolvido em 1999 por Kent Beck. Veja a seguir as 12 regras de ouro deste modelo: • O planejamento do sistema deve ser feito ao longo de todo o ciclo de desenvolvimento. • Crie pequenas vers˜ oes de seu sistema. • Compartilhe a mesma arquitetura (vis˜ ao do sistema). • Simplifique sua an´ alise (design). Evite criar sistemas excessivamente abstratos. • Teste o sistema de forma constante. Pode-se, por exemplo, manter uma máquina em tempo integral realizando testes automatizados. • Considere a necessidade de se refazer determinadas partes do sistema na medida em que inova¸co˜es estejam ocorrendo (evite deixar seu sistema muito defasado). • Crie duas equipes de trabalho. Enquanto uma equipe desenvolve o módulo do software, a outra equipe desenvolve o módulo de teste e realiza os testes. • Compartilhe o c´ odigo. Evite que os desenvolvedores se sintam donos de sua parte do c´ odigo. Todos devem poder alterar qualquer parte do c´ odigo. • Mantenha o sistema integrado de forma cont´ınua. Novamente o sistema de dupla de trabalho deve ser utilizado para manter o sistema integrado. • Evite que a equipe de desenvolvimento trabalhe mais do que 40 horas por semana. Comprovadamente o excesso de trabalho implica na adi¸caõ de bugs ao sistema. • Incentive ou viabilize a participa¸caõ dos clientes/usu´ arios no uso e teste do sistema. • Toda equipe deve, na medida do poss´ıvel, usar uma mesma nota¸caõ (estabelecer padr˜ oes de desenvolvimento). Segundo [Teles, 2006], ”as práticas de XP s˜ ao definidas de forma clara, embora cada equipe de desenvolvimento deva decidir como aplic´ a-las”. Você encontra maiores detalhes sobre XP em [Teles, 2006, Teles, 2004]. Consideramos que quase todos estes itens devem ser aplicados, mas particularmente discordamos dos seguintes pontos: Programa¸caõ Orientada a Objeto com C++


5.4. O MODELO SELECIONADO

105

• O planejamento do sistema deve ser feito ao longo de todo o ciclo de desenvolvimento. Neste caso, a tendência é a equipe fazer um planejamento minimalista, com diversos ”furos”; além do mais, passa a idéia de que erros no planejamento possam ser resolvidos a qualquer momento. • Simplifique sua an´ alise (design). Evite criar sistemas excessivamente abstratos. A an´ alise deve ser detalhada e n˜ ao simplificada. Os modelos devem ser desenvolvidos fazendo-se uma an´ alise criteriosa de cada aspecto do sistema a ser desenvolvido. Pequenos erros na an´ alise têm forte impacto na reimplementa¸caõ e provocam atrasos e descumprimento de prazos. • Crie duas equipes de trabalho. ´ um enfoque exagerado no teste (esta necessidade ocorre quando o planejamento e a E an´ alise s˜ ao mal feitos). Dependendo do tamanho da equipe e da complexidade do sistema, uma rela¸caõ de dois ou três desenvolvedores para cada testador é mais do que suficiente.

5.4

O modelo selecionado

O modelo de engenharia de software aqui apresentado é uma adapta¸caõ do modelo TMO, do modelo espiral, do modelo iterativo e de itens de UP e XP, aconselhada para pequenos grupos de desenvolvimento e laboratórios de pesquisa numérica. Novos conceitos de UP e XP podem ser integrados a esta metodologia ` a medida que seu grupo de trabalho aumenta. Também eliminamos t´ opicos muito espec´ıficos, tornando o uso da modelagem orientada a objeto mais fácil. A Figura 5.1 ilustra as diversas etapas a serem seguidas no desenvolvimento de um programa com o modelo aqui apresentado. Note que, sempre que se desenvolve um programa, essas etapas est˜ ao presentes, mesmo que n˜ ao sejam documentadas. As etapas iniciais s˜ ao mais teóricas, conceituais, e cada nova etapa envolve maior detalhamento, ocorrendo uma migra¸caõ do teórico para o aplicado. Observe que o modelo é iterativo. Concep¸ c˜ ao (requisitos/especifica¸ c˜ ao) Envolve a concep¸caõ/idéia do problema, a defini¸caõ de requisitos a serem satisfeitos e a especifica¸caõ do sistema (descri¸caõ do objetivo e o que se espera do sistema a ser desenvolvido) (se¸caõ 6.1). Elabora¸ c˜ ao Etapa em que a equipe de desenvolvimento toma conhecimento mais detalhado da área e do problema a ser resolvido (veja se¸caõ 6.2). Identifica os subsistemas e pacotes, é feita a an´ alise de riscos, levantamento de custos e prazos. An´ alise orientada a objeto – AOO An´ alise do problema com o objetivo de identificar a estrutura do sistema (objetos, classes, atributos, métodos), o relacionamento das classes (associa¸co˜es, agrega¸co˜es) e a dinâmica do sistema (veja se¸caõ 6.3). Projeto do sistema Defini¸caõ dos conceitos relativos ao sistema a ser implementado e escolha da plataforma do sistema: hardware, sistema operacional, linguagem de programa¸caõ e bibliotecas a serem utilizadas (veja se¸caõ 6.6). Programa¸caõ Orientada a Objeto com C++



106

Projeto orientado a objeto Acréscimo à an´ alise desenvolvida das caracter´ısticas da plataforma escolhida, maior detalhamento do funcionamento do programa (veja se¸caõ 6.7). Implementa¸ c˜ ao do programa Transforma¸caõ do projeto em c´ odigo. Integrar os diversos módulos, compilar e linkar (veja se¸caõ 6.8). Teste e depura¸ c˜ ao No teste verificamos se o programa satisfaz os requisitos. Devemos testar o programa ` medida que o programa é testado, realizando as tarefas usuais e depois as excepcionais. A os erros encontrados s˜ ao corrigidos (veja se¸caõ 6.9). Documenta¸ c˜ ao Das especifica¸co˜es, dos assuntos, das classes, das associa¸co˜es, dos métodos e dos atributos. Descri¸caõ do c´ odigo para programadores. Cria¸caõ do arquivo de Ajuda [help] e dos manuais do programa (veja se¸caõ 6.10). Manuten¸ c˜ ao do programa Objetiva incluir aperfei¸coamentos e corrigir problemas (veja se¸caõ 6.11). Nota: embora o teste esteja representado como uma etapa estanque (por quest˜ oes de didática), ele deve ser realizado ao longo de todo o ciclo de desenvolvimento. Pessoalmente gosto de verificar e testar tudo o que j´ a desenvolvi a cada ciclo de itera¸caõ.

5.5


Vimos que o uso de um modelo de engenharia de software é u ´ til para o desenvolvimento de softwares profissionais que aliem caracter´ısticas como funcionalidade, confiabilidade, usabilidade e eficiência. Quando n˜ ao usamos engenharia de software, ou usamos modelos inadequados, temos como conseq¨ uência a gera¸caõ de c´ odigos in´ uteis, nunca utilizados e geradores de bugs. Uma palavra final sobre modelagem: escolha um modelo que se adapta às suas caracter´ısticas pessoais. Se você est´ a acostumado a desenvolver modelos, use um modelo como TMO (veja se¸caõ 5.3.7) ou o apresentado na se¸caõ 5.4. Se você gosta de ir mais r´ apido para a etapa de programa¸caõ, pense em usar XP (veja se¸caõ 5.3.9). Uma posi¸caõ intermedi´ aria é dada por UP (veja se¸caõ 5.3.8). No Cap´ıtulo 6 – Etapas de para o desenvolvimento de um programa, veremos passo-a-passo as etapas para o desenvolvimento de um programa utilizando uma metodologia mista, que envolve etapas do método TMO, dicas dos métodos espiral, iterativo, de UP e de XP.

5.6

Exerc´ıcios

1. Pesquise no dicion´ ario os termos engenharia e software. 2. Quais as caracter´ısticas comuns aos diferentes modelos de engenharia de software? 3. Por que modelos baseados em prototipagem falham? 4. Quando devemos utilizar um modelo como o espiral? 5. Qual a dificuldade para aplicar o modelo UP? Programa¸caõ Orientada a Objeto com C++


5.6. EXERCÍCIOS

107

Figura 5.1: Etapas de desenvolvimento de um software e os documentos gerados. doc Espeficicação.doc Diag. de caso de uso

Concepção Iterações (testes) doc Elaboração

Anotações

AOO.doc Diag. de classes, de maq.estado, sequência, comunicação e atividade.

doc Análise Orientada a Objeto

doc Projeto do Sistema

Projeto sistema.doc

doc

POO.doc Diag. Componentes, de execução.

Projeto Orientado a Objeto

doc Implementação

Implementação.doc

doc Testes/Depuração

Documentação.doc Testes/Bugs

Ciclo de manutenção Documentação Desenvolvimento de novas funcionalidades, módulos, sub-sistemas.

6. Por que XP falha em sistemas novos? Por que XP é adequado para o desenvolvimento de varia¸co˜es de sistemas existentes? 7. Fa¸ca uma an´ alise cr´ıtica das 12 regras de XP. Por exemplo: o que significa ”fazer o planejamento ao longo de todo projeto”? 8. Fa¸ca uma an´ alise cr´ıtica do modelo de engenharia de software selecionado. Dica: você quer fazer um churrasco no domingo mas n˜ ao sabe se vai ter sol? A dica do professor Nivaldo é ir até o site do CPTEC, http://tempo.cptec.inpe.br/, e, em seguir, digitar o nome de sua cidade no campo :: Previs˜ oes — Digite o nome da Cidade . O site mostra a previs˜ ao para hoje e para os próximos quatro dias e inclui: temperaturas máximas e m´ınimas, hora do sol nascente e do sol poente, raios UV, e ´ıcones com previs˜ ao de sol/chuva/nublado.



108


5.6. EXERCÍCIOS


Cap´ıtulo 6

Etapas para o Desenvolvimento de um Software Mostraremos neste cap´ıtulo as etapas para o desenvolvimento de um software, o qual tem uma liga¸caõ direta com o modelo apresentado na se¸caõ 5.4 e com a UML apresentada no Cap´ıtulo 4 – Modelagem orientada a objeto. Na primeira edi¸caõ os diagramas foram descritos no Cap´ıtulo 3, e as etapas para desenvolvimento do software no Cap´ıtulo 4. O leitor precisava ler o Cap´ıtulo 3, depois o 4 e novamente o 3 e o 4, pois existiam interdependências. Nesta edi¸caõ as etapas para o desenvolvimento de software incluem a apresenta¸caõ dos diversos diagramas. Por exemplo: na se¸caõ 6.4.1 apresentamos um conjunto de regras que auxiliam o programador na identifica¸caõ das classes do programa. J´ a na se¸caõ 6.4.4 apresentaremos como modelar os aspectos estruturais do software utilizando diagramas de classe. Iniciaremos este cap´ıtulo apresentando o conceito de concep¸caõ (ou especifica¸ca õ) do software (se¸caõ 6.1), os casos de uso (se¸caõ 6.1.1) e os diagramas de casos de uso (se¸caõ 6.1.2). Em seguida, apresentaremos a elabora¸ca õ (se¸caõ 6.2) e os itens correlacionados como a an´ alise de dom´ınio (se¸caõ 6.2.1), a identifica¸caõ de pacotes (se¸caõ 6.2.2) e os diagramas de pacotes (se¸caõ 6.2.3). S˜ ao apresentadas ainda a montagem de prot´ otipos da interface (se¸caõ 6.2.5) e a defini¸caõ de cronogramas, prazos e custos (se¸caõ 6.2.6). Na se¸caõ 6.3 apresenta-se a AOO – an´ alise orientada a objeto, iniciando com a apresenta¸caõ do modelo estrutural (se¸caõ 6.4). Veremos descri¸co˜es dos elementos presentes em uma an´ alise orientada a objeto, e, em seguida, os diagramas UML correspondentes; a identifica¸caõ de classes (se¸caõ 6.4.1) e os diagramas de classe (se¸caõ 6.4.4); a identifica¸caõ de atributos (se¸caõ 6.4.2), métodos (se¸caõ 6.4.3), associa¸co˜es (se¸caõ 6.4.5); a classe de associa¸caõ (se¸caõ 6.4.6) e os diagramas de classe com associa¸co˜es (se¸caõ 6.4.7); a identifica¸caõ de agrega¸co˜es e composi¸co˜es (se¸caõ 6.4.8) e os respectivos diagramas (se¸caõ 6.4.9); a identifica¸caõ de heran¸cas (se¸caõ 6.4.10) e os diagramas de classe com heran¸cas (se¸caõ 6.4.11). Veremos ainda o uso de restri¸co˜es (se¸caõ 6.4.13), realiza¸co˜es (se¸caõ 6.4.14) e dependências (se¸caõ 6.4.15). A identifica¸caõ de objetos (seçaõ 6.4.16) e o diagrama de objetos (se¸caõ 6.4.17). Descreve-se ainda a etapa de itera¸caõ (se¸caõ 6.4.20). No modelo dinˆ amico (se¸caõ 6.5), o foco é a intera¸caõ entre os objetos, atributos e métodos – como os objetos se comportam quando o programa est´ a sendo executado. Veremos a identifica¸caõ de eventos e mensagens (se¸caõ 6.5.1), os diagramas de seq¨ uência (se¸caõ 6.5.2), e de comunica¸caõ (se¸caõ 6.5.3). Aprenderemos também a identificar os diferentes estados assumidos pelos objetos (se¸caõ 6.5.4) e os diagramas de máquinas de estado (se¸caõ 6.5.5). 109

˜ – ESPECIFICAC ˜ 6.1. CONCEPC ¸ AO ¸ AO

110

Na etapa de projeto do sistema (se¸caõ 6.6), veremos a defini¸caõ da interface de programa¸caõ – API (se¸caõ 6.6.1), a sele¸caõ da implementa¸caõ de controle (se¸caõ 6.6.2) e das plataformas a serem suportadas (se¸caõ 6.6.3). Aprenderemos quando usar e como selecionar bibliotecas externas (se¸caõ 6.6.4) e a biblioteca gr´ afica a ser utilizada – GDI (se¸caõ 6.6.5), além da sele¸caõ do ambiente de desenvolvimento integrado – IDE (se¸caõ 6.6.6). Na etapa do projeto orientado a objeto (se¸caõ 6.7), veremos os diagramas de componentes (se¸caõ 6.7.1) e de implanta¸caõ (execu¸caõ) (se¸caõ 6.7.2). Na etapa de implementa¸ca õ (se¸caõ 6.8), veremos conceitos relacionados ao teste de software (se¸caõ 6.9), ao porquê de se testar (se¸caõ 6.9.1), ` a equipe (se¸caõ 6.9.2) e à metodologia de teste (se¸caõ 6.9.3). Finalmente veremos porque a documenta¸ca õ dos programas é t˜ ao importante (se¸caõ 6.10), além do uso de cartões CRC (se¸caõ 6.32), a manuten¸ca õ (se¸caõ 6.11) e o reuso do software (se¸caõ 6.11).

6.1

Concep¸ c˜ ao – especifica¸c˜ ao

A primeira etapa do desenvolvimento de um software é a concep¸caõ, a defini¸caõ de requisitos a serem satisfeitos e a especifica¸caõ do sistema (descri¸caõ do objetivo e o que se espera do sistema a ser desenvolvido, o contexto da aplica¸caõ). Na concep¸caõ ocorre a primeira reuni˜ ao da equipe de desenvolvimento com os clientes, quando é feita a especifica¸caõ do software. O cliente por meio das especifica¸co˜es e das entrevistas, passa para o analista idéias gerais de uso do sistema. O resultado da etapa de especifica¸caõ é um conjunto formal de documentos e requisitos organizados pelo analista do sistema com apoio dos usuários. As especifica¸co ˜es definem as caracter´ısticas gerais do programa, aquilo que ele deve realizar e n˜ ao a forma como ir´ a fazê-lo. Definem as necessidades a serem satisfeitas. Envolvem a sele¸caõ do tipo de interface (modo texto ou gr´ afica), a forma de intera¸caõ com o usuário (teclado, mouse); se vai ter uma ou m´ ultiplas janelas; se o programa vai imprimir seus resultados, o formato dos arquivos de disco; se vai existir um helpe seu formato. Podem ser especificadas caracter´ısticas de desempenho. O cliente define o que deve obrigatoriamente ser satisfeito e o que é opcional – isto é, tudo o que o software deve ser. • As especifica¸co˜es devem ser bem feitas, porque s˜ ao a base para a etapa de an´ alise orientada a objeto (veja se¸caõ 6.1.1). • Cuidado com ambig¨ uidades e com termos vagos nas especifica¸co˜es; seja claro. • Observe que os diagramas de caso de uso podem ser utilizados na etapa de especifica¸caõ (veja se¸caõ 6.1.2). • Fa¸ca o teste das especifica¸co˜es (veja a se¸caõ 6.9, sobre teste de software). • Na medida do poss´ıvel, ap´ os a an´ alise de dom´ınio (veja se¸caõ 6.2.1), os limites do sistema e os atores externos devem estar claros. Dica: a comunica¸caõ com o cliente pode ser melhorada com o uso de met´ aforas, como, por exemplo, a met´ afora da ”lixeira”. Programa¸caõ Orientada a Objeto com C++



6.1.1

111

Casos de uso do software – cen´ arios

Segundo [Blaha and Rumbaugh, 2006], ”um cen´ ario pode ser um registro histórico de execu¸caõ de um sistema real ou um experimento de execu¸caõ teórica de um sistema proposto”. Um caso de uso descreve um ou mais cenários de uso do software, exemplos de uso, como o sistema interage com usu´ arios externos (atores). Ademais, ele deve representar uma seq¨ uência t´ıpica de uso do programa (a execu¸caõ de determinadas tarefas-padrão). Também deve representar as exce¸co˜es, casos em que o usu´ ario comete algum erro, em que o sistema n˜ ao consegue realizar as tarefas solicitadas. Segundo [Pressman, 2002], o caso de uso deve ”produzir uma descri¸caõ clara e n˜ ao amb´ıgua de como o usu´ ario final e o sistema interagem um com o outro”. [Pressman, 2002] diz ainda que ”uma vez definidos o ator e seu caso de uso, uma hierarquia de comandos é identificada”. Devem ser montados diversos diagramas de caso de uso. Por exemplo: para cada cenário, crie diagramas de seq¨ uência listando os objetos e os diversos eventos que partem de um objeto para outro (veja se¸caõ 6.5.2). A Tabela 6.1 mostra os itens a serem inclu´ıdos na descri¸caõ do caso de uso, podendo-se ainda incluira lista de atores e as pré-condi¸co˜es para execu¸caõ. O item etapas é opcional, pois elas podem ser inclu´ıdas diretamente no diagrama de caso de uso (veja se¸caõ 6.1.2) Uma vez apresentados os conceitos relacionados aos casos de uso, cenários, apresentaremos como modelar os cen´ arios com os diagramas de caso de uso da UML. Tabela 6.1: Exemplo de caso de uso. Nome do caso de uso: Resumo/descri¸caõ: Etapas:

Cen´ arios alternativos:

6.1.2

C´ alculo da integral de uma fun¸caõ. Determina¸caõ da integral de uma fun¸caõ em um dado intervalo. 1. Criar objeto fun¸caõ. 2. Criar objeto de integra¸caõ. 3. Definir intervalo de integra¸caõ e n´ umero de pontos. 4. Calcular ´ area da fun¸caõ. 5. Gerar gr´ aficos. 6. Analisar resultados. Um cen´ ario alternativo envolve uma entrada errada do usuário (por exemplo, a fun¸caõ é logar´ıtmica, e o intervalo vai de -1 a 10). O programa apresentar´ a um bug quando for determinar o logar´ıtmo de -1.

Diagrama de casos de uso

´ o diagrama mais O diagrama de casos de uso é uma representa¸caõ visual dos casos de uso. E simples da UML, sendo utilizado para demonstrar os cenários de uso do sistema pelos usuários, os quais ao verem esses diagramas ter˜ ao uma visão geral do sistema. O diagrama de caso de uso pode ser utilizado durante e ap´ os a etapa de especifica¸caõ, adicionando às especifica¸co˜es textuais alguns cenários de uso do programa a ser desenvolvido. A Figura 6.1 mostra um diagrama de caso de uso. O diagrama de caso de uso pode incluir: atores, elipses, generaliza¸co˜es, associa¸co˜es, pacotes, inclus˜ oes, extensões, notas e restri¸co˜es. • Um ator é um boneco utilizado para representar um usuário, um sistema, um hardware, Programa¸caõ Orientada a Objeto com C++



112

uma entidade que interage com o sistema. O ator comunica-se com o sistema somente com associa¸co˜es. Um diagrama de caso de uso pode incluir um ou mais atores. • Dentro das elipses s˜ ao inclu´ıdas descri¸co˜es das etapas, a¸co˜es e opera¸co˜es que ser˜ ao executadas pelo sistema. Uma elipse também pode incluir um caso de uso, que ser´ a detalhado em outro diagrama ou em uma tabela (veja Tabela 6.1).

C souldeçãum sopa:FrunCçãálcuodaAcesoasitem jAnalisresulutdadoCsaolcsuiterm d a e a a . SÁriaem á ã f n ç o u Atorusário uársiaoa:tofub).jneçtãoodeintgraçãoD C(daáreslitacodohaebrCjm á ã l f a c a r e a n ç o u u C ã f i l i t t e n r e r a o n e g r a ç o v á f i e r a g c o s G CetofunçãoAtorusário Analisresultadosgnuplot

• Um associa¸ c˜ ao entre um ator e uma elipse é representada por uma seta. A associa¸caõ pode ligar ainda dois atores e incluir estereótipos como < > e < >. O diagrama de caso de uso geral da Figura 6.1 mostra o usuário acessando os sistemas de ajuda do software, calculando a ´ area de uma fun¸caõ ou analisando resultados. No exemplo da Figura 4.9, o caso de uso de Acesso ao sistema de ajuda é detalhado. Observe que ilustramos o acesso aos diferentes tipos de manuais que o usuário poder´ a acessar. Figura 6.1: Diagrama de caso de uso – um caso de uso geral.

O caso de uso Calcular ´ area fun¸caõ descrito na Figura 6.1 e na Tabela 6.1 é detalhado na Figura 6.2. O usuário criar´ a um objeto fun¸caõ matemática, um objeto para sua integra¸caõ; em seguida, definir´ a o intervalo de integra¸caõ, calcular´ a a área da fun¸caõ criada e, por fim, analisará os resultados (eventualmente gerar´ a gr´ aficos com os resultados obtidos utilizando um sistema externo, como o programa gnuplot ). Este diagrama de caso de uso ilustra as etapas a serem executadas pelo usu´ ario ou sistema, a itera¸caõ do usuário com o sistema. Figura 6.2: Diagrama de caso de uso – calcular área fun¸caõ.

Especializa¸ c˜ ao/Generaliza¸ c˜ ao

Em um diagrama de caso de uso, um ator ou um caso de uso (elipse) pode ser especializado/generalizado. Uma generaliza¸caõ de um caso de uso mostra que este pode ser realizado de uma forma mais espec´ıfica. Funciona da mesma forma que heran¸ca em classes; o caso de uso geral deve ser abstrato, e os casos de uso herdeiros, espec´ıficos. Veja na Figura 6.3 a generaliza¸caõ do ator respons´ avel por gerar os gr´ aficos do sistema. Neste exemplo os gráficos poder˜ ao Programa¸caõ Orientada a Objeto com C++


stáolighdaerm ufcsno:)lta.dosG ã l i eragáficosAnalm e n r a ç o z A(Ccdaenm A g i d c q e s u á d f i e r a o e r c o s g g á f d r o s p m i l d t s r e s a o s u l s l t n c a e u v , g i b o c a . i l b s c a ó i l i t t t r e a r o o c a e v E Ator?usário gnuplot


113

ser gerados pelos programas externos gnuplot, octave ou scilab. Da mesma forma como ocorre em heran¸cas, toda a estrutura é herdada e novas caracter´ısticas e varia¸co˜es comportamentais podem ser adicionadas. Figura 6.3: Diagrama de caso de uso: analisar resultados (uso de generaliza¸caõ).

Inclus˜ ao

Quando um caso de uso é comum, o mesmo pode ser inclu´ıdo em outro. No exemplo da Figura 6.4, ”An´ alisar várias fun¸co˜es”, o usu´ ario ir´ a analisar várias curvas, repetindo várias vezes o caso de uso ”Analisar resultado”. Observe que fazemos referência ao caso de uso ”Analisar resultados” ilustrado na Figura 6.3 usando uma seta tracejada e o estereótipo < >. Figura 6.4: Diagrama de caso de uso – Analisar várias fun¸co˜es (uso de inclus˜ ao). Analisar resultados <>

Analisar várias curvas/funções Ator-usuário

Extens˜ ao Na Tabela 6.1, inclu´ımos uma excess˜ ao, um caso de uso excepcional, o mesmo pode ser representado como uma extensão do caso de uso da Figura 6.2. Veja na Figura 6.5, como representar uma extensão do caso de uso ”Calcular área fun¸caõ”, observe o uso do estereótipo < >, a inclus˜ ao de uma elipse que lembra que o usuário pode entrar com dados errados. Inclu´ımos ainda uma anota¸caõ lembrando a necessidade de se criar uma rotina para controle da entrada de dados. A seta tracejada aponta para o caso de uso que utiliza o caso de uso extendido. Um caso de uso < > pode ser descrito por uma anota¸caõ.

6.1.3

Senten¸cas para casos de uso

• Os casos de uso fornecem uma vis˜ ao externa do sistema (eventos externos) [Fowler and Scott, 2000]. • Cada diagrama de caso de uso deve ter um nome u ´ nico, indicado no canto superior esquerdo, dentro de uma nota. Programa¸caõ Orientada a Objeto com C++


˜ 6.2. ELABORAC ¸ AO

114

Figura 6.5: Diagrama de caso de uso – entrada de dados errada (uso de extensão). Caso de uso: Exemplo de extensão do caso de uso "Calcular área função"

Calcular área função

<>

Entrada de dados errada Ator-usuário

• Segundo [Blaha and Rumbaugh, 2006], um ator deve ter um prop´ osito u ´ nico e coerente. • Um caso de uso pode ser generalizado, pode ser extendido. Use o estereótipo < > para indicar que o caso de uso é uma extensão de outro caso de uso, e o estereótipo < > para indicar que um caso de uso inclui outro. • Deve-se criar um dicion´ ario com o nome dos casos de uso e uma breve descri¸caõ. Nome do caso de uso: Nome do caso de uso:

Descri¸caõ/Resumo Descri¸caõ/Resumo

• Um diagrama de caso de uso pode ser ampliado para incluir intera¸co˜es entre objetos do sistema, sendo tranformado em diagrama de comunica¸caõ (veja se¸caõ 6.5.3). • Uma mesma pessoa pode representar mais de um ator em um sistema, devendo ser representado separadamente. – Exemplo: um coordenador de curso de uma universidade também costuma ser um professor. • Observe que sistemas complexos podem ser utilizados por diferentes tipos de usuário. Se isto ocorrer, inclua nos casos de uso os diferentes tipos de usuário. – Exemplo: alguns programas modificam sua interface em fun¸caõ do tipo de usuário: iniciante, intermedi´ ario ou avan¸cado. • Na UML 2, os elementos de um caso de uso podem incluir multiplicidades. • Verifique se as especifica¸co˜es atendem aos requisitos b´ asicos da engenharia de software. Teste: quando finalizar a etapa de concep¸caõ, fa¸ca o teste das especifica¸co˜es (veja item 1 na se¸caõ 6.9).

6.2

Elabora¸c˜ ao

Depois da defini¸caõ dos objetivos, da especifica¸caõ do software e da montagem dos primeiros diagramas de caso de uso, a equipe de desenvolvimento passa por um processo de elabora¸caõ que envolve o estudo de conceitos relacionados ao software a ser desenvolvido, a an´ alise de dom´ınio e a identifica¸caõ de pacotes. Programa¸caõ Orientada a Objeto com C++



115

Na elabora¸caõ fazemos uma an´ alise dos requisitos, ajustando os requisitos iniciais de forma a desenvolver um sistema u ´ til, que atenda a`s necessidades do usuário e, na medida do poss´ıvel, permita seu reuso e futura extensão. Eliminam-se os requisitos ”imposs´ıveis”, e ajusta-se a idéia do sistema de forma que este seja flex´ıvel, considerando-se aspectos como custos e prazos. Veja a seguir uma lista de atividades a serem realizadas na elabora¸caõ (veja Figura 6.6): • Realizar a an´ alise de dom´ınio (veja se¸caõ 6.2.1). • Identificar pacotes (assuntos) (veja se¸caõ 6.2.2). • Montar o(s) diagrama(s) de pacotes (veja se¸caõ 6.2.3). • Revisar as especifica¸co˜es/requisitos do sistema deixando-os mais precisos, sem ambig¨ uidades e inconsistências, [Blaha and Rumbaugh, 2006].

6.2.1

An´ alise de dom´ınio

A an´ alise de dom´ınio é uma parte da elabora¸caõ; seu objetivo é entender o dom´ınio, a abrangência do sistema a ser desenvolvido. Envolve itens como estimar o reuso do software utilizando-se da cria¸caõ de bibliotecas genéricas. Neste ponto, o analista pensa no sistema de uma forma mais genérica, identificando conceitos fundamentais que podem ser reaproveitados em outros sistemas. Por exemplo: o uso ou o desenvolvimento de padr˜ oes de projeto s˜ ao etapas da an´ alise de dom´ınio (Veja Figura 6.6). • Estudo dos requisitos/especifica¸co˜es do sistema. • Defini¸caõ e caracteriza¸caõ do dom´ınio a ser investigado (´ area dos programas e bibliotecas a serem investigadas). Uma boa maneira de identificar os assuntos relacionados ao sistema que est´ a sendo desenvolvido é dar uma olhada nos livros, manuais e artigos da área. • Manter contato com especialistas que tenham dom´ınio dos conceitos envolvidos. Segundo [Fowler and Scott, 2000], estas pessoas ”devem ser abertas, ter bastante conhecimento prático e estar dispon´ıveis para perguntas”. • Deve-se fazer entrevistas com os usu´ arios do software (para detalhamento dos diagramas de caso de uso). • Identifica¸caõ de amostras (instalar e testar programas e bibliotecas similares). • Na elabora¸caõ deve-se analisar a possibilidade de se reaproveitar projetos antigos (bibliotecas externas, programas existentes etc). Procurar as classes em bibliotecas existentes antes de implement´ a-las [Pressman, 2002]. Se a equipe de desenvolvimento já tem experiência com algumas bibliotecas (como a STL, bibliotecas da GNU, bibliotecas GPL), isto deve ser considerado. A idéia é reaproveitar o conhecimento legado. • Identifica¸caõ e defini¸caõ dos objetos genéricos (a serem reutilizados). Talvez o aspecto mais importante da elabora¸caõ seja o contato com o cliente. Quando o cliente/usu´ ario tem uma no¸caõ b´ asica de como o sistema é desenvolvido, ele passa a fazer solicita¸co˜es que ser˜ ao mais facilmente implementadas. Programa¸caõ Orientada a Objeto com C++



116

Figura 6.6: Elabora¸caõ e an´ alise de dom´ınio (adaptado de [Pressman, 2002]). Análise de Domínio: Modelo genérico, assuntos, classes, e relacionamentos genéricos.

Universo de conhecimentos relacionados ao sistema.

Etapas da elaboração

Análise dos requisitos

Requisitos Consulta Consulta

Consulta a especialistas

Livros, manuais, literatura tecnica

Análise de domínio

Consulta Bibliotecas Especialistas

Entrevistas Analista

Consulta Programas existentes

Identificação e Montagem dos Diagramas de pacotes

Entrevistas Usuário Cliente

6.2.2

Revisão dos requisitos

Identifica¸c˜ ao de pacotes – assuntos

Um assunto é aquilo que é tratado ou abordado em uma discuss˜ ao, em um estudo e é utilizado para orientar o leitor em um modelo amplo e complexo. • Se um grupo de classes troca muitas informa¸co˜es entre si, provavelmente as classes fazem parte de um mesmo assunto. Assim, classes que se relacionam por meio de conceitos em comum fazem parte de uma mesma ´ area, s˜ ao reunidas e formam um assunto (pacote). • Em um pacote, os nomes de classes e de associa¸co˜es devem ser semelhantes. • Preste aten¸caõ a semelhan¸cas na forma de c´ alculo. Procedimentos semelhantes indicam polimorfismo e s˜ ao candidatos a superclasses. Usualmente a classe mais genérica de uma hierarquia de classes identifica um assunto. • Em C++ é usual um pacote ser representado como umnamespace (os namespaces ser˜ ao descritos no Cap´ıtulo 10 – Namespace). Dica: monte um diagrama de pacotes (assuntos, módulos) (veja se¸caõ 6.2.3).

6.2.3

Diagrama de pacotes – assuntos, m´ odulos

Um diagrama de pacotes é u ´ til para mostrar as dependências entre as diversas partes do sistema; pode incluir: sistemas, subsistemas, hierarquias de classes, classes, interfaces, componentes, n´ os, colabora¸co˜es e casos de uso. O exemplo da Figura 4.2 apresenta um diagrama de pacotes para um sistema de métodos numéricos. Observe que o diagrama de pacotes inclui um pacote bibliotecas, o qual é dividido em bibliotecas matemáticas, de estat´ıstica e de simula¸caõ. A seguir o componente biblioteca de simula¸caõ ser´ a detalhado. Outro exemplo de diagrama de pacotes é apresentado na Figura 4.7. O programa grafo depende da biblioteca grafo; a biblioteca lib lmpt depende das bibliotecas confeq, stl, grafo e TReconstru¸caõ. Programa¸caõ Orientada a Objeto com C++



6.2.4

117

Senten¸cas para pacotes

• Pode-se agrupar casos de uso dentro de um pacote. • A referência a um elemento de um pacote em um diagrama deve incluir o nome do pacote (exemplo: NomeDoPacote::elemento). • Dentro de um pacote n˜ ao podem existir nomes repetidos. O nome do pacote pode ser igual ao nome da -superclasse. • De um modo geral uma hierarquia de classes faz parte de um u ´ nico pacote, e a superclasse deve ser uma classes de interface (abstrata). Depois de realizar a an´ alise de dom´ınio, identificar e montar os primeiros diagramas de pacotes, podemos montar um esbo¸co, um prot´ otipo da interface do software. Note que esta etapa é opcional.

6.2.5

Montagem de prot´ otipo da interface do software

O prot´ otipo da interface do software é uma vers˜ ao simplificada do software que vai ser desenvolvido. No prot´ otipo, os ´ıcones, botões, menus e diálogos s˜ ao implementados visualmente em um software do tipo RAD (como o qt-designer ). Observe que n˜ ao existe o c´ odigo; existe apenas a casca externa do software, de modo que, ao pressionar um botão, nenhuma a¸caõ é realizada. Veja a seguir algumas dicas para montagem do prot´ otipo do software: • Para iniciar a montagem do prot´ otipo, parta da interface de programas existentes, das especifica¸co˜es do software, do conhecimento dos usuários e procure fazer um prot´ otipo o mais simples poss´ıvel. • Como a interface é geradora de muitos eventos, ela deve servir de base para a montagem de diversos cen´ arios. Talvez seja necess´ ario montar novos diagramas de caso de uso. • Todos os eventos identificados na elabora¸caõ do prot´ otipo foram devidamente considerados? • Deve-se testar o prot´ otipo desenvolvido (veja se¸caõ 6.9, sobre teste de software). • Finalizado o prot´ otipo, ele deve ser apresentado e testado pelos clientes. Obtenha um retorno dos usu´ arios, sua avalia¸caõ do prot´ otipo. Responda a quest˜ oes como: i) ele responde ` as necessidades levantadas nas especifica¸co˜es? ii) est´ a faltando alguma coisa? iii) a interface utilizada é adequada (usabilidade)? A Figura 6.7 mostra que os eventos gerados pelos atores (eventos do teclado, do mouse e de dispositivos externos como a entrada auxiliar) s˜ ao tratados por um controlador. O controlador organiza a fila de eventos e os distribui para os diferentes objetos do sistema. S˜ ao mostrados ainda os eventos e mensagens gerados e trocados entre os objetos que compõem o sistema. Teste: quando terminar a montagem do prot´ otipo fa¸ca o teste da interface (veja item 2, na se¸caõ 6.9.3). Ap´ os a etapa de elabora¸caõ – an´ alise de dom´ınio, identifica¸caõ e montagem dos diagramas de pacotes – e a cria¸caõ do prot´ otipo da interface, eles devem ser documentados, organizados e apresentados ao cliente. Deve-se definir ainda quest˜ oes como cronogramas, prazos e custos. Programa¸caõ Orientada a Objeto com C++



118

Figura 6.7: Interface gr´ afica e eventos. Interface e eventos. Uma interface gráfica como a ilustrada ao lado, gera muitos eventos (teclado, mouse, outros dispositivos). Mensagens de outros dispositivos

Interface gráfica do programa SAIL.

Controle (recepção e distribuição) das mensagens.

Mensagens do Mouse controlador Mensagens do teclado

Objeto

Objeto Objeto

6.2.6

Troca de mensagens diretas entre objetos do sistema.

Defini¸c˜ ao de cronogramas, prazos, custos, contratos

As quest˜ oes de prazos, montagem da equipe de desenvolvimento, custos, contrato, medi¸co˜es e controle das atividades desenvolvidas, entre outras, n˜ ao s˜ ao focos deste livro. Para maiores detalhes consulte as referências [Pressman, 2002, Martin and McClure, 1993, Emerson Rios, 2004, Sonerviile, 1993].



´ 6.3. AOO – ANALISE ORIENTADA A OBJETO

6.3

119

AOO – An´ alise Orientada a Objeto

A terceira etapa do desenvolvimento de um programa é a AOO – An´ alise Orientada a Objeto. A AOO utiliza algumas regras para identificar os objetos de interesse, as rela¸co˜es entre os pacotes, as classes, os atributos, os métodos, as heran¸cas, as associa¸co˜es, as agrega¸co˜es, as composi¸co˜es e as dependências. O modelo de an´ alise deve ser conciso, simplificado e deve mostrar o que deve ser feito, n˜ ao se preocupando como isso ser´ a realizado. O resultado da an´ alise é um conjunto de diagramas que identificam os objetos e seus relacionamentos. A AOO envolve o desenvolvimento de doismodelos: • O modelo estrutural (veja se¸caõ 6.4). • O modelo dinˆ amico (veja se¸caõ 6.5).

6.4

AOO – Modelo estrutural

O foco do modelo estrutural é a an´ alise da estrutura do sistema, dos objetos e de seus relacionamentos. Este modelo é desenvolvido em camadas; veja a Figura 4.2. Em uma primeira camada s˜ ao montados os diagramas de pacotes (se¸caõ 6.2.3), mostrando o relacionamento dos dos módulos e subsistemas. Em seguida, cada pacote é detalhado, incluindo-se os diagramas de componentes; em uma terceira camada s˜ ao montados os diagramas de classes (se¸caõ 6.4.4, 6.4.6, 6.4.9, 6.4.11) e os diagramas de objetos (se¸caõ 6.4.17). Opcionalmente, em uma quarta camada, montamos os diagramas de estrutura composta (se¸caõ 6.4.18). Observe que a cada nova camada o n´ıvel de detalhamento do sistema é maior. Na maioria dos programas o modelo estrutural é o mais importante, pois representa e identifica os objetos e os relacionamentos que compõem o sistema, sendo utilizado por ferramentas CASE, como o umbrello, para montar o c´ odigo inicial do programa. Como o modelo estrutural é constitu´ıdo de elementos que são facilmente reconhecidos tanto pelos clientes como pelos desenvolvedores, este modelo permite uma maior comunica¸caõ no desenvolvimento do programa. Veremos a seguir como identificar as classes (objetos) e como devemos montar os diagramas de classes usando UML. Nota: o modelo estrutural equivale em parte ao modelo de objetos da OMT.

6.4.1

Identifica¸c˜ ao de classes

Segundo a técnica de [Booch, 1986], podemos iniciar nossa an´ alise estudando as especificaço˜es do programa. Para encontrar candidatas a classes, pegue as especifica¸co˜es e sublinhe os substantivos. Depois fa¸ca uma an´ alise mais detalhada das poss´ıveis classes, eliminando as desnecess´ arias e acrescentando alguma outra que tenha surgido. Segundo [Booch, 1986], os verbos nas especifica¸co˜es costumam referenciar métodos (veja se¸caõ 6.4.3). Senten¸ cas para identificar classes Veja se seguir um conjunto de dicas de [Johnson and Foote, 1998] que nos ajudam a identificar as classes. Programa¸caõ Orientada a Objeto com C++


120

6.4. AOO – MODELO ESTRUTURAL

• A nova classe representa uma abstra¸caõ significativa para o dom´ınio do problema. • Modelar com classes as entidades que ocorrem naturalmente no dom´ınio do problema. • A classe é complexa. • O conjunto de métodos da classe é freq¨ uentemente utilizado por outras classes. • Se representada como um método de uma outra classe, poucos usuários desta classe a solicitariam. Senten¸ cas para conserva¸ c˜ ao das classes corretas2 Veja a seguir um conjunto de dicas de [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006] que nos ajudam a eliminar as classes desnecessárias. • Se a classe n˜ ao estiver muito clara, se n˜ ao se encaixar bem no problema, você deve elimin´ ala, ou encaixá-la dentro de outra. • Se duas classes representam a mesma informa¸caõ, uma delas deve ser eliminada. • Em uma associa¸caõ, costuma-se atribuir a cada classe o seu papel. O nome a ser dado à classe deve representar seu conceito b´ asico e n˜ ao o papel que ela exerce em uma associa¸caõ. • Se um atributo costuma ser acessado muitas vezes isoladamente, representando um conceito, e se for independente, transforme-o em uma classe. • Conceitos relacionados ` a implementa¸caõ das classes devem ser inclu´ıdos apenas na etapa de projeto (veja se¸caõ 6.7). Dica: revise o diagrama de classes (veja se¸caõ 6.4.4), incluindo as classes que foram identificadas.

6.4.2

Identifica¸c˜ ao de atributos

Os atributos devem ter nomes significativos, devem representar uma propriedade do objeto, do dom´ınio da aplica¸caõ ou do mundo real. Segundo [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006], os atributos podem ser identificados por substantivos seguidos por frases possessivas como ”a cor da cadeira” ou ”a posi¸caõ do cursor”. Os adjetivos muitas vezes representam valores de atributos espec´ıficos e enumerados. Um atributo derivado é aquele que é obtido a partir de outros atributos. Por exemplo: se você tem o raio de um c´ırculo, pode obter sua área e seu per´ımetro. Neste caso, o raio seria um atributo normal; a ´ area e o per´ımetro seriam atributos derivados, os quais devem ter uma nota¸caõ diferente, mas n˜ ao podem ser omitidos. Na etapa de projeto eles poder˜ ao ser especificados por meio de um método (um método calcular´ a a área e outro, o per´ımetro). Os atributos de associa¸caõ devem ser claramente identificados, pois existem em fun¸caõ de uma associa¸caõ entre dois ou mais objetos (veja a se¸caõ 6.4.7 e a Figura 6.10). Atributos coletivos (de classes ou est´ aticos) podem ser substitu´ıdos com vantagens por classes associadas. Programa¸caõ Orientada a Objeto com C++



121

Senten¸ cas para conserva¸ c˜ ao dos atributos corretos2 Segundo [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006], a conserva¸caõ dos atributos corretos envolve: • Se o atributo for pouco descritivo, poder´ a ser eliminado da an´ alise e inclu´ıdo no projeto. • Elimine da etapa de an´ alise todo e qualquer flag (valor booleano do tipo verdadeiro/falso). • Se uma propriedade depende da presen¸ca de uma associa¸caõ, ent˜ ao aquela pode ser implementada como um atributo da associa¸caõ (veja a se¸caõ 6.4.7 e a Figura 6.10). • Se a classe apresenta grupos de atributos que parecem comportar-se isoladamente, pense em dividir a classe. Dica: revise o diagrama de classes, incluindo os atributos que foram identificados.

6.4.3

Identifica¸c˜ ao de m´ etodos

Se o objeto identificado na AOO é um objeto real, é fácil identificar suas opera¸co˜es, mas existem métodos de dif´ıcil identifica¸caõ. Segundo [Booch, 1986], os verbos nas especifica¸co˜es costumam referenciar métodos. Adicionalmente, definir em que classe um determinado método deve ser colocado nem sempre é um processo fácil. A pergunta é: onde devo colocar este método? Em geral, um método deve ser colocado na classe-alvo. Se existe uma classe mais afetada por determinado método, o método deve ser colocado nessa classe. A inclus˜ ao de métodos pode ser realizada a todo instante, sendo realizada com base em um dos conceitos expostos a seguir [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006]. • Na etapa de modelagem, concentre-se no que o método faz, n˜ ao em como implement´ a-lo. • Projeteos métodos com um u ´ nico objetivo. • De modo geral, cada evento enviado a um objeto corresponde a um método no objeto (veja a se¸caõ 6.5.2). • A¸co˜es e atividades no diagrama de máquinas de estados podem ser métodos (veja a se¸caõ 6.5.5). • De modo geral, cada fun¸caõ do diagrama de atividade corresponde a um método (veja a se¸caõ 6.5.7). Senten¸ cas para conserva¸ c˜ ao dos m´ etodos corretos2 • Se um método manipula dados externos mais do que os da própria classe, considere mud´ alo de classe. • Se os métodos realizam trabalhos semelhantes, eles podem fazer parte de uma heran¸ca. • Projete um novo método quando se defrontar com a alternativa de ampliar um já existente. • Evite métodos extensos (m´ aximo 30 linhas). • Armazene como atributos de classe os atributos que s˜ ao necess´ arios a mais de um método ou a uma classe-base. Programa¸caõ Orientada a Objeto com C++


122


• Evite a chamada de um método em fun¸caõ do resultado de outro método. Dica: inclua no diagrama de classes os métodos que foram encontrados (veja a se¸caõ 6.4.4). Verifique os efeitos no diagrama de máquina de estado (veja a se¸caõ 6.5.5) e no diagrama de seq¨ uência (eventos) (veja a se¸caõ 6.5.2). Dica: veja na se¸caõ 6.11.4 senten¸cas para construir métodos robustos.

6.4.4

Diagrama de classes

Iniciaremos aqui a apresenta¸caõ dos diagramas de classes, os quais ser˜ ao utilizados para a montagem da vers˜ ao inicial do c´ odigo do programa pelo uso de geradores de c´ odigo (como o Umbrello), devendo ser bem desenvolvidos e entendidos. No diagrama de classes constam as classes (se¸caõ 6.4.1), seus atributos (se¸caõ 6.4.2), métodos (se¸caõ 6.4.3) e os relacionamentos entre as diversas classes, como associa¸co˜es (se¸caõ 6.4.5), agrega¸co˜es (se¸caõ 6.4.8), heran¸cas (se¸caõ 6.4.10), restri¸co˜es (se¸caõ 6.4.13), realiza¸co˜es (se¸caõ 6.4.14), e dependências (se¸caõ 6.4.15). Pode incluir ainda interfaces, colabora¸co˜es e anota¸co˜es. Observe na Figura 6.8 a representa¸caõ UML de uma classe. No primeiro bloco vai o nome da classe (sempre no singular); no segundo bloco, os atributos, e no terceiro,os métodos. Uma representa¸caõ mais detalhada dos atributos engloba sua visibilidade (+publico, #protegido ou -privado), seu tipo e valor. Os atributos de classe aparecem sublinhados. Da mesma forma, pode-se detalhar os métodos, incluindo os parˆ ametros, o retorno e o tipo de acesso. Veja que os atributos e métodos podem ou n˜ ao ser visualizados. Da mesma forma, detalhes como tipo de retorno de um método, tipo e n´ umero de parˆ ametros podem ou n˜ ao ser visualizados. Uma classe gabarito (template) representa um conceito genérico que pode ser implementado com diferentes tipos de objetos. Métodos e classes abstratas s˜ ao representados em itálico. Classes persistentes s˜ ao armazenadas em disco ou em uma base de dados e s˜ ao identificadas no diagrama de classe com o estereótipo < >. Figura 6.8: Diagrama de classes – representando classes. Diagrama de classe simples, classe template e abstrata.

Nome da classe

Diagrama de classe persistente detalhada com atributos e métodos.

Classe <>

Classe

ClasseAbstrata Assinatura

Nome dos atributos +atributo Nome dos métodos

+Método()

NomeTemplate:tipo <>

Classe +atributo +Método()

Diagrama de classe template


+atributoPublico: tipo = valor #atributoProtegido -atributoPrivado +atributoDeClasse +... +Metodo(P1:Tipo=valor): TipoRetorno +MetodoDeClasse()

Tipo de acesso (visibilidade) +publico, #protegido, -privado



6.4.5

123

Identifica¸c˜ ao de associa¸c˜ oes

As associa¸co˜es representam relacionamentos estruturais (permanentes). Segundo [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006], uma rela¸caõ ou conex˜ ao entre classes é uma associa¸caõ. Segundo esse autor, as associa¸co˜es correspondem muitas vezes a verbos est´ aticos ou locu¸co˜es verbais. O que inclui a posi¸caõ (com, parte de, contido em), as a¸co˜es (direciona), comunica¸co˜es (fala a), a posse (tem, parte de) e rela¸co˜es diretas (como trabalha para, casado com, gerencia). Uma liga¸caõ é uma instância de uma associa¸caõ. Observe que a associa¸caõ aparecer´ a no diagrama de classes, e a liga¸caõ, no diagrama de objetos. As associa¸co˜es podem ser implementadas de várias maneiras, mas as decis˜ oes de implementa¸caõ devem ser mantidas fora do modelo de an´ alise. Veja a seguir exemplos de associa¸co˜es. • Um jogador de futebol e uma bola s˜ ao dois objetos independentes, mas se desejarmos um jogo de futebol, teremos esses dois objetos se relacionando, formando uma associa¸caõ. • Quando um gerente solicita a um funcionário a realiza¸caõ de uma determinada tarefa, existe uma associa¸caõ entre o gerente e o funcionário. Senten¸ cas para associa¸ co ˜es2 • A UML representa associa¸co˜es n-árias utilizando losangos. • As associa¸co˜es podem ser tern´ arias ou de ordem mais elevada, mas na prática a maioria é binária. • Evite associa¸co˜es tern´ arias. N˜ ao amontoe os atributos de uma classe de associa¸caõ em uma classe-alvo. Utilize associa¸co˜es qualificadas onde for poss´ıvel. • Evite associa¸co˜es 1:1; geralmente esta é uma associa¸cão 1:0 ou 1:n, significando que o objeto associado pode ou n˜ ao existir. • Como um nome de papel pode representar um atributo do objeto, ele n˜ ao deve ter o mesmo nome dos atributos do objeto. • Geralmente as associa¸co˜es s˜ ao implementadas com a utiliza¸caõ de ponteiros, mas n˜ ao devem ser representadas no modelo de objetos com ponteiros (veja o Cap´ıtulo 15 – Ponteiros e referências.). • Uma rela¸caõ de uma classe consigo mesma é chamada de associa¸caõ un´ aria. • Se uma associa¸caõ tem um lado com muitos elementos (*), mas estes s˜ ao ordenados, podese utilizar o estereótipo{ordered}. O estereótipo {bag} indica um conjunto de objetos com repeti¸co˜es. O estereótipo {sequence} indica um conjunto de objetos ordenados com repeti¸caõ (como um ). Segundo [Blaha and Rumbaugh, 2006], os estereótipos {bag} e {sequence} indicam a possibilidade de liga¸co˜es m´ ultiplas para um par de classes. • Em uma associa¸caõ qualificada, o objeto do lado muitos (*) pode ser identificado pelo atributo qualificador. Programa¸caõ Orientada a Objeto com C++


124


Senten¸ cas para conserva¸ c˜ ao das associa¸ co ˜es corretas2 Depois de definidas as associa¸co˜es, deve-se verificar quais foram definidas incorretamente e descart´ a-las segundo os critérios a seguir, [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006]: • Descreva com clareza o que é a associa¸caõ, e n˜ ao o porquê de ela ocorrer. • Um evento transiente n˜ ao pode ser confundido com uma associa¸caõ (exemplo: uma batida entre um carro e uma moto). • Na medida do poss´ıvel, classes, atributos e associa¸co˜es devem representar informa¸co˜es diferentes. • Se faltam informa¸co˜es, os métodos n˜ ao percorrem a associa¸caõ, os papéis s˜ ao muito/pouco abrangentes, ent˜ ao a associa¸caõ é desnecessária. • Evite associa¸co˜es tern´ arias (entre três objetos). Subdivida-as. • Normalmente, uma associa¸caõ s´ o aparece em um diagrama; uma classe, por sua vez, pode aparecer em mais de um diagrama, mostrando a rela¸caõ entre os diferentes diagramas. Dica: revise o diagrama de classes, incluindo as associa¸co˜es que foram identificadas (veja se¸caõ 6.4.6).

6.4.6

Diagrama de classes com associa¸c˜ oes

Veja na Figura 6.9 como representar uma associa¸caõ. Observe que a associa¸caõ recebe um nome, podendo-se ainda definir o papel de cada classe que participa da associa¸caõ e sua multiplicidade. Se uma associa¸caõ for representada com uma seta, ela s´ o ser´ a executada na dire¸caõ da seta (unidirecional). Figura 6.9: Diagrama de classes – representando associa¸cões. NomeAssociação

Classe B +atributo

papel de B nb

Classe A

papel de A na

Representação de uma associação bidirecional.

Representação de uma dependência.

+atributo +Método()

{nomeRestrição}

+Método()

Class D

NomeDependência

Class C Class E

A seta indica a direção de execução da associação.

Representação de restrições: Uma restrição impõe uma dada condição ao relacionamento indicado.

Multiplicidade A multiplicidade é um tipo de restri¸caõ utilizada para indicar as quantidades de cada objeto em uma associa¸caõ (aparece no diagrama de classes). J´ a a cardinalidade indica Programa¸caõ Orientada a Objeto com C++



125

por meio de n´ umeros as quantidades de cada objeto em uma liga¸caõ (aparece no diagrama de objetos). Na Figura 6.9, a multiplicidade da classe A é nA (n´ umero de objetos do tipo A) e, da classe B, nB (n´ umero de objetos do tipo B). Os valores de multiplicidade podem ser: 1

um

1..n

um a n

1..*

um a infinito

0..1

0 ou 1

2..7

no m´ınimo 2 e no máximo 7

0..*

0 a infinito

*

infinito

Papel Quando uma associa¸caõ n˜ ao é clara, pode-se colocar no diagrama de classes o nome da associa¸caõ e/ou o nome do papel exercido por cada classe. Um papel é utilizado para indicar a forma como a classe vai atuar em uma associa¸caõ. Deve ter um nome un´ıvoco, normalmente um substantivo, que identifique com clareza o papel que a classe exerce na associa¸caõ. Em alguns casos um papel é uma restri¸caõ ao objeto. Por exemplo: uma empresa tem três secretárias, uma cuida da agenda do chefe, as outras duas trabalham na recep¸caõ. Observe que as três s˜ ao secretárias, mas o papel de cada uma é diferente. Restri¸ co ˜es Em um modelo de objetos as restri¸co˜es estabelecem rela¸cões funcionais entre objetos, classes, atributos e associa¸co˜es. Como exemplo de restri¸co˜es, podemos citar a restri¸caõ de que o raio de um c´ırculo n˜ ao ultrapasse determinado valor, a restri¸caõ de s´ o poder desenhar dentro da ´ area cliente de uma janela. Um modelo de objetos bem desenvolvido deve ter muitas restri¸co˜es. Veja na Figura 6.9 que as restri¸co˜es aparecem dentro de colchetes {}. A Figura ?? mostra que o aluno s´ o ser´ a aprovado se obtiver nota maior ou igual a seis. Dica: se um atributo apresenta uma multiplicidade n, como em uma seq¨ uência, ent˜ ao o mesmo poder´ a ser implementado utilizando um container da STL, como ou .

6.4.7

Classe de associa¸c˜ ao

No relacionamento de dois objetos, pode surgir uma propriedade que n˜ ao pertence a nenhum dos objetos originais, s´ o existindo quando ocorre a intera¸caõ. Por exemplo: na intera¸caõ do objeto telha (matriz s´ olida) com o objeto fluido (chuva) surge a propriedade tens˜ ao interfacial. A tens˜ ao interfacial é uma propriedade da associa¸caõ. Veja na Figura 6.10 a ilustra¸caõ de uma classe de associa¸caõ. Em alguns casos, a classe de associa¸caõ n˜ ao é criada, e seus atributos e métodos s˜ ao movidos para classe A ou B. Isto deve ser evitado na etapa de an´ alise, principalmente quando a associa¸caõ é do tipo *..* (muitos para muitos).

6.4.8

Identifica¸c˜ ao de agrega¸c˜ oes e composi¸c˜ oes

Quando unimos vários objetos simples para criar um objeto mais complexo, estamos utilizando uma agrega¸ca õ, também denominada estrutura todo-parte. Diz-se ”todo-parte” em que todo representa o objeto composto e parte, uma das partes que o compõem. Podemos dizer ainda ”uma parte de” ou ”tem um”. Programa¸caõ Orientada a Objeto com C++


126


Figura 6.10: Diagrama de classes – representando classes de associa¸caõ. Classe A

associação

nome: tipo = valor

Classe B nome: tipo = valor

Representação de classe de associação.

Classe de associação +atributo: tipo = valor +Metodo(): tipo

• Uma agrega¸caõ é uma propriedade transitiva, isto é, se A é parte de B e B é parte de C, ent˜ ao A é parte de C. • Uma agrega¸caõ é uma propriedade anti-simétrica, ou seja, se A é parte de B, ent˜ ao B n˜ ao faz parte de A. Em alguns casos, os dois objetos s´ o podem existir simultaneamente. • Uma agrega¸caõ pode ser recursiva, isto significa que um objeto pode conter um objeto de seu tipo. • Se houver d´ uvida em rela¸caõ a um objeto ser ou n˜ ao uma agrega¸caõ de outro, deve-se usar uma associa¸caõ. Composi¸ c˜ ao Uma composi¸caõ é uma agrega¸caõ forte, no sentido de que as partes s´ o poder˜ ao ser constru´ıdas a partir do todo. No exemplo da Figura 6.11, um volante s´ o existiria como parte de um carro. Senten¸ cas para conserva¸ c˜ ao das agrega¸ co ˜es e composi¸ co ˜es corretas2 • Ser´ a uma agrega¸caõ se você usar a express˜ ao ”parte de”. • Ser´ a uma agrega¸caõ se as opera¸co˜es executadas sobre um se propagarem para o outro. A propaga¸caõ ocorre quando uma opera¸caõ aplicada sobre um objeto se estende para os demais. • Ser´ a uma associa¸caõ se os dois objetos forem normalmente considerados separados.

6.4.9

Diagrama de classes com agrega¸c˜ oes e composi¸c˜ oes

Veja na Figura 6.11 como representar agrega¸co˜es e composi¸co˜es. Observe que uma agrega¸caõ é representada com um losango na classe todo e uma composi¸caõ é representada como um losango cheio. Observe que podemos incluir o papel e a multiplicidade de cada classe. Também podemos incluir um estereótipo.

6.4.10

Identifica¸c˜ ao de heran¸cas

Vimos na se¸caõ 3.6 o conceito de heran¸ca. A abstra¸caõ que utiliza o conceito de heran¸ca é poderosa, permitindo destacar o que é comum aos diversos objetos que compõem a heran¸ca, sem deixar de levar em conta as suas particularidades. Programa¸caõ Orientada a Objeto com C++



127

Figura 6.11: Diagrama de classes – representando agrega¸cões. Diagrama de classes representando agregações. No exemplo, um carro tem portas, a multiplicidade 2-6 indica que um carro pode ter de 2 a 6 portas. A composição indica que o carro obrigatoriamente deve ter um volante.

Parte +atributo

Porta Volante



2-6 <>

papel da parte na NomeAgregação <> papel do todo nb

+Método()

(a)

Todo

Carro

+atributo

+atributo

+Método()

+Método()

(b)

Neste ponto, podemos refinar o diagrama de classes incluindo o conceito de heran¸ca. Realize primeiro a generaliza¸caõ e depois a especializa¸caõ. Generaliza¸ c˜ ao A generaliza¸caõ (bottom-up) é realizada identificando-se atributos e opera¸co˜es semelhantes. No exemplo da Figura 6.12, um rel´ ogio é uma generaliza¸caõ de rel´ ogio cronˆ ometro e rel´ ogio alarme. Especializa¸ c˜ ao Especializa¸caõ é a cria¸caõ de classes-derivadas (filhas) a partir de uma classe-base (pai). As classes-derivadas têm acesso a todos os métodos e atributos da classe-base. A especializa¸caõ (top-down) pode ser verificada por meio de frases substantivas compostas por diversos adjetivos relativos ao nome da classe (exemplo: lâmpada incandescente, lˆ ampada fluorescente). Uma especializa¸caõ pode ter um nome como ”é um tipo de” ou ”é um”. No exemplo da Figura 6.12, um rel´ ogio cronˆ ometro é um tipo de rel´ ogio que foi especializado. Na especifica¸caõ do sistema podem ter sido definidos alguns subcasos, os quais s˜ ao candidatos à heran¸ca. Senten¸ cas para conserva¸ c˜ ao das heran¸ cas corretas2 • Se uma classe inclu´ıda na heran¸ca n˜ ao é um ”tipo de”, ent˜ ao ela deve ser eliminada da heran¸ca. • Se a classe foi inserida na heran¸ca apenas para aproveitamento de c´ odigo, ela deve ser eliminada. • Lembre-se que modifica¸co˜es na classe-base têm impacto nas classes-derivadas e devem ser feitas com cuidado. Senten¸ cas para solucionar problemas de heran¸ ca m´ ultipla2 Veja a seguir dicas de [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006] para solucionar problemas de heran¸ca m´ ultipla: • Se uma classe tem mais de um pai, isto é, heran¸ca m´ ultipla, poderemos eliminar problemas utilizando mecanismos de delega¸caõ (transferir responsabilidades). Programa¸caõ Orientada a Objeto com C++


128


• Nos casos em que uma das classes-base é mais importante que as demais, podemos utilizar heran¸ca desta e delega¸caõ para as demais. • Se uma das classes-base é o gargalo do desempenho, esta deve ser a superclasse. Dica: revise o diagrama de classes, incluindo as heran¸cas identificadas (veja se¸caõ 6.4.11).

6.4.11

Diagrama de classes com heran¸cas

Veja na Figura 6.12 como a UML representa as heran¸cas. Observe que a classe-base é mais genérica, e as classes-derivadas s˜ ao especializa¸co˜es da classe-base. A classe-derivada é ”um tipo de” classe-base. Discriminador Em um diagrama de classes, um discriminador costuma indicar qual propriedade de um objeto est´ a sendo generalizada.

Figura 6.12: Diagrama de classes – representando heran¸cas. Exemplo

Relogio

Base Representação de uma herança.

+atributo

+hora +Hora(): int +Hora(int:horaCerta): void

+Método() +MetodoAbstrato()

<<«Discriminador»>> NomeHerança

Derivada_A

Derivada_B

+atributo

+atributo

+Método()

+Método()

RelogioCronometro +tempoCronometro +TempoCronometro() +ZeraCronometro()

(a)

6.4.12

(b)

RelogioAlarme +horaAlarme +alarmeAtivo +HoraAlarme(): int +HoraAlarme(horaCerta:int): void

RelogioCronometroAlarme

Identifica¸c˜ ao de classes abstratas e classes de interface

Na Figura 3.2 da se¸caõ 3.2, vimos que o encapsulamento envolve a separa¸caõ do que é vis´ıvel ou n˜ ao ao usuário de um objeto. Esta separa¸caõ foi chamada de encapsulamento do objeto. O analista de sistema é respons´ avel por esta separa¸caõ, a qual envolve a identifica¸caõ e defini¸caõ dos métodos da classe que o usu´ ario poder´ a acessar. Esta defini¸caõ deve ser genérica e consistente, pois erros no encapsulamento s˜ ao trabalhosos para se corrigir. Depois de separar conceitualmente o que dever´ a ser p´ ublico e o que deverá ser privado, o analista usa, nos diagramas UML, o s´ımbolo ”+” para indicar que o atributo/método é p´ ublico (vis´ıvel) e os s´ımbolos ”#” e ”-” para indicar, respectivamente, protegido (vis´ıvel nas classesderivadas) ou privado (invis´ıvel). Depois de feito o encapsulamento, temos definido de forma mais clara qual ser´ a a interface de acesso ao objeto. Neste ponto, a modelagem orientada a objeto disponibiliza o conceito de classe de interface. Programa¸caõ Orientada a Objeto com C++



129

Uma classe de interface é uma classe genérica, que s´ o tem métodos vis´ıveis e costuma ser utilizada como classe-base de uma hierarquia de classes. Veja na Figura 6.13 que a visão do engenheiro de software é mais detalhada que a visão do usu´ ario, o qual vê apenas o que n˜ ao foi ocultado e que est´ a disponibilizado na classe de interface. Lembre-se, quando você faz um programa, você utiliza bibliotecas externas, feitas por outros programadores/analistas. Neste caso, você é o usuário, e n˜ ao importa os detalhes de como a biblioteca foi montada, o que interessa é sua forma de uso, sua interface. Como exemplo de classes de interface, veremos as classes (se¸caõ 33.1), (se¸caõ 33.2) e (se¸caõ 33.3). Dica: uma superclasse é a classe mais b´ asica de uma hierarquia de classes; normalmente é uma classe de interface. Figura 6.13: Classe de interface. Representação de uma classe de interface. A interface informa o que é público e pode ser acessado pelo usuário.

Visão do Engenheiro de software

NomeClasse Eng. Software

NomeClasse +MétodoVisivel()

+atributoVisível -atributoInvisível +MétodoVisivel() -MétodoInvisível() MétodoImplementacao ()

Uma classe de interface, não tem atributos, apenas métodos públicos. Usuário

Visão do Usuário

A linguagem C++ permite a montagem de classes de interfaces e de classes abstratas. A diferen¸ca é que uma classe abstrata tem pelo menos um método virtual puro, um método que é declarado mas n˜ ao é implementado. Como conseq¨ uência, uma classe abstrata n˜ ao pode ser utilizada para criar objetos. Senten¸ cas para elaborar classes abstratas2 Veremos a seguir dicas de [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006] para elaborar classes abstratas: • Acesse todos os atributos de uma classe somente pelo envio de mensagens. As classes ficar˜ ao mais abstratas quando dependerem menos das suas representa¸co˜es de dados. • Identifique mensagens e métodos comuns e migre-os para uma classe-base. Isto pode criar a necessidade de quebrar métodos e dividi-los entre classe-base e classes-derivadas. • Elimineos métodos de uma superclasse que s˜ ao freq¨ uentemente sobrescritos em vez de herdados por suas classes-derivadas. Isto torna a superclasse mais abstrata e conseq¨ uentemente mais u ´ til. • Trabalhe classes-derivadas para serem especializadas. Uma classe-derivada ser´ a especializada se herdar todos os métodos da clase-base e acrescentar novos a si própria. Uma classe-derivada sempre representa um superconjunto da classe-base. Programa¸caõ Orientada a Objeto com C++


130


• O conceito de fatora¸caõ envolve a cria¸caõ de sub-rotinas que ser˜ ao acessadas por um método da classe-base e ser˜ ao implementadas de forma diferente pelas classes-derivadas. • Subdivida um método em sub-rotinas que ser˜ ao diferentes para as diversas classes-derivadas. Dica: revise o diagrama de classes (veja se¸caõ 6.4.4), incluindo as classes abstratas que foram identificadas.

6.4.13

Restri¸c˜ oes

Uma restri¸caõ é uma condi¸caõ booleana aplicada a atributos, métodos, classes, associa¸co˜es e pacotes. Por exemplo: o atributo {umAluno.nota < = 10} tem como resultado um valor 0 ou 1. A porta de uma casa pode ser aberta se n˜ ao estiver trancada (chaveada) ou se tivermos a chave. Observe que restri¸co˜es s˜ ao colocadas dentro de chaves {}, podendo-se ainda estar descritas dentro de notas. A linguagem de restri¸co˜es de objeto (OCL – Object Contraint Language) utiliza express˜ oes como umRelogio.Hora(horaCerta) para percorrer/navegar sobre o conjunto de classes do sistema. A OCL é utilizada para identificar falhas e inconsistências no sistema. Veja a seguir um exemplo de uma express˜ ao OCL extra´ıda de [Blaha and Rumbaugh, 2006]: • umaContaCart˜ ao.Extrato.Transa¸co˜es->Select(umaDataInicial == dataTransa¸caõ and dataTransa¸caõ <= umaDataFinal).

6.4.14

Realiza¸c˜ oes

Uma realiza¸caõ é um tipo especial de heran¸ca em somente os métodos s˜ ao herdados. Normalmente uma realiza¸caõ é uma classe que implementa os métodos declarados mas n˜ ao definidos em uma classe de interface.

6.4.15

Dependˆ encias

Como visto, as associa¸co˜es, agrega¸co˜es e heran¸cas representam aspectos estruturais das rela¸co˜es entre objetos. As dependências representam rela¸co˜es de uso. Uma dependência é representada por uma seta tracejada que parte da classe que executa o método de interesse (exemplo: MinhaJanela - - ->biblioteca Qt), assim como mostra aFigura 6.30. Observe que se a classe MinhaJanela depende da biblioteca Qt, mudan¸cas na biblioteca Qt podem implicar em mudan¸cas na classe MinhaJanela.

6.4.16

Identifica¸c˜ ao de objetos

´ um conceito, Um objeto é simplesmente algo que faz sentido no contexto de uma aplica¸caõ. E uma abstra¸caõ, algo com limites n´ıtidos e significativos em rela¸caõ ao problema. Se a existência independente de uma entidade for importante e n˜ ao apenas o seu valor, ent˜ ao ela é um objeto. Neste momento você pode reler as se¸co˜es 2.1, 2.2 e 2.3. Dica: monte diagramas de objetos para testar o relacionamento dos diversos objetos (veja se¸caõ 6.4.17). Programa¸caõ Orientada a Objeto com C++



6.4.17

131

Diagrama de objetos

O diagrama de objetos é basicamente o diagrama de classes, mas apresenta as instâncias dos objetos criados, isto é, descreve os valores dos atributos assumidos por determinados objetos e seus relacionamentos em um dado momento. Serve para auxiliar os diagramas de comunica¸caõ em uma etapa de teste. Inclui itens como objetos e liga¸co˜es, notas, restri¸co˜es e pacotes. Veja na Figura 6.14 a representa¸caõ de um diagrama de objetos. Observe que o objeto pode estar ativo ou inativo, pode ser uma instância simples ou m´ ultipla, pode ou n˜ ao ter seus atributos descritos e pode incluir estereótipos. Qualificador ´ usada na repreUm qualificador, uma qualifica¸caõ inter-relaciona classes de objetos. E senta¸caõ das instâncias da classe.

Figura 6.14: Diagrama de objetos – representando objetos e instâncias. Representação de objetos simples, de instâncias simples ou múltiplas, objetos ativos ou inativos.

<> Objeto inativo (borda fina) instância simples [estado explícito] atributos

6.4.18

<> Objeto inativo instância múltipla [estado explícito]

Objeto

<> Objeto ativo (borda grossa) instância múltipla [estado explicito]

atributos atributos

Diagrama de estrutura composta

´ um diagrama estrutural usado O diagrama de estrutura composta foi inclu´ıdo na UML 2. E para detalhar o relacionamento dos elementos internos de uma classe, componente ou módulo do ´ constru´ıdo a partir da composi¸caõ de elementos e pode ser utilizado para descrever o sistema. E relacionamento dos atributos de classes complexas. Por exempo: dentro de uma classe Pessoa, como se relacionam as propriedades: endere¸co, telefone, e-mail, nome, idade, sexo etc. Veja na Figura ?? um diagrama de estrutura composta da classe de simula¸caõ de um reservatório de petr´ oleo (SimReservat´ orio).

6.4.19

Resumo dos diagramas do modelo estrutural

Vimos que o diagrama de classes é um diagrama em que constam as classes, seus atributos, métodos, e relacionamentos. O diagrama de classes é o mais importante para o desenvolvedor pois é utilizado pelos programas modeladores, como o umbrello, para montagem do c´ odigo inicial do programa. Veremos como montar o c´ odigo inicial do programa usando o umbrello na se¸caõ 6.8.2. Programa¸caõ Orientada a Objeto com C++


132


O diagrama de objetos é pouco utilizado, normalmente os diagramas de caso de uso s˜ ao transformados em diagramas de comunica¸caõ, mostrando a rela¸caõ entre o usuário e os objetos internos. O diagrama de estrutura composta foi introduzido a partir da UML 2 e objetiva detalhar as rela¸co˜es e comunica¸co˜es entre os atributos e métodos de uma mesma classe, bem como os elementos internos do objeto se relacionam. Ademais, deve ser utilizado para detalhar o funcionamento de objetos complexos.

6.4.20

Itera¸c˜ ao

Observe na Figura 5.1 que, ap´ os a cada etapa realizada, deve-se realizar uma itera¸caõ, a qual consiste em analisar as diversas etapas anteriormente realizadas, com o objetivo de encontrar e eliminar erros, de lembrar pontos esquecidos e de verificar a coerência do modelo. Segundo [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006], os seguintes itens devem ser verificados: • Identificados classes e objetos, você deve criar um dicionário, com o nome de cada classe/objeto e a descri¸caõ em um par´ agrafo do que é e representa cada um deles. • Verifique se os casos de uso foram detalhados e se suas necessidades foram resolvidas. • Verifique se h´ a classes desnecessárias (sem atributos e métodos). • Verifique se h´ a atributos e métodos deslocados. • Verifique se os atributos e os métodos s˜ ao compat´ıveis. • Verifique se os métodos têm acesso; se n˜ ao tiverem, est˜ ao faltando associa¸co˜es. • Verifique se h´ a associa¸co˜es repetidas. • Verifique a presen¸ca de assimetrias nas associa¸co˜es e generaliza¸co˜es. • Teste os diversos caminhos do modelo obtido para verificar sua consistência e completude. • Depois de corrigido o modelo, podemos agrupar as classes e os módulos que têm algum sentido l´ ogico em comum em um diagrama (diagrama de pacotes). • Se nos requisitos n˜ ao foram inclu´ıdos dados relativos ao desempenho do sistema, este é um bom momento. • Classes, atributos, métodos e associa¸co˜es criados foram documentados?



ˆ 6.5. AOO – MODELO DINAMICO

6.5

133

AOO – Modelo dinˆ amico

O modelo dinˆ amico é utilizado na descri¸caõ das transforma¸co˜es dos objetos em rela¸caõ ao tempo, preocupando-se com o controle da execu¸caõ, sua seq¨ uência. Representa a evolu¸caõ da execu¸caõ do programa, as respostas do programa aos eventos gerados pelo usuário. Preocupa-se com aspectos como os eventos, as mensagens e suas seq¨ uências, as comunica¸co˜es e colabora¸co˜es entre objetos e subsistemas, as mudan¸cas de estados e a realiza¸caõ de atividades. Todo programa que envolva intera¸caõ e tempo, ou ainda interface gráfica com o usuário e controle de processos, deve ter um bom modelo dinâmico, o qual pode ser constru´ıdo com diagramas de seq¨ uência (se¸caõ 6.5.2), de comunica¸caõ (se¸caõ 6.5.3), diagramas de máquina de estado (se¸caõ 6.5.5) e diagramas de atividade (se¸caõ 6.5.7). Reveja o relacionamento dos diagramas do modelo dinâmico na Figura 4.3. Veja a seguir como identificar os eventos e mensagens e como implementar o modelo dinâmico e seus diagramas.

6.5.1

Identifica¸c˜ ao de eventos e mensagens

Um evento pode ser um est´ımulo externo provocado pelo usuário ao pressionar o mouse ou ao selecionar um item de menu. Pode ser provocado por um outro programa ou pelo sistema operacional. Um evento induz a modifica¸caõ do estado de um ou mais objetos, representa uma a¸caõ que ocorre em determinado tempo e tem dura¸caõ zero. Os eventos incluem toda e qualquer intera¸caõ do usuário com o programa (sele¸co˜es de menu, entrada de dados, pressionamento do mouse etc.), decis˜ oes, interrup¸co˜es, transi¸co˜es, a¸co˜es de ou para usu´ arios de dispositivos externos. Segundo [Blaha and Rumbaugh, 2006], ”os eventos freq¨ uentemente correspondem a verbos conjugados no passado ou ao come¸co de alguma condi¸caõ”. Uma mensagem especifica uma comunica¸caõ entre objetos; s˜ ao o meio pelo qual os objetos interagem, [Pressman, 2002]. Uma mensagem pode ser enviada de um objeto para outro, transferindo informa¸co˜es (inclui o objeto destino, o método a ser executado e seus parˆ ametros). Por exemplo: quando o usu´ ario clica no ´ıcone impressora ele gera um evento. O sistema que controla o processamento das entradas do usuário associa a este evento uma mensagem que efetivará a chamada do método de impressão. Senten¸ cas para eventos • Um evento é uma ocorrência u ´ nica, isto é, distinta das demais. Ocorre em um determinado momento; a hora em que determinado evento ocorre é um atributo do evento. • Um evento n˜ ao retorna um valor. • Os eventos simples n˜ ao transportam parˆ ametros, mas a maioria transporta algum tipo de parˆ ametro. • Um evento pode ser gerado por um ator e se dirigir a um objeto, a um conjunto de objetos, ou a outro ator. Também pode ser gerado por um objeto e ter como destino outro objeto ou ator. • Os eventos podem ser agrupados segundo propriedades comuns. Você deve juntar os eventos que atuam de forma semelhante sobre o fluxo de controle e dar-lhes nomes semelhantes, mesmo se os valores dos parˆ ametros diferirem. Programa¸caõ Orientada a Objeto com C++



134

• Se dois eventos n˜ ao s˜ ao relacionados de forma causal, eles s˜ ao chamados concorrentes – um n˜ ao tem efeito sobre o outro, n˜ ao existe uma rela¸caõ temporal entre eles (ordem de execu¸caõ).

• Nossa an´ alise é que transforma um determinado evento em um evento de erro, ou seja, n´ os é que interpretamos o evento como sendo um erro.

• Pode-se especificar a data e hora em que determinado evento ocorrerá, ou usar um timer para gerar eventos a cada intervalo de tempo. Pode-se descrever que um evento ocorrerá dentro de um determinado tempo (exemplo: ap´ os 10s).

• Os eventos s˜ ao mais expressivos que os métodos, porque o efeito de um evento n˜ ao depende somente da classe do objeto, mas também de seu estado.

Dica: monte diagramas de seq¨ uência (veja a se¸caõ 6.5.2) e/ou diagramas de comunica¸caõ (se¸caõ 6.5.3).

6.5.2

Diagrama de sequ encia – eventos e mensagens ¨ˆ

O diagrama de seq¨ uência enfatiza a troca de eventos e mensagens e sua ordem temporal. Contém informa¸co˜es sobre o fluxo de controle do programa. Costuma ser montado a partir de um diagrama de caso de uso e estabelece o relacionamento dos atores (usu´ arios e sistemas externos) com alguns objetos do sistema. Veja o prot´ otipo de um diagrama de seq¨ uência na Figura 6.15, no qual incluimos um ator, sua linha de vida (linha vertical pontilhada), uma mensagem, um objeto que receberá a mensagem. Observe que a linha de vida do objeto fica cheia quando ele est´ a realizando algum processamento (ativo). Veja que uma mensagem pode incluir sua ordem de execu¸caõ, o evento que a gerou, condi¸co˜es (ou restri¸co˜es), itera¸co˜es (representadas pelo s´ımbolo *) e o retorno.

• Mensagens podem ser ass´ıncronas (quando n˜ ao bloqueiam o chamador).

• Em um diagrama de seq¨ uência as mensagens de retorno s˜ ao optativas e s˜ ao representadas com linha tracejada. Aconselha-se a inclus˜ ao da u ´ ltima mensagen de retorno, de forma a deixar claro a finaliza¸caõ da tarefa. Se existir processamento paralelo, as instru¸co˜es de retorno devem ser inclu´ıdas. Programa¸caõ Orientada a Objeto com C++



135

Figura 6.15: Diagrama de seq¨ uência – elementos. Representação de um diagrama de sequência: eventos e mensagens

Objeto O ator clica em um item de menu enviando uma mensagem para o objeto.

Linha de vida

Ator evento: {condição} Mensagem: Método()

evento: Mensagem de retorno: valor

Linha tracejada indica objeto inativo

Linha cheia indica processamento, o objeto esta ativo

O X indica fim da vida do objeto

Veja na Figura 6.16 um exemplo de diagrama de seq¨ uência. Observe que um evento gerado pelo ator, o professor, provoca o envio de uma mensagem para o objeto prova. Neste exemplo, o professor est´ a montando uma prova: primeiro separa uma folha de papel (cria a prova), a seguir cria mentalmente as quest˜ oes e depois as adiciona à prova. Quando a prova est´ a pronta, o professor a entrega para o aluno. O aluno faz a prova, devolve-a para o professor e ent˜ ao aguarda o resultado. O professor corrige a prova e ent˜ ao mostra-a para o aluno (veja diagrama de máquina de estado do aluno na Figura 6.20). Observe que uma mensagem pode ser enviada para o próprio objeto (autochamada). O aluno emite para si mesmo a mensagem, ”prestar aten¸caõ”. Observe que temos uma prova, várias quest˜ oes e vários alunos. Programa¸caõ Orientada a Objeto com C++



136

Figura 6.16: Diagrama de seq¨ uência – montando uma prova. Diagrama de sequência (eventos e mensagens)

Aluno fazendo prova

Objeto

Ator

Prova

Questão

Professor Mensagem <> <>

adiciona <>

adiciona revisar e imprimir prestar atenção

entregar prova

Autochamada devolver corrigir mostrar nota destruição

Na Figura 6.17 mostramos a seq¨ uência para c´ alculo da área de uma fun¸caõ. Depois de criar o objeto do tipo Simulador, com nome SimAreaFuncao, executamos a fun¸caõ pol´ıtica Run(), respons´ avel pelo gerenciamento do c´ alculo da ´ area da fun¸caõ. O simulador cria um objeto fun¸caõ, um objeto de integra¸caõ e em seguida chama o método Area() do objeto de integra¸caõ passando como parˆ ametro a fun¸caõ. A ´ area é determinada. Por fim, podemos solicitar ao programa externo Gnuplot a plotagem de gr´ aficos da fun¸caõ.

Figura 6.17: Diagrama de seq¨ uência – seq¨ uência para c´ alculo da área de uma fun¸caõ. função : Funcao

integral : Integral

: SimAreaFuncao

gnuplot : Gnuplot

: Ator-usuário : SimAreaFuncao() : Run()

: Funcao()

: Integral() : Area(ptrFuncao : Funcao*) : double

: operator()(_x : double) : double

: Gnuplot()

: Plot()




6.5.3

137

Diagrama de comunica¸c˜ ao – colabora¸c˜ ao

No diagrama de comunica¸caõ o foco é a intera¸caõ e a troca de mensagens e dados entre os objetos. Veja na Figura 6.18 uma representa¸caõ do diagrama de comunica¸caõ equivalente ao diagrama de seq¨ uência da Figura 6.16. Observe que a seq¨ uência de execu¸caõ é dada por n´ umeros. O diagrama de comunica¸caõ pode ser utilizado em uma etapa de testes l´ ogicos ou conceituais dos modelos desenvolvidos. Observe que o diagrama de comunica¸caõ pode ser desenvolvido como uma extensão do diagrama de caso de uso, detalhando o caso de uso por meio da inclus˜ ao dos objetos, mensagens e parˆ ametros trocados entre os objetos. • O diagrama de comunica¸caõ inclui atores, objetos, mensagens e componentes do sistema. • Objetos podem ser conectados por rela¸co˜es de associa¸caõ ou dependência. As dependências entre os n´ os representam rela¸co˜es de comunica¸caõ (podendo ser unidirecionais ou bidirecionais). • Um diagrama de comunica¸caõ pode ser detalhado usando-se uma numera¸caõ como em 1; 1.1; 1.2; e assim por diante. • Algumas ferramentas CASE podem gerar o diagrama de comunica¸caõ a partir do diagrama de eventos e vice-versa. • [Fowler and Scott, 2000] consideram que o estudo de alternativas, isto é, varia¸co˜es nos diagramas de comunica¸caõ e seq¨ uência podem ser exploradas com o uso de cartões CRC (veja se¸caõ 6.10.2).

Figura 6.18: Diagrama de comunica¸caõ – montando uma prova. 5: prestar atenção 1: criar questões 9: destruir questões

Diagrama de comunicação. Use para fazer testes lógicos do funcionamento do programa. Professor Prova

2: adicionar questões a prova 3: revisar e imprimir a prova 7: corrigir a prova

Questão

4: entregar prova ao aluno 6: receber prova do aluno 8: mostrar nota

<> Aluno veja diagrama de estado lista de atributos

Veja na Figura 6.19 uma representa¸caõ de um diagrama de comunica¸caõ equivalente ao diagrama de seq¨ uência da Figura 6.17. O diagrama de comunica¸caõ ilustrado na Figura 6.19 mostra a seq¨ uência para c´ alculo da área de uma fun¸caõ. Programa¸caõ Orientada a Objeto com C++


138

ajátqoudáefeiratcnaoçsgãm cnacçiãafuoén:da.por: 1::FFuunnccaaoo()2:In4te:gG ueroq.unêim D l I t n e g r a áCábiaillsaccgeuuorrvom d e : CO l ( ) r a ( ) d b l * A F F t r e a p r n c a o n c a o o e u u u : : : 3 l ) t n p o u . ladr 5P(Gplt rPotagnrpflcos :sim ˆ 6.5. AOO – MODELO DINAMICO

Figura 6.19: Diagrama de comunica¸caõ – seq¨ uência para c´ alculo da área de uma fun¸caõ.

6.5.4

Identifica¸c˜ ao dos estados assumidos pelo objeto

Os valores assumidos pelos atributos de um objeto ao longo do tempo, a realiza¸caõ de uma atividade, ou a espera de um evento representam o estado do objeto. Segundo [Blaha and Rumbaugh, 2006], ”o estado é uma abstra¸caõ dos valores e liga¸co˜es de um objeto”, ”normalmente correspondem a verbos no ger´ undio (esperando, discando)”. • Um estado pode representar tanto caracter´ısticas ativas como passivas. • Considere apenas atributos relevantes ao definir um estado. • Dê a cada estado um nome significativo. O nome pode n˜ ao ser necess´ ario se o estado for diretamente identificado.

• Para ajudar na identifica¸caõ dos estado, fa¸ca uma an´ alise de cada atributo do objeto. Por exemplo: o atributo temperatura da ´ agua indica se a água est´ a no estado s´ olido, l´ıquido ou gasoso. • Um estado pode sofrer altera¸co˜es qualitativas (transi¸caõ de estado) e quantitativas (transi¸co˜es internas). Uma altera¸caõ quantitativa representa qualquer altera¸caõ em um dos atributos do objeto, por exemplo, a altera¸caõ da temperatura da água de 55 ◦ C para 54 ◦ C. J´ a uma altera¸caõ qualitativa representa uma altera¸caõ conceitual do objeto, como a altera¸caõ da temperatura da ´ agua de 55 ◦ C (l´ıquida) para -5 ◦ C (sólida). O estado depende de uma condi¸caõ (a temperatura da ´ agua). • Uma transi¸caõ de estado pode estar associada a um evento/mensagem ou a uma atividade que altere um atributo (por exemplo, uma atividade que altere a temperatura da água). A transi¸caõ de estado é representada por uma seta. • Transi¸co˜es internas s˜ ao ocorrências que podem alterar o valor de um atributo, mas n˜ ao mudam o estado do objeto. • Depois de considerar os eventos normais (default ), considere as exce¸co˜es (casos de erro). • Se a seq¨ uência puder ser repetida indefinidamente, ela formará um la¸co. Sempre que poss´ıvel, substitua seq¨ uências finitas por la¸cos. • Um estado depende dos eventos anteriores, mas de modo geral os eventos anteriores s˜ ao ocultados pelos posteriores. • Lembre-se de que uma instru¸caõ ”fa¸ca: X”em um objeto pode ser um evento para outro objeto, ou seja, verifique as instru¸co˜es, fa¸ca nos diversos objetos e verifique se esta n˜ ao representa um evento para outro objeto; caso represente, desenhe no outro objeto. Programa¸caõ Orientada a Objeto com C++



139

Prepare um diagrama de máquina de estado para cada classe de objetos com comportamento dinâmico importante (n˜ ao trivial), mostrando os eventos que o objeto recebe e envia. Isto é, s´ o construa diagramas de máquina de estados para classes de objetos com comportamento dinâmico significativo (veja a se¸caõ 6.5.5 e a Figura 6.20).

6.5.5

Diagrama de m´ aquina de estado

Um diagrama de máquina de estado representa os diversos estados que o objeto assume e os eventos que ocorrem ao longo de sua vida ou mesmo ao longo de um processo (hist´ orico do ´ objeto). E usado para modelar aspectos dinâmicos do objeto. Elementos presentes em um diagrama de máquina de estado s˜ ao: • Estado – indica de forma abreviada o estado do objeto. Um exemplo de estado é a realizaçaõ de uma atividade demorada. Por exemplo: realizando entrada de dados, processando integra¸caõ, processando montagem dos gráficos (veja a Figura 6.21). Veja na Figura 6.20 (a) o prot´ otipo de representa¸caõ de um estado, o qual inclui: o nome do estado, a a¸caõ de entrada(entry), a atividade a ser realizada(do) e a a¸caõ de sa´ıda(exit). – Nome – indica o nome do estado/atividade e deve ser u ´ nico. – entry – a¸caõ de entrada, a ser executada quando entra no estado. – do/atividade – indica uma atividade em andamento. – exit – a¸caõ de sa´ıda a ser executada quando sai do estado. • Evento – causa a transi¸caõ de estado (provoca execu¸caõ da a¸caõ que muda o estado do objeto). • Condi¸ c˜ ao de guarda (guard condition) – uma condi¸caõ de guarda imp˜ oe algum tipo ´ uma restri¸caõ booleana, se verdadeira a a¸caõ que de restri¸caõ ` a transi¸caõ de estado. E provoca a transi¸caõ de estado é executada. Uma condi¸caõ é representada entre colchetes {}. Por exemplo: um aluno s´ o ser´ a considerado aprovado se tiver obtido média final maior que 6 (veja a Figura 6.20). • A¸ c˜ ao – todo método que é executado quase instantaneamente e que est´ a associado a um evento é denominado a¸caõ (action). As a¸co˜es podem representar opera¸co˜es internas de controle. A¸co˜es internas n˜ ao mudam o estado do objeto. Quando as transi¸co˜es de um estado executam a mesma a¸caõ, pode-se vincular o estado à a¸caõ. A¸co˜es est˜ ao associadas a transi¸co˜es. Veja na Figura 6.20 (b) um exemplo de diagrama de máquina de estado para um aluno. Observe que este é formado por n´ os que representam os estados e setas que representam as transi¸co˜es entre os estados; observe também como s˜ ao representados o estado inicial e final. Inicie a constru¸caõ do diagrama de máquina de estado a partir dos diagramas de seq¨ uência; use os eventos oriundos dos casos de uso. Todo caso de uso corresponde a um caminho a ser seguido no diagrama de máquina de estado, ou seja, deve-se comparar os diversos casos de uso e verificar os pontos em que eles divergem (e que precisam ser codificados no diagrama de máquina de estados). Lembre-se de que dois caminhos em um diagrama de máquina de estado ser˜ ao os mesmos se o objeto esquecer os valores passados. Veja na Figura ?? os estados de uma thread e na Figura ?? os estados de um processo. Programa¸caõ Orientada a Objeto com C++



140

Figura 6.20: Diagrama de máquina de estado – um aluno. Diagrama de estado.

Exemplo, diagrama de máquina de estado para um aluno matrícula recusada

início

Notação para estado

Nome do estado entry/entrada do/atividades exit/saída

Fazendo Matrícula

{matricula ok}

estado

Assistindo aula

mensagem preparação Estudando assistir aula

rematricular realizar prova {média < 6}

áono/d m m qcroi.ui> nEn atfdrueaegd eCD sliatgdreoR :seiaadluiezlD ã d I t r o c e s a n o n e g r a ç o P i ( ) / A t > n g r ¢ D ardosProcesaD n ag coD Pelom t()gráficos o/dgoum plont¢> áquinadeR iagrm tEntfrueaadgd adem seatlaizdD oonc/d scoi> m e ocsocD sradost:ClasePrim m p o rn uocelasdoaD .o/dgoum D á f i t n a g e m g r c o s l l ( ) P t > p o o Õ tagpedosçtãna:d,o adoscaluandoÁRreatornadoresultadocPiEnorsm InicandoD Reprovado

Esperando resultado

fim

aguardar

Fazendo prova

{3 < mediaParcial < 6}

descansar

{média >= 6}

Aprovado

(a)

(b)

Fazendo recuperação

Figura 6.21: Diagrama de máquina de estado – estados do objeto simulador.

Diagrama de estados compostos ou subestados

Pode-se representar mais detalhadamente um estado, usando-se diagramas de estados compostos. Cada estado composto representa um subestado, semelhante a sub-rotinas. Compare as Figuras 6.21 e 6.22, observe que o estado ”processando integra¸caõ” pode ser detalhado em sub-estados. No caso, inclu´ımos os sub-estados iniciando dados, calculando área e retornando resultados. Figura 6.22: Diagrama de máquina de estado: Estados compostos do objeto simulador.




141

Á d l d t p e r s a o c a a n o r e a u u : S á i(Epxaegrpm iloesa).lizsn d d d t a e m q n a e s a o u : á d l d t s a o c a a n o r e a u : D , E daco tRo/d o s c o r n e s d d t t r e p e n o c m s o l P I P t o c n e r s s v c o n r . iEtfrucengacnaddooD IDi> n ardosProceassuunbdb oIsstaeaddrvoolsIm paresP d lplon dPoe troceosrnaD tt a> e an ro/d sgoum o e ag u R lom t()gráficos

Diagramas de estados concorrentes

Podemos representar concorrências e sincroniza¸caõ no interior de um objeto utilizando diagramas de máquinas de estado. Uma concorrência dentro de um estado subdivide o estado. Observe na Figura 6.23 que o processo de c´ alculo da área foi subdividido em dois processos concorrentes, podendo ser utilizado processamento paralelo. Veremos uma introdu¸caõ ao uso de cluster e a programa¸caõ paralela usando m´ ultiplas threads ou m´ ultiplos processos a partir do Cap´ıtulo ?? – Introdu¸caõ ` a Utiliza¸caõ de Clusters de Computadores. Figura 6.23: Diagrama de máquina de estado – estados concorrentes do objeto simulador.

Senten¸ cas para diagramas de m´ aquina de estado2

Veja a seguir dicas de [Rumbaugh et al., 1994] para a constru¸caõ de um diagrama de máquinas de estados. • Um cen´ ario pode ajud´ a-lo a encontrar novos estados.

• O diagrama de máquina de estado da classe-base deve ser separado do diagrama de máquina de estado da classe-derivada, o qual deve descrever os seus atributos. • Verifique a consistência dos diversos diagramas de máquina de estado e verifique se os eventos compartilhados est˜ ao coerentes. • As liga¸co˜es entre os diversos diagramas de máquina de estado s˜ ao realizadas pelas mensagens e eventos compartilhados. • Um diagrama de máquina de estado pode representar ciclos de vida. No caso em que um objeto é criado, realiza determinados procedimentos e é eliminado. Pode representar la¸cos cont´ınuos quando o objeto é persistente (n˜ ao é destru´ıdo). • Um estado complexo pode ser dividido em diagramas de n´ıvel inferior, denominados estados compostos ou subestados. • Algumas simula¸co˜es de engenharia podem demorar vários dias. Como os computadores falham (ocorrem quedas de energia), é importante criar mecanismos que permitam o rein´ıcio da simula¸caõ do ponto em que parou. Para facilitar a cria¸caõ destes pontos, os diagramas de máquina de estado acrescentaram o conceito de estado de hist´ oria, representado pela letra ”H”. As informa¸co˜es do sistema são armazenadas de tal forma que permitam o rein´ıcio da simula¸caõ a partir deste ponto. Releia a se¸caõ 1.3.3. • O controle da interface do usu´ ario pode ser descrito em um diagrama de máquina de estado. Programa¸caõ Orientada a Objeto com C++


142


• Observe nas figuras apresentadas que os gr´ aficos de estado costumam ser descritos no ger´ undio (exemplo: mostrando, calculando, gerando). • Concorrências e sincroniza¸co˜es, conceitos utilizados em processamento paralelo, podem ser representados em diagramas de máquina de estado (veja a Figura 6.23). • Teste – verifique a consistência do diagrama de máquina de estado. Compare eventos entre objetos para verificar se o diagrama est´ a completo. Verifique os erros de sincroniza¸caõ, por exemplo, quando uma entrada ocorre em um momento inadequado.




6.5.6

143

Identifica¸c˜ ao de atividades

Como vimos nos diagramas de máquinas de estado (se¸caõ 6.5.5), uma atividade é uma opera¸caõ que demora um determinado tempo, como, por exemplo, a solu¸caõ de um sistema de equa¸co˜es, o processamento de transa¸co˜es em um grande banco de dados, a simula¸caõ de um reservatório de petr´ oleo, o processamento de sinais etc. Como uma atividade pode ser complexa, precisamos detalhar por meio de um fluxograma como esta atividade vai ser realizada. Normalmente uma atividade é implementada por um método de um determinado objeto, e detalhar o funcionamento da atividade corresponde a detalhar o funcionamento de determinada método/fun¸caõ. • Um método deve ter precondi¸co˜es para seus dados de entrada e de sa´ıda. Comece verificando os parˆ ametros de entrada (tipo, valor-padrão, valores máximos e m´ınimos). Em seguida, verifique se o retorno é adequado. • Verifique a l´ ogica de c´ alculo/processamento utilizada. • Verifique as estruturas de controle utilizadas (if, for, switch, case, do, while) (veja o Apêndice D). • Verifique as restri¸co˜es entre objetos. Uma restri¸caõ é uma dependência funcional entre objetos. Dica: o detalhamento das atividades pode ser descrito com o uso dos diagramas de atividades (veja a se¸caõ 6.5.7).

6.5.7

Diagrama de atividades

O diagrama de atividades também se preocupa com quest˜ oes dinâmicas, mas em um n´ıvel mais detalhado, sendo utilizado para descri¸caõ dos diversos métodos das classes. Segundo [Blaha and Rumbaugh, 2006], ”um diagrama de atividades mostra a seq¨ uência de etapas que compõem um processo complexo, como um algoritmo ou fluxo de trabalho”; seu enfoque s˜ ao os métodos e n˜ ao os objetos. Isto é, o objetivo do diagrama de atividades é descrever algoritmos e funcionalidades complexas, detalhando um estado de atividade do diagrama de máquina de estados. • O diagrama de atividades se preocupa com os valores de entrada e sa´ıda dos métodos, como os atributos s˜ ao alterados, as dependências entre os métodos. • Em um diagrama de atividades os n´ os representam a¸co˜es ou atividades, e as linhas representam transi¸co˜es (uma transi¸caõ pode ocorrer quando a a¸caõ/atividade anterior foi completada). • Os diagramas de atividades s˜ ao especialmente importantes em áreas como engenharia. • O diagrama de atividades é baseado em redes de petri; é semelhante a um fluxograma, a diferen¸ca é que ele permite que atividades sejam executadas paralelamente. Os elementos presentes em um diagrama de atividades s˜ ao: • Estado de a¸ c˜ ao – descreve a atividade que est´ a sendo executada. • Transi¸ co ˜es – s˜ ao setas que indicam que a atividade anterior terminou e que a nova atividade vai ser executada. Programa¸caõ Orientada a Objeto com C++



144

• Barra de sincroniza¸ c˜ ao (bifurca¸ c˜ ao/separa¸ c˜ ao) – quando o método admite processamento paralelo, utilizamos barras de sincroniza¸caõ para indicar uma separa¸caõ dos processos. • Barra de sincroniza¸ c˜ ao (aglutina¸ c˜ ao/jun¸ c˜ ao) – a barra de sincroniza¸caõ é utilizada ainda para representar a aglutina¸caõ de uma atividade. • Losangos – losangos s˜ ao utilizados para indicar tomadas de decis˜ ao, uso de estruturas de controle, como um if, um switch. Uma breve descri¸caõ sobre a decis˜ ao pode ser inclu´ıda utilizando-se anota¸co˜es.

A Figura 6.24 mostra em (a) o prot´ otipo de um diagrama de atividades. Observe que est˜ ao presentes os indicadores de in´ıcio e fim da atividade (os mesmos do diagrama de máquinas de estado), losangos para tomada de decis˜ ao, bifurca¸co˜es e aglutina¸co˜es (utilizadas para indicar processamento concorrente) e as atividades. A Figura 6.24 (b) mostra o diagrama de atividades de um método de binariza¸caõ (transforma uma imagem em tons de cinza ou colorida em imagem preto/branco). Observe que se a imagem já estiver binarizada o método n˜ ao faz nada. Se a imagem é em tons de cinza, chama o método que binariza imagens em tons de cinza e, se for imagem colorida, chama o método que binariza imagens coloridas. Observe que é um método pol´ıtico e envolve apenas tomadas de decis˜ oes. O processamento ser´ a feito em métodos auxiliares.

Figura 6.24: Em (a) o prot´ otipo de um diagrama de atividades. Em (b) o diagrama de atividades de um método de binariza¸caõ. O diagrama de atividades se preocupa com os detalhes de implementação dos métodos. O que ocorre dentro de cada método importante.

No exemplo um método de binarização.

início Atividade

separação bifurcação [ Imagem Binarizada ] Tomada de decisão

[ Imagem Colorida ] Atividade [ Imagem Cinza ]

[false]

[true] [ Iterativo ]

Atividade

[ Direto ]

Atividade Executa método iterativo

Executa método direto

Executa binarização de imagem Cinza

aglutinação união, junção fim (a)

(b)

A Figura 6.25 mostra o diagrama de atividades para o método do Trap´ ezio. O mesmo é utilizado para calcular a ´ area de uma fun¸caõ. Observe que toda seq¨ uência de c´ alculo é detalhada. Programa¸caõ Orientada a Objeto com C++



145

Figura 6.25: Diagrama de atividades – método do Trap´ ezio para c´ alculo da área. Diagrama de Atividades: Classe: IntTrapezio Método: Area() Método de cálculo

Recebe intervalo integração e função f,xmax,xmin,numeroIntervalos dx=(xmax-xmin)/numeroIntervalos

faz x=xmin, Area=f(x).dx/2

x >= xmax x < xmax

Area = Area +f(x).dx/2

x = x + dx

y=f(x)

Area = Area + y.dx

Diagrama de atividades com raias de nata¸ c˜ ao O diagrama de atividades pode apresentar linhas verticais (raias de nata¸caõ) separando os diferentes objetos. O uso de raias de nata¸caõ permitem a visualiza¸caõ da execu¸caõ de seq¨ uências de troca de mensagens e dados entre objetos. Como pode incluir barras de bifurca¸caõ e aglutina¸caõ, pode ser utilizado para representar processamentos paralelos. Veja o exemplo na Figura 6.26. Nele, o usu´ ario externo cria um objeto simulador e em seguida roda a simula¸caõ. O objeto simulador cria um objeto fun¸caõ e um objeto integrador, define seus atributos e logo ap´ os inicia o c´ alculo da ´ area da fun¸caõ. O simulador identifica a presen¸ca de dois n´ os (de um cluster) e separa o calculo da ´ area em dois intervalos, i e j. Depois de calculada a área, o simulador envia para o programa externo gnuplot o comando para gerar e plotar os gráficos. O resultado final é analisado pelo usu´ ario.

á sRC rordiaSiim ouladçoãrCriaSiom u U N N ubjelatodiofruengçrãaoiC antóelcr1vuaoprim eroiC antóelcr2vuaosegundognuplot efiC narlPcluottearrvÁgaleáoficnFotusçãoAreaIntervaloiAreaIntervalojG D á f i e r a g r c o s ost AnalisrResultados M Figura 6.26: Diagrama de atividades – uso de raios de nata¸caõ.




146

Diagrama de atividades e envio de sinal para dispositivos externos O diagrama de atividades pode incluir ainda retˆ angulos com pontas triangulares, os quais s˜ ao utilizados para indicar o envio/recebimento de sinais de/para sistemas externos. Veja na Figura 4.5 os elementos utilizados pela UML para representar o envio/recebimento de sinais.

6.5.8

Diagrama de tempo

Mostra mudan¸cas no estado ou papel de uma classe ao longo do tempo; é util para descrever processos temporais.

6.5.9

Diagrama de intera¸c˜ ao geral

´ um diagrama que mistura elementos do diagrama de máquinas de estado, de seq¨ E uência, de comunica¸caõ e de pacotes, objetivando detalhar toda intera¸caõ de um determinado cenário de uso do programa.

6.5.10

Resumo dos diagramas do modelo dinˆ amico

Observe que com os diagramas dinˆ amicos temos representadas todas as caracter´ısticas dinˆ amicas do sistema e dos objetos. Os diagramas de seq¨ uência e de comunica¸caõ se preocupam com a troca de dados entre objetos e atores do sistema, a intera¸caõ dos objetos em um n´ıvel mais macro. O diagrama de máquinas de estado é focado nos estados assumidos pelo objeto e suas transi¸co˜es (valores dos atributos), os poss´ıveis comportamentos do objeto. O diagrama de atividades se preocupa com o que ocorre dentro de cada método da classe, detalhando seu funcionamento (a microdinˆ amica do sistema, os algoritmos). O diagrama de tempo mostra varia¸co˜es de um objeto ao longo do tempo. J´ a o diagrama de intera¸caõ geral é uma mescla de vários diagramas, sendo usado para detalhar um determinado cen´ ario.

6.5.11

Itera¸c˜ ao

Observe na Figura 5.1 que, ap´ os cada etapa realizada, deve-se realizar uma itera¸caõ. Os seguintes itens devem ser verificados: • Revise os diagramas de seq¨ uência e de comunica¸caõ. • Você incluiu diagramas de máquinas de estados para as classes complexas? • Algoritmos complexos foram montados utilizando os diagramas de atividades? • A estrutura de um modelo dinˆ amico é estreitamente relacionada com o modelo estrutural. Os eventos podem ser representados como métodos no modelo estrutural. A hierarquia de estados de um objeto é equivalente a um conjunto de restri¸co˜es do modelo estrutural. • Você verificou o efeito da modelagem dinˆ amica nos diagramas estruturais? • Confira as rela¸co˜es entre os diagramas dinˆ amicos e os métodos nas classes. • Você incluiu nos diagramas os casos excepcionais? As entradas erradas? Falhas no sistema? Problemas com hardware? Programa¸caõ Orientada a Objeto com C++



147

• Teste – terminado o modelo dinˆ amico, fa¸ca o teste l´ ogico (veja o item 3, na se¸caõ 6.9). Dica: otimiza¸caõ – o modelo dinˆ amico deve incluir a identifica¸caõ dos pontos do programa que merecem ser otimizados. Isto pode ser feito baseando-se na an´ alise dos diagramas de atividade (veja a se¸caõ 6.5.7) e na an´ alise dos algoritmos que precisam ser implementados. Identifique pontos concorrentes e que podem ser executados em paralelo. Comece fazendo uma pesquisa na internet por bibliotecas similares; veja como os outros resolveram a quest˜ ao da otimiza¸caõ de determinado algoritmo. Na etapa de implementa¸caõ, você pode utilizar um profiler (veja o Cap´ıtulo ?? – Auditoria e Otimiza¸caõ de Programas) para identificar os gargalos de desempenho.



148

6.6

6.6. PROJETO DO SISTEMA

Projeto do sistema

Depois da an´ alise orientada a objeto desenvolve-se o projeto do sistema, qual envolve etapas como a defini¸caõ dos protocolos, da interface API, o uso de recursos, a subdivisão do sistema em subsistemas, a aloca¸caõ dos subsistemas ao hardware e a sele¸caõ das estruturas de controle, a sele¸caõ das plataformas do sistema, das biblitoecas externas, dos padr˜ oes de projeto, além da tomada de decis˜ oes conceituais e pol´ıticas que formam a infraestrutura do projeto. Deve-se definir padr˜ oes de documenta¸caõ, padr˜ oes para o nome das classes, padr˜ oes de retorno e de parˆ ametros em métodos, caracter´ısticas da interface do usuário e caracter´ısticas de desempenho. Segundo [Rumbaugh et al., 1994, Blaha and Rumbaugh, 2006], o projeto do sistema é a estratégia de alto n´ıvel para resolver o problema e elaborar uma solu¸caõ. Você deve se preocupar com itens como: 1. Protocolos • Defini¸caõ dos protocolos de comunica¸caõ entre os diversos elementos externos (como dispositivos). Por exemplo: se o sistema envolve o uso dos n´ os de um cluster, devem ser considerados aspectos como o protocolo de comunica¸caõ entre os n´ os do cluster. • Defini¸caõ dos protocolos de comunica¸caõ entre os diversos elementos internos (como objetos). • Defini¸caõ da interface API de suas bibliotecas e sistemas (veja a se¸caõ 6.6.1). • Defini¸caõ do formato dos arquivos gerados pelo programa. Por exemplo: prefira formatos abertos, como arquivos txt e xml. 2. Recursos • Identifica¸caõ e aloca¸caõ dos recursos globais, como os recursos do sistema ser˜ ao alocados, utilizados, compartilhados e liberados. Implicam modifica¸co˜es no diagrama de componentes (veja a se¸caõ 6.7.1). • Identifica¸caõ da necessidade do uso de banco de dados. Implicam em modifica¸co˜es nos diagramas de atividades e de componentes. • Identifica¸caõ da necessidade de sistemas de armazenamento de massa. Por exemplo: um storage em um sistema de cluster ou sistemas de backup. 3. Controle • Identifica¸caõ e sele¸caõ da implementa¸caõ de controle, seq¨ uencial ou concorrente, baseado em procedimentos ou eventos (veja a se¸caõ 6.6.2). Implicam modifica¸co˜es no diagrama de execu¸caõ (veja a se¸caõ 6.7.2). • Identifica¸caõ das condi¸co˜es extremas e de prioridades. • Identifica¸caõ da necessidade de otimiza¸caõ. Por exemplo: prefira sistemas com grande capacidade de mem´ oria; prefira vários hds pequenos a um grande. • Identifica¸caõ e defini¸caõ de loops de controle e das escalas de tempo. • Identifica¸caõ de concorrências – quais algoritmos podem ser implementados usando processamento paralelo (veja a se¸caõ ??). 4. Plataformas Programa¸caõ Orientada a Objeto com C++



149

• Identifica¸caõ das estruturas arquitetônicas comuns. • Identifica¸caõ de subsistemas relacionados à plataforma selecionada. Podem implicar em modifica¸co˜es no diagrama de pacotes (veja a se¸caõ 6.2.3) e no diagrama de componentes (veja a se¸caõ 6.7.1). • Identifica¸caõ e defini¸caõ das plataformas a serem suportadas: hardware, sistema operacional e linguagem de programa¸caõ (veja a se¸caõ 6.6.3). • Sele¸caõ das bibliotecas externas a serem utilizadas (veja a se¸caõ 6.6.4). • Sele¸caõ da biblioteca utilizada para montar a interface gráfica do programa – GDI (veja a se¸caõ 6.6.5). • Sele¸caõ do ambiente de desenvolvimento para montar a interface de desenvolvimento – IDE (veja a se¸caõ 6.6.6). 5. Padr˜ oes de projeto • Normalmente os padr˜ oes de projeto s˜ ao identificados e passam a fazer parte de uma biblioteca de padr˜ oes da empresa. Mas isto s´ o ocorre ap´ os a realiza¸caõ de diversos projetos. Nota: uma das maiores preocupa¸co˜es de simula¸co˜es de engenharia é o desempenho. A necessidade de se aliar desempenho, interface gráfica amig´ avel e reuso de bibliotecas limita o n´ umero de linguagens a serem utilizadas, de modo que C++ tem sido a mais indicada (veremos a otimiza¸caõ de programas no Cap´ıtulo ?? – Auditoria e Otimiza¸caõ de Programas, e técnicas de processamento paralelo a partir do Cap´ıtulo ?? – Introdu¸caõ à Utiliza¸caõ de Clusters de Computadores).

6.6.1

Defini¸c˜ ao da interface de programa¸c˜ ao – API

Quando estamos desenvolvendo uma classe, um módulo ou um sistema, precisamos definir sua interface de acesso. Uma API – Application Programming Interface ou interface de programa¸caõ de aplica¸caõ é um conjunto de instru¸co˜es e informa¸co˜es sobre a forma como a biblioteca deve ser acessada. A API separa o que é p´ ublico (acess´ıvel) do que é protegido ou privado (inacess´ıvel). Na se¸caõ 3.2 e por meio da Figura 3.2, mostramos que a visão do que é publico e do que é privado depende da audiência, isto é, de quem vai utilizar a classe/m´ odulo/sistema. Na prática isto significa que, quando formos definir as interfaces de nossos sistemas, precisamos definir claramente quem s˜ ao seus usu´ arios (a audiência). Por exemplo: a API de bibliotecas como Qt, GTK, MFC, VCL s˜ ao desenvolvidas para programadores medianos. O protocolo é o conjunto de métodos que podem ser acessados pelo usuário, o conjunto de mensagens a que o objeto responde; ou seja, o protocolo é o conjunto de métodos p´ ublicos da classe. Veja a seguir dicas de [Winblad et al., 1993] para melhorar os protocolos. Senten¸ cas para melhorar os protocolos • Dê nomes similares ou idênticos a mensagens e métodos quando uma classe se comunica com outras classes para realizar opera¸co˜es similares. • Desenhe classes onde uma mensagem possa ser enviada diretamente para um objeto e manipulada corretamente pelos métodos nele contidos. Finalmente, é importante montar a interface API de seu programa de modo que ela seja extens´ıvel, reaproveit´ avel e que considere requisitos futuros. Programa¸caõ Orientada a Objeto com C++


150

6.6.2


Sele¸c˜ ao da implementa¸c˜ ao de controle

O sistema ou subsistema de controle da execu¸caõ do software pode ser implementado de diferentes formas. Veja a seguir alguns exemplos: • Se o sistema realiza seq¨ uências predefinidas como em arquivos de lote (por exemplo, autoexec.bat, init.d), ou c´ alculos seq¨ uênciais, ent˜ ao o controle pode ser feito por arquivos ASCII, os quais determinam a seq¨ uência a ser realizada. Sistemas de reinicializa¸caõ do sistema podem ser inclu´ıdos (veja a se¸caõ 1.3.1 e 1.3.2). Este tipo de sistema utiliza uma estrutura de controle chamada de transforma¸ca õ em lote, bastante utilizada em procedimentos de engenharia, no processamento de transa¸co˜es banc´ arias (cheques) e transa¸co˜es agendadas. • Um sistema com controle do tipo transforma¸ca õ cont´ınua permite a realiza¸caõ de etapas de simula¸co˜es. Para cada bloco de tarefas executadas, o usuário analisa os resultados obtidos e toma decis˜ oes a respeito da seq¨ uência de execu¸caõ do sistema, ou seja, o usuário pode alterar o fluxo de execu¸caõ do programa. Veja a se¸caõ 1.3.3. • Em uma interface interativa os usu´ arios interagem o tempo todo com o sistema (geralmente utilizando uma interface gr´ afica). De maneira geral, este tipo de controle é baseado em eventos e permite a execu¸caõ concorrente (pelo uso de m´ ultiplas threads e/ou processos). O acesso compartilhado aos recursos pode ser controlado por bloqueadores de acesso (mutex). Sistemas de software modernos com controle do tipo interface interativa utilizam listas e podem ter macros para execu¸caõ de atividades repetitivas (veja a se¸caõ 1.3.4). Sistemas cient´ıficos e simula¸co˜es de engenharia (como processamento de dados, sinais e imagens, simula¸co˜es qu´ımicas e ambientais) podem utilizar um dos tipos de controle acima definidos. Se a simula¸caõ é fechada (dados de entrada e sa´ıda previamente definidos), pode-se utilizar tranforma¸ca õ em lote. Se existem poucas necessidades de intera¸caõ com o usuário use transforma¸ca õ cont´ınua. Sistemas modernos de engenharia utilizam interface interativa, possibilitando um controle mais refinado das simula¸co˜es a serem realizadas.

6.6.3

Sele¸c˜ ao das plataformas a serem suportadas

Uma plataforma de programa¸caõ envolve o hardware, o sistema operacional e a linguagem de programa¸caõ. Veja a seguir alguns exemplos: • Computador do tipo Macintosh – sistema operacional Mac Os X – linguagem C. • Computador do tipo PC/Intel – sistema operacional Windows – linguagem C++. • Computador do tipo Workstation/AMD - Opteron – sistema operacional GNU/Linux – linguagem C++. Um programa em ANSI C++ pode ser compilado em diversas plataformas. O procedimento é simples; basta copiar o c´ odigo-fonte para a plataforma-alvo e, em seguida, compilar os programas usando um compilador padr˜ ao Ansi C++. Para facilitar a compila¸caõ de um programa em m´ ultiplas plataformas, as equipes de desenvolvimento da GNU desenvolveram os programas autoconf, automake e libtool (os quais ser˜ ao descritos no Cap´ıtulo ?? – Introdu¸caõ ` a Programa¸caõ Multiplataforma com Software Livre). Programa¸caõ Orientada a Objeto com C++



6.6.4

151

Sele¸c˜ ao das bibliotecas externas

No projeto do sistema é necess´ ario definir quais bibliotecas externas ser˜ ao utilizadas. A dica é utilizar bibliotecas reconhecidas e bem-documentadas, como as bibliotecas da GNU. Segundo [Korson and Macgregor, 92], uma biblioteca orientada a objeto deve: ter protocolos uniformes (nomes e assinaturas), focar um tema completo (fechado), mas considerando generalidades (aliando, na medida do poss´ıvel, uniformidade, completude e generalidade). Também deve permitir sua extensão e ser eficiente. Veremos na se¸caõ ?? as vantagens e as desvantagens do uso de bibliotecas externas. Veja a seguir alguns exemplos de bibliotecas externas. Exemplos de bibliotecas externas • Bibliotecas da GNU, veja http://www.gnu.org. • Bibliotecas disponibilizadas no site Scientific Applications on Linux (SAL), veja http://sal.linet.gr.jp/index.shtml. • Bibliotecas disponibilizadas no site The Object-Oriented Numerics Page, veja http://www.oonumerics.org/oon/. • Biblioteca magick++, apresentada na se¸caõ ??, veja http://www.simplesystems.org/Magick++/ . • Biblioteca commom C++, apresentada na se¸caõ ??, veja http://www.gnu.org/directory/GNU/commoncpp.html . • Biblioteca boost, apresentada na se¸caõ ??, veja http://www.boost.org/. • Biblioteca de métodos numéricos, veja http://users.physik.tu-muenchen.de/gammel/matpack/. Depois de selecionar as bibliotecas externas que utilizar´ a, é necess´ ario fazer o download/instala¸caõ da biblitoteca, ler os manuais do usuário e a documenta¸caõ API, além de estudar os exemplos que acompanham a biblioteca. A apresenta¸caõ das bibliotecas, seus conceitos, vantagens e desvantagens, como montar e como usar nossas próprias bibliotecas e como usar bibliotecas conhecidas ser˜ ao vistas nos cap´ıtulos e se¸co˜es abaixo: • A se¸caõ 6.6.5 mostra a sele¸caõ da biblioteca gráfica a ser utilizada – GDI. • Na se¸caõ 6.11.5 apresentaremos algumas senten¸cas para montagem de bibliotecas. • Na se¸caõ 6.11.6 veremos senten¸cas para montagem de frameworks. • No Cap´ıtulo ?? – Bibliotecas, veremos como implementar nossas próprias bibliotecas. • No Cap´ıtulo ?? – O Programa Libtool, veremos como implementar nossas próprias bibliotecas em sistemas multiplataforma. ´ • Veremos a partir do Cap´ıtulo ?? – Bibliotecas Uteis, exemplos de bibliotecas externas. Para desenvolver programas em um ambiente de janelas como o Windows, o Mac OS X, o GNOME ou o KDE, você ter´ a que escolher uma biblioteca gráfica. Veja na se¸caõ 6.6.5 uma discuss˜ ao sobre a sele¸caõ de bibliotecas gr´ aficas. Programa¸caõ Orientada a Objeto com C++


152

6.6.5


Sele¸c˜ ao da biblioteca gr´ afica a ser utilizada – GDI

H´ a alguns anos desenvolvia-se um programa em computadores PC XT/AT, utilizando-se um ambiente em modo texto, pois n˜ ao existiam janelas e ´ıcones. Mais recentemente, praticamente todos os programas utilizam janelas, ´ıcones, menus etc. e s˜ ao desenvolvidos para plataformas computacionais como o PC/Windows Vista, esta¸co˜es de trabalho rodando Unix, GNU/Linux com interface gráfica padr˜ ao MOTIF, GNOME, KDE, ou mesmo Macintosh rodando MAC OS System X. Desenvolver um programa ”For Windows”, assim que se lan¸cou o Windows 3.0, era uma verdadeira calamidade, pois a API do Windows s´ o fornecia algumas fun¸co˜es b´ asicas, e o programador tinha que escrever praticamente tudo o que ia utilizar. Situa¸caõ semelhante ocorria com os demais ambientes de janelas. Desenvolver um programa para um ambiente de janelas tornou-se mais fácil, gra¸cas a bibliotecas de interfaces gráficas orientadas a objeto (GDI), como a Qt, a GTK, a VCL, a MFC, entre outras. Essas interfaces fornecem toda uma hierarquia de classes que podem ser imediatamente herdadas pelo seu programa. Você pode criar janelas, menus, botões, barras de ferramentas, entre outros objetos, com muita facilidade. Entretanto, para que se possa desenvolver um programa para um ambiente gráfico, é preciso aprender programa¸caõ orientada a objeto. Você s´ o conseguirá herdar e utilizar os objetos fornecidos pelas bibliotecas gr´ aficas se compreender a programa¸caõ orientada a objeto e a sintaxe de C++ (veremos a sintaxe de C++ em detalhes a partir do Cap´ıtulo 7 – Introdu¸caõ ao C++.). Em 2007, as bibliotecas gr´ aficas mais utilizadas no ambiente Windows s˜ ao a VCL, do Builder, Delphi e a MFC, do Microsoft Visual C++. No ambiente GNU/Linux, as mais utilizadas s˜ ao as bibliotecas Qt (da TrollTech/KDE) e a biblioteca GTK (da GNU/GNOME). Dica: dê preferência a bibliotecas que sejam livres e multiplataforma. Veremos no Cap´ıtulo ?? – A biblioteca Qt 4, exemplos de uso da biblioteca Qt.

6.6.6

Sele¸c˜ ao do ambiente de desenvolvimento integrado – IDE

Uma IDE é uma interface integrada para o desenvolvimento de programas e softwares avançados. Ela facilita a vida do programador, pois as diversas ferramentas a serem utilizadas – compilador, editor de texto, linker, debuger, sistema de controle de vers˜ oes, entre outros – est˜ ao integrados em uma u ´ nica ferramenta. A seguir ser˜ ao descritos alguns ambientes de desenvolvimento integrados utilizados nas plataformas Windows, Mac OS X, Unix e GNU/Linux. Windows Em se tratando de ambientes de desenvolvimento, pode-se dizer que o Borland C++, o Builder C++ e o Microsoft Visual C++ s˜ ao programas bastante seguros e completos. Contam com geradores autom´ aticos de c´ odigo e visualizadores de classes. Um programa GPL (software livre) simples e bom é o Dev C++. Mac OS System X O Mac OS System X é um sistema operacional compat´ıvel com os sistemas Unix e GNU/Linux, de forma que programas feitos utilizando bibliotecas multiplataforma, como a Qt ou GTK, rodar˜ ao no seu Mac OS X. Um ambiente de desenvolvimento bastante conhecido pelo pessoal que usa Mac é o Code Warrior Metroworks. GNU/Linux (Unix) Nos u ´ ltimos anos os ambientes de desenvolvimento do GNU/Linux sofreram diversos Programa¸caõ Orientada a Objeto com C++



153

aperfei¸coamentos. Distribui¸co˜es do GNU/Linux incluem diversos pacotes para aux´ılio ao desenvolvimento de software em C++, podendo-se citar: controle de vers˜ oes (cvs, subversion, cervisia), auditoria de software (gprof, callgrind, oreport, valgrind, kcachegrind, chainsaw ), “ debugagem” (gdb, ddd ), interfaces integradas de desenvolvimento (kdevelop, Eclipse, glade, QtDesigner), e utilitários (Kbabel, emacs, kbugbuster ). A programa¸caõ para software livre e GNU/Linux ser´ a discutida na parte IV do livro. Dica: veja na Revista Linux, edi¸caõ 29, uma lista auxiliar de ambientes de desenvolvimento para GNU/Linux. Procure o endere¸co: http://www.revistadolinux.com.br/ed/029/assinantes/desenvolvimento.php3. A Linux Magazine, n´ umero 12, apresenta a reportagem Ferramentas de Desenvolvimento – An´ alise. Ambientes de desenvolvimento A seguir ser´ a apresentada uma lista de ambientes de desenvolvimento. Abra o site indicado e verifique quais s˜ ao as plataformas suportadas. Microsoft Visual C++ .NET 2003 ´ uma IDE completa que usa a biblioteca de classes MFC (Microsoft Foundation Classes). E Veja a seguir as principais caracter´ısticas do Visual C++, as quais foram extra´ıdas do site da Microsoft. Conformidade do C++ com as normas ISO; otimiza¸co˜es atualizadas do compilador; verifica¸co˜es aperfei¸coadas de seguran¸ca do buffer; Windows Forms Designer; melhor diagnóstico do compilador; depura¸caõ aperfei¸coada no C++; documenta¸caõ expandida e amostras; e bibliotecas revisadas para maior seguran¸ca. Para maiores detalhes consulte o site http://msdn.microsoft.com/visualc/. Borland Enterprise Studio C++ ´ uma IDE completa que usa a biblioteca de classes VCL (Visual Class Library). E Para maiores detalhes consulte o site http://www.borland.com.br/estudiocpp/. Borland C++ Builder Ambiente completo, do tipo RAD, que utiliza a biblioteca VCL – Visual Class Library. Tem suporte ` a UML 1.5 ou 2.0, e, com o LiveSource, pode-se alternar entre o desenvolvimento da modelagem UML ou da implementa¸caõ. Também permite a cria¸caõ de novos padr˜ oes. Veja o que diz o site da Borland: ”Para o desenvolvedor C++ profissional, que exige aplica¸co˜es confi´ aveis e de alta-performance. R 2006 atualiza e refina o popular IDE Enfim o IDE que você esperava! O C++Builder R com as mais recentes fun¸ do C++Builder co˜es RAD e ALM para o desenvolvimento C e C++ cr´ıtico ` a miss˜ ao. Desenvolva robustas aplica¸co˜es GUI, de base de dados e Web em tempo recorde, com desenvolvimento de aplica¸co˜es Web WYSIWYG, poderosos novos provedores de dados, as mais recentes fun¸co˜es de produtividade IDE, e uma profunda integra¸caõ de IDE com controle de vers˜ ao, acompanhamento de bugs e colabora¸caõ de equipe. Alavanque uma grande variedade de componentes de terceiros com o mais recente VCL (Visual Component Library). Parte do Borland Developer Studio, o C++Builder 2006 também inclui suporte completo ao desenvolvimento Web, de base de dados e GUI utilizando C, C++, C#, Delphi Win32 e Delphi .NET.” Para maiores detalhes consulte o site http://www.borland.com/us/products/cbuilder/. Programa¸caõ Orientada a Objeto com C++


154

6.6. PROJETO DO SISTEMA Nota: o kylix foi uma tentativa frustada da borland de desenvolver um ambiente para plataforma GNU/Linux.

Dev C++ Ambiente visual pequeno, simples de usar e que utiliza as ferramentas da GNU. Veja na Figura 6.27 a tela do programa Dev C++. Para maiores detalhes, como instala¸caõ, siga as instru¸co˜es do site http://www.bloodshed. net/dev/.

Figura 6.27: A tela do programa Dev C++.

Code Warrior Metroworks Ambiente completo com uso da biblioteca Code Warrior. Muito utilizada no Mac Os System X. Para maiores detalhes consulte o site http://www.metrowerks.com. Kdevelop O kdevelop tornou-se um ambiente multilinguagem, podendo ser utilizado para desenvolver programas em Ada, C, C++ (biblioteca GDI – Qt ou GTK), banco de dados, Fortran, Haskell, Java, Pascal, Perl, PHP, Python, Ruby e Shell. Ou seja, você aprende a usar um ambiente de desenvolvimento e faz programas utilizando diferentes linguagens. Adaptou o Qt-designer para funcionamento integrado, tem interface integrada para acesso a debuger e a diferentes sistemas de controle de vers˜ oes. Permite visualizar os arquivos e as classes de diferentes formas. Muito bem documentado. Veja na Figura 6.28 a tela do kdevelop. Programa¸caõ Orientada a Objeto com C++



155

Para maiores detalhes consulte o site http://www.kdevelop.org. Figura 6.28: A tela do programa kdevelop.

Qt-designer Ambiente do tipo RAD, completo e de uso simplificado. Veja uma pequena reportagem sobre o Qt-designer na Revista Linux, edi¸caõ 31, dispon´ıvel em http://www. revistadolinux.com.br/ed/031/assinantes/programacao.php3. Exemplos de uso da biblioteca Qt, utilizada pelo Qt-designer, est˜ ao dispon´ıveis na se¸caõ ??. Para maiores detalhes consulte o site http://www.trolltech.com. Glade ´ o Ambiente completo que utiliza o toolkit do gtk++ (veja http://www.gtk.org/). E ambiente ideal para o desenvolvimento de programas para o GNOME. Para maiores detalhes consulte o site http://glade.gnome.org/. Eclipse ´ um o eclipse é uma plataforma completa para constru¸caõ e integra¸caõ de software. E software livre desenvolvido pela IBM, escrito em Java, mas que tem suporte para C e C++. Veja o que diz o site http://www.eclipse.org/: ”O Eclipse é um projeto da comunidade de software aberto focado na construçaõ de uma plataforma de desenvolvimento composta de bibliotecas extens´ıveis e ferramentas para desenvolvimento, constru¸caõ e gerenciamento, em tempo de execu¸caõ, de softwares ao longo de seu ciclo de vida. Uma grande e entusiasmada equipe, formada pelos maiores vendedores de tecnologias e iniciativas inovadoras, como universidades, institui¸co˜es de pesquisa e indiv´ıduos, tem extendido, complementado e dado suporte a plataforma do Eclipse” Programa¸caõ Orientada a Objeto com C++


156


Figura 6.29: A tela do programa qt-designer.

Anjuta Outro ambiente de desenvolvimento para o GTK/GNOME. Para maiores detalhes consulte o site http://anjuta.sourceforge.net. Source navigator Dispon´ıvel em algumas distribui¸co˜es Redhat. Para maiores detalhes consulte o site http://sources.redhat.com/sourcenav/. Sistema GNU Pode-se desenvolver os programas com editores de texto simples (emacs, vi), compilar os programas com o gcc/g++, linkar com o ld, e usar o make para compila¸caõ automatizada. Tem o cvs para controle de vers˜ oes. O programa doxygem é utilizado para gerar documenta¸caõ embutida. O sistema da GNU tem ainda os pacotes automake, autoconf e libtool que permitem o desenvolvimento de sistemas multiplataforma. Todos esses sistemas ser˜ ao vistos em detalhes a partir do Cap´ıtulo ?? – Introdu¸caõ à Programa¸caõ Multiplataforma com Software Livre. Para maiores detalhes consulte o site http://www.gnu.org. Observe que o sistema GNU garante maior portabilidade e uniformidade no desenvolvimento de seus programas, pois esse sistema est´ a presente em praticamente todas as plataformas. As bibliotecas gráficas mais interessantes s˜ ao a Qt e a GTK pois s˜ ao livres e multiplataforma. Os sistemas GNU ser˜ ao discutidos na Parte?? – Programa¸caõ Multiplataforma com Software Livre. Nota: se o sistema que vai ser desenvolvido é grande, ent˜ ao a etapa de projeto pode ser feita em paralelo à an´ alise e deve considerar as experiências da equipe de desenvolvimento. Programa¸caõ Orientada a Objeto com C++


6.7. PROJETO ORIENTADO A OBJETO – POO

6.7

157

Projeto orientado a objeto – POO

O projeto orientado a objeto é a etapa posterior ao projeto do sistema (veja a Figura 5.1). Baseia-se na an´ alise, mas considera as decis˜ oes do projeto do sistema. Acrescenta a an´ alise desenvolvida e as caracter´ısticas da plataforma escolhida (hardware, sistema operacional e linguagem de programa¸caõ). Passa pelo maior detalhamento do funcionamento do programa, acrescentando atributos e métodos que envolvem a solu¸caõ de problemas espec´ıficos n˜ ao identificados durante a an´ alise. Envolve a otimiza¸caõ da estrutura de dados e dos algoritmos, a minimiza¸caõ do tempo de execu¸caõ, de mem´ oria e de custos. Existe um desvio de ênfase para os conceitos da plataforma selecionada. Exemplo: na an´ alise você define que existe um método para salvar um arquivo em disco, define um atributo nomeDoArquivo, mas n˜ ao se preocupa com detalhes espec´ıficos da linguagem. J´ a no projeto, você inclui as bibliotecas necess´ arias para acesso ao disco, cria um objeto espec´ıfico para acessar o disco, podendo, portanto, acrescentar novas classes àquelas desenvolvidas na an´ alise. Efeitos do projeto no modelo estrutural • Adicionar nos diagramas de pacotes as bibliotecas e subsistemas selecionados no projeto do sistema (exemplo: a biblioteca gr´ afica selecionada). • Novas classes e associa¸co˜es oriundas das bibliotecas selecionadas e da linguagem escolhida devem ser acrescentadas ao modelo. • Estabelecer as dependências e restri¸co˜es associadas à plataforma escolhida. Efeitos do projeto no modelo dinˆ amico • Revisar os diagramas de seq¨ uência e de comunica¸caõ considerando a plataforma escolhida. • Verificar a necessidade de se revisar, ampliar e adicionar novos diagramas de máquinas de estado e de atividades. Efeitos do projeto nos atributos • Atributos novos podem ser adicionados a uma classe, como, por exemplo, atributos espec´ıficos de uma determinada linguagem de programa¸caõ (acesso a disco, ponteiros, constantes e informa¸co˜es correlacionadas). • Estruturas de dados avan¸cadas podem ser montadas utilizando-se os containers e algoritmos genéricos de C++ (a STL ser´ a discutida a partir do Cap´ıtulo 31 – Introdu¸caõ à Biblioteca Padr˜ ao de Gabaritos de C++ – STL ). Efeitos do projeto nos m´ etodos • Em fun¸caõ da plataforma escolhida, verifique as poss´ıveis altera¸co˜es nos métodos. O projeto do sistema costuma afetar os métodos de acesso aos diversos dispositivos (exemplo: hd, rede). • De maneira geral os métodos devem ser divididos em dois tipos: i) tomada de decis˜ oes, métodos pol´ıticos ou de controle; devem ser claros, leg´ıveis, flex´ıveis e usam polimorfismo. Programa¸caõ Orientada a Objeto com C++


158

6.7. PROJETO ORIENTADO A OBJETO – POO ii) realiza¸caõ de processamentos, podem ser otimizados e em alguns casos o polimorfismo deve ser evitado.

• Algoritmos complexos podem ser subdivididos. Verifique quais métodos podem ser otimizados. Pense em utilizar algoritmos prontos como os da STL (algoritmos genéricos). • Responda a pergunta: os métodos da classes est˜ ao dando resposta às responsabilidades da classe? • Revise os diagramas de classes, de seq¨ uência e de máquina de estado. Efeitos do projeto nas heran¸ cas • Reorganiza¸caõ das classes e dos métodos (criar métodos genéricos com parˆ ametros que nem sempre s˜ ao necess´ arios e englobam métodos existentes). • Abstra¸caõ do comportamento comum (duas classes podem ter uma superclasse em comum). • Utiliza¸caõ de delega¸caõ para compartilhar a implementa¸caõ (quando você cria uma heran¸ca irreal para reaproveitar c´ odigo). Usar com cuidado. • Revise as heran¸cas no diagrama de classes. Efeitos do projeto nas associa¸ co ˜es • Deve-se definir na fase de projeto como as associa¸co˜es serão implementadas, se obedecer˜ ao um determinado padr˜ ao ou n˜ ao. • Se existe uma rela¸caõ de ”muitos”, pode-se implementar a associa¸caõ com a utiliza¸caõ de um dicion´ ario, que é um mapa das associa¸co˜es entre objetos. Assim, o objeto A acessa o dicion´ ario fornecendo uma chave (um nome para o objeto que deseja acessar) e o dicion´ ario retorna um valor (um ponteiro) para o objeto correto. Veja o Cap´ıtulo 29 – Implementando Associa¸co˜es em C++. • Evite percorrer várias associa¸co˜es para acessar dados de classes distantes. Pense em adicionar associa¸co˜es diretas. Efeitos do projeto nas otimiza¸ co ˜es • Fa¸ca uma an´ alise de aspectos relativos ` a otimiza¸caõ do sistema. Lembrando que a otimiza¸caõ deve ser desenvolvida por analistas/desenvolvedores experientes. • Identifique pontos a serem otimizados em que podem ser utilizados processos concorrentes. • Pense em incluir bibliotecas otimizadas. • Se o acesso a determinados objetos (atributos/métodos) requer um caminho longo (exemplo: A->B->C->D.atributo), pense em incluir associa¸co˜es extras (exemplo: A-D.atributo). • Atributos auxiliares podem ser inclu´ıdos. • A ordem de execu¸caõ pode ser alterada. • Revise as associa¸co˜es nos diagramas de classes. Programa¸caõ Orientada a Objeto com C++



159

Depois de revisados os diagramas da an´ alise você pode montar dois diagramas relacionados à infraestrutura do sistema. As dependências dos arquivos e bibliotecas podem ser descritos pelo diagrama de componentes (veja a se¸caõ 6.7.1), e as rela¸cões e dependências entre o software e o hardware podem ser ilustradas com o diagrama de implanta¸caõ (veja a se¸caõ 6.7.1).

6.7.1

Diagrama de componentes

O diagrama de componentes mostra a forma como os componentes do programa se relacionam, suas dependências. Inclui itens como: componentes, subsistemas, execut´ aveis, n´ os, associa¸co˜es, dependências, generaliza¸co˜es, restri¸co˜es e notas. Exemplos de componentes s˜ ao bibliotecas est´ aticas, bibliotecas dinâmicas, dlls, componentes Java, execut´ aveis, arquivos de disco, c´ odigo-fonte. Veja na Figura 6.30 um exemplo de diagrama de componentes. Observe que este inclui muitas dependências, ilustrando as rela¸co˜es entre os arquivos. Por exemplo: o subsistema biblioteca inclui os arquivos das classes A e B, e a gera¸caõ dos objetos A.obj e B.obj depende dos arquivos A.h, A.cpp, B.h e B.cpp. A gera¸caõ da biblioteca depende dos arquivos A.obj e B.obj. O subsistema biblioteca Qt, um subsistema exerno, inclui os arquivos de c´ odigo da biblioteca Qt e a biblioteca em si. O subsistema banco de dados representa o banco de dados utilizado pelo sistema e tem uma interface de acesso que é utilizada pelo programa para acesso aos dados armazenados no banco de dados. O programa execut´ avel a ser gerado depende da biblioteca gerada, dos arquivos da biblioteca Qt, do módulo de arquivos MinhaJanela e do banco de dados. Algumas observa¸co˜es u ´ teis para o diagrama de componentes: • De posse do diagrama de componentes, temos a lista de todos os arquivos necess´ arios para compilar e rodar o programa. • Observe que um assunto/pacote pode se transformar em uma biblioteca e ser´ a inclu´ıdo no diagrama de componentes. • A liga¸caõ entre componentes pode incluir um estereótipo indicando o tipo de relacionamento ou algum protocolo utilizado.

Figura 6.30: Diagrama de componentes. Diagrama de componentes, módulos do programa. Mostra os componentes necessários para montagem do programa. <> MinhaJanela.h MinhaJanela.cpp

<> MétodosNuméricos

<> A.h A.cpp

<> A.obj

<> B.h B.cpp

<> B.obj

<> Arquivos biblioteca Qt

<> biblioteca dependência <> Sub-sistema banco de dados *postgresql


<> meuPrograma Um receptáculo e uma observação mostrando a conexão do programa com o banco de dados.


160


6.7.2

Diagrama de implanta¸c˜ ao – execu¸c˜ ao

O diagrama de implanta¸caõ é um diagrama de alto n´ıvel que inclui rela¸co˜es entre o software e o hardware e que se preocupa com os aspectos da arquitetura computacional escolhida. Seu enfoque é o hardware, a configura¸caõ dos n´ os em tempo de execu¸caõ. O diagrama de implanta¸caõ deve incluir os elementos necess´ arios para que o sistema seja colocado em funcionamento: computador, periféricos, processadores, dispositivos, n´ os, relacionamentos de dependência, associa¸caõ, componentes, subsistemas, restri¸co˜es e notas. Veja na Figura 6.31 um exemplo de diagrama de implanta¸caõ de um cluster. Observe a presen¸ca de um servidor conectado a um switch. Os n´ os do cluster (ou clientes) também est˜ ao conectados ao switch. Os resultados das simula¸co˜es s˜ ao armazenados em um servidor de arquivos (storage). Pode-se utilizar uma anota¸caõ de localiza¸caõ para identificar onde determinado componente est´ a residente, por exemplo {localiza¸caõ: sala 3}. Figura 6.31: Diagrama de implanta¸caõ.

Diagrama de implantação, inclui aspectos de hardware, conexões, drives. Mostra o hardware e as ligações necessárias para rodar o programa.

switch Giga

<>

<>

<> <>

<> <> <> <>

<>

Servidor Lógico OpenMosix HD <>

<> <> <> <>

Demais clientes repetem configuração do cluster-01.

Programa simulação

Servidor de arquivos, armazenamento de dados



˜ 6.8. IMPLEMENTAC ¸ AO

6.8

161

Implementa¸c˜ ao

Nesta se¸caõ veremos como nos preparar para a implementa¸caõ, algumas dicas para implementa¸caõ da interface gr´ afica do programa, e como montar o c´ odigo inicial do programa com o umbrello.

6.8.1

Antes de iniciar a implementa¸c˜ ao

• Dica de UP – fa¸ca um planejamento da implementa¸caõ (monte um plano). ` medida que se modelam as diversas classes e métodos, deve-se testar cada classe e cada • A método desenvolvido (teste l´ ogico). A dica é criar classes de teste para testar as classes e subsistemas criados (veja o item 4 da se¸caõ 6.9). • Antes de iniciar a implementa¸caõ de um método complexo, você deve concluir o seu diagrama de atividades. • Mantenha contato constante com os usuários do sistema e esteja atento a custos e prazos.

6.8.2

Roteiro para montar o c´ odigo inicial do programa com o Umbrello

Softwares modeladores como o umbrello, o dia e o Visual-Paradigm podem ser utilizados para montagem do c´ odigo inicial do programa. De modo geral, o c´ odigo é gerado a partir do diagrama de classes, e a maioria dos modeladores implementa uma ”casca” inicial do programa que inclui as classes, seus atributos, métodos, associa¸co˜es e documenta¸co˜es. Vimos na se¸caõ 4.4.2 o programa umbrello, o qual pode ser utilizado para gerar o c´ odigo inicial do programa. Uma das vantagens do umbrello é que ele é software livre e tem a capacidade de gerar os c´ odigos para diversas linguagens. • C++, Actionscript, Ada, IDL, Java, JavaScript, Pascal, Perl, PHP, Python, Ruby, SQL, TCL, XMLschema. Nota: se você ainda n˜ ao tem o programa umbrello instalado, veja na se¸caõ 4.4.2 como obter o umbrello. Leia o manual de instala¸caõ e instale o programa. Em seguida leia o manual do usuário do umbrello para se familiarizar com o programa. Aprenda em detalhes como criar os diagramas de classe. Veja a seguir um roteiro para montar o c´ odigo inicial do programa com o umbrello. 1. Abra o programa umbrello. 2. Monte os diagramas de classes para seu sistema. Inclua todos os atributos, métodos e associa¸co˜es necess´ arias. Como exemplo, você pode reproduzir o exemplo da Figura 4.8. 3. Revise o diagrama de classe. A idéia é s´ o gerar o c´ odigo depois que o diagrama de classe esteja correto. 4. Inclua as considera¸co˜es do projeto e revise novamente o diagrama. 5. Selecione o item de menu ’C´ odigo->Linguagem Ativa’ e logo ap´ os selecione C++. Programa¸caõ Orientada a Objeto com C++


162

6.9. TESTE DE SOFTWARE

6. Selecione o item de menu ’C´ odigo->Assistente de Gera¸caõ de Código’. No diálogo ’Assistente de Gera¸caõ de C´ odigo’, selecione as classes que devem ter seu c´ odigo gerado e em seguida pressione o botão ”Pr´ oximo”. 7. No diálogo ’Op¸co˜es de Gera¸caõ de C´ odigo’ temos 3 abas: (a) Geral – você define a linguagem a ser utilizada, além da pasta onde o programa vai ser armazenado e a pol´ıtica de substitui¸caõ de arquivos. (b) Formata¸caõ – define caracter´ısticas dos coment´ arios, tipo e quantidade de indenta¸caõ. (c) Op¸co˜es de linguagem – define caracter´ısticas espec´ıficas da linguagem selecionada. Depois de fazer suas op¸co˜es pressione o botão ”Próximo”. 8. Confira as classes selecionadas e ent˜ ao pressione ”Gerar”. O c´ odigo gerado estar´ a disponibilizado no diret´ orio informado. 9. Use o editor ou IDE de sua preferência para editar os c´ odigos gerados. Com o c´ odigo inicial do programa gerado por uma ferramenta CASE (como o umbrello ou o Visual-Paradigm), parte-se para a implementa¸caõ do programa. Nesta etapa s˜ ao essenciais n˜ ao s´ o os conhecimentos da modelagem orientada a objeto, mas da linguagem de programa¸caõ, ou seja, as regras de sintaxe e a forma como a linguagem implementa a programa¸caõ orientada a objeto.

6.8.3

Dicas para implementa¸c˜ ao da interface gr´ afica

Para implementar a interface gr´ afica do programa, o engenheiro de software deve considerar aspectos como: • Padroniza¸caõ (consistência; opera¸co˜es semelhantes têm interfaces semelhantes). • Na medida do poss´ıvel, a interface deve ser orientada a objeto, isto é, os elementos visuais da interface devem representar objetos internos. • Use threads (processamento paralelo). Por exemplo: é interessante ter uma thread separada respons´ avel pela atualiza¸caõ da interface gráfica do sistema, enquanto outras threads est˜ ao realizando as atividades solicitadas. • Di´ alogos devem lembrar as u ´ ltimas op¸co˜es selecionadas. Você pode incluir um botão ”default”. • Veja um conjunto de instru¸co˜es para construir interfaces gráficas amig´ aveis no documento http://developer.gnome.org/projects/gup/hig/.

6.9

Teste de software

Apresenta-se nesta se¸caõ o teste de software: o que é, porque devemos testar nossos softwares, a equipe de teste e uma metodologia simplificada para o teste de software. Programa¸caõ Orientada a Objeto com C++



6.9.1

163

Por que testar?

O teste se preocupa com o funcionamento l´ ogico do programa, se o software cumpre com seus objetivos, se os requisitos de qualidade, usabilidade e performance foram atendidos, com o controle dos bugs. Segundo [Pressman, 2002], ”o objetivo do teste é encontrar o maior n´ umero poss´ıvel de erros, com um m´ınimo de esfor¸co aplicado, durante um intervalo de tempo real´ıstico”. • O objetivo prim´ ario do teste de software é diminuir as falhas de um software, tendo como conseq¨ uência uma redu¸caõ no custo e no tempo de desenvolvimento do software. • Entre as vantagens de um software bem testado est˜ ao o aumento da qualidade, da funcionalidade e a redu¸caõ das falhas. Outras conseq¨ uências de um software bem testado é a redu¸caõ na necessidade de suporte. • Incluir no cronograma de desenvolvimento do sistema as atividades de teste. • Controle o processo de teste. Você precisa definir o rigor, o n´ıvel de detalhamento dos testes a serem realizados. Por exemplo: um programa para controle de vôo requer um sistema de testes extremamente rigoroso. • Use procedimentos automatizados para execu¸caõ do teste (como check-list e programas de teste). • Use uma metodologia de teste adaptada à sua equipe. Dica de XP: o planejamento e execu¸caõ do teste deve ser integrado ao projeto de desenvolvimento do sistema. Isto é, os testes do software devem ser realizados ao longo de todas as etapas de desenvolvimento.

6.9.2

Equipe de teste

O tamanho da equipe de teste depende do tamanho da equipe envolvida no projeto. Em alguns casos a equipe de teste é uma equipe separada. A seguir, ser˜ ao brevemente apresentadas as responsabilidades de cada membro da equipe: • Gerente – respons´ avel pela infraestrutura do sistema de teste, pela montagem da equipe e pela sele¸caõ das ferramentas a serem utilizadas. • Analista – respons´ avel pelo planejamento do teste, estrutura l´ ogica do teste, cria¸caõ de check-list e an´ alise dos resultados obtidos. • Testador – realiza os testes e emite relat´ orios. Dica de XP: a metodologia eXtreme Programming indica a montagem de duas equipes, uma implementa as classes e a outra, o sistema de testes.

6.9.3

Metodologia de teste

Segundo [Sonerviile, 1993], o processo de teste evolue: teste de unidade, teste de módulos, teste de subsistemas, teste do sistema e teste de aceita¸caõ. Existem diferentes metodologias de teste. Veja a seguir uma poss´ıvel metodologia para o teste de seu software: Programa¸caõ Orientada a Objeto com C++


164


1. Teste das especifica¸co˜es: • O teste come¸ca na an´ alise dos requisitos, das especifica¸co˜es – O sistema especificado est´ a fechado (completo)? • Teste dos casos de uso – Eles fazem sentido? Est˜ ao completos? • Teste da interface (prot´ otipo) ´ amig´ – A interface satisfaz as necessidades do cliente? E avel? – Montar uma equipe com dois a três usuários que farão testes com o prot´ otipo gerado, dando uma resposta a quesitos como funcionalidade, facilidade de uso, e sugest˜ oes para melhoria da interface do sistema. 2. Teste da estrutura do sistema: • Os assuntos/pacotes foram identificados? Eles fazem sentido? • Os diagramas de classes est˜ ao completos? 3. Teste da dinâmica do sistema (teste l´ ogico): • Todos os diagramas de caso de uso foram considerados? Foram utilizados para montagem dos diagramas de comunica¸caõ? • O teste l´ ogico é realizado sem nenhum c´ odigo; para tanto, partimos dos diagramas de casos de uso e criamos os diagramas de comunica¸caõ. No teste l´ ogico é verificada a integra¸caõ entre pacotes, componentes e classes. • Quando necess´ ario os diagramas de máquina de estado foram montados? • Você montou os diagramas de atividade para os métodos complexos? 4. Teste do projeto: • A arquitetura e a plataforma escolhidas s˜ ao adequadas? S˜ ao multiplataforma? S˜ ao extens´ıveis? • O sistema suportar´ a m´ ultiplos processos? • O sistema permite o uso de processamento paralelo? 5. Teste de unidade (classes, atributos, métodos e subsistemas): Utilizado para verificar se cada unidade (classe, subsistema) est´ a consistente. Deve ser realizado antes e depois da implementa¸caõ de cada classe. • Classes: – A classe tem sentido l´ ogico? Ela representa uma abstra¸caõ significativa do problema? – Testar a classe utilizando diagramas de comunica¸caõ. – O programador implementa as diferentes classes e, para cada classe importante, cria uma classe de teste. – A classe de teste deve testar toda interface da classe-alvo (métodos p´ ublicos). • Atributos: Programa¸caõ Orientada a Objeto com C++



165

– O tipo e a precisão s˜ ao adequados? – O atributo foi inicializado? – O intervalo de valores é respeitado? • Métodos: – – – – –

Verificar as entradas, tipo dos parˆ ametros, limites, precisão. L´ ogica do método/algoritmo (montar diagrama de atividade). Verificar aloca¸caõ/desaloca¸caõ de memória, uso de ponteiros. Verificar tipo de retorno, valores retornados. Cada método deve ser testado com um conjunto de dados que inclua dadospadr˜ ao e dados de exce¸co˜es (valores inválidos). Primeiro, deve-se testar os casos simples, mais usuais; depois, os casos complexos, com os métodos assumindo valores próximos aos extremos admitidos.

• Pacotes: – Pode-se criar pequenos programas para teste das classes de um pacote. 6. Teste de integra¸caõ: Consiste em testar a integra¸caõ entre as diversas partes do sistema (classes <-> subsistemas, subsistema<->subsistema). • Testar a integra¸caõ entre as classes que fazem parte de um pacote/assunto ou hierarquia. Acesso, comunica¸caõ, funcionalidade (usar diagramas de comunica¸caõ, de atividades, de componentes). • Testar integra¸caõ dentro de uma hierarquia. • Testar as rela¸co˜es e integra¸co˜es entre pacotes/subsistemas: 7. Teste de compila¸caõ: • Mensagens de warning. Verifique todas essas mensagens, pois elas precisam ser eliminadas. • Como os compiladores têm evolu´ıdo rapidamente, é normal aparecerem erros diferentes quando se compila o software com compiladores diferentes. A dica é compilar o programa em diferentes plataformas com diferentes compiladores. 8. Teste de sistema (usu´ ario <-> sistema): • Teste de opera¸caõ normal com alguns usuários (teste do sistema como um todo). – Um cliente ou usu´ ario experiente pode ajudar um membro da equipe de desenvolvimento a montar uma estrutura de dados que ser´ a utilizada nos testes. – Coloque usu´ arios para testar o sistema, avaliar sua qualidade, sua usabilidade (facilidade de uso do software). – Deve-se usar a mesma equipe utilizada no teste da interface, mas agora testando o sistema em funcionamento. Os usuários devem avaliar novamente a interface, o tempo de resposta do programa. – Verifique os seguintes aspectos: o programa produz os resultados esperados? Os dados incorretos s˜ ao corretamente tratados? O programa é fácil de usar? A performance é satisfat´ oria? Programa¸caõ Orientada a Objeto com C++


166

6.9. TESTE DE SOFTWARE • Teste de estresse/desempenho – Consiste em testar os limites do sistema (opera¸co˜es extremas). Os atributos e parˆ ametros assumem valores extremos. – Testar o desempenho do sistema, sua performance. Veja como aumentar a performance de seus programas e testar o desempenho de cada método/fun¸caõ usando profilers no Cap´ıtulo ?? – Auditoria e Otimiza¸caõ de Programas. • Teste de compatibilidade (multiplataforma) – Teste de interoperabilidade. – Verifique se o sistema pode ser compilado e linkado em outras máquinas, com outros sistemas e compiladores. A idéia é verificar se o sistema respeita o conceito multiplataforma. – Testar/verificar o formato dos arquivos gerados. Verificar se o arquivo gerado em uma plataforma pode ser aberto em outra (a dica é usar padr˜ oes abertos). • Teste de seguran¸ca – O sistema tem prote¸caõ contra ataques externos? • Teste de aceita¸caõ – Teste de instala¸caõ. O programa de instala¸caõ funciona? – Teste dos manuais, tutoriais. Os manuais foram feitos? Foram revisados? Os links est˜ ao corretos? • Teste de vers˜ oes – Consiste em distribuir o sistema e receber o retorno dos usuários (vers˜ ao alfa e beta).

9. Teste de regress˜ ao: Toda vez que alteramos uma parte do sistema que estava funcionando, podemos adicionar novos bugs. O teste de regress˜ ao é realizado para verificar se o programa continua funcionando. Para reduzir o n´ umero de testes de regress˜ ao procure deixar suas classes completas. • Deve ser realizado sempre que uma classe é alterada. • Quando temos certeza de que programa est´ a correto, usamos o programa de teste para gerar uma sa´ıda-padr˜ ao, que é armazenada no disco (exemplo: NomeClasse.padrao.out). A cada nova execu¸caõ do teste, uma nova sa´ıda é gerada (exemplo: NomeClasse.regressao.out). As duas vers˜ oes s˜ ao ent˜ ao comparadas com o programa diff. Se existirem diferen¸cas, ent˜ ao o programa n˜ ao passou no teste, e o c´ odigo precisa ser corrigido. 2

Dica: podemos incluir dentro dos arquivos Makefile as instru¸co˜es para rodar o programa de teste e verificar se as sa´ıdas est˜ ao iguais.

6.9.4

Senten¸cas para teste de software

• Manter uma lista enumerada com os bugs encontrados no arquivo bugs. Marcar os solucionados e os n˜ ao-solucionados. Descrever o bug e as condi¸co˜es em que ocorre, além de sua localiza¸caõ. Programa¸caõ Orientada a Objeto com C++



167

• O programa checker da GNU, obtido no endere¸co http://www.gnu.org/software/checker/, pode ser utilizado para verificar o acesso à memória realizado pelo seu programa. Segundo o site da GNU, o checker é uma ferramenta que procura erros de memória em tempo de execu¸caõ. Sua fun¸caõ prim´ aria é emitir mensagens de warning quando o programa realiza acesso a vari´ aveis n˜ ao inicializadas, ou quando o programa acessa memória n˜ ao alocada. • Quando uma classe é enviada para o repositório, o sistema de controle das vers˜ oes pode executar um programa auxiliar, este programa auxiliar pode ser o programa de teste (veja se¸caõ ??). • Para realizar o teste de unidade, procure no google por ”Objetct Oriented Software” and ”test”. Dê uma olhada no programa da GNU cppUnit, dispon´ıvel em http://cppunit. sourceforge.net. • Veja as referências: [Pressman, 2002, Emerson Rios, 2004, Winblad et al., 1993, Martin and McClure, 1993].



˜ DO PROGRAMA 6.10. DOCUMENTAC ¸ AO

168

6.10

Documenta¸c˜ ao do programa

A documenta¸caõ de um programa é essencial pelos seguintes motivos: • Compreens˜ ao do funcionamento do programa e de seu planejamento. • Acompanhamento da execu¸caõ das atividades de implementa¸caõ, testes e depura¸caõ. • Compreens˜ ao e controle das atividades desenvolvidas. • Prepara¸caõ dos manuais e da ajuda [help]do programa. • Permite a manuten¸caõ e a altera¸caõ do programa por terceiros. A Figura 5.1 ilustra as diversas etapas de desenvolvimento de um programa e os documentos que devem ser gerados. Observe que a documenta¸caõ é gerada ao longo do desenvolvimento do programa e deve servir de base para a elabora¸caõ dos manuais (estes devem ser desenvolvidos somente ap´ os a conclusão do programa). Deve-se criar um diret´ orio onde ser˜ ao armazenados os arquivos do programa a ser desenvolvido. Neste diret´ orio ser˜ ao inclu´ıdas todas as informa¸co˜es relativas ao programa, ou seja, a documenta¸caõ da an´ alise orientada a objeto, do projeto do sistema, do projeto orientado a objeto, das bibliotecas desenvolvidas, dos testes realizados, o arquivo de help do programa (tutoriais e manuais). No diret´ orio-raiz crie um arquivo README/LEIAME, com informa¸co˜es b´ asicas sobre o sistema, um arquivo com instru¸co˜es para instala¸caõ do programa (INSTALL), um arquivo com a lista das modifica¸co˜es (ChangeLog), um arquivo com as novidades da vers˜ ao (NEWS), um arquivo com os bugs identificados/solucionados (BUGS), um arquivo com instruço˜es sobre a licen¸ca do programa (COPYING), um arquivo com a lista de autores (AUTHORS) e um arquivo com questionamentos sobre poss´ıveis mudan¸cas, tarefas (TODO). No arquivo INSTALL você precisa incluir a lista de bibliotecas externas (de terceiros) que ser˜ ao utilizadas, informando também como estas bibliotecas podem ser obtidas e instaladas (pré-requisitos). Nota: para o desenvolvedor existe um efeito secund´ ario associado à documenta¸caõ do sistema, que é o estudo, a compreens˜ ao e a descri¸caõ do próprio código.

6.10.1

Itens a serem documentados

Veremos a seguir um conjunto de itens que devem estar presentes na documenta¸caõ de um software. Dentro de [] colocamos os itens opcionais. Esta lista de itens tem como base o sistema ao descritos na de documenta¸caõ JAVA DOC (o sistema JAVA DOC e o programa doxygen s˜ se¸caõ ??) e o programa umbrello (veja a Figura 4.7). Podemos dividir a documenta¸caõ em duas partes, uma relacionada aos aspectos estruturais e outra, aos aspectos dinˆ amicos. Observe que dentro do sistema temos subsistemas e dentro dos subsistemas temos pacotes. Em alguns casos, temos componentes externos (como programas externos) e artefatos externos (como arquivos e tabelas). Veremos no cap´ıtulo de programa¸caõ multiplataforma que podemos organizar nosso programa em pastas/subdiret´ orios, por isso, existe um item pasta. A seguir temos a documenta¸caõ das classes normais e classes de interface, além de suas poss´ıveis associa¸co˜es, atributos e métodos. Podemos documentar ainda as enumera¸co˜es. Programa¸caõ Orientada a Objeto com C++



169

Documenta¸ c˜ ao do sistema • Nome do sistema: • [Subsistemas:] • [Formas de acesso:] • [Bibliotecas externas utilizadas:] • Descri¸caõ: breve descri¸caõ do sistema (inclui suas responsabilidades). Documenta¸ c˜ ao dos subsistemas • Nome do subsistema: • [Nome do estereótipo:] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • Descri¸caõ: breve descri¸caõ do subsistema, o que representa. Documenta¸ c˜ ao dos assuntos/pacotes • Nome do assunto/pacote: • [Nome do estereótipo:] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • [Bibliotecas relacionadas:] • [Classes relacionadas:] • Descri¸caõ: breve descri¸caõ do pacote, o que representa. Documenta¸ c˜ ao dos componentes externos • Nome do componente: • [Nome do estereótipo:] • [Execut´ avel: S/N.] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • Descri¸caõ: breve descri¸caõ do componente, o que representa. Documenta¸ c˜ ao dos artefatos externos • Nome do artefato: • [Nome do estereótipo:] • Desenhar como: padr˜ ao, arquivo, biblioteca, tabela. • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • Descri¸caõ: breve descri¸caõ do artefato. Programa¸caõ Orientada a Objeto com C++


170


Documenta¸ c˜ ao das pastas (diret´ orios) • Nome da pasta: • [Nome do estereótipo:] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • Descri¸caõ: breve descri¸caõ da pasta. Documenta¸ c˜ ao das classes • Nome da classe: • [Nome do arquivo:] • Autor: • Data: • Copyright: • Licen¸ca: • [Nome do estereótipo:] • [Nome do pacote: assunto a que est´ a relacionada.] • [Abstrata?] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • [Superclasse:] • [Concorrência:] • [Bugs identificados:] • [See ou veja também: link para informa¸co˜es externas.] • Descri¸caõ: inclui descri¸caõ do objetivo da classe (tarefas, responsabilidades, colaboradores): Documenta¸ c˜ ao das classes de interface • Nome da classe de interface: • Autor: • Data: • Copyright: • Licen¸ca: • [Nome do estereótipo:] • [Nome do pacote: assunto a que est´ a relacionada.] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • Descri¸caõ: inclui descri¸caõ do objetivo da classe, sua forma geral de uso. Programa¸caõ Orientada a Objeto com C++



171

Documenta¸ c˜ ao das associa¸ co ˜es • Nome da associa¸caõ: • Tipo: • [Multiplicidades:] • [Atributo(s) de associa¸caõ:] • Descri¸caõ: breve descri¸caõ da associa¸caõ. Documenta¸ c˜ ao dos atributos • Nome: • Tipo: • [Valor inicial: valor m´ınimo: valor máximo:] • [Visibilidade]: p´ ublico, protegido, privado, de implementa¸caõ. • [Restri¸co˜es:] [Derivado (S/N):] • [Linguagem/escopo]: friend, const, static. • [Nome do estereótipo:] • Descri¸caõ: breve descri¸caõ do atributo. Documenta¸ c˜ ao dos m´ etodos • Nome: • Acesso: p´ ublico, protegido, privado. • Retorno: Tipo • Parâmetros: Tipo • [Nome do estereótipo:] • [Precondi¸co˜es:] • Tipo: virtual, est´ atico, normal, const. • [Exce¸co˜es:] • [Concorrência:] • Descri¸caõ: breve descri¸caõ da forma de uso. Programa¸caõ Orientada a Objeto com C++



172 Documenta¸ c˜ ao das enumera¸ co ˜es • Nome da enumera¸caõ: • [Nome do estereótipo:]

• [Visibilidade]: p´ ublico, protegido, privado, de implementa¸caõ. • Descri¸caõ: breve descri¸caõ da enumera¸caõ. Relacionados aos aspectos dinˆ amicos temos a documenta¸cão dos casos de uso, dos atores, das associa¸co˜es entre atores e casos de uso. Documenta¸ c˜ ao dos casos de uso • Nome do caso de uso: • [Nome do estereótipo:] • [Abstrato?] • [Visibilidade: p´ ublico, protegido, privado, de implementa¸caõ.] • Documenta¸caõ: breve descri¸caõ do caso de uso. Documenta¸ c˜ ao dos atores • Nome do atores: • [Nome do estereótipo:] • [Visibilidade]: p´ ublico, protegido, privado, de implementa¸caõ. • Documenta¸caõ: breve descri¸caõ do ator. Dica: para documenta¸caõ embutida, utilize o formato JAVA DOC (veja a se¸caõ ??), e, para montar os manuais do usu´ ario, o sistema DOCBOOK (sgml/xml, usando o programa LYX).

6.10.2

Cart˜ oes CRC

Alguns desenvolvedores utilizam cartões CRC (Classe/Responsabilidade/Colabora¸caõ). Um cartão CRC é dividido em três se¸co˜es: no topo, o nome da classe; na coluna da esquerda, as responsabilidades; e na coluna da direita, os colaboradores. Veja a Tabela 6.32. Figura 6.32: Cart˜ oes CRC: – cClasse, responsabilidade, colabora¸caõ. Nome da classe: Responsabilidades Colaboradores

6.10.3

Dicion´ ario de classes

´ usual a cria¸caõ de um arquivo de texto ou planilha em que constam os nomes das classes E criadas e uma breve descri¸caõ. Funciona como um dicion´ ario das classes criadas. Programa¸caõ Orientada a Objeto com C++


˜ E REUSO DE SOFTWARE 6.11. MANUTENC ¸ AO

6.11

173

Manuten¸c˜ ao e reuso de software

A manuten¸caõ do programa envolve a corre¸caõ dos bugs remanescentes e a necessidade de se extender o programa. A quest˜ ao da manuten¸caõ envolve ainda aspectos como custo da manuten¸caõ, custo para desenvolvimento de novas vers˜ oes, além de como manter a equipe de desenvolvimento. A reutiliza¸ca õ consiste em elaborar um programa com a preocupa¸caõ de este ser posteriormente reaproveitado. A idéia por tr´ as do reuso do software é simples: construir módulos, bibliotecas e classes que possam ser reaproveitados por você, sua equipe de desenvolvimento e por terceiros. Para conseguir o reuso devemos melhorar os protocolos e aumentar o empacotamento, viabilizando a constru¸caõ de bibliotecas e frameworks. Benef´ıcios do reuso de software • Redu¸caõ de custo. • Software mais testado e ”debugado”. • Economia de tempo. Veja a seguir um conjunto de dicas, algumas extra´ıdas de [Winblad et al., 1993] e [Rumbaugh et al., 1994], para aumentar a reusabilidade.

6.11.1

Senten¸cas e dicas para conseguir o reuso de software

Senten¸ cas diversas: • Documente e teste todos os sistemas desenvolvidos (veja a se¸caõ 6.9 e 6.10). • Coloque os c´ odigos em reposit´ orios (veja o Cap´ıtulo 6.11.1 – Controle de Vers˜ oes – o cvs). • Sempre que poss´ıvel use delega¸caõ. • Como outras pessoas podem ter interesse em partes de seu c´ odigo, monte-o utilizando sistemas multiplataforma, mesmo que você sempre trabalhe com a mesma plataforma.

6.11.2

Senten¸cas para aumentar o empacotamento

O conceito de empacotamento envolve a necessidade de se unir dois ou mais programas desenvolvidos por pessoas diferentes. Pode ocorrer que dois programadores desenvolvam classes com o mesmo nome e você ter´ a a necessidade de alterar o nome de uma delas. Uma linguagem que permite um bom empacotamento eliminar´ a esta necessidade. Felizmente C++ fornece o conceito de namespace (veja Cap´ıtulo 10 – Namespace), facilitando um bom empacotamento.

6.11.3

Senten¸cas para conseguir o reuso de classes

• Na elabora¸caõ use abstra¸caõ; procure deixar o sistema genérico. • Deixe a interface de acesso ` a classe simples de usar (use oculta¸caõ). • Elimine interfaces duplicadas. • Existe a necessidade de se deixar o programa mais genérico. Programa¸caõ Orientada a Objeto com C++



174

• A interface de acesso deve ser testada por outros usuários (é simples? faz sentido? obedece a um mesmo padr˜ ao?). • Se a estrutura das classes é idêntica e pouco mut´ avel, use templates. Se a estrutura das classes é dinâmica, polim´ orfica, use heran¸ca. • O objeto se comporta como um objeto padr˜ ao de C++? • Os operadores foram sobrecarregados?

6.11.4

Senten¸cas para conseguir o reuso de m´ etodos

• Construa métodos reutilizáveis. • Deixe o método o mais genérico poss´ıvel. • Mantenha os métodos pequenos, com menos de 30 linhas de c´ odigo. • Mantenha os métodos coerentes, por exemplo, executar uma u ´ nica tarefa ou tarefas estreitamente relacionadas. • Mantenha os métodos consistentes, por exemplo, métodos semelhantes devem ter nomes e formatos semelhantes. • Separe métodos pol´ıticos, aqueles que envolvem a tomada de decis˜ oes, dos de implementa¸caõ, aqueles que realizam um procedimento espec´ıfico. • Os parˆ ametros dos métodos devem ser passados de forma uniforme. Elimine parˆ ametros n˜ ao utilizados. • N˜ ao acesse informa¸co˜es globais em um método. • Evite métodos que mudam seu comportamento drasticamente em fun¸caõ de altera¸co˜es no estado dos objetos ou que tenham influência do histórico da execu¸caõ do sistema. • C´ odigos legados (antigos) feitos por terceiros poder˜ ao ser reaproveitados. Mas neste caso, você vai ter de fazer uma reengenharia neste c´ odigo. Comece encapsulando o c´ odigo de forma a deixar o acesso transparente, com os mesmos protocolos utilizados em seus sistemas. • Abuse dos métodos privados e evite métodos p´ ublicos. • Se parte de um algoritmo é repetida em dois métodos diferentes (fA, fB), pense em criar um método auxiliar, no qual o c´ odigo duplicado vai ser colocado. Se for uma heran¸ca, este método auxiliar deve ser colocado na classe-base. Senten¸ cas para construir m´ etodos robustos Um método é robusto se ele n˜ ao falha, mesmo quando recebe parˆ ametros errados. • Somente otimize o programa depois de este funcionar e ter sido testado. • Valide argumentos de métodos acessados pelo usuário. • N˜ ao inclua atributos que n˜ ao podem ser validados. Programa¸caõ Orientada a Objeto com C++



175

• Evite limites predefinidos. Dê preferência à aloca¸caõ dinâmica de memória. • Reduza o n´ umero de parˆ ametros, dividindo uma mensagem em várias (n´ umero de argumentos <= 6). • Reduza o tamanho dos métodos para até 30 linhas.

6.11.5

Senten¸cas para montagem de bibliotecas

A montagem de bibliotecas ser´ a vista no Cap´ıtulo ?? – Bibliotecas e no Cap´ıtulo ?? – O Programa Libtool. • Construa sua biblioteca utilizando a STL (descrita a partir do Cap´ıtulo 31 – Introdu¸caõ à Biblioteca Padr˜ ao de Gabaritos de C++ – STL). • N˜ ao coloque numa mesma biblioteca ´ıtens n˜ ao correlacionados, ou seja, crie tantas bibliotecas quantas forem necess´ arias. • Se for necess´ ario usar bibliotecas/vari´ aveis que n˜ ao s˜ ao multiplataforma, crie uma classe genérica, multiplataforma, e crie classes herdeiras com c´ odigos espec´ıficos para determinada plataforma. Veja a seguir dicas de [Winblad et al., 1993] para montagem de bibliotecas. ´ muito importante que um objeto seja completo, para que possa ser utilizado como uma • E biblioteca expans´ıvel. • Uma biblioteca de classes é algo genérico, com a classe-base (superclasse), as classesderivadas, os atributos e os métodos b´ asicos, além da estrutura de liga¸caõ das classes. • Uma biblioteca de classes precisa ser desenvolvida, planejada, pois n˜ ao surge espontaneamente. • Para facilitar o uso de uma biblioteca, podemos criar mais de uma interface de acesso, isto é, uma nova interface pode ser desenvolvida para atender um determinado tipo de uso. • Depois de montar a vers˜ ao 1.0 de sua biblioteca, preocupe-se em eliminar bugs, em sua otimiza¸caõ, antes de incluir novas funcionalidades.

6.11.6

Senten¸cas para montagem de framework

Uma framework é uma biblioteca de classes que foi aprimorada, aperfei¸coada para solucionar os problemas espec´ıficos de uma determinada área. As frameworks s˜ ao o objetivo fundamental do projeto orientado a objeto, uma vez que representam o n´ıvel mais alto de abstra¸caõ.Veja a seguir dicas de [Winblad et al., 1993] para montagem de frameworks. • Identifique classes-derivadas que implementem o mesmo método de diferentes maneiras. Se um método é sempre redefinido, reconsidere onde estes métodos poderiam estar mais bem localizados. • Envie mensagens para outras classes em vez de para a própria classe. • Substitua frameworks baseadas em hereditariedade por frameworks baseadas em componentes, sobrepondo métodos com mensagens enviadas para os componentes. Programa¸caõ Orientada a Objeto com C++



176

• Identifique conjuntos de métodos combinados em uma classe somente para acessar um atributo de instância comum. Considere a migra¸caõ de um ou mais métodos para outras classes; mude os métodos para passar parˆ ametros expl´ıcitos. Isto facilitará a divisão de classes. • Segundo Kent Beck (autor do modelo XP) [Teles, 2006], ”frameworks s˜ ao arriscadas quando s˜ ao desenvolvidas cedo demais, pois nesse caso serão dif´ıceis de usar. Se você estiver usando XP, primeiro você constr´ oi duas ou mais aplica¸co˜es e ent˜ ao abstrai aquilo que é comum, fazendo com que aplica¸co˜es semelhantes sejam constru´ıdas mais facilmente no futuro”. Note que esta dica é valida para qualquer metodologia, e n˜ ao apenas XP.

6.11.7

Senten¸cas para facilitar a extens˜ ao de um programa

` medida que o tempo passa, novas exigências (especifica¸cões) s˜ A ao realizadas pelos usuários, e o analista/programador deve modificar o programa com o objetivo de dar resposta às novas necessidades do usuário [Winblad et al., 1993]. • Encapsular classes. • Ocultar estruturas de dados. • Evite percorrer muitas associa¸co˜es para executar determinada tarefa. • Evite instru¸co˜es ”case” sobre o tipo de objeto. • Distinga métodos p´ ublicos dos privados.

6.11.8

Senten¸cas para programa¸c˜ ao em grande escala

Veja a seguir um conjunto de senten¸cas para o desenvolvimento de programas em grande escala [Winblad et al., 1993, Rumbaugh et al., 1994]. • N˜ ao inicie o programa prematuramente. • Mantenha os métodos compreens´ıveis. • Fa¸ca métodos leg´ıveis. • Utilize os mesmos nomes do modelo de objetos. • Escolha os nomes cuidadosamente. • Utilize diretrizes (regras) de programa¸caõ. • Procure criar módulos empacotando as classes. • Documente as especifica¸co˜es, classes, métodos, atributos e as associa¸co˜es. Deixe o usuário ter acesso a essas informa¸co˜es. • Fa¸ca um documento de uso do programa pelo usuário. Embora o texto apresentado nesta parte do livro seja introdutório, considero-o suficiente para a maioria dos sistemas a serem desenvolvidos por engenheiros ou novatos da área de Ciências da Computa¸caõ, Inform´ atica ou Sistemas de Informa¸caõ. Para maiores informa¸co˜es sobre engenharia de software veja as referências: Programa¸caõ Orientada a Objeto com C++



177

• [Blaha and Rumbaugh, 2006, Teles, 2004, Guedes, 2004, Kruchten, 2003, Pressman, 2002, Fowler and Scott, 2000, Booch et al., 2000, Martin and McClure, 1993, Winblad et al., 1993, Booch, 1986, Coad and Yourdon, 1993].

6.12


Neste cap´ıtulo aprendemos as diversas etapas para o desenvolvimento de um software. Desde a especifica¸caõ até a documenta¸caõ e a manuten¸caõ. Vimos que a especifica¸caõ do programa deve ser feita textualmente e pode incluir cenários de uso do programa, exemplos de uso. Os cenários s˜ ao visualizados com ajuda dos diagramas de caso de uso, os diagramas mais simples da UML. Em seguida, aprendemos que precisamos fazer uma elabora¸cão do problema, um estudo do problema, envolvendo a an´ alise de dom´ınio, a identifica¸caõ de pacotes e seus diagramas. Na etapa de an´ alise orientada a objeto, vimos que o modelo estrutural se preocupa com a identifica¸caõ de classes, dos atributos, dos métodos e com a montagem do diagrama de classe. Vimos como identificar as associa¸co˜es, agrega¸co˜es, composi¸co˜es, heran¸cas, restri¸co˜es, realiza¸co˜es e dependências e como descrevê-las graficamente com os diagramas de classes. Pelo modelo dinˆ amico descrevemos a dinâmica do sistema, tanto do ponto de vista do usuário (diagramas de caso de uso) quanto do ponto de vista do sistema. O macrosistema é representado pelos diagramas de sequência e de comunica¸caõ (eventos e mensagens). O comportamento das classes é descrito pelos diagramas de máquinas de estado. J´ a a microdinâmica, que ocorre dentro dos métodos, é descrita pelos diagramas de atividade. Na etapa de projeto do sistema definimos conceitos como os protocolos – API, a aloca¸caõ de recursos, a defini¸caõ do tipo de controle e a especifica¸caõ das plataformas. Inclui ainda a sele¸caõ de bibliotecas e de ambiente de desenvolvimento. De posse do diagrama de implanta¸caõ identificamos todos os equipamentos necess´ arios para colocar o sistema em funcionamento. No projeto orientado a objeto aprendemos a montar os diagramas de componentes e de implanta¸caõ (execu¸caõ). Na implementa¸caõ aprendemos que podemos usar o umbrello para montagem do c´ odigo inicial utilizando os diagramas de classe. Aprendemos a importˆ ancia do teste de software. Vimos que a documenta¸caõ é uma etapa fundamental para o desenvolvimento de programas com qualidade. Finalmente, a manuten¸caõ envolve tanto a adapta¸caõ do programa às novas solicita¸co˜es dos usuários quanto a montagem de bibliotecas reutilizáveis. Uma maneira de ”prever” o futuro é estar sempre atualizado, ler revistas de programa¸caõ, inscrever-se em sites de discuss˜ ao das APIs que for utilizar e inscrever-se em sites de desenvolvimento de software. Nota: deve-se ressaltar que os seus primeiros programas utilizando POO consumirão o mesmo tempo que os desenvolvidos utilizando técnicas estruturadas. As vantagens do reaproveitamento aparecem ` a medida que os programas vão sendo desenvolvidos, ou quando você já disp˜ oe de uma biblioteca OO e pode desenvolver o programa com ela.

6.13

Exerc´ıcios

1. Um programa antigo, escrito em C, tem as seguintes vari´ aveis e fun¸co˜es: // Vari´ aveis float x,y,z, a,b,c; Programa¸caõ Orientada a Objeto com C++


6.13. EXERCÍCIOS

178 float media,desvioPadrao; double area, perimetro, volume; double limiteInferior, limiteSuperior; float vetorDados [100]; // Fun¸ c~ oes // Calcula ´ area de uma figura double Area(..); double Perimetro(..); double Volume(..); // Calcula ´ area de uma fun¸ c~ ao double IntegralSimpson(..); double IntegralTrapezio(..); // Fun¸ c~ ao de uma vari´ avel float Fy(float x); // Fun¸ c~ ao de duas vari´ aveis float Fz(float x, float y); float FormulaBasca(..); // Calcula m´ edia de um grupo de dados, de um vetor float Media(..); float DesvioPadrao(..);

Monte o diagrama UML de um programa equivalente em C++ (diagrama de classes com atributos, métodos e associa¸co˜es). Dica: você deve agrupar atributos e métodos que se relacionam dentro de classes. 2. Para o diagrama de classes a seguir, acrescente alguns atributos e métodos (e eventualmente classes) e estabele¸ca as rela¸co˜es entre as classes (associa¸co˜es, agrega¸co˜es e heran¸cas). • Exemplos de atributos: nome, n´ umero, capacidade, valor, data, dimensões, sexo, idade, extensão, entre outros. • Exemplos de métodos: Contratar(), Despedir(), Abastecer(), Limpar(), PrepararPouso(), ConferirPassagem(), Manuten¸caõ(), ApertarCinto(), MoverFlaps(), CheckIn(), entre outros. • Monte um diagrama de eventos para o piloto. • Monte um diagrama de comunica¸caõ para o passageiro. 3. Descreva, de forma resumida, as etapas para o desenvolvimento de um programa. Diga quais s˜ ao as quatro etapas mais importantes e justifique. 4. Fa¸ca as especifica¸co˜es de um programa que calcula o ajuste de um conjunto de pares ordenados x,y a uma fun¸caõ polinomial. Isto é, como determinar uma curva (polinomial, 1D = reta, 2D = par´ abola) usando métodos como m´ınimos quadrados? (a) Monte um diagrama de caso de uso ilustrando cenários de intera¸caõ do usuário com o programa. (b) Monte os diagramas de classe incluindo os conceitos de associa¸caõ, agrega¸caõ e heran¸ca (generaliza¸caõ/especializa¸caõ). Justifique suas decis˜ oes. (c) Monte diagramas de máquina de estado para alguma classe. Programa¸caõ Orientada a Objeto com C++


6.13. EXERCÍCIOS

179

Figura 6.33: Exerc´ıcio – modelagem sistema aeroporto.

(d) Monte diagramas de atividade para algum método. Dica: crie classes de fun¸co˜es 1D, 2D, de estat´ıstica, de ajuste de curvas, de um simulador.



180

6.13. EXERCÍCIOS



Parte II

POO usando C++

181

Cap´ıtulo 7

Introdu¸c˜ ao ao C++ Neste cap´ıtulo veremos um pouco da história de C++ (se¸caõ 7.1), exemplos de aplica¸co˜es em C+ (se¸caõ 7.2), o que é o ANSI C++ (se¸caõ 7.3) e quais as novidades de C++ (se¸caõ 7.4). Ademais, veremos quais s˜ ao os tipos de programas em C++ (se¸caõ 7.5), as diferen¸cas de nomenclatura entre POO e C++ (se¸caõ 7.6), os conceitos de pré-processamento, compila¸caõ, linkagem, debugagem e otimiza¸caõ (se¸caõ 7.7). Por fim, veremos como é o layout de um programa em C++ com m´ ultiplos arquivos (se¸caõ 7.8).

7.1

Um pouco de hist´ oria

C A linguagem C foi desenvolvida por Denis Richard, em 1972, e teve origem na linguagem B, desenvolvida por Ken Thompson, em 1970. O ano de 1978 foi histórico para a linguagem C, uma vez que naquele foi editado o livro The C Programming Language, o qual teve grande vendagem e foi o respons´ avel pela divulga¸caõ de C [Kernighan and Ritchie, 1988]. Veja a seguir algumas caracter´ısticas de C: • O sucesso da linguagem C se deve ao fato de C ser independente de hardware. • C tem sido utilizada em programas estruturados. • A linguagem C e o sistema operacional Unix foram desenvolvidos conjuntamente. Isto significa que C/C++ e ambientes operacionais como Unix, GNU/Linux e Mac OS X têm uma intera¸caõ muito ´ıntima. C++ Em 1980, Bjarne Stroustrup desenvolveu a linguagem de programa¸caõ C++, um superconjunto de C inicialmente chamado C com classes. Observe que o operador ++ é o operador de incremento; assim, C++ é o C incrementado. Isto significa que C++ apresenta uma série de vantagens em rela¸caõ ao C e tem se mostrado extremamente eficiente nos mais variados campos de programa¸caõ, e por isso quase todas as grandes empresas que desenvolvem softwares utilizam C++. Mas, afinal de contas, devo aprender C e depois C++, ou ir direto para C++? O criador do C++, Bjarne Stroustrup, afirma: ”Estou firmemente convencido de que é melhor ir direto para C++” [Bjarne, 1999]. 183

˜ 7.2. EXEMPLOS DE APLICAC ¸ OES EM C++

184

Veja a seguir algumas caracter´ısticas de C++: ´ classificada como uma linguagem moderna, de quinta gera¸caõ. • E ´ de alto n´ıvel, orientada a objeto. • E ´ fortemente tipada. • E ´ linguagem de prop´ • E osito geral, ou seja, pode ser utilizada para desenvolver praticamente ´ utilizada nos mais variados tipos de computadores, sistemas todo tipo de programa. E operacionais, aplica¸co˜es e em todos os pa´ıses do mundo [Stroustrup, 2005]. ´ a mais utilizada para montagem de sistemas complexos e grandes, como os sistemas • E operacionais Windows, GNU/Linux, e programas como o Office e o OpenOffice. Nota: segundo o IDC – International Data Corporation( http://www.idc.com/), a linguagem C++ tem mais de três milh˜ oes de programadores; e esse n´ umero est´ a crescendo.

7.2

Exemplos de aplica¸c˜ oes em C++

C++ é uma linguagem de programa¸caõ de m´ ultiplos prop´ ositos, podendo ser utilizada para cria¸caõ de vários tipos de aplica¸co˜es. Veja a lista de exemplos de aplica¸co˜es em C++ no endere¸co http://www.research.att.com/~bs/applications.html. • Desenvolvimento de sistema operacional (kernel, ferramentas, device drivers, rede etc) – Microsoft Windows Vista, XP, NT, 98; BeOS (sistema operacional) • Internet – Internet Explorer; Mozilla, Firefox, Thunderbird • Aplica¸co˜es com interface gr´ afica elaborada – Microsoft Office, FrontPage, Money, Project, Exchange, AppleWorks • Sistemas gráficos, ambientes de janela, jogos – Adobe Photoshop, Illustrator, Acrobat, CDE desktop. KDE. • Banco de dados – MySQL • Sistemas CAD/CAM – Autocad • Ambientes de desenvolvimento, bibliotecas, linguagens derivadas – Qt-designer, kdevelop; CORBA, MICO; C#, Java. • Programa¸caõ cient´ıfica – Imago, Sail Veja a seguir alguns exemplos de empresas que usam C++: • Amazon, Ericsson, Bloomberg, Google, IBM, Intel, Microsoft, Metrowerks, SGI, Autodesk. Programa¸caõ Orientada a Objeto com C++


´ O ANSI C++? 7.3. O QUE E

7.3

185

O que ´ e o Ansi C++?

O ANSI C++ – American National Standards Institute – é um comitê que estabelece os conceitos b´ asicos da linguagem C++, principalmente os referentes à sintaxe. Se você desenvolver um programa compat´ıvel com o ANSI C++, pode ter certeza de que ele poder´ a ser compilado por diferentes compiladores de C++ para diferentes plataformas. Note que o compilador também deve estar dentro dos padr˜ oes de C++. • Em 1990 foi publicado o ANSI/ISO/IEC:9899:1990, que é o ANSI C ou [C90]. • Em 1998 foi aprovado o ANSI/ISO/IEC:14882:1998[E], que é o ANSI C++ ou [C++98]. • Em 1999 foi aprovado o ANSI/ISO/IEC:9899:1999[E], que é o ANSI C revisado ou [C99]. • Em 2003 foi aprovado o ANSI/ISO/IEC:14882:2003[E], que é o ANSI C++ revisado inclu´ındo o ”TR1 – Technical Corrigendum 1”, também conhecido como [C++03]. • Para 2009 est´ a prevista a aprova¸caõ do ANSI/ISO/IEC:14882:2009, que é o ANSI C++ com as inova¸co˜es do C++0x. Este livro cobre as defini¸co˜es estabelecidas pelo comitê ANSI C++. Nota: você encontra maiores informa¸co˜es do ANSI C++ no site http://www.open-std.org/ jtc1/sc22/wg21/. As inova¸co˜es do C++0x ser˜ ao apresentadas no Cap´ıtulo ?? – C++0x – O que vem por a´ı?

7.4

Quais as novidades e vantagens de C++ em rela¸c˜ ao a C?

A linguagem C++ é uma das melhores linguagens de programa¸caõ existentes, porque agrupa formula¸co˜es altamente abstratas como classes (que permitem um trabalho de alto n´ıvel) e formula¸co˜es de baixo n´ıvel (como o uso de ponteiros, aloca¸caõ dinâmica de memória e até a utiliza¸caõ de chamadas de interrup¸co˜es que realizam tarefas altamente espec´ıficas). Com C++ um u ´ nico programador consegue gerenciar uma quantidade maior de c´ odigo. Veja a seguir algumas novidades e vantagens de C++. • Como novidades de C++ em rela¸ c˜ ao ao C podemos citar – a utiliza¸caõ de classes, fun¸co˜es inline, convers˜ ao de tipo, verifica¸caõ de parˆ ametros de fun¸caõ, operadores para gerenciamento de mem´ oria (new/delete), referências, constantes, sobrecarga de operador, sobrecarga de fun¸co˜es, polimorfismo, templates (gabaritos), tratamento de exce¸co˜es e namespaces. Destes novos conceitos, os que mais se destacam s˜ ao o uso de classes, do polimorfismo e os templates. • Como vantagens de C++ em rela¸ c˜ ao ao C podemos citar – aumento da produtividade, maior reaproveitamento de c´ odigo, maior qualidade geral do projeto, facilidade de extensão e manuten¸caõ. Maior compreensão geral por toda a equipe de desenvolvimento. ´ importante notar que essas vantagens s˜ E ao compreendidas na medida em que se usa C++. Programa¸caõ Orientada a Objeto com C++


186

7.5

7.5. QUAIS OS TIPOS DE PROGRAMAS EM C++

Quais os tipos de programas em C++

Como dito, C++ é um superconjunto de C que foi desenvolvido para dar suporte à programa¸caõ orientada a objeto. A implica¸caõ dessa heran¸ca de C em C++ é que você ir´ a se deparar com programas nos seguintes formatos: • Programa estruturado escrito em C – utiliza os conceitos b´ asicos de C, dados e fun¸co˜es separados. • Programa estruturado escrito em C++ – utiliza alguns conceitos de C++, como cin/cout, switch, fun¸co˜es inline, const e referências, ou seja, utiliza algumas novidades de C++ (exemplos nos apêndices). • Programa baseado em objeto escrito em C++ – utiliza os conceitos de classes e heran¸cas. Inclui controle de acesso (public, protected e private), fun¸co˜es friend e o conceito fundamental de classes (exemplos a partir do Cap´ıtulo 11 – Classe). • Programa orientado a objeto escrito em C++ – inclui o conceito de polimorfismo e pode incluir a utiliza¸caõ de conceitos da STL, como containers e iteradores (exemplos a partir do Cap´ıtulo 19 – Polimorfismo). • Programa gen´ erico escrito em C++ – inclui os conceitos de programa¸caõ genérica. Inclui a utiliza¸caõ de algoritmos genéricos da STL, uso intensivo de containers e iteradores (exemplos na Parte III: Introdu¸caõ a STL). Este livro tem enfoque na programa¸caõ orientada a objeto em C++ e na programa¸caõ genérica.

7.6

Diferen¸cas de nomenclatura – POO e C++

A Tabela 7.1 mostra as diferen¸cas entre a nomenclatura da programa¸caõ orientada a objeto (Parte I – Filosofia e modelagem orientada a objeto) e a nomenclatura de C++. Neste livro procurei usar sempre os nomes objeto, atributo e método. Chamarei de fun¸caõ apenas as fun¸co˜es globais e fun¸co˜es de C, e chamarei de método as fun¸co˜es que s˜ ao implementadas como parte de uma classe. O objetivo é aproximar os conceitos da POO aos de programa¸caõ em C++. Tabela 7.1: Diferen¸cas na nomenclatura da POO e de C++. Nomenclatura POO Nomenclatura C++ Objeto Objeto Classe Classe Método Método/Fun¸caõ Atributo Atributo, vari´ avel Mensagem Chamada de fun¸caõ Subclasse Classe-derivada Superclasse Classe-base Hereditariedade Hereditariedade, deriva¸caõ



´ 7.7. EDITAR, PRE-PROCESSAR, COMPILAR, LINKAR, DEBUGAR E OTIMIZAR

7.7

187

Editar, pr´ e-processar, compilar, linkar, debugar e otimizar

S˜ ao descritos a seguir alguns conceitos gerais e a seq¨ uência usual para montagem de um programa. Etapa de edi¸ c˜ ao Um programa em C++ é composto por um ou mais arquivos de texto com as extensões .h (declara¸caõ de classes) e .cpp (defini¸caõ de métodos da classe). Um arquivo do programa é formado por um conjunto de instru¸co˜es de programa¸caõ que s˜ ao organizadas logicamente para realizar determinadas tarefas. Veja na Figura 7.1 os arquivos de texto Class1.h, Class1.cpp, Class2.h, Class2.cpp e Prog.cpp. Etapa de pr´ e-processamento ´ a primeira fase da compila¸caõ de um programa. Nela o compilador verifica as instru¸co˜es E passadas com o sinal #. Primeiro s˜ ao inclu´ıdos os arquivos externos, depois s˜ ao processadas as macros. Na fase de pré-processamento, cada letra do arquivo de disco é mapeada para o padr˜ ao Unicode (ISO/IEC 10646) e posteriormente para o conjunto de caracteres de execu¸caõ. O resultado da fase de pré-processamento é uma seq¨ uência de s´ımbolos que chamamos de unidade de tradu¸caõ. A unidade de tradu¸caõ é independente de outros arquivos (veja Figura 7.1). Note ainda que cada arquivo do programa é compilado separadamente. No exemplo a seguir a unidade de tradu¸caõ vai incluir o arquivo . Exemplo: // Arquivo Prog.cpp #include int main() { std::cout < < "Oi tudo bem!";

return 0; }

Para gerar o arquivo de pré-processamento digite: g++ -E Prog.cpp > Prog.ii . Note que o arquivo gerado é muito grande. Etapa de compila¸ c˜ ao – o compilador O compilador é o programa respons´ avel pela convers˜ ao do programa (texto) escrito usando uma linguagem de programa¸caõ, em c´ odigo binário (linguagem de máquina); ou seja, o compilador realiza a tradu¸caõ do c´ odigo em linguagem de máquina. Adicionalmente, o compilador encontra os erros de sintaxe do programa e, depois de compilado, o programa passa a ter um arquivo objeto *.obj (*.o no Unix, GNU/Linux). Observe na Figura 7.1 que cada classe tem dois arquivos (Class1.h e Class1.cpp) e que, ap´ os a compila¸caõ do Class1.cpp, é gerado o arquivo Class1.o. Etapa de liga¸ c˜ ao – o linker O linker é o programa que agrupa um ou mais arquivos objeto *.obj (*.o) em um arquivo execut´ avel, resolvendo as dependências (entre os arquivos) e fazendo as liga¸co˜es necess´ arias. Os erros de liga¸caõ s˜ ao detectados pelo linker. Os arquivos que ser˜ ao agrupados s˜ ao relacionados em um arquivo de projeto ou em um arquivo Makefile. Depois de linkado um programa tem um arquivo execut´ avel (*.exe no Windows, a.out no GNU/Linux). Na Figura 7.1, o linker é utilizado para gerar o programa final. Veja na Tabela 7.2 as extensões dos arquivos gerados nas Programa¸caõ Orientada a Objeto com C++


188

´ 7.7. EDITAR, PRE-PROCESSAR, COMPILAR, LINKAR, DEBUGAR E OTIMIZAR

Figura 7.1: Seq¨ uência de montagem de um programa. pré-processador Definição da classe

Class1.h

compilador

[opcional]

Class1.ii

Definição dos métodos da classe

Class1.cpp Class1.o

lib Biblioteca

Class2.o

Class2.h Class2.ii

Prog

Class2.cpp Arquivo com a função int main()

Prog.ii Prog.cpp

Prog.o

linker

diferentes plataformas. Observe que diversos arquivos objeto .o podem ser agrupados em uma biblioteca. Etapa de debugagem – o debuger O debuger é um programa que ajuda o programador a encontrar os erros de programa¸caõ – os famosos bugs. Com um debuger podemos analisar a execu¸caõ do programa passo a passo (ou linha a linha), e a cada passo podemos verificar o que est´ a acontecendo. Etapa de otimiza¸ c˜ ao – o profiler O profiler é um programa que ajuda o programador a identificar os pontos do programa que consomem mais tempo (ou seja, onde o programa est´ a lento). De posse dessa informa¸caõ podese melhorar a qualidade do programa e a sua velocidade;. para isso, apenas rode o programa de dentro do profiler e analise os resultados de tempo de execu¸caõ de cada fun¸cão. Tabela 7.2: Extensões usuais dos arquivos nas diferentes plataformas. Situa¸caõ DOS/Windows Unix, GNU/Linux Mac antes de compilar nome.h/nome.cpp nome.h/nome.cpp nome.h/nome.cpp depois de pré-processar nome.ii nome.ii nome.ii depois de compilar nome.obj nome.o nome.o depois de linkar nome.exe a.out ou nome a.out ou nome Veremos as diretrizes de pré-processador no Apêndice A – Diretrizes de pré-processador. Veremos em detalhes o compilador da GNU, o g++, no Cap´ıtulo ?? – Compilando com gcc e g++. Veremos a debugagem de programas no Cap´ıtulo ?? – Uma introdu¸caõ aos bugs e a debugagem de programas e no Cap´ıtulo ?? – Os programas gdb, ddd e o bugzilla. Por fim, veremos o uso de profilers no Cap´ıtulo ?? – Auditoria e otimiza¸caõ de programas. Programa¸caõ Orientada a Objeto com C++


7.8. LAYOUT DE UM PROGRAMA ORIENTADO A OBJETO EM C++2

7.8

189

Layout de um programa orientado a objeto em C++2

Veremos nesta se¸caõ o layout e uma estrutura-padrão para os arquivos de um programa orientado a objeto em C++; j´ a no próximo cap´ıtulo, veremos nossos primeiros exemplos. A implementa¸caõ de um programa inicia com a defini¸caõ do arquivo de projeto. Ele lista todos os arquivos que fazem parte do projeto (veja se¸caõ 7.8.1). Depois de criado o arquivo de projeto, s˜ ao criados os arquivos de cabe¸calho (*.h) com a defini¸caõ da classe, e os arquivos de implementa¸caõ (*.cpp) com a defini¸caõ dos métodos da classe. Note na Figura 7.1 que, para cada classe criada, s˜ ao gerados dois arquivos, CNomeClasse.h e CNomeClasse.cpp. O programa principal, aquele que tem a fun¸caõ main(), deve estar em um arquivo separado, com a extensão .cpp (exemplo: Programa.cpp). Nas se¸co˜es que seguem apresentaremos o prot´ otipo e a em seguida um exemplo de cada tipo de arquivo. • O arquivo de cabe¸calho da classe (*.h) é apresentado na se¸caõ 7.8.2, e um exemplo, a declara¸caõ da classe CAplicacao, é apresentado na listagem 7.1. • O arquivo de implementa¸caõ da classe (*.cpp) é apresentado na se¸caõ 7.8.3, e um exemplo, a implementa¸caõ dos métodos da classe CAplicacao, é apresentado na listagem 7.2. • O arquivo de implementa¸caõ da fun¸caõ main() é apresentado na se¸caõ 7.8.4, e um exemplo é apresentado na listagem 7.3.

7.8.1

Arquivo de projeto

A organiza¸caõ dos programas separando o c´ odigo em diversos arquivos facilita sua manutençaõ e possibilita um maior entendimento da estrutura dos programas; conseq¨ uentemente, todo o processo de compila¸caõ/recompila¸caõ fica mais r´ apido. O arquivo de projeto define quais arquivos fazem parte do programa e em que seq¨ uência devem ser compilados. Ademais, ele contém uma lista com os nomes dos arquivos de cabe¸calho (*.h) e de implementa¸caõ (*.cpp) e a forma como os mesmos ser˜ ao compilados e linkados. Vimos na se¸caõ 6.6.6 os diferentes compiladores e ambientes de desenvolvimento de C++. Cada ambiente de desenvolvimento gera um arquivo de projeto próprio. Por exemplo: um arquivo de projeto do Borland C++ tem a extensão *.ide ou *.prj; um arquivo do Microsoft Visual C++, por sua vez, tem a extensão *.mfc. No kdevelop a extensão é *.kdevelop, e no Dev C++, *.dev. No Unix e no GNU/Linux, o arquivo de projeto costuma ser um arquivo Makefile. Nota: veremos, no Cap´ıtulo ?? – Make, como montar arquivos de projeto Makefile e, no Cap´ıtulo ?? – Montagem de um programa multiplataforma com ferramentas da GNU, como montar arquivos de projeto independente de plataforma. Veja exemplo de arquivo Makefile na se¸caõ ??.

7.8.2

Arquivo de cabe¸calho da classe – CNomeClasse.h

A defini¸caõ da classe é armazenada em arquivos de cabe¸calho com a extensão *.h. Observe no prot´ otipo a seguir que inclu´ımos a documenta¸caõ. No primeiro bloco de coment´ arios inclu´ımos informa¸co˜es gerais sobre o programa, o nome do arquivo e dos autores. Depois inclu´ımos as bibliotecas padr˜ oes de C++ que ser˜ ao utilizadas e iniciamos a defini¸caõ da classe com um breve coment´ ario sobre o que a classe é e representa. Em seguida definimos a forma de acesso a cada atributo/método. Por fim, declaramos os atributos e métodos da classe colocando um breve coment´ ario sobre o que cada atributo/método representa. Programa¸caõ Orientada a Objeto com C++



190

Prot´ otipo: /** Cabe¸calho do programa Documenta¸ca õ geral do programa, do sistema como um todo. @autor nome do(s) autor(es) @file CNomeClasse.h */ /// Inclus˜ ao das bibliotecas padr˜ oes de C++ #include /// Documenta¸ca õ da classe CNomeClasse /// O que a classe é e representa... class CNomeClasse { /// Especifica¸ca õ do controle de acesso public: /// Declara¸ca õ de atributo Tipo nomeAtributo; /// Declara¸ca õ de método TipoRetorno NomeMétodo(Parˆ ametros); }; Apresenta-se na listagem 7.1 o arquivo de cabe¸calho da classe. Além da declara¸caõ e defini¸caõ da classe, inclu´ımos uma breve documenta¸caõ da classe e uma descri¸caõ do método Run(). Procurou-se incluir a maioria dos itens presentes em um programa real. Listing 7.1: Exemplo b´ asico: Arquivo de cabe¸calho da classe. // Este p r o g r a m a e x e m p l i f i c a a e s t r u t u r a / layout de um // p r o g r a m a t´ ı pico em C ++ /* * D e c l a r a uma classe minimalista , a classe C A p l i c a c a o A mesma inclui apenas um m´ e todo , o m´ e todo Run () . * */ class CAplicacao { public : // / M´ e todo de e x e c u ¸ c~ a o da a p l i c a ¸ c~ ao. void Run () ; };

Nota: vimos informa¸co˜es b´ asicas sobre documenta¸caõ de programas na se¸caõ 6.10. Veremos, ent˜ ao, como implementar a documenta¸caõ em C++ no Cap´ıtulo ?? – Documenta¸caõ de programas.

7.8.3

Arquivo de implementa¸c˜ ao da classe – CNomeClasse.cpp

As defini¸co˜es dos métodos da classe s˜ ao armazenadas em arquivos de implementa¸caõ com a extensão (*.cpp). Observe, no prot´ otipo a seguir, que sempre incluiremos o arquivo com o nome da classe #include "CNomeClasse.h". Prot´ otipo: /** Programa¸caõ Orientada a Objeto com C++



191

Cabe¸calho do programa Documenta¸ca õ geral do programa, do sistema como um todo. Implementa os métodos da classe CNomeClasse,... @autor nome do(s) autor(es) @file CNomeClasse.cpp */ /// Inclus˜ ao das bibliotecas .padr˜ ao de C++ #include /// Inclus˜ ao das bibliotecas do grupo de programadores #include ”CNomeClasse.h” /// Defini¸ca õ dos métodos da classe TipoRetorno CNomeClasse::NomeMétodo(Parˆ ametros) { ..Conjunto de tarefas a serem realizadas..; } Apresenta-se na listagem 7.2 o arquivo de implementa¸caõ da classe CAplicacao. Observe que depois de incluir o arquivo CAplicacao.h, implementamos o c´ odigo do método Run(). Listing 7.2: Exemplo b´ asico: Arquivo de implementa¸caõ da classe. /* *

Este p r o g r a m a e x e m p l i f i c a a e s t r u t u r a / layout de um p r o g r a m a t´ ı pico em C ++ */ # include < iostream > // / Inclui a d e c l a r a ¸ c~ a o da classe # include " CAplicacao . h " // / I m p l e m e n t a os m ´ e t o d o s da classe // / O m´ e todo Run () e s c r e v e uma m e n s a g e m na tela void CAplicacao :: Run () { // std :: cout e s c r e v e na tela o texto " Bem - vindo ao C ++!" std :: cout << " Bem - vindo ao C ++! " << std :: endl ; }

Nota: em Java todo c´ odigo da classe fica em um u ´ nico arquivo. Prefiro o formato usado por C++; a separa¸caõ da implementa¸caõ em um arquivo *.cpp deixa o arquivo de cabe¸calho mais enxuto e mais claro.

7.8.4

Arquivo de implementa¸c˜ ao da fun¸c˜ ao main() – programa.cpp

Além do arquivo de defini¸caõ *.h e do arquivo de implementa¸caõ *.cpp, você vai precisar de um arquivo com a defini¸caõ da fun¸caõ main(), a qual é chamada quando o programa é executado. O arquivo programa.cpp usa as classes definidas pelo programador. Veja o prot´ otipo a seguir: Prot´ otipo: /** Cabe¸calho do programa Documenta¸ca õ geral do programa, do sistema como um todo. Programa¸caõ Orientada a Objeto com C++


192

7.9. SENTENCAS ¸ @autor nome do(s) autor(es) @file programa.cpp */ /// Inclui as classes que ser˜ ao utilizadas #include ”CNomeClasse.h” /// Implementa a fun¸ca õ principal, main() int main() { TipoParˆ ametro parˆ ametro; // Cria parˆ ametro CNomeClasse objeto; // Cria objeto objeto.NomeMétodo(parˆ ametro); // Usa método do objeto criado return 0; }

Veja na listagem 7.3 a implementa¸caõ da fun¸caõ main(). O programa inicia com a fun¸caõ main(), na qual um objeto do tipo CAplicacao com nome ap é criado. O objeto ap executa o método Run() que envia para a tela a mensagem "Bem-vindo ao C++". Ap´ os a execu¸caõ do método Run(), o controle volta para a fun¸caõ main() e termina ao final desta fun¸caõ com um return 0;. • Para compilar o programa no GNU/Linux – g++ Programa.cpp CAplicacao.cpp • Para executar o programa no GNU/Linux – /a.out Listing 7.3: Exemplo b´ asico: Arquivo de implementa¸caõ da fun¸caõ main(). /* * Este p r o g r a m a e x e m p l i f i c a a e s t r u t u r a / layout de um p r o g r a m a t´ ı pico em C ++ */ // Inclui o a r q u i v o " C A p l i c a c a o . h " que tem a d e c l a r a ¸ c~ a o da classe C A p l i c a c a o # include " CAplicacao . h " // A fun¸ c~ a o main () , r e t o r n a um inteiro , se chama main () e // n~ a o tem nenhum p a r ^ ametro int main () { CAplicacao ap ; // Cria objeto do tipo C A p l i c a c a o com nome ap ap . Run () ;

// E x e c u t a o m´ e todo Run () do objeto ap

return 0;

// A fun¸ c~ a o main () deve r e t o r n a r um i n t e i r o // o zero indica que o p r o g r a m a t e r m i n o u bem .

} Bem vindo ao C ++!

7.9

Senten¸cas

• Observe que, de modo geral, arquivos de programa¸caõ em C têm a extensão .c, e arquivos de programa¸caõ em C++ têm a extensão .cpp (de C plus plus ou C mais mais). • C++ é extensivamente utilizado em aplica¸co˜es cient´ıficas, em programas com interface gr´ afica e em programas com muita intera¸caõ com o usuário. Programa¸caõ Orientada a Objeto com C++



193

• Programas de engenharia, f´ısicos e matemáticos s˜ ao bem representados em C++, pois as diferentes ´ areas da matemática s˜ ao facilmente modeladas como classes em C++. Isto é, faz-se uma associa¸caõ clara entre conceitos matemáticos e classes de C++. • Se você utilizou uma ferrramenta UML como o umbrello (veja se¸caõ 4.4.2), pode gerar automaticamente a estrutura inicial dos arquivos *.h e *.cpp. Assim, para cada classe criada, o umbrello gera os respectivos arquivos .h e .cpp.

7.10


Neste cap´ıtulo aprendemos um pouco sobre a história da linguagem C++, a qual tem origem na linguagem C, que, por sua vez, é derivada da linguagem B. Ser´ a que existiu uma linguagem A? Vimos que a linguagem C++ é derivada da linguagem C e que, em fun¸caõ das transforma¸co˜es ocorridas nos u ´ ltimos anos, podemos ter programas C++ em diferentes formatos: estruturado, baseado em objeto, orientado a objeto, ou, ainda, utilizando programa¸caõ genérica. Aprendemos que o ANSI C++ é o comitê respons´ avel pela padroniza¸caõ de C++ e que, ao fazermos um programa usando ANSI C++, esse deve compilar e rodar em centenas de plataformas. Vimos as diferen¸cas na nomenclatura de POO e C++. Aprendemos os conceitos b´ asicos de compila¸caõ, gera¸cão do c´ odigo objeto, e a linkagem – montagem do programa execut´ avel. Vimos que os debugers s˜ ao utilizados para localiza¸caõ dos bugs do programa e que os profilers s˜ ao utilizados para melhorar a performance do programa. Por fim, vimos o layout de um programa em C++. Dica: ao final de cada cap´ıtulo dedique cerca de 5-10 minutos para fazer uma r´ apida revisão dos conceitos apresentados.

7.11

Exerc´ıcios

1. Fa¸ca uma pesquisa na internet sobre a história de C++. 2. Quais as vantagens da padroniza¸caõ do Ansi C++? 3. V´ a até o site do Ansi C++ (procure por Ansi C++) e veja quais novidades est˜ ao previstas para os próximos anos. 4. Procure na biblioteca por livros de C/C++. Coloque-os em ordem de data de publica¸caõ e, em seguida, compare os c´ odigos. Veja que a forma como os programas s˜ ao desenvolvidos tem modificado constantemente (veja se¸caõ 7.5). 5. Quais s˜ ao as tarefas do compilador? 6. Quais s˜ ao as tarefas do pré-processador? 7. Quais s˜ ao as tarefas do linker? 8. O que s˜ ao e para que servem os debugers e os profilers? 9. Quantos arquivos têm um programa OO m´ınimo em C++. Qual é sua extensão e conte´ udo?



194

7.11. EXERCÍCIOS



Cap´ıtulo 8

Conceitos b´ asicos de C++ Veremos neste cap´ıtulo alguns conceitos b´ asicos de C++: a sintaxe (se¸caõ 8.1), as palavraschave do C++ (se¸caõ 8.2) e como você deve nomear (se¸caõ 8.3), declarar (se¸caõ 8.4) e definir os seus objetos (se¸caõ 8.5). Veremos ainda uma série de introdu¸co˜es, incluindo: introdu¸caõ à fun¸caõ main() (se¸caõ 8.6), alguns exemplos de programas em C++ (se¸caõ 8.7), introdu¸caõ à entrada e sa´ıda de dados com cin e cout (se¸caõ 8.7), introdu¸caõ às diretrizes de pré-processador (se¸caõ 8.8), introdu¸caõ ` as estruturas de controle (se¸caõ 8.9), introdu¸caõ aos operadores de C++ (se¸caõ 8.10), introdu¸caõ as fun¸co˜es (se¸caõ 8.11), e a rela¸caõ entre declara¸co˜es e escopo (se¸caõ 8.12). No final do cap´ıtulo veremos algumas senten¸cas (se¸caõ 8.13).

8.1

Sobre a sintaxe de C++

Veremos a seguir alguns conceitos b´ asicos da sintaxe de C++. Esses conceitos ser˜ ao mais bem compreendidos posteriormente, com as listagens de programas que ser˜ ao apresentadas. Arquivo – é um texto que contém c´ odigo-fonte em C++ e diretrizes para o pré-processador. Coment´ arios – s˜ ao utilizados para descrever/detalhar o funcionamento de determinadas partes do c´ odigo. Um coment´ ario em C utiliza os caracteres /* para iniciar o coment´ ario e */ para encerrar o coment´ ario. Um coment´ ario em C++ utiliza duas barras //; tudo o que estiver ap´ os as duas barras é coment´ ario. Note que o arquivo é composto por linhas de texto e que o coment´ ario de C++ é válido apenas para linha em que foi inclu´ıdo. Exemplo: /* Aqui ´ e coment´ ario */ Aqui ´ e programa ; // Aqui ´ e coment´ ario. S´ımbolos – existem cinco tipos de s´ımbolos em um programa C++: palavras-chave, identificadores, operadores, literais e separadores. Esses tipos de s´ımbolos s˜ ao brevemente descritos a seguir. Palavras-chaves – s˜ ao de uso interno do C++, têm significado para a linguagem, para o processo de compila¸caõ, e n˜ ao podem ser utilizados para nomear objetos. Veja se¸caõ 8.2. Identificadores – um identificador é uma seq¨ uência de letras usadas pelo programador para dar nome aos objetos, atributos e métodos. Um nome denota um objeto, uma 195

196

8.1. SOBRE A SINTAXE DE C++ fun¸caõ, um enumerador, um tipo, um membro de classe, um modelo, um valor ou um label (veja se¸caõ 8.3). Além disso, pode estar definido em uma biblioteca externa. No exemplo a seguir criamos três n´ umeros inteiros com os nomes x, y, z. Exemplo: int x,y,z; char nomeDaPessoa[50];

// x,y e z s~ ao identificadores // nomeDaPessoa ´ e um identificador

Operadores – o s´ımbolo + é o operador soma, sendo utilizado para somar dois objetos. J´ a o operador ++ é utilizado para incrementar o valor de uma vari´ avel, ou seja, operadores s˜ ao s´ımbolos cuja utilidade j´ a é definida pelo C++. Os operadores de C++ est˜ ao listados na Tabela C.1. Veremos os operadores em detalhes no Apêndice C – Operadores. No exemplo a seguir temos três exemplos de operadores: operador soma (+), que é bin´ ario (atua sobre dois objetos); operador incremento (++), que é un´ ario (atua sobre um u ´ nico objeto); e o operador de compara¸caõ maior que (>) . Neste exemplo, se x for maior do que y retornar´ a verdadeiro. Exemplo: + ´ e o operador de soma (´ e um operador bin´ ario). ++ ´ e o operador de incremento (´ e um operador un´ ario). x > y; o s´ ımbolo > ´ e o operador maior que. Literais – tipos de vari´ aveis previamente definidas pela linguagem C++ para representar objetos de uso corrente. Como exemplo podemos citar: um booleano, um caracter, um n´ umero inteiro, um n´ umero em ponto flutuante, uma string constante. Exemplo: int x = 5; char c = ’a’; float y = 5.3; char* nome = "Vinicios";

// // // //

O n´ umero 5 ´ e um literal A letra ’a’ ´ e um literal O n´ umero 5.3 ´ e um literal Vinicios ´ e um literal

Declara¸ c˜ ao – diz que existe um objeto com nome fulano de tal, mas n˜ ao cria o objeto. Uma declara¸caõ pode ser repetida (veja se¸caõ 8.4). A partir de sua declara¸caõ um objeto pode ser utilizado. Exemplo: extern int a; extern const int c; int f(); struct S; class C;

// // // // //

Declara Declara Declara Declara Declara

um inteiro a inteiro constante C que existe uma fun¸ c~ ao f() que existe uma estrutura S que existe uma classe C

Defini¸ c˜ ao – uma defini¸caõ cria um ou mais objetos e reserva memória. Uma defini¸caõ n˜ ao pode ser repetida (veja se¸caõ 8.5). Veremos o uso de extern na se¸caõ B.2.1. Exemplo: int b; extern const int c = 1; int f(){ return 5; };

// Cria/define um n´ umero inteiro b // Atribue valor para c // Define a fun¸ c~ ao f()

Atribui¸ c˜ ao – quando se armazena algum valor no objeto. Programa¸caõ Orientada a Objeto com C++


8.1. SOBRE A SINTAXE DE C++ Exemplo: int x = 5;

197

// Atribui o valor 5 para x

Classes de armazenamento – definem o tempo de vida de um objeto, podendo ser est´ atico (existe durante toda execu¸caõ do programa) ou dinâmico (existe por um determinado per´ıodo de tempo). Veja nas se¸co˜es B.1 e B.3 informa¸co˜es sobre classes de armazenamento e modificadores de acesso. Escopo – define onde um objeto é vis´ıvel. O escopo pode ser local {bloco}, de fun¸caõ, de arquivo, de classe ou global (veja se¸co˜es 8.12 e B.4). Blocos – um bloco se inicia com ”{” e termina com ”}”. Objetos criados dentro do bloco est˜ ao no escopo do bloco e n˜ ao podem ser acessados externamente. Objetos criados dentro do bloco s˜ ao objetos autom´ aticos, e estes s˜ ao automaticamente destru´ıdos quando o bloco é encerrado. Exemplo: { ... }

// Inicio do bloco // Fim do bloco

Tipos predefinidos – tipos de objetos previamente definidos pela linguagem C++ (veja Cap´ıtulo 9 – Tipos). Exemplo: int x; long int r; unsigned int s; float y; double z;

// // // // //

N´ umero N´ umero N´ umero N´ umero N´ umero

inteiro, com nome x inteiro longo com sinal, com nome r inteiro sem sinal, com nome s flutuante, com nome y com dupla precis~ ao, com nome z

Tipos derivados – tipos definidos pelo programador, como estruturas, enumera¸co˜es e uniões (veja Cap´ıtulo 9 – Tipos). No exemplo a seguir definimos a classe CPessoa, com os atributos nome e idade. Exemplo: class CPessoa { public: string nome; int idade; };

// CPessoa ´ e um tipo do usu´ ario

Especificador – é uma palavra-chave da linguagem que é utilizada para definir o tipo do objeto ou modificar determinado tipo. Por exemplo: um especificador inline é utilizado para modificar a forma com que a fun¸caõ/método ser´ a compilada. Um especificador de tipo informa o tipo do objeto. Um especificador typedef é usado para criar um apelido para um tipo conhecido (veja Cap´ıtulo 9 – Tipos). Exemplo: int x; inline void f() { cout < < "saida" < < typedef float racional;

// int ´ e o especificador // inline ´ e o especificador endl; } // typedef e float s~ ao o especificador



198

8.2. PALAVRAS-CHAVE DO C++

Lvalues – um objeto é uma regi˜ ao de armazenamento de memória. Um lvalue é uma express˜ ao que se refere a um objeto ou fun¸caõ (o retorno é algo ativo). Pode aparecer à esquerda do sinal igual (=), podendo ser alterado. Objetos especificados como const n˜ ao s˜ ao lvalues. Exemplo: int x = 3; const int y = 3;

// x ´ e um lvalue. // y N~ AO ´ e um lvalue.

Diretrizes de pr´ e-processador – s˜ ao informa¸co˜es/instru¸co˜es que s˜ ao passadas para o compilador com o s´ımbolo #. Veremos o uso das diretrizes de pré-processador no Apêndice A – Diretrizes de pré-processador.

8.2

Palavras-chave do C++

Uma linguagem de programa¸caõ faz uso extensivo de determinadas palavras, denominadas palavras-chave. Essas palavras foram definidas para a linguagem C++ e s˜ ao utilizadas pelo programador com algum objetivo espec´ıfico. Como essas palavras já têm um significado predefinido para a linguagem, você n˜ ao pode declarar um objeto com o mesmo nome de uma palavra-chave, pois o compilador faria uma confusão e acusaria erro. Com o objetivo de economizar palavras, algumas palavras-chave têm mais de uma utilidade, por exemplo, a palavra-chave virtual, que pode especificar um método virtual ou uma heran¸ca virtual. Outro exemplo é void, que, para ponteiros, é um ponteiro para qualquer coisa e, para métodos, significa ausência de parˆ ametros ou ausência de retorno. Veja as palavraschave do ANSI C++ na Tabela 8.1. As palavras-chave est˜ ao classificadas de acordo com seu uso. Tabela 8.1: Palavras chaves do ANSI C++. Tipos Modificadores de tipos Controle L´ ogicos Mem´ oria Controle de acesso Convers˜ oes Exce¸co˜es Diversos

bool, char, wchar_t, short, int, long, float, double, long double, void auto, const, extern, mutable, register, signed, static, typedef, unsigned, volatile break, case, continue, default, do, else, for, goto, if, return, switch, while and, and_eq, bitand, bitor, compl, false, not, not_eq, or, or_eq, true, xor, xor_eq delete, new private, protected, public const_cast, dynamic_cast, reinterpret_cast, static_cast try, throw, catch asm, class, enum, explicit, export, friend, inline, namespace, operator, sizeof, struct, template, this, typeid, typename, union, using, virtual

Dica: a linguagem C/C++ reservou alguns identificadores para uso futuro – você deve evitar o seu uso. S˜ ao eles: is (exemplo: isblank), mem, str (exemplo: strtof), to, wcs. Programa¸caõ Orientada a Objeto com C++


8.3. NOME DOS OBJETOS – IDENTIFICADORES

8.3

199

Nome dos objetos – identificadores

O nome de um objeto deve come¸car com uma letra (a-z, A-Z) ou sublinhado ( ). A linguagem C++ difere mai´ usculas e min´ usculas, ou seja, AA é diferente de aa. A especifica¸caõ-padrão de C++ também permite o uso de caracteres especiais como π. Embora ’ ’ possa ser utilizado no in´ıcio de um nome, ele deve ser evitado. O uso de dois underscores, como em nome objeto, é reservado, devendo ser evitado. Caracteres v´ alidos – a-z A-Z 0-9 + - * / = , . : ; ? \ ” ’ | ! # $ & ( ) [ ] { } Caracteres inv´ alidos – ++ – = *= /= ?: :: /**

8.3.1

==

&&

//

<<

>>

>=

<=

+=

-

Conven¸c˜ ao para nomes de objetos

Para facilitar a leitura do programa, é usual a ado¸caõ de uma conven¸caõ para nomear os objetos. Veja na Tabela 8.2 um exemplo. Veremos a seguir como declarar e definir objetos em C++. Tabela 8.2: Conven¸caõ para nomes de objetos. Tipo de Objeto Vari´ aveis #define Nome de classes Nome de estruturas Nome de uni˜ oes Nome de enumera¸co˜es Nome de métodos/fun¸co˜es Atributos Atributos est´ aticos

8.4

Formato do Nome #define MAIUSCULA; CNomeClasse; SNomeEstrutura UNome ENome InicialMai´ uscula(); inicialMin´ uscula min´ usculas

Exemplos #define SIZE 100 class CNormal{...}; struct SData{}; union UPressao{}; enum ESemana{}; int MediaPonderada(); int mediaPonderada; static int contador;

Declara¸c˜ oes

Uma declara¸caõ introduz um ou mais nomes em um programa e especifica como esses nomes devem ser interpretados. Uma declara¸caõ n˜ ao reserva memória para o objeto, apenas diz que ele existe. Além disso, declara¸caõ pode ser uma fun¸caõ, um tipo, um objeto (constante ou vari´ avel), um namespace, um template ou uma entidade relacionada, [Lischner, 2003]. Veja no prot´ otipo a seguir que uma declara¸caõ tem três componentes: os qualificadores, os especificadores e os declaradores. Prot´ otipo Qualificadores Especificadores Declarador; Qualificador – especifica o tipo de linkagem, est´ atica ( static ), externa ( extern ), ou export (veja se¸ca õ B.2), ou modifica o tipo de acesso com const , volatile e mutable (veja se¸ca õ B.3). A ordem dos qualificadores n˜ ao importa, isto significa que extern const volatile int x; é o mesmo que const extern volatile int x;. Programa¸caõ Orientada a Objeto com C++


˜ 8.5. DEFINIC ¸ OES

200

Especificador – indica o tipo fundamental, a classe de armazenamento ou outras propriedades dos objetos declarados. Declarador – especifica o nome dos objetos e opcionalmente modifica o tipo com um * . Um declarador pode especificar um valor inicial para o identificador que est´ a sendo declarado ( = ). Exemplo: static int x1; int x2; class CPonto; typedef int I; int * ptr; int& ref = &x1;

// // // // // //

Declara Declara Declara Declara Declara Declara

um objeto int est´ atico, com nome x1 um objeto do tipo int com nome x2 um nome de classe um sin^ onimo para int (um apelido) um objeto ponteiro para int uma refer^ encia para x1.

Ao longo do livro veremos como declarar e usar tipos mais elaborados, como vetores, arrays, tipos do usuário e tipos definidos em bibliotecas externas.

8.4.1

Exemplos de declara¸c˜ oes e defini¸ c˜ oes2

Veja na Tabela 8.3 exemplos de declara¸co˜es e defini¸co˜es de objetos. Inclu´ımos declara¸co˜es de matrizes, fun¸co˜es e ponteiros. Tabela 8.3: Exemplos de declara¸co˜es e defini¸co˜es. Sintaxe da declara¸caõ Tipo nome[]; Tipo nome[3]; Tipo* nome; Tipo* nome[]; Tipo* (nome[]); Tipo (*nome)[]; Tipo& nome; Tipo nome[nx][ny]; Tipo nome[nx][ny][nz]; Tipo nome(); Tipo*nome(); Tipo*( nome()); Tipo (*nome)();

8.5

Tipo efetivo Vetor do Tipo Vetor do tipo com três elementos Ponteiro para tipo Vetor de ponteiros para tipo Vetor de ponteiros para tipo Ponteiro para vetor do tipo Referência para o tipo Matriz 2D com nx por ny elementos Matriz 3D com nx por ny por nz elementos Fun¸caõ que retorna o tipo Fun¸caõ que retorna ponteiro tipo* Fun¸caõ que retorna ponteiro Tipo* Ponteiro para fun¸caõ que retorna o Tipo

Exemplo int cont[]; int cont[3]; //0,1,2 int* ptr; int* cont[]; int* (cont[]); int (*cont)[]; int& cont; int m[5][6]; int m[5][6][4]; int cont(); int* cont(); int*(cont()); int (*cont)()

Defini¸c˜ oes

Uma defini¸caõ define o tipo de armazenamento, o valor, o corpo e o conte´ udo de uma declara¸caõ. Enquanto uma declara¸caõ informa que algo existe (interface), uma defini¸caõ a implementa e especifica como aquela funciona. A defini¸caõ de uma fun¸caõ, por exemplo, inclui o corpo da fun¸caõ [Lischner, 2003]. Além disso, uma defini¸caõ faz com que seja reservada a quantidade adequada de mem´ oria para o objeto e seja feita qualquer inicializa¸caõ apropriada. Uma declara¸caõ de uma defini¸caõ, por sua vez, a menos que contenha um extern e n˜ ao tenha um inicializador. Programa¸caõ Orientada a Objeto com C++


˜ A ` FUNC ˜ MAIN() 8.6. INTRODUC ¸ AO ¸ AO

201

Exemplo: extern int x; // Declara¸ c~ ao: informa que existe um int x int y; // Defini¸ c~ ao: reserva espa¸ co de mem´ oria para y Defini¸ c˜ ao simples – consiste em declarar um objeto de cada vez. Exemplo: int x;

// Define objeto do tipo int, com nome x

Defini¸ c˜ ao m´ ultipla – consiste em declarar vários objetos de uma u ´ nica vez. A defini¸caõ m´ ultipla deve ser evitada, pois o ideal é declarar um objeto por linha e incluir um coment´ ario sobre o objeto. Exemplo: float r,s,t;

// Define objetos do tipo float, com nome r,s,t

Defini¸ c˜ ao com inicializa¸ c˜ ao – consiste em declarar um objeto e, ao mesmo tempo, atribuir um valor a esse objeto. Exemplo: int x = 7; float y = 5.2; int r(30); int s[4];

8.6

// // // //

O mesmo que int x(7); Inicializa y com o valor 5.2 Inicializa r com o valor 30 Cria array com 4 elementos, valores = 0

Introdu¸ c˜ ao ` a fun¸c˜ ao main()

Quando você roda um programa, o sistema operacional carrega-o na memória e em seguida inicia na fun¸caõ principal, que inicia a execu¸caõ do programa. Em programas em C e C++, a fun¸caõ inicial de um programa é chamada main(). Veremos a seguir dois prot´ otipos para fun¸caõ main(), e nas listagens 8.1 e 8.3, veremos exemplos de uso. Prot´ otipo int main() {..... return 0;} A fun¸ca õ retorna um n´ umero inteiro e n˜ ao recebe nenhum parˆ ametro. int main(int argc, const char *argv[]) {...... return 0;} A fun¸ca õ retorna um n´ umero inteiro e recebe dois parˆ ametros. O parˆ ametro argc é o n´ umero de elementos digitados na linha de comando e argv[] o vetor para as strings digitadas na linha de comando. Nota: veremos detalhes e exemplos de uso da fun¸caõ main() na se¸caõ E.1.

8.7

Introdu¸ c˜ ao ` a entrada e sa´ıda de dados com cin e cout

Apresenta-se nesta se¸caõ uma breve introdu¸caõ à entrada e sa´ıda de dados em C++ usando os objetos cin e cout. Isto é suficiente para os nossos primeiros exemplos. Programa¸caõ Orientada a Objeto com C++


˜ A ` ENTRADA E SAÍDA DE DADOS COM CIN E COUT 8.7. INTRODUC ¸ AO

202

8.7.1

Usando cout

Veja na listagem 8.1 nosso primeiro exemplo de programa em C++, o qual mostra como enviar textos para tela. O programa inicia-se incluindo um coment´ ario na linha // Arquivo listagens/Cap-08/novaLinha-tab-beep.cpp Em seguida, inclui um arquivo da biblioteca-padr˜ ao de C++, a , na linha #include A é uma biblioteca utilizada para entrada e sa´ıda de dados. Ela fornece o objeto std::cout, utilizado para enviar uma mensagem para a tela (cout = C out ). Esse exemplo inclui ainda a fun¸caõ inicial de um programa em C++. int main() { Dentro da fun¸caõ main(), o objeto std::cout envia para a tela a mensagem ”Bem

Vindo!”

std::cout < < "Bem" < < ’\t’ < < "Vindo!\n"; O caractere ’\t’ é utilizado para colocar uma tabula¸caõ entre a palavra "Bem" e a palavra "Vindo". Em seguida, o programa envia para a tela a mensagem "Bem Vindo ao C++!", std::cout < < "B\ne\nm\n\nVindo ao C++!\a" < < std::endl; incluindo, entre cada caractere da palavra "Bem", uma nova linha ’\n’. O caractere ’\n’ é utilizado para colocar uma quebra de linha. O caractere ’\a’ é usado para emitir um beep. O trecho std::endl é usado para incluir uma linha nova e enviar o texto imediatamente para tela. O manipulador std::endl; é fornecido pelo arquivo . Au ´ ltima linha da fun¸caõ main() é a return 0; } utilizada para finalizar a fun¸caõ main() e o programa, retornando para o sistema operacional o valor 0. O retorno do valor 0 indica para o sistema operacional que o programa terminou com sucesso sua execu¸caõ. Observe ap´ os a listagem como ficou a sa´ıda. Listing 8.1: Usando sa´ıda para tela, nova linha, tabula¸caõ e beep. // A r q u i v o l i s t a g e n s/ Cap -08/ novaLinha - tab - beep . cpp # include < iostream > int main () { std :: cout << " Bem " << ’\ t ’ << " Vindo !\ n " ; std :: cout << " B \ ne \ nm \ n \ nVindo ao C ++!\ a " << std :: endl ; return 0; }




203

bash -3.00 $ ./ a . out Bem Vindo ! B e m Vindo ao C ++!

Os caracteres ’\n’(nova linha), ’\a’ (beep) e ’\t’ (tabula¸ c~ ao) s˜ ao conhecidos como caracteres de escape. Um caracter de escape é composto de uma barra invertida e uma letra que indica a a¸caõ a ser executada. Veja na Tabela 22.3 os caracteres de escape de C/C++. Nota: veremos no Apêndice K – Arquivos de cabe¸calho, uma lista com o nome dos diversos arquivos de cabe¸calho da biblioteca-padr˜ ao de C e C++.

8.7.2

Usando cin

Veja na listagem 8.2 um exemplo com declara¸caõ de objetos, entrada e sa´ıda de dados. A Figura 8.2 ilustra a execu¸caõ do programa. Figura 8.1: Diagrama mostrando entrada e sa´ıda de dados em C++.

soma

=

temporária

5

Entre com o valor de a: 2 Entre com o valor de b: 3 Soma = 5

5

<> std::cout

+

a

b

2

3

cin >> a; <> std::cin

cin >> b;

2 enter 3 enter

Novamente, o programa inicia-se com um coment´ ario e, em seguida, inclui a bibliotecapadr˜ ao de C++ para entrada e sa´ıda de dados, a , a qual, como dito anteriormente, fornece o objeto std::cout, que é utilizado para escrever na tela usando o operador de inser¸caõ < <. Na linha 7 int a; criamos um n´ umero inteiro com nome a, e, em seguida, enviamos para a tela uma mensagem solicitando o valor de a. std::cout < < "Entre com o valor de a: "; Programa¸caõ Orientada a Objeto com C++



204 Na linha 13

std::cin > > a; o valor digitado pelo usu´ ario é armazenado no objeto a. O arquivo de cabe¸calho fornece o objeto std::cin, utilizado para entrada de dados. O operador de extra¸caõ > > extrai um objeto do teclado e move-o para o objeto ` a direita do sinal > >, no caso o n´ umero a. Na linha 16 std::cin.get(); o objeto std::cin é usado para pegar do teclado o enter digitado pelo usuário e, em seguida, desconsider´ a-lo. O mesmo procedimento é repetido para a var´ıavel b. Posteriormente, criamos na linha int soma; a vari´ avel soma, que ser´ a utilizada para armazenar o resultado da soma de a e b. . Na linha 29 soma = a + b; os valores de a e b s˜ ao somados e o resultado é armazenado em soma. A linha 32 std::cout < < "Soma = " < < soma; é usada para enviar para a tela o resultado da soma. std::cout < < std::endl; é usada para enviar para a tela um caracter de nova linha, evitando-se que a u ´ ltima mensagem enviada pelo programa fique sem quebra de linha. Outros coment´ arios est˜ ao embutidos no texto. A sa´ıda é ilustrada na Figura 8.2. Listing 8.2: Declara¸caõ de objetos e uso de cin e cout. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// A r q u i v o: ../ l i s t a g e n s / Cap -08/ cout - cin . cpp # include < iostream > int main () { // Um int ´ e um tipo pr´ e - definido , serve para a r m a z e n a r n ´ umeros inteiros // Na linha a seguir o tipo do objeto ´ e int e seu nome a int a ; // E s c r e v e na tela " Entre com o valor de a :" std :: cout << " Entre com o valor de a : " ; // A r m a z e n a o valor d i g i t a d o no objeto a std :: cin >> a ; // Pega o enter e d e s c o n s i d e r a std :: cin . get () ; int b ; std :: cout << " Entre com o valor de b : " ; std :: cin >> b ;



˜ AS ` DIRETRIZES DE PRE-PROCESSADOR ´ 8.8. INTRODUC ¸ AO 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

205

std :: cin . get () ; // O b s e r v e que os o b j e t o s s~ a o d e c l a r a d o s perto de onde eles // c o m e ¸ c a m a ser usados . int soma ; // V e r i f i c a o tipo de a , o tipo de b , se c o m p a t ´ ıveis realiza a opera¸ c~ ao+ // o r e s u l t a d o ´ e a r m a z e n a d o na v a r i ´ a v e l soma ( o p e r a d o r =) soma = a + b ; // E s c r e v e na tela o r e s u l t a d o de soma std :: cout << " Soma = " << soma ; // O c o m a n d o std :: endl envia para a tela um final de linha ( linha nova ) std :: cout << std :: endl ; return 0; }

Os programas foram compilados e executados em um PC utilizando GNU/Linux e em um PC usando Windows, ambos com software livre. O compilador utilizado é o g++, da GNU. Por default, o compilador da GNU gera um execut´ avel com nome a.out. Para compilar o programa, abra um terminal, vá para o diret´ orio onde o programa est´ a localizado e digite g++ cout-cin.cpp. Para executar o programa, digite ./a.out (no GNU/Linux) e cout-cin.exe (no Windows). Veja a Figura 8.2. Para compilar e executar o programa no ambiente Windows consulte os manuais de seu ambiente de desenvolvimento. Figura 8.2: Compilando e executando programas no shell.

8.8

Introdu¸ c˜ ao ` as diretrizes de pr´ e-processador

Vimos, na se¸caõ 7.7, conceitos b´ asicos de pré-processamento, compila¸caõ, linkagem, debugagem e otimiza¸caõ. Nesta se¸caõ veremos uma breve introdu¸caõ às diretrizes de pré-processador de C++ e um pequeno exemplo (listagem 8.3).

8.8.1

Usando #ifdef..#endif

Agora que j´ a vimos como escrever na tela usando cout e como ler o conte´ udo de uma vari´ avel usando cin, podemos apresentar um programa que utiliza diretrizes de pré-processamento. Como visto na se¸caõ 7.7, a primeira fase da compila¸caõ é denominada pré-processador. Nela o compilador verifica as instru¸co˜es de compila¸caõ passadas com o sinal #. No exemplo da listagem 8.3 inclu´ımos três diretrizes de pré-processador: a primeira inclui o arquivo , na linha #include ; a segunda diretriz de pré-processador Programa¸caõ Orientada a Objeto com C++


˜ AS ` ESTRUTURAS DE CONTROLE 8.9. INTRODUC ¸ AO

206

define um bloco #ifdef..#endif, ou seja, se a vari´ avel DEBUG já foi definida, o programa inclui a parte de c´ odigo que envia a mensagem "Vers~ ao com vari´ avel debug ativada" para a tela; do contrário, a linha com a mensagem é desconsiderada (n˜ ao é compilada). A terceira diretriz é o #endif que finaliza o bloco. O exemplo da listagem 8.3 deve ser compilado usando g++ UsandoDiretrizesDePreProcessador-ifdef.cpp e, em seguida, testado ./a.out. Por fim, compile usando g++ DDEBUG UsandoDiretrizesDePre-Processador-ifdef.cpp e teste novamente. Veja as diferen¸cas na sa´ıda. Listing 8.3: Usando diretrizes de pré-processador: #ifdef. # include < iostream > int main () { # ifdef DEBUG std :: cout << " Vers~ a o com vari´ a vel debug ativada " << std :: endl ; # endif return 0; } [ b u e n o @ s u p o r t e 3 ] $ g ++ UsandoDire t r iz e sD e P re - Processador - ifdef . cpp [ b u e n o @ s u p o r t e 3 ] $ ./ a . out [ b u e n o @ s u p o r t e 3 ] $ g ++ - DDEBUG UsandoDire tr i z es D eP r e - Processador - ifdef . cpp [ b u e n o @ s u p o r t e 3 ] $ ./ a . out Vers~ a o com vari´ a vel debug ativada

Nota: veremos maiores detalhes sobre diretrizes de pré-processador no Apêndice A – Diretrizes de pré-Processador.

8.9

Introdu¸ c˜ ao ` as estruturas de controle

Nesta se¸caõ veremos o uso das estruturas de controle for e while.

8.9.1

Usando for

O for é uma estrutura de controle de repeti¸caõ utilizado para a realiza¸caõ de la¸cos (loopings). O prot´ otipo a seguir ilustra a forma de uso do for. O primeiro item é a inicializa¸caõ da vari´ avel de controle do la¸co; o segundo, é a condi¸caõ utilizada para continuar no la¸co – se esta for falsa o la¸co é encerrado; o terceiro item, a¸ c~ ao1, é utilizado, geralmente, para modificar a vari´ avel de controle. A a¸caõ2 é executada repetidas vezes, até que a condi¸caõ seja falsa. Prot´ otipo: for(inicializa¸ca õ; condi¸ca õ; a¸ca õ1) a¸caõ2; As listagens 8.4 e 8.5 mostram o uso de for. Na listagem 8.4 usamos um bloco for para enviar para tela o valor da vari´ avel i, criada dentro do for. Dentro do for a vari´ avel i é inicializada com o valor 1 (int i = 1;). Em seguida, cada la¸co do for envia para a tela o valor i (std::cout < < i < < " ";). Observe na sa´ıda os valores de i: 1 2 3 4 5 6 7 8 9 10. Ap´ os cada la¸co, o valor de i é incrementado, i++, e comparado com o valor 10, i <= 10;. Quando i for igual a 11 a condi¸caõ se torna falsa, e o for é encerrado. Programa¸caõ Orientada a Objeto com C++


˜ AS ` ESTRUTURAS DE CONTROLE 8.9. INTRODUC ¸ AO

207

Listing 8.4: Usando for. # include < iostream > int main () { for ( int i = 1; i <= 10; i ++) std :: cout << i << " " ; std :: cout << std :: endl ; return 0; } 1 2 3 4 5 6 7 8 9 10

Na listagem 8.5, usamos um for encadeado, um for dentro de outro para enviar para tela y linhas e x vezes o caracter ’.’. Listing 8.5: Usando for encadeado. # include < iostream > int main () { int x , y ; std :: cout << " Entre com dois n´ u meros inteiros positivos ( x espa¸ c o y enter ) : " ; std :: cin >> x >> y ; std :: cin . get () ; for ( int i = 1; i <= y ; i ++) { for ( int j = 1; j <= x ; j = j + 1) std :: cout << ’. ’; std :: cout << std :: endl ; } return 0; } [ b u e n o @ l d s c 0 5 ] $ ./ a . out Entre com dois n´ u meros inteiros positivos ( x espa¸ c o y enter ) : 4 2 .... .... [ b u e n o @ l d s c 0 5 ] $ ./ a . out Entre com dois n´ u meros inteiros positivos ( x espa¸ c o y enter ) : 6 3 ...... ...... ......

8.9.2

Usando while e fun¸c˜ oes da biblioteca de C/C++

O prot´ otipo a seguir mostra uma estrutura de controle do tipo while. O funcionamento de um bloco while é simples, enquanto a condi¸caõ for verdadeira a a¸caõ vai ser executada. Desta forma, em algum momento o bloco que contém a a¸caõ a ser executada deve tornar a condi¸caõ falsa. Note que se a condi¸caõ nunca for falsa, o bloco com a a¸caõ nunca vai ser encerrado, ocorrendo um la¸co infinito (sem sa´ıda). Prot´ otipo: while (condi¸ca õ) {a¸ca õ;}; Veja agora o exemplo da listagem 8.6. Neste exemplo o objetivo é calcular o valor da potência dada por potencia = baseexpoente , o usu´ ario deve entrar com a base e o expoente. A seguir, dentro do bloco while, a potência é calculada. Observe que o valor de i inicia em 1 e é Programa¸caõ Orientada a Objeto com C++


˜ AOS OPERADORES DE C++ 8.10. INTRODUC ¸ AO

208

incrementado dentro do while, quando i > y o la¸co é encerrado. O comando cin.get(); é utilizado para retirar do teclado o enter. Observe que o mesmo resultado pode ser obtido usando-se diretamente a fun¸caõ pow(x,y); da biblioteca padr˜ ao de C. Para usar arquivos da biblioteca matemática padr˜ ao de C inclu´ımos o arquivo . Listing 8.6: Usando while: Calculando a potência. # include < iostream > // B i b l i o t e c a de e n t r a d a e sa´ ı da # include < cmath > // B i b l i o t e c a m a t e m ´ a t i c a de C / C ++ int main () { int x , y ; std :: cout << " Entre com a base ( inteiro ) : " ; std :: cin >> x ; std :: cout << " Entre com o expoente ( inteiro ) : " ; std :: cin >> y ; std :: cin . get () ; int i = 1; double potencia = 1; while ( i <= y ) { potencia = potencia * x ; // O mesmo que p o t e n c i a *= x ; ++ i ; // O mesmo que i = i + 1; } std :: cout << " pot^ e ncia = " << potencia << std :: endl ; // C a l c u l a p o t ^ e n c i a usando fun¸ c~ a o pow (x , y ) std :: cout << " pow (x , y ) = " << pow (x , y ) << std :: endl ; return 0; } [ a n d r e @ m e r c u r i o Cap2 - Sintaxe ] $ ./ a . out Entre com a base ( inteiro ) : 3 Entre com o expoente ( inteiro ) : 4 81

Você encontra uma descri¸caõ detalhada das diversas estruturas de controle de C++ no Apêndice D – Estruturas de controle.

8.10

Introdu¸ c˜ ao aos operadores de C++

Veremos nesta se¸caõ uma breve introdu¸caõ aos operadores de C++ e um exemplo.

8.10.1

Usando operadores de C++

Neste ponto podemos apresentar um programa que utiliza operadores de C++. Se você ainda n˜ ao conhece os operadores de C/C++, ap´ os a leitura desta se¸caõ, aconselha-se a leitura do Apêndice C – Operadores. Veja a seguir o prot´ otipo de uso dos operadores relacionais (>, >=, <, <=, ==, !=), os quais s˜ ao utilizados para comparar objetos. Prot´ otipo Operador

Descri¸ca õ



˜ AOS OPERADORES DE C++ 8.10. INTRODUC ¸ AO >

maior

>=

maior ou igual

<

menor

<=

menor ou igual

==

igual

!=

diferente

209

Um exemplo de uso dos operadores de compara¸caõ é apresentado na listagem C.1. A fun¸caõ main() cria dois inteiros, a e b. Em seguida, ela pede ao usuário que entre com os valores de a e b. O programa chama ent˜ ao a fun¸caõ void compara(int a, int b);, utilizada para comparar os valores a e b, e mostrar na tela o resultado da compara¸caõ. Veja na sa´ıda que o usuário entrou com os valores 3 e 4. A fun¸caõ Compara() n˜ ao retorna nada (void), recebe como parˆ ametros dois inteiros (int x, int y) e é usada para comparar os valores de a e b. Note que os objetos a e b, criados dentro de main(), s˜ ao passados por c´ opia para a fun¸caõ Compara(). Veremos as diferentes formas de passagem de parˆ ametros na se¸caõ 13.6. Listing 8.7: Usando os operadores de compara¸caõ, incremento, decremento, e os operadores compostos. # include < iostream > // D e c l a r a fun¸ c~ ao Compara void Compara ( int x , int y ) ; int main () { int a , b ; std :: cout << " Entre com dois numeros inteiros ( a espa¸ c o b enter ) : " ; // O b s e r v e abaixo a l e i t u r a de duas v a r i ´ a v e i s em uma ´ u nica linha . // Isto pode ser feito , mas deve ser e v i t a d o. std :: cin >> a >> b ; std :: cin . get () ; // Pega o enter Compara (a , b ) ; // E x e c u t a fun¸ c~ a o C o m p a r a () a += 5; // O p e r a d o r c o m p o s t o . Compara (a , b ) ; // E x e c u t a fun¸ c~ a o C o m p a r a () b - -; // O p e r a d o r de d e c r e m e n t o . Compara (a , b ) ; // E x e c u t a fun¸ c~ a o C o m p a r a () a *= ++ b ; // O p e r a d o r de i n c r e m e n t o . Compara (a , b ) ; // E x e c u t a fun¸ c~ a o C o m p a r a () return 0; // E n c e r r a o p r o g r a m a } // Define a fun¸ c~ a o C o m p a r a ( c´ o digo da fun¸ c~ ao ) void Compara ( int x , int y ) { if ( x == y ) // O p e r a d o r e s de c o m p a r a ¸ c~ ao std :: cout << x << " == " << y << " \ t " ; if ( x != y ) std :: cout << x << " != " << y << " \ t " ; if ( x < y ) std :: cout << x << " < " << y << " \ t " ; if ( x > y ) std :: cout << x << " > " << y << " \ t " ; if ( x <= y ) std :: cout << x << " <= " << y << " \ t " ; if ( x >= y )



˜ AS FUNC ˜ 8.11. INTRODUC ¸ AO ¸ OES

210 std :: cout << x << " >= " << y << " \ t " ; }

Entre com dois numeros inteiros ( a espa¸ c o b enter ) : 3 4 3 != 4 3 < 4 3 <= 4 8 != 4 8 > 4 8 >= 4 8 != 3 8 > 3 8 >= 3 32 != 4 32 > 4 32 >= 4

Neste exemplo adicionamos, além do uso de operadores, o uso de fun¸co˜es separadas de main(), o que é t´ıpico em programas estruturados. Nota: como os conceitos de operadores (+, -, *, ...) e de estruturas de controle já s˜ ao bastante conhecidos, eles foram inclu´ıdos no Apêndice C – Operadores e no Apêndice D – Estruturas de controle. Continue lendo o livro normalmente. Se tiver problemas para entender como funciona determinado operador ou estrutura de controle, consulte o item espec´ıfico no apêndice. Nota: veremos o uso de métodos no Cap´ıtulo 13 – Métodos e no Cap´ıtulo 14 – Sobrecarga de métodos.

8.11

Introdu¸ c˜ ao as fun¸c˜ oes

Vimos os conceitos de fun¸co˜es e métodos na se¸caõ 3.5. Lembre-se que fun¸co˜es no estilo de C, s˜ ao normalmente fun¸co˜es globais, utilizadas em programa¸caõ estruturada. A idéia de usar fun¸co˜es é possibilitar que partes do c´ odigo que s˜ ao constantemente repetidas sejam separadas do fluxo principal. J´ a vimos na se¸caõ 8.6 a fun¸caõ main(). Veremos aqui o prot´ otipo e exemplos de declara¸caõ, defini¸caõ e uso de fun¸co˜es no estilo de C. Veja no prot´ otipo a seguir que uma fun¸caõ tem um retorno, um nome e uma lista de parˆ ametros. Prot´ otipo: retorno NomeDaFun¸ca õ(parˆ ametros); Normalmente as fun¸co˜es s˜ ao declaradas antes da fun¸caõ main(), e definidas depois de main(). Isto possibilita que as fun¸co˜es possam ser chamadas de dentro de main(). Veja a seguir algumas listagens com exemplos de fun¸co˜es. Veja na listagem 8.8 uma fun¸caõ simples, usada para calcular o cubo de um n´ umero. Observe que que a fun¸caõ cubo() é chamada diversas vezes dentro do for. Listing 8.8: Fun¸caõ cubo. # include < iostream > int cubo ( int y ) ;

// D e c l a r a ¸ c~ a o da fun¸ c~ ao

int main () {




211

int min , max ; std :: cout << " Entre com o intervalo ( valor m´ ı nimo e m´ a ximo ) ( ex : 3 e 10) : " ; std :: cin >> min >> max ; std :: cin . get () ; for ( int x = min ; x <= max ; x ++) std :: cout << " cubo de ( " << x << " ) = " << cubo ( x ) << std :: endl ; return 0; } // D e f i n i ¸ c~ a o da fun¸ c~ ao : // r e t o r n o _ d a _ f u n ¸ c~ ao Nome_da_fun¸ c~ ao ( par^ ametros) { corpo_da_fun¸ c~ ao} int cubo ( int y ) { return y * y * y ; } Entre com o intervalo ( valor minimo e m´ a ximo ) ( ex : 3 e 10) :5 7 cubo de (5) =125 cubo de (6) =216 cubo de (7) =343

Veja na listagem 8.9 uma fun¸caõ simples, sem retorno e sem parˆ ametros. Observe que usamos recursão para fun¸caõ main(). Uma recursão existe quando uma fun¸caõ chama a s´ı mesma. Veremos o uso de recursões na se¸caõ E.3. Listing 8.9: Fun¸caõ com void. # include < iostream > void f () ; void g ( void ) ;

// C ++ // C p r e c i s a do s e g u n d o void

int main () { std :: cout << " \ a \ n " ; std :: cout << " Executar f () ou g () ? " ; char resp = ’f ’ ; std :: cin >> resp ; std :: cin . get () ; // Pega o enter if ( resp == ’f ’ || resp == ’F ’) f () ; else if ( resp == ’ g ’ || resp == ’G ’) g () ; else { std :: cout << " Sele¸ ca ~ o errada , selecionou ( " << resp << " ) " << std :: endl ; main () ; // R e c u r s ~ ao } return 0; } void f () { std :: cout << " Fun¸ ca ~ o void n~ a o retorna nada ( selecionou f ) " << std :: endl ; } void g ( void ) { std :: cout << " Fun¸ ca ~ o void n~ a o retorna nada ( selecionou g ) " << std :: endl ; } Executar f () ou g () ? g Fun¸ ca ~ o void n~ a o retorna nada ( selecionou g )




212

[ andre@mercurio Executar f () ou Sele¸ ca ~ o errada , Executar f () ou Fun¸ ca ~ o void n~ ao

Parte - VI ] $ ./ a . out g () ?6 seleciono u (6) g () ? f retorna nada ( selecionou f )

Apresenta-se na listagem 8.10 uma fun¸caõ em linha, utilizada para calcular o volume de uma esfera. Veremos em detalhes os conceitos de fun¸co˜es em linha na se¸caõ 13.10. Uma vari´ avel declarada com const é uma vari´ avel que n˜ ao pode ser alterada. Veremos em detalhes o uso de const na se¸caõ 12.4. Listing 8.10: Fun¸caõ em linha: volume esfera. # include < iostream > // V a r i ´ a v e i s g l o b a i s devem ser d e c l a r a d a s com m a i ´ usculas // const indica ser constante , n~ a o muda const double PI = 3.14159; /* Um p r o g r a m a d o r C usaria # define PI 3 . 1 4 1 5 9 */ // Fun¸ c~ a o em linha inline double V o l u m e E s f e r a ( const double raio ) { return 4.0 / 3.0 * PI * raio * raio * raio ; } /* Um p r o g r a m a d o r C usaria uma macro , sem n e n h u m a v e r i f i c a ¸ c~ a o de tipo . # define V o l u m e E s f e r a ( raio ) ( 4 . 0 / 3 . 0 * PI * raio * raio * raio ) */ int main () { double raio ; std :: cout << " Entre com o raio : " ; std :: cin >> raio ; std :: cin . get () ; std :: cout << " Raio r = " << raio << " volume V = " << V o l u m e E s f e r a ( raio ) << std :: endl ; return 0; } Entre com o raio : 5 Raio r =5 volume V = 523.598

Veja na listagem 8.11 uma fun¸caõ utilizada para gerar n´ umeros randˆ omicos num determinado intervalo de valores. Listing 8.11: Exemplo de uso da biblioteca . # include < iostream > # include < iomanip > // A b i b l i o t e c a abaixo , no C chama stdlib .h , no C ++ chama c s t d l i b // a mesma f o r n e c e a fun¸ c~ a o srand - s e m e n t e para g e r a d o r // e rand - gera n´ u mero r a n d o m i c o . # include < cstdlib > int main () {



˜ 8.12. DECLARAC ¸ OES E ESCOPO

213

int semente ; std :: cout << " Entre com uma semente : " ; std :: cin >> semente ; std :: cin . get () ; int min ; std :: cout << " Entre com o valor m´ ı nimo ( a ) : " ; std :: cin >> min ; std :: cin . get () ; int max ; std :: cout << " Entre com o valor m´ a ximo ( b ) : " ; std :: cin >> max ; std :: cin . get () ; // Passa a s e m e n t e para o g e r a d o r de n ´ umeros aleat´ orios srand ( semente ) ; for ( int i = 1; i <= 50; i ++) // Chama 50 vezes a fun¸ c~ a o rand { std :: cout << std :: setw (10) << ( min + ( rand () % ( max - min + 1) ) ) ; if ( i % 5 == 0) std :: cout << std :: endl ; } return 0; } Entre com uma semente : 4 Entre com o valor m´ ı nimo ( a ) : 1 Entre com o valor m´ a ximo ( b ) : 10 2 4 5 7 8 6 4 9 5 5 5 5 5 3 2 2 8 5 9 10 9 3 3 1 1 4 5 7 10 5 5 4 2 10 7 6 2 3 9 3

4 6 4 10 4 1 10 3 5 4

Nota: veremos o uso de elipse ... em fun¸co˜es na se¸caõ E.4.

8.12

Declara¸c˜ oes e escopo

Um escopo é uma regi˜ ao de c´ odigo que contém declara¸co˜es. Cada declara¸caõ adiciona um nome ao escopo, e o uso desses nomes deve ser resolvido pelo compilador. Isto significa que n˜ ao podemos ter dois nomes iguais no mesmo escopo pois o compilador ficaria confuso e acusaria uma ambig¨ uidade. No exemplo a seguir int y; é declarado duas vezes, o que causa uma ambig¨ uidade. Exemplo: int main() { int x; int y; int y; return 0; }

// // // //

In´ ıcio do escopo de main(), do bloco de main() Declara um inteiro x Declara um inteiro y Erro, mesmo nome no mesmo escopo (ambiguidade)

// Fim do escopo de main(), do bloco de main()



´ 8.13. SENTENCAS ¸ PARA CONCEITOS BASICOS DE C++

214

No exemplo a seguir criamos, dentro do bloco de main(), um bloco interno. Observe que temos duas vari´ aveis y: a primeira y = 3; e a segunda y = 4;. Note que, quando um bloco interno é fechado, os objetos criados dentro do bloco s˜ ao destru´ıdos automaticamente. Exemplo: int main() { // In´ ıcio do escopo de main() int x; int y = 3; std::cout < < "y = " < < y ; // Sa´ ıda: y = 3 { // Bloco interno, define novo escopo int y = 4; std::cout < < "y = " < < y ; // Sa´ ıda: y = 4 } // y = 4 sai de escopo e ´ e destru´ ıdo automaticamente std::cout < < "y = " < < y ; // Sa´ ıda: y = 3 return 0; } // Fim do escopo de main() Veremos mais detalhes sobre escopo ao longo deste livro e na se¸caõ B.4.

8.13

Senten¸cas para conceitos b´ asicos de C++

• Sempre deixe uma linha em branco antes de uma declara¸caõ. Isto deixa o c´ odigo mais claro. • Um objeto s´ o pode ser utilizado depois de ter sido declarado. • Sempre que poss´ıvel, inicie os objetos na sua declara¸caõ. • Quando uma express˜ ao for complexa, coloque parênteses extras para facilitar o entendimento do c´ odigo. Sempre use espa¸cos para maior claridade. • Sempre use indenta¸caõ para deixar o c´ odigo organizado (você pode usar o programa indent. Veja se¸caõ ??). • Use nomes curtos para objetos muito usados e nomes longos para objetos e métodos pouco usados. Utilize um padr˜ ao para o nome dos objetos (veja se¸caõ 8.3). • No C temos de declarar todas as vari´ aveis no in´ıcio do programa; no C++ podemos declarar os objetos em qualquer parte. O ideal é declarar os objetos perto de onde ser˜ ao utilizados. • Sempre declare um objeto por linha. Exemplo: // Cria int* a; e int b; int *a, b; // Declarar um objeto por linha deixa o programa mais claro int* a; int b; • Objetos est´ aticos s˜ ao inicializados com 0. Programa¸caõ Orientada a Objeto com C++



215

• Objetos locais, criados dentro de um bloco (ou fun¸caõ), n˜ ao s˜ ao inicializados. Você precisa passar-lhes um valor. • Nem todos os compiladores aceitam o uso de caracteres universais. • A linguagem C/C++ reservou para uso futuro os seguintes prefixos: is (exemplo: isblank()), mem (exemplo: memf()), str (exemplo: strtof()), to (exemplo: toascii()), wcs (exemplo: wcstof()). • Utilize a palavra-chave export para informar que aquele objeto/classe/método é acess´ıvel externamente. • Note que podemos montar a sa´ıda que aparecer´ a na tela do computador usando o objeto std::cout e o operador de inser¸caõ < <. Podemos ir redirecionando caracteres e vari´ aveis do programa para tela do computador. Por exemplo, na linha std::cout < < "Mensagem1 " < < "Mensagem2 " < < "Mensagem3 "; enviamos para tela o texto "Mensagem1 Mensagem2 Mensagem3 ". • 2 Objetos podem ser modificados com as palavras-chave const (constante, n˜ ao muda), volatile (podem mudar de forma inesperada) e static (duram toda a execu¸caõ do programa). Veja se¸caõ B.3. • 2 Você n˜ ao deve confundir a classe de armazenamento com o escopo do objeto. A classe de armazenamento se refere ao tempo de vida do objeto (temporário ou permanente), já o escopo do objeto define onde ele pode ser utilizado (onde é vis´ıvel). Veja uma descri¸caõ dos conceitos de classes de armazenamento na se¸caõ B.1, dos modificadores de acesso na se¸caõ B.3 e do escopo das vari´ aveis na se¸caõ B.4 do Apêndice B. • 2 Segundo [Lischner, 2003], uma express˜ ao integral constante deve ter seu valor definido na compila¸caõ. As situa¸co˜es em que isto é necess´ ario incluem: tamanho de um array, inicializa¸caõ dos valores de uma enumera¸caõ, r´ otulos de instru¸co˜es case:, inicializa¸caõ de membros est´ aticos e argumentos de templates.

8.14


Neste cap´ıtulo vimos alguns conceitos b´ asicos de C++, como os coment´ arios, s´ımbolos, especificador, lvalues. Aprendemos o que s˜ ao os identificadores, os operadores e os literais. Vimos um grupo de palavras-chaves reservadas pelo C++, as palavras-chave de C++. Aprendemos que o nome dos objetos deve ser simples e claro. Aprendemos ainda a forma como declaramos e definimos os objetos, e as diferen¸cas da declara¸caõ (informa que o objeto existe) para defini¸caõ (reserva espa¸co na memória para o objeto). Vimos uma introdu¸caõ a diversos conceitos b´ asicos de C++, como fun¸caõ main(), uso de cin e cout, as diretrizes de pré-processador (#ifdef..#endif), algumas estruturas de controle (for, while), fun¸co˜es da biblioteca-padr˜ ao (pow(x,y)), alguns operadores, e uma introdu¸caõ ao conceito de fun¸co˜es. Finalmente, vimos a rela¸caõ entre declara¸co˜es e escopo. Nota: ao longo do livro veremos outros exemplos e listagens que esclarecem temas como escopo, cria¸caõ, destrui¸caõ e tempo de vida dos objetos. Programa¸caõ Orientada a Objeto com C++


8.15. EXERCÍCIOS

216

8.15

Exerc´ıcios

1. Qual a diferen¸ca b´ asica entre uma declara¸caõ e uma defini¸caõ? 2. Fa¸ca uma lista das palavras-chave que você j´ a memorizou. 3. Quais s˜ ao os tipos padr˜ oes de C++ que você j´ a conhece? 4. Modifique a listagem 8.1 usando os caracteres apresentados na Tabela 22.3. 5. Modifique a listagem 8.2 criando e usando novas vari´ aveis. Incluir outras opera¸co˜es como multiplica¸caõ e divisão. 6. Modifique a listagem 8.3, incluindo novas diretrizes de pré-processador (veja Apêndice A – Diretrizes de pré-processador). 7. Modifique as listagens 8.4, 8.5 e 8.6 fazendo com que elas fa¸cam algo mais u ´ til. 8. Rode agora o programa da se¸caõ 7.8. Você j´ a conseguiria modific´ a-lo? Comece adicionando coisas novas dentro do método Run(). 9. Um programa pode ser encerrado a qualquer momento chamando-se a fun¸caõ exit();, a qual encerra o programa destruindo os objetos criados, ou chamando abort();, que encerra o programa sem destruir os objetos criados. Monte um programa que use exit(); e outro que use abort();. Nota: se você n˜ ao est´ a familiarizado com o uso de algoritmos, consulte as referências [Holloway, 2006] (algoritmos em C++) e [Cormen et al., 2002, Boente, 2006].



Cap´ıtulo 9

Tipos Neste cap´ıtulo veremos uma introdu¸caõ ao conceito de tipos: o que é um tipo (Se¸caõ 9.1) e quais os tipos predefinidos de C++ (Se¸caõ 9.2). A defini¸caõ de tipos do usuário (Se¸caõ 9.3), como vetores no estilo de C (Se¸caõ 9.3.1), como estruturas (Se¸caõ 9.3.2), uniões (Se¸caõ 9.3.3), enumera¸co˜es (Se¸caõ 9.3.4), e classes (Se¸caõ 9.3.5). Os tipos definidos em bibliotecas externas (Se¸caõ 9.4), como a classe (Se¸caõ 9.4.1) e a classe da STL (Se¸caõ 9.4.2). Como manipular os tipos de C++ (Se¸caõ 9.5), como criar apelidos com typedef (Se¸caõ 9.5.1), o uso de size_t() (Se¸caõ 9.5.2) e sizeof() para obter o tamanho dos objetos (Se¸caõ 9.5.3), e o uso de typeid() para verificar o tipo do objeto (Se¸caõ 9.5.4). Veremos também a vantagem da tipifica¸caõ forte do C++ (Se¸caõ 9.6). Nota: neste cap´ıtulo apresentaremos vários tipos de objetos que s˜ ao utilizados em um programa ´ um cap´ıtulo extenso, com muitas informa¸co˜es, n˜ em C++. E ao se preocupe se n˜ ao entender tudo em uma primeira leitura. Ao longo dos próximos cap´ıtulos estes conceitos ser˜ ao reapresentados de forma mais detalhada.

9.1

Introdu¸ c˜ ao ao conceito de tipos

Um tipo é uma abstra¸caõ de algo (Se¸caõ 3.1). Para a linguagem C++ os tipos podem ser classificados em três grupos: • Tipos predefinidos da linguagem, como bool, char, int, double (Se¸caõ 9.2). • Tipos definidos pelo programador (Se¸caõ 9.3). • Tipos definidos em bibliotecas externas, como a STL (Se¸caõ 9.4).

9.2

Uso de tipos predefinidos de C++

Os tipos numéricos predefinidos da linguagem C++ s˜ ao bool, char, int, float e double.

• O tipo bool é utilizado para armazenar valores booleanos 0 (false/falso) ou 1 (true/verdadeiro), sendo utilizado como flag, por exemplo, em estruturas de controle. char é utilizado para armazenar caracteres ou n´ umeros inteiros pequenos. int é usado para armazenar n´ umeros inteiros, com ou sem sinal (unsigned). J´ a float e double s˜ ao utilizados para armazenar n´ umeros flutuantes (n´ umeros racionais). 217

218

9.2. USO DE TIPOS PREDEFINIDOS DE C++

• No n´ umero 7.48e9, 7.48 é a mantissa, e 9 o expoente. O ponto é o separador da parte fracion´ aria (quando utiliza-se o locale ”C”. Veja Se¸caõ 22.9.2. O caracter ”e” ou ”E” indica nota¸caõ exponencial. • Se o resultado de uma determinada conta for infinito (um n´ umero maior que a precisão suportada), a sa´ıda ser´ a “Inf” ou “Infinity”. Se o resultado for um valor indeterminado (como em 0/0) a sa´ıda ser´ a “NaN” ou “Not a Number”. • CUIDADO: A divisão de dois n´ umeros inteiros retorna um n´ umero inteiro, assim, 4 / 3 = 1. A divisão de um n´ umero inteiro por um n´ umero flutuante retorna um n´ umero flutuante. Uma representa¸caõ do consumo de mem´ oria em bytes dos diferentes tipos é apresentada na Figura 9.1. Observe que um double consome o dobro de memória de um float. A escolha por float ou double dependerá do uso: se você precisa de mais precisão use double; se quer economizar memória use float. Os intervalos de valores suportados pelos tipos predefinidos est˜ ao listados na Tabela 9.1. Observe que char pode ser utilizado como uma letra ou como um n´ umero com intervalo entre -128 e +127. De fato, char é utilizado como n´ umero em alguns programas de processamento de imagens. Um n´ umero inteiro short int, vai de -32768 até 32767. Isto significa que a conta realizada com um short int n˜ ao poder´ a ultrapassar esses valores. Se precisar de n´ umeros inteiros grandes, use int, long int, ou long long.

1

2

3

4

1

bool, char, unsigned char

1

2

short int, unsigned short

1

2

3

4

int, unsigned int, long, unsigned long, int*

1

2

3

4

float

6

7

8

long long, double

1

2

3

4

5

5

6

7

8

9 10 11 12 long double

Figura 9.1: Tipos predefinidos de C++ e suas dimensões (32 bits). Vimos exemplos de como criar e utilizar um objeto com base em um tipo predefinido de C++, nas listagens 8.2, 8.4, 8.5, 8.6 e C.1. Veremos na Se¸caõ 9.5.3 que o n´ umero de bytes consumido por um n´ umero inteiro varia de acordo com a plataforma. Veja na Listagem 9.1 um programa que utiliza os tipos predefinidos de C++. Observe que este exemplo n˜ ao tem nem entrada nem sa´ıda de dados, n˜ ao sendo necess´ aria a inclus˜ ao de arquivos externos. Listing 9.1: Usando os tipos pré-definidos de C++. 1 2 3 4 5 6

int main () { // Tipos pr´ e - d e f i n i d o s da l i n g u a g e m C ++ // Tipo booleano , i n t e r v a l o 0 ou 1 (1 byte ) bool flag = 0;




219

Tabela 9.1: Tipos predefinidos e intervalos.

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Tipos b´ asicos

Caracter´ısticas

bytes

Valor m´ınimo

Valor m´ aximo

bool char wchar_t unsigned char short unsigned short int unsigned int long unsigned long long long

booleano caracteres caracteres caracteres sem sinal inteiro inteiro pequeno, sem sinal inteiro inteiro sem sinal inteiro grande inteiro grande com sinal inteiro muito grande

1 1 2 1 2 2 4 4 4 4 8

float double long double enum

precis˜ ao simples, 7 d´ıgitos precis˜ ao dupla, 15 d´ıgitos precis˜ ao dupla, 19 d´ıgitos enumerados

4 8 12 2

0 -128 0 0 -32768 0 -2.147.483.648 0 -2.147.483.648 0 -9.223.372.036 .854 .775.808 1.17e-38 1.7e-308 3.4e-4932 -2.147.483.648

1 127 65535 255 32767 65535 +2.147.483.647 +4.294.967.295 +2.147.483.647 +4.294.967.295 +9.223.372.036 .854.775.807 3.40e+38 1.7e+308 1.1e+4932 +2.147.483.648

// Tipo char , i n t e r v a l o -128 a +127 (1 byte ) char ch = ’ b ’; char nch = 14; // Tipo int , i n t e r v a l o int int_x = 777;

-2147483648 a + 2 1 4 7 4 8 3 6 4 7 (4 bytes , 32 bits )

// Tipo float , i n t e r v a l o +/ - 3.4. e +/ -38 (7 d ´ ı g i t o s de p r e c i s ~ a o ) (4 bytes ) float float_y = 3.212 f ; // Tipo double , i n t e r v a l o +/ - 1.7 e +/ -308 (15 d ´ ı g i t o s de p r e c i s ~ a o ) (8 bytes ) double double_z = 7.48 e9 ; // Tipo long double , i n t e r v a l o +/ - 3.4 e +/ -4932 // (19 d ´ ı g i t o s de p r e c i s ~ a o) (12 bytes ) long double l o n g _ d o u b l e _ r = 1.2 e -18; return 0; }

Observe no exemplo da Listagem 9.2 o uso e as diferen¸cas dos tipos int (inteiro) e unsigned int (inteiro sem sinal). Observe que quando usamos int a opera¸caõ x - y é válida pois int aceita n´ umeros negativos. J´ a quando usamos unsigned int, z s´ o pode armazenar n´ umeros inteiros positivos, n˜ ao podendo armazenar o resultado de x - y quando y > x. Observe na sa´ıda gerada pelo compilador a mensagem de warning por estarmos armazenando um inteiro negativo em um inteiro sem sinal (unsigned int t = -1;). Observe na sa´ıda que quando usamos int temos x = 300 e y = 500, e z = x - y apresenta o valor correto -200. Quando usamos unsigned int, aparece um valor absurdo, 4294967096, no lugar de -200. Como dito, isto ocorre porque z s´ o pode armazenar n´ umeros inteiros positivos. Vamos explicar este problema com um exemplo. Observe na Tabela 9.1 que um n´ umero unsigned int, vai de 0 até +4.294.967.295, se criarmos um n´ umero t usando unsigned int t = 4.294.967.295; Programa¸caõ Orientada a Objeto com C++


220


Quando fazemos t = t + 1; o valor de t é incrementado do valor 1 e ultrapassa o limite definido. Como os n´ umeros s˜ ao tratados de maneira c´ıclica, o novo valor de t passa a ser 0 (zero). O mesmo problema ocorre quando ultrapassamos o limite inferior, isto é, se t = 0; o c´ odigo t = t -1; faz com que t assuma o valor +4.294.967.295. Listing 9.2: Diferen¸cas no uso de inteiro com sinal (signed) e sem sinal (unsigned). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

# include < iostream > int main () { { std :: cout << " - - - - - - - - - - > Testando a utiliza¸ ca ~ o de int " << std :: endl ; int x , y , z ; std :: cout << " Entre com int x ( ex : 300) : " ; std :: cin >> x ; std :: cout << " Entre com int y ( ex : 500) : " ; std :: cin >> y ; std :: cin . get () ; z = x + y; std :: cout << " int z = x + y = " << z << std :: endl ; z = x - y; std :: cout << " int z = x - y = " << z << std :: endl ; } std :: cout << " - - - - - - - - - - > Testando a utiliza¸ ca ~ o de unsigned int " << std :: endl ; unsigned int x , y , z ; std :: cout << " Entre com unsigned int x ( ex : 300) : " ; std :: cin >> x ; std :: cout << " Entre com unsigned int y ( ex : 500) : " ; std :: cin >> y ; std :: cin . get () ; z = x + y; std :: cout << " unsigned int z = x + y = " << z << std :: endl ; z = x - y; std :: cout << " unsigned int z = x - y = " << z << std :: endl ; // Se x if ( x > z = x else z = y

> y r e t o r n a z = x - y , caso c o n t r ´ a r i o ( else ) r e t o r n a z = y - x y) - y; - x;

// A r m a z e n a a i n f o r m a ¸ c~ a o do sinal , o b s e r v e que sinal ´ e do tipo int . int sinal ; if ( x > y ) sinal = +1; else sinal = -1; // Cria objeto int para a r m a z e n a r o r e s u l t a d o int r e s u l t a d o _ c o r r e t o = sinal * z ; std :: cout << " z = | x - y | = " << z << std :: endl ; std :: cout << " sinal de x - y = " << sinal << std :: endl ; std :: cout << " int r e s u l t a d o _ c o r r e t o = sinal * z = " << r e s u l t a d o _ c o r r e t o << std :: endl ; unsigned int t = -1; std :: cout << " unsigned int t = -1 --> t = " << t << std :: endl ; return 0; }




221

Compila¸ ca ~o : ========= == bash -3.00 $ g ++ signed - unsigned . cpp signed - unsigned . cpp : In function ’ int main () ’: signed - unsigned . cpp :49: warning : converting negative value ’ -0 x000000001 ’ to ’ unsigned int ’ b [ a n d r e @ m e r c u r i o lyx ] $ ./ a . out - - - - - - - - - - > Testando uso de int Entre com int x ( ex : 300) :300 Entre com int y ( ex : 500) :500 int z = x + y =800 int z = x - y = -200 - - - - - - - - - - > Testando uso de unsigned int Entre com unsigned int x ( ex : 300) :300 Entre com unsigned int y ( ex : 500) :500 unsigned int z = x + y = 800 unsigned int z = x - y = 4294967096 z =| x - y |=200 sinal de x - y = -1 int r e s u l t a d o _ c o r r e t o = sinal * z = - 200 unsigned int t = -1 --> t =

9.2.1

4294967295

Uso de sufixos para os tipos predefinidos2

Quando digitamos um literal, Exemplo: int x = 7;

// 7 ´ e um literal

o mesmo representa que tipo de n´ umero inteiro? é um short? um int? um long int? ou um long long int? Por padr˜ ao, 7 é um int. Podemos definir de forma exata o tipo do literal usando sufixos. Veja lista de sufixos e exemplo de uso a seguir: I,L

long

u,U

unsigned

ul,uL,UL unsigned long uLL,Ull

unsigned long long

f

float

Por exemplo: • O n´ umero 7.45 é um double, 7.45f é um float, e 7.45L é long double. • O n´ umero 7L é um long int, 7uL é um unsigned long int. • O n´ umero 7LL é um long long int. • O n´ umero que inicia com 0x é um n´ umero hexadecimal. • O n´ umero que inicia com 0 (zero) é um n´ umero octal. Programa¸caõ Orientada a Objeto com C++


222

9.2.2


Uso avan¸cado dos tipos predefinidos2

Veja na Listagem 9.3 um programa que mostra informa¸co˜es sobre os tipos predefinidos de C++. Como este exemplo utiliza conceitos avan¸cados de C++, como o uso de templates e bibliotecas padr˜ oes de C++, n˜ ao se preocupe se n˜ ao entender seu funcionamento nesta primeira leitura. O arquivo de cabe¸calho inclui a classe template , a qual inclui atributos e métodos que fornecem informa¸co˜es sobre os tipos predefinidos. Por exemplo, a chamada a numeric_limits::is_integer() retorna verdadeiro se o Tipo for char, short, int, unsigned int. Neste exemplo, a fun¸caõ Info() recebe o tipo de objeto e uma string com seu nome. Em seguida, envia para a tela informa¸co˜es b´ asicas sobre o tipo como: é inteiro?; valores máximos e m´ınimos suportados; expoentes m´ınimos e máximos; valor infinito e dados como radix, epsilon, round_error e round_style. Listing 9.3: Verificando os limites dos tipos pré-definidos de C++. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

# include < iostream > # include < string > # include < limits > using namespace std ; // Fun¸ c~ a o t e m p l a t e u t i l i z a d a para i n f o r m a r dados sobre o n´ u mero . // Recebe dois par^ a metros , p r i m e i r o o n´ u mero n , s e g u n d o o nome s template < typename Tipo > void Info ( Tipo n , string s ) { cout << " \n - - - > Informa¸ co ~ e s sobre n´ u meros " << s << " <--- " ; s = " \ nnumeric_limit s < " + s + " >:: " ; cout << s << " is_integer = " << numeric_limits < Tipo >:: is_integer << s << " max () = " << numeric_limits < Tipo >:: max () << s << " min () = " << numeric_limits < Tipo >:: min () << s << " m i n _ e x p o n e n t = " << numeric_limits < Tipo >:: m i n _ e x p o n e n t << s << " m i n _ e x p o n e n t 1 0 = " << numeric_limits < Tipo >:: m i n _ e x p o n e n t 1 0 << s << " m a x _ e x p o n e n t = " << numeric_limits < Tipo >:: m a x _ e x p o n e n t << s << " m a x _ e x p o n e n t 1 0 = " << numeric_limits < Tipo >:: m a x _ e x p o n e n t 1 0 << s << " digits = " << numeric_limits < Tipo >:: digits << s << " digits10 = " << numeric_limits < Tipo >:: digits10 << s << " radix = " << numeric_limits < Tipo >:: radix << s << " infinity () = " << numeric_limits < Tipo >:: infinity () << s << " epsilon () = " << numeric_limits < Tipo >:: epsilon () << s << " round_err or () = " << numeric_limits < Tipo >:: round_err or () << s << " round_sty le = " << numeric_limits < Tipo >:: round_sty le << endl ; } int main () { char c ; int i ; long l ; long long ll ; float f ; double d ; long double ld ; Info (c , " char " ) ; Info (i , " int " ) ; Info (l , " long " ) ; Info ( ll , " long long " ) ; Info (f , " float " ) ; Info (d , " double " ) ; Info ( ld , " long double " ) ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ linux64 ./ a . out




223

---> Informa¸ co ~ e s sobre n´ u meros char < - - numeric_limits < char >:: is_integer = 1 numeric_limits < char >:: digits = 7 ... ---> Informa¸ co ~ e s sobre n´ u meros int < - - numeric_limits < int >:: is_integer = 1 numeric_limits < int >:: max () = 2147483647 numeric_limits < int >:: min () = -2147483648 numeric_limits < int >:: digits = 31 ... ---> Informa¸ co ~ e s sobre n´ u meros long < - - numeric_limits < long >:: is_integer = 1 numeric_limits < long >:: max () = 9 2 2 3 3 7 2 0 3 6 8 5 4 7 7 5 8 0 7 numeric_limits < long >:: min () = -922337203 6 85 4 77 5 80 8 numeric_limits < long >:: digits = 63 ... ---> Informa¸ co ~ e s sobre n´ u meros long long < - - numeric_limits < long long >:: is_integer = 1 numeric_limits < long long >:: max () = 9 2 2 3 3 7 2 0 3 6 8 5 4 7 7 5 8 0 7 numeric_limits < long long >:: min () = -9223372036 8 54 7 7 58 0 8 numeric_limits < long long >:: digits = 63 ... ---> Informa¸ co ~ e s sobre n´ u meros float < - - numeric_limits < float >:: is_integer = 0 numeric_limits < float >:: max () = 3.40282 e +38 numeric_limits < float >:: min () = 1.17549 e -38 numeric_limits < float >:: m i n _ e x p o n e n t = -125 numeric_limits < float >:: m i n _ e x p o n e n t 1 0 = -37 numeric_limits < float >:: m a x _ e x p o n e n t = 128 numeric_limits < float >:: m a x _ e x p o n e n t 1 0 = 38 numeric_limits < float >:: digits = 24 numeric_limits < float >:: infinity () = inf ... ---> Informa¸ co ~ e s sobre n´ u meros double < - - numeric_limits < double >:: is_integer = 0 numeric_limits < double >:: max () = 1.79769 e +308 numeric_limits < double >:: min () = 2.22507 e -308 numeric_limits < double >:: m i n _ e x p o n e n t = -1021 numeric_limits < double >:: m i n _ e x p o n e n t 1 0 = -307 numeric_limits < double >:: m a x _ e x p o n e n t = 1024 numeric_limits < double >:: m a x _ e x p o n e n t 1 0 = 308 numeric_limits < double >:: digits = 53 numeric_limits < double >:: digits10 = 15 numeric_limits < double >:: infinity () = inf ... ---> Informa¸ co ~ e s sobre n´ u meros long double < - - numeric_limits < long double >:: is_integer = 0 numeric_limits < long double >:: max () = 1.18973 e +4932 numeric_limits < long double >:: min () = 3.3621 e -4932 numeric_limits < long double >:: m i n _ e x p o n e n t = -16381 numeric_limits < long double >:: m i n _ e x p o n e n t 1 0 = -4931 numeric_limits < long double >:: m a x _ e x p o n e n t = 16384 numeric_limits < long double >:: m a x _ e x p o n e n t 1 0 = 4932 numeric_limits < long double >:: digits = 64 numeric_limits < long double >:: digits10 = 18 numeric_limits < long double >:: infinity () = inf ...

Nota: veja no manual do seu ambiente de desenvolvimento onde est˜ ao armazenados os arquivos da biblioteca de C++. No GNU/Linux est˜ ao em /usr/include/c++/vers˜ aoDoCompilador. Dê uma olhada no arquivo de biblioteca (exemplo: /usr/include/c++/4.1.1/limits). Programa¸caõ Orientada a Objeto com C++


224

9.2. USO DE TIPOS PREDEFINIDOS DE C++ Esse arquivo contém vari´ aveis que definem os limites para os tipos predefinidos da linguagem.

9.2.3

Senten¸cas para uso de tipos predefinidos

• Os tipos inteiros (char, short, int, long) e os tipos flutuantes (float, double, long double) também s˜ ao conhecidos como tipos aritméticos. • Um tipo aritmético pode ser automaticamente convertido para outro. Por default, um tipo menor é convertido em um tipo maior (exemplo: int é convertido para float). A idéia é que os valores sejam preservados. Cuidado especial deve ser tomado quando convertemos um tipo com sinal negativo para um tipo sem sinal (veja Listagem 9.2). • Um tipo flutuante, quando convertido para int, é truncado (exemplo: int y = 4.33; // y = 4). • Utilize unsigned char quando precisar trabalhar com n´ umeros entre 0 e 255. Utilize signed char quando precisar trabalhar com n´ umeros entre -128 e 127. • A palavra-chave const é usada para indicar que o conte´ udo do objeto n˜ ao muda. No exemplo a seguir o valor de y ser´ a sempre 5. Exemplo: const int y = 5; // Cria objeto constante do tipo inteiro • Por default, o n´ umero 5.3 é um double; j´ a 5.3f é um n´ umero float. • Podemos atribuir a um bool um valor diferente de 0 e 1. Neste caso, todo valor diferente de zero assume o valor 1 (true/verdadeiro). • Um caracter é representado dentro de aspas simples, como na sequência: ’a’, ’\b’, ’\u03co’. O caracter ’a’ é uma letra simples. O caracter ’\b’ é um caracter de escape (veja Tabela 22.3). J´ a ’\u03co’ é um caracter universal. • Uma string de C (cstring) é representada dentro de aspas duplas, como em: "oi tudo bem!" observe que podemos quebrar a string utilizando uma barra invertida, "oi tudo \ bem" concatenar strings, "oi" " tudo" " bem" ou incluir caracteres de escape "oi\t tudo\t bem\a". • Um espa¸co ’ ’, uma tabula¸caõ horizontal ’\t’, uma tabula¸caõ vertical ’\v’, um avan¸co de formulário ’\f’e um caracter de nova linha ’\n’ s˜ ao conhecidos e tratados como ”whitespace caracters”. • 2 Uma wide string também é representada dentro de aspas duplas, mas a string é antecedida da letra L como em: L"oi tudo bem!". Programa¸caõ Orientada a Objeto com C++


´ 9.3. USO DE TIPOS DO USUARIO

9.3

225

Uso de tipos do usu´ ario

Veja nesta se¸caõ exemplos preliminares de defini¸caõ e uso de tipos do usuário. Veremos como criar tipos do usu´ ario utilizando vetores (Se¸caõ 9.3.1), estruturas (Se¸caõ 9.3.2), uniões (Se¸caõ 9.3.3), enumera¸co˜es (Se¸caõ 9.3.4) e classes (Se¸caõ 9.3.5).

9.3.1

Introdu¸ c˜ ao aos vetores no estilo de C

Em C/C++, podemos criar um vetor usando o tipo do objeto a ser armazenado no vetor, o nome do vetor e o n´ umero de elementos do vetor que é colocado dentro de []. Veja a seguir o prot´ otipo para criar e usar um vetor no estilo de C. Prot´ otipo: // Para criar um vetor em C Tipo NomeVetor [dimens˜ ao]; Tipo NomeVetor []= {lista de elementos}; // Para acessar um elemento do vetor NomeVetor[posi¸ca õ]; O exemplo a seguir ilustra a cria¸caõ e o uso de um vetor de n´ umeros inteiros. Observe que definimos explicitamente o tamanho de v1, com a dimensão 5. O tamanho de v2 é calculado pelo compilador, em tempo de compila¸caõ. Usamos um for para calcular a soma dos elementos de v1 e v2 e armazenar em v3. Exemplo: int v1[5]; for( int i = 0; v[i] = i; int v2[] = { 3, int v3[5]; for( int i = 0; v3[i] = v1[i]

// Cria vetor v1 i < 5 ; ++i ) // Inicializa valores de v1 4, 7, 9, 1 }; // Cria vetor v2 e j´ a inicializa // Cria vetor v3 i < 5 ; ++i ) + v2[i];

Dica: em C e C++ os vetores iniciam com o ´ındice 0 e n˜ ao com 1. Assim, num vetor de tamanho n, o primeiro elemento é o elemento v[0], e o u ´ ltimo elemento o v[n-1]. Nota: o Apêndice H, Vetores e matrizes – arrays, mostra em detalhes o uso de vetores e arrays ´ importante no estilo de C. Veremos na Se¸caõ 15.3 o uso de aloca¸caõ dinâmica e vetores. E destacar que o uso de vetores no estilo de C é obsoleto; eles têm sido substitu´ıdos por de C++. Veremos uma introdu¸caõ aos vetores no estilo de C++ na Se¸caõ 9.4.2. Veremos o uso avan¸cado de vetores e arrays no Cap´ıtulo ?? – Biblioteca Blitz++.

9.3.2

Introdu¸ c˜ ao ` as estruturas

A linguagem C utiliza a palavra-chave struct para criar estruturas de dados que s˜ ao utilizadas para armazenar vari´ aveis, dentro de uma entidade u ´ nica (sem fun¸co˜es). O prot´ otipo para defini¸caõ de uma estrutura inicia-se com a palavra-chave struct e, em seguida, o nome da estrutura e o bloco com a defini¸caõ das vari´ aveis que fazem parte da estrutura. N˜ ao se esque¸ca do ponto e v´ırgula ap´ os o final do bloco. Programa¸caõ Orientada a Objeto com C++



226 Prot´ otipo: // Declara estrutura SNomeEstrutura struct SNomeEstrutura; // Define estrutura SNomeEstrutura struct SNomeEstrutura { Tipo1 vari´ avel1; Tipo2 vari´ avel2; };

Depois de definida uma estrutura, o seu nome passa a ser um tipo do usuário, podendo ser utilizada de forma semelhante a de qualquer outro tipo de C++. Para criar um objeto do tipo SNomeEstrutura fa¸ca: SNomeEstrutura nomeObjeto; Podemos utilizar as vari´ aveis da estrutura usando nomeObjeto.variavel1 = valor; O exemplo da Listagem 9.4 ilustra a declara¸caõ e utiliza¸caõ de estruturas simples. Dentro da struct SPessoa criamos dois vetores de caracteres no estilo de C, nome e matr´ ıcula. A fun¸caõ main() utiliza a estrutura SPessoa para criar um professor. Em seguida, solicita os dados do professor. Na linha SPessoa aluno[numeroAlunos]; criamos um vetor aluno para armazenar informa¸co˜es sobre os alunos. Observe que cada casa do vetor armazena uma estrutura do tipo SPessoa. Um la¸co for é utilizado para entrada dos dados dos alunos, e, ent˜ ao, uma rela¸caõ com os dados do professor e dos alunos é enviada para a tela. Neste exemplo definimos um tipo novo, o tipo SPessoa, criamos objetos a partir deste tipo, o professor e o vetor aluno, e utilizamos os objetos criados. Listing 9.4: Usando struct. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# include < iostream > // Define uma nova e s t r u t u r a struct SPessoa { char nome [50]; // Vetor nome com 50 c a r a c t e r e s ( uma c s t r i n g ) char matricula [20]; // Vetor m a t r i c u l a com 20 c a r a c t e r e s }; int main () { std :: cout << " Entre com o n´ u mero de alunos da disciplina ( ex =3) : " ; int n u m e r o A l u n o s ; std :: cin >> n u m e r o A l u n o s ; std :: cin . get () ; SPessoa professor ; std :: cout << " Entre com o nome do professor ( sem espa¸ co ): ";



´ 9.3. USO DE TIPOS DO USUARIO 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

227

std :: cin >> professor . nome ; std :: cout << " Entre com a matr´ ı cula do professor : " ; std :: cin >> professor . matricula ; SPessoa aluno [ n u m e r o A l u n o s ]; for ( int contador = 0; contador < n u m e r o A l u n o s ; contador ++) { std :: cout << " Aluno " << contador ; std :: cout << " \ nEntre com o nome do aluno ( sem espa¸ co ): "; std :: cin >> aluno [ contador ]. nome ; std :: cout << " Entre com a matr´ ı cula do aluno : " ; std :: cin >> aluno [ contador ]. matricula ; } std :: cout << " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << " \ nRELA¸ C~ A O DE PROFESSOR E S E ALUNOS : " << " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << " \ nNome do professor : " << professor . nome << " \ nMatr´ ı cul a : " << professor . matricula ; for ( int contador = 0; contador < n u m e r o A l u n o s ; contador ++) { std :: cout << " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " << " \ nAluno " << contador << " \ nNome do aluno : " << aluno [ contador ]. nome << " \ nMatr´ ı cul a : " << aluno [ contador ]. matricula ; } return 0; } [ b u e n o @ l d s c 0 5 Cap -09] $ ./ a . out Entre com o n´ u mero de alunos da disciplina ( ex =3) :3 Entre com o nome do professor ( sem espa¸ c o ) : P . C . Philippi Entre com a matr´ ı cula do professor : 3251 Aluno 0 Entre com o nome do aluno ( sem espa¸ co ): Liang_Zhirong Entre com a matr´ ı cula do aluno : 6154 Aluno 1 Entre com o nome do aluno ( sem espa¸ co ): Fabio_Magnani Entre com a matr´ ı cula do aluno : 9465 Aluno 2 Entre com o nome do aluno ( sem espa¸ co ): Luis_Orlando_Emeri ch Entre com a matr´ ı cula do aluno : 3164 ------------------------------------------------------RELA¸ C~ A O DE PROFESSORE S E ALUNOS : ------------------------------------------------------Nome do professor : P . C . Philippi Matr´ ı cula : 3251 ------------------------------------------------------Aluno 0 Nome do aluno : L i a n g _ Z h i r o n g Matr´ ı cula : 6154 ------------------------------------------------------Aluno 1 Nome do aluno : F a b i o _ M a g n a n i Matr´ ı cula : 9465 ------------------------------------------------------Aluno 2 Nome do aluno : L u i s _ O r l a n d o _ E m e r i c h

Nota: veremos o uso de estruturas em detalhes no Apêndice G – Estruturas, uniões, enumePrograma¸caõ Orientada a Objeto com C++



228 ra¸co˜es.

9.3.3

Introdu¸ c˜ ao ` as uni˜ oes

Também podemos criar novos tipos, ou tipos do usuário utilizando uniões. Uma union (uni˜ ao) permite a um conjunto de objetos ocupar o mesmo local na memória. Veja o prot´ otipo a seguir. Observe que, como os objetos ocupam o mesmo local na memória, somente um objeto pode ser utilizado por vez e que o tamanho da union ser´ a dado pelo tamanho do maior objeto. Note ainda que podemos colocar dois objetos definidos pelo usuário dentro de uma union, mas s´ o podemos utilizar um de cada vez. Isto é, quando um é usado, o outro é perdido. Prot´ otipo: // Declara uni˜ ao UNomeUniao union UNomeUniao; // Define uni˜ ao UNomeUniao union UNomeUniao { Tipo1 v1; Tipo2 v2; } A Listagem 9.5 inicia definindo a uni˜ ao UPropriedade, com dois atributos– um double e um int. Em seguida, cria objeto a partir da uni˜ ao definida, UPropriedade obj;. O acesso aos atributos da união é simples, nomeObjetoUni˜ ao.nomeAtributo (exemplo: obj.raioHidraulico;). Observe que o sizeof() da uni˜ ao tem a mesma dimensão do sizeof() de um double. Veremos o uso de sizeof() na Se¸caõ 9.5.3. Listing 9.5: Usando union. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# include < iostream > int main () { union U P r o p r i e d a d e { int r a i o H i d r a u l i c o ; double condutanc i a ; };

// Define a uni~ ao // A t r i b u t o s da uni~ ao

U P r o p r i e d a d e obj ; // Cria objeto do tipo UPropriedade , com nome obj obj . r a i o H i d r a u l i c o = 3; std :: cout << " r a i o H i d r a u l i c o = " << obj . r a i o H i d r a u l i c o << ’\ t ’; obj . condutanci a = 5.0; std :: cout << " condut^ a nci a = "

<< obj . condutanc i a << ’\ n ’;

std :: cout << " sizeof ( double ) = " << sizeof ( double ) << ’\ t ’; std :: cout << " sizeof ( U P r o p r i e d a d e ) = " << sizeof ( U P r o p r i e d a d e ) return 0;

<< std :: endl ;

} raioHidraulico = 3 sizeof ( double ) = 8

condut^ a nc i a = 5 sizeof ( U P r o p r i e d a d e ) = 8

Nota: veremos o uso de uni˜ oes em detalhes no Apêndice G – Estruturas, uniões, enumera¸co˜es. Programa¸caõ Orientada a Objeto com C++



9.3.4

229

Introdu¸ c˜ ao ` as enumera¸c˜ oes

Uma enumera¸caõ é uma seq¨ uência de valores que tem como objetivo enumerar algum processo. Uma enumera¸caõ é um tipo definido pelo usuário. No prot´ otipo a seguir, v1 , v2 , v3 ,..., vn s˜ ao os valores, e ENome é o nome da enumera¸caõ. Prot´ otipo: enum ENome { v1, v2, v3,...,vn }; Veja no exemplo a seguir como declarar e usar uma enumera¸caõ. EDia é o nome da enumera¸caõ e dom = 1, seg = 2, ter = 3, qua = 4, qui = 5, sex = 6, sab = 7, os valores da enumera¸caõ. Observe que os valores de cada elemento da enumera¸caõ s˜ ao incrementados de 1. Note que criamos um objeto do tipo da enumera¸caõ na linha EDia dia; e o utilizamos da forma como usamos os tipos predefinidos de C++. Exemplo: enum EDia { dom, seg, ter, qua, qui, sex, sab }; EDia dia; dia = seg; cout < < "hoje ´ e " < < dia; Nota: veremos o uso de enumera¸co˜es em detalhes no Apêndice G – Estruturas, uniões, enumera¸co˜es.

9.3.5

Introdu¸ c˜ ao ` as classes

A forma mais comum de criar tipos do usuário é utilizar o conceito de classe. C++ permite a constru¸caõ do conceito de classe, com atributos e métodos, exatamente da forma discutida na Parte I – Filosofia e modelagem orientada a objeto. N˜ ao se preocupe se n˜ ao entender exatamente o que est´ a sendo feito, pois, no Cap´ıtulo 11 – Classes, descreveremos em detalhes como criar e utilizar as classes de C++. Implementaremos nossa primeira classe na Listagem 9.6. Nosso objetivo é mostrar a forma como C++ define uma classe e mostrar que uma classe definida pelo usuário se comporta da mesma forma que os tipos predefinidos da linguagem. Observe que a declara¸caõ de um objeto do tipo CComplexo (exemplo: CComplexo a, b;) usa o mesmo formato que a declara¸caõ de um tipo predefinido de C++ (exemplo: int x;). A forma de uso também é igual (exemplo: c = a + b). Nota: neste exemplo utilizamos o conceito de sobrecarga de operador na linha c = a + b;. Veja o conceito de operadores no Apêndice C – Operadores, e de sobrecarga de operadores no Cap´ıtulo 21 – Sobrecarga de operador. O conceito de friend ser´ a apresentado no Cap´ıtulo 20 – Friend. Listing 9.6: Exemplo preliminar de defini¸caõ de classe do usuário. 1 2 3 4 5 6 7 8

# include < iostream > // / E x e m p l o p r e l i m i n a r de d e f i n i ¸ c~ a o de um tipo de usu´ a rio , // / por meio de uma classe // / D e f i n i ¸ c~ a o do tipo do u s u ´ a r i o CComplexo , r e p r e s e n t a um n´ u mero c o m p l e x o class CComplexo { public :



230 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

9.4. USANDO TIPOS DEFINIDOS EM BIBLIOTECAS – STL

// / A t r i b u t o s real e img double real , img ; // / M´ e todo usado para d e f i n i ¸ c~ a o dos v a l o r e s de real e img void Set ( double _real , double _img ) { real = _real ; img = _img ; } // / S o b r e c a r g a do o p e r a d o r + friend CComplexo operator +( CComplexo & c1 , CComplexo & c2 ) ; }; // / E x e m p l o da d e f i n i ¸ c~ a o da s o b r e c a r g a de um o p e r a d o r + // / O o p e r a t o r+ cria um novo n´ u mero c o m p l e x o com nome c3 onde a r m a z e n a a soma // / dos v a l o r e s reais e i m a g i n ´ a r i o s de c1 e c2 . CComplexo operator +( CComplexo & c1 , CComplexo & c2 ) { CComplexo c3 ; c3 . real = c1 . real + c2 . real ; c3 . img = c1 . img + c2 . img ; return c3 ; } int main () { CComplexo a , b ;

// / Fun¸ c~ ao principal

// / Cria os o b j e t o s a e b do tipo C C o m p l e x o // / Chama m´ e todo Set dos o b j e t o s a e b a . Set (5 , 4) ; // / a . real = 5; a . img = 4 b . Set (2 , 6) ; // / b . real = 2; b . img = 6 CComplexo c ; // / Cria um novo objeto do tipo c o m p l e x o com nome c c = a + b; // / Soma os c o m p l e x o s a e b e a r m a z e n a em c // / Mostra o r e s u l t a d o na tela std :: cout << " c ( " << c . real << " ," << c . img << " ) = " << " a ( " << a . real << " ," << a . img << " ) + " << " b ( " << b . real << " ," << b . img << " ) " << std :: endl ; return 0; // / E n c e r r a o p r o g r a m a

} [ a n d r e @ m e r c u r i o Parte - II ] $ ./ a . out c (7 ,7) = a (5 ,4) + b (2 ,3)

Agora que você já sabe usar os tipos predefinidos de C++ (char, int, float, etc.), já tem idéia de como se declara e se define um tipo do usuário (a estrutura SPessoa, a união UPropriedade, a enumera¸caõ EDia e a classe CComplexo), podemos ver um exemplo que utiliza uma biblioteca externa (a biblioteca-padr˜ ao de C++, a STL). Nota: os tipos numéricos predefinidos da linguagem C++, bool, char, int, float e double, podem ser vistos como classes definidas pelo criador do C++ e que est˜ ao escondidas de você. Assim, pode-se imaginar que existem as classes: class bool{};, class char{};, class int{};, class float{};, class double{};.

9.4

Usando tipos definidos em bibliotecas – STL

Uma biblioteca é um conjunto de arquivos objetos reunidos em um u ´ nico arquivo. Você pode criar e utilizar suas próprias bibliotecas ou utilizar bibliotecas desenvolvidas por terceiros. Veremos como criar nossas próprias bibliotecas no Cap´ıtulo ?? – Bibliotecas, e na Se¸caõ ?? – Critérios para sele¸caõ de bibliotecas externas. Programa¸caõ Orientada a Objeto com C++



231

Nesta se¸caõ vamos apresentar uma introdu¸caõ a duas classes da biblioteca-padr˜ ao de C++: as classes e .

9.4.1

Introdu¸ c˜ ao ` a classe

Basicamente uma string é uma seq¨ uência de caracteres. Para utilizar a classe string de C++, inclua o arquivo de cabe¸calho , crie objetos do tipo string e, em seguida, acesse seus métodos. Veja no exemplo a seguir diferentes formas para criar strings: Exemplo: #include int main() { // Cria string vazia com nome s1 std::string s1; // Cria string com nome s2 e conte´ udo "a classe string" std::string s2 ("a classe string"); // Cria string com nome s3 e inicializa com " ´ e legal" std::string s3 = " ´ e legal"; // Cria string com nome s4, uma c´ opia de s3 std::string s4 (s3); // Cria string s5, com espa¸ co para 10 caracteres, preenche com b std::string s5 (10, ’b’); // Cria string com nome s6 e redimensiona para 100 caracteres std::string s6 ("eu terei espa¸ co para 100 caracteres"); s6.resize(100); return 0; } Veja a seguir o prot´ otipo de alguns métodos da classe string. Note que size_type, normalmente, é um int informando a dimensão da string. A palavra-chave const em um parˆ ametro indica que o mesmo n˜ ao vai ser alterado (é constante). A palavra-chave const no final da declara¸caõ de um método indica que este método n˜ ao modifica o objeto (é somente leitura). size type size() const; Retorna o n´ umero de elementos utilizados pelo container (veja Figura 32.1). Para mudar o size() de um container use resize(novaDimens~ ao). void reserve (size type n = 0); Reserva espa¸co de mem´ oria para n elementos (n caracteres). void clear (); Zera a string. A string fica vazia. bool empty () const; Retorna true se a string estiver vazia. void erase(iterator p); Remove o elemento da posi¸caõ p, isto é, o elemento acessado usando o iterador p. string substr (size type pos = 0, size type n = npos) const; Cria uma substring a partir da posi¸caõ pos, considerando n caracteres. Programa¸caõ Orientada a Objeto com C++


232


size type find (const char * s, size type pos, size type n) const; Procura a primeira ocorrência da string s, de modo que a pesquisa inicia em pos e considera até n caracteres. size type find (const string & str, size type pos = 0) const; Procura a primeira ocorrência da cstring str, a pesquisa inicia em pos. const char* c str(); Retorna uma string constante no estilo de C (uma cstring). A palavra-chave const no in´ıcio da declara¸caõ de um método indica que este método retorna um objeto constante (const char*). Na Listagem 9.7, alguns métodos da classe string s˜ ao testados. Uma descri¸caõ detalhada da classe string é apresentada no Cap´ıtulo 24 – A classe . Listing 9.7: Exemplo preliminar de uso da classe de C++. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# include < iostream > # include < string > int main () { // Cria string com nome s1 std :: string s1 ; s1 = " Oi , tudo bem " ; // Cria string com nome s2 e a r m a z e n a " C ++ ´ e legal " std :: string s2 ( " C ++ e ´ legal " ) ; // Cria string com nome s3 e i n i c i a l i z a com " demais " std :: string s3 = " demais " ; // Tamanho , c a p a c i d a d e e d i m e n s ~ ao std :: cout << " \ ns1 . size () = " << " \ ns1 . capacity () = " << " \ ns1 . max_size () = "

m´ a xima da string s1 << s1 . size () << s1 . capacity () << s1 . max_size () << std :: endl ;

// R e t o r n a true se s1 e s t i v e r vazia if ( s1 . empty () ) std :: cout << " A std :: string s1 esta vazia " << std :: endl ; // C o n c a t e n a ¸ c~ ao s1 += s2 + s3 ; std :: cout << " Ap´ o s s1 += s2 + s3 ; \ ns1 = " << s1 << " \ ns2 = " << s2 << " \ ns3 = " << s3 << std :: endl ; return 0; }

s1 . size () = 12 s1 . capacity () = 12 s1 . max_size () = 4 6 1 1 6 8 6 0 1 8 4 2 7 3 8 7 8 9 7 Ap´ o s s1 += s2 + s3 ; s1 = Oi , tudo bem C ++ e ´ legal demais s2 = C ++ e ´ legal s3 = demais




9.4.2

233

Introdu¸ c˜ ao ` a STL e ` a classe

A STL, ou Standard Template Library, é uma biblioteca de objetos avan¸cada que foi desenvolvida utilizando os mais modernos conceitos da programa¸caõ orientada a objeto em C++. Todo desenvolvimento da STL foi acompanhado e aprovado pelo comitê de padroniza¸caõ do C++, o ANSI C++ (veja Se¸caõ 7.3), sendo parte integrante das distribui¸co˜es-padr˜ ao de C++. Entre as caracter´ısticas da STL destacam-se: • N˜ ao utiliza polimorfismo em fun¸caõ do desempenho. • Utiliza extensivamente os templates (veremos os templates no Cap´ıtulo 27 – Templates). A STL é constru´ıda com base em três conceitos (Se¸caõ 31.1.2): • Containers – objeto utilizado para armazenar grupos de objetos (como ). • Iteradores – objetos utilizados para percorrer o container (são ponteiros inteligentes). • Programa¸ c˜ ao gen´ erica – conjunto de fun¸co˜es genéricas que manipulam os containers utilizando os iteradores. A STL é apresentada em detalhes na Parte III deste livro. No exemplo da Listagem 9.8 você ver´ a a utiliza¸caõ da classe , uma classe extremamente u ´ til disponibilizada pela STL. Mas antes de discutirmos o exemplo, vamos apresentar alguns conceitos b´ asicos de . Um é um tipo de container em que os dados est˜ ao armazenados de forma seq¨ uêncial; funciona como um vetor no estilo de C (Se¸caõ 9.3.1), permitindo acesso aleat´ orio (veja agora as Figuras 32.1 e 31.2). O container tem r´ apida inser¸caõ de objetos no final do vetor e lenta no meio. Como em vetores comuns de C, n˜ ao verifica os ´ındices. Isto significa que se o vetor tem dez casas, podemos acessar de v[0] até v[9]. N˜ ao podemos acessar v[10]. O Acesso a v[10] provoca um acesso de mem´ oria ilegal, e o programa pode travar/terminar (veremos exemplos de bugs na Listagem ??). Veja no exemplo a seguir como criar e usar um . Para usar um container do tipo , inclua o arquivo de cabe¸calho . Observe que, como criei objetos do tipo , posso acessar os métodos da classe, no caso, o método v.size() retorna o n´ umero de elementos do container. Exemplo: #include int main() { // Cria um vetor para armazenar n´ umeros inteiros // v1 tem tamanho zero. std::vector v1(); // Cria um vetor de inteiros, com 15 elementos, e nome v2 std::vector v2(15); // Cria um vetor de floats com 16 elementos todos iguais a 3.55 std::vector v3(16,3.55); std::cout < < "\nn´ umero de elementos do container =" < < v3.size() < < "\ncapacidade do container =" < < v3.capacity() < < "\no vetor esta vazio? " < < v3.empty() < < std::endl; return 0; } Programa¸caõ Orientada a Objeto com C++


234


Os métodos size(), reserve(), clear(), empty() e erase(), brevemente descritos na Se¸caõ 9.4.1, s˜ ao válidos para . Veja a seguir outros métodos u ´ teis de . void push back(const T& x); Insere uma c´ opia do objeto x no final do vetor (no fim do container). void pop back(); Remove o u ´ ltimo elemento do vetor (sem retorno). No exemplo da Listagem 9.8 é criado um vetor e solicitada ao usuário a entrada de dados. Cada novo valor que o usuário introduz é armazenado no vetor. Para encerrar a entrada de dados, o usu´ ario digita Ctrl + d no GNU/Linux e Mac OS X, e ctrl + z no Windows. Em seguida, o programa mostra os valores do vetor. Este exemplo inclui o uso do objeto container e os métodos push_back(), size(), empty(), clear(), front() e back(). Note ainda que como a classe é uma classe genérica (template), posso criar um vetor de inteiros, de n´ umeros flutuantes ou de outro tipo qualquer. Observe que para criar um usamos std::vector nomeVetor;, ou seja, é necess´ ario passar dentro de <> o tipo de objeto que o vetor vai armazenar. No exemplo estamos criando um vetor de inteiros, logo, usamos std::vector v;. O programa utiliza streams, como std::cout e std::cin, para sa´ıda e entrada de dados. O método good() pode ser acessado pela istream std::cin para verificar se a u ´ ltima entrada foi correta. Neste exemplo usamos if(std::cin.good()) para verificar se a entrada foi correta. Caso afirmativo, o objeto data é acrescentado no fim do vetor v com push_back(data);. O programa utiliza ainda estruturas de controle, como, do...while() (veja Se¸caõ D.3.3), e for (veja Se¸caõ 8.9.1, D.3.1). Listing 9.8: Exemplo preliminar de uso da classe da biblioteca STL. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# include < iostream > // Entrada e sa´ ı da # include < vector > // Classe de vetores , do container vector int main () // Defini¸ ca ~ o da fun¸ ca ~ o main () . { // Cria um vector , do tipo int , com nome v ( um vetor de inteiros ) // Como um vector pode armazenar objetos de diferente s tipos // ( char , int , float , CComplexo ) preciso informar dentro de <> // o tipo a ser manipulad o pelo vetor . std :: vector < int > v ; int data ; std :: cout << << << <<

" No DOS um Ctrl + z encerra a entrada de dados ." " No Mac um Ctrl + d encerra a entrada de dados ." " No GNU / Linux um Ctrl + d encerra a entrada de dados ." std :: endl ;

// Inicia la¸ c o do .. while , vai ser repetido enquanto a entrada for correta // note que do .. while e ´ executado pelo menos uma vez . do { std :: cout << "\ nEntre com o dado (" << v . size () << ") : "; std :: cin >> data ; std :: cin . get () ; if ( std :: cin . good () ) v . push_back ( data ) ; } while ( std :: cin . good () ) ;

// Se a entrada for v´ a lida // Adiciona data ao final do vetor v // Enquanto n~ a o digitar ctrl +d , ou ctrl + z



9.5. MANIPULANDO TIPOS 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

235

// Acessa partes do vetor usando m´ e todos front () e back () std :: cout << "\ nPrimeiro elemento do vetor = " << v . front () << "\ n ´ U ltimo elemento do vetor = " << v . back () << std :: endl ; // Usa um la¸ c o for para percorrer o vetor e mostrar os elementos na tela for ( int i = 0; i < v . size () ; i ++) std :: cout << " v [" << i << "]=" << v [ i ] << ’ ’; std :: cout << std :: endl ; if ( v . empty () ) // Verifica se o container esta vazio std :: cout << " O vetor est´ a vazio " << std :: endl ; else std :: cout << " O vetor n~ a o est´ a vazio " << std :: endl ; // Chama m´ e todo clear () , que apaga todos os objetos armazenad o s no vetor . v . clear () ; if ( v . empty () ) // Verifica se o container esta vazio std :: cout << " O vetor est´ a vazio " << std :: endl ; else std :: cout << " O vetor n~ a o est´ a vazio " << std :: endl ; std :: cin . get () ; return 0; } [ a n d r e @ m e r c u r i o Parte - II ] $ ./ a . out No DOS um ctrl + z encerra a entrada de dados . No Mac um ctrl + d encerra a entrada de dados . No Linux um ctrl + d encerra a entrada de dados . Entre Entre Entre Entre

com com com com

o o o o

dado dado dado dado

(0) :1 (1) :2 (2) :3 (3) :

Primeiro elemento do vetor = 1 ´ U ltimo elemento do vetor = 3 v [0]=1 v [1]=2 v [2]=3 O vetor n~ a o esta vazio O vetor esta vazio

Bem, vimos exemplos de como declarar, definir e utilizar os tipos predefinidos de C++, tipos do usuário e tipos definidos em bibliotecas externas (como a STL). Revise os exemplos e veja que a forma como se declara, define-se e se usa os três tipos de objetos é a mesma.

9.5

Manipulando tipos

Veremos a seguir um conjunto de conceitos de C++ utilizados para manipular os diferentes tipos de objeto de C++.

9.5.1

Criando apelidos – typedef

Um typedef nada mais é do que um apelido para uma declara¸caõ de um objeto. Veja a seguir o prot´ otipo para definir e usar um typedef. Prot´ otipo: typedef TipoConhecido Apelido; Apelido nomeObjeto; Programa¸caõ Orientada a Objeto com C++


236

9.5. MANIPULANDO TIPOS

No exemplo a seguir vamos criar um apelido para o tipo const float, com nome cfloat. Um objeto const e float poder´ a ser criado usando-se cfloat. Exemplo: typedef const float cfloat; cfloat objeto_float_constante; No próximo exemplo criaremos outros apelidos, como uint, uchar, ptrInt e schar. Exemplo: typedef unsigned int uint; typedef unsigned char uchar; typedef int* ptrInt; typedef signed char schar; A vantagem do uso de typedefs é que o programador precisa digitar um n´ umero menor de caracteres. A desvantagem é que – em alguns editores – perde-se o recurso de identifica¸caõ da sintaxe utilizada, conhecido como ”sintax highlighty” e dispon´ıvel na maioria dos editores de programas (como o emacs, gedit, kate).

9.5.2

Obtendo o tipo de tamanho – size_t()

O tipo size_t é um conceito genérico que representa a dimensão de um objeto (seu tama´ um tipo integral, sem sinal. O tipo efetivo de size_t depende da plataforma, sendo nho). E usualmente implementado como um int. Veja a seguir o prot´ otipo para uso de size_t(). Prot´ otipo: size t(objeto); Nota: de um modo geral size_t é formatado como unsigned int.

9.5.3

Obtendo o tamanho dos objetos – sizeof()

O operador sizeof() é utilizado para retornar o tamanho de um objeto em bytes. Quando aplicado a um vetor, retorna o n´ umero total de bytes do vetor. Pode ser aplicado ao ponteiro de uma fun¸caõ, mas n˜ ao se aplica a uma fun¸caõ. Veja a seguir o prot´ otipo de sizeof(): Prot´ otipo: sizeof(Tipo); Retorna o tamanho do Tipo. sizeof(obj); Retorna o tamanho do objeto. sizeof(Tipo*); Retorna o tamanho da classe do ponteiro. Na Listagem 9.9 mostramos na prática o uso de sizeof(). No in´ıcio da listagem, colocamos em coment´ ario as instru¸co˜es para compilar o programa para plataforma de 32 e 64 bits. Até aqui, todo programa que compilamos tinha o nome a.out. Podemos informar o nome do execut´ avel com a op¸caõ -o. Por exemplo, a linha g++ -m64 sizeof.cpp -o sizeof-64 Programa¸caõ Orientada a Objeto com C++



237

é usada para compilar o arquivo sizeof.cpp para plataforma de 64 bits (op¸caõ -m64), e solicita que o nome do execut´ avel seja sizeof-64 (op¸caõ -o sizeof-64). Observe que também geramos uma vers˜ ao de 32 bits do programa. Note as diferen¸cas no tamanho em bytes dos tipos predefinidos de C++: • 64 bits: – sizeof(long int) = 8 – sizeof(long double) = 16 – sizeof(&nome) = 8 • 32 bits: – sizeof(long int) = 4 – sizeof(long double) = 12 – sizeof(&nome) = 4 Note que a sa´ıda das listagens 9.3, 9.9 e as informa¸co˜es da Tabela 9.1 s˜ ao dependentes da plataforma (16, 32, 64 ou 128 bits). Isto significa que antes de usar os tipos predefinidos você deve verificar quais os valores assumidos pelos tipos predefinidos na sua plataforma. Listing 9.9: Usando sizeof(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// Vers~ a o 32 bits : g ++ - m32 sizeof . cpp -o sizeof -32 // Vers~ a o 64 bits : g ++ - m64 sizeof . cpp -o sizeof -64 # include < iostream > int main () { char nome [] = " Uma string de C ou cstring " ; std :: cout << " \ n sizeof ( bool ) = " << " \ n sizeof ( char ) = " << " \ n sizeof ( unsigned char ) = " << << << <<

"\n "\n "\n "\n

sizeof ( int ) = " sizeof ( unsigned int ) = " sizeof ( long int ) = " sizeof ( long long int ) = "

<< " \ n sizeof ( float ) = " << " \ n sizeof ( double ) = " << " \ n sizeof ( long double ) = "

<< " \ n sizeof (& nome ) = " << " \ n sizeof ( nome ) = " return 0;

<< sizeof ( bool ) << sizeof ( char ) << sizeof ( unsigned char ) << << << <<

sizeof sizeof sizeof sizeof

( int ) ( unsigned int ) ( long int ) ( long long int )

<< sizeof ( float ) << sizeof ( double ) << sizeof ( long double )

<< sizeof (& nome ) << sizeof ( nome ) << std :: endl ;

} [ b u e n o @ l d s c 0 5 Cap -09] $ g ++ - m64 sizeof . cpp -o sizeof -64 [ b u e n o @ l d s c 0 5 Cap -09] $ ./ sizeof -64 sizeof ( bool ) =1 sizeof ( char ) =1 sizeof ( unsigned char ) =1 sizeof ( int ) =4 sizeof ( unsigned int ) =4 sizeof ( long int ) =8 <--



238


sizeof ( long long int ) =8 sizeof ( float ) =4 sizeof ( double ) =8 sizeof ( long double ) =16 sizeof (& nome ) = 8 sizeof ( nome ) = 27

<-<--

[ b u e n o @ l d s c 0 5 Cap -09] $ g ++ - m32 sizeof . cpp - o sizeof -32 [ b u e n o @ l d s c 0 5 Cap -09] $ ./ sizeof -32 sizeof ( bool ) =1 sizeof ( char ) =1 sizeof ( unsigned char ) =1 sizeof ( int ) =4 sizeof ( unsigned int ) =4 sizeof ( long int ) =4 <-sizeof ( long long int ) =8 sizeof ( float ) =4 sizeof ( double ) =8 sizeof ( long double ) =12 <-sizeof (& nome ) = 4 <-sizeof ( nome ) = 27

Veja outro exemplo de uso de sizeof() na Listagem C.1. Nota: veremos como gerar programas multiplataforma no Cap´ıtulo ?? – Como montar um programa multiplataforma com as ferramentas da GNU. O compilador g++ é descrito em detalhes no Cap´ıtulo ?? – Compilando com gcc e g++.

9.5.4

Identificando o tipo do objeto – typeid()2

Para facilitar a verifica¸caõ do tipo de determinado objeto, foi desenvolvida a biblioteca . Essa biblioteca sobrecarrega os operadores == e != para comparar tipos do usuário. O operador typeid(), quando aplicado a um objeto, retorna o tipo do objeto. Veja a seguir o prot´ otipo para uso de typeid(). Prot´ otipo: typeid(objeto); typeid(objeto).name(); • Para uso do typeid() é preciso estar ativada a op¸caõ -RTTI – Run Time Type Identification do compilador. No compilador da GNU, o g++, esta op¸caõ já é ativada por padr˜ ao. Leia no manual de seu compilador como ativar esta op¸caõ. • Se você passar para a fun¸caõ typeid() um ponteiro (ou referência) com o valor 0, a fun¸caõ typeid() lan¸ca uma exce¸caõ do tipo bad_typeid. Veja no exemplo da Listagem 9.10 como verificar se dois objetos a e b s˜ ao do mesmo tipo. Observe que o método typeid() retorna um objeto com informa¸co˜es sobre o tipo, assim, você pode chamar o método name() para obter o nome da classe do objeto. Listing 9.10: Usando typeid(). 1 2 3 4 5 6

# include < iostream > # include < string > # include < typeinfo > // Uso de typeid () using namespace std ; class A {

public :

int a ; };



˜ FORTE DO C++ 9.6. VANTAGEM DA TIPIFICAC ¸ AO 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

class B : public A {

public :

class K {

int k ; };

int { A B K

public :

239

int b ; };

main () a; b; k;

// Cria objeto do tipo A com nome a // Cria objeto do tipo B com nome b // Cria objeto do tipo K com nome k

cout << << << <<

" \ ntypeid ( a ) " \ ntypeid ( a ) " \ ntypeid ( a ) " \ ntypeid ( b )

== == == ==

typeid ( a ) -> " typeid ( b ) -> " typeid ( k ) -> " typeid ( k ) -> "

<< << << <<

( typeid ( typeid ( typeid ( typeid

(a) (a) (a) (b)

== == == ==

typeid typeid typeid typeid

(a)) (b)) (k)) (k))

<< " \ ntypeid ( a ) . name () ->" << ( typeid ( a ) . name () ) << " \ ntypeid ( b ) . name () ->" << ( typeid ( b ) . name () ) << " \ ntypeid ( k ) . name () ->" << ( typeid ( k ) . name () ) << endl ; int o b j e t o I n t e i r o = 3; string n o m e O b j e t o I n t e i r o = typeid ( o b j e t o I n t e i r o ) . name () ; cout << " nomeObjetoI nt e ir o - > " << n o m e O b j e t o I n t e i r o << endl ; double o b j e t o D o u b l e = 3; string n o m e O b j e t o D o u b l e = typeid ( o b j e t o D o u b l e ) . name () ; cout << " nomeObjetoDo ub le - > " << n o m e O b j e t o D o u b l e << endl ; return 0; } typeid ( a ) == typeid ( a ) - >1 typeid ( a ) == typeid ( b ) - >0 typeid ( a ) == typeid ( k ) - >0 typeid ( b ) == typeid ( k ) - >0 typeid ( a ) . name () - >1 A typeid ( b ) . name () - >1 B typeid ( k ) . name () - >1 K nomeObjetoIn te i ro - > i nomeObjetoDou bl e - > d

9.6

Vantagem da tipifica¸c˜ ao forte do C++

A tipifica¸caõ forte obriga o programador a tomar mais cuidado na declara¸caõ, defini¸caõ e utiliza¸caõ dos objetos, atributos e métodos. Em troca, tem uma garantia maior de que o c´ odigo n˜ ao apresenta problemas, pois, com a tipifica¸caõ forte, o compilador pode encontrar mais facilmente os erros do programa.

9.7

Senten¸cas para tipos

• Um tipo do usu´ ario, ou um tipo de uma biblioteca externa, estar´ a bem definido se puder ser utilizado da mesma forma que um tipo predefinido de C++. • Em uma plataforma de 32 bits, o tipo float tem 32 bits, double tem 64 bits e long double tem 96 bits. Note que o tipo long double possui 12 bytes de comprimento e é exatamente assim que o processador 80 x 87 trabalha com n´ umeros em pontos flutuantes. Dessa forma, pode-se passar um objeto do tipo long double diretamente para programas em assembler. Programa¸caõ Orientada a Objeto com C++



240

• O compilador g++ (descrito no Cap´ıtulo ?? – Compilando com gcc e g++) suporta o tipo long long, que representa um inteiro de 64 bits. • A convers˜ ao de tipos é discutida no Cap´ıtulo 25 – Convers˜ oes.

9.8


Neste cap´ıtulo aprendemos que a linguagem C++ é altamente prototipada. Aprendemos a criar e usar objetos predefinidos de C++ (como int e float). Vimos que os tipos predefinidos podem ser do tipo inteiro (char, short int, int, long int) ou flutuantes (float, double, long double). Os mesmos podem ser explicitamente indicados no c´ odigo com uso de sufixos, como em 7.45f (float) ou 89LL (long long int). Aprendemos a usar o arquivo de cabe¸calho e o template numeric_limits para obter informa¸co˜es numéricas sobre os tipos predefinidos. Vimos exemplos preliminares que mostram como proceder para criar tipos do usuário e a utilizá-los da mesma forma que os tipos predefinidos de C++. Vimos os vetores no estilo de C, uma introdu¸caõ às estruturas, às uniões, às enumera¸co˜es e às classes, aprendendo a criar tipos do usu´ ario (tipos do programador). Criamos uma estrutura SPessoa, uma união UPropriedade, uma enumera¸caõ EDia e uma classe CComplexo. Aprendemos os conceitos b´ asicos da classe e seu uso para manipular objetos strings em C++. Também aprendemos a utilizar um objeto da STL. O método push_back(); é usado para adicionar elementos no final do vetor. O método size(); retorna o tamanho do vetor. O método empty(); retorna true se o vetor estiver vazio e false se estiver com algum elemento. O método clear(); é utilizado para zerar o vetor (apagar todos os elementos). Vimos ainda conceitos como typedef para criar apelidos, typeid() para verificar o tipo do objeto, e sizeof() para obter o tamanho dos objetos. Nos próximos cap´ıtulos descreveremos, passo a passo, como criar nossas próprias classes (tipos do usuário) e como utilizar em detalhes os containers da STL.

9.9

Exerc´ıcios

1. Quais s˜ ao os tipos predefinidos de C++ e seus respectivos valores m´ınimos, máximos? 2. Se vou trabalhar com uma matriz em que os valores variam de -100 a +100, qual tipo devo utilizar? 3. Por que devo tomar cuidado com unsigned? 4. Modifique a Listagem 9.1 acrescentando sa´ıda para tela. 5. Modifique a Listagem 9.2, troque int por char e veja os resultados. 6. Compile e rode a Listagem 9.3 em computadores de 32 e 64 bits. Verifique as diferen¸cas nas sa´ıdas. 7. Modifique a Listagem 9.4, acrescentando novas vari´ aveis na estrutura criada. 8. Documentar a Listagem 9.4, descrevendo o que ocorre a cada linha. 9. Modifique a Listagem 9.5, criando uma uni˜ ao de tipos diferentes. Programa¸caõ Orientada a Objeto com C++


9.9. EXERCÍCIOS

241

10. Implementeexemplo que utilize enumera¸co˜es (Se¸caõ 9.3.4). 11. Modifique a Listagem 9.7, acrescentando o uso de find(), reserve(), substr(), clear() e replace(). 12. Modifique a Listagem 9.8, acrescentando o uso de erase(), pop_back() e clear(). 13. A Listagem 9.8 apresenta um trecho de c´ odigo repetido. Monte uma fun¸caõ externa para tratar esse trecho de c´ odigo. 14. Compare os métodos disponibilizados para e para . 15. Compile e rode a Listagem 9.9, em um computador 32 bits, e anoteos resultados. Repita o procedimento para um computador de 64 bits. 16. Tente modificar a Listagem 9.6. Tente acrescentar um operador de subtra¸caõ -. 17. Na Listagem 9.2 explique porque foi poss´ıvel criar os n´ umeros x, y, z duas vezes dentro de main()? 18. Se você tiver curiosidade, pode ler antecipadamente a Se¸caõ 32.1, que descreve o container .



242


9.9. EXERCÍCIOS


Cap´ıtulo 10

Namespace Vimos na se¸caõ 6.2.2 os conceitos de assuntos e pacotes. Veremos, ent˜ ao, que os mesmos podem ser implementados em C++ utilizando-se o conceito de namespace. Para isso, estudaremos o que é um namespace (Se¸caõ 10.1) e como usar o espa¸co de nomes da biblioteca-padr˜ ao de C++ (Se¸caõ 10.2). Em seguida, mostraremos como usar a palavra-chave using para liberar o acesso a determinado objeto (Se¸caõ 10.3), como definir e utilizar um espa¸co de nomes para criar pacotes (Se¸caõ 10.4) e como usar um namespace anˆ onimo (Se¸caõ 10.5). Veremos ainda o uso avan¸cado dos namespaces (Se¸caõ 10.6), como compor namespaces (Se¸caõ 10.6.1), como criar namespaces aninhados (Se¸caõ 10.6.2) e como usar vari´ aveis est´ aticas em um namespace (Se¸caõ 10.6.3).

10.1

O que ´ e um namespace?

Vimos na Se¸caõ 6.2.2 que um pacote é um conjunto de classes mais fortemente relacionadas entre si, e que essas classes costumam fazer parte do mesmo assunto. Usualmente C++ usa o conceito de namespace para empacotar grupos de classes. Como o próprio nome diz, namespace significa espa¸co para nomes. Um namespace é um espa¸co utilizado para declarar vari´ aveis, fun¸co˜es, classes, uniões, estruturas, enumera¸co˜es etc. Um namespace define um escopo. Quando você monta seu programa utilizando bibliotecas externas, podem ocorrer duplica¸co˜es de nomes, isto é, um objeto definido em uma das bibliotecas externas pode ter o mesmo nome de um objeto definido por você. Por exemplo: você criou as fun¸co˜es min() e max(), as quais retornam o menor e o maior valor de um vetor, mas a STL j´ a possui essas fun¸co˜es. Desta forma, ao chamar a fun¸caõ min(), o compilador n˜ ao sabe qual fun¸caõ min() você quer chamar – a que você definiu ou a da STL? Solucionar o problema da duplica¸caõ de nomes pode ser complexo, pois, se esses nomes pertencerem a bibliotecas externas, você precisará contactar os desenvolvedores dessas bibliotecas para resolver os conflitos, ou renomear seus objetos e fun¸co˜es. Veremos a seguir como usar o namespace padr˜ ao de C++ e, na Se¸caõ 10.4, como definir um namespace. 243

244

10.2

˜ – STD:: 10.2. UTILIZANDO O ESPACO ¸ DE NOMES DA BIBLIOTECA-PADRAO

Utilizando o espa¸co de nomes da biblioteca-padr˜ ao – std::

Para utilizar os objetos da biblioteca-padr˜ ao de C++ é preciso incluir a palavra-chave std e, em seguida, o operador de resolu¸caõ de escopo ::. Veja o prot´ otipo. Prot´ otipo: // Para usar uma fun¸ca õ da std std::nomeFuncao(); // Para usar um objeto da std std::nomeObjeto; // Para chamar uma fun¸ca õ da std com parˆ ametros da std std::nomeFuncao(std::nomeParˆ ametro); Nas listagens de c´ odigo j´ a apresentadas, j´ a utilizamos std::cout, std::cin.get() e std::endl.

10.3

Mudando escopo com using

A palavra-chave using é utilizada para mudar o escopo de uma vari´ avel, um atributo, um objeto, uma fun¸caõ ou um método. De um modo geral, using pode ser utilizado para: • Liberar o uso de um objeto de um namespace para uso no escopo local. No exemplo a seguir liberamos apenas o uso de cout. Exemplo: using std::cout; cout < < "oi tudo bem" < < std::endl; • Liberar o acesso de fun¸co˜es de escopo diferente no escopo local. No exemplo a seguir liberamos o uso da fun¸caõ abort(), da biblioteca-padr˜ ao de C. Veja exemplo da Listagem 10.2. Exemplo: #include using std::abort; // Torna a fun¸ c~ ao abort() acess´ ıvel • Liberar o uso de todas as classes, objetos e fun¸co˜es declaradas dentro de um namespace para uso no escopo local. No exemplo a seguir liberamos todos os objetos, fun¸co˜es e classes da std:: para uso local. Exemplo: using namespace std; int x = 3; cout < < " Entre com x : "; cin > > x; cin.get(); cout < < " x = " < < x < < endl; • Compor namespaces. Veremos exemplo na Se¸caõ 10.6.1. • 2 Mudar a visibilidade (p´ ublica, protegida ou privada) dos membros de uma classe em heran¸cas (Se¸caõ 17.5). Programa¸caõ Orientada a Objeto com C++


´ 10.4. PROTOTIPO PARA DECLARAR E DEFINIR UM NAMESPACE

10.4

245

Prot´ otipo para declarar e definir um namespace

Nesta se¸caõ veremos como criar um pacote utilizando o conceito de namespace. Veja o prot´ otipo. Observe que colocamos a palavra-chave namespace seguido do nome do namespace. Tudo que estiver dentro do bloco far´ a parte do namespace, do escopo do namespace. • Por conven¸caõ o nome de um namespace/pacote inicia com letra min´ uscula. Prot´ otipo: // Declara¸ca õ/defini¸ca õ do namespace namespace nomeNamespace { // Declara¸ca õ de vari´ avel/objeto Tipo nome; // Declara¸ca õ de fun¸ca õ retorno NomeFun¸ca õ (parˆ ametros); // Declara¸ca õ de classe class CNomeClasse { // Declara¸ca õ de atributo da classe Tipo nomeAtributo; // Declara¸ca õ de método da classe retorno NomeMétodo(parˆ ametros); }; // Fim da classe } // Fim do namespace // Definindo fun¸co ˜es de um namespace fora do namespace retorno nomeNamespace::NomeFun¸ca õ(parˆ ametros){...}; // Definindo métodos de um namespace fora do namespace retorno nomeNamespace::CNomeClasse::NomeMétodo(parˆ ametros){...}; Veja na Listagem 10.1 um exemplo de defini¸caõ e uso de um namespace. Observe que criamos três n´ umeros x: um global, x = 3, um dentro de main(), x = 2, e um dentro do namespace n1, x = 7. Também criamos dentro do namespace n1 o namespace n2. Dentro da fun¸caõ main() mostramos como acessar o x global e do namespace, e como chamar a fun¸caõ Saida(). Observe que dentro de main(), x se refere ao x de main() e, dentro da fun¸caõ Saida(), x se refere ao x do namespace. Ou seja, cada fun¸caõ acessa o objeto que est´ a no seu escopo. Listing 10.1: Definindo e usando um namespace. # include < iostream > int x = 3; namespace n1 { const int x = 7; void Saida () ; namespace n2 { int y = 4; } }

// // // // // // // // // //

Objeto x no escopo global Cria um bloco n a m e s p a c e com o nome n1 Inicio do bloco do n a m e s p a c e n1 Objeto x do n a m e s p a c e n1 Fun¸ c~ a o Saida () do n a m e s p a c e n1 Cria n a m e s p a c e n2 a n i n h a d o dentro de n1 Inicio do bloco do n a m e s p a c e n2 Objeto y do n a m e s p a c e n1 :: n2 Fim do bloco do n a m e s p a c e n2 Fim do bloco do n a m e s p a c e n1

int main () {

// Fun¸ c~ a o main ()



´ 10.4. PROTOTIPO PARA DECLARAR E DEFINIR UM NAMESPACE

246

std :: cout << " \ nFun¸ ca ~ o main () : " << std :: endl ; int x = 2; // Cria x no escopo de main () // U t i l i z a x = 2 std :: cout << " x = " << x << std :: endl ; // U t i l i z a x = 3 global std :: cout << " :: x = " << :: x << std :: endl ; // U t i l i z a x do n a m e s p a c e n1 , x = 7 std :: cout << " n1 :: x = " << n1 :: x << std :: endl ; // U t i l i z a y do n a m e s p a c e n1 :: n2 std :: cout << " n1 :: n2 :: y = " << n1 :: n2 :: y << std :: endl ; n1 :: Saida () ; // Chama fun¸ c~ a o Saida () do n a m e s p a c e n1 return 0; } // D e f i n i ¸ c~ a o da fun¸ c~ a o Saida () do n a m e s p a c e n1 void n1 :: Saida () { std :: cout << " \ nFun¸ ca ~ o Saida () do namespace n1 " << " \ nx = " << x // x do n a m e s p a c e << " \ n :: x = " << :: x // x global << " \ nn2 :: y = " << n2 :: y << std :: endl ; } Fun¸ ca ~ o main () : x = 2 :: x = 3 n1 :: x = 7 n1 :: n2 :: y = 4 Fun¸ ca ~ o Sa´ ı da () do namespace n1 x = 7 :: x = 3 n2 :: y = 4

O exemplo da Listagem 10.2 mostra o uso de using para colocar duas fun¸co˜es de diferentes escopos no escopo de main(). Quando chamamos F(2.33); (linha 25), é executada a fun¸caõ global (que recebe um int) e n˜ ao a do namespace. Isto ocorre poque a fun¸caõ F(double) do namespace n˜ ao est´ a no escopo da fun¸caõ global. Para colocar as duas fun¸co˜es no mesmo escopo usamos using. Quando compilamos um programa o compilador pode emitir mensagens de warning ou ”cuidado”, indicando que estamos utilizando algum recurso da linguagem de forma incorreta. Ao compilar a Listagem 10.2, aparece a mensagem de warning ao converter um float para int na linha 25. Listing 10.2: Usando using para colocar fun¸co˜es no mesmo escopo. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# include < iostream > void F ( int i ) // Fun¸ c~ a o global { std :: cout << " Global : void F ( int i ) " << std :: endl ; } namespace M e u N a m e s p a c e // Cria um n a m e s p a c e M e u N a m e s p a c e { // Fun¸ c~ a o F ( double ) do n a m e s p a c e M e u N a m e s p a c e . void F ( double d ) { std :: cout << " namespace M e u N a m e s p a c e : void F ( double d ) " << std :: endl ;} // Fun¸ c~ a o G () do n a m e s p a c e M e u N a m e s p a c e . void G () { std :: cout << " namespace M e u N a m e s p a c e : void G () " << std :: endl ; F (3) ;



ˆ 10.5. NAMESPACES ANONIMOS 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

247

} } // Cria um apelido , um s i n ^ o n i m o para M e u N a m e s p a c e com nome nm namespace mn = M e u N a m e s p a c e ; int main () { F (1) ; F (2.33) ; mn :: F (1) ; mn :: F (2.33) ; mn :: G () ;

using mn :: F ; using :: F ; F (1) ; F (2.33) ; return 0;

// // // // //

Chama Chama Chama Chama Chama

fun¸ c~ ao fun¸ c~ ao fun¸ c~ ao fun¸ c~ ao fun¸ c~ ao

F ( int ) global F ( int ) global F ( double ) do n a m e s p a c e F ( double ) do n a m e s p a c e G , que chama fun¸ c~ a o F do n a m e s p a c e

// // // // //

Posso c o l o c a r as f u n ¸ c~ o e s no escopo de main () Coloca mn :: F ( double ) no escopo de main () Coloca F ( int ) no escopo de main () Chama fun¸ c~ a o F ( int ) global Chama fun¸ c~ a o F ( double ) do n a m e s p a c e

} [ b u e n o @ l d s c 0 5 ] $ g ++ namespace . cpp namespace . cpp : In function ’ int main () ’: namespace . cpp :25: warning : passing ’ double ’ for argument 1 to ’ void F ( int ) ’ [ b u e n o @ l d s c 0 5 ] $ ./ a . out Global : void F ( int i ) Global : void F ( int i ) namespace N : void F ( double namespace N : void F ( double namespace N : void G () namespace N : void F ( double Global : void F ( int i ) namespace N : void F ( double

10.5

d) d) d) d)

Namespaces anˆ onimos

Um namespace pode ser anˆ onimo, isto é, sem nome. Neste caso, vari´ aveis, fun¸co˜es, objetos e classes definidas dentro do namespace est˜ ao no escopo em que o namespace é definido. No exemplo a seguir criamos um namespace anˆ onimo. Observe que a vari´ avel x pode ser acessada diretamente. Exemplo: namespace // Cria namespace an^ onimo { int x = 0; // Se comporta como uma vari´ avel global void f(); } int main() { cout < < x < < endl; // Acessa x do namespace an^ onimo diretamente } As vari´ aveis criadas dentro de um namespace anˆ onimo s´ o podem ser utilizadas no arquivo em que o namespace foi definido. Funciona da mesma maneira que vari´ aveis est´ aticas globais (veja Se¸caõ B.4). Programa¸caõ Orientada a Objeto com C++


2 10.6. NAMESPACES – USO AVANCADO ¸

248

Programadores de C costumam usar static para indicar que determinada vari´ avel tem escopo de arquivo. O mesmo pode ser feito com C++, mas é melhor usar um namespace anˆ onimo, porque este pode conter classes, enumera¸co˜es e templates, enquanto static suporta apenas fun¸co˜es e objetos [Lischner, 2003].

10.6

Namespaces – uso avan¸ cado2

Veremos nesta se¸caõ o uso avan¸cado dos namespaces: Como compor (Se¸caõ 10.6.1), como criar namespaces aninhados (Se¸caõ 10.6.2) e como usar vari´ aveis est´ aticas em um namespace (Se¸caõ 10.6.3).

10.6.1

Compondo namespace com using2

Você pode compor dois ou mais namespaces. No exemplo a seguir o namespace minhalib inclui os namespace lib1 e lib2. As linhas using namespace lib1; e using namespace lib2; fazem com que lib1 e lib2 fiquem no mesmo escopo da minhalib. Exemplo: // Compondo namespaces namespace lib1{...}; namespace lib2{...}; namespace minhalib { using namespace lib1; using namespace lib2; ... }

10.6.2

Namespace aninhado2

Namespaces podem ser aninhados (como classes aninhadas, veja Se¸caõ 11.5.4). Veja na Listagem 10.1 um exemplo.

10.6.3

Usando vari´ aveis est´ aticas em um namespace2

Vari´ aveis est´ aticas definidas em um namespace precisam ser definidas. Veja Listagem 10.3. Listing 10.3: Usando vari´ aveis est´ aticas em um namespace. // Uso de v a r i ´ avel est´ a t i c a em um n a m e s p a c e # include < iostream > namespace m { struct S { static int i ; }; } // Define o a t r i b u t o e s t ´ a t i c o i , da e s t r u t u r a S , do n a m e s p a c e m int m :: S :: i = 1; int main () { // usa a t r i b u t o e s t ´ a t i c o do n a m e s p a c e m , da e s t r u t u r a S std :: cout << m :: S :: i << std :: endl ; return 0; }



10.7. SENTENCAS ¸ PARA NAMESPACE

249

bash -3.1 $ g ++ namespace - e - static . cpp bash -3.1 $ ./ a . out 1

10.7

Senten¸cas para namespace

• Por conven¸caõ o nome de um pacote/namespace inicia com letra min´ uscula. • Se uma vari´ avel ou fun¸caõ é declarada com o mesmo nome de um namespace, ent˜ ao, a vari´ avel declarada oculta o namespace. O acesso ao namespace deve ser feito usando o operador de resolu¸caõ de escopo. • Fun¸co˜es definidas dentro do namespace s˜ ao vis´ıveis entre si (veja no exemplo da Listagem 10.2 as fun¸co˜es F() e G()). • Em arquivos de cabe¸calho (*.h) nunca utilize using namespace std;. Por exemplo: para acessar cout nos arquivos de cabe¸calho use std::cout. Isto se justifica, pois, se colocarmos using namespace std; no in´ıcio do arquivo que declara a classe, a inclus˜ ao de um objeto global com o mesmo nome de um objeto do namespace cria uma ambig¨ uidade. • Pode-se criar um sinˆ onimo para um namespace. No exemplo a seguir, ml é um apelido para Minha_lib_versao_x_y_z (veja Listagem 10.2): Exemplo: namespace ml = Minha_lib_versao_x_y_z; • Utilize um nome de namespace grande e depois crie um sinˆ onimo para ele. • Use namespace para grupos de classes que formam um assunto, classes que representam um conceito em comum. • A declara¸caõ using é transitiva, isto é, se o namespace A usa o namespace B, e o namespace B usa o namespace C, um nome acess´ıvel em A também é acess´ıvel em C, [Lischner, 2003]. • Um namespace pode ser definido dentro de outro namespace, mas n˜ ao pode ser definido dentro de um bloco (reveja Se¸caõ 10.6.2 e Listagem 10.1). • Um namespace pode ser criado sem um nome – namespace anˆ onimo (veja Se¸caõ 10.5). Exemplo: namespace {...} • Segundo [Lischner, 2003], namespaces de C++ s˜ ao semelhantes a namespaces de Java. A diferen¸ca é que em Java, duas classes do mesmo pacote (namespace) têm privilégios de acesso, o que n˜ ao ocorre em C++. • Quando declaramos uma classe dentro de um namespace, todos os atributos, métodos e operadores devem ser declarados dentro do mesmo namespace. • Um namespace n˜ ao tem custo computacional. • 2 A senten¸ca ”using namespace std;” é válida no escopo em que foi definida, e s´ o deve ser utilizada em programas pequenos. Programa¸caõ Orientada a Objeto com C++



250

10.8


Neste cap´ıtulo aprendemos que o conceito de namespace existe para resolver o problema da duplica¸caõ de nomes por meio da cria¸caõ de escopos adicionais. Vimos que podemos usar os objetos da biblioteca-padr˜ ao diretamente, basta incluir a declara¸caõ using namespace std; no in´ıcio do programa. Aprendemos a criar nossos próprios namespaces, de forma que podemos usar namespaces para criar o conceito de assunto/pacotes em C++. Aprendemos que um namespace é um escopo, e as fun¸co˜es, vari´ aveis e classes definidas dentro do namespace est˜ ao no escopo do namespace. A defini¸caõ do escopo e da visibilidade dos objetos em C++ ser´ a vista na Se¸caõ 11.2 e no Apêndice B.4. Vimos ainda que a palavra-chave using pode ser utilizada para colocar objetos e fun¸co˜es de diferentes escopos em um mesmo escopo. Aprendemos que podemos criar um namespace anˆ onimo, podemos compor namespaces e criar namespaces aninhados. No próximo cap´ıtulo, Cap´ıtulo 11 – Classe, veremos como implementar o conceito de classes em C++.

10.9

Exerc´ıcios

1. Diga com suas palavras o que é um namespace e quais suas vantagens. 2. Monte os diagramas UML para a Listagem 10.1, acrescentando os pacotes necess´ arios. 3. Modifique a Listagem 10.1, acrescentando um nome longo para n1 e n2, e, em seguida, definindo n1 e n2 como sinˆ onimos. 4. Acrescente o conceito de namespace nas listagens 9.1, 9.2 e 9.6. 5. Modifique a Listagem 10.2, acrescentando um namespace n3. 6. Adicione uma vari´ avel static float j na Listagem 10.3.



Cap´ıtulo 11

Classes Vimos, no Cap´ıtulo 3 – Conceitos b´ asicos de orienta¸caõ a objeto, que a classe é a unidade de ´ dentro da classe que declaramos os atributos, encapsulamento dos atributos e dos métodos. E os métodos e seus controles de acesso. Neste cap´ıtulo veremos o prot´ otipo para declarar e definir uma classe em C++ (Se¸caõ 11.1). Veremos como utilizar as palavras-chave public, protected e private para definir a visibilidade (acesso) dos atributos e métodos da classe (Se¸caõ 11.2), bem como a rela¸caõ entre classes e escopo (Se¸caõ 11.3) e o uso de diretrizes de pré-processador com classes (Se¸caõ 11.4). Veremos ainda o uso avan¸cado de classes (Se¸caõ 11.5), as classes abstratas (Se¸caõ 11.5.1), as classes de interface (Se¸caõ 11.5.2), o encapsulamento e a robustez de c´ odigo (Se¸caõ 11.5.3), as classes aninhadas (Se¸caõ 11.5.4), as classes do tipo POD (Se¸caõ 11.5.5) e as classes do tipo trivial (Se¸caõ 11.5.6).

11.1

Prot´ otipo para declarar e definir classes

Uma classe é um conjunto de atributos (vari´ aveis ou objetos) reunidos com um conjunto de métodos (fun¸co˜es). Os atributos e métodos inclu´ıdos na classe s˜ ao aqueles que fazem sentido à classe; s˜ ao chamados ainda de elementos da classe. • Quando você cria uma classe, est´ a definindo um novo tipo – trata-se de um tipo do usuário. Você deve incluir na documenta¸caõ do programa o conceito e a forma de uso do novo tipo. • Um mesmo nome n˜ ao pode ser dado a um método e a um atributo. • Para identificar as classes e seus relacionamentos, fa¸ca associa¸co˜es diretas com conceitos do mundo real. Veja exemplo a seguir: Exemplo: Uma classe edif´ ıcio, janela, porta etc. • Ao criar suas classes, dê a elas um formato simples. Isto pode ser feito dividindo uma classe grande e complexa em classes menores. • Crie classes pequenas para realizar tarefas pequenas. Note que o uso de classes extensas torna sua manuten¸caõ mais complexa. • A classe n˜ ao é um objeto, é uma descri¸caõ do objeto (defini¸caõ da forma e do conte´ udo do objeto). 251

252 11.2. ENCAPSULAMENTO EM C++ UTILIZANDO O ESPECIFICADOR DE ACESSO • A declara¸caõ de uma classe define um escopo, todos os membros da classe est˜ ao no escopo da classe. Adicionalmente, todos os membros de uma classe têm de ser declarados em seu interior. Veja a seguir o prot´ otipo para declara¸caõ e defini¸caõ de uma classe em C++. Verifique que existem diferentes tipos de atributos e de métodos. Ao lado do prot´ otipo, h´ a um coment´ ario informando a se¸caõ em que o mesmo ser´ a apresentado. Prot´ otipo: // Declara¸ca õ, diz que existe a classe class CNomeClasse; // Defini¸ca õ, inclui o corpo da classe class CNomeClasse { // Especificadores de acesso public: // Acesso p´ ublico, veja se¸ca õ 11.2 protected: // Acesso protegido, veja se¸ca õ 11.2 private: // Acesso privado, veja se¸ca õ 11.2 // Atributos Tipo nome; // Atributos de objeto, veja se¸ca õ 12.2 static Tipo nome; // Atributos de classe, est´ aticos - static , veja se¸ca õ 12.3, const Tipo nome; // Atributos constantes - const , veja se¸ca õ 12.4 mutable Tipo nome; // Atributos mutantes - mutable , veja se¸ca õ 12.5.1 volatile Tipo nome; // Atributos vol´ ateis - volatile , veja se¸ca õ 12.5.2 // Métodos Tipo Método(parˆ ametros); // Métodos normais, veja se¸ca õ 13.7 Tipo Método(parˆ ametros) const ; // Métodos constantes - const , veja se¸ca õ 13.8 static Tipo Método(parˆ ametros); // Métodos est´ aticos - static , veja se¸ca õ 13.9 inline Tipo Método(parˆ ametros); // Métodos em linha - inline , veja se¸ca õ 13.10 virtual Tipo Método(parˆ ametros); // Métodos virtuais - virtual , veja se¸ca õ 19.2 virtual Tipo Método(parˆ ametros)=0; // Métodos virtuais puros, veja se¸ca õ 19.4 }; // Encerra a defini¸ca õ da classe ´ importante observar a presen¸ca de (;) no final do bloco que declara a classe. E

11.2

Encapsulamento em C++ utilizando o especificador de acesso

Para a an´ alise orientada a objeto, encapsulamento é o ato de esconder do usuário informa¸co˜es que n˜ ao s˜ ao de seu interesse. Assim, o encapsulamento envolve a separa¸caõ dos elementos vis´ıveis de um objeto dos invis´ıveis. Reveja as se¸co˜es 3.1, 3.2 e a Figura 3.2. Lembre-se que a vantagem do uso do encapsulamento surge quando h´ a a necessidade de se modificar um programa ou biblioteca existente. Para implementar o conceito de encapsulamento (ou ocultamento de informa¸caõ), C++ oferece as palavras-chave public, protected e private. public Significa que o atributo ou método faz parte da interface do objeto, podendo ser acessado de qualquer local. Veremos exemplos nas listagens 13.1, 13.2, 13.3. Programa¸caõ Orientada a Objeto com C++


11.3. CLASSES E ESCOPO

253

protected Significa que o atributo ou método est´ a protegido de acesso externo. S´ o pode ser acessado pelos métodos da classe, pelos métodos das classes-derivadas (classes herdeiras) e por fun¸co˜es amigas – friend. Veremos exemplos na Listagem 13.5. private Significa que o atributo ou método s´ o pode ser acessado pelos métodos da classe (métodos internos da classe) e por fun¸co˜es amigas – friend. Veremos exemplos nas listagens 13.2, 13.3. Para aumentar o encapsulamento da classe, declare tudo como privado. S´ o deixe como p´ ublico o que for essencial e fizer parte da interface da classe. Evite atributos protegidos, uma vez que eles podem ser utilizados em diversas classes derivadas, sendo dif´ıcil identificar o impacto de mudan¸cas nestes atributos. A utiliza¸caõ de public, protected e private ser´ a esclarecida por meio dos exemplos e listagens apresentados ao longo do livro.

11.3

Classes e escopo

Vimos que um escopo é uma regi˜ ao de c´ odigo que contém declara¸co˜es, que cada declara¸caõ adiciona um nome ao escopo, e que o uso desses nomes deve ser resolvido pelo compilador. Conclui-se, ent˜ ao, que n˜ ao podemos ter dois nomes iguais no mesmo escopo, pois isso causa uma ambig¨ uidade. • Uma classe define um escopo. • Todo membro (atributo/método) declarado dentro da classe est´ a no escopo da classe. • Para acessar os atributos declarados em uma classe precisamos ter um objeto. • Vimos na Se¸caõ 11.2 que s´ o podemos acessar externamente os membros p´ ublicos da classe, ou seja, o membro deve ser vis´ıvel. • 2 Atributos de classe, isto é, atributos declarados com static pertencem à classe e n˜ ao ao objeto, podendo ser acessados sem um objeto se forem p´ ublicos. • 2 Uma fun¸caõ friend n˜ ao pertence ao escopo da classe. A palavra-chave friend apenas indica que a fun¸caõ é amiga. Veremos fun¸co˜es e métodos amigos no Cap´ıtulo 20 – Friend.

11.4

Classes e diretrizes de pr´ e-processador

Em nossos programas costumamos incluir algumas bibliotecas, como a . Se tivermos um programa com muitos arquivos, a biblioteca pode ser inclu´ıda mais de uma vez. Para evitar que a seja inclu´ıda mais de uma vez na mesma unidade de tradu¸caõ, no in´ıcio do arquivo est˜ ao presentes as seguintes diretrizes de préprocessador. Exemplo: #ifndef __IOSTREAM // In´ ıcio do bloco #ifndef #define __IOSTREAM // Seq¨ u^ encia da biblioteca.... Programa¸caõ Orientada a Objeto com C++


2 11.5. CLASSES – USO AVANCADO ¸

254 #include #include ... #endif

// Fim do bloco

As instru¸co˜es apresentadas realizam os seguintes passos: primeiro verificam se a vari´ avel __IOSTREAM j´ a foi definida; se ainda n˜ ao foi, ela é definida e, em seguida, as instru¸co˜es compilam a seq¨ uência da biblioteca. Se a vari´ avel __IOSTREAM já foi definida, todo o restante do bloco é pulado. Observe que com essas instru¸co˜es a ”Seq¨ uência da biblioteca....” s´ o é pré-processada uma u ´ nica vez. Da mesma forma, nossas próprias classes também devem utilizar as diretrizes de préprocesssador para evitar que a classe seja redefinida. Veja a seguir como implementar a classe CEndereco ilustrada na Figura 12.1. Observe que basta iniciar o arquivo com as linhas #ifndef CEndereco e #define CEndereco, e terminar o arquivo com a linha #endif. Exemplo: #ifndef __CEndereco #define __CEndereco #include class CEndereco { protected: int numero; string rua; public: int Numero(); string Rua(); }; #endif

11.5

// // // // // // //

In´ ıcio do bloco __CEndereco Define vari´ avel __CEndereco Classe string da biblioteca padr~ ao Cria classe CEndereco Controle de acesso Acesso protegido Atributos

// Acesso p´ ublico // M´ etodos

// Fim do bloco __CEndereco

Classes – Uso avan¸ cado2

Veremos nesta se¸caõ o uso avan¸cado de classes em C++. Os conceitos aqui apresentados têm uma rela¸caõ direta com o conceito de métodos virtuais, que ser´ a apresentado na Se¸caõ 19.2 e com o conceito de polimorfismo, que ser´ a apresentado na Se¸caõ 19.3.

11.5.1

Classes abstratas2

Métodos virtuais s˜ ao métodos que têm seu endere¸co definido dinamicamente, ou seja, durante a execu¸caõ do programa. Métodos virtuais puros s˜ ao métodos que s˜ ao declarados como virtuais na classe-base e que n˜ ao s˜ ao implementados (n˜ ao s˜ ao definidos). Eles ser˜ ao descritos na Se¸caõ 19.4. Uma classe que contém métodos virtuais n˜ ao implementados é uma classe abstrata, n˜ ao podendo ser utilizada para criar objetos. Exemplo: class CNomeClasse { // M´ etodo virtual puro virtual void NomeM´ etodo(parametro) = 0; }; Programa¸caõ Orientada a Objeto com C++



255

Se n˜ ao podemos criar um objeto, ent˜ ao para que serve uma classe abstrata? Embora n˜ ao possamos criar objetos, podemos criar ponteiros para classes abstratas. Normalmente usamos um ponteiro para classe-base da hierarquia para acessar os diferentes objetos criados. Veremos exemplos na Se¸caõ 19.3.

11.5.2

Classes de interface2

Segundo [Parga, 2006], ”Um dos desafios de se trabalhar com POO é criar uma rela¸caõ um-para-um entre os elementos do problema do mundo real e os elementos da solu¸caõ onde est´ a sendo modelado o problema”, ou seja, o desafio é identificar com clareza os objetos ”reais”, dando-lhes limites claros, além de definir de forma simples sua interface de acesso. O mesmo autor afirma ainda que ”a interface s´ o estabelece que pedidos possam ser feitos a um objeto. A codifica¸caõ necess´ aria para satisfazer cada pedido deve estar definida na classe que implementa essa interface”. Esta segunda frase destaca que podemos ter duas classes: a primeira descreve a interface de acesso (é uma classe abstrata); a segunda implementa de fato as funcionalidades da classe. Em C++ você pode criar uma classe de interface, basta que ela s´ o tenha métodos p´ ublicos vazios. Observe que a classe n˜ ao tem atributos, apenas métodos que informam a forma de acesso à classe. Veja a seguir um exemplo de classe de interface. Coloquei a inicial I para indicar que a classe é uma classe de interface. Lembre-se que usamos a inicial C para indicar que se trata de uma classe do usu´ ario. Observe que usamos o conceito de métodos virtuais puros, veja Se¸caõ 19.2. class ICPessoa { public: // Acesso p´ ublico ICPessoa(){}; virtual ~ICPessoa(){}; virtual std::string Nome() virtual int Idade() virtual std::string Sexo() virtual CEndereco Endereco() };

const const const const

= = = =

0; 0; 0; 0;

Note a diferen¸ca entre classe abstrata e classe de interface. A classe abstrata pode ter atributos e métodos normais; j´ a a classe de interface s´ o deve ter métodos p´ ublicos.

11.5.3

Classes encapsulamento e robustes de c´ odigo2

O conceito de encapsulamento é essencial ao desenvolvimento de softwares robustos e seguros e envolve aspectos como: • ocultar os membros internos; • garantir que altera¸co˜es nos membros internos n˜ ao afetem a interface do objeto; • proteger os membros internos de acessos n˜ ao-autorizados. Outro mecanismo u ´ til para garantir maior robustez é definir a interface da classe apenas com métodos normais, n˜ ao virtuais. Esta técnica é conhecida como NVI – NonVirtual Interface, [Sutter, 2006]. Os mesmos chamariam métodos virtuais, veja o exemplo: Programa¸caõ Orientada a Objeto com C++



256

Exemplo: class CNome{ public: // M´ etodos p´ ublicos n~ ao virtuais void M1() { return M1_v(); }; void M2() { return M2_v(); }; private: virtual void M1_v(); // M´ etodos privados virtuais virtual void M2_v(); }; Isto garante maior robustez, pois a interface permanece fixa, enquanto podemos redeclarar e redefinir os métodos virtuais mais a ` vontade. Por exemplo, poder´ıamos reescrever a classe da seguinte forma: Exemplo: class CNome{ public: void M1() { M1_v_preProcessamento(); M1_v(); M1_v_posProcessamento(); }; void M2() { M2_v(); }; private: virtual void M1_v_preProcessamento(); virtual void M1_v(); virtual void M1_v_posProcessamento(); virtual void M2_v(); }; Note que a interface de M1() n˜ ao foi mudada, mas sua implementa¸caõ sim. Inclu´ımos os métodos virtuais virtual void M1_v_preProcessamento(); e virtual void M1_v_posProcessamento();.

11.5.4

Classes aninhadas3

Podemos declarar classes aninhadas (classes dentro de classes). Veja no exemplo a seguir que a classe CNomeClasse tem uma classe aninhada CNomeClasseAninhada. Veja exemplo na Listagem G.1. Exemplo: class CNomeClasse { public: int x; // Classe aninhada class CNomeClasseAninhada { int y; }; }; Nota: o comportamento de classes aninhadas em C++ é diferente do encontrado em Java. Uma classe aninhada em C++ é como um membro static em Java. Programa¸caõ Orientada a Objeto com C++



11.5.5

257

Classes do tipo POD3

Um POD – Plain Old Data – é um tipo especial de classe. Veja a seguir suas caracter´ısticas: • Uma classe POD é compat´ıvel com estruturas de C. • Todos os seus membros de dados s˜ ao armazenados de forma cont´ıgua. • Uma classe POD pode ser copiada usando-se fun¸co˜es da biblioteca-padr˜ ao de C, como memcpy(). A vantagem de uma classe POD é que a mesma pode ser manipulada como uma estrutura. Por exemplo, o uso de memcpy() garante melhor desempenho na c´ opia de uma estrutura. Segundo [Lischner, 2003] uma classe do tipo POD n˜ ao pode ter: • construtores e destrutores; • operador de c´ opia; • métodos virtuais; • classes-base; • membros privados ou protegidos n˜ ao est´ aticos; • membros de dados n˜ ao est´ aticos que s˜ ao referências.

11.5.6

Classes do tipo trivial3

Uma classe trivial é um tipo especial de classe. Segundo [Lischner, 2003] uma classe trivial n˜ ao pode ter: • construtores e destrutores; • operador de c´ opia; • métodos virtuais; • classes-base. Veja a seguir outras caracter´ısticas de uma classe trivial: • Todas as classes-base de uma classe trivial devem ser triviais. • Todos os membros n˜ ao est´ aticos devem ser triviais. As classes triviais s˜ ao importantes porque uniões s´ o podem ter membros triviais. Veremos uniões na Se¸caõ G.2. Programa¸caõ Orientada a Objeto com C++


258

11.6

11.6. SENTENCAS ¸ PARA CLASSES

Senten¸cas para classes

• Os atributos que compõem a classe podem ser de diferentes tipos. No exemplo, da classe CEndereco, utilizam-se uma string e um int. • Costumo adotar o seguinte padr˜ ao para classes: primeiro coloco os atributos e métodos p´ ublicos, depois os protegidos e, por fim, os privados. • Linguagens como Java e C# têm o conceito de classe de interface. • 2 Uma classe-base imediata é chamada de clase-base direta. Uma classe-base n˜ ao imediata é chamada ainda de classe ancestral. • 2 Note que fun¸co˜es friend n˜ ao est˜ ao no escopo da classe. • 2 Uma classe com pelo menos um método virtual é uma classe polim´ orfica. • 2 Uma classe A qualquer n˜ ao pode conter um objeto do tipo A, mas somente um ponteiro para A. Antes do final da defini¸caõ de uma classe, seu nome s´ o pode ser utilizado se o tamanho da classe n˜ ao for necess´ ario. • 2 Lembre-se: uma classe do usu´ ario é um tipo novo e deve ter todos os elementos esperados, isto é, construtor/destrutor, construtor de c´ opia, operadores, métodos de convers˜ ao, atributos e métodos. • 2 Uma classe com atributos const ou referências têm de ter obrigatoriamente um construtor para inicializar esses atributos. Veja Se¸caõ 16.1. • 2 Se um método tem inicializadores, isto é, atributos com valores predefinidos, estes devem ficar vis´ıveis na classe (arquivo *.h), pois quem utiliza a classe olha o arquivo de cabe¸calho (*.h) e nem sempre tem acesso ao arquivo de implementa¸caõ (*.cpp). Veja Se¸caõ 13.6.4. • 2 Note que uma classe de interface também pode ser implementada utilizando heran¸cam´ ultipla. • 3 Como um membro privado participa da pesquisa de resolu¸caõ do método a ser executado, é vis´ıvel nos arquivos em que foi inclu´ıdo, mas n˜ ao pode ser chamado porque é privado, de modo que algumas chamadas podem se tornar inválidas ou amb´ıguas, mesmo que o método nunca possa ser executado [Sutter, 2006]. Veja Se¸caõ 14.3.1. • 3 Podemos ter classes locais, isto é, classes declaradas dentro de blocos, mas elas têm as seguintes restri¸co˜es [Lischner, 2003]: – N˜ ao podem ter membros est´ aticos. – Todos os métodos internos devem ser inline. – Uma classe local n˜ ao pode ser utilizada como argumento de um template. • 3 O polimorfirmo em tempo de compila¸caõ utilizando templates possibilita a quebra do conceito de encapsulamento e, portanto, deve ser evitado. Programa¸caõ Orientada a Objeto com C++



11.7

259


Vimos e revimos alguns conceitos b´ asicos sobre classes e o prot´ otipo para declarar e definir uma classe em C++. Aprendemos a definir a visibilidade (encapsulamento) com o uso das palavras-chave public, protected e private. Vimos que C++ usa métodos p´ ublicos e abstratos para criar classes de interface. Lembre-se: os métodos abstratos s˜ ao declarados mas n˜ ao definidos. Aprendemos que os membros da classe est˜ ao no escopo da classe. Aprendemos a evitar que um mesmo bloco com defini¸caõ de um namespace ou classe seja compilado duas vezes usando as diretrizes de pré-processador #ifndef, #define e #endif. Aprendemos a diferenciar classes abstratas de classes de interface. Aprendemos que a defini¸caõ da interface de uma classe é extremamente importante, é um dos momentos cruciais no design de um sistema. Isto significa que deve-se dispender um bom tempo de an´ alise com a correta defini¸caõ da interface. Isto se justifica, pois a redefini¸caõ da interface tem um custo elevado. Aprendemos a aumentar o encapsulamento das classes usando a técnica NVI (Se¸caõ 11.5.3). Finalmente, vimos como criar classes aninhadas, classes do tipo POD e classes triviais.

11.8

Exerc´ıcios

1. Abra um editor UML (como umbrello ou vp), monte um diagrama de classes e, em seguida, gere o c´ odigo. Abra os arquivos gerados em um editor de texto e verifique se os mesmos seguem o prot´ otipo definido neste cap´ıtulo (Se¸caõ 11.1). 2. Baixe alguns programas em C++ na internet e veja se os mesmos seguem o prot´ otipo definido neste cap´ıtulo (Se¸caõ 11.1). Observe que cada autor costuma ter um estilo um pouco diferente, mas a estrutura geral é a mesma. 3. Dê uma olhada no estilo dos arquivos da biblioteca-padr˜ ao (no GNU/Linux est˜ ao em /usr/include/c++/vers˜ ao, no Windows est˜ ao instalados no diret´ orio do pacote de desenvolvimento). 4. Dê exemplos de objetos com atributos e métodos que devem ser p´ ublicos. Em seguida, indique atributos protegidos e privados. 5. Exponha com suas palavras o que é uma classe de interface. 6. Para que servem as classes triviais? 7. Neste momento você pode reler a Se¸caõ 6.11.3, senten¸cas para conseguir o reuso de classes. 8. Explique com suas palavras como funciona o escopo em uma classe. 9. Para que servem as classes abstratas? E as classes de interface? 10. O que s˜ ao classes aninhadas? 11. O que significa POD? E NVI?



260

11.8. EXERCÍCIOS



Cap´ıtulo 12

Atributos Neste momento você pode reler a Se¸caõ 3.4, a qual apresenta o conceito de atributo. Veremos neste cap´ıtulo o prot´ otipo para declarar e definir atributos em C++ (Se¸caõ 12.1), o que s˜ ao atributos de objeto (Se¸caõ 12.2), atributos de classe – static (Se¸caõ 12.3) e os atributos constantes – const (Se¸caõ 12.4). Veremos ainda o uso avan¸cado dos atributos (Se¸caõ 12.5), os atributos mutantes – mutable (Se¸caõ 12.5.1) e os atributos vol´ ateis – volatile (Se¸caõ 12.5.2). Nota: exemplos completos de classes com atributos e métodos serão apresentados no Cap´ıtulo 13 – Métodos.

12.1

Prot´ otipo para declarar e definir atributos

Em C++ um atributo pode ser um tipo predefinido da linguagem, um tipo definido pelo programador ou um tipo definido em uma biblioteca externa, como a STL (veja Cap´ıtulo 9 – Tipos). Veja a seguir o prot´ otipo para declara¸caõ de um atributo normal, de um atributo de classe (ou est´ atico) e de atributos const, mutable e volatile. Ao lado do prot´ otipo est´ a o n´ umero da se¸caõ em que o mesmo ser´ a apresentado. Prot´ otipo: // Arquivo CNomeClasse.h class CNomeClasse { // Atributos Tipo nome; // Atributos de objeto, veja se¸ca õ 12.2 static Tipo nome; // Atributos de classe, est´ aticos - static , veja se¸ca õ 12.3, const Tipo nome; // Atributos constantes - const , veja se¸ca õ 12.4 mutable Tipo nome; // Atributos mutantes - mutable , veja se¸ca õ 12.5.1 volatile Tipo nome; // Atributos vol´ ateis - volatile , veja se¸ca õ 12.5.2 }; // Arquivo CNomeClasse.cpp Tipo CNomeClasse::nomeA; // Defini¸ca õ de atributo est´ atico 261

262

12.2. ATRIBUTOS DE OBJETO

12.2

Atributos de objeto

Um atributo de objeto é declarado dentro da classe sem a utiliza¸caõ do modificador de tipo static. Para criar um atributo de objeto, coloca-se o tipo seguido do nome do atributo. Exemplo: class CNomeClasse { public: int x; }; O exemplo da Listagem 12.1 ilustra a declara¸caõ, dentro da classe, de alguns atributos. O diagrama UML da classe CEndereco e da classe CTeste é ilustrado na Figura 12.1. No in´ıcio do arquivo inclu´ımos as classes- padr˜ ao de C++ que ser˜ ao utilizadas e definimos o uso dos objetos no escopo da std. Criamos as classes CEndereco e CTeste. A classe CEndereco tem dois atributos: o primeiro é um n´ umero inteiro utilizado para armazenar o n´ umero da casa; o segundo é a string rua, utilizada para armazenar o nome da rua. Os métodos Numero() e Rua() retornam, respectivamente, o n´ umero e nome da rua. Os métodos ser˜ ao apresentados no Cap´ıtulo 13 – Métodos. A segunda classe, CTeste, tem cinco atributos. Dois deles s˜ ao tipos predefinidos (int e float), o terceiro atributo, CEndereco, é um objeto da classe que definimos anteriormente. Temos ainda um atributo e um atributo . Ou seja, a classe CTeste tem atributos de diversos tipos. Observe que dentro da classe CTeste, declaramos um objeto do tipo CEndereco. Os tipos ou classes definidas por n´ os passam a funcionar da mesma forma que os tipos predefinidos da linguagem. Note que a classe é uma classe template, e que precisamos passar dentro de <> o tipo de objeto que ser´ a armazenado no vetor vd. No caso, vd armazenar´ a n´ umeros do tipo double. Dentro da fun¸caõ main(), criamos um objeto do tipo CTeste com nome obj. Em seguida, utilizamos os atributos definidos em CTeste, como x, nome e vd. Note que para acessar os atributos do objeto usa-se nomeObjeto.nomeAtributo (exemplo: obj.x = 3.1;). A linha obj.vd.push_back(34.5); é usada para adicionar no vetor vd o n´ umero 34.5. Veja na Figura 12.1 como fica um objeto do tipo CEndereco e CTeste na memória. Os métodos ser˜ ao descritos em detalhes no Cap´ıtulo 13 – Métodos. Listing 12.1: Usando atributos de objeto em uma classe. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include < iostream > # include < string > # include < vector > using namespace std ;

// // // //

E n t r a d a e sa´ ı da de dados Classe string de C ++ C o n t a i n e r < vector > da stl E s t a m o s usando o n a m e s p a c e std

class CEndereco // Cria classe C E n d e r e c o { public : int numero ; // A t r i b u t o s string rua ; public : // M ´ etodos int Numero () { return numero ; } string Rua () { return rua ; } }; class CTeste

// Cria classe CTeste



12.3. ATRIBUTOS DE CLASSE – STATIC 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

{ public : int contador ; float x ; CEndereco endereco ; string nome ; vector < double > vd ; };

// // // // //

263

int ´ e um tipo pr´ e - d e f i n i d o de C ++ float ´ e um tipo pr´ e - d e f i n i d o de C ++ C E n d e r e c o foi d e f i n i d o acima O tipo string ´ e um tipo da biblioteca - padr~ ao O tipo vector ´ e um tipo da biblioteca - padr~ ao

// Dentro da fun¸ c~ a o main () cria e usa um objeto do tipo CTeste int main () { CTeste obj ; // Cria objeto do tipo CTeste com nome obj obj . x = 3.1; // A r m a z e n a o valor 3.1 em obj . x obj . endereco . rua = " Avenida Atlantida " ; obj . endereco . numero = 360; obj . nome = " Joao da Silva " ; // A r m a z e n a " jo~ a o " em obj . nome obj . vd . push_back (34.5) ; cout << " \ nobj . x = " << obj . x << " \ nobj . nome = " << obj . nome << " \ nendereco . rua = " << obj . endereco . rua << " \ nendereco . numero = " << obj . endereco . numero << " \ nobj . vd [0] = " << obj . vd [0] << endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out obj . x = 3.1 obj . nome = Joao da Silva endereco . rua = Avenida Atlantida endereco . numero = 360 obj . vd [0] = 34.5

Figura 12.1: Como ficam os objetos do tipo CTeste e CEndereco na memória. UML

Objeto do tipo CTeste na memória Objeto do tipo CEndereco na memória

CEndereco

CTeste

+numero: int +rua: string +Numero(): int +Rua(): string

+contador: int +x: float +endereco: CEndereco +nome: string +vd: vector

Contador

numero

x

rua

endereco nome

Inclui todo o vetor vd

12.3

vd

Atributo agregado O objeto CTeste "tem um" endereço

Atributos de classe – static

Existem dois tipos de atributos dentro de uma classe: os atributos de objeto (individuais, s˜ ao armazenados no objeto) e os atributos de classe (coletivos, s˜ ao armazenados na classe). O objetivo dos atributos de classe é possibilitar o seu compartilhamento por todos os objetos criados. Outro objetivo dos membros est´ aticos em classes é eliminar o uso de vari´ aveis globais. Programa¸caõ Orientada a Objeto com C++


264

12.3. ATRIBUTOS DE CLASSE – STATIC

Para criar um atributo de classe, coloca-se a palavra-chave static seguida do tipo e do nome do atributo.

Exemplo: static int contador;

O exemplo a seguir ilustra a declara¸caõ e a defini¸caõ de atributos de classe (estáticos). O atributo mec é um atributo est´ atico.

Exemplo: #include "CEndereco.h" class CUniversidade { public: // Atributo de objeto, do tipo int, com nome numeroAlunos int numeroAlunos; // Atributo de objeto, do tipo CEndereco, com nome endereco CEndereco endereco; // Atributo de classe (static), do tipo string, com nome mec static string mec; }; string CUniversidade::mec = "Minist´ erio Educa¸ c~ ao e Cultura"; int main() { // Cria dois objetos do tipo CUniversidade CUniversidade ufsc,unicamp; return 0; }

Observe que atributos est´ aticos precisam ser definidos fora da classe. Observe a forma da defini¸caõ.

// Tipo NomeClasse::nomeAtributo = valor; string CUniversidade::mec = "Minist´ erio Educa¸ c~ ao e Cultura";

Veja na Figura 12.2 o diagrama UML da classe CUniversidade e como fica a memória para os objetos ufsc e unicamp. Observe que tanto o objeto ufsc quanto o objeto unicamp têm os atributos numeroAlunos e endereco, mas o atributo mec é armazenado na classe e compartilhado pelos dois objetos. Programa¸caõ Orientada a Objeto com C++


12.4. ATRIBUTOS CONSTANTES – CONST

265

Figura 12.2: Como ficam os objetos na memória quando a classe tem atributos est´ aticos. Diagrama UML

Objetos ufsc e unicamp na memória Memória do programa

CUniversidade +mec: string +numeroAlunos: int +endereco: TEndereco

Objeto ufsc

Objeto unicamp

numeroAlunos endereco

numeroAlunos endereco

classe CUniversidade mec

Atributo estático aparece sublinhado Atributo estático armazenado na classe e compartilhado pelos objetos ufsc e unicamp.

Note que a altera¸caõ de um atributo est´ atico se reflete em todas as instâncias da classe. Se o atributo for est´ atico e p´ ublico, poder´ a ser acessado externamente sem um objeto. Basta passar o nome da classe, o operador de resolu¸caõ de escopo (::) e o nome do atributo. Exemplo: string orgao_regulador = CUniversidade::mec; Nota: atributos inteiros constantes e est´ aticos e enumera¸co˜es podem ser definidos dentro da classe. Exemplo: class CNomeClasse { static const int valor = 5; };

12.4

Atributos constantes – const

O objetivo de um atributo const é fornecer ao objeto um atributo que ele poder´ a acessar, mas n˜ ao poder´ a alterar, ou seja, é utilizado para cria¸caõ de atributos constantes (somente leitura). Um atributo const deve ser inicializado nos métodos construtores da classe, n˜ ao podendo mais ser alterado. Os métodos construtores ser˜ ao descritos na Se¸caõ 16.1, e o uso de atributos const na Se¸caõ 16.4. No exemplo a seguir, o atributo static const float pi; pertence à classe e n˜ ao pode ser modificado. O atributo max pertence ao objeto, é inicializado no construtor da classe e n˜ ao pode ser alterado (é constante). Exemplo: class CMath { // Atributo est´ atico e constante, do tipo float, // com nome pi pertence a classe static const float pi; // Atributo normal e constante, do tipo int, // com nome max, pertence ao objeto Programa¸caõ Orientada a Objeto com C++


2 12.5. ATRIBUTOS – USO AVANCADO ¸

266

const int max; // Inicializa atributo max no m´ etodo construtor (detalhes na sec~ ¸ ao 16.4) CMath(int _max) : max(_max){}; }; // Inicializa atributo est´ atico const float CMath::pi = 3.141516; Veja outro exemplo na Listagem 13.3.

12.5

Atributos – uso avan¸ cado2

Veremos nesta se¸caõ o uso avan¸cado de atributos em C++. O que s˜ ao os atributos mutantes – mutable (Se¸caõ 12.5.1) e os atributos vol´ ateis – volatile (Se¸caõ 12.5.2).

12.5.1

Atributos mutantes – mutable2

Se uma classe tem um método membro const, TipoDeRetorno NomeM´ etodo(par^ ametros) const; este n˜ ao pode alterar os atributos da classe. Uma forma de contornar isto é definir o atributo como mutable. A palavra-chave mutable significa que o atributo pode mudar, mesmo que ele seja declarado como const. Membros mutable s˜ ao usados em atributos que s˜ ao logicamente const, mas que por motivos operacionais podem ser alterados [Lischner, 2003]. A utilidade real de mutable ocorre quando um método utiliza diversos atributos do objeto, mas você quer ter certeza de que estes n˜ ao ser˜ ao alterados e por isso declara o método como const. No entanto, por algum motivo, um determinado atributo precisa ser alterado, bastando para tal defini-lo com o qualificador mutable. Exemplo: class CTeste { public: mutable int x; void Altera_x() const; } A seguir, embora o método Altera_x() seja const, x é alterado pois foi declarado como mutable. void CTeste::Altera_x()const { x++; }; A palavra-chave mutable pode ser utilizada em classes como uma alternativa ao const_cast<> (Se¸caõ 25.8). Programa¸caõ Orientada a Objeto com C++


12.6. SENTENCAS ¸ PARA ATRIBUTOS

12.5.2

267

Atributos vol´ ateis – volatile3

A palavra-chave volatile é utilizada para dar a um atributo o status de volatile. Este tipo de atributo pode mudar de forma inesperada. volatile é utilizado na programa¸caõ paralela com threads. Veja exemplos de uso de volatile no Cap´ıtulo ?? – Introdu¸caõ ao processamento paralelo com m´ ultiplas threads. Veremos exemplo na Listagem ??.

12.6

Senten¸cas para atributos

• Observe que você pode combinar alguns qualificadores e um especificador. Veja no exemplo a seguir a utiliza¸caõ dos qualificadores const e volatile e do especificador int. Exemplo: int x; const int y; const volatile int x; • Lembre-se: os atributos devem ser, na medida do poss´ıvel, sempre privados e devem ser acessados usando métodos p´ ublicos. Desta forma o acesso pelos clientes é uniforme. Uma das vantagens desta técnica é poder substituir os métodos void NomeAtributo() por vers˜ oes que, além de retornar/setar o atributo, realizam alguma opera¸caõ adicional. No exemplo a seguir, quando mudamos o n´ umero de intervalos, nx, devemos recalcular dx, considerando os intervalos de integra¸caõ xmax e xmin. Exemplo: // Cria atributo nx int nx; // Seta novo valor para nx, e j´ a atualiza dx void Nx(int _nx) { nx = _nx; dx = (xmax - xmin) / nx; }; // Obt´ em valor de nx int Nx() { return nx; }; • O uso de métodos para acessar os atributos da classe garante a invariˆ ancia da classe. • Membros est´ aticos podem ser utilizados para compartilhar atributos entre objetos da mesma classe. • Se o atributo for o mesmo para todas as classes da hierarquia, use static. • Em alguns casos, mas n˜ ao sempre, o uso de const faz com que o programa fique mais r´ apido. Como o uso de const aumenta a seguran¸ca do programa, use e abuse de const. Para maiores detalhes veja [Sutter, 2006]. • 2 Se o atributo for const, este n˜ ao muda. Como ele n˜ ao muda seu valor, deve ser definido no construtor. • 2 Lembre-se que a declara¸caõ const n˜ ao garante totalmente que o atributo seja const, pois podemos usar const_cast<>, mutable ou volatile para mudar um atributo const. • 2 Um objeto est´ atico definido em um método é criado na primeira execu¸caõ do método e destru´ıdo no final da execu¸caõ do programa. Programa¸caõ Orientada a Objeto com C++



268 Exemplo int M´ etodo() { static int x = 0; ... return x; } • 3 Uma classe local n˜ ao pode conter membros est´ aticos.

12.7


Vimos o conceito de atributos na Se¸caõ 3.4, e, neste cap´ıtulo, aprendemos a implementar diferentes tipos de atributos com C++. Aprendemos a declarar e definir atributos na Se¸caõ 12.1. Vimos que na maioria dos casos trabalharemos com atributos de objeto, mas, quando necess´ ario, podemos usar os atributos de classe (declarados com static). Aprendemos que podemos declarar dentro da classe atributos const, mutable e volatile, sendo que const é mais utilizado. Lembre-se que um const é um atributo que vai ser inicializado na constru¸caõ do objeto e que vai se manter constante. No próximo cap´ıtulo, Cap´ıtulo 13 – Métodos, veremos na prática vários exemplos de classes. Veremos como inicializar os atributos no construtor na Se¸caõ 16.4 e a ordem de constru¸caõ dos atributos de um objeto na Se¸caõ 16.6.1.

12.8

Exerc´ıcios

1. Na Listagem 12.1 use o operador sizeof() para obter o tamanho dos objetos CEndereco e CTeste. 2. Monte um exemplo que inclua atributos normais, est´ aticos e const. 3. Construa uma classe com atributos const (Se¸caõ 12.4).



Cap´ıtulo 13

M´ etodos Vimos na Se¸caõ 3.5 o conceito de métodos. Neste cap´ıtulo mostraremos como implementar o conceito de métodos em C++. Veremos uma introdu¸caõ aos métodos de C++ (Se¸caõ 13.1), o prot´ otipo para declarar, definir e utilizar métodos em uma classe (Se¸caõ 13.2), os detalhes da declara¸caõ (Se¸caõ 13.3), defini¸caõ (Se¸caõ 13.4) e retorno dos métodos (Se¸caõ 13.5). Além disso, veremos como funciona a passagem de parˆ ametros (Se¸caõ 13.6), por c´ opia (Se¸cão 13.6.1), por referência (Se¸caõ 13.6.2), por ponteiro (Se¸caõ 13.6.2) e o uso de parˆ ametros predefinidos (Se¸caõ 13.6.4). Veremos também o que s˜ ao os métodos normais (Se¸caõ 13.7), os métodos constantes – const (Se¸caõ 13.8) e os métodos est´ aticos – static (Se¸caõ 13.9), além de aprendermos como otimizar o programa utilizando os métodos em linha – inline (Se¸caõ 13.10). Por fim, veremos links para se¸co˜es em que trataremos do uso avan¸cado de métodos e algumas senten¸cas u ´ teis. Nota: neste momento você pode reler a Se¸caõ 6.11.4, senten¸cas para conseguir o reuso de métodos e para construir métodos robustos.

13.1

Introdu¸ c˜ ao aos m´ etodos de C++

O leitor mais atento deve ter percebido que o que estamos fazendo é definir um conjunto de ferramentas relacionadas ao uso dos objetos. Imagine o objeto como sendo uma caixa, onde atributos/propriedades podem ser armazenados. Os métodos s˜ ao funcionalidades que podemos realizar com nossa caixa. Imagine que temos uma caixa com bolinhas de gude, de todos os tipos e cores. As bolinhas de gude s˜ ao atributos do tipo ”todo parte” do objeto caixa. Ou seja, você sabe que uma bolinha de gude n˜ ao é uma caixa, mas que uma caixa pode ter bolinhas de gude. A pergunta é: você deixaria qualquer um mexer em suas bolinhas de gude? Provavelmente ´ muito provável que você queira dividir sua caixa em três partes. Na primeira divisão, n˜ ao. E p´ ublica, você coloca as bolinhas de gude que qualquer um poder´ a acessar. Na segunda divisão, protegida, você coloca bolinhas especiais, que somente você e seus filhos poder˜ ao mexer. Finalmente, em uma terceira divisão, você vai colocar aquelas bolinhas especiais, que somente você ter´ a acesso. Esta divisão é bastante próxima de nossa realidade, de nosso dia-a-dia. A mesma é implementada em C++ com os especificadores de controle de acesso public, protected e private. Vamos a um outro exemplo, uma pessoa. Uma pessoa tem atributos normais, que mudam com o tempo. Como exemplo a idade, o peso. Também temos atributos que s˜ ao constantes, n˜ ao mudam. Como exemplo, o sexo e a data de nascimento, os quais s˜ ao definidos quando 269

´ ´ 13.2. PROTOTIPO PARA DECLARAR E DEFINIR METODOS

270

o objeto tem origem e n˜ ao muda nunca mais. Finalmente, um grupo de irmãos tem algumas caracter´ısticas em comum, compartilhadas. Como exemplo, o sobrenome e o nome do planeta em que vivemos (nosso programa s´ o atende aos terr´ aqueos). Veremos em nossos exemplos que esses conceitos da vida real s˜ ao implementados em C++ com os atributos normais (peso), const (data de nascimento, nome dos pais) e static (sobrenome, planeta em que vivem). Enfim, os conceitos j´ a existem. Precisamos usar os mecanismos da linguagem C++ para informar o compilador que o objeto tem um determinado comportamento. Isto é feito com o uso das palavras-chave public, protected, private, const, static etc.

13.2

Prot´ otipo para declarar e definir m´ etodos

Vimos anteriormente os conceitos de declara¸caõ (Se¸caõ 8.4) e defini¸caõ (Se¸caõ 8.5). Para métodos a declara¸caõ informa que o método existe (sua assinatura); já sua defini¸caõ reserva espa¸co de memória para o c´ odigo do método. A rela¸caõ entre a declara¸caõ e a defini¸caõ é dada pela assinatura do método. Veja a seguir o prot´ otipo para declara¸caõ de um método. Os itens dentro de [] s˜ ao opcionais. Cada um desses itens ser´ a explicado neste ou nos próximos cap´ıtulos. Prot´ otipo: [Pré-qualificador] TipoRetorno NomeMétodo([Tipo Parˆ ametro,...]) [P´ os-qualificador] Pré-qualificador inline , static , extern , explicit , virtual , friend TipoRetorno void, bool , char , short , int , long , float , double , tipos do usu´ ario, tipos de bibliotecas externas,... NomeMétodo Nome do método definido pelo programador (Tipo Parˆ ametro,...) Tipo e nome de cada parˆ ametro [na declara¸ca õ o nome é opcional, na defini¸ca õ é obrigat´ orio], o tipo pode incluir: void, bool , char , short , int , long , float , double , tipos do usu´ ario, tipos de bibliotecas externas,... P´ os-qualificador const , volatile , [lista de exce¸co ˜es que podem ser lan¸cadas] Veja a seguir o prot´ otipo para declarar e definir os métodos de uma classe. Observe que os métodos s˜ ao declarados dentro da classe (no arquivo CNomeClasse.h) e definidos fora da classe (no arquivo CNomeClasse.cpp), com exce¸caõ dos métodos inline, os quais podem ser declarados e definidos dentro da classe. Veja ainda que a declara¸caõ dos métodos normais, est´ aticos, em linha e virtuais é diferente, mas a defini¸caõ é igual. A defini¸caõ do método const inclui a palavra-chave const. Ao lado do prot´ otipo do método colocamos o n´ umero da se¸caõ em que o mesmo ser´ a apresentado. Prot´ otipo: // Arquivo CNomeClasse.h class CNomeClasse { Programa¸caõ Orientada a Objeto com C++


˜ DE UM METODO ´ 13.3. DECLARAC ¸ AO // Declara¸ca õ de Métodos Tipo Método(parˆ ametros); Tipo Método(parˆ ametros) const ; static Tipo Método(parˆ ametros); inline Tipo Método(parˆ ametros); virtual Tipo Método(parˆ ametros); virtual Tipo Método(parˆ ametros)=0;

271

// Métodos normais, veja se¸ca õ 13.7 // Métodos constantes - const , veja se¸ca õ 13.8 // Métodos est´ aticos - static , veja se¸ca õ 13.9 // Métodos em linha - inline , veja se¸ca õ 13.10 // Métodos virtuais - virtual , veja se¸ca õ 19.2 // Métodos virtuais puros, veja se¸ca õ 19.4

// Método inline impl´ıcito, veja se¸ca õ 13.10 Tipo Método(parˆ ametros) { ... Implementa¸ca õ do método ... return(Tipo); } }; // Fim da declara¸ca õ da classe Prot´ otipo: // Arquivo CNomeClasse.cpp #include ”CNomeClasse.h” // Defini¸ca õ de um método da classe Tipo CNomeClasse::Método(parˆ ametros) { ... Implementa¸ca õ do método ... return(Tipo); } // Defini¸ca õ de um método const da classe Tipo CNomeClasse::Método(parˆ ametros) const { ... Implementa¸ca õ do método ... return(Tipo); } Nota: o acesso aos métodos da classe pode ser modificado com as palavras-chave public, protect e private (veja Se¸caõ 11.2). Veja na Se¸caõ 10.4 o prot´ otipo para declarar e definir um método em uma classe definida dentro de um namespace. Veremos a seguir cada uma das tarefas realizadas por um método. Além disso, veremos como declarar e definir um método, seu retorno e seus parˆ ametros.

13.3

Declara¸c˜ ao de um m´ etodo

Um método recebe como parˆ ametros de entrada um conjunto de objetos, realiza determinada seq¨ uência de opera¸co˜es e, em seguida, retorna um objeto. As tarefas realizadas por um método em C++ s˜ ao: • Receber uma lista de objetos (parˆ ametros). • Executar um conjunto de tarefas. • Retornar apenas um objeto. Programa¸caõ Orientada a Objeto com C++


˜ DE UM METODO ´ 13.4. DEFINIC ¸ AO

272

A declara¸caõ de um método é a descri¸caõ de seu retorno, seu nome e seus parˆ ametros, antes de sua defini¸caõ. A vantagem das declara¸co˜es é que elas facilitam o trabalho do compilador, ou seja, auxiliam na identifica¸caõ da chamada de métodos com parˆ ametros errados. No exemplo a seguir o retorno é do tipo int, o nome do método é SomaInt(), e os parˆ ametros s˜ ao dois objetos do tipo int. Note que na declara¸caõ de um método, o nome dos parˆ ametros é opcional. A declara¸caõ do método SomaFloat() inclui como retorno um float, e como parˆ ametro, dois objetos do tipo float, com nomes a, b. Exemplo: // Arquivo CSoma.h class CSoma { public: // Declara¸ c~ ao do m´ etodo SomaInt(), par^ ametro sem nome int SomaInt( int , int ); // Declara¸ c~ ao do m´ etodo SomaFloat(), par^ ametro com nome float SomaFloat( float a, float b ); };

13.4

Defini¸c˜ ao de um m´ etodo

A defini¸caõ de um método é a implementa¸caõ de seu c´ odigo, do conjunto de instru¸co˜es que ser˜ ao executadas pelo método. Veja a seguir a implementa¸caõ do método SomaInt() e seu uso dentro da fun¸caõ main(). Observe que colocamos o retorno, int, o nome da classe, CSoma, o operador de resolu¸caõ de escopo (::), o nome do método, SomaInt(), e seus parˆ ametros ( int a, int b ). O nome da classe seguido de :: é necess´ ario pois informa ao compilador que o método SomaInt() pertence à classe CSoma. Se n˜ ao colocarmos CSoma::, deixando apenas int SomaInt( int a, int b );, teremos uma fun¸caõ global e n˜ ao um método da classe (um erro comum). Exemplo: // Arquivo CSoma.cpp // Inclui o arquivo "CSoma.h" com a defini¸ c~ ao da classe CSoma #include "CSoma.h" // Defini¸ c~ ao do m´ etodo SomaInt() da classe CSoma int CSoma::SomaInt ( int a, int b ) { return a + b; } // Arquivo programa.cpp // Uso do m´ etodo SomaInt() da classe CSoma #include "CSoma.h" #include int main() { // Cria objetos do tipo int com nomes x e y int x = 3; int y = 4; // Cria objeto do tipo CSoma com nome obj CSoma obj; // Uso do m´ etodo SomaInt() de obj Programa¸caõ Orientada a Objeto com C++


´ 13.5. RETORNO DE UM METODO

273

int z = obj.SomaInt(x,y); std::cout < < "\nSoma = " < < z < < std::endl; return 0; } Observe que para criar um objeto do tipo int, fazemos int nomeObjeto;. Para criar um objeto do tipo do usu´ ario, o procedimento é o mesmo, CSoma obj;. Tendo um objeto da classe CSoma, podemos acessar seus atributos e métodos p´ ublicos diretamente, como em obj.SomaInt(x,y);.

13.5

Retorno de um m´ etodo

Todo método deve ter um tipo de retorno. • O retorno e os parˆ ametros de um método podem ser de qualquer tipo, isto é, um tipo predefinido de C++, um tipo do usu´ ario ou um tipo definido em uma biblioteca externa. • C++ tem alguns padr˜ oes de retorno definidos no arquivo de cabe¸calho , como EXIT_SUCESS e EXIT_FAILURE. #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 • Quando você n˜ ao quiser nenhum retorno, deverá especificar o tipo void. O uso de void como retorno significa que o método n˜ ao tem retorno. No exemplo a seguir o M´ etodo() n˜ ao tem nenhum retorno, o que é informado com a palavra-chave void. Exemplo: class CMath { int abs(int x); double sqrt(double x); void M´ etodo(); };

// M´ etodo com retorno do tipo int // M´ etodo com retorno do tipo double // M´ etodo sem retorno e sem par^ ametro

• O retorno de um método pode ser uma chamada a outro método ou a um objeto. • 2 O retorno de um método n˜ ao pode ser um array nem uma fun¸caõ, mas pode ser um ponteiro ou referência a um array ou fun¸caõ. Veja Apêndice H – Vetores e matrizes – arrays.

13.6

Parˆ ametros dos m´ etodos

Quando declaramos um método devemos incluir a lista de parˆ ametros. Isto é, a lista de objetos que o método receber´ a. Veremos nesta se¸caõ que os parˆ ametros podem ser passados por c´ opia (Se¸caõ 13.6.1), referência (Se¸caõ 13.6.2), ou ponteiro (Se¸caõ 13.6.3). Programa¸caõ Orientada a Objeto com C++


ˆ ´ 13.6. PARAMETROS DOS METODOS

274

13.6.1

Passagem dos parˆ ametros por c´ opia

Neste caso o método recebe como parˆ ametro uma c´ opia do objeto. Note que como é criada ´ mais lento porque precisa criar uma c´ opia, o objeto original n˜ ao sofre nenhuma altera¸caõ. E uma c´ opia de cada objeto passado como parˆ ametro. No exemplo a seguir, dentro de main(), o objeto int a n˜ ao vai sofrer nenhuma altera¸caõ, pois o método M() vai receber uma c´ opia de a, com nome x. Exemplo: class CNomeClasse { public: int M(int x); }; int CNomeClasse::M(int x) { return x = 5; } int main() { CNomeClasse obj; int a = 1; int b = obj.M(a); return 0; }

13.6.2

// Declara¸ c~ ao do m´ etodo M() // Defini¸ c~ ao do m´ etodo M()

// Chamada do m´ etodo M()(uso) // aqui a = 1, b = 5

Passagem dos parˆ ametros por referˆ encia

Uma referência é um apelido para um objeto. Veja no exemplo a seguir como criar uma referência. Exemplo: int x; // Cria objeto do tipo inteiro com nome x int& ref_x; // Cria uma refer^ encia para x ref_x = 5; // Usa a refer^ encia para armazenar o valor 5 em x Veremos descri¸caõ detalhada do uso de referências no Cap´ıtulo 15 – Ponteiros, referências e gerenciamento de mem´ oria. Como uma referência é um apelido para um objeto, quando o método recebe como parˆ ametro a referência, ele recebe o próprio objeto e n˜ ao uma c´ opia. Note que a passagem de parˆ ametro por referência é mais r´ apida, pois o método tem acesso direto aos objetos (sem criar uma c´ opia destes). Observe ainda que o objeto passado pode sofrer altera¸co˜es dentro do método. No exemplo a seguir, dentro de main(), o objeto a vai sofrer altera¸caõ, pois o método M() vai receber o próprio a. Note que dentro de main() o nome do objeto é a, e dentro do método M() o apelido de a é x. Exemplo: class CNomeClasse { public: int M(int& x); };

// Declara¸ c~ ao do m´ etodo M()



ˆ ´ 13.6. PARAMETROS DOS METODOS int CNomeClasse::M(int &x) { return x = 5; } int main() { CNomeClasse obj; int a = 1; int b = obj.M(a); return 0; }

13.6.3

275

// Defini¸ c~ ao do m´ etodo M()

// Chamada de M()(uso) // aqui a = 5, b = 5

Passagem dos parˆ ametros por ponteiro

Neste caso o método recebe como parˆ ametro um ponteiro para o objeto. Um ponteiro é um objeto que aponta para outro objeto, podendo ser usado para alterar os valores armazenados no objeto apontado. Veja no exemplo a seguir que dado um objeto x do tipo inteiro, podemos criar um ponteiro para x usando int* ptr_x = &x;. Observe que usamos o caracter * para indicar que estamos criando um ponteiro para um inteiro. O caracter & (e comercial) é usado para pegar o endere¸co de x e armazenar em ptr_x. Exemplo: int x; // Cria objeto do tipo inteiro com nome x int* ptr_x; // Cria ponteiro para inteiro ptr_x = &x; // Pega o endere¸ co do objeto x e armazena em ptr Veremos descri¸caõ dos ponteiros no Cap´ıtulo 15 – Ponteiros, referências e gerenciamento de memória. No exemplo a seguir declaramos como parˆ ametro um ponteiro com nome pb, que é utilizado dentro do método M() para acessar o objeto. O objeto acessado pelo ponteiro pode sofrer altera¸co˜es. Exemplo: class CNomeClasse { public: int M(int *pb); // Declara¸ c~ ao do m´ etodo M() }; int CNomeClasse::M(int* pb)// Defini¸ c~ ao do m´ etodo M() { return *pb = 5; } int main() { CNomeClasse obj; int a = 1; int b = obj.M( &a ); // Chamada do m´ etodo M()(uso) return 0; // aqui a = 5, b = 5 } Note que a passagem por ponteiro é semelhante àpassagem por referência no que tange à modifica¸caõ do parˆ ametro. Isto é, ambos modificam o objeto passado como parˆ ametro. Veja na Listagem 13.1 exemplo ilustrando a passagem de parˆ ametros. N˜ ao se preocupe se n˜ ao entender a parte que usa ponteiros; depois de ler o cap´ıtulo de ponteiros, releia esse Programa¸caõ Orientada a Objeto com C++


ˆ ´ 13.6. PARAMETROS DOS METODOS

276

exemplo. O programa inicia com a inclus˜ ao da biblioteca . Em seguida, cria a classe CTeste com quatro métodos p´ ublicos, Soma_Valor(), Soma_Referencia(), Soma_Ponteiro() e Soma_ReferenciaPonteiro(). Na fun¸caõ main() criam-se duas vari´ aveis a e b, do tipo int. Os valores de a e b s˜ ao mostrados na tela. Depois disso, cria-se um objeto do tipo CTeste, e os métodos de CTeste s˜ ao executados. No in´ıcio da execu¸caõ de Soma_Valor(), criam-se as vari´ aveis x e y c´ opias de a e b. Assim, a modifi¸caõ de x e y dentro de Soma_Valor() n˜ ao altera os valores dos parˆ ametros passados, no caso a e b definidos dentro de main(). Por fim, as vari´ aveis a e b s˜ ao passadas como parˆ ametros dos outros três métodos. Nestes três casos, os valores de a e b definidos dentro de main() s˜ ao modificados. Listing 13.1: Passando parˆ ametros por valor, referência e ponteiro. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

# include < iostream > using std :: cout ; using std :: endl ; class CTeste { public : int Soma_Valor ( int , int ) ; int S o m a _ R e f e r e n c i a ( int & , int &) ; int S o m a _ P o n t e i r o ( int * , int *) ; int S o m a _ R e f e r e n c i a P o n t e i r o ( int *& , int *&) ; }; // D e f i n i ¸ c~ a o de um m´ e todo que recebe p a r ^ a m e t r o s por valor ( int ) int CTeste :: Soma_Valo r ( int x , int y ) { int soma = x + y ; x = 5; // In´ u til , usado apenas para m o s t r a r que a , b y = 7; // d e f i n i d o s dentro de main () n~ a o s~ ao alterados return soma ; } // D e f i n i ¸ c~ a o de um m´ e todo que recebe p a r ^ a m e t r o s por r e f e r ^ e n c i a ( int &) int CTeste :: S o m a _ R e f e r e n c i a ( int & x , int & y ) { int soma = x + y ; x = 55; y = 77; return soma ; } // D e f i n i ¸ c~ a o de um m´ e todo que recebe p a r ^ a m e t r o s por p o n t e i r o ( int *) int CTeste :: S o m a _ P o n t e i r o ( int *x , int * y ) { int soma = * x + * y ; * x = 555; * y = 777; return soma ; } // D e f i n i ¸ c~ a o de um m´ e todo que recebe p a r ^ a m e t r o s como // r e f e r ^ e n c i a para um p o n t e i r o ( int *&) int CTeste :: S o m a _ R e f e r e n c i a P o n t e i r o ( int *& x , int *& y ) { int soma = * x + * y ; * x = 5555; * y = 7777; return soma ; }



ˆ ´ 13.6. PARAMETROS DOS METODOS 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

277

int main () { // Cria o b j e t o s a e b do tipo int int a = 1; int b = 2; cout << " a = " << a << " , b = " << b << endl ; // Cria objeto obj do tipo CTeste CTeste obj ; // Chama m ´ e t o d o s do objeto obj cout << " Ap´ o s chamar Soma_Valor (a , b ) ; " << " soma = " << obj . Soma_Valor (a , b ) << " , a = " << a << " , b = " << b << endl ; cout << " Ap´ o s chamar S o m a _ R e f e r e n c i a (a , b ) ; " << " soma = " << obj . S o m a _ R e f e r e n c i a (a , b ) << " , a = " << a << " , b = " << b << endl ; cout << " Ap´ o s chamar S o m a _ P o n t e i r o (& a ,& b ) ; " << " soma = " << obj . S o m a _ P o n t e i r o (& a , & b ) << " , a = " << a << " , b = " << b << endl ;

// Cria int * pa int * pb cout << << <<

p o n t e i r o s para a e b = &a; = &b; " Ap´ o s chamar S o m a _ R e f e r e n c i a P o n t e i r o ( pa , pb ) ; " " soma = " << obj . S o m a _ R e f e r e n c i a P o n t e i r o ( pa , pb ) " , a = " << a << " , b = " << b << endl ;

return 0; } a = 1 , b = Ap´ o s chamar Ap´ o s chamar Ap´ o s chamar Ap´ o s chamar

13.6.4

2 Soma_Valor (a , b ) ; soma = 3 , a = 1 , b = 2 S o m a _ R e f e r e n c i a (a , b ) ; soma = 3 , a = 1 , b = 2 S o m a _ P o n t e i r o (& a ,& b ) ; soma = 132 , a = 55 , b = 77 S o m a _ R e f e r e n c i a P o n t e i r o ( pa , pb ) ; soma = 1332 , a = 555 , b = 777

Parˆ ametros predefinidos – inicializadores

A utiliza¸caõ de parˆ ametros predefinidos consiste em atribuir valores iniciais aos parˆ ametros de um método. Assim, quando o método é chamado sem parˆ ametros, ser˜ ao utilizados os parˆ ametros predefinidos. Veja o prot´ otipo. Note que se o parˆ ametro pn n˜ ao for passado, o método vai assumir que pn tem o valor vn. Prot´ otipo: TipoRetorno NomeMétodo(Tipo p1 = v1, Tipo p2 = v2, ... ,Tipo pn = vn); No exemplo a seguir, o método M() tem os parˆ ametros a, b e c previamente inicializados com os valores 4, 7 e 9.3, respectivamente. Observe que o método M() pode ser chamado de diferentes formas e que os parˆ ametros que deixam de ser fornecidos s˜ ao aqueles que est˜ ao mais à direita. Exemplo: int CNomeClasse::M(int a = 4, int b = 7, float c = 9.3) { Programa¸caõ Orientada a Objeto com C++


´ 13.7. METODOS NORMAIS

278 return a + b + c; } int main() { // O m´ etodo M() pode CNomeClasse obj; obj.M(77, 5, 66.6); obj.M(33, 75); obj.M(67); obj.M(); return 0; }

ser chamado das seguintes formas: // // // //

a a a a

= = = =

77, 33, 67, 4,

b b b b

= = = =

5, 75, 7, 7,

c c c c

= = = =

66.6 9.3 9.3 9.3

Um parˆ ametro predefinido pode ser a chamada a um método, veja o exemplo: Exemplo: int CNome::M1() { return 2; } int CNome::M2(int x, int y = CNome::M1(), int z = 3) { return x + y + z; } Parˆ ametros predefinidos podem ser acumulados em mais de uma declara¸caõ. No exemplo a seguir, o método M2() foi declarado diversas vezes. Lembre-se que declara¸co˜es podem ser repetidas. Observe que a chamada a M2() sem parˆ ametros funciona, pois considera as declara¸co˜es (2) e (3). Embora válido, este procedimento deve ser evitado, porque as declara¸co˜es podem estar em arquivos diferentes. Exemplo: int M2(int x, int y, int z); // Declara¸ c~ ao (1) int M2(int x, int y, int z = 3); // Declara¸ c~ ao (2) int M2(int x = 1, int y = 2, int z); // Declara¸ c~ ao (3) void Teste() { CNomeClasse obj; obj.M2(); // Equivale a obj.M2(1, 2, 3) } Note que se os tipos dos parˆ ametros forem diferentes teremos sobrecarga de métodos, a qual ser´ a discutida no Cap´ıtulo 14 – Sobrecarga de métodos. Veremos a seguir os diferentes tipos de métodos de uma classe.

13.7

M´ etodos normais

Os métodos normais s˜ ao declarados dentro da classe sem nenhum qualificador adicional, isto é, sem uso dos qualificadores inline, static, virtual ou const. Veja o prot´ otipo: Prot´ otipo: class CNome { // Declara¸ca õ TipoRetorno NomeMétodo(parˆ ametros); Programa¸caõ Orientada a Objeto com C++



279

}; // Defini¸ca õ TipoRetorno CNomeClasse::NomeMétodo(parˆ ametros) {.. c´ odigo..} // Uso objeto.NomeMétodo(parˆ ametros); Veremos o uso dos métodos normais mediante a implementa¸cão da classe CPessoa. Veja na Figura 13.1 o diagrama UML da classe CPessoa e na Listagem 13.2 sua implementa¸caõ. Neste exemplo, usamos os tipos predefinidos de C++, os tipos do usuário e os tipos da biblioteca-padr˜ ao de C++ ( e ). CPessoa +nome: string +matricula: string +Entrada(): void +Saida(): void

Figura 13.1: A classe CPessoa. O programa inicia pela inclus˜ ao das bibliotecas que ser˜ ao utilizadas e pela libera¸caõ do uso do namespace std. Em seguida, define a classe CPessoa, com atributos nome, matricula e dois métodos, um para Entrada() e outro para Saida() de dados. O método Entrada() pede para o usuário a entrada dos atributos do objeto, o nome da pessoa e seu n´ umero de matricula. O método Saida() envia para a tela o nome e matricula do objeto. Na fun¸caõ main(), criamos um objeto do tipo CPessoa, com nome professor e solicitamos seus dados. Em seguida, criamos um da STL (Se¸caõ 9.4.2) para armazenar dois objetos do tipo CPessoa. Dentro do primeiro for(), para cada aluno i, executamos o método Entrada(), ou seja, lemos os dados do aluno[i]. No segundo for(), cada aluno[i] envia para a tela seus atributos, chamando o método Saida(). Note no exemplo da Listagem 13.2 que os dados do professor s˜ ao lidos diretamente usando getline (cin, professor.nome);, isto s´ o é poss´ıvel porque os atributos nome e matricula s˜ ao p´ ublicos. Listing 13.2: Classe com atributo e método normal. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include < iostream > # include < string > # include < vector > using namespace std ; /* * A classe C P e s s o a r e p r e s e n t a uma pessoa ( um aluno ou um p r o f e s s o r ) de uma u n i v e r s i d a d e . Tem um nome , uma matr´ ı cula , e m´ etodos b´ a s i c o s para e n t r a d a e sa´ ı da de dados . */ class CPessoa { public : std :: string nome ; // A t r i b u t o s n o r m a i s std :: string matricula ; void Entrada () ; // M´ e todo normal void Saida () const ; // M´ e todo const };




280 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

// S o l i c i t a a t r i b u t o s do objeto void CPessoa :: Entrada () { cout << " Entre com o nome do aluno : " ; getline ( cin , nome ) ; cout << " Entre com a matr´ ı cula do aluno : " ; getline ( cin , matricula ) ; } // Mostra void { cout << << }

a t r i b u t o s do objeto CPessoa :: Saida () const " Nome do aluno : " << nome " \ nMatr´ ı cul a : " << matricula << endl ;

int main () { string linha = " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " ; const int n u m e r o A l u n o s = 2; // Cria CPessoa cout << getline cout << getline

um objeto do tipo C P e s s o a com nome p r o f e s s o r professor ; " Entre com o nome do professor : " ; ( cin , professor . nome ) ; " Entre com a matr´ ı cula do professor : " ; ( cin , professor . matricula ) ;

// Cria um vetor de o b j e t o s do tipo C P e s s o a com nome aluno vector < CPessoa > aluno ( n u m e r o A l u n o s ) ; for ( int contador = 0; contador < n u m e r o A l u n o s ; contador ++) { cout << " \ nAluno " << contador << endl ; aluno [ contador ]. Entrada () ; } cout << linha << " \ nRELA¸ C~ A O DE PROFESSOR E S E ALUNOS : " << linha << " \ nNome do professor : " << professor . nome << " \ nMatr´ ı cul a : " << professor . matricula << endl ; for ( int contador = 0; contador < n u m e r o A l u n o s ; contador ++) { cout << linha << " \ nAluno " << contador << endl ; aluno [ contador ]. Saida () ; } cout << linha ; return 0; } Entre com o nome do professor : Andre Duarte Bueno Entre com a matr´ ı cula do professor : 123 Aluno 0 Entre com o nome do aluno : Giovanni Colonese Entre com a matr´ ı cula do aluno : 324 Aluno 1 Entre com o nome do aluno : Alan Galante Entre com a matr´ ı cula do aluno : 984 ------------------------------------------------------RELA¸ C~ A O DE PROFESSOR E S E ALUNOS : -------------------------------------------------------



´ 13.8. METODOS CONSTANTES – CONST

281

Nome do professor : Andre Duarte Bueno Matr´ ı cula : 123 ------------------------------------------------------Aluno 0 Nome do aluno : Giovanni Colonese Matr´ ı cula : 324 ------------------------------------------------------Aluno 1 Nome do aluno : Alan Galante Matr´ ı cula : 984

Este é um de seus primeiros programas orientados a objeto. Simples, n˜ ao é? • Você declarou uma classe: class CPessoa... • Definiu os métodos da classe: void CPessoa::Entrada(){...} • Criou objetos da sua classe: CPessoa professor; • Usou o objeto: cout < < "Nome do professor: " < < professor.nome < < "\n";

13.8

M´ etodos constantes – const

Se um método da classe n˜ ao altera o estado e os atributos do objeto, ele deve ser declarado como const. Observe no prot´ otipo a seguir que a palavra-chave const é colocada no final da declara¸caõ: Prot´ otipo: class CNome { // Declara¸ca õ TipoRetorno NomeMétodo(parˆ ametros) const; }; // Defini¸ca õ TipoRetorno NomeClasse::NomeMétodo(parˆ ametros) const {.. c´ odigo..} // Uso objeto.NomeMétodo(parˆ ametros); • A declara¸caõ const instrui o compilador de que o método n˜ ao pode alterar o estado do objeto. Observe no próximo exemplo que a palavra-chave const é colocada antes do (;) ponto-e-v´ırgula que finaliza a declara¸caõ. Exemplo: class CNomeClasse { int valor; Programa¸caõ Orientada a Objeto com C++


´ 13.8. METODOS CONSTANTES – CONST

282 int Valor() const; int MudaValor(); }; int CNomeClasse::Valor() const { return valor; } void CNomeClasse::Valor(int v) { return valor = v; }

// Declara¸ c~ ao de m´ etodo const // Declara¸ c~ ao de m´ etodo normal // Defini¸ c~ ao de m´ etodo const // Defini¸ c~ ao de m´ etodo normal // muda atributo valor

• Se dentro de um método const algum atributo for modificado, ou um método n˜ ao const for chamado, o compilador acusar´ a o erro. Exemplo: int CNomeClasse::Valor() const // Outra defini¸ c~ ao para Valor { ++valor; // Erro, n~ ao pode mudar atributo Valor(5); // Erro, n~ ao pode chamar m´ etodo normal return valor; } • Se um método qualquer receber como parˆ ametro um objeto const, esse método s´ o poder´ a acessar os métodos const desse objeto, ou seja, n˜ ao poder´ a acessar os métodos que modificam o estado do objeto. Exemplo: void f(const CNomeClasse& obj) { cout < < obj.Valor(); // ok, o m´ etodo Valor() ´ e const obj.MudaValor(); // Erro, n~ ao pode chamar m´ etodo normal } Releia a Listagem 13.2, observe que o método Saida() é const. Veja na Listagem 13.3 um exemplo de uso de parˆ ametros e métodos const. Neste exemplo criamos uma classe CNumeroRandomico, a qual é usada para fornecer n´ umeros randˆ omicos. O atributo random armazena o n´ umero randˆ omico. O método Random() retorna o n´ umero randˆ omico. O método Update() gera um novo n´ umero randˆ omico. Como Update() altera o estado do objeto, isto é, altera o valor de random, ele n˜ ao pode ser declarado como const. A fun¸caõ main() solicita a entrada de uma semente e cria um objeto CNumeroRandomico, em seguida chama Inicializa() passando a semente. Dentro do for, chama o método Update(), que gera um novo n´ umero randˆ omico e ent˜ ao chama Random(). Esse exemplo mostra o uso de duas fun¸co˜es da biblioteca-padr˜ ao de C, a srand(), para informar o valor da semente e a rand(), para gerar um novo n´ umero randˆ omico. Nota: veremos, no Apêndice K – Arquivos de cabe¸calho, os arquivos de cabe¸calho padr˜ ao de C/C++ e uma breve descri¸caõ das fun¸co˜es mais utilizadas. Listing 13.3: Classe com método const. 1 2 3 4 5

# include < iostream > # include < iomanip > # include < cstdlib > using namespace std ;

// F u n ¸ c~ o e s srand () e rand ()



´ 13.8. METODOS CONSTANTES – CONST 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

283

class C N u m e r o R a n d o m i c o { private : double random ; int semente ; public :

// A t r i b u t o s n o r m a i s // n´ u mero r a n d o m i c o // s e m e n t e g e r a d o r a i n i c i a l // M ´ etodos // M´ e todo de i n i c i a l i z a ¸ c~ ao void Inicializa ( const int _semente = 1) ; // M ´ e t o d o s const double Random () const ; // R e t o r n a n´ u mero r a n d o m i c o int Semente () const ; // R e t o r n a a s e m e n t e void Update () ; // M´ e todo normal

}; // M´ e todo de i n i c i a l i z a ¸ c~ ao void C N u m e r o R a n d o m i c o :: Inicializa ( const int _semente ) { semente = _semente ; random = 0; srand ( semente ) ; } double C N u m e r o R a n d o m i c o :: Random () { return random ; }

const

int C N u m e r o R a n d o m i c o :: Semente () { return semente ; }

const

// Update gera um novo n´ u mero r a n d ^ o m i c o e a r m a z e n a em random void C N u m e r o R a n d o m i c o :: Update () { random = rand () ; } int main () { cout << " \ nEntre com uma semente : " ; int semente ; cin >> semente ; cin . get () ; C N u m e r o R a n d o m i c o gerador ; gerador . Inicializa ( semente ) ; cout << " Valor da semente : " << gerador . Semente () << " Valor inicial : " << gerador . Random () << endl ; for ( int i = 0; i < 5; i ++) { gerador . Update () ; cout << " gerador . Random ( " << setw (3) << i << " ) = " << setw (15) << gerador . Random () << endl ; } return 0; } bash -3.00 $ ./ a . out Entre com uma semente : 4 Valor da semente : 4 Valor inicial : 0 gerador . Random ( 0) = 1.96808 e +09 gerador . Random ( 1) = 2.87724 e +08 gerador . Random ( 2) = 4.10622 e +08 gerador . Random ( 3) = 5.58519 e +08



´ ´ 13.9. METODOS ESTATICOS – STATIC

284 gerador . Random (

4) =

4.60165 e +08

Dica: a biblioteca Matpack, descrita no Cap´ıtulo ?? – Biblioteca Matpack, inclui diversas classes utilitárias para gera¸caõ de n´ umeros randˆ omicos.

13.9

M´ etodos est´ aticos – static

Vimos que existem dois tipos de atributos: os atributos de objeto (Se¸caõ 12.2) e de classe (Se¸caõ 12.3). Se você montar um método que s´ o opera sobre os atributos est´ aticos da classe, pode declar´ a-lo como sendo um método est´ atico. Adicionalmente, um método est´ atico e p´ ublico pode ser acessado sem um objeto da classe, basta colocar o nome da classe, o operador de resolu¸caõ de escopo (::) e o nome do método. Veja a seguir o prot´ otipo: Prot´ otipo: class CNome { // Declara¸ca õ static TipoRetorno NomeMétodo(parˆ ametros); }; // Defini¸ca õ TipoRetorno NomeClasse::NomeMétodo(parˆ ametros) {.. c´ odigo..} // Uso NomeClasse::NomeMétodoEst´ atico(); Veja na Listagem 13.4 um exemplo de classe com atributo e método est´ atico. Este exemplo é um aperfei¸coamento da Listagem 13.2. Como inova¸caõ temos o atributo iaa, e o n´ umero de alunos é solicitado ao usu´ ario. Também temos um atributo est´ atico, numeroAlunos, utilizado para armazenar o total de alunos (e professores) que foram criados. O método est´ atico NumeroAlunos() retorna o n´ umero de alunos e pode ser acessado sem um objeto. Listing 13.4: Classe com atributo e método est´ atico. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# include < iostream > # include < string > # include < vector > using namespace std ; /* A classe C P e s s o a r e p r e s e n t a uma pessoa ( um aluno ou um p r o f e s s o r ) de uma u n i v e r s i d a d e . Tem um nome , uma matricula , um iaa , e m´ etodos b´ a s i c o s para e n t r a d a e sa´ ı da de dados . */ class CPessoa { public : std :: string nome ; std :: string matricula ; float iaa ; private : static int n u m e r o A l u n o s ; public : void Entrada () ; void Saida () const ; // Um m´ e todo e s t ´ a t i c o s´ o pode a c e s s a r e a l t e r a r a t r i b u t o s e s t ´ aticos static int N u m e r o A l u n o s () ;



´ ´ 13.9. METODOS ESTATICOS – STATIC 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

285

}; // A t r i b u t o e s t ´ atico ´ e aquele que p e r t e n c e a classe e n~ a o ao objeto // e p r e c i s a ser d e f i n i d o depois da classe int CPessoa :: n u m e r o A l u n o s = 0; // M´ e todo est´ a tico , r e t o r n a o n´ u mero de alunos int CPessoa :: N u m e r o A l u n o s () { return n u m e r o A l u n o s ; } void CPessoa :: Entrada () { n u m e r o A l u n o s ++; cout << " Entre com o nome : " ; getline ( cin , nome ) ; cout << " Entre com a matr´ ı cula : " ; getline ( cin , matricula ) ; cout << " Entre com o IAA : " ; cin >> iaa ; cin . get () ; } void { cout << << << }

CPessoa :: Saida () const " Nome : " << nome " \ tMatr´ ı cula : " << matricula " \ tIAA : " << iaa << endl ;

int main () { string linha = " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " ; cout << " \ nEntre com o n´ u mero de alunos da disciplin a ( ex : 3) : " ; int n u m e r o A l u n o s ; cin >> n u m e r o A l u n o s ; cin . get () ; CPessoa professor ; cout << " Entre com o nome do professor : " ; getline ( cin , professor . nome ) ; cout << " Entre com a matr´ ı cula do professor : " ; getline ( cin , professor . matricula ) ; vector < CPessoa > aluno ( n u m e r o A l u n o s ) ; for ( int contador = 0; contador < aluno . size () ; contador ++) { cout << linha << " \ nAluno " << contador << endl ; aluno [ contador ]. Entrada () ; } cout << linha << " \ nRELA¸ C~ A O DE PROFESSORE S E ALUNOS : " << linha << " \ nNome do professor : " << professor . nome << " \ nMatr´ ı cula : " << professor . matricula << " \ n " ; for ( int contador = 0; contador < aluno . size () ; contador ++) { cout << linha << " \ nAluno " << contador << endl ; aluno [ contador ]. Saida () ; } // Usa m´ e todo e s t ´ a t i c o sem ter um objeto cout << " \ nN´ u mero alunos = " << CPessoa :: N u m e r o A l u n o s () << endl ; return 0;



´ 13.10. METODOS EM LINHA – INLINE

286 85

} Entre com o n´ u mero de alunos da disciplina ( ex : 3) : 3 Entre com o nome do professor : Andr´ e Duarte Bueno Entre com a matr´ ı cula do professor : 654 ---------------------------------------------------------Aluno 0 Entre com o nome : Tiago Schaewer Entre com a matr´ ı cula : 548 Entre com o IAA : 9.8 ---------------------------------------------------------Aluno 1 Entre com o nome : Alan Galante Entre com a matr´ ı cula : 987 Entre com o IAA : 9 ---------------------------------------------------------Aluno 2 Entre com o nome : Giovanni Colonese Entre com a matr´ ı cula : 475 Entre com o IAA : 9.3 ---------------------------------------------------------RELA¸ C~ A O DE PROFESSOR E S E ALUNOS : ---------------------------------------------------------Nome do professor : Andr´ e Duarte Bueno Matr´ ı cula : 654 ---------------------------------------------------------Aluno 0 Nome : Tiago Schaewer Matr´ ı cula : 548 IAA : 9.8 ---------------------------------------------------------Aluno 1 Nome : Alan Galante Matr´ ı cula : 987 IAA : 9 ---------------------------------------------------------Aluno 2 Nome : Giovanni Colonese Matr´ ı cula : 475 IAA : 9.3 N´ u mero alunos =3

Dica: substitua o uso de atributos est´ aticos por fun¸co˜es est´ aticas que retornam uma referência para objetos est´ aticos. Veja o exemplo: Exemplo: const double& Pi() { static const double pi = 3.141516; return pi; }

13.10

M´ etodos em linha – inline

Quando você define um método, o compilador reserva um espa¸co de memória que é ocupado pelo c´ odigo do método. Quando você chama um método com parˆ ametros, o compilador passa os parˆ ametros para o método a ser executado, mudando a linha de execu¸caõ do programa (P1). Depois de executado o método, o programa retorna para o local onde estava (P2) e executa a instru¸caõ seguinte à chamada do método. Observe que existem dois passos intermedi´ arios, ir até onde o método est´ a e depois retornar, o que consome tempo de processamento. A Figura 13.2 ilustra o processo considerando a seq¨ uência com método normal e inline. Programa¸caõ Orientada a Objeto com C++



287

Observe que na seq¨ uência normal a fun¸caõ main() faz x = 3; e cria o objeto obj, do tipo C. Em seguida, o método M() é chamado (P1), dentro do método executa a seq¨ uência int z = x + 3; e faz z*z. Finalizado o método M(), o mesmo retorna o valor de z*z (P2) e armazena em y. O valor de y é enviado para a tela e, ent˜ ao, o programa é encerrado. Na seq¨ uência com método inline, o c´ odigo de C::M() é copiado para dentro de main(), eliminando os passos intermedi´ arios (P1) e (P2). // Declaração da classe class C { // Declara método inline inline int M(int x); }; // Define método M() int C::M(int x) { int z = x + 3; return z * z; }

(P2)

// Seqüência Normal #include "C.h" int main() { int x = 3; (P1) C obj; int y = obj.M(x); cout << "y = "<< y << endl; return 0; }

// Seqüência com método inline #include "C.h" int main() { int x = 3; Trecho de C obj; código int z = x + 3; copiado de int y = z * z; C::M() cout << "y = "<< y << endl; return 0; }

Figura 13.2: Como ficam os métodos inline. Veja a seguir algumas caracter´ısticas dos métodos inline: • Métodos inline devem ser métodos pequenos, por isso o termo em linha. S˜ ao métodos que s˜ ao executados mais rapidamente. • Uma especifica¸caõ inline é uma sugest˜ ao para que seja feita a sua substitui¸caõ e n˜ ao a sua chamada; o compilador é que decide. Se o método for grande, o compilador ir´ a desconsiderar o especificador inline. • Um método inline é ideal para retorno de valores. • Um método definido dentro da defini¸caõ da classe é inline por default. Veja linhas 20-24 da Listagem 13.5. • A utiliza¸caõ de métodos inline torna o programa mais r´ apido, porém maior. • Coloque o c´ odigo de todos os métodos inline dentro da defini¸caõ da classe. • Um método recursivo (que chama a si mesmo) n˜ ao pode ser inline. Isto ocorre porque o método teria de ser substitu´ıdo onde é chamado, e, como é recursivo, o n´ umero de substitui¸co˜es é indefinido ou implica na gera¸caõ de c´ odigos muito extensos. Veremos na Se¸caõ 28.1.2 fun¸co˜es expandidas em tempo de compila¸caõ, uma maneira de construir métodos recursivos em tempo de compila¸caõ. • Altera¸co˜es em um método inline implicam na necessidade de se recompilar todas as bibliotecas que fa¸cam uso deste, ou seja, utilize inline com cuidado. Em resumo, os métodos inline foram criados para otimizar o programa. Quando um método inline é chamado, o compilador, em vez de chamar o método, coloca uma c´ opia deste onde ´ uma situa¸caõ semelhante à que ocorria com as antigas macros de C, ele est´ a sendo chamado. E com a vantagem de fazer verifica¸caõ de tipo. Veja a seguir um exemplo: Programa¸caõ Orientada a Objeto com C++



288 Exemplo: class CRetangulo { int base, altura; public: // inline impl´ ıcito, pois o int Base() const { void Base(int _base) { int Altura() const { void Altura(int _altura) { int Perimetro() const { // inline expl´ ıcito, uso da inline int Area() { };

m´ etodo ´ e definido dentro da classe return base; }; base = _base; }; return altura; }; altura = _altura; }; return base*base + altura*altura; }; palavra-chave inline return base*altura; };

Nota: no exemplo anterior usamos métodos com mesmo nome, mas n´ umero de parˆ ametros diferente. Veja o Cap´ıtulo 14 – Sobrecarga de métodos. Veja na Figura 13.3 o diagrama UML da classe CPonto, cujo c´ odigo para implementa¸caõ é apresentado nas listagens 13.5 e 13.6. Observe a utiliza¸caõ de métodos inline para acesso aos atributos da classe e o uso de métodos const. A classe CPonto ser´ a utilizada na Listagem 13.7.

CPonto

A classe CPonto inclui dois atributos normais do tipo inteiro e um atributo de classe.

+x: int +y: int +contador: static int = 0 +Desenha(): virtual void

Figura 13.3: A classe CPonto. Listing 13.5: A classe CPonto. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# ifndef CPonto_h # define CPonto_h // Define a classe CPonto , o tipo de u s u ´ a r i o CPonto . class CPonto { protected : int x ; int y ; static int contador ; public : // Seta a t r i b u t o s do ponto inline void Set ( CPonto & p ) // M´ e todo inline e x p l ´ ıcito { x = p . X () ; y = p . Y () ; } void Set ( int & _x , int & _y ) {

// M´ e todo inline i m p l ´ ıcito



´ 13.10. METODOS EM LINHA – INLINE 22 23 24 25 26 27 28 29 30 31 32 33 34

289

x = _x ; y = _y ; } // Obt´ e m a t r i b u t o s do ponto // Usa m ´ e t o d o s em linha - inline i m p l ´ ıcito int X () const { return x ; }; int Y () const { return y ; }; void Desenha () ; static int Contador () ;

// M´ e todo normal , d e s e n h a o ponto // M´ e todo est´ a tico , r e t o r n a o c o n t a d o r

}; # endif

Listing 13.6: Implementa¸caõ da classe CPonto. # include < iostream > # include " CPonto . h " // Define a t r i b u t o da classe int CPonto :: contador = 0; // Define m´ e todo e s t ´ a t i c o da classe int CPonto :: Contador () { return contador ; } void CPonto :: Desenha () { std :: cout << " \ nCPonto : Coordenada x = " << x << " \ nCPonto : Coordenada y = " << y << std :: endl ; }

Na Listagem 13.7 um objeto do tipo CPonto é criado, CPonto ponto;, e utilizado ponto.Set(x,y); ponto.Desenha();. Quando o bloco é encerrado o objeto ponto sai de escopo e é destru´ıdo. Observe que, depois de destruir o objeto ponto, utilizamos o método Contador(). Isto é poss´ıvel porque o método é p´ ublico e est´ atico. Listing 13.7: Usando métodos e atributos de uma classe. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# include < iostream > # include " CPonto . h " using namespace std ; // E x e m p l o de c r i a ¸ c~ a o e uso de um objeto do tipo CPonto int main () { int x = 5; int y = 4; { CPonto p1 ; // Cria objeto do tipo CPonto com nome p1 p1 . Set (x , y ) ; // Chama m´ e todo Set () do objeto p1 p1 . Desenha () ; // Chama m´ e todo D e s e n h a () do objeto p1 CPonto p2 ; p2 . Set ( p1 ) ; p2 . Desenha () ;

// Cria objeto do tipo CPonto com nome p2 // Chama m´ e todo Set () do objeto p2 // Chama m´ e todo D e s e n h a () do objeto p2

CPonto p3 ; // Cria objeto do tipo CPonto com nome p3 x = p1 . X () + p2 . X () ; y = p1 . Y () + p2 . Y () ;



´ 13.11. METODOS – USO AVANCADO ¸

290 22 23 24 25 26 27 28 29

p3 . Set ( x , y ) ; p3 . Desenha () ; }

// Sai de escopo e detr´ o i os o b j e t o s p1 , p2 , p3

// Chama m´ e todo e s t ´ a t i c o e p´ u blico , o b s e r v e que n~ a o p r e c i s a de um objeto cout << " Contador = " << CPonto :: Contador () << endl ; return 0; } CPonto : Coordenada x = 5 CPonto : Coordenada y = 4 CPonto : Coordenada x = 5 CPonto : Coordenada y = 4 CPonto : Coordenada x = 10 CPonto : Coordenada y = 8 Contador = 0

13.11

M´ etodos – uso avan¸ cado

Inclu´ımos nesta se¸caõ referências para se¸co˜es que incluem o uso avan¸cado de métodos em C++. • Os métodos n˜ ao virtuais foram apresentados neste cap´ıtulo. Veremos outras caracter´ısticas dos métodos n˜ ao virtuais na Se¸caõ 19.1. • Veremos os métodos virtuais, na Se¸caõ 19.2, e como implementar o polimorfismo, na Se¸caõ 19.3. • Veremos os métodos virtuais puros na Se¸caõ 19.4. • Veremos os métodos virtuais sobrecarregados na Se¸caõ 19.5. • Apresentaremos um exemplo cobrindo o uso prático de polimorfismo na Se¸caõ 19.6.

13.12

Senten¸cas para m´ etodos

• Os métodos p´ ublicos formam a interface da classe e devem ter nomes claros e uniformes (veja Tabela 8.2). • Se um método manipula preferencialmente os atributos de um objeto, ele provavelmente é um método desse objeto. • Em C++, todos os métodos precisam de uma declara¸caõ, a qual auxilia o compilador a encontrar erros. • Objetos grandes devem ser passados por referência ou por ponteiros. • Evite utilizar parˆ ametros de métodos com nome igual ao de outros objetos para evitar ambig¨ uidades. • Analise os parˆ ametros dos métodos. Se estes n˜ ao forem alterados, deverão ser declarados como const. Programa¸caõ Orientada a Objeto com C++


´ 13.12. SENTENCAS ¸ PARA METODOS

291

• O uso de void como parˆ ametro significa que o método n˜ ao recebe nenhum argumento. Exemplo: // Declarando uma fun¸ c~ ao sem retorno e sem par^ ametro void fun¸ c~ ao(void);// C void fun¸ c~ ao(); // C++ • Seguran¸ca – se você quer ter certeza de que o parˆ ametro n˜ ao ser´ a alterado, deve passá-lo como referência constante. Veja o exemplo a seguir. O especificador const informa que o objeto é constante e n˜ ao pode ser alterado dentro do método. Deste modo, o método pode acessar o objeto, mas n˜ ao pode modific´ a-lo. Exemplo: NomeM´ etodo(const Tipo& obj); • Desempenho – parˆ ametros passados por referência aumentam a eficiência, pois os valores n˜ ao s˜ ao copiados. • Você pode passar informa¸co˜es de uma classe para outra ou para objetos por meio de atributos est´ aticos da classe. • Um objeto é criado por c´ opia quando: ´ um parˆ 1. E ametro de um método. ´ um retorno de um método. 2. E ´ lan¸cado como uma exce¸caõ (veja Cap´ıtulo 26 – Exce¸co˜es). 3. E • Use inline somente quando houver ganho efetivo de desempenho. • Métodos inline devem ter exatamente a mesma defini¸caõ em todos os arquivos. • 2 Se você criar um ponteiro para uma fun¸caõ inline, o compilador criar´ a uma c´ opia n˜ ao inline da fun¸caõ, e o ponteiro apontar´ a para esta c´ opia. • 2 Na linkagem, os métodos inline devem estar acess´ıveis a todas as unidades de tradu¸caõ. • 2 A lista de exce¸co˜es que um método pode lan¸car n˜ ao faz parte de sua assinatura. • 2 Uma fun¸caõ friend definida dentro de uma classe é uma fun¸caõ inline impl´ıcita. • 2 Um método est´ atico (static) n˜ ao recebe um ponteiro this e, portanto, n˜ ao pode ser utilizado para acessar os atributos e métodos da classe. • 2 Devo usar métodos com parˆ ametros predefinidos ou sobrecarga de operador? De modo geral, usamos sobrecarga quando os parˆ ametros s˜ ao complexos (evitando a c´ opia desnecessária dos parˆ ametros). Se os parˆ ametros s˜ ao simples e o c´ odigo é complexo, prefira parˆ ametros predefinidos, assim, o c´ odigo é escrito uma u ńica vez [Lischner, 2003]. • 2 Na chamada a uma fun¸caõ ou método: i) primeiro é feita uma pesquisa pelos nomes, isto é, procura-se por métodos com aquele nome; ii) em seguida é verificada a sobrecarga, isto é, qual método atende melhor a assinatura do método chamado; iii) finalmente, é verificada a acessibilidade. Na prática isso significa que um método que tem uma assinatura mais conhecidente nem sempre é chamado, pois a sobrecarga é verificada antes. Veja Se¸caõ 14.3.1. Programa¸caõ Orientada a Objeto com C++



292

• 3 Outro aspecto interessante, relatado por [Sutter, 2006], é que a substitui¸caõ do c´ odigo dos métodos inline pode ser feita a qualquer tempo, ou seja, na compila¸caõ, na linkagem, na instala¸caõ e até na execu¸caõ. Tudo depende do compilador e de op¸co˜es de otimiza¸caõ. • 3 Lembre-se que o uso de inline n˜ ao garante que o método/fun¸caõ seja efetivamente inline. Na prática, o compilador pode colocar um método como sendo inline em uma parte do c´ odigo e n˜ ao inline em outra parte. A decis˜ ao é sempre do compilador, e n˜ ao podemos fazer nenhuma suposi¸caõ sobre o que ser´ a feito. • 3 Para ter maior robustez no seu c´ odigo, deixe os métodos virtuais como privados ou protegidos. Monte a interface com métodos normais. Veja Se¸caõ 11.5.3. Esta técnica é conhecida como NVI – NonVirtual Interface [Sutter, 2006].

13.13


Neste cap´ıtulo vimos o prot´ otipo para declarar, definir e utilizar os métodos de uma classe. Vimos em detalhes como funciona a declara¸caõ a defini¸caõ e o retorno dos métodos. Aprendemos que o retorno 0 ou EXIT SUCESS indica sucesso e EXIT FAILURE ou != 0 indica fracasso. Aprendemos a utilizar os diferentes tipos de passagem de parˆ ametros (cópia, referência, ponteiro). Entendemos o uso dos parˆ ametros predefinidos. Depois aprendemos a declarar e implementar os métodos normais, os métodos constantes, os métodos est´ aticos e os métodos em linha. Vimos que os métodos est´ aticos s˜ ao criados para manipular os atributos est´ aticos (de classe). Lembre-se que um atributo static faz parte da classe e n˜ ao do objeto, sendo compartilhado ´ como uma vari´ por todos os objetos. E avel ”global para os objetos daquela classe”. Observe que a necessidade de atributos static é bastante real. Nota: os métodos construtores ser˜ ao apresentados no Cap´ıtulo 16 – Métodos construtores e destrutores. Veremos o uso avan¸cado da fun¸caõ main() e a entrada na linha de comando na Se¸caõ E.1 e fun¸co˜es recursivas na Se¸caõ E.3.

13.14

Exerc´ıcios

1. Modifique a Listagem 13.1, acrescentando um método que recebe parˆ ametros por c´ opia, referência, ponteiro e referência de ponteiro. 2. Monte um exemplo que use parˆ ametros predefinidos (Se¸caõ 13.6.4). 3. Monte uma classe CTriangulo que tenha um método normal, um método const, um método static e um método inline. 4. Reveja o exemplo da Listagem 13.1, prestando aten¸caõ na forma como os métodos s˜ ao declarados, definidos e usados. 5. Modifique a Listagem 13.2, deixando os atributos nome e matr´ıcula como privados. 6. Modifique a Listagem 13.4. Crie duas classes, uma para o professor e outra para os alunos. 7. 2 Modifique a Listagem 13.3 acrescentando sobrecarga para o operator(), isto é, substitua Random() pelo operator(). Programa¸caõ Orientada a Objeto com C++


13.14. EXERCÍCIOS

293

8. Implemente o exemplo da classe CRetangulo da Se¸caõ 13.10. Que tal criar as classes CQuadrado, CCirculo, CElipse? • Coloque os atributos da Listagem 13.2 como private: e, em seguida, veja o que acontece na compila¸caõ. Modifique a fun¸caõ main() de forma que o exemplo funcione mesmo com os atributos sendo privados.



294


13.14. EXERCÍCIOS


Cap´ıtulo 14

Sobrecarga de M´ etodos Neste cap´ıtulo apresentaremos a sobrecarga de métodos, ou seja, a utiliza¸caõ de métodos com o mesmo nome mas com n´ umero ou tipo de parˆ ametros diferentes. Veremos o que é a sobrecarga de métodos (Se¸caõ 14.1) e como implement´ a-la (Se¸caõ 14.2). Na Se¸caõ Sobrecarga de métodos – uso avan¸cado (Se¸caõ 14.3) veremos a rela¸cão entre acessibilidade e visibilidade (Se¸caõ 14.3.1). Finalmente, veremos algumas senten¸cas para sobrecarga de métodos (Se¸caõ 14.4).

14.1

Prot´ otipo para sobrecarga de m´ etodos

Sobrecarga de métodos se refere ` a utiliza¸caõ de métodos com o mesmo nome, mas com tipos ou n´ umero de parˆ ametros diferentes. Veja o prot´ otipo a seguir. Observe que a ordem dos parˆ ametros é importante. De modo geral, como os métodos sobrecarregados têm o mesmo nome, devem ser utilizados para realizar tarefas semelhantes. Prot´ otipo: Retorno Retorno Retorno ... Retorno

Método(Tipo1 p1); Método(Tipo1 p1, Tipo2 p2); Método(Tipo1 p1, Tipo2 p2, Tipo3 p3); Método(Tipo1 p1, Tipo2 p2, Tipo3 p3, ...,TipoN pn);

Observe que, como usaremos um mesmo nome para todos os métodos que realizam coisas semelhantes, é muito importante escolher com cuidado o nome do método. Adicionalmente, o nome deve indicar de forma clara o que vai ser realizado.

14.2

Como implementar a sobrecarga de m´ etodos

O exemplo a seguir declara métodos com o mesmo nome, métodos sobrecarregados. Exemplo: void M´ etodo(int x, int y); // Declara¸ c~ ao (1)- par^ ametros int, int void M´ etodo(float x, float y); // Declara¸ c~ ao (2)par^ ametros float, float void M´ etodo(int x, float y); // Declara¸ c~ ao (3)par^ ametros int, float 295

296

´ 14.2. COMO IMPLEMENTAR A SOBRECARGA DE METODOS

O exemplo a seguir usa o método acima declarado. O compilador identifica que xx e yy s˜ ao do tipo int e chama o primeiro método declarado, ou seja, o compilador reconhece qual método você quer acessar, verificando o tipo e o n´ umero de parˆ ametros. Exemplo: int xx = 3; int yy = 4; M´ etodo( xx , yy );

// Acessa m´ etodo (1)- int, int

Observe que mudar o nome dos parˆ ametros n˜ ao é uma sobrecarga; o compilador diferencia o tipo, e n˜ ao o nome. No exemplo a seguir ocorre um erro na compila¸caõ do método, pois este tem como parˆ ametros dois inteiros, repetindo a declara¸cão (1) void M´ etodo(int x,int y);. Exemplo int M´ etodo(int z, int r);

// Declara¸ c~ ao (4)- Erro repete (1)

Enfim, você deve estar atento ` as convers˜ oes de tipo quando declara métodos sobrecarregados. Tome os seguintes cuidados: • O tipo e a referência para o tipo. void M´ etodo(int a); void M´ etodo(int & a);

// Erro, redeclara¸ c~ ao

• Somente a diferencia¸caõ do nome dos parˆ ametros n˜ ao é sobrecarga. void M´ etodo(int a, int b); void M´ etodo(int c, int d);

// Erro, redeclara¸ c~ ao

• Um método com parˆ ametros predefinidos é uma sobrecarga: void M´ etodo(int a, int b, int c = 1); ´ como se você criasse os métodos seguintes: E void M´ etodo(int a, int b, int c); void M´ etodo(int a, int b); Na Se¸caõ 13.3, declara¸caõ de um método, montamos uma classe CSoma com dois métodos, SomaInt() e SomaFloat(). Veja a seguir como a classe CSoma pode ficar considerando-se o uso de métodos sobrecarregados. A grande vantagem é o uso do mesmo nome, Soma(), pois isso facilita a memoriza¸caõ dos objetos e suas funcionalidades. Exemplo: // Arquivo CSoma.h class CSoma { public: // Declara¸ c~ ao do m´ etodo Soma, par^ ametro do tipo int, sem nome int Soma( int , int ); // Declara¸ c~ ao do m´ etodo Soma, par^ ametro do tipo float, com nomes a e b float Soma( float a, float b ); }; Reveja a listagem 13.5, observe que o método Set() é sobrecarregado. Programa¸caõ Orientada a Objeto com C++


2 ´ 14.3. SOBRECARGA DE METODOS – CONCEITOS AVANCADOS ¸

14.3

297

Sobrecarga de m´ etodos – conceitos avan¸cados2

Nesta Se¸caõ veremos alguns conceitos avan¸cados de sobrecarga de métodos.

14.3.1

Acessibilidade x visibilidade: como ´ e feita a sele¸c˜ ao do m´ etodo a ser executado

Quando um método é chamado, a seq¨ uência que envolve a defini¸caõ de qual método vai ser executado passa por três etapas: 1. O compilador pesquisa por métodos com mesmo nome e verifica seu escopo, montando uma lista com os poss´ıveis candidatos. Note que métodos privados e protegidos farão parte desta lista. 2. Em seguida o compilador verifica a presen¸ca de sobrecarga e a assinatura dos métodos. O objetivo é identificar qual método se encaixa melhor (tem maior correspondência), seguindo a seguinte ordem: (a) A assinatura do método é totalmente coincidente. ´ necess´ (b) E ario realizar promo¸co˜es integrais (exemplo: convers˜ ao de um n´ umero unsigned int em int). ´ necess´ (c) E ario usar convers˜ oes-padr˜ ao de C++. ´ necess´ (d) E ario usar convers˜ oes definidas pelo usuário (veja Cap´ıtulo 25 – Convers˜ oes). 3. O terceiro passo do compilador é fazer a verifica¸caõ de acesso (public, protected e private). Um estudo detalhado dessa seq¨ uência deixa claro que nem sempre o método com maior correspondência é chamado, pois a verifica¸caõ da acessibilidade é o u ´ ltimo item a ser considerado. Ou seja, se um método com maior correspondência for inacess´ıvel, ent˜ ao um método com menor correspondência ser´ a chamado. Se o que temos n˜ ao é uma fun¸caõ, é um ponteiro, um template ou um objeto, ent˜ ao a resolu¸caõ da chamada segue a seguinte ordem: 1. método/fun¸caõ f(), 2. um ponteiro para método/fun¸caõ f(), 3. uma fun¸caõ template f(), 4. a constru¸caõ de um objeto do tipo f(), ou a chamada do operador() de um objeto f(). Nota: para maiores detalhes consulte [Sutter, 2006, Meyers, 2005]. As convers˜ oes ser˜ ao discutidas no Cap´ıtulo 25 – Convers˜ oes.

14.4

Senten¸ca para sobrecarga de m´ etodos

• Os valores de retorno n˜ ao s˜ ao avaliados em uma sobrecarga. • Um método com parˆ ametros predefinidos é uma sobrecarga. Programa¸caõ Orientada a Objeto com C++



298

• Se o método sobrecarregado recebe int, fa¸ca uma an´ alise das poss´ıveis convers˜ oes automáticas, ou seja, se for passado um tipo integral diferente de int, analise como este vai ser tratado. • 2 Um conjunto de métodos/fun¸co˜es sobrecarregados que executam os mesmos procedimentos, mas sobre tipos diferentes, podem ser substitu´ıdos por métodos/fun¸co˜es gabaritos. Veja Cap´ıtulo 27 – Templates (ou gabaritos).

14.5


Neste cap´ıtulo aprendemos o que é e como implementar a sobrecarga de métodos em C++. A grande vantagem da sobrecarga é o uso do mesmo nome para fun¸co˜es/métodos que ir˜ ao receber como parˆ ametros objetos de tipos diferentes. Vimos que a sobrecarga ocorre quando os parˆ ametros têm tipo diferente ou n´ umero de parˆ ametros diferente. Em alguns casos a sobrecarga pode apresentar ambig¨ uidade; normalmente isto ocorre em fun¸caõ das convers˜ oes impl´ıcitas de tipo.

14.6

Exerc´ıcios

1. Fa¸ca as modifica¸co˜es necess´ arias para que o programa da listagem 13.1 tenha todos os métodos com o mesmo nome (e funcione). 2. Implemente a classe CRetangulo descrita na Se¸caõ 13.10. N˜ ao se esque¸ca de fazer o diagrama de classes no umbrello. Inclua o uso de métodos sobrecarregados.



Cap´ıtulo 15

Ponteiros, Referˆ encias e Gerenciamento de Mem´ oria Uma das grandes vantagens de C++ em rela¸caõ a outras linguagens de programa¸caõ é sua capacidade de fornecer ao programador um controle refinado da memória consumida pelo programa. Isto é poss´ıvel gra¸cas ao seu mecanismo de gerenciamento de memória dinâmica por meio do uso dos operadores de new e delete. Veremos neste cap´ıtulo os ponteiros (Se¸caõ 15.2), a utiliza¸caõ destes para criar e usar objetos dinâmicos (Se¸caõ 15.3); o uso do operador new (Se¸caõ 15.3.1); o uso do operador delete (Se¸caõ 15.3.2); o ponteiro this (Se¸caõ 15.4); os ponteiros const (Se¸caõ 15.5); a utiliza¸caõ de referências (Se¸caõ 15.6); as diferen¸cas entre referência e ponteiro (Se¸caõ 15.6.1) e o uso de referências para ponteiros (Se¸caõ 15.6.2). Veremos ainda conceitos b´ asicos de gerenciamento de memória (Se¸caõ 15.7), como alinhamento (Se¸caõ 15.7.2), e d´ uvidas freq¨ uentes no uso de new e delete (Se¸caõ 15.7.3). Conceitos avan¸cados de ponteiros ser˜ ao descritos no Apêndice F – Ponteiros – Uso Avan¸cado. Veremos as opera¸co˜es com ponteiros (Se¸caõ F.1), o uso de ponteiro void* (Se¸caõ F.2) e de ponteiro para ponteiro (Se¸caõ F.3); a convers˜ ao de ponteiros (Se¸caõ F.4) e o uso de auto_ptr (Se¸caõ F.5); como implementar ponteiro de fun¸caõ (Se¸caõ F.6); ponteiros para métodos e atributos da classe (Se¸caõ F.7); e o uso de ponteiros em hierarquias (Se¸caõ F.8). Nota: o uso de ponteiros j´ a é conhecido por quem programa em C. As novidades deste cap´ıtulo est˜ ao associadas ao uso de const, new e delete e ao uso de referências.

15.1

Prot´ otipo para declarar e definir ponteiros e referˆ encias

Ponteiros s˜ ao objetos cujo conte´ udo é o endere¸co de outros objetos. Para declarar ponteiros, precedemos o nome do objeto pelo asterisco *, ou seja, para um tipo T, T* é um ponteiro. Uma referência pode ser encarada como um outro nome para um objeto, um apelido. Para declararmos uma referência colocamos Tipo& nomeDaRefer^ encia. Note que toda referência precisa ser inicializada na sua declara¸caõ. O operador &, como em &objeto, retorna o endere¸co do objeto, uma referência para o objeto. Veja o prot´ otipo a seguir. Observe que é boa prática de programa¸caõ inicializar todo ponteiro com o valor 0 (zero) ou com NULL. Note ainda que algo deve ser do tipo Tipo: 299

300

15.2. PONTEIROS

Ponteiro

Objeto

&obj

3

ptr

obj

int main() { int obj = 3; int* ptr; // (P1) ptr = &obj; // (P2) cout << obj << endl; cout << *ptr << endl; // P(3) return 0; }

Figura 15.1: Ilustra¸caõ da cria¸caõ e uso de ponteiros. Prot´ otipo: Tipo * ponteiro = 0; // Cria o ponteiro (1) Tipo objeto; // Cria o objeto ponteiro = &objeto; // Coloca o endere¸co do objeto no ponteiro (2) *ponteiro = algo; // Usa o ponteiro armazenando algo no objeto (3) // Cria uma referência para o objeto Tipo& nomeReferência = &objeto;

15.2

Ponteiros

O procedimento de cria¸caõ e uso de um ponteiro tem três etapas (veja Figura 15.1). Primeiro, cria-se o ponteiro (P1). Em seguida, coloca-se no ponteiro o endere¸co do objeto para o qual ele vai apontar, usando o operador endere¸co de & (P2). Finalmente, utiliza-se o ponteiro, usando o operador desreferencia * (P3). Na prática, os ponteiros s˜ ao utilizados para substituir os objetos originais. Sua vantagem est´ a associada ao seu pequeno tamanho. Assim, passar um ponteiro como parˆ ametro de um método é mais r´ apido e econˆ omico que passar uma c´ opia do objeto (veja Se¸caõ 13.6). Vamos explicar o funcionamento e a utiliza¸caõ dos ponteiros por meio de um exemplo hipotético. Digamos que o sistema de armazenamento de objetos em um programa funcione como o correio. A entrega de um pacote precisa do endere¸co de destino e de um carteiro, isto é, o carteiro deve pegar um valor e armazen´ a-lo no objeto. Para realizar este trabalho, o carteiro precisa do valor (ou seja, um pacote para entregar) e do endere¸co do objeto onde o valor deve ser armazenado (endere¸co de entrega). Quando você faz x = 3, est´ a dizendo para o carteiro pegar o valor 3 e levar até a casa de x. Um ponteiro pode ser imaginado como um endere¸cador indireto para o objeto. Veja o exemplo a seguir, o qual é ilustrado na Figura 15.2. • Cria objeto do tipo int, com nome x. O endere¸co de x é sua posi¸caõ na memória do computador; admita que o endere¸co de x é 1503. Exemplo: int x;

// Figura 15.2 (a)

• Diz para o carteiro levar o valor 3 até a casa de x (no n´ umero 1503). Programa¸caõ Orientada a Objeto com C++


˜ E USO DE OBJETOS DINAMICOS ˆ 15.3. CRIAC ¸ AO COM PONTEIROS x = 3;

301

// Figura 15.2 (b)

• Constr´ oi um objeto ponteiro, do tipo int*, com nome ptr. Conte´ udo de ptr = NULL. int* ptr = NULL;

// Figura 15.2 (P1) (c)

• Pega o endere¸co de x (1503) e o armazena na casa de ptr, o mesmo que ptr = 1503. ptr = & x ;

// Figura 15.2 (P2) (d)

• O carteiro pega o valor 7, vai até a casa de ptr, chegando a´ı, ele encontra o endere¸co de x e recebe instru¸caõ para levar o pacote até x. Em seguida, ele leva o valor 7 até x. *ptr = 7;

// Figura 15.2 (P3)

Memória do seu computador

.... Endereço de x = 1503

.... Endereço ptr=2673

....

x = lixo

....

x = 3

....

ptr=NULL

x = 3

....

ptr=1503

....

x = 7

....

ptr=1503

Memória do seu programa

Memória de outro programa

....

int main() { int x; // (a) x = 3; // (b) int * ptr = NULL;// (c) ptr = &x; // (d) *ptr = 7; // (e) std::cout << *ptr; return 0; }

Figura 15.2: Como declarar e usar um ponteiro. Note que para obter o endere¸co do objeto x, utiliza-se o operador de endere¸co (&), também chamado operador referência. Para utilizar o ponteiro para acessar o objeto x, utiliza-se o operador desreferência (*ptr). A constante NULL é predefinida com o valor 0. NULL e 0 s˜ ao utilizados para zerar os ponteiros. Veremos a seguir como os ponteiros s˜ ao usados para criar e manipular objetos criados em tempo de execu¸caõ (objetos dinˆ amicos).

15.3

Cria¸c˜ ao e uso de objetos dinˆ amicos com ponteiros

Os ponteiros s˜ ao utilizados na sua essência para criar, usar e apagar objetos dinamicamente. Mas por que devo usar objetos dinˆ amicos? A utiliza¸caõ de objetos dinâmicos possibilita ao programador ter um controle mais eficiente e flex´ıvel da mem´ oria utilizada. Quando os objetos s˜ ao alocados durante a compila¸caõ, o programador deve definir previamente o tamanho deles. No exemplo a seguir é criado um vetor de C para armazenar uma string com 50 caracteres. char nome[50]; Programa¸caõ Orientada a Objeto com C++


˜ E USO DE OBJETOS DINAMICOS ˆ 15.3. CRIAC ¸ AO COM PONTEIROS

302

Mas o que acontece se o nome tiver mais de 50 caracteres? Ocorrerá um estouro de pilha (acesso à mem´ oria inválida) e o seu programa ir´ a travar. E se o nome tiver apenas 20 caracteres? Ent˜ ao você estar´ a desperdi¸cando 30 caracteres. Para evitar o estouro de pilha e o desperd´ıcio de memória utilizam-se os objetos dinâmicos. Os objetos dinâmicos s˜ ao alocados (criados) com o operador new (Se¸caõ 15.3.1) e usam o bloco de memória disponibilizado pelo sistema operacional (pilha ou heap). Em seguida, s˜ ao usados e, ent˜ ao, devem ser destru´ıdos utilizando-se o operador delete (Se¸caõ 15.3.2).

15.3.1

O operador new

O operador new é utilizado para alocar dinamicamente um bloco de memória. Primeiro new solicita ao sistema operacional um bloco de mem´ oria. Ap´ os alocar o bloco de memória, new retorna um ponteiro para o bloco alocado. Se new falhar, retorna um bad_aloc (veja Cap´ıtulo 26 – Exce¸co˜es). Veja a seguir o prot´ otipo para usar new. Observe que new Tipo cria um objeto do tipo Tipo, e new Tipo [dimens~ ao] cria um vetor de objetos. Prot´ otipo: Tipo* ptrObjeto = new Tipo ; Tipo* ptrVetor = new Tipo [dimens˜ ao]; No exemplo que segue criamos um objeto inteiro com new e armazenamos o endere¸co em ptrInt. Exemplo: int * ptrInt = NULL; // Cria o ponteiro ptrInt = new int; // Aloca bloco de mem´ oria e cria objeto if( ptrInt == NULL ) // Se ocorreu erro na aloca¸ c~ ao sai do programa cerr < < "Erro aloca¸ c~ ao ptrInt" < < endl; ... usa ptrInt ... Neste outro exemplo criamos um vetor de caracteres e armazenamos o endere¸co em nomePessoa. Exemplo: char * nomePessoa = NULL; nomePessoa = new char [tamanhoNecess´ ario + 1]; if( nomePessoa == NULL ) cerr < < "Erro aloca¸ c~ ao nomePessoa" < < endl; ... usa nomePessoa ... Nota: a macro NULL é definida no arquivo de cabe¸calho e em outros cabe¸calhos de C. Nota: veremos na Se¸caõ 26.8.1 o uso de new (nothrow) e sua rela¸caõ com exce¸co˜es.

15.3.2

O operador delete

Para destruir o objeto e devolver a mem´ oria para o sistema operacional, utiliza-se o operador delete. Para deletar um vetor use delete [] ptrVetor;. Observe que apenas o bloco de mem´ oria é destru´ıdo. O ponteiro continua existindo e apontando para o bloco de mem´ oria que agora n˜ ao existe mais, ou seja, depois de usar delete ptrObjeto, o ponteiro aponta para um monte de lixo e n˜ ao deve ser utilizado. Depois de deletar o objeto é boa prática de programa¸caõ atribuir o valor NULL para o ponteiro. Programa¸caõ Orientada a Objeto com C++


˜ E USO DE OBJETOS DINAMICOS ˆ 15.3. CRIAC ¸ AO COM PONTEIROS

303

Se fizermos uma analogia com vari´ aveis comuns, inicializar ou setar o conte´ udo do ponteiro com NULL equivale a definir um valor inicial para uma variv´ avel qualquer (como um int), ou seja, n˜ ao existe muito sentido em termos vari´ aveis em nosso programa cujo conte´ udo é um monte de lixo. Prot´ otipo: delete ptrObjeto; ptrObjeto = NULL; delete [] ptrVetor; ptrVetor = NULL; No exemplo a seguir os ponteiros criados na Se¸caõ 15.3.1 são destru´ıdos. Exemplo: delete ptrInt; delete [] nomePessoa; Veja no exemplo da listagem 15.1 a utiliza¸caõ de objetos dinâmicos com ponteiros. A listagem inicia-se com a inclus˜ ao da biblioteca para entrada e sa´ıda de dados, incluindo ainda a classe CPonto (listagem 13.5). Observe que arquivos da biblioteca s˜ ao inclu´ıdos usando-se <> (estão dentro do diret´ orio-padr˜ ao para arquivos de inclus˜ ao; exemplo, /usr/include), e arquivos do programador s˜ ao inclu´ıdos usando-se ”” (estão no diret´ orio de trabalho). Na linha 9 criamos um ponteiro para CPonto (CPonto*), e o igualamos a NULL. Na linha 11 o objeto é alocado com new CPonto, note que new retorna o endere¸co do objeto criado para o ponteiro (agora o ponteiro aponta para o objeto criado). Na linha 12 verificamos a aloca¸caõ com if(ptr == NULL). Depois de criado o objeto dinˆ amico, o objeto é utilizado, ptr->Set(x, y);, ptr->Desenha();. Compare este exemplo com o apresentado na listagem 13.7; naquele utilizávamos mecanismos est´ aticos para criar o objeto CPonto; neste usamos mecanismos dinâmicos. Listing 15.1: Usando ponteiros para criar e usar objetos dinâmicos. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# include < iostream > # include " CPonto . h " using namespace std ; // E x e m p l o de c r i a ¸ c~ a o e uso do objeto CPonto int main () { int x = 6; int y = 7; CPonto * ptr = NULL ; ptr = new CPonto ; if ( ptr == NULL ) { cout << " Falha aloca¸ ca ~o . " return 1; } ptr - > Set (x , y ) ; ptr - > Desenha () ; int xx = ptr - > X () ; delete ptr ; return 0; }

// // // //

Cria p o n t e i r o para objeto do tipo CPonto Cria objeto do tipo CPonto e coloca e n d e r e ¸ c o em ptr . Testa a l o c a ¸ c~ ao

<< endl ;

// // // // // //

Chama m´ e todo Set () do objeto ptr Chama m´ e todo D e s e n h a () Chama m´ e todo X () que r e t o r n a x Destr~ o e o objeto a p o n t a d o por ptr Encerra o programa ptr sai de escopo e ´ e destru´ ıdo

[ b u e n o @ l d s c 0 5 Cap -15] $ make P r o g C P o n t o D i n a m i c o g ++ -g - O2 -o P r o g C P o n t o D i n a m i c o P r o g C P o n t o D i n a m i c o . o CPonto . o [ b u e n o @ l d s c 0 5 Cap -15] $ ./ P r o g C P o n t o D i n a m i c o TPonto : Coordenada x =6 TPonto : Coordenada y =7



304

15.4. PONTEIRO THIS

Observe que com objetos est´ aticos usa-se nomeobjeto.atributo, e com objeto dinâmicos, troca-se o ponto (.) pela seta (->) nomeobjeto->atributo. Se você deseja acessar um método de um objeto dinâmico, pode usar uma das duas op¸co˜es que seguem: Exemplo: ptr->M´ etodo(); *ptr.M´ etodo(); Otimiza¸ c˜ ao: toda opera¸caõ de aloca¸caõ com new e desaloca¸caõ com delete tem um custo em termos de tempo de processamento. Se o desempenho do programa é importante, ent˜ ao deve ser feita uma otimiza¸caõ do programa com o objetivo de reduzir as o n´ umero de opera¸co˜es com new e delete.

15.4

Ponteiro this

Na parte de an´ alise orientada a objeto (Cap´ıtulo 3 – Conceitos Básicos de POO), vimos que a classe é definida como uma f´ abrica de objetos e que é a classe que define a forma do objeto. Vimos ainda que, quando se cria um objeto, é reservado espa¸co na memória para inclus˜ ao de todos os atributos n˜ ao est´ aticos do objeto e n˜ ao é reservado espa¸co para os métodos. Assim, um objeto na memória do computador contém somente atributos (veja as Figuras 12.1 e 12.2). Os métodos n˜ ao s˜ ao criados para cada objeto; eles ficam armazenados na classe. Isto faz sentido, pois dois objetos da mesma classe ter˜ ao atributos diferentes, mas os métodos ser˜ ao os mesmos. Quando um objeto acessa um de seus métodos, ele est´ a acessando os métodos da classe. Como os métodos s˜ ao os mesmos para todos os objetos da classe é necess´ ario um dispositivo de identifica¸caõ de qual objeto est´ a acessando o método. Esse dispositivo é implementado por meio do ponteiro this. Por meio deste, o método da classe sabe qual objeto o est´ a acessando. Veja a seguir um exemplo de método que usa o ponteiro impl´ıcito this para acessar o atributo x. Exemplo: class CPonto { int x, y; public: int X(int _x) { x = _x ; } int X() { return this->x; } }; int main() { CPonto objeto; int vx = 4; objeto.X(vx); cout < < objeto.X(); return 0; }

// Atributos // M´ etodo que seta x // M´ etodo que retorna x // Uso de this

// Cria objeto // Acessa m´ etodo int X(int) da classe CPonto // Acessa m´ etodo int X() da classe CPonto

O compilador traduz a sua chamada ao método X(int) da seguinte forma: Programa¸caõ Orientada a Objeto com C++


15.5. PONTEIROS CONST E PONTEIROS PARA CONST Exemplo: X(const Tipo* this = &objeto, vx);

305

// Tradu¸ c~ ao para C

Ou seja, this é um ponteiro para o objeto que é passado implicitamente para o método. Exemplo: this = &objeto;

// this cont´ em o endere¸ co do objeto.

• Observe que, quando um objeto chama um método da classe, ele passa para o método o seu endere¸co por meio do ponteiro this. Dessa forma, ao utilizar um atributo x, na realidade o método est´ a utilizando this->x. Assim, this é um ponteiro que é passado implicitamente a um método da classe, informando qual objeto o est´ a acessando. • Um ponteiro this da classe T é do tipo T* const, isto é, aponta sempre para o mesmo objeto. • Um método est´ atico n˜ ao recebe um ponteiro this, ou seja, n˜ ao sabe qual objeto est´ a acessando. Este é o motivo pelo qual um método est´ atico só pode acessar atributos est´ aticos. • Se um método é const, seu ponteiro this é do tipo const T* const, isto é, aponta sempre para o mesmo objeto, e este n˜ ao pode ser alterado. Exemplo com uso de this é apresentado na listagem 17.2.

15.5

Ponteiros const e ponteiros para const

A palavra-chave const é utilizada para informar que o objeto é constante, n˜ ao muda. Pode ser utilizada com ponteiros, significando que o ponteiro aponta sempre para o mesmo local de memória ou que o objeto apontado n˜ ao muda, ou ambos. Entenda a seguir as diferentes formas de uso de const com ponteiros.

15.5.1

Ponteiro para um objeto constante

O conte´ udo do objeto apontado é constante, mas o ponteiro pode ser utilizado para apontar para outros objetos. Exemplo: int a = 1; int b; const int *ptrC = &a; b = *ptrC; *ptrC = 6; ado ´ e const ptrC = &b; &a

// // // //

Cria ponteiro para const int que aponta para a. Ok, b recebe o conte´ udo de a Erro, ptrC n~ ao pode ser desreferenci-

// Ok, ponteiro aponta para b a=1

&b

a=6

ptrC

ptrC b =1


b =1

ptrC pode apontar para a ou b, mas não pode mudar o conteúdo de a ou b.


ˆ 15.6. REFERENCIAS (&)

306

15.5.2

Ponteiro constante

Quando o ponteiro aponta para o mesmo local da memória, o objeto apontado pode ser alterado. Exemplo: int a = 3; int b = 4; int* const cPtr = &a; b = *cPtr; *cPtr = 5; cPtr = &b; jeto. &a

// // // //

a=3

cPtr

Ok, cria o ponteiro e inicializa Ok, b recebe o conte´ udo de a (b = 3) Ok, a recebe o valor 5 (a = 5) Erro, cPtr aponta sempre para o mesmo ob-

&a cPtr

b =4

15.5.3

a=5

b =4

cPtr pode mudar o conteúdo de a. Mas não pode apontar para b.

Ponteiro constante para um objeto constante

Neste caso tanto o ponteiro como o objeto apontado n˜ ao podem ser alterados. Exemplo: double a = 3.1415; const double * const cPtrC = &a; double b = 7.2; *cPtrC = 6.2; // Erro, o conte´ udo do objeto apontado n~ ao pode mudar cPtrC = &b; // Erro, cPtrC aponta sempre para o mesmo endere¸ co &a

a = 3,1415

&a cPtrC

cPtrC b =7.2

15.6

a=5

cPtrC não pode apontar para b, nem mudar o conteúdo de a.

b =4

Referˆ encias (&)

Uma referência pode ser encarada como um outro nome para um objeto, um apelido. Ela deve ser definida uma u ´ nica vez, dessa forma apontar´ a sempre para o mesmo local da memória (para o mesmo objeto). Na prática referências s˜ ao utilizadas como parˆ ametros de métodos e fun¸co˜es. Veja Se¸caõ 13.6. • Referências para ponteiros costumam ser utilizadas como parˆ ametros de métodos. • Uma referência n˜ ao pode ser alterada para referenciar outro objeto ap´ os sua inicializa¸caõ (ou seja, uma referência se comporta como um ponteiro constante). • Como as referências n˜ ao s˜ ao objetos, n˜ ao podem existir matrizes de referências. Com rela¸caõ às referências n˜ ao podemos: Programa¸caõ Orientada a Objeto com C++


ˆ 15.6. REFERENCIAS (&)

307

• N˜ ao podemos declarar referências de referências. • N˜ ao podemos declarar referências para membros de classe. • N˜ ao podemos declarar um ponteiro para uma referência. • N˜ ao podemos declarar um array de referências. Veja a seguir o prot´ otipo e um exemplo de uso de referências. Prot´ otipo: Tipo& nomeReferência = &objeto; Exemplo: int v1 = 5; int algo = 3; int v2; // Declara uma refer^ encia a v1, ou seja, refV1 ´ e o mesmo que v1 int& refV1 = v1; // Para armazenar v1 em v2 v2 = refV1; // Para armazenar algo em v1 usando a refer^ encia refV1 = algo; // O endere¸ co da refer^ encia ´ e igual ao endere¸ co do objeto referenciado. // Armazena endere¸ co de v1 em ptr int* ptr = &refV1; A listagem 15.2 mostra o uso de referências. Listing 15.2: Usando referências. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# include < iostream > using namespace std ; int main () { int x = 3; // tipo = int , nome =x , valor =3 int & ref = x ; // tipo = r e f e r ^ e n c i a para inteiro , nome = ref , valor = x // Daqui para frente , ref ´ e a mesma coisa que x . cout << " Valor de x = " << x << " \ tValor da ref = " << ref << endl ; ref = 156; cout << " Mudou ref " << endl ; cout << " Valor de x = " << x << " \ tValor da ref = " << ref << endl ; x = 6; cout << " Mudou x " << endl ; cout << " Valor de x = " << x << " \ tValor da ref = " << ref << endl ; return 0; } bash -3.00 $ Valor de x Mudou ref Valor de x Mudou x Valor de x

./ a . out = 3

Valor da ref = 3

= 156

Valor da ref = 156

= 6

Valor da ref = 6

Vimos na Se¸caõ 13.6 a passagem de parˆ ametros em métodos, incluindo o uso de referências. Reveja a listagem 13.2. Programa¸caõ Orientada a Objeto com C++


2 ´ ´ 15.7. CONCEITOS BASICOS DE GERENCIAMENTO DE MEMORIA

308

15.6.1

Diferen¸cas entre referˆ encia e ponteiro

Uma referência n˜ ao reserva espa¸co na mem´ oria para si própria, ao contrário dos ponteiros, que reservam um espa¸co na mem´ oria. Observe que existe ponteiro de ponteiro (veja Se¸caõ F.3), mas n˜ ao existe referência de referência.

15.6.2

Referˆ encias para ponteiros

Você pode declarar uma referência para um ponteiro, ou seja, um outro nome para um ponteiro. Veja o exemplo que segue e a listagem 13.2. Exemplo: int x = 3; int * ponteiro = &x; Tipo * & referenciaDePonteiro = ponteiro;

15.7

Conceitos b´ asicos de gerenciamento de mem´ oria2

O desenvolvimento de softwares avan¸cados, principalmente o de softwares cient´ıficos, requer um controle mais refinado da mem´ oria utilizada pelo programa. Um dos pontos cr´ıticos em programa¸caõ cient´ıfica é o eficiente controle da rela¸cão memória consumida versus tempo de processamento. Veremos nesta se¸caõ alguns conceitos b´ asicos de gerenciamento de memória. Nota: veremos na Se¸caõ 21.8 como sobrecarregar o operador new de C++.

15.7.1

Entendendo o uso de new/delete com vetores

• Quando uso int* v = new int[n]; aloco um vetor de inteiros de tamanho n. Posteriormente deleto o bloco de mem´ oria com delete [] v. A pergunta é: como o compilador sabe o tamanho do bloco a ser deletado? – A maioria dos compiladores coloca, imediatamente antes da casa v[0], um espa¸co para um unsigned int (ou similar), no qual o tamanho n é armazenado. Note que se o vetor armazenar objetos grandes, o espa¸co consumido para armazenar a dimensão do vetor continuar´ a sendo – provavelmente – do tamanho de um unsigned int. Veja Figura 15.3.

15.7.2

Alinhamento

Vamos iniciar nossa discuss˜ ao apresentando um exemplo e uma pergunta. Na listagem 15.3, por que o sizeof(C1) é diferente de sizeof(C2)? Listing 15.3: Entendendo o alinhamento. 1 2 3 4 5 6 7 8 9

# include < iostream > using namespace std ; class C1 { char ca ; int x ; char cb ;}; class C2 { char ca ; char cb ; int x ;}; class C3 { char ca ; char cb ; char cc ; char cd ; int x ;}; int main () {




309

Figura 15.3: Consumo real de memória de um vetor de inteiros. int * v = new int[n]; A dimensão do vetor é armazenada na posição v[-1]. Desta forma, delete [] v; sabe o tamanho do bloco a ser destruído.

v n

v[0]

v[1]

v[2]

v[3]

v[4]

.......

v[n-1]

sizeof(v) Bloco de memória solicitado

Bloco de memória efetivamente alocado

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

C1 vC1 [10]; C2 vC2 [10]; C3 vC3 [10]; cout << " Consumo individual de C1 -> sizeof ( char ) *2 + sizeof ( int ) = " << sizeof ( char ) *2 + sizeof ( int ) << " \ nsizeof ( C1 ) = " << sizeof ( C1 ) << " \ tsizeof ( vC1 ) = " << sizeof ( vC1 ) << " \ n \ nConsumo individual de C2 -> sizeof ( char ) *2 + sizeof ( int ) = " << sizeof ( char ) *2 + sizeof ( int ) << " \ nsizeof ( C2 ) = " << sizeof ( C2 ) << " \ tsizeof ( vC2 ) = " << sizeof ( vC2 ) << " \ n \ nConsumo individual de C3 -> sizeof ( char ) *4 + sizeof ( int ) = " << sizeof ( char ) *4 + sizeof ( int ) << " \ nsizeof ( C3 ) = " << sizeof ( C3 ) << " \ tsizeof ( vC3 ) = " << sizeof ( vC3 ) << endl ; return 0; } Consumo individual de C1 -> sizeof ( char ) *2 + sizeof ( int ) = sizeof ( C1 ) = 12 sizeof ( vC1 ) = 120

6

Consumo individual de C2 -> sizeof ( char ) *2 + sizeof ( int ) = sizeof ( C2 ) = 8 sizeof ( vC2 ) = 80

6

Consumo individual de C3 -> sizeof ( char ) *4 + sizeof ( int ) = sizeof ( C3 ) = 8 sizeof ( vC3 ) = 80

8

A resposta é o alinhamento, um dos conceitos b´ asicos associados ao gerenciamento do consumo de mem´ oria. A idéia é simples: quando um bloco de memória é alocado, o mesmo é feito sempre em peda¸cos m´ınimos de bytes de tamanho m. Isto significa que, se alocamos um bloco de tamanho n, sendo n


310

Figura 15.4: Desperd´ıcio de mem´ oria em fun¸caõ do alinhamento. Um objeto:

1 ca 4 x

(a)

C1 desperdício com alinhamento

1 cb

1 ca

(b)

sizeof(Objeto)

C2 desperdício com alinhamento

4 x 1 1 1 1 ca cb cc cd 4 x

Um vetor de objetos:

Objeto[0] atributos

1 cb

Objeto[1] atributos

C3 sem desperdício

Objeto[2] atributos

.....

Desperdício de memória com alinhamentos

declara¸caõ da classe C2 é mais econˆ omica, pois a ordem utilizada reduz a perda de memória provocada pelo alinhamento. Note que a classe C3 tem o melhor aproveitamento da memória. ´ importante entender que podemos diminuir este desperd´ıcio mas n˜ E ao o evitar totalmente. A dica é simples: declare atributos do mesmo tipo em seq¨ uência. Em seguida, use o operador sizeof() para ver o tamanho efetivo da classe criada. Você pode reorganizar a ordem dos atribudos até encontrar o menor sizeof() poss´ıvel. Se tivermos um vetor de objetos, Figura 15.4(b), teremos um desperd´ıcio maior, associado ao alinhamento entre os objetos. Isso também depende do tamanho do objeto.

15.7.3

D´ uvidas frequ ëntes no uso de new, delete e gerenciamento de 2 mem´ oria

Veremos a seguir algumas d´ uvidas comuns associadas ao uso dos operadores new e delete e ao gerenciamento de mem´ oria, além de algumas respostas curtas e diretas. D´ uvidas b´ asicas • Se um ponteiro ptr tem valor NULL, qual o efeito de delete ptr? – delete ptr n˜ ao faz nada quando ptr == NULL. • O comando delete ptr exclui o ponteiro ptr ou o dado apontado por *ptr? – Exclui o dado; o ponteiro continua existindo. • Posso deletar um bloco de mem´ oria alocado com new usando free? – N˜ ao. N˜ ao podemos misturar o uso dos operadores de C++ new/delete com as fun¸co˜es de aloca¸caõ de C malloc() e free(). Veja a listagem ??. • Um vetor de tamanho n e tipo T consome quanto bytes? Programa¸caõ Orientada a Objeto com C++



311

– Provavelmente n*sizeof(T) + sizeof(unsigned int), ou seja, o tamanho do bloco a ser utilizado mais o tamanho de um inteiro em que é armazenado o tamanho n do vetor criado. Veja Figura 15.3. • 2 Ap´ os usar new, preciso realmente testar a aloca¸caõ com if(ptr != NULL)? – N˜ ao. Como visto no Cap´ıtulo 26 – Exce¸co˜es, quando new falha, ele lan¸ca exce¸co˜es que podem ser tratadas externamente (fora do bloco try). • 2 Veremos como sobrecarregar o operador new na Se¸caõ 21.8. • 2 Posso evitar que um objeto seja est´ atico? – Sim, mas neste caso todos os construtores da classe CNome devem ser privados e você deve fornecer métodos p´ ublicos e est´ aticos que criam objetos do tipo CNome usando new. Veja o exemplo a seguir; observe, dentro de main(), que precisamos chamar os métodos p´ ublicos. Exemplo: class CNome { public: // M´ etodos p´ ublicos static CNome* New() { return new CNome(); } static CNome* New(int n) { return new CNome[n]; } static CNome* New(const CNome& obj) { return new CNome(obj); } // Construtores privados (n~ ao podem ser chamados) private: CNome(); CNome(const CNome& obj); }; int main() { CNome* p = CNome::New(); // Cria um objeto CNome* ptrV = CNome::New(10); // Cria um vetor de objetos delete p; delete ptrV; return 0; } D´ uvidas associadas ao uso de exce¸ co ˜es2 • O que acontece se um construtor lan¸car uma exce¸caõ? – O objeto é destru´ıdo, e a mem´ oria é devolvida para o sistemas operacional. • O uso de set_new_handler(f)garante que a fun¸caõ definida f sempre ser´ a utilizada? – N˜ ao. Vimos na Se¸caõ 16.6.3 que objetos globais est´ aticos s˜ ao constru´ıdos antes da execu¸caõ de main(), ou seja, antes de executar set_new_handler(f). Isto significa que, se um objeto est´ atico chamar uma determinada fun¸caõ, que usa new, ser´ a utilizada a fun¸caõ new_handler padr˜ ao do sistema e n˜ ao a que definimos. Programa¸caõ Orientada a Objeto com C++


ˆ 15.8. SENTENCAS ¸ PARA PONTEIROS, REFERENCIAS E GERENCIAMENTO DE ´ 312 MEMORIA D´ uvidas associadas ao uso da STL21 • O que s˜ ao os gerenciadores de mem´ oria (ou alocadores) da STL? – s˜ ao objetos da STL utilizados para construir os containers. De modo geral, cada container tem um gerenciador de mem´ oria padr˜ ao. • Um container de tamanho n e tipo T consome quanto bytes? – Depende do tipo de container e de informa¸co˜es associadas ao alinhamento dos atributos. A dica é simples: construa o container usando diferentes tipos de container e fa¸ca testes para ver qual consome menos memória. • Qual container da STL é mais econˆ omico? – O container mais econˆ omico é vector. Basicamente vector consome n*sizeof(T) + sizeof(int). N˜ ao existe overhead em um vector. – Em um container deque s˜ ao criados diversos blocos de dados. O gerenciamento desses blocos implica em um pequeno aumento do consumo de memória (da ordem de ˜4%). Para saber o valor exato, construa um vector, um deque e veja a diferen¸ca no consumo de mem´ oria. – Em uma lista , veja Se¸caõ 32.2, cada elemento deve armazenar dois iteradores extras (veja Figura 32.3), ou seja, cada elemento da lista vai consumir pelo menos o tamanho do objeto armazenado mais o tamanho de dois iteradores. – Os containers e trabalham com três ponteiros extras, ou seja, cada elemento do vai consumir pelo menos o tamanho do objeto armazenado mais o tamanho de três iteradores. – Os containers e também trabalham com três ponteiros extras, mas neste caso s˜ ao três pairs, de modo que first é a chave e second o valor, ou seja, cada elemento do vai consumir pelo menos o tamanho do objeto armazenado mais o tamanho de três iteradores para pares pair. – A dica de otimiza¸caõ de mem´ oria é: construa seu programa utilizando diferentes tipos de containers e verifique qual o mais econˆ omico.

15.8

Senten¸cas para ponteiros, referˆ encias e gerenciamento de mem´ oria

• Se o ponteiro aponta para NULL, o uso de delete ptr; n˜ ao tem efeito. • Se uma fun¸caõ retorna uma referência para um objeto, ela pode aparecer à esquerda do operador =. Exemplo: // Declara¸ c~ ao e defini¸ c~ ao de m´ etodo int & Valor(int &i){ return i; }; int x; Valor(x) = 234; 1 Veremos

a STL na Parte III: Introdu¸ c˜ ao a STL.




313

• Evite retornar referências, ponteiros ou iteradores para atributos internos do objeto. Isto deixa o c´ odigo mais encapsulado. • Em C a chamada a f(a,b) passa para f uma c´ opia de a e de b (a e b n˜ ao ser˜ ao alterados); a chamada a f2(&a,&b), por sua vez, passa para f2 ponteiros para a e b, indicando que a e b poder˜ ao ser alterados. Em C++, a chamada a f(a,b) n˜ ao informa se a e b ser˜ ao ´ necess´ passados por c´ opia ou por referência. E ario conferir isso no arquivo de declara¸caõ da classe. • Se o parˆ ametro de um método/fun¸caõ é do tipo integral e n˜ ao pode ser alterado, ele pode ser passado por c´ opia. Isto se justifica porque os tipos integrais s˜ ao copiados de forma muito r´ apida, sendo inclusive mais r´ apidos que o uso de referências. • Ao criar objetos locais, usando new, verifique se eles s˜ ao destru´ıdos. • Para possibilitar a chamada de métodos encadeados, o método deve retornar um objeto (um lvalue). No exemplo a seguir o método retorna uma referência ao próprio objeto. Exemplo: Tipo& CNomeClasse::M1() { return *this; } // Uso ( (obj.M1() ).M2() ).M3(); • Em linguagens como Smalltalk e Java todos os objetos s˜ ao acessados com ponteiros. • Somente sobrecarregue new e delete como métodos est´ aticos. • 2 Lembre-se de que delete ptr executa operator delete(void*); já delete[] ptr chama operator delete[] (void*). • 3 Bugs: Digamos que você deseja passar um objeto como parˆ ametro para um método Método(nomeclasse obj). Como você est´ a passando o objeto por c´ opia, vai criar uma c´ opia do objeto. Depois vai usar o objeto dentro do método e, ao encerrar o método, o objeto ser´ a deletado. Se o objeto original tinha algum ponteiro com aloca¸caõ dinâmica, esse ponteiro ser´ a deletado, sendo deletado o bloco de memória por ele acessado. Assim, o ponteiro do objeto original aponta agora para um monte de lixo. Para que isso n˜ ao ocorra, você deve passar uma referência do objeto, de forma que é passado o próprio objeto e n˜ ao uma c´ opia deste, e, quando sair de escopo, o objeto n˜ ao ser´ a eliminado. Outra solu¸caõ é sempre implementar o construtor de c´ opia (veja Se¸caõ 16.5.1).

15.9


Normalmente o aprendizado de ponteiros em C é confuso e complicado. Isto ocorre porque C n˜ ao tem o conceito de referências, e, portanto, tem-se de usar em demasia os ponteiros. Mais do que isto, é normal em C o uso excessivamente elaborado de ponteiros. Programadores ”experientes” abusam dos ponteiros e deixam o c´ odigo ileg´ıvel para os programadores comuns. A dica é: use e abuse dos ponteiros, mas n˜ ao deixe o c´ odigo rebuscado demais – isto atrapalha mais do que ajuda. Neste cap´ıtulo aprendemos que um ponteiro é um objeto pequeno que armazena o endere¸co de outro objeto. Aprendemos a criar e usar objetos dinâmicos usando o operador new e a deletá-los usando o operador delete. A grande vantagem é que temos um controle refinado Programa¸caõ Orientada a Objeto com C++


15.10. EXERCÍCIOS

314

do uso da memória. Vimos ainda que o ponteiro oculto this é um ponteiro para o objeto que chamou o método. Aprendemos a usar as diferentes varia¸co˜es de ponteiros com const. Aprendemos a utilizar as referências de C++ e suas diferen¸cas em rela¸caõ aos ponteiros. No final do cap´ıtulo, vimos os conceitos b´ asicos de gerenciamento de memória. Nota: o uso de vetores no estilo de C é apresentado no Apêndice H – Vetores e Matrizes – Arrays.

15.10

Exerc´ıcios

1. Qual a vantagem do uso de ponteiros e aloca¸caõ dinâmica de memória? 2. Releia a listagem 13.1. 3. Explique com suas palavras o funcionamento de new e delete. 4. Explique com suas palavras o funcionamento de this. 5. Comece modificando a listagem 15.1. Acrescente objeto com uso normal de CPonto e compare os c´ odigos. 6. Monte um exemplo que use os conceitos apresentados na Se¸caõ 15.2. Justifique a vantagem do uso de ponteiros const. 7. Crie um exemplo que utilize ponteiros normais, ponteiros para objetos que n˜ ao podem mudar, e ponteiros que n˜ ao podem ser usados para apontar outros objetos. 8. Para que servem as referências? 9. Monte um exemplo que inclua o uso de referências. 10. Quando o uso de referências para ponteiros é interessante? Monte um exemplo. 11. Crie exemplo que inclua o uso de um vetor de bool com n elementos. Um ponteiro deve ser utilizado para alocar dinamicamente o vetor, e para acessar seus elementos. O usuário deve poder visualizar e modificar cada bit, tendo como base perguntas simples cuja resposta seja sempre verdadeiro/falso. 12. Crie exemplo que tenha a seguinte configura¸caõ: duas fun¸co˜es globais que incluam a cria¸caõ de objetos est´ aticos com valores predefinidos (inicializados com 0). A cada vez que uma fun¸caõ é chamada, seus valores s˜ ao atualizados (por exemplo contadores). Crie uma classe com um método normal, mas que tenha parˆ ametros predefinidos, os quais devem ser inicializados com os valores das fun¸co˜es globais. Comente o exerc´ıcio.



Cap´ıtulo 16

M´ etodos Construtores e Destrutores Descreveremos neste cap´ıtulo a implementa¸caõ e uso dos métodos construtores e destrutores. Faremos uma introdu¸caõ aos métodos construtores e destrutores (Se¸caõ 16.1), suas caracter´ısticas e prot´ otipos (Se¸caõ 16.2). A seguir veremos o construtor default (Se¸caõ 16.3);a inicializa¸caõ dos atributos no construtor (Se¸caõ16.4); o construtor de c´ opia T(const T& obj) (Se¸caõ 16.5); quando um objeto é constru´ıdo/destru´ıdo (Se¸caõ 16.6); a ordem de constru¸caõ dos atributos de um objeto (Se¸caõ 16.6.1) e a ordem de destrui¸caõ dos atributos (Se¸caõ 16.6.2); a constru¸caõ de objetos globais est´ aticos (Se¸caõ 16.6.3); conceitos b´ asicos de construtor e ambig¨ uidade (Se¸caõ 16.7). Veremos ainda temas avan¸cados na Se¸caõ 16.8, incluindo: construtor e ambig¨ uidade (Se¸caõ 16.8.1) e construtor e interface (Se¸caõ 16.8.2).

16.1

Introdu¸ c˜ ao aos m´ etodos construtores e destrutores

Veremos nesta se¸caõ uma introdu¸caõ aos métodos construtores e destrutores, isto é, suas caracter´ısticas. Caracter´ısticas dos m´ etodos construtores Nas listagens apresentadas até aqui, ap´ os construir um objeto precisávamos iniciar os atributos; método Entrada() na listagem 13.2, método Inicializa() na listagem 13.3, método Set() na listagem 13.5. N˜ ao seria interessante se pudéssemos ter métodos especiais para iniciar os objetos automa´ exatamente isso o que fazem os construtores. ticamente quando os mesmos s˜ ao constru´ıdos? E Veja a seguir algumas caracter´ısticas dos construtores: • Um método construtor é um método como outro qualquer; a diferen¸ca é que esse é automaticamente executado quando o objeto é criado. • O objetivo b´ asico dos construtores é inicializar os atributos do objeto. • Além de inicializar os atributos do objeto, podemos realizar outras tarefas. Por exemplo: se sua classe representa uma impressora, você pode verificar se existe uma impressora conectada ao sistema. 315

´ 16.2. PROTOTIPO PARA CONSTRUTORES E DESTRUTORES

316

• Um método construtor tem o mesmo nome da classe e n˜ ao retorna nada, nem mesmo void. • Por padr˜ ao da linguagem, os métodos construtores n˜ ao podem ser const nem volatile. • Crie vari´ aveis dinˆ amicas no construtor com new e apague no destrutor com delete (Se¸caõ 15.3). • 2 Um construtor n˜ ao pode ser virtual, mas pode ser sobrecarregado (veja Cap´ıtulo 14 – Sobrecarga de Métodos). Quando criamos um objeto (exemplo: CNome objeto;), a seq¨ uência de constru¸caõ é dada por: • Solicita¸caõ de mem´ oria para o sistema operacional (para armazenar os atributos do objeto). • Cria¸caõ dos atributos do objetos. • Execu¸caõ do c´ odigo do construtor da classe. Caracter´ısticas dos m´ etodos destrutores Os métodos destrutores têm o objetivo de destruir o objeto e devolver para o sistema operacional a memória alocada, fazendo o trabalho inverso do construtor. Veja a seguir algumas caracter´ısticas do destrutor: • Tem o mesmo nome da classe antecedido pelo til (~). • N˜ ao retorna nada, nem mesmo void. • N˜ ao pode ter parˆ ametros. • N˜ ao pode ser sobrecarregado. • N˜ ao pode ser static, const nem volatile. • Em cada classe, devemos ter um u ´ nico destrutor. • Faz o trabalho inverso do construtor. Deve liberar a memória alocada no construtor e destruir os objetos dinˆ amicos. • O destrutor é automaticamente executado quando o objeto sai de escopo.

16.2

Prot´ otipo para construtores e destrutores

Veja a seguir o prot´ otipo para declara¸caõ dos métodos construtores e destrutores. Ao lado do prot´ otipo est´ a o n´ umero da se¸caõ em que o mesmo ser´ a discutido. Observe que o método construtor tem o mesmo nome da classe e n˜ ao retorna nada, nem mesmo void. O método destrutor também n˜ ao retorna nada e tem o mesmo nome da classe precedido do til (~). Prot´ otipo: class CNome { CNome(); Programa¸caõ Orientada a Objeto com C++

// Construtor default, veja se¸ca õ 16.3 André Duarte Bueno

16.3. CONSTRUTOR DEFAULT T()

317

CNome(parˆ ametros); // Construtor sobrecarregado, veja se¸ca õ 16.3 CNome(const CNome& obj); // Construtor de c´ opia, veja se¸ca õ 16.5 CNome(const CNome& obj, int=0); // Construtor de c´ opia, veja se¸ca õ 16.5 Tipo(); // Construtor de convers˜ ao, veja se¸ca õ 25.3 ˜CNome(); // Destrutor , veja se¸ca õ 16.1 virtual ˜CNome(); // Destrutor virtual, veja se¸ca õ 19.2 }; // Implementa¸ca õ dos construtores CNome::CNome(parˆ ametros) : atributo1(valorInicial), atributo2(valorInicial),... // veja se¸ca õ 16.4 {....c´ odigo do construtor.... } // Implementa¸ca õ dos destrutores CNome::˜CNome() {....c´ odigo do destrutor.... }

16.3

Construtor default T()

• Se você n˜ ao criar um método construtor, o compilador cria – automaticamente – um construtor vazio, que n˜ ao recebe nenhum parˆ ametro e é chamado de construtor default. Veja o prot´ otipo na Se¸caõ 16.2. No exemplo a seguir, o compilador cria um método construtor default para a classe CNomeClasse. Exemplo: class CNomeClasse { int a; // O compilador cria automaticamente o construtor // a seguir, sem par^ ametros e vazio // CNomeClasse(){}; }; int main() { CNomeClasse obj2(); // ok, usa o construtor default. } • Caso seja de seu interesse, você pode implementar o construtor default. class CNomeClasse { int a; public: CNomeClasse(){ a = 0; }; };

// (1)

• Observe que, se você criar um construtor com parˆ ametros, deixa de existir o construtor default. Exemplo: class CNomeClasse Programa¸caõ Orientada a Objeto com C++


318

˜ DOS ATRIBUTOS DA CLASSE NOS CONTRUTORES 16.4. INICIALIZAC ¸ AO { int a; public: // Construtor criado CNomeClasse(int _a){ }; int main() { CNomeClasse obj1(5); CNomeClasse obj2(); }

pelo programador, recebe um int a = _a; }; // (2)

// ok, usa (2) // Erro, n~ ao existe um construtor default

• Se na classe existirem atributos referências ou atributos const, o compilador n˜ ao criar´ a o construtor default. Neste caso, você ter´ a de implementar o construtor default (sem parˆ ametros). Isto ocorre porque você precisa inicializar os atributos const e as referências. Exemplo: class CNomeClasse { public: int a, b; const int c;

// Atributos normais // Atributo const // Construtor com par^ ametros CNomeClasse(int _a,int _b,int _c) : a(_a),b(_b),c(_c) {}; };

• Um vetor no estilo de C s´ o pode ser contru´ıdo se a classe tiver um construtor default. Veja o exemplo: int main() { // Cria vetor de objetos do tipo CNomeClasse, com 30 elementos CNomeClasse vetorEstatico [30]; // ok, usa (1) return 0; } • Se um atributo CX da classe CNomeClasse for um tipo do usuário que n˜ ao tem um construtor default, ent˜ ao o construtor de CX deve ser explicitamente chamado. • Crie sempre um construtor default, assim você evita problemas.

16.4

Inicializa¸c˜ ao dos atributos da classe nos contrutores

Os atributos do objeto podem (e devem) ser inicializados no construtor, o prot´ otipo de inicializa¸caõ dos atributos da classe no construtor é dado a seguir. Depois do nome do construtor e de seus parˆ ametros, observe o uso de : e, em seguida, a lista de atributos com seus valores separados por v´ırgula. Observe que, ao inicializar o atributo ap´ os :, este é inicializado na sua constru¸caõ, o que é mais r´ apido do que atribuir um valor ao atributo dentro do construtor. Programa¸caõ Orientada a Objeto com C++


´ 16.5. CONSTRUTOR DE COPIA T(CONST T& OBJ)

319

Prot´ otipo: CNomeClasse(T1 v1, T2 v2,..,TN vn) :atributo1(v1),atributo2(v2),...,atributon(vn) { ..defini¸ca õ do construtor.. }; No exemplo a seguir a op¸caõ (1) constr˜ oe a e b e já inicializa com _a e _b. A op¸caõ (2) é mais lenta – primeiro constr˜ oe a e b e depois atribue valores a = _a; b = _b;. Exemplo: class CNomeClasse { public: int a, b; const int c; // Atributos // Op¸ c~ ao 1: Inicializa atributos ap´ os : CNomeClasse(int _a,int _b,int _c) : a(_a),b(_b),c(_c) {}; // Op¸ c~ ao 2: Inicializa dentro do construtor CNomeClasse(int _a, int _b, int _c) :c(_c) { a = _a; b = _b; }; };

16.5

Construtor de c´ opia T(const T& obj)

Outro construtor bastante utilizado é o construtor de c´ opia, o qual é utilizado para criar uma c´ opia de um objeto existente (veja o prot´ otipo e o exemplo). Se você n˜ ao criar um construtor de c´ opia e utilizar o operador de atribui¸caõ (=), ent˜ ao o compilador ir´ a construir automaticamente o construtor de c´ opia. Veja no prot´ otipo a seguir que o parˆ ametro recebido pelo construtor de c´ opia é um objeto da própria classe; o const informa que o objeto recebido n˜ ao pode ser alterado, o que faz sentido pois estamos criando um objeto novo e nosso interesse é apenas copiar os atributos do objeto antigo para o novo. Prot´ otipo: CNomeClasse(const CNomeClasse& obj); No exemplo a seguir, o construtor de c´ opia é utilizado para construir os objetos p2 e p3 a partir de p1. Exemplo: CPonto p1;

// // CPonto p2 = p1; // // // CPonto p3(p1); // // CPonto p4; // p4 = p3; // if( p4 == p2 ) // {...}

Cria objeto do tipo CPonto com nome p1, utiliza o construtor default. Cria objeto do tipo CPonto com nome p2, utiliza o construtor de c´ opia, os atributos de p2 ser~ ao iguais aos de p1. Cria objeto p3, utiliza o construtor de c´ opia, os atributos de p3 ser~ ao iguais aos de p1 Cria objeto p4, utiliza o construtor default. Utiliza o operador =, igualando p4 a p3. Utiliza o operador ==, comparando p4 e p2.

Na listagem 16.1, mostra-se a utiliza¸caõ do construtor default e do construtor de c´ opia. Note que, tanto no construtor default como no de c´ opia, inicializamos os valores de nome, matricula Programa¸caõ Orientada a Objeto com C++



320

e iaa e enviamos uma mensagem para tela. Note que o construtor de cópia copia um a um os atributos do objeto. No destrutor decrementamos o n´ umero de objetos e enviamos mensagem para tela; o objetivo das mensagens é acompanhar os processos de constru¸caõ e destrui¸caõ (did´ atico). Observe que, para cada atributo, criamos dois métodos um para defini¸caõ e outro para leitura do valor do atributo. Os métodos de Entrada() e Saida() s˜ ao utilizados para entrada e sa´ıda de todos os dados do objeto. Outros coment´ arios s˜ ao embutidos no texto. Observe na sa´ıda que cria um objeto usando o construtor default : ”Criou objeto 2 construtor default ”. Em seguida, ele cria os objetos 3, 4 usando o construtor de c´ opia. Posteriormente, apaga o objeto criado com o construtor default ”Destruiu o objeto 4”. Na prática, isso significa que você deve sempre criar um construtor de c´ opia. Observe que os atributos nome, matricula e iaa (´ındice de aproveitamento acumulado) s˜ ao inicializados no construtor. ao criados utilizando o construtor de Note que, tanto o professor2 quanto o professor3, s˜ c´ opia. Listing 16.1: Usando construtor default e de c´ opia. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

# include < iostream > # include < string > # include < vector > using namespace std ; class CPessoa { private : string nome ; string matricula ; double iaa ; static int n u m e r o A l u n o s ; public : // C o n s t r u t o r default , c h a m a d o a u t o m a t i c a m e n t e // na c o n t r u ¸ c~ a o do objeto CPessoa () : nome ( " " ) , matricula ( " " ) , iaa (0) { n u m e r o A l u n o s ++; cout << " Criou objeto " << n u m e r o A l u n o s << " construto r default " << endl ; } // C o n s t r u t o r de c´ o pia , cria uma c´ o pia de um objeto e x i s t e n t e CPessoa ( const CPessoa & obj ) { nome = obj . nome ; matricula = obj . matricula ; iaa = obj . iaa ; n u m e r o A l u n o s ++; cout << " Criou objeto " << n u m e r o A l u n o s << " construto r de c´ o pia " << endl ; } ~ CPessoa () // M´ e todo Destrutor , c h a m a d a a u t o m a t i c a m e n t e { // na d e s t r u i ¸ c~ a o do objeto cout << " Destruiu objeto " << n u m e r o A l u n o s << endl ; numeroAlunos - -; } void void void void

Entrada () ; Nome ( string _nome ) { Matricula ( string _m ) { Iaa ( double _iaa ) {

void Saida () const ; string Nome () const string Matricula () const

{ {

nome = _nome ; matricula = _m ; iaa = _iaa ;

} } }

return nome ; return matricula ;

} }



´ 16.5. CONSTRUTOR DE COPIA T(CONST T& OBJ) 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

double Iaa ()

const

{

static int N u m e r o A l u n o s () {

return iaa ;

321 }

return n u m e r o A l u n o s ;};

}; int CPessoa :: n u m e r o A l u n o s = 0; void CPessoa :: Entrada () { cout << " Entre com o nome : " ; getline ( cin , nome ) ; cout << " Entre com a matr´ ı cula : " ; getline ( cin , matricula ) ; cout << " Entre com o iaa : " ; cin >> iaa ; cin . get () ; } void CPessoa :: Saida () const { cout << " Nome do aluno : " << nome << " Matr´ ı cula : " << matricula << " iaa : " << iaa << endl ; } int main () { string linha = " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ; CPessoa professor ; // Usa c o n s t r u t o r d e f a u l t cout << " Entre com o nome do professor : " ; string nome ; getline ( cin , nome ) ; professor . Nome ( nome ) ; cout << " Entre com a matr´ ı cula do professor : " ; string matricula ; getline ( cin , matricula ) ; professor . Matricula ( matricula ) ; cout << " Entre com o n´ u mero de alunos da disciplina ( ex : 3) : " ; int n u m e r o A l u n o s ; cin >> n u m e r o A l u n o s ; cin . get () ; // Cria vetor do tipo C P e s s o a com nome aluno , usa c o n s t r u t o r d e f a u l t vector < CPessoa > aluno ( n u m e r o A l u n o s ) ; for ( int contador = 0; contador < aluno . size () ; contador ++) { cout << " Aluno " << contador << endl ; aluno [ contador ]. Entrada () ; } cout << linha << " RELA¸ C~ A O DE PROFESSOR ES E ALUNOS : \ n " << linha ; cout << " Nome do professor : " << professor . Nome () << endl ; cout << " Matr´ ı cula : " << professor . Matricula () << endl ; for ( int contador = 0; contador < aluno . size () ; contador ++) { cout << linha << " Aluno " << contador << endl ; aluno [ contador ]. Saida () ; }



322 106 107 108 109 110 111 112 113 114 115 116 117 118


cout << linha << " N´ u mero de alunos = " << CPessoa :: N u m e r o A l u n o s () << endl ; cout << linha << " chamando : CPessoa professor2 ( professor ) ; " << endl ; CPessoa professor2 ( professor ) ; // Usa c o n s t r u t o r de c´ o pia professor2 . Saida ( cout ) ; { cout << linha << " chamando : CPessoa professor 3 = professor2 ; " << endl ; CPessoa professor 3 = professor2 ; // Usa c o n s t r u t o r de c´ o pia professor3 . Saida ( cout ) ; } // <- D e s t r ´ o i professor3 , professor2 , alunos e p r o f e s s o r return 0; } Criou objeto 1 construto r default Entre com o nome do professor : Andr´ e Duarte Bueno Entre com a matr´ ı cula do professor : 123 Entre com o n´ u mero de alunos da disciplina ( ex : 3) : 2 Criou objeto 2 construto r default Criou objeto 3 construto r de c´ o pia Criou objeto 4 construto r de c´ o pia Destruiu objeto 4 Aluno 0 Entre com o nome do aluno : Danilo Marques Entre com a matr´ ı cula do aluno : 343 Entre com o IAA do aluno : 8 Aluno 1 Entre com o nome do aluno : Tiago Schaewer Entre com a matr´ ı cula do aluno : 123 Entre com o IAA do aluno : 9 ------------------------------------------------------RELA¸ C~ A O DE PROFESSOR E S E ALUNOS : ------------------------------------------------------Nome do professor : Andr´ e Duarte Bueno Matr´ ı cula : 123 ------------------------------------------------------Aluno 0 Nome do aluno : Danilo Marques Matr´ ı cula : 343 IAA : 8 ------------------------------------------------------Aluno 1 Nome do aluno : Tiago Schaewer Matr´ ı cula : 123 IAA : 9 ------------------------------------------------------N´ u mero de alunos = 3 ------------------------------------------------------chamando : TPessoa professor2 ( professor ) ; Criou objeto 4 construto r de c´ o pia Nome do aluno : Andr´ e Duarte Bueno Matr´ ı cula : 123 IAA : 0 ------------------------------------------------------chamando : TPessoa professor 3 = professor2 ; Criou objeto 5 construto r de c´ o pia Nome do aluno : Andr´ e Duarte Bueno Matr´ ı cula : 123 IAA : 0 Destruiu objeto 5 Destruiu objeto 4 Destruiu objeto 3 Destruiu objeto 2




323

Figura 16.1: Por que devemos criar um construtor de c´ opia. v1

v1

ptr v2

ops! v2.ptr aponta para v1.ptr Cuidado!

ptr v2

ptr

ptr (a)

(b)

v1

v1 ptr

v2 sai de escopo e é destruído Cuidado!!

v1.Saida() acessa o vetor que foi destruído! v1 tenta destruir novamente o bloco CRASH!

ptr v2 ptr

(c)

Solução implementar o construtor de cópia (d)

Destruiu objeto 1

Nota: a listagem F.2 apresenta um problema que est´ a associado à falta do construtor de c´ opia.

16.5.1

Construtor de c´ opia e objetos dinˆ amicos

A Figura 16.1 mostra um problema t´ıpico quando utilizamos atributos dinâmicos e esquecemos de implementar o construtor de c´ opia. O objeto v1 tem um ponteiro ptr que aponta para um bloco de mem´ oria que é alocado no construtor com new. Se criarmos um objeto v2 utilizando o construtor de c´ opia, o ponteiro v2.ptr vai apontar para o mesmo bloco de memória de v1.ptr (Figura 16.1(a)). O exemplo da listagem 16.2 mostra o problema. O exemplo é auto-explicativo. Na linha CVetor v1 (5); cria objeto do tipo CVetor, com nome v1 (Figura 16.1(a)), e, em seguida, mostra o vetor na tela. Na linha CVetor v2 = v1; cria o vetor v2, uma c´ opia de v1. Observe que v2.ptrV e v1.ptrV apontam para o mesmo bloco de mem´ oria (Figura 16.1(a)). Ap´ os executar v2.Saida(); o bloco em que v2 foi criado é destru´ıdo, e o destrutor de v2 é chamado. Note que o destrutor ir´ a deletar o bloco de memória (compartilhado) (Figura 16.1(b)). Até aqui nenhum problema. O problema ocorre quando chamamos v1.Saida(); O método Saida() tenta acessar um bloco de memória que n˜ ao existe mais; v1.ptrV aponta para um monte de lixo (Figura 16.1(c)). O que ocorre é indefinido, provavelmente um bug a qualquer momento. Programa¸caõ Orientada a Objeto com C++


324


Na mensagem de erro apresentada na sa´ıda, o bug ocorre quando o destrutor de v1 é executado. O mesmo tenta destruir o bloco de mem´ oria compartilhado novamente. Listing 16.2: Problemas com a falta do construtor de c´ opia em objetos com atributos dinâmicos. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

# include < iostream > using namespace std ; class CVetor { private : int dimensao ; int * ptrV ; public : void Saida () ;

// Cria classe CVetor

// D i m e n s ~ a o do vetor // P o n t e i r o para o vetor

// C o n s t r u t o r d e f a u l t e ao mesmo tempo com par^ a metros , // aloca o vetor d i n a m i c a m e n t e . CVetor ( int n = 10) : dimensao ( n ) { cout << " Construtor default de CVetor : " << endl ; ptrV = NULL ; ptrV = new int ( dimensao ) ; if ( ptrV == NULL ) { cerr << " \ nFalha aloca¸ ca ~ o " << ends ; exit (0) ; // E n c e r r a o p r o g r a m a } for ( int i = 0; i < dimensao ; i ++) ptrV [ i ] = i ; // P r e e n c h e v a l o r e s do vetor } virtual ~ CVetor () // D e s t r u t o r { cout << " Destrutor do vetor : " << endl ; delete [] ptrV ; } }; void CVetor :: Saida () { for ( int i = 0; i < dimensao ; i ++) cout << " " << ptrV [ i ] << " " ; cout << endl ; } int main () { CVetor v1 (5) ; // Cria objeto do tipo CVetor , com nome v1 cout << " Sa´ ı da de v1 . Saida () " << endl ; v1 . Saida () ; // Mostra o vetor na tela { CVetor v2 = v1 ; // Cria v2 , uma c´ o pia de v1 cout << " Sa´ ı da de v2 . Saida () ap´ o s CVetor v2 = v1 " << endl ; v2 . Saida () ; } // v2 sai de escopo e ´ e deletado cout << " Sa´ ı da de v1 . Saida () ap´ o s dele¸ ca ~ o de v2 " << endl ; v1 . Saida () ; // Efeito i n e s p e r a d o return 0; } // v1 sai de escopo e ´ e d e l e t a d o ( BUG ) Construto r do vetor : Sa´ ı da de v1 . Saida ()



´ CONSTRUÍDO/DESTRUÍDO 16.6. QUANDO O OBJETO E

325

0 1 2 3 4 Sa´ ı da de v2 . Saida () ap´ o s CVetor v2 = v1 0 1 2 3 4 Destrutor do vetor : Sa´ ı da de v1 . Saida () ap´ o s dele¸ ca ~ o de v2 0 0 2 3 4 Destrutor do vetor : *** glibc detected *** ./ a . out : double free or corruption ( fasttop ) : 0 x 0 0 0 0 0 0 0 0 0 0 6 0 2 0 1 0 *** ======= Backtrace : ========= / lib64 / libc . so .6[0 x39e486ea3 0 ] .... ./ a . out ( _ _ g x x _ p e r s o n a l i t y _ v 0 +0 x69 ) [0 x400a29 ] ======= Memory map : ======== 00400000 -00402000 r - xp 00000000 08:05 6059456 / home / bueno / Bueno / A p o s t i l a s P e s s o a i s / LivroCPP / listagens / Parte - II / a . out 7 fff7bb32000 -7 fff7bb4700 0 rw - p 7 fff7bb320 0 0 00:00 0 [ stack ] ffffffffff600 00 0 - f f f f f f f f f f e 0 0 0 0 0 --- p 00000000 00:00 0 [ vdso ] Abortado

A solu¸caõ para este problema é implementar manualmente o construtor de c´ opia, alocando a memória com new para os objetos dinˆ amicos (Figura 16.1(d)). Acrescente na classe CVetor (da listagem 16.2) o construtor de c´ opia apresentado a seguir. Observe que o novo objeto vai ter um vetor com a mesma dimensão e os mesmos valores. Exemplo: CVetor::CVetor(const CVetor& obj) { // obj e this ter~ ao a mesma dimens~ ao this->dimensao = obj.dimensao; this->ptrV = NULL; // Cria um novo vetor para this this->ptrV = new int (this->dimensao); if(this->ptrV == NULL) { cerr < < "\nFalha aloca¸ c~ ao" < < ends; exit(0);} // Copia os valores de v1 para this for(int i = 0; i < dimensao; i++) this->ptrV[i] = obj.ptrV[i]; } Nota: o objeto cerr é utilizado para enviar mensagens de erro para a tela, da mesma forma que cout. A diferen¸ca é que cerr n˜ ao tem buffer, sendo o texto enviado imediatamente para tela. A fun¸caõ exit(0) encerra a execu¸caõ do programa.

16.6

Quando o objeto ´ e constru´ıdo/destru´ıdo

Vimos ao longo deste cap´ıtulo uma série de métodos construtores e destrutores. Uma pergunta que pode ser feita é: quando um objeto é criado e quando um objeto é destru´ıdo? Segundo [Lischner, 2003], as possibilidades s˜ ao: • Quando criamos um objeto autom´ atico. Exemplo: int x; CEndereco endereco; CAluno aluno; Programa¸caõ Orientada a Objeto com C++



326

• Quando criamos um objeto est´ atico. Exemplo: static int x; static CEndereco endereco; • Quando criamos um objeto dinamicamente. Exemplo: const int dimensao = 10; int * ptrVetor = new int[dimensao]; • Quando criamos objetos tempor´ arios. No exemplo a seguir a soma de 4+5 é armazenada em um objeto tempor´ ario, que é criado, usado para armazenar o valor 9, e, em seguida, usado para copiar o valor 9 para x. Vale lembrar que a cria¸caõ do objeto temporário é interna, transparente. Exemplo: int x = 4 + 5; • Quando usamos retorno e parˆ ametros de um método. No exemplo a seguir quando entra no método Metodo() o parˆ ametro int x é criado. Quando o método é encerrado, uma c´ opia de x é retornada. Exemplo: int CNomeClasse::Metodo(int x) {... return x; } • Quando usamos convers˜ oes impl´ıcitas. No exemplo a seguir, um n´ umero temporário do tipo int é criado e usado para armazenar o n´ umero 3 (o n´ umero flutuante 3.1415 é truncado para 3); depois, este n´ umero tempor´ ario é copiado para x. Exemplo: int x = 3.1415; • Quando usamos construtores com inicializadores. Exemplo: CCirculo::CCirculo(int _r,int _x,int _y): CPonto(_x,_y), r(_r){...} • Todos os objetos anteriormente constru´ıdos s˜ ao destru´ıdos quando os mesmos saem de escopo. A exce¸caõ ocorre quando usamos constru¸caõ dinâmica. Neste caso o objeto deve ser explicitamente destru´ıdo com delete.

16.6.1

Ordem de constru¸c˜ ao dos atributos

A ordem de constru¸caõ dos atributos de uma classe é dada pela ordem em que os mesmos foram declarados, e n˜ ao pela ordem passada para o construtor. Veja exemplo na listagem 16.3. Observe que a classe Y tem três atributos agregados do tipo X, e que os mesmos s˜ ao declarados na ordem x1, x2, x3. Programa¸caõ Orientada a Objeto com C++



327

A lista passada para o construtor da classe Y é dada por ”Y() : x2(2), x3(3), x1(1)”, mas observe na sa´ıda que os objetos foram criados na ordem em que foram declarados; ou seja, vai criar x1 depois x2 e depois x3, mesmo que no construtor tenhamos colocado x2, x3, x1. Depois de construir seus atributos o construtor do objeto obj_y é executado. Listing 16.3: Ordem de constru¸caõ dos atributos de um objeto. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# include < iostream > using namespace std ; class X { public : X ( int n ) { cout << " Criou X : " << n << endl ; }; }; class Y { public : Y () : x2 (2) , x3 (3) , x1 (1) { cout << " Criou Y . " << endl ; }; private : X x1 , x2 , x3 ; // D e c l a r a os a t r i b u t o s na ordem x1 , x2 , x3 }; int main () { Y obj_y ; return 0; } Criou Criou Criou Criou

X :1 X :2 X :3 Y.

16.6.2

Ordem de destrui¸c˜ ao dos atributos

Quando um objeto é criado, s˜ ao criados os atributos internos e depois é executado o corpo do construtor. Os atributos internos s˜ ao criados na ordem em que foram declarados (veja Se¸caõ 16.6.1). A seq¨ uência de destrui¸caõ é inversa ` a da cria¸caõ, isto é, primeiro é executado o método destrutor e depois s˜ ao eliminados os objetos internos da classe, na ordem inversa a que foram declarados. Se for criado um vetor de objetos de tamanho n, a seq¨ uência de cria¸caõ é obj[0], obj[1], obj[2],..., obj[n-1] e a seq¨ uência de destrui¸caõ obj[n-1], obj[n-2], obj[n-3],..., obj[1], obj[0]. Exemplo: class V { int n; int * ptr; V(int _n = 30):n(_n),ptr(0) { ptr = new int (n); }; ~V() { delete [] ptr; };

// Construtor // Destrutor




328 }; int main() { V objeto; return 0; }

// Cria objeto // Objeto sai de escopo e ´ e destru´ ıdo

No exemplo anterior, dentro da fun¸caõ main() é criado um objeto do tipo V. Primeiro cria o atributo n e inicializa com 30 e, em seguida, cria o ponteiro ptr e inicializa com NULL. Depois é executado o corpo do construtor, que aloca mem´ oria para um vetor de 30 inteiros e armazena o endere¸co do bloco alocado em ptr. Quando o bloco de main() termina os objetos criados s˜ ao destru´ıdos, logo, o destrutor do objeto é executado. Na seq¨ uência de destrui¸caõ, primeiro é executado o corpo do destrutor, que deleta o conte´ udo do ponteiro; em seguida é eliminado o atributo ptr e posteriormente o atributo n. Observe que a ordem de destrui¸caõ é inversa a de constru¸caõ. A melhor maneira de entender a seq¨ uência de cria¸caõ e destrui¸caõ dos objetos é acompanhar a execu¸caõ passo a passo do programa em um debugger. No Dev-C++ (veja Figura 6.27), usa-se a fun¸caõ f7. Veja, no Cap´ıtulo ?? – Como Evitar Bugs e Utilizar o Debuger da GNU (gdb), como usar o debugger da GNU.

16.6.3

Constru¸c˜ ao de objetos globais est´ aticos

Lembre-se de que um objeto global é um objeto criado fora do escopo das classes e fun¸co˜es globais. Exemplo: ..escopo global.. Retorno FuncaoGlobal(parametros){..escopo da fun¸ c~ ao global..} ..escopo global.. class CNomeClasse{...escopo da classe..}; ..escopo global.. Retorno CNomeClasse::Metodo(parametros){..escopo do m´ etodo..} ..escopo global.. int main() {..escopo de main()..} Objetos globais est´ aticos s˜ ao criados quando o programa é carregado (antes de main()) e destru´ıdos quando o programa é encerrado. Isto significa que podemos criar uma fun¸caõ global e execut´ a-la antes de main() para iniciar um objeto est´ atico. Veja exemplo na listagem 16.4. Listing 16.4: Objetos est´ aticos globais. 1 2 3 4 5 6 7 8 9 10 11 12 13 14

# include < iostream > int f () // Fun¸ c~ a o Global { std :: cout << " Executada antes de main () . " << std :: endl ; return 0; } // x ´ e uma v a r i ´ a v e l global e s t ´ atica static int x = f () ; // que ´ e i n i c i a l i z a d a com o r e t o r n o de f () int main () { std :: cout << " Ol´ a " << std :: endl ; return 0; }



¨ 16.7. CONSTRUTOR E AMBIGUIDADE

329

Executada antes de main () . Ol´ a

16.7

Construtor e ambigu ¨ idade

Uma ambig¨ uidade ocorre quando o compilador n˜ ao consegue identificar qual atributo ou método deve ser acessado. O exemplo a seguir mostra uma ambig¨ uidade hipotética – do dia-adia. Exemplo: /* Al´ o, com quem deseja falar? Com o Fernando. Mas qual Fernando, o Henrique ou o Collor?. */ De modo geral ocorrer´ a ambig¨ uidade quando, no mesmo escopo, tivermos atributos ou métodos com o mesmo nome. A verifica¸caõ de ambig¨ uidade é feita antes do controle de acesso, assim, o compilador primeiro verifica se o objeto n˜ ao é amb´ıg¨ uo e depois se pode ser acessado (Se¸caõ 14.3.1). As ambig¨ uidades podem ser resolvidas explicitamente com o operador de resolu¸caõ de escopo (::) ou com o uso da palavra-chave using (Se¸caõ 10.3). Ao tentar compilar o exemplo da listagem 16.5, aparece uma mensagem de erro. Na linha (11) "X obj1(5);" o compilador cria o objeto obj1 usando o construtor sobrecarregado. Na linha (12) "X obj2;" o compilador fica em d´ uvida – deve usar o construtor default ou o construtor sobrecarregado? A solu¸caõ deste problema é um dos exerc´ıcios deste cap´ıtulo. Listing 16.5: Erro ao definir o construtor default e um construtor sobrecarregado com inicializadores. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class X { int x ; public : // Sejam os c o n s t r u t o r e s : X () { }; // C o n s t r u t o r _ 1 ( d e f a u l t ) X ( int _x = 0) { x = _x ; }; // C o n s t r u t o r _ 2 ( s o b r e c a r r e g a d o ) }; int main () { X obj1 (5) ; X obj2 ;

// // // //

Se na t e n t a t i v a de criar um objeto voc^ e faz : Cria objeto 1 , usa c o n s t r u t o r _ 2 Ambig¨ u idade , qual c o n s t r u t o r ? X () ou X ( int _x =0)

return 0; }; : In :14: :8: :7:

function ’ int main () ’: error : call of overloade d ’X () ’ is ambiguous note : candidates are : X :: X ( int ) note : X :: X ()

16.8

Construtor e destrutor – conceitos avan¸cados2

Nesta se¸caõ veremos alguns conceitos avan¸cados de construtores e destrutores. Programa¸caõ Orientada a Objeto com C++


2 16.8. CONSTRUTOR E DESTRUTOR – CONCEITOS AVANCADOS ¸

330

16.8.1

Construtor e ambigu ïdade

Por defini¸caõ do comite ANSI C++, quando o compilador fica em d´ uvida se uma determinada linha de c´ odigo significa a declara¸caõ de uma nova fun¸caõ ou a cria¸caõ de um objeto, por padr˜ ao, assume que o programador est´ a declarando uma nova fun¸caõ e n˜ ao criando um novo objeto. A listagem 16.6 mostra um exemplo. O programa inicia definindo uma classe T (observe que, quando o construtor é executado, ele envia uma sa´ıda para tela). Em seguida mostra o problema das ambig¨ uidades. A linha (18) T f1(); declara uma fun¸caõ f1() que n˜ ao recebe nada e retorna T ou cria um objeto f1 do tipo T? Obedecendo o padr˜ ao, estamos declarando uma fun¸caõ f1() que retorna T. A linha (21) T (obj1); cria um novo objeto, do tipo T, com nome obj1. A linha (26) T obj2(1); cria um novo objeto, do tipo T, com nome obj2, e usa construtor que recebe um int. A linha (34) T f3(T(x)); declara uma fun¸caõ f3(). Observe que podemos informar que queremos criar um objeto usando o cast (T obj3(static_cast(x));). Listing 16.6: Construindo objetos ou declarando fun¸co˜es? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// A m b i g u i d a d e : C o n s t r u i n d o o b j e t o s ou d e c l a r a n d o f u n ¸ c~ o e s? # include < iostream > class T // Cria uma classe T { // Acesso p ´ ublico public : // C o n s t r u t o r e s T () { std :: cout << " \ tConstrut or T () \ n " ; } T ( int ) { std :: cout << " \ tConstrut or T ( int ) \ n " ; } }; int main () { int x ;

// Fun¸ c~ ao principal // Cria objeto do tipo int , com nome x

// A m b i g u i d a d e ? // D e c l a r a fun¸ c~ a o f1 () , que n~ a o recebe nada e r e t o r n a T ? ou // Cria objeto f1 do tipo T ? std :: cout << " T f1 () ; -> Declara¸ ca ~ o de fun¸ ca ~ o . " << std :: endl ; T f1 () ; std :: cout << " T ( obj1 ) ; -> Cria obj1 , usa construtor T () " << std :: endl ; T ( obj1 ) ; // A m b i g u i d a d e ? std :: cout << " T obj2 (1) ; -> Cria objeto obj2 , do tipo T , " << " usa construtor T ( int ) " << std :: endl ; T obj2 (1) ; std :: cout << " T f2 ( int ) ; -> Declara fun¸ ca ~ o f2 , retorna T , " << " argumento int sem nome " << std :: endl ; T f2 ( int ) ; // A m b i g u i d a d e ? std :: cout << " T f3 ( T ( x ) ) ; - > Declara fun¸ ca ~ o f3 , retorna T , " << " e recebe T " << std :: endl ; T f3 ( T ( x ) ) ; std :: cout << " T obj3 ( static_cast ( x ) ) ; " << " -> Cria objeto obj3 , do tipo T " << std :: endl ; T obj3 ( static_cast ( x ) ) ; std :: cout << std :: endl ; return 0; }



2 16.8. CONSTRUTOR E DESTRUTOR – CONCEITOS AVANCADOS ¸

331

T f1 () ; -> Declara¸ ca ~ o de fun¸ ca ~o . T ( obj1 ) ; -> Cria obj1 , usa construtor T () Construtor T () T obj2 (1) ; -> Cria objeto obj2 , do tipo T , usa construtor T ( int ) Construtor T ( int ) T f2 ( int ) ; -> Declara fun¸ ca ~ o f2 , retorna T , argumento int sem nome T f3 ( T ( x ) ) ; - > Declara fun¸ ca ~ o f3 , retorna T , e recebe T T obj3 ( static_cast ( x ) ) ; -> Cria objeto obj3 , do tipo T Construtor T ( int )

16.8.2

Construtor e interface

Em alguns casos a classe é definida corretamente, mas um usuário distra´ıdo pode criar o objeto de forma incorreta. Veja exemplo na listagem 16.7. Observe que o objeto é criado com o nome da cidade e da pessoa trocados. Um erro n˜ ao detectado pelo compilador, porque nome e cidade s˜ ao do tipo string, e o compilador diferencia os tipos e n˜ ao os nomes. Este erro ocorre porque a interface (ou protocolo) de acesso ao construtor n˜ ao impede que o usuário entre com dados trocados. Listing 16.7: Construtor e interface: erro na passagem de parˆ ametros. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# include < iostream > # include < string > using namespace std ; class CPessoa { int idade ; string nome ; string cidade ; public : CPessoa ( int i , string n , string c ) : idade ( i ) , nome ( n ) , cidade ( c ) {} }; int main () { // Erro na ordem de p a s s a g e m dos p a r ^ ametros CPessoa joao (32 , " Rio de Janeiro " , " Jo~ a o da Silva " ) ; return 0; }

Pode-se contornar este problema usando classes ou estruturas auxiliares. Veja o exemplo da listagem 16.8. Usamos struct porque SNome e SCidade n˜ ao representam conceitos; s˜ ao apenas estruturas auxiliares utilizadas para eliminar o problema. O uso de explicit ser´ a apresentado na Se¸caõ 25.5. Basicamente explicit garante que o construtor s´ o seja chamado explicitamente. Listing 16.8: Construtor e interface: erro na passagem de parˆ ametros corrigidos. 1 2 3 4 5 6 7 8 9 10

# include < iostream > # include < string > using namespace std ; struct SNome { explicit SNome ( string n ) : nome ( n ) {}; string nome ; };



332 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

16.9. SENTENCAS ¸ PARA CONSTRUTORES E DESTRUTORES

struct SCidade { explicit SCidade ( string c ) : cidade ( c ) {}; string cidade ; }; class CPessoa { int idade ; string nome ; string cidade ; public : CPessoa ( int i , SNome n , SCidade c ) : idade ( i ) , nome ( n . nome ) , cidade ( c . cidade ) {} }; int main () { // Erro na p a s s a g e m de p a r ^ ametros corrigida // agora a p a s s a g e m dos p a r ^ a m e t r o s ficou mais clara CPessoa joao (32 , SNome ( " Jo~ a o da Silva " ) , SCidade ( " Rio de Janeiro " ) ) ; return 0; }

Veja a seguir outras dicas para classes de interface (reveja Se¸caõ 11.5.2): • A interface de acesso a classe deve ser simples, prática e lógica. • Deve ter um controle rigoroso da entrada e sa´ıda de dados (limites m´ınimos e máximos de cada atributo). • Os operadores-padr˜ ao devem ser sobrecarregados (veja Cap´ıtulo 21 – Sobrecarga de Operador). • As classes derivadas devem ter uma interface com a mesma l´ ogica da classe-base.

16.9

Senten¸cas para construtores e destrutores

• Um objeto autom´ atico é constru´ıdo na sua defini¸caõ e destru´ıdo quando sai de escopo. Exemplo: { int x; }

// Objeto x ´ e constru´ ıdo // Objeto x sai de escopo e ´ e destru´ ıdo

• Ao criar um vetor est´ atico de objetos, você é obrigado a utilizar o construtor default. Para utilizar um outro construtor, você ter´ a de criar os objetos um a um dinamicamente. No exemplo a seguir, utiliza-se um construtor sobrecarregado, que recebe uma lista de parˆ ametros. Observe que os objetos s˜ ao criados um a um, dinamicamente, dentro do for. Exemplo: CNomeClasse { public: CNomeClasse(){}; // Construtor default }; // Cria vetor est´ atico, com 30 objetos CNomeClasse vObjetos[30]; // Cria vetor com 50 ponteiros Programa¸caõ Orientada a Objeto com C++


16.9. SENTENCAS ¸ PARA CONSTRUTORES E DESTRUTORES

333

CNomeClasse* vptrObj[50]; for ( int i = 0 ; i < 50 ; i++ ) vptrObj[i] = new CNomeClasse (parametros); • Em determinados casos é conveniente termos um método de inicializa¸caõ, um método utilizado para inicializar os atributos da classe e que pode ser chamado a qualquer momento para reinicializar os atributos com valores-padrão, exemplo: Init();. • Atributos est´ aticos da classe devem ser definidos fora da classe. • Bugs – um objeto autom´ atico, criado na avalia¸caõ de uma express˜ ao, é destru´ıdo no fim do bloco (ou do método). Assim, n˜ ao armazene nenhuma informa¸caõ (ponteiro, referência) em objetos autom´ aticos. O exemplo a seguir mostra um erro comum. Exemplo: int* f() { int x = 3; int * ptrX = &x; return ptrX; } // Aqui x ´ e destru´ ıdo e ptrX aponta para o lixo (um bug). • Todos os atributos do objeto devem ser copiados um a um no construtor de c´ opia. Se um novo atributo for adicionado ` a classe, n˜ ao esque¸ca de incluir sua c´ opia no construtor de c´ opia. • A utiliza¸caõ de uma lista de inicializa¸caõ – como no exemplo que segue – n˜ ao é permitida se você criou um construtor com parˆ ametros e n˜ ao existe um construtor default . Exemplo: Tipo a[] = { v1, v2, ..., vn }; • Lembre-se de que o operador delete primeiro chama o método destrutor do objeto e, em seguida, devolve a mem´ oria para o sistema operacional. • Um objeto criado com new deve ser apagado com delete. • N˜ ao destruir um objeto alocado dinamicamente n˜ ao causa um erro (bug ), mas é um desperd´ıcio de mem´ oria. • 2 O construtor de c´ opia e o operador de atribui¸caõ da classe derivada devem chamar o método equivalente da classe-base. Veja o exemplo: Exemplo: Derivada& operator=( const Derivada& d ) { Base::operator=(d); this->atributo = d.atributo; } • 2 O construtor de uma classe-derivada chama automaticamente o destrutor da classe-base. Programa¸caõ Orientada a Objeto com C++



334

• 2 O corpo de um destrutor é executado antes dos destrutores para os objetos membros. De maneira geral, a ordem de destrui¸caõ dos objetos é inversa à ordem de constru¸caõ (veja Se¸co˜es 16.6.2). • 2 Como regra b´ asica, sempre declare o destrutor como virtual (veja Se¸caõ 19.2). • 2 Se durante a execu¸caõ do programa é chamada a fun¸caõ exit(), os destrutores locais n˜ ao ser˜ ao executados e os globais sim. Se for chamada a fun¸caõ abort(), nenhum destrutor ser´ a executado. • 2 Destrutores n˜ ao devem lan¸car exce¸co˜es. Se um método chamado pelo destrutor pode chamar uma exce¸caõ, o tratamento deve ser feito no destrutor. • 2 O destrutor, assim como o construtor, n˜ ao deve chamar métodos virtuais. • 2 Como vimos, quando n˜ ao criamos um construtor, o compilador cria um. O mesmo ocorre para o construtor de c´ opia, o operador de atribui¸caõ e o destrutor. Todos esses métodos, quando criados pelo compilador, s˜ ao métodos inline [Lischner, 2003]. • 2 Se você criou um construtor de c´ opia, um operador de atribui¸caõ, ou um destrutor, ent˜ ao você provavelmente precisa criar todos os três [Lischner, 2003]. Isto ocorre normalmente quando a classe tem membros de dados dinˆ amicos. • 2 As classes containers da STL e a classe string n˜ ao têm um destrutor virtual. Assim, tome cuidado no uso de heran¸ca dessas classes. No exemplo a seguir, delete ptr invoca o destrutor de string e n˜ ao de MinhaString. Exemplo: class MinhaString: public std::string {...}; string * ptr = new MinhaString(); delete ptr; • 2 Por default, se um construtor de uma classe X recebe um u ´ nico argumento do tipo Y, este também define uma convers˜ ao de Y para X. Para evitar a convers˜ ao autom´ atica, use a palavra-chave explicit (veja Se¸caõ 25.5).

16.10


Vimos que o método construtor é utilizado para inicializar os atributos do objeto, podendo ainda realizar alguma atividade extra. Quando n˜ ao criamos um construtor, o compilador cria um construtor vazio chamado construtor default, o qual n˜ ao recebe nenhum parˆ ametro. Vimos ainda que o construtor pode ser sobrecarregado, isto é, podemos ter mais de um construtor. Vimos que a implementa¸caõ do construtor de c´ opia, T(const T& obj), é importante principalmente quando o objeto tem atributos dinˆ amicos. Aprendemos a inicializar os atributos do objeto no construtor. A inicializa¸caõ dos atributos ap´ os : é mais r´ apido que a inicializa¸caõ dentro do bloco do construtor. Aprendemos ainda que a ordem de constru¸caõ dos atributos é a ordem em que os mesmos foram declarados. O destrutor faz o trabalho inverso, destr´ oi o objeto. Aprendemos que o método destrutor deve ser u ´ nico, de preferência virtual, e deve ser utilizado para destruir os atributos e finalizar o objeto. Programa¸caõ Orientada a Objeto com C++


16.11. EXERCÍCIOS

335

Aprendemos que a ordem de destrui¸caõ dos atributos de um objeto é inversa à ordem de constru¸caõ. Finalmente, aprendemos conceitos como ambig¨ uidade e interface. Vimos que podemos eliminar problemas com a passagem dos parˆ ametros do construtor usando estruturas de interface.

16.11

Exerc´ıcios

1. Na listagem 16.1 acrescente um construtor que recebe todos os atributos do objeto. Com ele elimina-se a necessidade de se chamar os métodos Set(). 2. Modifique a listagem 16.1 acrescentando novos atributos. Por exemplo, acrescente o uso de CEndereco. 3. Comente em detalhes a listagem 16.2. 4. Acrescente a listagem 16.2 as corre¸co˜es indicadas na Se¸caõ 16.5.1. 5. Releia a listagem 13.3. 6. Releia a Se¸caõ 16.7 e corrija o problema da listagem 16.5. 7. Indique duas op¸co˜es para eliminar a ambig¨ uidade na listagem 16.5. A seguir, implemente as modifica¸co˜es sugeridas. 8. Modifique a listagem 13.3 substituindo Inicializa() por um construtor. 9. Arrume a listagem 16.3 chamando os objetos na ordem em que s˜ ao declarados. Em seguida, veja a sa´ıda gerada. 10. Como os construtores podem ser sobrecarregados, podemos ter várias formas para construir um objeto. Alguns programadores gostam de fornecer uma alternativa que passa pela defini¸caõ de todos os construtores como privados e o acesso a cada um deles usando um método est´ atico e p´ ublico com nome diferente. Este método é conhecido como Named Constructor Idiom. Como exerc´ıcio, fa¸ca uma pesquisa por ”Named Constructor Idiom” no Google. 11. Se um objeto do tipo CNome é constru´ıdo estaticamente no escopo global, ent˜ ao ele é executado antes de main(). Isto deve ser evitado, pois se o construtor de CNome criar outros objetos est´ aticos, ent˜ ao n˜ ao existe garantia de que a seq¨ uência de cria¸caõ seja correta. Como exerc´ıcio, fa¸ca uma pesquisa por ”Construct on First Use Idiom” no Google.



336


16.11. EXERCÍCIOS


Cap´ıtulo 17

Heran¸ ca Vimos nas se¸co˜es 3.6 e 6.4.10 o conceito de heran¸ca; na Se¸caõ 6.4.10, vimos como identificar heran¸cas e na Se¸caõ 6.4.11, como descrever a heran¸ca usando UML. Neste cap´ıtulo veremos como implementar heran¸cas em C++. Veremos o prot´ otipo para heran¸ca (Se¸caõ 17.1), o uso de heran¸ca simples (Se¸caõ 17.2) e o uso do especificador de heran¸ca (Se¸caõ 17.3). Ademais, veremos as diferen¸cas entre heran¸ca p´ ublica e heran¸ca privada (Se¸caõ 17.4); como usar using em heran¸cas (Se¸caõ 17.5); como chamar os construtores das classes-base explicitamente (Se¸caõ 17.6); a redeclara¸caõ de método ou atributo na classe-derivada (Se¸caõ 17.7) e algumas senten¸cas para heran¸ca (Se¸caõ 17.8). No Cap´ıtulo 18 – Heran¸ca M´ ultipla, veremos como implementar o conceito de heran¸ca m´ ultipla.

17.1

Prot´ otipo para heran¸ca simples

O conceito de heran¸ca permite a cria¸caõ de uma classe-derivada a partir de uma classebase. A classe-derivada herda todos os atributos e métodos da classe-base. Neste cap´ıtulo vamos apresentar a utiliza¸caõ do conceito de heran¸ca em C++. Veja a seguir o prot´ otipo para implementar heran¸ca em C++: Nota: seria interessante neste momento você reler a Se¸caõ 3.6. Prot´ otipo: // Arquivo Base.h class Base { // Defini¸ca õ dos atributos e métodos da classe-base }; // Arquivo Derivada.h #include ”Base.h” class Derivada: especificadorDeHeran¸ca Base // veja se¸co ˜es 17.2 e 17.3 { // Defini¸ca õ dos atributos e métodos da classe-derivada }; 337

338

17.2. COMO IMPLEMENTAR A HERANCA ¸ SIMPLES

17.2

Como implementar a heran¸ca simples

Observe no prot´ otipo anterior a linha, class Derivada: especificadorDeHeran¸ ca Base Nessa linha, informa-se que a classe-derivada é herdeira da classe-base. Como s´ o temos uma classe-base temos uma heran¸ca simples. O especificador de heran¸ca define a forma como a classe-derivada pode acessar os atributos e métodos da classe-base. O uso do especificador de heran¸ca é detalhado na Se¸caõ 17.3. Veja na Figura 17.1 o diagrama UML da classe CCirculo e, na listagem 17.1, seu c´ odigo. A classe CCirculo é herdeira da classe CPonto. CPonto +x: int +y: int +contador: static int +Desenha(): virtual void

CCirculo +r1: int +Desenha(): virtual void

Figura 17.1: Heran¸ca simples: CPonto e CCirculo. Observe a forma como é declarada a heran¸ca da classe CCirculo com a classe CPonto. class CCirculo : public CPonto A classe CCirculo cria o atributo r1 e inclui o método R1(). Agora preste aten¸caõ no construtor da classe CCirculo e observe a chamada do construtor da classe-base CPonto. A classe CCirculo chama explicitamente o construtor da classe CPonto para passar os atributos x e y. CCirculo(int _x,int _y, int _raio) : CPonto(_x,_y), r1(_raio) {}; Alguns métodos Set() de CPonto s˜ ao sobrecarregados (mesmo nome, mas parˆ ametros diferentes). Observe no método CCirculo::Set(CCirculo& C) que a classe CCirculo pode acessar os atributos x e y diretamente, pois esses foram herdados da classe CPonto. Note no método inline void Set (int _x, int _y, int raio); que podemos chamar CPonto::Set ( x, y); da classe-base. Observe que o método Desenha() é declarado como sendo virtual. Veremos os métodos virtuais na Se¸caõ 19.2. Listing 17.1: A classe CCirculo. 1 2 3 4

# ifndef CCirculo_h # define CCirculo_h # include " CPonto . h "

// C o m p i l a ¸ c~ ao condicional // Inclui classe - base



17.3. ESPECIFICADOR DE HERANCA ¸ 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

class CCirculo : public CPonto { protected : int r1 ;

339

// Define o tipo de u s u ´ a r i o C C i r c u l o. // H e r d e i r a de CPonto

public : // Construtor , o b s e r v e que p r i m e i r o passa para o c o n s t r u t o r da classe - base // os a t r i b u t o s x e y , e a seguir define r1 . CCirculo ( int _x , int _y , int _raio ) : CPonto ( _x , _y ) , r1 ( _raio ) { }; // M´ e todo Set () Seta a t r i b u t o s do c i r c u l o x , y e raio inline void Set ( int _x , int _y , int raio ) { CPonto :: Set ( _x , _y ) ; // Chama Set () da classe - base this - > r1 = raio ; // Uso de this ´ e opcional } // Seta a t r i b u t o s do c i r c u l o a partir de um ponto e um raio . inline void Set ( CPonto & p , int _raio ) { x = p . X () ; y = p . Y () ; r1 = _raio ; } // Seta a t r i b u t o s do c i r c u l o a partir de outro c i r c u l o inline void Set ( CCirculo & c ) { this - > x = c . x ; this - > y = c . y ; this - > r1 = c . r1 ; } int R1 () const { return r1 ; }; virtual void Desenha () ; }; # endif

Veja na listagem 17.2 a implementa¸caõ da classe CCirculo, a qual redefine o método Desenha(). Note que na implementa¸caõ de Desenha() chamamos o método Desenha() da classebase CPonto::Desenha() e fazemos mais alguma coisa, ou seja, CCirculo vai executar Desenha() de uma forma diferente. Listing 17.2: Implementa¸caõ da classe CCirculo. 1 2 3 4 5 6 7 8 9

# include < iostream > # include " CCirculo . h " // U t i l i z a o m´ e todo D e s e n h a da classe - base e a c r e s c e n t a o d e s e n h o do c ´ ırculo void CCirculo :: Desenha () { CPonto :: Desenha () ; // Chama m´ e todo da classe - base std :: cout << " \ nTCirculo : Coordenada r1 = " << r1 << std :: endl ; }

17.3

Especificador de heran¸ca

O especificador de heran¸ca altera a forma como se processa a heran¸ca, alterando o tipo de acesso herdado. Pode-se utilizar os especificadores public, protected e private. Veja o Programa¸caõ Orientada a Objeto com C++


340

17.3. ESPECIFICADOR DE HERANCA ¸

prot´ otipo a seguir. Prot´ otipo: class Derivada: public Base {}; class Derivada: protected Base {}; class Derivada: private Base {}; O acesso aos membros da classe-base ir´ a depender do especificador de heran¸ca (public, protect e private) e dos especificadores de acesso na classe-base (public, protect e private). A Tabela 17.1 mostra o acesso herdado. Na primeira coluna, o especificador de acesso utilizado na classe-base; na segunda, o especificador de heran¸ca; e na terceira, o acesso efetivamente herdado. Observe na primeira linha da Tabela que, se o atributo é public e o especificador de heran¸ca também, o acesso herdado é public; e se o atributo é protected e o especificador de heran¸ca é private, o acesso herdado ser´ a private. Observe que C++ utiliza as palavras-chave public, protected e private com dois objetivos: o primeiro, especificar a forma de encapsulamento dos atributos do objeto (veja Se¸caõ 11.2); o segundo, especificar a forma da heran¸ca. Tabela 17.1: Acesso herdado Especificador de acesso na classe-base public protected private public protected private public protected private

Especificador de heran¸ca public public public protected protected protected private private private

Acesso herdado public protected inacess´ıvel protected protected inacess´ıvel private private inacess´ıvel

Vamos esclarecer a utiliza¸caõ do especificador de acesso na classe-base e do especificador de heran¸ca por meio da listagem 17.3. Este exemplo contém erros, os quais s˜ ao detectados pelo compilador. Veja a sa´ıda. Listing 17.3: Usando especificador de acesso e de heran¸ca. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include < iostream > using namespace std ; class Base { public : int x ; protected : int y ; private : int z ; }; class DerivadaA : public Base { public : int X () { return x ; }; int Y () { return y ; }; int Z () { return z ; };

// Acesso p ´ ublico // Acesso p r o t e g i d o // Acesso p r i v a d o

// Ok x ´ e p´ ublico // Ok y ´ e protegido // Erro n~ a o tem acesso a z



´ 17.4. DIFERENCA ¸ ENTRE HERANCA ¸ PUBLICA E PRIVADA 17 18 19 20 21 22 23 24 25

341

}; class DerivadaB : private { public : int X () { return x ; int Y () { return y ; int Z () { return z ; };

Base

}; }; };

// Ok x ´ e privado // Ok y ´ e privado // Erro n~ a o tem acesso a z

especificador - heranca . cpp : In member function ’ int DerivadaA :: Z () ’: especificador - heranca . cpp :8: error : ’ int Base :: z ’ is private especificador - heranca . cpp :16: error : within this context especificador - heranca . cpp : In member function ’ int DerivadaB :: Z () ’: especificador - heranca . cpp :8: error : ’ int Base :: z ’ is private especificador - heranca . cpp :24: error : within this context make : ** [ especificador - heranca . o ] Erro 1

17.4

Diferen¸ca entre heran¸ca p´ ublica e privada

Se a heran¸ca é p´ ublica, um objeto D da classe-derivada é um tipo de objeto da classe-base, ou seja, quando necess´ ario, o compilador converte o objeto D em um objeto do tipo B. Quando a heran¸ca é privada, tal convers˜ ao n˜ ao é realizada [Meyers, 2005]. Logo, se você quer implementar uma rela¸caõ do tipo ”é um”, a heran¸ca deve ser p´ ublica. • A heran¸ca privada é usada ent˜ ao para reaproveitamento de c´ odigo; por exemplo, use heran¸ca privada se precisar reaproveitar membros protegidos ou refinar métodos virtuais [Meyers, 2005]. • Na maioria dos casos a heran¸ca privada pode ser substitu´ıda por uma composi¸caõ. • O uso de heran¸ca privada ou sua substitui¸caõ por composi¸caõ é uma decis˜ ao de projeto.

17.5

Mudando a visibilidade em heran¸cas com using

Vimos o uso da palavra-chave using na Se¸caõ 10.3. Podemos utilizar a palavra-chave using para mudar a visibilidade (p´ ublica, protegida) dos membros de uma classe em heran¸cas. Veja o exemplo da listagem 17.4. Observe na sa´ıda que podemos transformar um membro protected em public, mas n˜ ao podemos mudar um membro private. Para que a mensagem de erro apare¸ca, você deve tirar o coment´ ario da linha // private. Listing 17.4: Usando using em heran¸cas. 1 2 3 4 5 6 7 8 9 10 11 12

# include < iostream > class Base { protected : const static int x = 123456; // p r i v a t e: const static int y = 789; };

// D e c l a r a que x ´ e protegido // Tirar o c o m e n t ´ ario // D e c l a r a que y ´ e privado

class Derivada : public Base { public :



342 13 14 15 16 17 18 19 20 21 22 23

17.6. CHAMANDO CONSTRUTORES DA CLASSE-BASE EXPLICITAMENTE

using Base :: x ; using Base :: y ;

// Agora x ´ e p u b l i c o - ok // Agora y ´ e p u b l i c o - Erro

}; int main () { Derivada d ; std :: cout << " d . x = " << d . x << std :: endl ; // ok std :: cout << " d . y = " << d . y << std :: endl ; // Erro return 0; } d . x = 123456 d . y = 789 [ b u e n o @ l d s c 0 5 ] $ g ++ U s a n d o U s i n g E m H e r a n c a s . cpp U s a n d o U s i n g E m H e r a n c a s . cpp :7: error : ’ const int Base :: y ’ is private U s a n d o U s i n g E m H e r a n c a s . cpp :11: error : within this context

17.6

Chamando construtores da classe-base explicitamente

Se a classe-base B s´ o tem construtores com parˆ ametros (n˜ ao tem o construtor default , Se¸caõ 16.3), a classe-derivada D deve chamar explicitamente um dos construtores de B. Veja o exemplo: Exemplo: class B { int a1, a2; public: // Declara¸ c~ ao do construtor (n~ ao tem construtor default ) B(int a1, int a2); }; // Defini¸ c~ ao do construtor da classe B B::B(int _a1, int _a2): a1(_a1), a2(_a2){}; class D: public B { int a3; public: D(int a1,int a2,int a3); }; // Defini¸ c~ ao do construtor da classe D. // Observe a chamada do construtor de B passando os par^ ametros _a1 e _a2 D::D(int _a1,int _a2,int _a3):B(_a1,_a2),a3(_a3) {};

17.7

Redeclara¸c˜ ao de m´ etodo ou atributo na classe-derivada

No Cap´ıtulo 3 – Conceitos Básicos de POO, vimos que uma classe-derivada herda os atributos e os métodos da classe-base, e que a forma como tudo acontece na classe-derivada é um pouco diferente da que ocorre na classe-base. Para que os objetos derivados sejam efetivamente diferentes, porém, você precisa redeclarar e redefinir alguns métodos da classe-base ou acrescentar novos métodos. Programa¸caõ Orientada a Objeto com C++


˜ DE METODO ´ 17.7. REDECLARAC ¸ AO OU ATRIBUTO NA CLASSE-DERIVADA

343

• A classe-derivada pode acrescentar novos métodos ou alterar os métodos da classe-base. Podemos ter dois casos: no primeiro, a classe-derivada realiza a mesma opera¸caõ que a classe-base, mas de uma outra forma. No segundo, a classe-derivada realiza a mesma opera¸caõ da classe-base e algo mais. Isto significa que a classe-derivada pode reescrever totalmente o método herdado ou pode chamar o método da classe-base e depois acrescentar algo mais (veja método Set(int,int,int) da listagem 17.1). • Se você criar um atributo na classe-derivada com o mesmo nome de um atributo da classe-base, o atributo da classe-base continuar´ a existindo, mas para acess´ a-lo, você deverá utilizar o operador de resolu¸caõ de escopo (::). Veja listagem 17.5. Exemplo: NomeClasseBase::nomeAtributoRedeclarado; • Se você redeclarar um método na classe-derivada, este oculta o método de mesmo nome da classe-base. O método da classe-base pode ser acessado utilizando-se o operador de resolu¸caõ de escopo. Exemplo: NomeClasseBase::nomeM´ etodoRedeclarado(); • 2 N˜ ao confundir redeclara¸caõ (método com mesmo nome e parˆ ametros na classe-derivada) com utiliza¸caõ de sobrecarga de métodos (métodos com mesmo nome, mas com n´ umero ou tipos dos parˆ ametros diferentes) ou com a utiliza¸caõ de métodos virtuais (método com mesmo nome e parˆ ametros, mas com especificador virtual). Listing 17.5: Redeclara¸caõ de método ou atributo na classe-derivada. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# include < iostream > int x = 0; // V a r i ´ a v e l global - escopo global class B { public : const int x ; B () : x (1) { std :: cout << << << << } }; class D : public B { public : const int x ; D () : x (2) { std :: cout << << << << } };

// Escopo da classe B " \ n \ tIn´ ı cio do construtor de B ( escopo de B ) : " " \ n \ t :: x = " << :: x " \ n \ tx = " << x " \ n \ tFim do construtor " << std :: endl ;

// Escopo da classe D // Oculta x da classe - base " \ n \ tIn´ ı cio do construtor de D ( escopo de D ) : " " \ n \ t :: x = " << :: x " \ n \ tx = " << x " \ n \ tB :: x = " << B :: x << std :: endl ;

int main () {



344 30 31 32 33 34 35 36 37 38

17.8. SENTENCAS ¸ PARA HERANCA ¸

std :: cout B obj_b ; std :: cout D obj_d ; std :: cout return 0;

<< " Fun¸ ca ~ o main () ( escopo de main () ) : " << " \ n :: x = " << :: x << std :: endl ; << " obj_b . x = " << obj_b . x <<

std :: endl ;

<< " obj_d . x = " << obj_d . x <<

std :: endl ;

} Fun¸ ca ~ o main () ( escopo de main () ) : :: x =0 In´ ı cio do construto r de B ( escopo de B ) : :: x =0 x =1 Fim do construto r obj_b . x =1 In´ ı cio do construto r de B ( escopo de B ) : :: x =0 x =1 Fim do construto r In´ ı cio do construto r de D ( escopo de D ) : :: x =0 x =2 B :: x =1 obj_d . x =2

17.8

Senten¸cas para heran¸ca

• A classe-base de uma hierarquia também é chamada de classe-pai ou de superclasse. As demais classes s˜ ao denominadas classes-derivadas, subclasses ou classes-filho. • A maior dificuldade em uma hierarquia é modelar com clareza as classes e seus relacionamentos. • Observe que a classe-derivada n˜ ao altera em nada a classe-base, de forma que, se a classederivada for alterada, somente ela precisará ser recompiladaA utiliza¸caõ de protected e private deixa o c´ odigo mais encapsulado e, portanto, mais facilmente depurado. • Uma classe vazia pode ser utilizada temporariamente quando o programador quer criar uma classe-base, mas ainda n˜ ao identificou as rela¸co˜es entre as classes-derivadas. Uma classe vazia pode criar objetos. Note que, nestes casos, você também pode criar uma classe de interface (Se¸caõ 11.5.2). • Em uma heran¸ca é aconselh´ avel que um método construtor chame os métodos construtores ancestrais para a declara¸caõ dos atributos ancestrais, em vez de atribuir ele mesmo esses atributos (Se¸caõ 17.6). • Se a heran¸ca é publica você tem ”um tipo de”, ou seja, a classe-derivada cria um tipo de objeto que pode ser utilizado no lugar de um objeto da classe-base. • Métodos da hierarquia podem ser ”desabilitados” colocando-os como private. Ao colocar o método como private, ele n˜ ao poder´ a mais ser acessado (sendo desabilitado o acesso ao mesmo). Programa¸caõ Orientada a Objeto com C++



345

• Objetos (nomes) criados em um escopo local, de fun¸caõ ou método, ocultam objetos com mesmo nome criados no escopo global ou de classe, mesmo sendo de tipos diferentes. Em heran¸cas isto também ocorre. Um atributo ou método com mesmo nome em uma classe-derivada oculta o atributo/método da classe-base (Se¸caõ 17.7). • Em uma hierarquia as classes devem ter operadores de convers˜ ao (veja Cap´ıtulo 25 – Convers˜ oes). • Segundo [Parga, 2006], ”heran¸ca é um tipo de relacionamento de alto acoplamento, posto que altera¸co˜es realizadas na superclasse s˜ ao refletidas em toda hierarquia abaixo dela. Sendo assim, a cria¸caõ de uma hierarquia de classes muito profunda torna o sistema extremamente sens´ıvel a altera¸co˜es, fazendo com que sua manuten¸caõ fique dif´ıcil”. • 2 Em uma hierarquia, se um método é reescrito nas classes-derivadas, ele deve ser virtual. • 2 O operador de atribui¸caõ e os construtores da classe-base n˜ ao s˜ ao herdados pelas classesderivadas, ou seja, todas as classes devem ter construtores default e de c´ opia, destrutores virtuais e operadores sobrecarregados. • 2 A utiliza¸caõ de classes, heran¸ca e métodos virtuais é a base para o polimorfismo, que possibilita o desenvolvimento de sistemas complexos (veja Cap´ıtulo 19 – Polimorfismo). • 2 Em uma hierarquia de classes, os destrutores devem ser virtuais. Se você tiver heran¸ca e destrutores n˜ ao virtuais, na destrui¸caõ de um objeto dinâmico o destrutor que ser´ a executado é o definido pelo tipo do ponteiro utilizado. •

2

Um ponteiro para classe-derivada pode acessar um método da classe-base [Meyers, 2005]. Derivada* ptr = new Derivada(); ptr->Base::Desenhar();

• 3 Em uma heran¸ca, se os métodos virtuais têm parˆ ametros predefinidos, eles devem ser iguais em toda hierarquia, pois os argumentos predefinidos s˜ ao definidos em tempo de compila¸caõ. • 3 Atributos, métodos privados e métodos n˜ ao virtuais s˜ ao invariantes para as classesderivadas [Meyers, 2005]. • 3 Em heran¸cas, métodos virtuais podem ser substitu´ıdos por métodos que recebem ponteiros para fun¸co˜es. Você também pode utilizar a classe utilitária da biblioteca boost (std::tr1::function). Veja Cap´ıtulo ??.

17.9


Nesce cap´ıtulo aprendemos a implementar o conceito de heran¸ca simples em C++. Basicamente, basta incluir, ap´ os o nome da classe, o trecho de c´ odigo : public Base. Vimos que podemos ter heran¸ca p´ ublica, protegida ou privada. Lembre-se de que, para ser um ”tipo de”, a heran¸ca deve ser p´ ublica. Isto significa que heran¸cas protegidas e privadas s˜ ao pouco utilizadas. Aprendemos que quando a classe-base n˜ ao tem um construtor default, o construtor existente deve ser explicitamente chamado. Programa¸caõ Orientada a Objeto com C++


17.10. EXERCÍCIOS

346

Aprendemos que a redeclara¸caõ de atributos na classe-derivada deve ser evitada, pois teremos dois atributos com o mesmo nome, mas em escopos diferentes. J´ a a redeclara¸caõ de métodos é normal quando o método é virtual. No Cap´ıtulo 18 – Heran¸ca M´ ultipla, veremos como implementar o conceito de heran¸ca m´ ultipla em C++.

17.10

Exerc´ıcios

1. Use o debuger da GNU (gdb ou ddd) para rodar passo a passo as listagens com heran¸ca simples e heran¸ca m´ ultipla. Veremos os depuradores nos cap´ıtulos ?? – Uma Introdu¸caõ aos Bugs e a Debugagem de Programas e ?? – Os Programas gdb, ddd e o bugzilla. 2. Corrija a listagem 17.3, incluindo métodos X()/X(int), Y()/Y(int), Z()/Z(int) para os atributos x, y, z. 3. Comente a listagem 17.5 4. Desenhe e implemente uma hierarquia com as classes CQuadrado, CRetangulo, CTriangulo, CTrapezio utilizando o conceito de heran¸ca.



Cap´ıtulo 18

Heran¸ ca M´ ultipla Na Se¸caõ 3.6, vimos a defini¸caõ de heran¸ca e heran¸ca m´ ultipla, e na Se¸caõ 6.4.11, como UML modela o conceito de heran¸ca m´ ultipla. No Cap´ıtulo 17 – Heran¸ca, vimos como implementar o conceito de heran¸ca em C++. Veremos neste cap´ıtulo uma introdu¸caõ e o prot´ otipo para implementar heran¸ca m´ ultipla (Se¸caõ 18.1), além de uma introdu¸caõ ao conceito de heran¸ca m´ ultipla em C++ (Se¸caõ 18.2). Veremos também como resolver os problemas de ambig¨ uidade em heran¸ca m´ ultipla (Se¸caõ 18.3), o uso de heran¸ca m´ ultipla com base comum (Se¸caõ 18.4), a ordem de cria¸caõ e destrui¸caõ dos objetos em uma heran¸ca (Se¸caõ 18.5) e a heran¸ca m´ ultipla virtual (Se¸caõ 18.6).

18.1

Prot´ otipo para heran¸ca m´ ultipla

Vimos na Se¸caõ 3.6 o conceito de heran¸ca e heran¸ca m´ ultipla. Neste cap´ıtulo veremos como implementar heran¸ca m´ ultipla em C++. A heran¸ca m´ ultipla ocorre quando uma classe tem mais de um pai, isto é, quando uma classe-derivada é herdeira de mais de uma classe-base; ocorre em muitos casos reais, quando um objeto n˜ ao é composto de outros objetos, mas de uma evolu¸caõ de outros objetos, ou seja, dois ou mais objetos foram unidos para criar um novo, e o objeto novo n˜ ao pode ser identificado como sendo uma agrega¸caõ de B1 ou B2. Veja a seguir o prot´ otipo para os diferentes tipos de heran¸ca m´ ultipla. Prot´ otipo: class Derivada : especificadorHeran¸ca Base1, especificadorHeran¸ca Base2,... {}; // Heran¸ca m´ ultipla (veja se¸ca õ 18.2) class Derivada : virtual especificadorHeran¸ca Base1, virtual especificadorHeran¸ca Base2 {}; // Heran¸ca m´ ultipla virtual (veja se¸ca õ 18.6)

18.2

Como implementar a heran¸ca m´ ultipla

Veja no exemplo a seguir como implementar a heran¸ca m´ ultipla apresentada na Figura 18.1. Observe que a classe D é herdeira das classes B1 e B2. Note ainda que a heran¸ca se d´ a da esquerda para a direita; primeiro herda os atributos e métodos de B1, depois de B2. 347

´ 18.2. COMO IMPLEMENTAR A HERANCA ¸ MULTIPLA

348

Figura 18.1: Heran¸ca m´ ultipla.

B1

B2

+atr_b1 +atr_b +f1() +f2()

+atr_b2 +atr_b +f1() +f2()

A classe D é herdeira de B1 e de B2.

Herança

D +atr_d

Exemplo: class B1 { public: int atr_b1; int atr_b; }; class B2 { public: int atr_b2; int atr_b; }; class D: public B1, public B2 { public: int atr_d; }; int main() { B1 b1; B2 b2; D d; return 0; }

// Heran¸ ca m´ ultipla

Observe na Figura 18.2 como ficam os objetos b1, b2 e d na memória de seu computador. O objeto b1 tem os atributos atr_b1 e atr_b; o objeto b2 tem os atributos atr_b2 e atr_b; e o objeto d, os atributos atr_b1 e atr_b (herdados da classe B1), atr_b2 e atr_b (herdados da classe B2) e atr_d (da própria classe D).

Figura 18.2: Como ficam os objetos b1, b2 e d em uma heran¸ca m´ ultipla. Objeto b1 na memória

Objeto b2 na memória

atr_b1

atr_b1

atr_b

atr_b

atr_b2

atr_b2

atr_b

atr_b

Objeto d na memória

atr_d



´ ¨ 18.3. RESOLVENDO AMBIGUIDADE EM HERANCA ¸ MULTIPLA COM USING

18.3

349

Resolvendo ambigu ultipla com ¨ idade em heran¸ca m´ using

Quando você utiliza heran¸ca m´ ultipla, pode ocorrer que as classes B1 e B2 tenham um atributo com o mesmo nome (veja na Figura 18.1 o atributo atr_b); esse atributo ser´ a criado duas vezes, uma pelo caminho D-B1 e outra pelo caminho D-B2. Quando você tentar acessar esse atributo em um método da classe D, o compilador exibir´ a uma mensagem de erro por ambig¨ uidade, ou seja, quando você acessa atr_b, você quer acessar atr_b herdado da classe B1 ou atr_b herdado da classe B2? Para contornar esse problema você deve utilizar o operador de resolu¸caõ de escopo (::). Veja o prot´ otipo a seguir:

Prot´ otipo: base1::nomeAtributoAmb´ıguo; base2::nomeAtributoAmb´ıguo;

Exemplo: B1::atr_b; B2::atr_b;

Alternativamente, pode-se eliminar o problema da ambig¨ uidade utilizando-se a palavra-chave using. Com as declara¸co˜es using, você pode selecionar, em uma classe-derivada, os métodos e atributos a serem utilizados. Veja o exemplo:

Exemplo: class D: public B1, public B2 { public: int atr_d; using B1::atr_b; // Quando chamar atr_b usar atr_b da classe B1 };

18.4

Heran¸ca m´ ultipla com base comum

O diagrama UML ilustrado na Figura 18.3 mostra uma heran¸ca m´ ultipla com base comum. A classe D é herdeira das classes B1 e B2 e estas s˜ ao herdeiras de B0. A classe B0 é uma classe-base comum (uma superclasse). Programa¸caõ Orientada a Objeto com C++


´ 18.4. HERANCA ¸ MULTIPLA COM BASE COMUM

350

Figura 18.3: Heran¸ca m´ ultipla com classe base comum.

B0 O atributo atr_b0 vai ser criado duas vezes, uma pelo caminho D->B1->B0, e outra pelo caminho D->B2->B0.

+atr_b0

Herança

B1

B2

+atr_b1

+atr_b2

Herança

D +atr_d

Veja a seguir como implementar a hierarquia da Figura 18.3.

Exemplo: class B0 { public: int atr_b0; }; class B1: public B0 { public: int atr_b1; }; class B2: public B0 { public: int atr_b2; }; class D: public B1, public B2 { public: int atr_d;}; int main() { B0 b0; B1 b1; B2 b2; D d;

return 0;

}

Quando você tem heran¸ca m´ ultipla com D herdando de B1 e B2, a classe D ir´ a percorrer os construtores das classes B1 e B0 e, em seguida, os contrutores de B2 e B0, criando duas vezes o atributo atr_b0. Observe na Figura 18.4 que o atributo atr_b0 é criado duas vezes, uma pelo caminho D::B1::B0 e outra pelo caminho D::B2::B0. Novamente, o acesso em D ao atributo atr_b0 é ambiguo e precisa ser resolvido com o operador de resolu¸caõ de escopo (::) ou usando a palavra-chave using. Programa¸caõ Orientada a Objeto com C++


˜ E DESTRUIC ˜ DOS OBJETOS EM HERANCAS 18.5. ORDEM DE CRIAC ¸ AO ¸ AO ¸

351

Figura 18.4: Como ficam os objetos b0, b1, b2 e d em uma heran¸ca m´ ultipla com base comum. Objeto b0 na memória


atr_b0


atr_b0

B1::atr_b0

atr_b1

atr_b1

atr_b0

B2::atr_b0

atr_b2

atr_b2 atr_d


18.5

Ordem de cria¸c˜ ao e destrui¸c˜ ao dos objetos em heran¸ cas

Em uma heran¸ca m´ ultipla (veja Figura 18.3), a seq¨ uência de cria¸caõ dos objetos ocorre da esquerda para a direita. A Figura 18.5 ilustra a seq¨ uência de cria¸caõ dos objetos b0, b1, b2 e d. Para o objeto d, primeiro executa o construtor de B0, depois o construtor de B1, novamente o construtor B0, o construtor B2 e finalmente o construtor de D. A seq¨ uência de destrui¸caõ é inversa à da cria¸caõ. Primeiro executa o destrutor de D depois o destrutor de B2, B0, e finalmente o destrutor de B1 e B0.

Figura 18.5: Seq¨ uência de constru¸caõ e destrui¸caõ dos objetos em uma heran¸ca. int main() { B0 b0;

B0() Sequência de criação dos objetos b0,b1,b2,d.

B1 b1;

B0()

B1()

B2 b2;

B0()

B2()

D d;

B0()

B1()

B0()

B2()

D()

return 0; }

~D()

~B2

~B0()

~B1()

~B0()

~B2()

~B0()

~B1()

~B0()

Sequência de destruição dos objetos b0,b1,b2 e d quando os mesmos saem de escopo.

~B0() Agora encerra programa retornando o valor 0.



´ 18.6. HERANCA ¸ MULTIPLA VIRTUAL

352

18.6

Heran¸ca m´ ultipla virtual

Vimos na Se¸caõ 18.3 que, ao criar uma classe-derivada de mais de uma classe-base (heran¸ca m´ ultipla), o compilador cria todos os atributos da classe-base B1 e depois todos os atributos da classe-base B2 (veja figuras 18.1 e 18.2). Vimos na Se¸caõ 18.4 que, se as classes B1 e B2 s˜ ao herdeiras da classe B0, ent˜ ao o compilador ir´ a criar os atributos de B0 e B1 e, em seguida, os atributos de B0 e B2, de forma que o atributo de B0 (atr_b0) ser´ a criado duas vezes (veja figuras 18.3 e 18.4). Se você deseja ter o atributo repetido, tudo bem (veja exemplo em nota no final da se¸caõ). Porém, se você deseja ter apenas uma c´ opia dele, você precisará definir a heran¸ca como virtual. O prot´ otipo a seguir mostra a sintaxe da heran¸ca virtual. Prot´ otipo: class Derivada: virtual especificadorDeHeran¸caBase1, virtual especificadorDeHeran¸ca Base2, ... {.... }; Veja na Figura 18.6 o diagrama UML de uma heran¸ca m´ ultipla virtual. Neste caso, como a heran¸ca é declarada como virtual, s´ o ser´ a criada uma c´ opia do atributo da classe-base, ou seja, atr_b0 s´ o é criado uma vez pelo caminho D-B1-B0. Veja no exemplo a seguir como implementar a hierarquia da Figura 18.6. Observe a utiliza¸caõ da palavra-chave virtual. Veja na Figura 18.7 que o atributo atr_b0 é criado apenas uma vez, pelo caminho D::B1::B0. Compare com a Figura 18.4. Figura 18.6: Heran¸ca m´ ultipla virtual. B0

O atributo atr_b0 vai ser criado apenas uma vez, pelo caminho D->B1->B0.

+atr_b0

<>

<>

B1

B2

+atr_b1 +atr_b2

D +atr_d

Exemplo: class B0 { public: class B1: { public: class B2: { public: class D:

int atr_b0; }; virtual public B0 int atr_b1; }; virtual public B0 int atr_b2; }; public B1, public B2



˜ E DESTRUIC ˜ DOS OBJETOS EM HERANCA 18.7. ORDEM DE CRIAC ¸ AO ¸ AO ¸ ´ MULTIPLA VIRTUAL

353

{ public: int atr_d; }; int main() { B0 b0; B1 b1; B2 b2; D d; return 0; }

Figura 18.7: Como ficam os objetos b0, b1, B2 e d em uma heran¸ca m´ ultipla com base virtual. Objeto b0 na memória

atr_b0



atr_b0

atr_b0

atr_b1

atr_b1 atr_b2

atr_b0 atr_d Objeto b2 na memória

atr_b2

Nota: vamos a um exemplo em que a repeti¸caõ do atr_b0 é u ´ til. Imagine que a classe D precisa herdar informa¸co˜es de acesso a sites de internet. No caso, dois sites de pesquisa, B1 e B2. A informa¸caõ do endere¸co de internet é armazenada em atr_b0. Neste caso, atr_b0 pelo caminho D::B1 vai retornar o endere¸co do site B1, e atr_b0 pelo caminho D::B2 vai retornar o endere¸co do site B1.

18.7

Ordem de cria¸c˜ ao e destrui¸c˜ ao dos objetos em heran¸ ca m´ ultipla virtual

Em uma hierarquia com classes virtuais, a ordem de cria¸caõ dos atributos é dada por: primeiro s˜ ao inicializadas as classes-base virtuais, depois as classes normais (da esquerda para direita), depois os atributos n˜ ao-estáticos e, finalmente, o corpo do construtor. No exemplo a seguir, uma classe X tem heran¸ca normal de Y e virtual de Z. A seq¨ uência de cria¸caõ do objeto x é dada por Z(), Y(), X(), ou seja, primeiro s˜ ao percorridas as heran¸cas virtuais (da esquerda para a direita) e depois as heran¸cas normais. Exemplo: // Classe X com heran¸ ca virtual de Z class X: public Y, virtual public Z {}; int main() { // Cria objeto do tipo X com nome x X x; return 0; } Veja na Figura 18.8 uma hierarquia de classes com heran¸cas normais e virtuais (B1, B2, D1, D2 e Top). As classes-base s˜ ao B1 e B2. A classe D1 tem deriva¸caõ normal de B2 e virtual de B1. Programa¸caõ Orientada a Objeto com C++


354

˜ E DESTRUIC ˜ DOS OBJETOS EM HERANCA 18.7. ORDEM DE CRIAC ¸ AO ¸ AO ¸ ´ MULTIPLA VIRTUAL

A classe D2 tem deriva¸caõ normal de B2 e virtual de B1. A classe Top tem deriva¸caõ normal de D1 e virtual de D2. Figura 18.8: Heran¸ca m´ ultipla normal e virtual.

B1 +atr_b1 virtual virtual

B2 +atr_b2

D1

D2

virtual

Top

A hierarquia da Figura 18.8 é implementada na listagem 18.1. Observe na sa´ıda a seq¨ uência de constru¸caõ e destrui¸caõ de um objeto do tipo Top. Listing 18.1: Seq¨ uência de constru¸caõ e destrui¸caõ em heran¸ca m´ ultipla virtual. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# include < iostream > class B1 { int atr_b1 ; public : B1 () { std :: cout << " Construtor de B1 - " ; ~ B1 () { std :: cout << " Destrutor de B1 - " ; }; class B2 { int atr_b2 ; public : B2 () { std :: cout << " Construtor de B2 - " ; ~ B2 () { std :: cout << " Destrutor de B2 - " ; }; class D1 : public B2 , virtual public B1 { public : D1 () { std :: cout << " Construtor de D1 - " ; ~ D1 () { std :: cout << " Destrutor de D1 - " ; };


}; };

}; };

}; };


´ 18.8. SENTENCAS ¸ PARA HERANCA ¸ MULTIPLA 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

class D2 : public B2 , virtual public B1 { public : D2 () { std :: cout << " Construtor de D2 -" ; ~ D2 () { std :: cout << " Destrutor de D2 -" ; };

355

}; };

class Top : public D1 , virtual public D2 { public : Top () { std :: cout << " Construtor de Top -" ; }; ~ Top () { std :: cout << " Destrutor de Top -" ; }; }; int main () { Top p ; return 0; } [bueno@ldsc05 Construtor de Construtor Destrutor

Parte - II ] $ ./ a . out B1 - Construtor de B2 - Construtor de D2 - Construtor de B2 de D1 - Construtor de Top - Destrutor de Top - Destrutor de D1 de B2 - Destrutor de D2 - Destrutor de B2 - Destrutor de B1 -

A seq¨ uência de cria¸caõ do objeto p é dada por: • Primeiro a seq¨ uência de D2 que é virtual: cria B1, que é virtual, cria B2 e, ent˜ ao, cria D2. • Depois a seq¨ uência de D1 que é normal:como a classe B1 é virtual, e a mesma já foi criada pelo caminho Top::D2::B1, n˜ ao precisa ser criado novamente. A seguir cria B2 e, depois cria D1. • Finalmente cria Top. Assim, os construtores default das classes virtuais s˜ ao chamados antes dos construtores das classes n˜ ao virtuais. Releia a frase anterior; veja que escrevemos ”os construtores default das classes virtuais”. Se a classe-base virtual n˜ ao tem um construtor default (sem parˆ ametros), um dos construtores com parˆ ametros deve ser explicitamente chamado. Lembre-se de que toda classe tem um construtor, sem parˆ ametros, que é criado automaticamente pelo compilador. Vimos que você pode reescrever o construtor da forma que quiser, e que, se criar qualquer construtor com parˆ ametros, o construtor default deixa de ser criado pelo compilador. Como o construtor default deixa de ser criado, o construtor existente precisa ser explicitamente chamado (Se¸caõ 16.3).

18.8

Senten¸cas para heran¸ca m´ ultipla

• Observe que a chamada do construtor da classe-base s´ o ser´ a importante se ele for efetivamente implementado e contiver, por exemplo, a cria¸caõ de objetos dinâmicos. • Uma classe D n˜ ao pode ter deriva¸caõ m´ ultipla de uma classe B. Este procedimento n˜ ao é permitido por ser amb´ıguo. Programa¸caõ Orientada a Objeto com C++


356

´ 18.8. SENTENCAS ¸ PARA HERANCA ¸ MULTIPLA Exemplo: class B { }; class D : public B, public B {}; // Erro de ambig¨ uidade

• Você pode criar um método de inicializa¸caõ (Inicializa()), que pode ser utilizado para inicializa¸caõ dos atributos do objeto. Você pode chamar Inicializa() no construtor da classe-derivada. • A utiliza¸caõ de heran¸ca virtual é interessante, permitindo construir classes mais complexas a partir da montagem de classes mais simples, com economia de memória e de implementa¸caõ. • A heran¸ca virtual deve ser utilizada com critério e com cuidado. O uso excessivo de heran¸ca virtual deixa o c´ odigo mais lento. • O acesso a atributos em classes com heran¸ca virtual é mais lento que em classes com heran¸ca comum. • Se em uma heran¸ca virtual a classe-base n˜ ao tiver um construtor default (pois foi definido um construtor com parˆ ametros), o construtor da classe-base virtual deve ser explicitamente chamado. Veja o exemplo: Exemplo: // Arquivo CMinhaJanela.h class CFrameWindow: virtual public CWindow {...}; class CMinhaJanela: public CFrameWindow { // Construtor CMinhaJanela(string titulo); }; // Arquivo CMinhaJanela.cpp - Defini¸ c~ ao do construtor // Chama construtor da classe-base e o // construtor da classe-base virtual explicitamente CMinhaJanela::CMinhaJanela(string titulo) :CFrameWindow(titulo),Window(titulo) {} • A dica para simplificar o uso de classes com heran¸ca virtual é sempre incluir um construtor default. • Se a classe-base é declarada como virtual, inclua um construtor default. Isto é necess´ ario para a cria¸caõ de uma matriz de objetos, pois quando esta é criada, o construtor executado é o construtor default. • Se você deseja ter um mecanismo para identificar de que classe é um objeto (dado que você tem apenas um ponteiro para a classe-base), você deve incluir um método que retorne o nome da classe. Isto é utilizado na programa¸caõ em ambientes de janela (como Windows, Mac OS X, Gnome, KDE), em que cada classe tem um método que retorna o nome da classe. Esse método é chamado GetClassName(). Mais recentemente, C++ incluiu a palavra-chave typeid que retorna dinamicamente o tipo de um objeto (veja Se¸caõ 9.5.4). • Procure criar uma classe-base que tenha somente métodos virtuais e p´ ublicos, uma classe de interface (veja Se¸caõ 11.5.2). Programa¸caõ Orientada a Objeto com C++


´ 18.9. EXEMPLO DE HERANCA ¸ SIMPLES E HERANCA ¸ MULTIPLA

357

• Note que uma hierarquia com heran¸cas simples é uma árvore (tree). Se a hierarquia inclui heran¸cas m´ ultiplas, ent˜ ao ela gera um grafo e n˜ ao uma árvore. • No exemplo a seguir usamos sizeof() para verificar o tamanho da classe-base e da classederivada. Exemplo: NomeClasseBase *ptr = new CNomeClasseDerivada; sizeof(CNomeClasseBase); // Retorna o tamanho da classe-base sizeof(CNomeClasseDerivada);// Retorna o tamanho da classederivada sizeof(ptr); // Retorna o tamanho da classe-base • 2 Nunca redefina um método n˜ ao virtual. Isto elimina o conceito de invariˆ ancia de métodos n˜ ao virtuais [Meyers, 2005]. • 2 Quando se utiliza o mecanismo do polimorfismo é fundamental que o destrutor da classebase seja virtual. Do contr´ ario, o destrutor da classe-derivada n˜ ao ser´ a executado.

18.9

Exemplo de heran¸ca simples e heran¸ca m´ ultipla

Observe na Figura 18.9 a hierarquia de classes CPonto. A classe CCirculo é herdeira de CPonto e a classe CElipse é herdeira de CCirculo. A classe CCirculoElipse é herdeira de CCirculo e de CElipse. As classes CPonto e CCirculo foram apresentadas nas listagens 13.5 e 17.1, respectivamente. Veja na listagem 18.2 a classe CElipse e, na listagem 18.4, um programa que utiliza as classes definidas. Figura 18.9: Hierarquia de classes CPonto, CCirculo, CElipse, CCirculoElipse. CPonto +x +y +Desenha()

Hierarquia de classes CPonto.

CCirculo +r1 +Desenha() CCirculoElipse tem Herança múltipla

CElipse +r2 +Desenha()

CCirculoElipse +Desenha()

Listing 18.2: A classe CElipse. 1

# ifndef CElipse_h



358 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

´ 18.9. EXEMPLO DE HERANCA ¸ SIMPLES E HERANCA ¸ MULTIPLA

# define CElipse_h # include " CCirculo . h " class CElipse : public CCirculo // H e r a n ¸ ca simples { protected : int r2 ; public : // C o n s t r u t o r CElipse ( int x , int y , int raio1 , int raio2 ) ; // Seta a t r i b u t o s do objeto void Set ( int x , int y , int raio1 , int raio2 ) ; virtual void Desenha () ; // R e d e c l a r a d a }; # endif

Observe na listagem 18.3 que o método Desenha() de CElipse chama Desenha() de CCirculo e, depois, acrescenta coisas novas. Isto é, o método Desenha() da classe-base é redefinido na classe-derivada, fazendo o que CCirculo::Desenha fazia e algo mais. Listing 18.3: Implementa¸caõ da classe CElipse. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# include < iostream > # include " CElipse . h " // O b s e r v e que a c h a m a d a e x p l ´ ı c i t a do c o n s t r u t o r da classe - base C C i r c u l o // ´ e necess´ a r i a porque C C i r c u l o n~ a o tem um c o n s t r u t o r d e f a u l t e // quero passar os a t r i b u t o s x , y e raio1 CElipse :: CElipse ( int x , int y , int raio1 , int raio2 ) : CCirculo (x , y , raio1 ) , r2 ( raio2 ) {} void CElipse :: Set ( int x , int y , int raio1 , int raio2 ) { // Herdou x e y de CPonto this - > x = x ; this - > y = y ; r1 = raio1 ; // Herdou r1 de C C i r c u l o r2 = raio2 ; // Criou o a t r i b u t o r2 na classe C E l i p s e } void CElipse :: Desenha () { CCirculo :: Desenha () ;

// I n s t r u ¸ c~ a o para d e s e n h a r o c ´ ırculo;

// Aqui voc^ e pode a c r e s c e n t a r i n s t r u ¸ c~ o e s r e f e r e n t e s ao d e s e n h o da elipse std :: cout << " \ nCElipse : Coordenada r2 = " << r2 << std :: endl ; }

Veja na listagem 18.4 um programa que utiliza as classes definidas. Listing 18.4: Usando as classes CPonto, CCirculo e CElipse. 1 2 3 4 5 6 7 8 9 10 11 12

# include < iostream > using namespace std ; # include " CElipse . h " int main () { int x = 5; int y = 4; { cout << " \n - - - - - - - - - - - - - - - - Testando CPonto : " << endl ; CPonto ponto ; // Cria objeto do tipo CPonto com nome ponto ponto . Set (x , y ) ; // Chama m´ e todo Set () do objeto ponto



´ 18.10. ANALISE DOS ERROS EMITIDOS PELO COMPILADOR2 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

ponto . Desenha () ;

359

// Chama m´ e todo D e s e n h a () do objeto ponto // Sai de escopo e detr´ o i objeto ponto

}

cout << " \n - - - - - - - - - - - - - - - - Testando CPonto din^ a mico : " << endl ; CPonto * ptr = NULL ; // Cria p o n t e i r o para CPonto ptr = new CPonto ; // Cria objeto do tipo CPonto x = 6; y = 7; ptr - > Set (x , y ) ; // Chama m´ e todo Set () do objeto usando ptr ptr - > Desenha () ; int xx = ptr - > X () ; delete ptr ; // Chama m´ e todo e s t ´ a t i c o da classe CPonto , // o b s e r v e que n~ a o p r e c i s a de um objeto // U t i l i z a o nome da classe s e g u i d o do o p e r a d o r de r e s o l u ¸ c~ a o de escopo . cout << " Contador = " << CPonto :: Contador () << endl ; cout << " \n - - - - - - - - - - - - - - - - Testando CCirculo : " << endl ; CCirculo c (55 , 44 , 33) ; c . Desenha () ; cout << " \n - - - - - - - - - - - - - - - - Testando CElipse : " << endl ; CElipse e (555 , 444 , 333 , 222) ; e . Desenha () ; return 0; } - - - - - - - - - - - - - - - - Testando CPonto : CPonto : Coordenada x = 5 CPonto : Coordenada y = 4 - - - - - - - - - - - - - - - - Testando CPonto din^ a mico : CPonto : Coordenada x = 6 CPonto : Coordenada y = 7 Contador = 2 - - - - - - - - - - - - - - - - Testando CCirculo : CPonto : Coordenada x = 55 CPonto : Coordenada y = 44 CCirculo : Coordenada r1 =33 - - - - - - - - - - - - - - - - Testando CElipse : CPonto : Coordenada x = 555 CPonto : Coordenada y = 444 CCirculo : Coordenada r1 =333 CElipse : Coordenada r2 =222

18.10

An´ alise dos erros emitidos pelo compilador2

No exemplo da listagem 18.5, define-se a classe CCirculoElipse. Esta representa um c´ırculo dentro de uma elipse (um olho). Na listagem 18.6 apresenta-se a implementa¸caõ da classe CCirculoElipse. Observe que o processo de compila¸caõ de CCirculoElipse falha, e o compilador apresenta erros que ser˜ ao discutidos a seguir. Listing 18.5: A classe CCirculoElipse. 1 2 3 4 5 6 7 8

# ifndef C C i r c u l o E l i p s e _ h # define C C i r c u l o E l i p s e _ h # include < iostream > using namespace std ; # include " CCirculo . h " # include " CElipse . h " // Quero um c i r c u l o e uma elipse ( um olho ) , as c o o r d e n a d a s do ponto c e n t r a l



360

´ 18.10. ANALISE DOS ERROS EMITIDOS PELO COMPILADOR2

9 10 11 12 13 14 15 16 17 18

// s~ a o as mesmas . H e r a n ¸ c a m´ u ltipla , herda de C C i r c u l o e de C E l i p s e class C C i r c u l o E l i p s e : public CCirculo , public CElipse { public : C C i r c u l o E l i p s e ( int xc , int yc , int rc , int r1e , int r2e ) ; C C i r c u l o E l i p s e ( CCirculo & circulo ) ; // C o n s t r u t o r de c o n v e r s ~ ao void Set ( int xc , int yc , int rc , int r1e , int r2e ) ; virtual void Desenha () ; // R e d e c l a r a d a }; # endif

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

# include " C C i r c u l o E l i p s e . h "

Listing 18.6: Implementa¸caõ da classe CCirculoElipse. C C i r c u l o E l i p s e :: C C i r c u l o E l i p s e ( int xc , int yc , int rc , int r1e , int r2e ) { // U t i l i z a o o p e r a d o r de r e s o l u ¸ c~ a o de escopo para a c e s s a r m´ e todo a n c e s t r a l CCirculo :: Set ( xc , yc , rc ) ; // C E l i p s e :: C C i r c u l o :: Set ( xc , yc , rc ) ; CElipse :: Set ( xc , yc , r1e , r2e ) ; } void C C i r c u l o E l i p s e :: Set ( int xc , int yc , int rc , int r1e , int r2e ) { CCirculo :: Set ( xc , yc , rc ) ; // C E l i p s e :: C C i r c u l o :: Set ( xc , yc , rc ) ; CElipse :: Set ( xc , yc , r1e , r2e ) ; } // C o n s t r u t o r de c o n v e r s ~ a o . Como o c ´ ı r c u l o n~ ao preenche totalmente // o C C i r c u l o E l i p s e e quero c o n s t r u i r um C C i r c u l o E l i p s e a partir de um // CCirculo , crio um c o n s t r u t o r de c o n v e r s ~ ao C C i r c u l o E l i p s e ( CCirculo & circulo ) { CCirculo :: Set ( circulo ) ; // O b s e r v e abaixo que passa c i r c u l o . r1 como r1 e r2 da C E l i p s e CElipse :: Set ( circulo .x , circulo .y , circulo . r1 , circulo . r1 ) ; } // I m p l e m e n t a ¸ c~ a o de Desenha , uso do o p e r a d o r de r e s o l u ¸ c~ a o de escopo // para i d e n t i f i c a r o m´ e todo da classe - base void C C i r c u l o E P o n t o :: Desenha () { CElipse :: Desenha () ; // D e s e n h a a elipse CCirculo :: Desenha () ; // D e s e n h a o c ´ ı r c u l o // C E l i p s e :: C C i r c u l o :: D e s e n h a () ; } C C i r c u l o E l i p s e . h :11: warning : direct base ’ CCirculo ’ i n a c c e s s i b l e in ’ C C i r c u l o E l i p s e ’ due to ambiguity C C i r c u l o E l i p s e . cpp : In construct or ’ C C i r c u l o E l i p s e :: C C i r c u l o E l i p s e ( int , int , int , int , int ) ’: C C i r c u l o E l i p s e . cpp :3: error : no matching function for call to ’ CCirculo :: CCirculo () ’ CCirculo . h :13: note : candidate s are : CCirculo :: CCirculo ( int , int , int ) CCirculo . h :6: note : CCirculo :: CCirculo ( const CCirculo &) C C i r c u l o E l i p s e . cpp :3: error : no matching function for call to ’ CElipse :: CElipse () ’ CElipse . h :11: note : candidates are : CElipse :: CElipse ( int , int , int , int ) CElipse . h :6: note : CElipse :: CElipse ( const CElipse &) C C i r c u l o E l i p s e . cpp :6: error : cannot call member function ’ void CCirculo :: Set ( int , int , int ) ’ without object C C i r c u l o E l i p s e . cpp : In member function ’ void C C i r c u l o E l i p s e :: Set ( int , int , int , int , int ) ’:




361

C C i r c u l o E l i p s e . cpp :12: error : cannot call member function ’ void CCirculo :: Set ( int , int , int ) ’ without object C C i r c u l o E l i p s e . cpp : At global scope : C C i r c u l o E l i p s e . cpp :19: error : expected ‘) ’ before ’& ’ token C C i r c u l o E l i p s e . cpp :29: error : ’ C C i r c u l o E P o n t o ’ has not been declared C C i r c u l o E l i p s e . cpp : In function ’ void Desenha () ’ : C C i r c u l o E l i p s e . cpp :31: error : cannot call member function ’ virtual void CElipse :: Desenha () ’ without object C C i r c u l o E l i p s e . cpp :32: error : cannot call member function ’ virtual void CCirculo :: Desenha () ’ without object make : ** [ C C i r c u l o E l i p s e . o ] Erro 1

A classe CCirculoElipse n˜ ao compila em virtude da presen¸ca de alguns erros. O primeiro erro est´ a na ambig¨ uidade no acesso ` a classe CCirculo. Isto ocorre porque esta classepode ser acessada pelo caminho CCirculo e pelo caminho CElipse::CCirculo. Outro erro apresentado é a falta da chamada expl´ıcita dos construtores de CCirculo. Como CCirculo n˜ ao tem um construtor default, o construtor de CCirculo precisa ser explicitamente chamado. O erro se repete para CElipse. Ocorre novo erro ao tentar converter CCirculoElipse para CCirculo, pois existem dois CCirculo e a base é amb´ıgua. Existe um erro na defini¸caõ do método construtor de CCirculoElipse: est´ a faltando o nome da classe e ::, isto é, CCirculoElipse::CCirculoElipse(...). Como você pode ver, a sa´ıda gerada pelo compilador pode ser muito grande. De modo geral, um pequeno erro de digita¸caõ (de sintaxe) pode gerar várias mensagens de erro. Um exemplo clássico de erro de digita¸caõ e que gera uma sa´ıda confusa é a falta ou excesso de colchetes {}. Com isso, você conclui que é necess´ ario compreender bem a sintaxe de C++ e digitar o programa com cuidado. Dica: veremos o uso do compilador da GNU, o g++ no Cap´ıtulo ?? – Compilando com gcc e g++, e a debugagem de programas no Cap´ıtulo ?? – Uma Introdu¸caõ aos Bugs e a Debugagem de Programas.

18.11


Vimos uma pequena introdu¸caõ e o prot´ otipo para implementar heran¸ca m´ ultipla. Aprendemos a implementar heran¸ca m´ ultipla em C++ e, ainda, como ficam os objetos na memória do computador. Em seguida, aprendemos a resolver os problemas de ambig¨ uidade em heran¸ca m´ ultipla e o uso de heran¸ca m´ ultipla com base comum. Também vimos o conceito de heran¸ca m´ ultipla virtual e a ordem de cria¸caõ e destrui¸caõ dos objetos em uma heran¸ca. Finalmente, aprendemos a analisar os erros emitidos pelo compilador. Dica: este é um dos cap´ıtulos mais complexos de C++. N˜ ao se preocupe se n˜ ao entendeu tudo em uma primeira leitura. Esses conceitos ser˜ ao assimilados ap´ os um certo per´ıodo de uso de C++.

18.12

Exerc´ıcios

1. Comente as listagens apresentadas. 2. Implemente as classes B1, B2 e D, descritas na Se¸caõ 18.2. 3. Implemente as classes B0, B1, B2 e D descritas na Se¸caõ 18.4. Programa¸caõ Orientada a Objeto com C++


362

18.12. EXERCÍCIOS

4. Monte o programa main() descrito na Figura 18.5. Rode o programa e veja se a ordem de constru¸caõ e destrui¸caõ descrita est´ a correta (você pode rodar o programa de dentro do debuger ddd; Veja Se¸caõ ??). 5. Modifique a listagem 18.1 acrescentando um parˆ ametro no construtor de B1. Veja a sa´ıda gerada. Em seguida, adicione a chamada ao construtor de B1. 6. Fa¸ca as corre¸co˜es necess´ arias no c´ odigo das listagens 18.5 e 18.6, de forma que a classe CCirculoElipse funcione e possa ser inclu´ıda no c´ odigo do programa da listagem 18.4. 7. Na Se¸caõ 18.9 apresentamos uma hierarquia de classes genéricas. A pergunta é,: um c´ırculo ”é um tipo de” ponto? Corrija a hierarquia. 8. Acrescente a hierarquia as classes CQuadrado, CRetangulo, CTriangulo e CTrapezio.



Cap´ıtulo 19

Polimorfismo Veremos neste cap´ıtulo como implementar o conceito de polimorfismo apresentado na Se¸caõ 3.7. Iniciamos explicando, na Se¸caõ 19.1, o funcionamento dos métodos n˜ ao virtuais (métodos normais e métodos est´ aticos). Em seguida apresentaremos os métodos virtuais, Se¸caõ 19.2, os quais s˜ ao a base para implementar o polimorfismo, descrito na Se¸caõ 19.3. Os métodos virtuais puros, utilizados para implementar classes abstratas ou de interface, s˜ ao descritos na Se¸caõ 19.4 e os métodos virtuais sobrecarregados na Se¸caõ 19.5. Finalmente, apresentaremos um exemplo cobrindo o uso prático de polimorfismo na Se¸caõ 19.6.

19.1

M´ etodos n˜ ao virtuais

Os métodos de uma classe podem ser normais, inline, est´ aticos ou virtuais. Os métodos normais, os métodos est´ aticos e os métodos em linha têm seu endere¸co definido a priori, na compila¸caõ, tendo uma liga¸caõ est´ atica. O termo liga¸caõ est´ atica significa que quando o compilador encontra uma chamada do método, ele substitui esta pelo endere¸co de memória onde o método est´ a localizado. J´ a os métodos com liga¸caõ dinâmica têm seu endere¸co definido durante a execu¸caõ. Veja na Tabela 19.1 exemplos de métodos com liga¸caõ est´ atica. Observe que métodos sem a palavra-chave virtual s˜ ao métodos com liga¸caõ est´ atica. Tabela 19.1: Métodos com liga¸caõ est´ atica Prefixo __ inline static inline static __ inline

Retorno Tipo Tipo Tipo Tipo Tipo Tipo

NomeMétodo NomeM´ etodo NomeM´ etodo NomeM´ etodo NomeM´ etodo NomeM´ etodo NomeM´ etodo

Parâmetro ( Tipo p ) ( Tipo p ) ( Tipo p ) ( Tipo p ) ( Tipo p ) ( Tipo p )

Sufixo __ __ __ __ const const

A Tabela 19.2 mostra métodos com liga¸caõ dinâmica. Observe o uso da palavra-chave virtual como prefixo. Note ainda que um método virtual pode ser const, mas n˜ ao pode ser static nem inline. 363

´ ˜ VIRTUAIS 19.1. METODOS NAO

364

Tabela 19.2: Métodos com liga¸caõ dinâmica Prefixo virtual virtual

Retorno Tipo Tipo

Nome Nome Nome

Parâmetro ( Tipo p ) ( Tipo p )

Sufixo __ const

Vamos tentar esclarecer o funcionamento da liga¸caõ est´ atica com um exemplo. Seja a classe B, com os métodos M1(), M2(), M3(). Verifique que M3() chama M1() e M2(). A classe D é derivada de B e redefine os métodos M1() e M2(). Na fun¸caõ main(), cria um objeto do tipo D com nome d e chama os métodos M1(), M2(), e M3(). Exemplo: class B { public: void M1(){...}; void M2(){...}; void M3(){ M1(); }; class D: public B { public: void M1() {...}; void M2() {...}; }; int main() { D d; d.M1(); d.M2(); d.M3();

M2(); };

// // // //

Chama M1() da Chama M2() da Chama M3() da pois M3() n~ ao

classe D classe D classe B, foi redefinida na classe D

return 0; } Como os métodos M1() e M2() têm liga¸caõ est´ atica, o método M3() definido apenas na classe B vai chamar os métodos M1() e M2() da classe B e n˜ ao da classe D, ou seja, como a liga¸caõ é est´ atica, o compilador traduz a fun¸caõ main() da seguinte forma: Exemplo: int main() { D d; D::M1(&d); // Chama M1() da classe D D::M2(&d); // Chama M2() da classe D B::M3(&d); // Chama M3() da classe B // O comando B::M3(&d); vai ser traduzido por // B::M1(&d); B::M2(&d); return 0; } Observe no exemplo anterior que foi criado um objeto do tipo D e que o método M3() est´ a executando os métodos M1() e M2() da classe B. Porém, se criamos uma classe D e redefinimos Programa¸caõ Orientada a Objeto com C++


´ 19.2. METODOS VIRTUAIS

365

M1() e M2(), normalmente iremos querer que os métodos M1() e M2() sejam sempre usados, mesmo quando chamamos M3(). Para que o método M3() chame os métodos M1() e M2() da classe D, os métodos M1() e M2() devem ser declaradas como métodos virtuais. Veremos a seguir como funcionam os métodos virtuais.

19.2

M´ etodos virtuais

Os métodos virtuais têm seu endere¸co definido dinamicamente, ou seja, durante a execu¸caõ do programa. Nesta se¸caõ, vamos discutir como isso funciona. Veja a seguir o prot´ otipo de declara¸caõ dos métodos virtuais. A u ´ nica diferen¸ca em rela¸caõ aos métodos normais é a inclus˜ ao da palavra-chave virtual. Veja na Tabela 19.2 exemplos de métodos com liga¸caõ dinˆ amica. Prot´ otipo: class B { // Declara método virtual virtual Tipo MétodoA(); // Declara método virtual com parˆ ametros virtual Tipo MétodoB(parˆ ametros); // Declara método virtual com parˆ ametros e const virtual Tipo MétodoC(parˆ ametros) const; }; class D: public B { // Redeclara método virtual virtual Tipo MétodoA(); // Redeclara método virtual com parˆ ametros virtual Tipo MétodoB(parˆ ametros); // Redeclara método virtual com parˆ ametros e const virtual Tipo MétodoC(parˆ ametros) const; }; Toda classe que possui métodos virtuais contém uma tabela chamada VMT - Virtual Memory Table ou Tabela de Métodos Virtuais. Essa tabela contém o endere¸co em tempo de execu¸caõ dos métodos virtuais. Assim, quando o programa est´ a rodando, a defini¸caõ de qual método vai ser executado é dada pela tabela VMT. Como funciona? A classe-base tem o endere¸co de seus métodos virtuais na sua tabela VMT e acessa-os verificando seus endere¸cos na tabela. A classe-derivada também tem uma VMT, onde h´ a o endere¸co de seus métodos virtuais. Desta forma, quando um objeto da classe-derivada chama um método, o endere¸co é obtido durante a execu¸caõ da sua VMT. Por meio desse mecanismo, a identifica¸caõ de qual método ser´ a executado é realizada dinamicamente através da verifica¸caõ do endere¸co dos métodos na tabela VMT. Esse mecanismo também recebe o nome de liga¸caõ dinˆ amica, pois o método que ser´ a executado, ser´ a definido durante a execu¸caõ. A Figura 19.1 ilustra o funcionamento da liga¸caõ dinâmica. Toda chamada a M1() e M2() passa pela VMT. Quando você cria um objeto do tipo B, este utiliza a VMT da classe B e sempre acessa os métodos M1() e M2() da classe B. Isso também é válido para a classe D. Quando você Programa¸caõ Orientada a Objeto com C++


´ 19.2. METODOS VIRTUAIS

366

cria um objeto do tipo D, este utiliza a VMT da classe D e sempre acessa os métodos M1() e M2() da classe D. Observe que quando um objeto da classe D acessa o método M3(), acessa o método M3() da classe B porque este n˜ ao foi redefinido na classe D. Mas quando M3() acessa M1() e M2(), est´ a acessando os métodos M1() e M2() da classe D porque passa pela VMT da classe D. Veremos a seguir senten¸cas para métodos virtuais e logo ap´ os, como usar os métodos virtuais para implementar o polimorfismo. Figura 19.1: Ilustra¸caõ do funcionamento da liga¸caõ dinâmica. Classe B

VMT_CLASSE_B M1

+M1(): virtual +M2(): virtual +M3()

M2 M3() { M1(); M2(); }

Herança

void main() { D* ptr = new D(); ptr->M1(); ptr->M2(); ptr->M3(); delete ptr; }

19.2.1

Classe D +M1(): virtual +M2(): virtual

VMT_CLASSE_D M1 M2

Senten¸cas para m´ etodos virtuais

• N˜ ao devemos chamar métodos virtuais de dentro do construtor, pois o construtor da classe sempre ir´ a chamar os métodos da própria classe. Isto ocorre porque a tabela VMT da classe derivada ainda n˜ ao foi criada. • Uma vez que um método é declarado como virtual, este o ser´ a para sempre e em todas as classes derivadas. Se um método M() é declarado como virtual na classe-base B, e, em uma classe-derivada D, o programador omite a palavra chave virtual, ent˜ ao ele est´ a indicando que este método n˜ ao deve ser redefinido nas classes derivadas de D. • Os métodos virtuais devem ter exatamente o mesmo prot´ otipo; se o nome for igual e os parˆ ametros diferentes, teremos sobrecarga de métodos. Veja o Cap´ıtulo 14 – Sobrecarga de Métodos e a Se¸caõ 19.5. • Retorno diferente n˜ ao diferencia métodos; o que diferencia os métodos é o seu nome e os seus parˆ ametros. • Note que um método virtual pode ser const, mas n˜ ao pode ser static (porque métodos static n˜ ao recebem o ponteiro this) nem inline (porque métodos inline s˜ ao substitu´ıdos/resolvidos em tempo de compila¸caõ). • A utiliza¸caõ de métodos virtuais em heran¸cas permite a implementa¸caõ do conceito de polimorfismo e elimina muitas das estruturas switch (veja Se¸caõ 19.3). • Quando você cria classes com métodos virtuais você deve declarar o destrutor como sendo virtual, garantindo, desta forma, a execu¸caõ do destrutor correto. Programa¸caõ Orientada a Objeto com C++


19.3. COMO IMPLEMENTAR O POLIMORFISMO

367

• Cuidado com parˆ ametros predefinidos em métodos virtuais. Embora o método a ser executado seja definido em tempo de execu¸caõ, os parˆ ametros s˜ ao definidos em tempo de compila¸caõ, tendo como base o tipo do ponteiro utilizado. Este problema é facilmente contornado. As assinaturas de todos os métodos virtuais devem ser exatamente iguais. • Se o método é virtual, você deve evitar o uso de parˆ ametros predefinidos ou ter certeza de que todas as declara¸co˜es e defini¸co˜es de um método virtual têm exatamente os mesmos valores predefinidos (veja Se¸caõ 13.6.4). • 2 Em uma hierarquia de classes, um método virtual deve ter o mesmo tipo de retorno. Se o tipo de retorno for diferente, ent˜ ao temos um retorno covariante. Este caso é poss´ıvel somente se o retorno for um ponteiro ou referência para um tipo derivado da classe-base. No exemplo a seguir o retorno do método M(); é covariante: Exemplo: class Base { virtual Base* M();}; class Derivada1: public Base { virtual Derivada1* M();}; class Derivada2: public Derivada1 { virtual Derivada2* M();};

19.3

Como implementar o polimorfismo

Vimos anteriormente que polimorfismo significa muitas formas (Se¸caõ 3.7), ou seja, para cada classe-derivada o método virtual ser´ a redefinido, mas de forma diferente. Vimos ainda que o método virtual que vai ser efetivamente executado é endere¸cado pela VMT. Para implementar o polimorfismo é necess´ ario uma hierarquia de classes com métodos virtuais e a cria¸caõ dos objetos de forma dinˆ amica (com o uso de um ponteiro para a classe-base). Veja na listagem 19.1 um exemplo que esclarece a utiliza¸caõ do polimorfismo. O programa Polimorfismo.cpp utiliza as classes CPonto, CCirculo e CElipse definidas anteriormente (veja Figura 18.9). O programa inicia-se criando um ponteiro para a classebase da hierarquia, a classe CPonto. Dentro do la¸co do..while() (veja Se¸caõ D.3.3), o usuário seleciona qual objeto deve ser criado, isto é, CPonto, CCirculo ou CElipse. Em seguida, dentro do switch (veja Se¸caõ D.2.4), cria o objeto selecionado. ao existe nenhuma referência ou informa¸caõ Observe que na chamada a ptr->Desenha();; n˜ sobre qual foi o objeto criado. Porém, com a utiliza¸caõ do mecanismo de polimorfismo, o método Desenha() que ser´ a executado é aquele do objeto que foi criado (usa a VMT do objeto criado). Observe que, depois que o objeto foi criado, pode-se utilizar os métodos p´ ublicos da classe CPonto. Se o usu´ ario solicitar a cria¸caõ de um objeto CPonto o programa ir´ a executar o método Desenha() de CPonto;; se o usu´ ario criar um objeto CCirculo, o programa ir´ a executar o método Desenha() de CCirculo; e se criar um objeto CElipse, o programa ir´ a executar o método Desenha() de CElipse. Isso quer dizer que o método executado dependerá do objeto criado. Veja no final da listagem como ficar´ a a sa´ıda do programa, selecionando-se os diferentes tipos de objetos. Para compilar a listagem Polimorfismo.cpp, digite: g++ Polimorfismo.cpp CCirculo.cpp CElipse.cpp CPonto.cpp Programa¸caõ Orientada a Objeto com C++


368

19.3. COMO IMPLEMENTAR O POLIMORFISMO

Nota: o la¸co do..while() é descrito na Se¸caõ D.3.3, e o uso de switch na Se¸caõ D.2.4. As listagens utilizadas s˜ ao: 13.5, 17.1, 18.2.

Listing 19.1: Exemplo de uso do polimorfismo. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# include < iostream > # include " CPonto . h " # include " CCirculo . h " # include " CElipse . h " using namespace std ; // E x e m p l o de c r i a ¸ c~ ao e utiliza¸ c~ a o do objeto CPonto , C C i r c u l o e C E l i p s e int main () { CPonto * ptr = NULL ; // 1. Crie um p o n t e i r o para a classe - base int selecao ; while ( true ) { // 2. P e r g u n t e qual objeto ser´ a criado cout << " \ nQual objeto criar ? " ; cout << " \ nCPonto ..(1) , CCirculo ..(2) , CElipse ..(3) , Para sair (4) ?: " ; cin >> selecao ; cin . get () ; switch ( selecao ) // 3. Crie o objeto s e l e c i o n a d o { case 1: ptr = new CPonto (1 , 2) ; break ; case 2: ptr = new CCirculo (1 , 2 , 3) ; break ; case 3: ptr = new CElipse (1 , 2 , 3 , 4) ; break ; case 4: return 0; default : ptr = new CCirculo (1 , 2 , 3) ; break ; } ptr - > Desenha () ; // 4. U t i l i z a o objeto criado ptr - > O u t r o s M ´ e t o d o s () delete ptr ; // 5. Para d e s t r u i r o objeto criado use delete ptr = NULL ; } return 0; } Qual objeto criar ? CPonto ..(1) , CCirculo ..(2) , CElipse ..(3) , Para sair (4) ?:1 CPonto : Coordenada x = 1 CPonto : Coordenada y = 2 Qual objeto criar ? CPonto ..(1) , CCirculo ..(2) , CElipse ..(3) , Para sair (4) ?:3 CPonto : Coordenada x = 1 CPonto : Coordenada y = 2 CCirculo : Coordenada r1 =3 CElipse : Coordenada r2 =4 Qual objeto criar ? CPonto ..(1) , CCirculo ..(2) , CElipse ..(3) , Para sair (4) ?:4

Releia o exemplo com cuidado e observe que depois que o objeto é criado dentro do switch, este pode ser utilizado (chamada a ptr->desenhar()), mas você n˜ ao saberá qual foi o objeto que o usuário criou. Trata-se de um mecanismo de programa¸caõ incomum e muito inteligente. Você escreve boa parte do c´ odigo de forma genérica, sem se preocupar se foi criado um ponto, um c´ırculo ou uma elipse. Programa¸caõ Orientada a Objeto com C++


´ 19.4. METODOS VIRTUAIS PUROS

19.3.1

369

Senten¸cas para polimorfismo

• Todo objeto criado sabe a qual classe pertence e utiliza a tabela VMT da sua classe. • O mecanismo virtual existe para permitir que as opera¸co˜es sobre um objeto sejam realizadas sem o conhecimento do tipo do objeto que ser´ a criado. • O polimorfismo deixa o programa mais simples e genérico, pois seu desenvolvimento é simplificado. • Toda classe com métodos virtuais tem uma tabela VMT, e todo objeto de uma classe com métodos virtuais tem oculto um ponteiro para esta tabela (virtual pointer ). Como conseq¨ uência da implementa¸caõ da hereditariedade e do polimorfismo, quando um programa orientado a objeto é executado, as mensagens s˜ ao recebidas por objetos. Normalmente, o método para manipula¸caõ de uma mensagem é armazenado no alto de uma biblioteca de classes (é uma classe de Interface). O método é localizado dinamicamente, quando necess´ ario, e a liga¸caõ ocorre no u ´ ltimo momento poss´ıvel (utilizando a VMT).

19.4

M´ etodos virtuais puros

Métodos virtuais puros s˜ ao métodos que s˜ ao declarados como virtuais na classe-base e que n˜ ao s˜ ao implementados (n˜ ao s˜ ao definidos). Eles s˜ ao utilizados para criar uma classe de Interface. Veja no prot´ otipo que o método é igualado ao valor 0. Como o método s´ o foi declarado e n˜ ao definido, n˜ ao posso criar um objeto da classe-base abstrata porque ele poderia chamar um método que n˜ ao existe. Prot´ otipo: class Base { virtual Tipo MétodoA() =0; virtual Tipo MétodoB(parˆ ametros)=0; virtual Tipo MétodoC(parˆ ametros) const =0; }; Se a classe-derivada n˜ ao implementa o método virtual puro, ela também é uma classe abstrata, que n˜ ao pode criar objetos. Se você tiver uma classe com um ou mais métodos virtuais puros, ter´ a uma classe abstrata, uma classe que n˜ ao poder´ a criar objetos (mas pode ser usada para criar ponteiros). Uma classe de interface normalmente é uma classe-base ou superclasse, podendo ser utilizada como uma interface para acessar, por meio de um ponteiro, as classes derivadas. Uma classe de interface é uma classe que n˜ ao tem atributos, e todos os seus métodos s˜ ao p´ ublicos.

19.5

M´ etodos virtuais sobrecarregados

Métodos virtuais podem ser sobrecarregados, mas a redeclara¸caõ de um destes métodos na classe-derivada oculta todos os métodos com mesmo nome na classe-base. Veja o exemplo: class Base { virtual Area(); Programa¸caõ Orientada a Objeto com C++


370

19.6. EXEMPLO COMPLETO COM POLIMORFISMO }; class Derivada : public Base { virtual Area(Funcao* f); // Sobrecarga, oculta Area(). };

No exemplo anterior, se criarmos um objeto do tipo da classe-derivada, s´ o poderemos acessar o método virtual Area(Funcao* f);

// Sobrecarga

pois o mesmo ocultou o método Area() da classe-base. A idéia de ocultar os métodos da classe-base teve como motiva¸caõ a preocupa¸caõ em se evitar que heran¸cas com sobrecarga sejam realizadas acidentalmente, sobretudo em programas e bibliotecas grandes [Meyers, 2005]. Esse problema pode ser contornado de duas formas: usando a palavra-chave using ou redefinindo todos os métodos na classe-derivada e chamando os métodos da classe-base. Veja a seguir a solu¸caõ usando using. class Derivada : public Base { virtual Area(Funcao* f);// Sobrecarga using Base::Area; // Informa que esta usando m´ etodo da classe-base }; A segunda solu¸caõ consiste em redefinir os métodos na classe-derivada. class Derivada : public Base { virtual Area(Funcao* f); // Sobrecarga virtual Area() // Redefinida { Base::Area(); } }; Observe que a solu¸caõ usando using é mais simples.

19.6

Exemplo completo com polimorfismo

O diagrama UML da hierarquia de classes que ser´ a implementado é ilustrado na Figura 19.2. Note que a classe CAlunoFuncionario tem heran¸ca m´ ultipla. Programa¸caõ Orientada a Objeto com C++


19.6. EXEMPLO COMPLETO COM POLIMORFISMO

371

CPessoa +nome: string +matricula: string +Entrada(): void +Saida(): void

CFuncionario

CAluno

+indiceProdutividade: float +Entrada(): virtual +Saida(): virtual

+iaa: float +numeroAlunos: static int +universidade: static string +Entrada(): virtual +Saida(): virtual

CAlunoFuncionario +indicePobreza: double +Entrada(): virtual +Saida(): virtual

Figura 19.2: Hierarquia CPessoa, CAluno, CFuncionario, CAlunoFuncionario. Veja na listagem 19.2 a classe CPessoa. Listing 19.2: A classe CPessoa. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# ifndef CPessoa_h # define CPessoa_h # include < string >

// U t i l i z a r e i o b j e t o s string ’s

/* A classe C P e s s o a r e p r e s e n t a uma pessoa . Tem um nome , e m ´ etodos b´ asicos para e n t r a d a e sa´ ı da de dados . Tem alguns c o n s t r u t o r e s e um d e s t r u t o r. A m a t r i c u l a foi a c r e s c e n t a d a na etapa de p r o j e t o . */ class CPessoa { private : std :: string nome ; std :: string matricula ;

// Acesso p r i v a d o ( s o m e n t e nesta classe )

public : // Acesso p ´ ublico CPessoa () ; // C o n s t r u t o r CPessoa ( const CPessoa & obj ) ; // C o n s t r u t o r de c´ o pia // C o n s t r u t o r s o b r e c a r r e g a d o CPessoa ( std :: string _nome , std :: string _matricula ) ; virtual ~ CPessoa () ; // D e s t r u t o r virtual void Entrada () ; // E n t r a d a e sa´ ı da de dados virtual void Saida () const ; std :: string Nome () const { return nome ; }; std :: string Matricula () const { return matricula ;}; void Nome ( std :: string _nome ) { nome = _nome ; }; void Matricula ( std :: string _m ) { matricula = _m ; }; }; # endif

Listing 19.3: Implementa¸caõ da classe CPessoa. 1

# include < iostream >



372 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46


# include " CPessoa . h " using namespace std ; // C o n s t r u t o r d e f a u l t ( sem p a r ^ ametros) CPessoa :: CPessoa () : nome ( " " ) , matricula ( " " ) { cout << " Criou objeto CPessoa construtor default " << endl ; } // C o n s t r u t o r de c´ o pia CPessoa :: CPessoa ( const CPessoa & obj ) { nome = obj . nome ; matricula = obj . matricula ; cout << " Criou objeto CPessoa construtor de c´ o pia " << endl ; } CPessoa :: CPessoa ( string _nome , string _matricula ) : nome ( _nome ) , matricula ( _matricula ) { cout << " Criou objeto CPessoa construtor s o b r e c a r r e g a d o " << endl ; } // D e s t r u t o r CPessoa ::~ CPessoa () { cout << " destruiu objeto CPessoa " << endl ; } // E n t r a d a de dados void CPessoa :: Entrada () { cout << " Entre com o nome : " ; getline ( cin , nome ) ; cout << " Entre com a matricula : " ; getline ( cin , matricula ) ; } // Sa´ ı da de dados void CPessoa :: Saida () const { cout << " Nome : " << nome << " Matricula : " << matricula << endl ; }

Veja na listagem 19.4 a classe CAluno. Listing 19.4: A classe CAluno. 1 2 3 4 5 6 7 8 9 10 11 12 13

# ifndef CAluno_h # define CAluno_h # include < string > # include " CPessoa . h " /* A classe CAluno ´ e h e r d e i r a da classe C P e s s o a r e p r e s e n t a um aluno da u n i v e r s i d a d e . R e d e f i n e os m ´ e t o d o s E n t r a d a/ Saida e a d i c i o n a o a t r i b u t o iaa e os m ´ e t o d o s Iaa ( int ) , Iaa () . */ class CAluno : virtual public CPessoa { private : double iaa ; // Indice de a p r o v e i t a m e n t o static int n u m e r o A l u n o s ; // N´ u mero total de alunos



19.6. EXEMPLO COMPLETO COM POLIMORFISMO 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

373

// Nome da u n i v e r s i d a d e static const std :: string u n i v e r s i d a d e ; public : CAluno () ; CAluno ( const CAluno & obj ) ; CAluno ( std :: string _nome , std :: string _matricula , double _iaa = 0) ; virtual ~ CAluno () ; virtual void Entrada () ; virtual void Saida ( std :: ostream & os ) const ; double Iaa () const { return iaa ; } void Iaa ( double _iaa ) { iaa = _iaa ; } static int N u m e r o A l u n o s () { return n u m e r o A l u n o s ; }; static const std :: string U n i v e r s i d a d e () { return u n i v e r s i d a d e ; }; }; # endif

Listing 19.5: Implementa¸caõ da classe CAluno. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

# include < iostream > using namespace std ; # include " CAluno . h " // I n i c i a l i z a a t r i b u t o s e s t ´ aticos int CAluno :: n u m e r o A l u n o s = 0; const string CAluno :: u n i v e r s i d a d e = " U n i v e r s i d a d e Estadual do Norte Fluminense " ; CAluno :: CAluno () : iaa (0.0) { n u m e r o A l u n o s ++; cout << " Criou objeto CAluno ( " << n u m e r o A l u n o s << " ) construtor default " << endl ; } CAluno :: CAluno ( const CAluno & obj ) : CPessoa ( obj ) { iaa = obj . iaa ; n u m e r o A l u n o s ++; cout << " Criou objeto CAluno ( " << n u m e r o A l u n o s << " ) construtor de c´ o pia " << endl ; } CAluno :: CAluno ( string _nome , string _matricula , double _iaa ) : CPessoa ( _nome , _matricula ) , iaa ( _iaa ) { n u m e r o A l u n o s ++; cout << " Criou objeto CAluno ( " << n u m e r o A l u n o s << " ) construtor s o b r e c a r r e g a d o " << endl ; } CAluno ::~ CAluno () { cout << " Destruiu objeto CAluno : " << n u m e r o A l u n o s << endl ; numeroAlunos - -; } void CAluno :: Entrada () { CPessoa :: Entrada () ; // Chama M´ e todo da classe base // A d i c i o n a abaixo o que ´ e d i f e r e n t e nesta classe cout << " Entre com o iaa do aluno : " ; cin >> iaa ; cin . get () ;



374 45 46 47 48 49 50 51


} void CAluno :: Saida () const { CPessoa :: Saida () ; cout << " iaa : " << iaa << endl ; }

Veja na listagem 19.6 a classe CFuncionario. Listing 19.6: A classe CFuncionario. # ifndef C F u n c i o n a r i o _ h # define C F u n c i o n a r i o _ h # include < string > # include " CPessoa . h " /* A classe C F u n c i o n a r i o ´ e h e r d e i r a da classe CPessoa , e r e p r e s e n t a um f u n c i o n a r i o de uma u n i v e r s i d a d e . R e d e f i n e os m ´ e t o d o s E n t r a d a/ Saida e adiciona o indiceProdutividade e m´ e t o d o s para ler e setar o I n d i c e P r o d u t i v i d a d e ( int ) , I n d i c e P r o d u t i v i d a d e () */ class C F u n c i o n a r i o : virtual public CPessoa { protected : double i n d i c e P r o d u t i v i d a d e ; // I´ ndice de p r o d u t i v i d a d e public : C F u n c i o n a r i o () ; C F u n c i o n a r i o ( const C F u n c i o n a r i o & obj ) ; C F u n c i o n a r i o ( std :: string _nome , std :: string _matricula , double _ip = 0) ; virtual ~ C F u n c i o n a r i o () ; virtual void Entrada () ; virtual void Saida () const ; double I n d i c e P r o d u t i v i d a d e () const { return i n d i c e P r o d u t i v i d a d e ; } void I n d i c e P r o d u t i v i d a d e ( double _ip ) { i n d i c e P r o d u t i v i d a d e = _ip ; } }; # endif

Listing 19.7: Implementa¸caõ da classe CFuncionario. # include < iostream > using namespace std ; # include " C F u n c i o n a r i o . h " C F u n c i o n a r i o :: C F u n c i o n a r i o () : i n d i c e P r o d u t i v i d a d e (0.0) { cout << " Criou objeto C F u n c i o n a r i o construtor default " << endl ; } C F u n c i o n a r i o :: C F u n c i o n a r i o ( const C F u n c i o n a r i o & obj ) : CPessoa ( obj ) { i n d i c e P r o d u t i v i d a d e = obj . i n d i c e P r o d u t i v i d a d e ; cout << " Criou objeto C F u n c i o n a r i o construtor de c´ o pia " << endl ; } C F u n c i o n a r i o :: C F u n c i o n a r i o ( string _nome , string _matricula , double _ip ) : CPessoa ( _nome , _matricul a ) , i n d i c e P r o d u t i v i d a d e ( _ip ) { cout << " Criou objeto C F u n c i o n a r i o construtor s o b r e c a r r e g a d o " << endl ; } C F u n c i o n a r i o ::~ C F u n c i o n a r i o () {




375

cout << " Destruiu objeto C F u n c i o n a r i o : " << endl ; } void C F u n c i o n a r i o :: Entrada () { CPessoa :: Entrada () ; cout << " Entre com o i n d i c e P r o d u t i v i d a d e do funcionari o : " ; cin >> i n d i c e P r o d u t i v i d a d e ; cin . get () ; } void C F u n c i o n a r i o :: Saida () const { CPessoa :: Saida () ; cout << " i n d i c e P r o d u t i v i d a d e : " << i n d i c e P r o d u t i v i d a d e << endl ; }

Apresentaremos na listagem 19.8 a classe CAlunoFuncionario. Listing 19.8: A classe CAlunoFuncionario. # ifndef C A l u n o F u n c i o n a r i o _ h # define C A l u n o F u n c i o n a r i o _ h # include " CAluno . h " # include " C F u n c i o n a r i o . h " /* A classe C A l u n o F u n c i o n a r i o r e p r e s e n t a um f u n c i o n ´ a r i o que ´ e aluno . Tem um nome , uma matr´ ı cula , e m ´ etodos b´ a s i c o s para e n t r a d a e sa´ ı da de dados . Tem alguns c o n s t r u t o r e s e um d e s t r u t o r . A c r e s c e n t a indice de p o b r e z a */ class C A l u n o F u n c i o n a r i o : public CAluno , public C F u n c i o n a r i o { double i n d i c e P o b r e z a ; // Por d e f a u l t ´ e private public : C A l u n o F u n c i o n a r i o () ; virtual ~ C A l u n o F u n c i o n a r i o () ; virtual void Entrada () ; virtual void Saida ( std :: ostream & os ) const ; void S e t i n d i c e P o b r e z a ( double _ i n d i c e P o b r e z a ) { i n d i c e P o b r e z a = _ i n d i c e P o b r e z a ;}; double G e t i n d i c e P o b r e z a () const { return i n d i c e P o b r e z a ; }; }; # endif

Veja na listagem ?? a implementa¸caõ da classe CAlunoFuncionario. Listing 19.9: Implementa¸caõ da classe CAlunoFuncionario. # include < iostream > using namespace std ; # include " C A l u n o F u n c i o n a r i o . h " C A l u n o F u n c i o n a r i o :: C A l u n o F u n c i o n a r i o () { cout << " Criou objeto C A l u n o F u n c i o n a r i o construto r default " << endl ; } C A l u n o F u n c i o n a r i o ::~ C A l u n o F u n c i o n a r i o () { cout << " Destruiu objeto C A l u n o F u n c i o n a r i o " << endl ; } // A seguir c´ o digo o p c i o n a l /* void C A l u n o F u n c i o n a r i o :: E n t r a d a ()



376


{ CAluno :: E n t r a d a () ; T F u n c i o n a r i o :: E n t r a d a () ; cout << " Entre com o ´ ı ndice de p o b r e z a : "; cin >> i n d i c e P o b r e z a ; cin . get () ; } */ // S o l u ¸ c~ a o para n~ a o chamar nome e m a t r ´ ı c u l a 2 vezes . void C A l u n o F u n c i o n a r i o :: Entrada () { CAluno :: Entrada () ; // E n t r a d a de nome , matr´ ı cula , iaa // E n t r a d a do i n d i c e P r o d u t i v i d a d e cout << " Entre com o ı ´ n d i c e P r o d u t i v i d a d e do funcionar i o : " ; cin >> i n d i c e P r o d u t i v i d a d e ; cin . get () ; cout << " Entre com o ı ´ ndice de pobreza : " ; cin >> i n d i c e P o b r e z a ; cin . get () ; // E n t r a d a do i n d i c e P o b r e z a } // Sa´ ı da de dados void C A l u n o F u n c i o n a r i o :: Saida () const { CAluno :: Saida () ; // Se chamar T F u n c i o n a r i o :: Saida ( os ) ; vai r e p e t i r os dados na tela cout << " ı ´ n d i c e P r o d u t i v i d a d e : " << i n d i c e P r o d u t i v i d a d e << " ı ´ ndice pobreza = : " << i n d i c e P o b r e z a << endl ; }

Veja na listagem 19.10 a implementa¸caõ do programa que utiliza as classes anteriormente definidas. Observe o uso de instru¸co˜es #ifndef, para inclus˜ ao dos arquivos de cabe¸calho. Note ainda que utilizamos o conceito de polimorfismo. Listing 19.10: Testando a heran¸ca m´ ultipla. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# include < iostream > # include < fstream > # include < string > // I n c l u s ~ a o de todos os a r q u i v o s de c a b e ¸ c a l h o *. h # ifndef CPessoa_h # include " CPessoa . h " # endif # ifndef CAluno_h # include " CAluno . h " # endif # ifndef C F u n c i o n a r i o _ h # include " C F u n c i o n a r i o . h " # endif # ifndef C A l u n o F u n c i o n a r i o _ h # include " C A l u n o F u n c i o n a r i o . h " # endif using namespace std ; int main () { string linha = " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ; int resp = 0; do { cout << linha << " Selecao do tipo de objeto ( -1 para sair ) \ n \ a "



19.6. EXEMPLO COMPLETO COM POLIMORFISMO 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

377

<< " CPessoa . . . . . . . . . . . . . . . . . . . . 0 \ n " << " CAluno . . . . . . . . . . . . . . . . . . . . . 1 \ n " << " C F u n c i o n a r i o . . . . . . . . . . . . . . . 2 \ n " << " C A l u n o F u n c i o n a r i o . . . . . . . . . . 3 : \ n " << linha ; cin >> resp ; cin . get () ; // Cria p o n t e i r o para um objeto , pode ser uma pessoa , // um aluno , ou um f u n c i o n ´ ario // O p o n t e i r o sempre aponta para a classe - base C P e s s o a . CPessoa * pobj = NULL ; switch ( resp ) // E s t r u t u r a de c o n t r o l e { case 0: // Cria objeto C P e s s o a pobj = new CPessoa () ; break ; case 1: // Cria objeto CAluno pobj = new CAluno () ; break ; case 2: // Cria objeto C F u n c i o n a r i o pobj = new C F u n c i o n a r i o () ; break ; case 3: // Cria objeto C A l u n o F u n c i o n a r i o pobj = new C A l u n o F u n c i o n a r i o () ; break ; case -1: default : // Op¸ c~ ao default cout << " \ nSair . " << endl ; return (0) ; break ; } // Este bloco usa pobj sem saber se criou CPessoa , CAluno , C F u n c i o n a r i o if ( pobj != NULL ) { pobj - > Entrada () ; pobj - > Saida ( cout ) ; delete pobj ; pobj = NULL ; } } while ( resp != -1) ; return 0; } -------------------------------------------------------------Selecao do tipo de objeto ( -1 para sair ) CPessoa . . . . . . . . . . . . . . . . . . . . 0 CAluno . . . . . . . . . . . . . . . . . . . . . 1 CFuncionario ...............2 CAlunoFuncionario ..........3: -------------------------------------------------------------0 criou objeto CPessoa construtor default Entre com o nome : Sergio Henrique Almeida Entre com a matricula : 540 Nome : Sergio Henrique Almeida Matricula : 540 destruiu objeto CPessoa -------------------------------------------------------------Selecao do tipo de objeto ( -1 para sair ) CPessoa . . . . . . . . . . . . . . . . . . . . 0




378

CAluno . . . . . . . . . . . . . . . . . . . . . 1 CFuncionario ...............2 CAlunoFuncionario ..........3: -------------------------------------------------------------1 criou objeto CPessoa construto r default criou objeto CAluno (1) construtor default Entre com o nome : Viatchsla v a I . Priimenko Entre com a matricula : 68 Entre com o IAA do aluno : 10 Nome : Viatchsla va I . Priimenko Matricula : 68 iaa : 10 destruiu objeto CAluno :1 destruiu objeto CPessoa -------------------------------------------------------------Selecao do tipo de objeto ( -1 para sair ) CPessoa . . . . . . . . . . . . . . . . . . . . 0 CAluno . . . . . . . . . . . . . . . . . . . . . 1 CFuncionario ...............2 CAlunoFuncionario ..........3: -------------------------------------------------------------3 criou objeto CPessoa construto r default criou objeto CAluno (1) construtor default criou objeto C F u n c i o n a r i o construtor default criou objeto C A l u n o F u n c i o n a r i o construtor default Entre com o nome : Cintia Matsumura Entre com a matricula : 546 Entre com o IAA do aluno : 9 Entre com o i n d i c e P r o d u t i v i d a d e do funcionar io : 9 Entre com o indice de pobreza : .8 Nome : Cintia Matsumura Matricula : 546 iaa : 9 indiceProdutividade : 9 indice pobreza = : 0.8 destruiu objeto C A l u n o F u n c i o n a r i o destruiu objeto C F u n c i o n a r i o : destruiu objeto CAluno :1 destruiu objeto CPessoa -------------------------------------------------------------Selecao do tipo de objeto ( -1 para sair ) CPessoa . . . . . . . . . . . . . . . . . . . . 0 CAluno . . . . . . . . . . . . . . . . . . . . . 1 CFuncionario ...............2 CAlunoFuncionario ..........3: --------------------------------------------------------------1 Sair .

19.7


Vimos na Se¸caõ 3.7 que polimorfismo significa muitas formas. Neste cap´ıtulo aprendemos que C++ utiliza métodos virtuais para implementar o conceito de polimorfismo. Vimos que os métodos virtuais têm uma tabela – VMT – que contém, em tempo de execu¸caõ, o endere¸co dos métodos da classe. Note que para implementar o polimorfismo é necess´ ario uma hierarquia de classes com métodos virtuais, e a cria¸caõ dos objetos deve ser feita de forma dinâmica, isto é, usando um ponteiro para a classe-base e o operador new. Programa¸caõ Orientada a Objeto com C++


19.8. EXERCÍCIOS

379

Aprendemos que os métodos virtuais puros s˜ ao utilizados para implementar o conceito de classes abstratas e classes de interface. Finalmente, vimos um exemplo completo com uso de polimorfismo.

19.8

Exerc´ıcios

1. Por que um método static n˜ ao pode ser const? 2. Modifique as listagens da Se¸caõ 19.6 de forma que na entrada e sa´ıda de dados n˜ ao apare¸cam repeti¸co˜es. 3. Para as listagens da Se¸caõ 19.6, crie uma classe de interface (com métodos p´ ublicos e puros). 4. Observe que a modelagem da Figura 19.2 n˜ ao é perfeita, afinal, uma pessoa tem um nome, mas n˜ ao tem uma matr´ıcula. O atributo matr´ıcula foi movido para CPessoa na etapa de projeto. Da mesma forma, o atributo string universidade n˜ ao est´ a bem colocado. Como exerc´ıcio você deve melhorar essa hierarquia e implementar no c´ odigo as modifica¸co˜es que considerar pertinentes. 5. Monte o c´ odigo em C++ para o diagrama de classes a seguir (arquivos .h e .cpp) Polinomio1G +a1: double +a2: double +y: double +f(_x:double): double +Entrada(): void

Polinomio2G +a3: double +f(_x:double): double +Entrada(): void



380

19.8. EXERCÍCIOS



Cap´ıtulo 20

Friend Vimos na Se¸caõ 3.8 uma breve defini¸caõ do conceito de friend. Neste cap´ıtulo veremos como C++ implementa o conceito de amizade, a utiliza¸caõ de classes, métodos e fun¸co˜es friend, além de como utilizar o conceito de friend para obter maior encapsulamento das diversas classes. Iniciaremos com uma introdu¸caõ ao conceito de friend (Se¸caõ 20.1), o prot´ otipo para uso de friend (Se¸caõ 20.1), e, em seguida, veremos as classes (Se¸caõ 20.3) e os métodos friend (Se¸caõ 20.4), além das fun¸co˜es globais (Se¸caõ 20.5). Finalizamos o cap´ıtulo com algumas senten¸cas para friend (Se¸caõ 20.6).

20.1

Introdu¸ c˜ ao ao conceito de friend

Vimos na Se¸caõ 3.2 que o conceito de encapsulamento est´ a relacionado com o ocultamento das informa¸co˜es do objeto. Com o encapsulamento nosso c´ odigo fica melhor, mais seguro. Como você é um programador interessado em manter a qualidade de seu c´ odigo, ir´ a preocuparse com o encapsulamento. Os atributos e métodos de uma classe X ser˜ ao, sempre que poss´ıvel, private ou protected. Dessa forma, outros objetos s´ o poder˜ ao acessar o que for public. Isto é, se você tiver um objeto do tipo X com nome obj_x, s´ o poder´ a acessar os atributos e métodos definidos como p´ ublicos na classe X. Alguns objetos, porém, podem apresentar entre si um relacionamento mais próximo, como se fossem amigos. Por exemplo, um desconhecido n˜ ao tem acesso a sua casa, aos seus bens pessoais; um amigo, por sua vez, pode entrar em sua casa e fazer uso de alguns objetos pessoais. Ou seja, com friend podemos implementar associa¸co˜es mais ´ıntimas entre as classes. Vamos a um exemplo: se duas classes Y e X têm uma associa¸caõ do tipo Y acessa X, ent˜ ao os métodos a serem acessados por Y devem ser p´ ublicos em X. Neste caso, no entanto, os métodos p´ ublicos de X ficam p´ ublicos para qualquer um que queira usar um objeto do tipo X e n˜ ao apenas para Y (quebrando o encapsulamento de X). Podemos manter o encapsulamento de X, informando que a classe Y tem privilégios de acesso ` a classe X, o que é feito com friend. A programa¸caõ orientada a objeto fornece o conceito de friend para que os objetos que s˜ ao ”amigos” funcionem da mesma forma. Basta informarmos quem s˜ ao os amigos de determinada classe. Com friend podemos preservar o encapsulamento (usando private/protected) e ao mesmo tempo liberar o acesso aos membros da classe para classes/métodos/fun¸co˜es declaradas como amigas. 381

´ 20.2. PROTOTIPO PARA FRIEND

382

20.2

Prot´ otipo para friend

Veja a seguir o prot´ otipo para fun¸co˜es, métodos e classes amigas. Observe que é adicionada a palavra-chave friend, utilizada para dar a uma classe, atributo, método ou fun¸caõ a possibilidade de acesso a membros n˜ ao p´ ublicos da classe. Prot´ otipo: // Uma fun¸ca õ global retorno NomeFun¸ca õ(parˆ ametros); // Uma classe class X { retorno NomeMétodo(parˆ ametros); }; // Uma segunda classe class Y { // Declara que a classe X é amiga da classe Y (veja se¸ca õ 20.3) friend class X; // Declara que o método X::NomeMétodo é amigo da classe Y (veja se¸ca õ 20.4) friend retorno X::NomeMétodo(parˆ ametros); // Declara que a fun¸ca õ global NomeFun¸ca õ é amiga da classe Y (veja se¸ca õ 20.5) friend retorno NomeFun¸ca õ(parˆ ametros); }; Veja a seguir um conjunto de dicas para uso de friend. • A declara¸caõ friend s´ o é válida para a classe em que foi declarada, ou seja, n˜ ao vale para as classes-derivadas. • Observe que se uma classe X é amiga de Y, e a classe Y é amiga de Z, n˜ ao implica que X seja amiga de Z, ou seja, todas as amizades devem ser explicitamente definidas. • Por conven¸caõ o especificador friend é usualmente o primeiro. • A declara¸caõ friend apenas indica que a classe/método/fun¸caõ declarada como amiga é amiga. N˜ ao pode ser confundida como a declara¸caõ em si da classe/método/fun¸caõ. • Au ´ nica maneira de especificar o relacionamento friend m´ utuo entre duas classes é declarar toda a segunda classe como friend da primeira e vice-versa. • Um método declarado como friend em uma classe deixa claro que este faz parte de uma estrutura l´ ogica da classe, provavelmente uma associa¸cão. • A declara¸caõ de um método envolve três aspectos: 1. O método tem acesso aos membros internos. 2. O método est´ a no escopo da classe. 3. O método precisa de um objeto da classe (com exce¸caõ dos métodos est´ aticos). Observe que uma fun¸caõ ou um método friend tem apenas o primeiro aspecto. • Para deixar o layout do seu programa mais bem organizado e manter um determinado padr˜ ao, coloque todas as declara¸co˜es friend no fim da classe. Programa¸caõ Orientada a Objeto com C++


20.3. CLASSES FRIEND

20.3

383

Classes friend

Se uma classe X for amiga da classe Y, os métodos da classe X poder˜ ao acessar todos os atributos e métodos de um objeto da classe Y. No exemplo da listagem 20.1, o método MX() da classe X pode acessar os atributos do objeto obj_y (recebido como parˆ ametro), porque toda classe X é declarada como amiga da classe Y. Observe neste exemplo que toda classe Y é privada; desta forma os atributos e métodos de Y s´ o podem ser acessados pela classe X. Listing 20.1: Usando classes friend. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

# include < iostream > // S o m e n t e d e c l a r a a classe Y class Y ; // D e c l a r a ¸ c~ ao e defini¸ c~ a o da classe X class X { int x ; public : // M´ e todo da classe X que recebe como p a r ^ a m e t r o um objeto Y void MX ( Y & obj_y ) ; }; // D e c l a r a ¸ c~ ao e defini¸ c~ a o da classe Y class Y { private : int y ; // A classe X ´ e amiga , o m´ e todo MX () pode a c e s s a r os a t r i b u t o s de Y friend class X ; }; void X :: MX ( Y & obj_y ) { std :: cout << " Fazendo x = obj_y . y ; " << std :: endl ; // O b s e r v e o acesso ao a t r i b u t o y do objeto obj_y x = obj_y . y ; } int main () { std :: cout << " Criando objetos X obj_x ; Y obj_y ; " << std :: endl ; X obj_x ; Y obj_y ; // O objeto obj_x acessa o m´ e todo MX p a s s a n d o como p a r ^ a m e t r o o obj_y obj_x . MX ( obj_y ) ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ List_18_1 Criando objetos X obj_x ; Y obj_y ; Fazendo x = obj_y . y ;

20.4

M´ etodos friend

No exemplo da listagem 20.2, um método da classe Y é declarado como amigo da classe Z na linha: Programa¸caõ Orientada a Objeto com C++


˜ 20.5. FUNC ¸ OES GLOBAIS FRIEND

384 friend void Y::MY(Z& obj_z);

Como o método MY() é declarado como amigo da classe Z, pode acessar os atributos de um objeto do tipo Z. Observe que o atributo z, mesmo sendo privado, é acessado pelo método MY(). Listing 20.2: Usando métodos friend. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

# include < iostream > class Z ; // S o m e n t e d e c l a r a a classe Z class Y // D e c l a r a ¸ c~ ao e defini¸ c~ a o da classe Y { private : int y ; public : // M´ e todo da classe Y que recebe um objeto do tipo Z . void MY ( Z & objZ ) ; }; class Z { private : int z ; // O m´ e todo MY da classe Y ´ e amigo , pode a c e s s a r os a t r i b u t o s de Z friend void Y :: MY ( Z & objZ ) ; }; void Y :: MY ( Z & objZ ) { std :: cout << " Fazendo y = objZ . z ; " << std :: endl ; y = objZ . z ; } int main () { std :: cout << " Criando objetos Y objY ; Z objZ ; " << std :: endl ; Y objY ; Z objZ ; objY . MY ( objZ ) ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ List_18_2 Criando objetos Y obj_y ; Z obj_z ; Fazendo y = obj_z . z ;

20.5

Fun¸ c˜ oes globais friend

Uma fun¸caõ com escopo global é uma fun¸caõ que pode ser acessada a qualquer momento. Ela é declarada e definida fora de qualquer bloco, classe, estrutura ou união. Programas estruturados escritos em C costumam ter diversas fun¸co˜es globais (veja discuss˜ ao sobre escopo em C na Se¸caõ B.4). Veja na listagem 20.3 um exemplo de fun¸caõ global friend. A fun¸caõ FuncaoGlobalAmiga() recebe como parˆ ametro um ponteiro para um objeto do tipo X. Listing 20.3: Usando fun¸co˜es globais friend. 1




20.6. SENTENCAS ¸ PARA FRIEND 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

385

// D e c l a r a que existe a classe X class X ; // D e c l a r a uma fun¸ c~ a o global void F u n c a o G l o b a l A m i g a ( X * ptr_x ) ; // D e c l a r a a classe X class X { private : static const int x = 321; // D e c l a r a que a fun¸ c~ a o global ´ e amiga da classe X friend void F u n c a o G l o b a l A m i g a ( X * ptr_x ) ; }; // Define a fun¸ c~ a o global void F u n c a o G l o b a l A m i g a ( X * ptr_x ) { std :: cout << ptr_x - > x << std :: endl ; } int main () { X * ptr_x = new X ; F u n c a o G l o b a l A m i g a ( ptr_x ) ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ g ++ List -18 -3 - friend - f u n c a o G l o b a l . cpp [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out 321

Dica: evite o uso de fun¸co˜es globais em um programa em C++.

20.6

Senten¸cas para friend

• Por padr˜ ao da linguagem, métodos construtores, métodos destrutores e métodos virtuais n˜ ao podem ser friend. • Como visto no Cap´ıtulo 4 – Modelagem Orientada a Objeto e na Se¸caõ 6.4.7, uma classe de associa¸caõ é utilizada para representar conceitos que s´ o passam a existir com o relacionamento de duas ou mais classes. Para aumentar o encapsulamento do programa, uma classe de associa¸caõ pode ser toda privada, tendo, em seu interior, declara¸co˜es friend das classes que far˜ ao acesso. • Na medida do poss´ıvel, classes/métodos/fun¸co˜es friend n˜ ao devem modificar o estado do objeto. • Fun¸co˜es friend s˜ ao comumente utilizadas para implementar a sobrecarga de operador (veja Se¸caõ 21.4). • Observe que em uma hierarquia os métodos da classe-base s˜ ao herdados pela classeao s˜ ao herdaderivada, mas as fun¸co˜es/métodos declaradas como friend da classe-base n˜ das. • Fun¸co˜es/métodos friend n˜ ao podem ser virtuais. Programa¸caõ Orientada a Objeto com C++



386

• Uma fun¸caõ friend pode acessar atributos est´ aticos da classe em que foi declarada como amiga (veja exemplo na listagem 20.3). • S´ o use friend quando realmente necess´ ario. Em alguns casos o uso de friend viola conceitos de POO, devendo, por isso, ser evitados. • 2 Também podemos usar friend com fun¸co˜es e classes templates. Veremos templates no Cap´ıtulo 27 – Templates (ou Gabaritos). • 2 Como a fun¸caõ friend n˜ ao faz parte da classe, pois s´ o é amiga, ela n˜ ao recebe um ponteiro impl´ıcito this, ou seja, é preciso passar explicitamente o objeto a ser manipulado pela fun¸caõ.

20.7


Em nossos programas devemos usar, sempre que poss´ıvel, o conceito de encapsulamento; desta forma estaremos diminuindo o acoplamento e as interdependências do sistema. O sistema fica mais ”livre”. Como algumas classes e fun¸co˜es apresentam naturalmente um relacionamento mais ´ıntimo, como se fossem amigas, C++ apresenta o conceito de friend, que d´ a a uma determinada classe/método/fun¸caõ a possibilidade de acessar os membros ocultos (protegidos/privados) da classe declarada como amiga. Aprendemos, por meio dos exemplos apresentados, como implementar o conceito de friend em C++. No próximo cap´ıtulo veremos que fun¸co˜es friend s˜ ao comumente utilizadas para implementar a sobrecarga de operador (Se¸caõ 21.4).

20.8

Exerc´ıcios

1. Descreva com suas palavras o conceito de friend. 2. Dê exemplos de relacionamentos de amizade na vida real e em termos de programa¸caõ. 3. Qual a diferen¸ca prática do uso de friend com classes e métodos? 4. No exemplo da listagem 20.1, tente acessar diretamente o atributo obj_y. 5. Modifique as listagens 20.1 e 20.2, adicionando novos atributos, métodos e relacionamentos de amizades. 6. Encontre o erro da listagem 20.3. 7. Substitua a fun¸caõ global por um método membro na listagem 20.3.



Cap´ıtulo 21

Sobrecarga de Operador Neste cap´ıtulo veremos uma introdu¸caõ à sobrecarga de operador (Se¸caõ 21.1), a lista de operadores que podem ser sobrecarregados (Se¸caõ 21.2) e os prot´ otipos para implementar a sobrecarga de operador em C++ (Se¸caõ 21.3). Em seguida apresenta-se a sobrecarga de operador como fun¸caõ friend (Se¸caõ 21.4) e como método membro da classe (Se¸caõ 21.5). Veremos ainda um exemplo de classe com sobrecarga de operador e seu uso (Se¸caõ 21.6). No final do cap´ıtulo apresentam-se alguns prot´ otipos de sobrecarga de operador (Se¸caõ 21.7), como sobrecarregar new (Se¸caõ 21.8), como sobrecarregar new dentro de uma classe (Se¸caõ 21.8.1), e algumas senten¸cas (Se¸caõ 21.9).

21.1

Introdu¸ c˜ ao ` a sobrecarga de operador

Quando definimos uma classe, definimos um tipo do programador, adicionamos um conjunto de atributos e de métodos que fazem sentido para a classe. Se criarmos uma classe Polinomio, podemos criar uma fun¸caõ para somar dois polinômios. Veja o exemplo: Exemplo: // Cria objetos do tipo Polinomio Polinomio pol_a, pol_b, pol_c; // Soma os polinomios pol_a e pol_b e armazena o resultado em pol_c Somar ( pol_a, pol_b, &pol_c ); Embora seja funcional, a nota¸caõ mostrada é t´ıpica de um programa em C e Java. Seria interessante se pudéssemos realizar opera¸co˜es como soma (+), subtra¸caõ (-) e multiplica¸caõ (*) utilizando os operadores usuais. O operador + realizaria a soma de dois polinômios; o operador * realizaria a multiplica¸caõ dos polinômios e assim por diante. O c´ odigo ficaria mais parecido com a linguagem matemática. Veja o exemplo: Exemplo: pol_c = pol_a + pol_b; Assim, podemos definir sobrecarga de operador como a defini¸caõ das tarefas que determinado operador realiza sobre um tipo definido pelo programador. Note que com C++ podemos utilizar uma nota¸caõ muito mais clara e próxima da matemática. Apresenta-se a seguir a lista de operadores de C++ que podem ser sobrecarregados. 387

388

21.2. OPERADORES QUE PODEM SER SOBRECARREGADOS

21.2

Operadores que podem ser sobrecarregados

Antes de apresentarmos a forma utilizada para implementar a sobrecarga dos operadores, é preciso classificar os operadores. Veja na Tabela 21.1 quais os operadores podem ser un´ arios ou bin´ arios. S˜ ao un´ arios quando atuam sobre um u ´ nico objeto e binários quando atuam sobre dois objetos. Observe que alguns operadores n˜ ao podem ser sobrecarregados. No exemplo z = x + y;, o operador + é bin´ ario, opera sobre os objetos x e y. O operador = é bin´ ario pois armazena o resultado de "x+y" em z. No exemplo r++, o operador ++ é un´ ario, pois atua somente sobre o objeto r. Tabela 21.1: Operadores que podem ser sobrecarregados. Operadores bin´ arios

Operadores un´ arios ou bin´ arios Operadores un´ arios N˜ ao podemos sobrecarregar

+ ˜ /= < <= , &

! %= == -> *

* = ˆ= != [] +

/ < &= <= () -

++ .

-.*

˜ ::

! ?:

% > |= >= new[]

ˆ += << && delete[]

& -= >> || new

| *= > >= ->* delete

Nota: n˜ ao podemos alterar a regra de precedência e associatividade da linguagem (veja Tabela C.1). Isso significa que na seq¨ uência z = x + y;, primeiro ser´ a realizada a soma e depois a igualdade, e esta seq¨ uência n˜ ao poder´ a ser alterada.

21.3

Prot´ otipo para sobrecarga de operador

Veja a seguir o prot´ otipo para sobrecarga de operador como fun¸caõ friend e método membro da classe. Observe que a declara¸caõ e a defini¸caõ s˜ ao iguais às de um método/fun¸caõ, apenas substitu´ımos o nome do método/fun¸caõ pela palavra-chave operator. Em (1) temos a sobrecarga de operador un´ ario como fun¸caõ friend; observe que a fun¸caõ recebe apenas um parˆ ametro – o objeto obj1. Em (2) temos a sobrecarga de operador bin´ ario como fun¸caõ friend; observe que a fun¸caõ recebe dois parˆ ametros – os objetos obj1 e obj2. Como a fun¸caõ friend n˜ ao faz parte da classe, pois s´ o é amiga, ela n˜ ao recebe um ponteiro impl´ıcito this, ou seja, é preciso passar explicitamente o objeto a ser manipulado pela fun¸caõ. Veja detalhes na Se¸caõ 21.4. Em (3) declaramos a sobrecarga de operador un´ ario como método membro; observe que o método n˜ ao recebe nenhum parˆ ametro. Lembre-se de que um método de uma classe tem acesso a todos os atributos e aos outros métodos da classe. Em (4) declaramos a sobrecarga de operador binário como método membro; neste caso, o segundo objeto deve ser recebido como parˆ ametro. Veja detalhes na Se¸caõ 21.5. Prot´ otipo: class CNomeClasse { Tipo atributo; Programa¸caõ Orientada a Objeto com C++


˜ FRIEND 21.4. SOBRECARGA DE OPERADOR COMO FUNC ¸ AO

389

// (1) Sobrecarga de operador un´ ario como fun¸ca õ friend (veja se¸ca õ 21.4) friend CNomeClasse& operatorX (CNomeClasse& obj1); // (2) Sobrecarga de operador bin´ ario como fun¸ca õ friend (veja se¸ca õ 21.4) friend CNomeClasse& operatorX (CNomeClasse& obj1, CNomeClasse& obj2); // (3) Sobrecarga de operador un´ ario como método membro (veja se¸ca õ 21.5) CNomeClasse& operatorX(); // (4) Sobrecarga de operador bin´ ario como método membro (veja se¸ca õ 21.5) CNomeClasse& operatorX(CNomeClasse& obj2); }; // (1) Defini¸ca õ de sobrecarga de operador un´ ario como fun¸ca õ friend CNomeClasse& operatorX (CNomeClasse& obj1) {... return (CNomeClasse); } // (2) Defini¸ca õ de sobrecarga de operador bin´ ario como fun¸ca õ friend CNomeClasse& operatorX (CNomeClasse& obj1, CNomeClasse& obj2) {... return (CNomeClasse); } // (3) Defini¸ca õ de sobrecarga de operador un´ ario como método membro CNomeClasse& CNomeClasse::operatorX() {... return (CNomeClasse); } // (4) Defini¸ca õ de sobrecarga de operador bin´ ario como método membro CNomeClasse& CNomeClasse::operatorX(CNomeClasse& obj2) {... return (CNomeClasse); } Vamos abordar primeiro a sobrecarga como fun¸caõ friend.

21.4

Sobrecarga de operador como fun¸c˜ ao friend

Lembre-se que fun¸co˜es friend s˜ ao fun¸co˜es amigas da classe; n˜ ao fazem parte dela. A declara¸caõ friend fornece ` a fun¸caõ a possibilidade de acessar os atributos/métodos do objeto como se fizesse parte da classe (é uma maneira de fazer com que a fun¸caõ amiga tenha acesso a todos os atributos e métodos da classe. Veja Cap´ıtulo 20 – Friend). No exemplo a seguir a fun¸caõ TestaIgualdade() retorna verdadeiro (true) se p1==p2, isto é, se p1.x == p2.x e p1.y == p2.y. Exemplo: // Arquivo CPonto.h class CPonto { public: int x, y; Programa¸caõ Orientada a Objeto com C++


´ 21.5. SOBRECARGA DE OPERADOR COMO METODO MEMBRO DA CLASSE

390

friend bool TestaIgualdade (const CPonto& p1, const CPonto& p2); }; // Arquivo CPonto.cpp bool TestaIgualdade(const CPonto& p1, const CPonto& p2) { return (p1.x == p2.x) && (p1.y == p2.y); } Agora vamos montar nossa classe CPonto, substituindo o método TestaIgualdade(), pela sobrecarga do operator== . Note que os operadores definidos com a palavra-chave friend também têm acesso a todos os atributos e métodos da classe. Exemplo: // Arquivo CPonto.h // Declara¸ c~ ao da sobrecarga de operador bin´ ario como fun¸ c~ ao friend class CPonto { public: int x, y; friend bool operator== (const CPonto& p1, const CPonto& p2); }; // Arquivo CPonto.cpp // Implementa¸ c~ ao da sobrecarga de operadores bin´ arios como func~ ¸ ao friend bool operator==(const CPonto& p1, const CPonto& p2) { return (p1.x == p2.x) && (p1.y == p2.y); } Observe que a sobrecarga é declarada e definida da mesma forma que uma fun¸caõ comum. Au ´ nica diferen¸ca é que, em vez de chamar TestaIgualdade(), usamos o nome operator==. Observe que o operador == verifica se os atributos de p1 e p2 s˜ ao iguais. Veja exemplo completo nas listagens 21.1, 21.2 e 21.3.

21.5

Sobrecarga de operador como m´ etodo membro da classe

Outra forma de implementar a sobrecarga de operador é usar um método membro da classe. Sendo um método da classe, pode acessar diretamente os atributos do objeto. Observe que um operador un´ ario n˜ ao receber´ a nenhum parˆ ametro (protótipo (3)) e um operador binário receber´ a apenas um (prot´ otipo (4)). Veja no exemplo a seguir que o operador ++ incrementa os valores de x (x++) e de y (y++). O operador + cria um terceiro objeto, com nome p3, no qual armazena a soma de p1 e p2. Observe na linha p3->x = this->x + p2.x; que armazena em p3->x a soma de this->x com p2.x. Exemplo: // CPonto.h class CPonto { public: Programa¸caõ Orientada a Objeto com C++


´ 21.6. EXEMPLO PRATICO DE SOBRECARGA DE OPERADOR

391

int x,y; // Sobrecarga de operador un´ ario como m´ etodo membro CPonto& operator++(); // Sobrecarga de operador bin´ ario como m´ etodo membro CPonto& operator+ (const CPonto& p2); }; // CPonto.cpp CPonto& CPonto::operator++() { x++; y++; return *this; } CPonto& CPonto::operator+(const CPonto& p2) { CPonto *p3 = new CPonto; p3->x = this->x + p2.x; p3->y = this->y + p2.y; return *p3; }

21.6

Exemplo pr´ atico de sobrecarga de operador

Os exemplos apresentados a seguir mostram, na prática, como usar a sobrecarga de operador. Veremos nas listagens 21.1, e 21.2 novamente a classe CPonto, agora com vários operadores sobrecarregados. Observe na listagem 21.1 o uso de sobrecarga de operador. Note que temos um conjunto de métodos sobrecarregados como método membro e outro como fun¸caõ friend. A listagem inclui explica¸co˜es adicionais. Listing 21.1: A classe CPonto com sobrecarga de operador. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# ifndef CPonto_h # define CPonto_h # include < iostream > class CPonto { private : int x ; int y ; static int contador ; public : CPonto () : x (0) , y (0) { contador ++; } CPonto ( const int _x , const int _y ) : x ( _x ) , y ( _y ) { contador ++; } CPonto ( const CPonto & p ) { x = p.x; y = p.y; contador ++; } virtual ~ CPonto () { contador - -; } inline void Set ( const CPonto & p ) {




392 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

x = p.x; y = p.y; } inline void Set ( const int &x , const int & y ) { this - > x = x ; // Uso de this this - > y = y ; } int X ( int _x ) { x = _x ; } int X () const { return x ; } int Y ( int _y ) { y = _y ; } int Y () const { return y ; } virtual void Desenha () ; static int Contador () { return contador ; }; // D e c l a r a ¸ c~ a o da s o b r e c a r g a de o p e r a d o r e s u n ´ a r i o s como m´ e todo membro CPonto & operator ++( int ) ; // S o b r e c a r g a para ++ p CPonto & operator - -( int ) ; // S o b r e c a r g a para --p CPonto & operator ++() ; // S o b r e c a r g a para p ++ CPonto & operator - -() ; // S o b r e c a r g a para p - // D e c l a r a ¸ c~ a o da s o b r e c a r g a de o p e r a d o r e s b i n ´ a r i o s como m´ e todo membro CPonto & operator + ( const CPonto & p2 ) const ; CPonto & operator - ( const CPonto & p2 ) const ; CPonto & operator = ( const CPonto & p2 ) ; CPonto & operator += ( const CPonto & p2 ) ; CPonto & operator -= ( const CPonto & p2 ) ; // D e c l a r a ¸ c~ a o da s o b r e c a r g a de o p e r a d o r e s b i n ´ a r i o s como fun¸ c~ a o friend friend bool operator == ( const CPonto & p1 , const CPonto & p2 ) ; friend bool operator != ( const CPonto & p1 , const CPonto & p2 ) ; // S o b r e c a r g a do o p e r a d o r de i n s e r ¸ c~ a o << , uso cout << ponto ; friend std :: ostream & operator < <( std :: ostream & out , const CPonto & p ) ; // S o b r e c a r g a do o p e r a d o r de e x t r a ¸ c~ a o >> , uso cin >> ponto ; friend std :: istream & operator > >( std :: istream & in , CPonto & p ) ; }; # endif

Na listagem 21.2 apresentamos a defini¸caõ da sobrecarga dos operadores para CPonto. O uso de this é descrito na Se¸caõ 15.4. Observe que a implementa¸caõ da sobrecarga dos operadores operator++(int) e operator++() s˜ ao iguais; o mesmo ocorre com operator--(int) e operator--(). Os operadores + e - criam um objeto adicional CPonto* p3;, que é usado para armazenar o resultado da opera¸caõ. Note no in´ıcio do operador= o uso da linha if( this == &p2) return *this; a qual impede que um objeto seja igualado a si mesmo. Finalmente, observe que os operadores (operator< < e operator> >) ser˜ ao sempre sobrecarregados como métodos friend. Listing 21.2: Implementa¸caõ da classe CPonto com sobrecarga de operador. 1 2 3 4 5 6 7 8 9 10

# include < iostream > # include " CPonto . h " int CPonto :: contador = 0; // M´ e todo v i r t u a l void CPonto :: Desenha () { std :: cout << " \ nCPonto : Coordenada x = " << x << " \ nCPonto : Coordenada y = " << y << std :: endl ; }



´ 21.6. EXEMPLO PRATICO DE SOBRECARGA DE OPERADOR 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

393

// D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r ++. S i m p l e s m e n t e i n c r e m e n t a x e y CPonto & CPonto :: operator ++( int ) { this - > x ++; this - > y ++; return * this ; } CPonto & CPonto :: operator ++() { this - > x ++; this - > y ++; return * this ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r - -. S i m p l e s m e n t e d e c r e m e n t a x e y CPonto & CPonto :: operator - -( int ) { this - >x - -; this - >y - -; return * this ; } CPonto & CPonto :: operator - -() { this - >x - -; this - >y - -; return * this ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r b i n ´ ario + CPonto & CPonto :: operator +( const CPonto & p2 ) const { CPonto * p3 = new CPonto ; p3 - > x = this - > x + p2 . x ; p3 - > y = this - > y + p2 . y ; return * p3 ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r b i n ´ ario CPonto & CPonto :: operator -( const CPonto & p2 ) const { CPonto * p3 = new CPonto ; p3 - > x = this - > x - p2 . x ; p3 - > y = this - > y - p2 . y ; return * p3 ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r = CPonto & CPonto :: operator =( const CPonto & p2 ) { if ( this == & p2 ) return * this ; // opcional , evita auto c´ o pia this - > x = p2 . x ; this - > y = p2 . y ; return * this ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r += CPonto & CPonto :: operator +=( const CPonto & p2 ) { this - > x += p2 . x ;



394 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110


this - > y += p2 . y ; return * this ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r -= CPonto & CPonto :: operator -=( const CPonto & p2 ) { this - > x -= p2 . x ; this - > y -= p2 . y ; return * this ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r == , como fun¸ c~ a o friend bool operator ==( const CPonto & p1 , const CPonto & p2 ) { return ( p1 . x == p2 . x ) && ( p1 . y == p2 . y ) ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r != , como fun¸ c~ a o friend bool operator !=( const CPonto & p1 , const CPonto & p2 ) { return !( p1 == p2 ) ; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r de i n s e r ¸ c~ a o <<, como fun¸ c~ a o friend std :: ostream & operator < <( std :: ostream & out , const CPonto & p ) { out << " ( " <
>, como fun¸ c~ a o friend std :: istream & operator > >( std :: istream & in , CPonto & p ) { in >> p . x ; in >> p . y ; return in ; }

Na listagem 21.3 apresentamos o teste de CPonto com sobrecarga. Para entender melhor o funcionamento do programa, compare cada linha com cout com a sa´ıda gerada. Listing 21.3: Usando a sobrecarga de operador. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# include < iostream > # include " CPonto . h " using namespace std ; // E x e m p l o de c r i a ¸ c~ a o e uso do objeto CPonto com s o b r e c a r g a int main () { int x ; int y ; // Cria o b j e t o s do tipo CPonto com nomes p1 , p2 , p3 CPonto p1 , p2 , p3 ; // Usando o p e r a d o r >> cout << " Entre com os valores de p1 [ x enter y enter ]: " ; cin >> p1 ; cin . get () ; // Usando o p e r a d o r << cout <<" --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ;



´ 21.6. EXEMPLO PRATICO DE SOBRECARGA DE OPERADOR 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

395

// Usando o p e r a d o r = p2 = p1 ; cout << " Ap´ o s p2 = p1 " << endl ; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; // Usando o p e r a d o r == cout << " Testando p1 == p2 " << endl ; if ( p1 == p2 ) cout << " p1 == p2 " << endl ; else cout << " p1 != p2 " << endl ; // Usando o p e r a d o r ++ p2 ++; cout << " Ap´ o s p2 ++ " << endl ; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; // Usando o p e r a d o r = cout << " Fazendo p3 = p2 ++ " << endl ; p3 = p2 ++; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; // Usando o p e r a d o r = cout << " Fazendo p3 = ++ p2 " << endl ; p3 = ++ p2 ; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; // Usando o p e r a d o r != cout << " Testando p2 == p3 " << endl ; if ( p2 != p3 ) cout << " p2 != p3 " << endl ; else cout << " p2 == p3 " << endl ; // Usando o p e r a d o r e s + e = p3 = p1 + p2 ; cout << " Ap´ o s p3 = p1 + p2 " << endl ; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; // Usando o p e r a d o r e s p - - e --p p3 - -; -- p2 ; p1 = p2 - p3 ; cout << " Ap´ os p3 - -; -- p2 ; p1 = p2 - p3 ; " << endl ; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; // Usando o p e r a d o r e s p += e p -= p3 += p2 ; p1 -= p2 ; cout << " Ap´ os p3 += p2 ; p1 -= p2 ; " << endl ; cout << " --- p1 - - > " << p1 << " --- p2 - - > " << p2 << " --- p3 - - > " << p3 << endl ; return 0; } Entre com os valores de p1 [ x enter y enter ]:1 2 --- p1 - - >(1 , 2) --- p2 - - >(0 , 0) --- p3 - - >(0 , 0) Ap´ o s p2 = p1 --- p1 - - >(1 , 2) --- p2 - - >(1 , 2) --- p3 - - >(0 , 0) Testando p1 == p2 p1 == p2 Ap´ o s p2 ++ --- p1 - - >(1 , 2) --- p2 - - >(2 , 3) --- p3 - - >(0 , 0)



396

21.7. COMO SOBRECARREGAR ++ E --

Fazendo p3 = p2 ++ --- p1 - - >(1 , 2) --- p2 - - >(3 , 4) --- p3 - - >(3 , 4) Fazendo p3 = ++ p2 --- p1 - - >(1 , 2) --- p2 - - >(4 , 5) --- p3 - - >(4 , 5) Testando p2 == p3 p2 == p3 Ap´ o s p3 = p1 + p2 --- p1 - - >(1 , 2) --- p2 - - >(4 , 5) --- p3 - - >(5 , 7) Ap´ os p3 - -; -- p2 ; p1 = p2 - p3 ; --- p1 - - >( -1 , -2) --- p2 - - >(3 , 4) --- p3 - - >(4 , 6) Ap´ os p3 += p2 ; p1 -= p2 ; --- p1 - - >( -4 , -6) --- p2 - - >(3 , 4) --- p3 - - >(7 , 10)

21.7

Como sobrecarregar ++ e --

Veja a seguir o prot´ otipo para sobrecarga dos operadores ++ e --. Observe que, para sobrecarga do operator++ (pré-fixado, como em ++obj), n˜ ao passamos nenhum parˆ ametro, mas, para sobrecarrega do operator++ (p´ os-fixado, como em obj++), passamos como parˆ ametro um int. Note que o parˆ ametro int n˜ ao é utilizado; ele é necess´ ario apenas para diferenciar obj++ de ++obj. Prot´ otipo: Tipo operator++(); Operador para Tipo operator- -(); Operador para Tipo operator++(int); Operador para Tipo operator- -(int); Operador para

21.8

++obj; Incremento Pré-fixado. - -obj; Decremento Pré-fixado. obj++; Incremento P´ os-fixado. obj- -; Decremento P´ os-fixado.

Como sobrecarregar new2

O operador new pode ser sobrecarregado de três formas diferentes. Veja a seguir os prot´ otipos para sobrecarga de new. Observe que este est´ a no escopo global. Prot´ otipo: void* ::operator new(std::size t size) throw (std::bad alloc); // (1) void* ::operator new(std::size t size, const std::nothrow t &) throw(); // (2) void* ::operator new(std::size t size, void* ptr) throw (); // (3) delete ptr->˜T(); A sobrecarga-padr˜ ao de new é dada em (1). Para usar new padr˜ ao fa¸ca: new T; Outra sobrecarga para new é new(nothrow) , uma vers˜ ao de new que n˜ ao lan¸ca exce¸co˜es (item (2)). Para usar new(nothrow) fa¸ca: new (std::nothrow) T; . O item (3) ilustra o uso de new in place. Com ele, o novo objeto vai ser armazenado em um endere¸co de memória existente, ou seja, new in place n˜ ao pede memória para o sistema operacional, pois usa a mem´ oria do objeto previamente alocado (existente). Note que o sizeof() do novo objeto deve ser menor ou igual ao anterior. Para usar new in place fa¸ca: new (ptr) T; . Note que, quando usamos new in place, devemos chamar o destrutor do objeto criado explicitamente. Programa¸caõ Orientada a Objeto com C++


21.8. COMO SOBRECARREGAR NEW2

397

Dica: evite usar new(nothrow), pois ele elimina o lan¸camento de exce¸co˜es, e, como o uso de exce¸co˜es é um padr˜ ao da linguagem, os usuários da sua biblioteca/programa esperam seu uso. A dica é: se for realmente necess´ ario usar new(nothrow), seu uso deve ser muito bem documentado.

21.8.1

Como sobrecarregar new dentro de uma classe2

O exemplo da listagem 21.4 mostra a declara¸caõ e o uso de sobrecarga de new para uma classe do usuário. Observe que sobrecarregamos todas as três formas de new. Em cada sobrecarga enviamos uma mensagem para tela e, em seguida, chamamos o operador global equivalente de new. Note que na chamada a new o primeiro parˆ ametro std::size_t n é passado implicitamente. Listing 21.4: Sobrecarregando new em uma classe. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

# include < iostream > using namespace std ; class CNome { char ch ; public : // S o b r e c a r g a para new Padr~ ao static void * operator new ( std :: size_t n ) throw () { cout << " Usando new padr~ a o da classe " << endl ; return :: operator new ( n ) ; } // S o b r e c a r g a para new n o t h r o w static void * operator new ( std :: size_t n , const std :: nothrow_t & r ) throw () { cout << " Usando new nothrow da classe " << endl ; return :: operator new (n , r ) ; } // S o b r e c a r g a para new in place static void * operator new ( std :: size_t n , void * ptr ) throw () { cout << " Usando new in place da classe " << endl ; return :: operator new ( n , ptr ) ; } CNome () { cout << " Construiu o objeto CNome . " << endl ; ~ CNome () { cout << " Destruiu o objeto CNome . " << endl ;

} }

}; class CAux { public : int x ; CAux () { cout << " Construtor classe auxiliar \ n " ; } ~ CAux () { cout << " Destrutor classe auxiliar \ n " ; } }; int main () { // Usando new padr~ ao CNome * prt_padrao = new CNome ; delete prt_padrao ;



398 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

21.9. SENTENCAS ¸ PARA SOBRECARGA DE OPERADOR

// Usando new n o t h r o w CNome * prt_nothro w = new ( std :: nothrow ) CNome ; delete prt_nothro w ; // Usando new in place // Cria objeto que tem m e m ´ o r i a s u f i c i e n t e para caber CNome CAux * ptr_inpla c e = new CAux ; // Cria objeto CNome usando new in place e a r m a z e n a em p t r _ i n p l a c e new ( static_cast < void * >( ptr_inpla ce ) ) CNome ; // Chama e x p l i c i t a m e n t e o d e s t r u t o r do objeto criado , p r e c i s a do cast ( reinterpret_ ca s t < CNome * >( ptr_inplac e ) ) - >~ CNome () ; // Chama o d e s t r u t o r do objeto o r i g i n a l delete ptr_inplac e ; return 0; } Usando new padr~ a o da classe Construiu o objeto CNome . Destruiu o objeto CNome . Usando new nothrow da classe Construiu o objeto CNome . Destruiu o objeto CNome . Construto r classe auxiliar Usando new in place da classe Construiu o objeto CNome . Destruiu o objeto CNome . Destrutor classe auxiliar

Dica importante: se sobrecarregar new em uma classe, implemente todas as três formas de sobrecarga para que o usu´ ario da sua biblioteca/programa n˜ ao tenha surpresas desagrad´ aveis. Isto é necess´ ario, pois se você sobrecarregar apenas new, e desconsiderar new(nothrow), um usu´ ario pode usar as diferentes formas de new no mesmo programa, e n˜ ao ir´ a compreender o porquê do funcionamento diferente. Novamente, a boa documenta¸caõ do sistema é importante.

21.9

Senten¸cas para sobrecarga de operador

• Você já deve ter percebido que muitos operadores da linguagem C++ s˜ ao sobrecarregados para os tipos internos. Por exemplo, o operador * é utilizado para multiplica¸caõ, declara¸caõ de ponteiros ou para obter o conte´ udo de ponteiros. • Tente utilizar sempre sobrecarga como método membro. A sobrecarga como fun¸caõ friend cria uma fun¸caõ global, que é desaconselh´ avel em um programa orientado a objeto. • Criar uma sobrecarga para += n˜ ao significa que você sobrecarregou + e =. • Por padr˜ ao, somente sobrecarregue new e delete como métodos est´ aticos. • Operadores de atribui¸caõ (=, +=,-=, ..) devem retornar uma referência ao objeto, pois podemos ter algo como obj1 = obj2 = obj3;. Exemplo: T& operator=(const T& obj) Programa¸caõ Orientada a Objeto com C++


21.9. SENTENCAS ¸ PARA SOBRECARGA DE OPERADOR

399

{ ... return *this; } • Por padr˜ ao, quando criar uma classe, sempre implemente o construtor de c´ opia e o operador de atribui¸caõ (operator=()). Lembre-se de que o operator=() deve evitar a autoc´ opia. Exemplo: T& T::operator=(const T& src) { if(this == &src) // Evita autoc´ opia return *this; ...copiar atributos... return *this; // Retorna refer^ encia } • A utiliza¸caõ do operador de atribui¸caõ (a = b) e do construtor de c´ opia por inicializa¸caõ (int a = b;) s˜ ao duas opera¸co˜es diferentes. Para evitar surpresas, crie você mesmo os operadores de c´ opia e de atribui¸caõ sempre que existirem atributos dinâmicos. Exemplo: class A { A(); // Construtor A(const A& ); // Construtor de c´ opia por inicializa¸ c~ ao A& operator=(const A& );// Operador de atribui¸ c~ ao }; • Os operadores de atribui¸caõ =, apontador para membro ->, subscrito [] e parênteses () s´ o podem ser sobrecarregados como métodos membro da classe (n˜ ao podem ser friend). • Quando for implementar a sobrecarga de operador esteja atento a efeitos como: Exemplo: obj1 = obj2 = obj3; // Encadeamentos string1 = string2 = "texto"; // Tipos diferentes complex_c = complex_a + double_x; // Sobrecarga m´ ultipla complex_d = double_y + complex_a; • Observe que os operadores < < e > >, quando aplicados a streams, sempre ser˜ ao sobrecarregados como fun¸caõ friend. • Para reduzir o n´ umero de sobrecargas, utilize métodos de convers˜ ao (veremos as convers˜ oes no Cap´ıtulo 25 – Convers˜ oes). • Veja a seguir outros prot´ otipos de sobrecarga. Prot´ otipo: Tipo* operator & (); Operador endere¸co de. Programa¸caõ Orientada a Objeto com C++



400 Tipo operator & (Tipo); Operador & bin´ ario. Tipo* operator->(); Operador de acesso. Tipo operator-(); Operador - , un´ ario. Tipo operator-(Tipo); Operador -, bin´ ario. Tipo& operator[](const Tipo &); Operador subscrito. Tipo& operator()(Tipo&); Operador chamada de fun¸ca õ.

• 2 Quando sobrecarregar < <, n˜ ao envie a sa´ıda diretamente para cout; envie-a para a stream, pois se pode ter algo como: Exemplo: cout < < "teste " < < objeto < < " "; • 2 Segundo Stroustrup [Bjarne, 1999] ”devido a um acidente histórico, os operadores = (atribui¸caõ), & (endere¸co) e seq¨ uenciamento () têm significados predefinidos quando aplicados a objetos de classes”. Você pode impedir o acesso a estes (e qualquer outro operador), declarando-os como private. • 2 Operadores n˜ ao podem ser definidos para receber exclusivamente ponteiros, exceto (=, &). • 2 O primeiro argumento de um operador sobrecarregado deve ser um lvalue. • 2 A sobrecarga como método membro n˜ ao é poss´ıvel com métodos est´ aticos (static), porque estes n˜ ao recebem implicitamente o ponteiro this. • 2 Uma sobrecarga é uma chamada de fun¸caõ; assim, os parˆ ametros podem definir o namespace a ser utilizado. • 2 Para que uma sobrecarga se torne mais r´ apida, declare-a como inline.

21.10


C++ é uma linguagem de programa¸caõ sensacional! Com ela, você pode sobrecarregar os operadores (+, -, *, /, = etc.) de forma que o exemplo do polinômio possa ser utilizado, ou seja, com C++ podemos utilizar uma nota¸caõ muito mais clara e pr´ oxima da matemática. Afinal de contas, o c´ odigo pol_c = pol_a + pol_b; é muito mais claro que Somar ( pol_a, pol_b, &pol_c ); Programa¸caõ Orientada a Objeto com C++


21.11. EXERCÍCIOS

401

Observe que C++ e a programa¸caõ orientada a objeto aproximam muito os conceitos computacionais dos conceitos f´ısicos e matemáticos, o que facilita o entendimento e o desenvolvimento de programas para as ´ areas de exatas e engenharia. Vimos que temos operadores un´ arios e binários, e que nem todos os operadores podem ser sobrecarregados. Aprendemos que podemos implementar a sobrecarga de operador utilizando métodos membro da classe ou fun¸co˜es friend. Apresentamos um exemplo – a classe . No final do cap´ıtulo vimos as diferentes formas de sobrecarga para new.

21.11

Exerc´ıcios

1. Diga com suas palavras as vantagens do uso de sobrecarga de operador. Destaque aspectos relacionados ` as ´ areas cient´ıficas como matemática, estat´ıstica e métodos numéricos. 2. Implemente exemplo com sobrecarga para operador + como operador un´ ario e binário. 3. Documente a classe CPonto das listagens 21.1 e 21.2. 4. Implemente uma classe CPolinomio com sobrecarga para os operadores +, -, =, ==. Use fun¸co˜es friend. 5. Implemente uma classe CMatriz com sobrecarga para os operadores +, -, *, / e []. Use métodos membro. 6. Explique o c´ odigo que segue (consulte a Se¸caõ G.3 – Enumera¸co˜es). Em seguida, implemente o c´ odigo para o operator- -. Os estados de um processo s˜ ao discutidos na Se¸caõ ?? e apresentados na Figura ??. Exemplo: enum EEstado {idle, ready, standby, running, blocked, suspended, zoombied, stopped}; EEstado& operator++(EEstado& e) { if ( e != stopped) e++; else e = idle; }



402


21.11. EXERCÍCIOS


Cap´ıtulo 22

Entrada e Sa´ıda Veremos neste cap´ıtulo a hierarquia de classes fornecidas pelo C++ para entrada e sa´ıda de dados, bem como definir a localidade a ser utilizada e formatar a sa´ıda e a entrada de dados. Iniciamos com uma introdu¸caõ ` a entrada e sa´ıda de dados (Se¸caõ 22.1). Em seguida, apresentamos a biblioteca-padr˜ ao para entrada e sa´ıda de dados (Se¸caõ 22.2): a classe ios_base (Se¸caõ 22.3), a classe (Se¸caõ 22.4), a classe (Se¸caõ 22.5), a classe (Se¸caõ 22.6), a classe (Se¸caõ 22.7) e a classe (Se¸caõ 22.8). Veremos ainda conceitos avan¸cados (Se¸caõ 22.9) como a classe locale (Se¸caõ 22.9.2) e o uso de facets (Se¸caõ 22.9.3). Por fim, veremos algumas senten¸cas para stream (Se¸caõ 22.10). Nota: um guia de referência ` as classes e aos métodos de entrada e sa´ıda est´ a dispon´ıvel em http://www.cplusplus.com/reference/.

22.1

Introdu¸ c˜ ao ` a entrada e sa´ıda de dados com C++

Nos cap´ıtulos anteriores e nos exemplos apresentados, aprendemos a utilizar os objetos cin e cout para entrada e sa´ıda de dados. Exemplo: using namespace std; int x; // Cria objeto do tipo int com nome x // Enviar para tela o conjunto de caracteres cout < < "Entre com o valor de x:"; cin > > x; // Pega o n´ umero digitado e armazena em x cin.get(); // Pega o enter // Enviar para tela o valor de x cout < < "Valor de x= " < < x < < endl; Neste exemplo, usamos os objetos cout e cin, que s˜ ao streams. Uma stream encapsula o conceito de fluxo de caracteres. De maneira geral, um objeto A do tipo stream insere (< <) ou extrai (> >) uma seq¨ uência de caracteres em um objeto B. Normalmente as streams est˜ ao associadas a dispositivos f´ısicos. O objeto cout, por exemplo, já vem previamente conectado com o dispositivo ’monitor’, e o objeto cin já vem previamente conectado com o dispositivo ’teclado’. Diversos dispositivos do seu computador funcionam utilizando streams. Veja os exemplos: 403

22.2. BIBLIOTECA DE ENTRADA E SAÍDA

404

• O teclado de seu computador tem um buffer onde s˜ ao armazenados os caracteres digitados. Esses caracteres s˜ ao extra´ıdos do buffer do teclado pelo objeto cin. • As sa´ıdas auxiliares (com1, com2, com3, com4) utilizam e funcionam com streams de caracteres. • O modem, as impressoras seriais, entre outros dispositivos, também utilizam e funcionam com streams de caracteres. • Programas podem comunicar-se utilizando streams. No Cap´ıtulo ?? – Introdu¸caõ ao Processamento Paralelo com M´ ultiplos Processos, utilizaremos streams para trocar dados entre processos, isto é, entre dois ou mais programas. Pois bem, este cap´ıtulo apresenta uma hierarquia de classes oferecidas pela biblioteca-padr˜ ao de C++ para manipula¸caõ de streams (entrada e sa´ıda de dados).

22.1.1

Streams buferizadas

Vimos que uma stream tem um buffer de memória utilizado para armazenar caracteres (Figura 8.2). Quando o buffer enche, os caracteres s˜ ao enviados para o dispositivo de destino. A linha cout < < "Entre com o valor de x: "; insere os caracteres "Entre com o valor de x: " no buffer de cout (os caracteres seguem o fluxo definido pelas setas < <). Observe que os caracteres ainda n˜ ao foram enviados para a tela. Quando você usa cin > > x;, o objeto cin envia para o objeto cout um comando flush(), o qual descarrega o buffer de cout, enviando todos os caracteres para o dispositivo de sa´ıda, no caso o monitor. Em resumo, o buffer de cout armazena temporariamente os caracteres enviados para a tela com cout< <. Quando o objeto cout recebe um comando flush(), ou quando o buffer enche, todo conte´ udo do buffer é enviado para a tela, e o buffer é esvaziado. Note que a vantagem do uso de um buffer é que as opera¸co˜es de sa´ıda s˜ ao executadas mais rapidamente.

22.2

Biblioteca de entrada e sa´ıda

A Figura 22.1 ilustra a hierarquia de classes para entrada e sa´ıda de dados com C++. De modo geral, um objeto dessa hierarquia pode armazenar, receber e fornecer caracteres. Um objeto da hierarquia de entrada e sa´ıda é uma stream, a qual contém um buffer onde ficam armazenados os caracteres e um conjunto de atributos utilizados na formata¸caõ desses caracteres. Note que a grande vantagem desta biblioteca é sua facilidade de uso. Por exemplo: o envio de dados para tela e para dispositivos externos (como disco, sa´ıda auxiliar, outros programas) funciona exatamente da mesma forma. Outra grande vantagem é sua portabilidade, isto é, o programa vai funcionar em praticamente todas as plataformas de interesse. Outro exemplo é o uso da classe , utilizada para definir a localidade (pais de interesse). Com locale podemos definir que o programa funciona usando português do Brasil ou o tradicional padr˜ ao de C. A classe ios_base contém um conjunto de métodos b´ asicos que s˜ ao herdados pelas demais classes da hierarquia. Essa classe tem o método setf() e um conjunto de atributos (status, flags e informa¸co˜es de formata¸caõ) que podem ser utilizados para defini¸caõ do formato de Programa¸caõ Orientada a Objeto com C++


22.3. A CLASSE IOS_BASE

405

entrada/sa´ıda de dados. Observe que a classe ios_base é independe do tipo de caractere (n˜ ao é uma classe template). A classe é herdeira de ios_base. Os métodos good(), bad(), fail() fornecem o estado da stream. Observe que depende do tipo de locale selecionado. A classe é utilizada para entrada de dados. C++ fornece o objeto cin do tipo para leitura de dados do teclado. A classe é utilizada para sa´ıda de dados. C++ fornece o objeto cout do tipo , o qual é utilizado para enviar caracteres para a tela. A classe pode ser utilizada para entrada e sa´ıda de dados. A classe contém um conjunto de manipuladores que podem ser utilizados para formata¸caõ da sa´ıda de dados. Como já visto as classes derivadas de têm objetivos predefinidos. A classe é utilizada nos casos em que a formata¸caõ n˜ ao precisa ser previamente definida. A classe é uma mistura da classe com a classe , funcionando ora como uma , ora como uma . Em alguns casos, desejamos enviar e receber dados para um dispositivo externo, como um arquivo de disco; nestes casos, utilizamos a classe e as classes e . A classe é apresentada no Cap´ıtulo 24 – Classe . A hierarquia de classes ilustrada na Figura 22.1 foi desenvolvida utilizando o conceito de templates (gabaritos). Isto significa que esta foi implementada para tipos genéricos de caracteres. Na prática, as classes s˜ ao constru´ıdas para dois tipos de caracteres: o char, já utilizado no C, e o wchar_t. O char suporta 256 caracteres e o wchar_t, cerca de 16.000 caracteres. O wchar_t foi desenvolvido para dar suporte a diversas linguagens (inglês, português etc.). Veremos os templates no Cap´ıtulo 27 – Templates (ou Gabaritos). Vamos iniciar a descri¸caõ da biblioteca de entrada e sa´ıda de dados, descrevendo a classe ios_base. Nota: veremos o acesso a arquivos de disco no Cap´ıtulo 23 – Entrada e Sa´ıda com Arquivos de Disco.

22.3

A classe ios_base

A classe ios_base contém atributos com informa¸co˜es de formata¸caõ da stream. Observe no diagrama de classes da Figura 22.1 que ios_base n˜ ao considera informa¸co˜es do locale. Veremos a seguir os métodos de ios_base. Na descri¸caõ de cada método colocamos, em negrito, na primeira linha, a declara¸caõ do método e abaixo, uma breve descri¸caõ. M´ etodos de ios base fmtflags setf(fmtflags fmtfl); O método setf() é um dos principais métodos da classe ios_base, sendo utilizado com o objetivo de definir a formata¸caõ de sa´ıda. Veja na Tabela 22.1 os flags que podem ser utilizados para alterar os atributos da stream por meio do método setf(). Lembre-se de que diferentes flags podem ser combinados com o operador |, como em setf(ios::scientific | ios::right). O método setf() retorna os flags anteriores. void unsetf(fmtflags mask); Desativa formata¸caõ de sa´ıda. Programa¸caõ Orientada a Objeto com C++


406


Figura 22.1: Diagrama UML da biblioteca de manipula¸caõ de entrada e sa´ıda. ios_base

locale

+flags() +setf() +unsetf() +rdstate() +width() +precision() +imbue() +getloc()

+bad() +clear() +eof() +fail() +good() +rdstate() +setstate() +fill() +rdbuf()

+locale() +name() +global() +classic()

+boolalpha() +noboolalpha() +showbase() +noshowbase() +showpoint() +noshowpoint() +showpos() +noshowpos() +skipws() +noskipws() +uppercase() +nouppercase() +left() +right() +dec() +hex() +oct() +fixed() +scientific() +endl() +ends() +flush() +ws() +setbase() +setfill() +setprecision() +setw() +unitbuf() +nounitbuf() +setiosflags() +resetiosflags()

+getline()

+gcount() +get() +getline() +ignore() +read() +tellg() +seekg() +putback() +unget() +peek() +sync() +operator>>()

+tellp() +seekp() +put() +write() +operator<<() +flush()

+is_open() +open() +close()

+str()

+is_open() +open() +close()




407

int rdstate(); Retorna o estado atual da stream. streamsize width(streamsize n); O método width() define a largura m´ınima do campo; isto significa que, se a largura é 6 e o n´ umero enviado para a tela tem 9 d´ıgitos de precisão, ser˜ ao mostrados os 9 d´ıgitos. Isto é válido apenas para a próxima sa´ıda. streamsize width(); Retorna a largura do campo. streamsize precision(streamsize n); Define a precisão da sa´ıda; o valor default é 6 caracteres. Retorna o valor da precisão anterior. locale imbue(const locale& loc); Seta nova localidade, retorna localidade anterior (veja listagem 22.7). locale getloc(); Retorna a localidade. fmtflags flags(); Retorna os flags atuais. fmtflags flags(fmtflags flags); Seta os flags, retorna flags anteriores.

Tabela 22.1: Flags para o método setf(). Flags de ios base ios::skipws ios::left ios::right ios::internal ios::shombase ios::showpoint ios::uppercase ios::showpos ios::scientific ios::fixed ios::unitbuf ios::stdio ios::dec ios::oct ios::hex ios::boolalpha

Significado Ignora espa¸cos em branco (somente entrada). Alinhamento à esquerda. Alinhamento à direita. Caractere de preenchimento entre o sinal +/- e o n´ umero (nointernal). Mostra indicador de base, 0x para hexadecimal (só sa´ıda). Mostra ponto decimal (flutuante) zeros n˜ ao significativos no final. Mai´ uscula para sa´ıda de valores hexadecimais (nouppercase). Mostra sinal positivo (+) se maior que 0 (noshowpos). Usa nota¸caõ cient´ıfica. Usa nota¸caõ fixa. Descarrega stream ap´ os inser¸caõ. Descarrega stdout e stderr ap´ os inser¸caõ. Base 10, decimal. Base 8, octal. Base 16, hexadecimal. Exibe true/false no lugar de 1 e 0.

Veja a seguir um exemplo de uso da classe ios::base. Lembre-se de que cout é um objeto do tipo ostream, herdeiro da classe ios_base, logo cout pode acessar o método setf() diretamente. Observe a forma como os flags da Tabela 22.1 s˜ ao passados para o método setf(). Programa¸caõ Orientada a Objeto com C++


408

22.3. A CLASSE IOS_BASE Exemplo: #include using namespace std; int main() { float x = 5.1234567890; // Armazena flags atuais ios::fmtflags flags = cout.flags(); // Muda flags, usa formato cient´ ıfico e alinhamento ` a esquerda cout.setf(ios::scientific); // Ativa nota¸ c~ ao cient´ ıfica cout.setf(ios::left); // Ativa alinhamento ` a esquerda // cout.setf(ios::scientific | ios::left); // Alternativa cout < < "Valor de x = " < < x < < endl; cout.flags(flags); // Retorna para flags anteriores cout < < "Valor de x = " < < x < < endl; return 0; }

Veja no exemplo da listagem 22.1 o uso de sa´ıda formatada. As opera¸co˜es de sa´ıda para tela podem ser realizadas com o objeto cout e o operador de inser¸caõ (< <). O exemplo mostra sa´ıda com e sem showpoint e, em seguida, define a largura do campo em 5 caracteres e imprime o valor de i. Veja na sa´ıda que o n´ umero 1 é impresso a partir da coluna 4. Posteriormente, entra em um la¸co for onde define a precisão de sa´ıda e imprime o contador i num campo com largura 2, e, ent˜ ao, o valor de d. Observe que d é truncado e n˜ ao arredondado. No final, define o caractere de preenchimento como sendo ’*’ e imprime i. Nota: note que dentro de main() criamos um inteiro i e dentro do for um novo inteiro i e que mudan¸cas no i do for n˜ ao alteraram o valor de i de main(), isto ocorre porque os mesmos est˜ ao em escopos diferentes. Veja Se¸caõ B.4. Listing 22.1: Formata¸caõ b´ asica da sa´ıda de dados. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# include < iostream > # include < string > using namespace std ; int main () { int i = 5; double d = 1.23456789 ; string nome = " Clube Palestra It´ a lia - Palmeiras " ; char letra = ’c ’ ; char cstring [] = " STRING_DE _C " ; cout << << << << <<

" \n - - - - - - - - - - - - - - - - - Formato padr~ ao - - - - - - - - - - - - - - - - " " \ nint_i double_d string_nom e char_c char * _cstring " " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " i << " " << d << " " << nome << ’ ’ << letra << " " cstring << endl ;

cout << " Alinhamen t o a esquerda " << endl ; cout . setf ( ios :: left ) ; cout . width (10) ; cout << i << " " ;



22.3. A CLASSE IOS_BASE 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

409

cout << " \ n A l i n h a m e n t o a direita " << endl ; cout . setf ( ios :: right ) ; cout . width (10) ; cout << i << endl ; cout << " Formato cient´ ı fico " << endl ; cout . setf ( ios :: scientific ) ; cout << d << endl ; cout << " Mostra sinal positivo " << endl ; cout . setf ( ios :: showpos ) ; cout << d << endl ; cout << " Seta precis~ a o num´ e rica em 12 " << endl ; cout . precision (12) ; cout << d << endl ; cout << " Seta espa¸ c o do campo em 20 caracteres " << endl ; cout . width (20) ; cout << i << endl ; cout << " Seta o caractere de p r e e n c h i m e n t o ’# ’ " << endl ; cout . width (20) ; cout . fill ( ’ # ’) ; cout << i << endl ; cout << " Escreve na tela 5 caracteres da cstring " << endl ; cout . write ( cstring , 5) ; cout << endl ; cout << " Imprime a letra G na tela " << endl ; cout . put ( ’G ’) ; cout << endl ; cout << " Imprime a letra " << ends << letra << endl ; cout << " Imprime c´ o digo ascii da letra \ n " << static_cast < int >( letra ) << endl ; cout << " Imprime o n´ u mero 12 em hexadecim al \ n " << hex << 12 << endl ; cout << " Parenteses evita ambig¨ u idade , imprime \"9\"\ n " << (5 + 4) << endl ; cout << " Imprime string de C \ n " << cstring << endl ; cout . flush () ; // U t i l i z a d o para d e s c a r r e g a r o buffer

cout << " Usando boolalpha : 1 = " << boolalpha << ( bool ) 1 << " \ nUsando noboolalp h a : 1 = " << noboolalph a << ( bool ) 1 << endl ; return 0; } - - - - - - - - - - - - - - - - - Formato padr~ ao - - - - - - - - - - - - - - - int_i double_d string_nom e char_c char * _cstring ----------------------------------------------5 1.23457 Clube Palestra It´ a lia - Palmeiras c STRING_DE _ C Alinhamen to a esquerda 5 Alinhamen to a direita



410


5 Formato cient´ ı fico 1.234568 e +00 Mostra sinal positivo +1.234568 e +00 Seta precis~ a o num´ e rica em 12 + 1 . 2 3 4 5 6 7 8 9 0 0 0 0 e +00 Seta espa¸ c o do campo em 20 caracteres +5 Seta o caractere de p r e e n c h i m e n t o ’# ’ ##################+5 Escreve na tela 5 caractere s da cstring STRIN Imprime a letra G na tela G Imprime a letrac Imprime c´ o digo ascii da letra +99 Imprime o n´ u mero 12 em hexadecim al c Parentese s evita ambig¨ u idade , imprime "9" 9 Imprime string de C STRING_D E_ C Usando boolalpha : 1 = true Usando noboolalp ha : 1 = 1

Veja exemplo na listagem 22.2. Observe que o valor na sa´ıda de cout é arredondado e n˜ ao truncado e que utilizamos endl para incluir uma linha nova e descarregar o buffer (cout < < endl;). O manipulador flush descarrega o buffer (cout.flush();). Listing 22.2: Formata¸caõ da sa´ıda de dados usando o método setf(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# include < iostream > using namespace std ; int main () { int i = 16; double d = 1 . 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 ; char c = ’ c ’; cout << " --> Mostrando n´ u meros em ponto flutuante " << endl ; cout . unsetf ( ios :: showpoint ) ; cout << " Sem shownpoin t 3.33000= " << 3.33000 << endl ; cout . setf ( ios :: showpoint ) ; cout << " Com shownpoin t 3.33000= " << 3.33000 << endl ; cout << " --> Definindo a largura do campo " << endl ; cout . width (5) ; cout < Definindo a precis~ a o da sa´ ı da " << endl ; for ( int i = 1; i <= 5; i ++) { cout << " Precis~ ao = "; cout . width (2) ; cout < Definindo o caractere de p r e e n c h i m e n t o " << endl ;



22.4. A CLASSE 31 32 33 34 35

411

cout . fill ( ’ * ’) ; cout . width (10) ; cout < Mostrando n´ u meros em ponto flutuante Sem shownpoint 3 . 3 3 0 0 0 = 3 . 3 3 Com shownpoint 3 . 3 3 0 0 0 = 3 . 3 3 0 0 0 --> Definindo a largura do campo 16 --> Definindo a precis~ a o da sa´ ı da Precis~ a o = 1 d =1. Precis~ a o = 2 d =1.1 Precis~ a o = 3 d =1.12 Precis~ a o = 4 d =1.123 Precis~ a o = 5 d =1.1235 --> Definindo o caractere de p r e e n c h i m e n t o ********16

22.4

A classe

A é uma classe de manipuladores que permite a defini¸caõ de um conjunto de parˆ ametros relacionados ` a formata¸caõ da sa´ıda de dados. A Tabela 22.2 mostra alguns manipuladores de , se o mesmo é usado para entrada (E) e sa´ıda (S) e seu significado. Muitos dos manipuladores de s˜ ao equivalentes a alguns flags do método setf(). Observe que, na coluna de significado, colocamos, dentro de [], o manipulador inverso. Programa¸caõ Orientada a Objeto com C++


412

22.4. A CLASSE

Tabela 22.2: Manipuladores da classe . Manipulador showpos showpoint skipws upercase left/right fixed/scientific endl ends flush resetiosflags(long fl) setbase(int i) setfill(char) setiosflags(lonf fl) setprecision(int n) setw(int w) ws dec oct hex showbase boolalpha unitbuf

E/S S S S S S S S S S E/S S E/S E/S E/S E/S S E/S E/S E/S S E/S S

Significado Mostra sinal positivo (+) [noshowpos]. Adiciona zeros [noshowpoint]. Ignora espa¸cos em branco [noskipws]. Letras mai´ usculas [nouppercase]. Alinhamento à esquerda/direita. Formato fixo/cient´ıfico. Insere nova linha ’\n’ e libera stream [flush]. Envia caractere nulo ’\0’. Esvazia o buffer da stream. Define os bits de ios indicados em long fl. Formata n´ umeros na base i. Define o caractere de preenchimento. Define os bits de ios indicados em long fl. Define a precisão float para n casas. Define o tamanho de campos para w espa¸cos. Ignora caracteres em branco. Formata n´ umeros na base decimal (10). Formata n´ umeros na base octal (8). Formata n´ umeros na base hexadecimal (16). Se ativo mostra base. Se ativo, usar true/false no lugar de 1/0 [noboolalpha]. Esvazia o buffer ap´ os cada opera¸caõ [nounitbuf].

No exemplo a seguir testamos o uso de showpoint, boolalpha e uppercase. Exemplo: #include int main() { int x = 11; std::cout < < x < < std::endl; < < "Sa´ ıda em hexadecimal\n" < < hex < < x < < "\nSa´ ıda com showpoint\n" < < showpoint < < x < < "\nSa´ ıda com boolalpha e uppercase\n" < < boolalpha < < uppercase < < (bool)0 < < endl; return 0; } Veja no exemplo da listagem 22.3 o uso de sa´ıda formatada usando os manipuladores da classe . Compare esse exemplo com a listagem 22.1. O exemplo inicia-se definindo a largura do campo com setw(). Em seguida, usa setprecision() para definir a precisão de sa´ıda e setfil() para definir o caractere de preenchimento. Listing 22.3: Formata¸caõ da sa´ıda de dados usando a classe . 1




22.4. A CLASSE 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

413

# include < iomanip > using namespace std ; int main () { int i = 16; double d = 1 . 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 ; char c = ’c ’ ; cout << " --> Definindo a largura do campo \ n " << setw (5) < Definindo a precis~ a o da sa´ ı da " << endl ; for ( int cont = 1; cont <= 10; cont ++) cout << " Precis~ a o = " << setw (2) << cont << s e t p r e c i s i o n ( cont ) << " d = " << d << endl ; cout << " --> Definindo o caractere de p r e e n c h i m e n t o \ n " << setw (10) << setfill ( ’* ’) < Definindo formato do n´ u mero " << " ( hexadecimal , octal e decimal ) " << " \ nhex 15 = " << hex << 15 << " \ noct 15 = " << oct << 15 << " \ ndec 15 = " << dec << 15 << " \ nbase 10= " << setbase (10) << 15 << endl ; return 0; }

--> Definindo 16 --> Definindo Precis~ ao = 1 Precis~ ao = 2 Precis~ ao = 3 Precis~ ao = 4 Precis~ ao = 5 Precis~ ao = 6 Precis~ ao = 7 Precis~ ao = 8 Precis~ ao = 9 Precis~ a o =10 --> Definindo ********16 --> Definindo hex 15 = f oct 15 =17 dec 15 =15 base 10=15

a largura do campo a precis~ a o da sa´ ı da d =1 d =1.2 d =1.23 d =1.235 d =1.2346 d =1.23457 d =1.234568 d =1.234567 9 d =1.2345678 9 d =1.2345678 9 o caractere de p r e e n c h i m e n t o formato do n´ u mero ( hexadecimal , octal e decimal )

Um bool tem como sa´ıda os valores 0 ou 1. Para ter na sa´ıda "false" ou "true", basta ativar este tipo de sa´ıda utilizando o manipulador boolalpha:

Exemplo: cout < < boolalpha < < 0; // Sa´ ıda: true cout < < boolalpha < < 1; // Sa´ ıda: false Programa¸caõ Orientada a Objeto com C++


414

22.5. A CLASSE

22.5

A classe

A classe é utilizada para enviar caracteres para um dispositivo (sa´ıda de dados). C++ cria automaticamente o objeto cout que pode ser utilizado para sa´ıda na tela do computador. Observe que cout é uma abrevia¸caõ de C out. A formata¸caõ da sa´ıda para a tela é realizada em dois passos. Primeiro, definem-se os atributos do objeto ostream (alinhamento, espa¸camento, formatos), e, em seguida, envia-se a stream para a sa´ıda desejada. Veja as listagens 22.1, 22.2 e 22.3. Veja a seguir os métodos da classe . M´ etodos de ostream& flush(); Descarrega o buffer. Como dito anteriormente, uma stream tem um buffer onde os caracteres ficam armazenados. Quando o buffer enche, os caracteres s˜ ao descarregados, isto é, enviados para o seu destino. O método flush() solicita o descarregamento imediato do buffer. A classe fornece o manipulador flush. ostream& put(char ch); Insere o caractere ch na stream. long tellp(); Retorna a posi¸caõ do ponteiro de escrita put. Veja Se¸caõ 23.5.1. ostream & operator< <(ostream & ); Operador de inser¸caõ. ostream & write(const signed char* s, streamsize n); Envia para ostream a string s com até n caracteres. N˜ ao interpreta o conte´ udo de s. Veja na Tabela 22.3 os caracteres de escape, os quais, quando inseridos em uma stream, realizam uma determinada tarefa. Exemplo: cout < < "\a\a";

Caracter ’\a’ ’\b’ ’\f’ ’\n’ ’\r’ ’\t’ \v ’\0’ ’\\’ \’ \"

Tabela 22.3: Caracteres de escape. Efeito. Toca o alarme (beep). Retrocede uma coluna (retrocesso). Pr´ oxima linha, ou p´ agina (ff). Pr´ oxima linha, nova linha. Retorno de carro. Tabula¸caõ horizontal. Tabula¸caõ vertical. Caractere nulo, usado no fim da string. Imprime \. Imprime ’. Imprime ”.



22.6. A CLASSE

22.5.1

415

Senten¸cas para

• Veja no exemplo a seguir como é a sobrecarga de uma ostream. Exemplo: ostream& operator< < (ostream& out, const Tipo obj) { out < < obj.atributo; return out; } • Observe que a sobrecarga de > > e < < é realizada com fun¸co˜es friend, n˜ ao admitindo a utiliza¸caõ do polimorfismo (n˜ ao s˜ ao métodos virtuais da classe). Você pode, porém, criar um método virtual para entrada e sa´ıda de dados. Exemplo: virtual void Entrada(istream &in); virtual void Saida(ostream &out);

22.6

A classe

A classe contém informa¸co˜es de formata¸caõ da stream considerando as informa¸co˜es do locale, isto é, a classe leva em conta o locale selecionado (a classe locale é descrita na Se¸caõ 22.9.2). A seguir s˜ ao descritos os métodos de utilizados para verificar o estado da stream. M´ etodos de bool good(); Retorna um (== 1) se n˜ ao tem erro, isto é, se est´ a tudo ok. Não é eof(), n˜ ao é fail(), n˜ ao é bad(). Associado ao bit de estado goodbit. bool bad(); Verifica se ocorreu um erro nas opera¸co˜es de entrada/sa´ıda de dados. Se estiver bad(), os caracteres da stream est˜ ao perdidos e você deve resetar a stream utilizando clear(). Retorna um valor diferente de 0 se ocorreu um erro (badbit == 1). Associado ao bit de estado badbit. bool fail(); Retorna um (== 1) se o estado da stream estiver incorreto. Se estiver fail(), indica que a próxima opera¸caõ ir´ a falhar. Uma falha pode ocorrer quando você realizou a leitura de caracteres incompat´ıveis, ou quando o arquivo a ser aberto é inexistente. Associado ao bit de estado failbit. void clear( int b = 0 ); O método clear() é utilizado para reestabelecer o estado da stream para o estado ok. O parˆ ametro opcional b é usado para setar os bits. Desliga os bits de estado eofbit, failbit e badbit e liga o bit de estado goodbit. bool eof(); Retorna um valor diferente de zero se estamos no final do arquivo. Observe que ”eof” = ”end of file”. Associado ao bit de estado eofbit. Programa¸caõ Orientada a Objeto com C++


416

22.6. A CLASSE

operator void!(); Diferente de zero (!= 0) se o estado do fluxo falhou. char fill(char ch); Define o caractere de preenchimento (o default é o caractere de espa¸co, ’ ’). Se um campo tem largura definida para 10 caracteres, e a sa´ıda s´ o ocupa 6, os 4 caracteres restantes s˜ ao preenchidos com o caractere de preenchimento. char fill(); Retorna o caractere de preenchimento. void setstate(iostate b); Usado para setar o estado do bit b. No exemplo a seguir, seta o bit eofbit para verdadeiro, também ativa o bit goodbit. Os demais flags de estado, failbit e goodbit, n˜ ao s˜ ao alterados. Veja exemplo na listagem 26.7. Exemplo: cin.setstate(ios::eofbit); operator!(); Retorna o estado da stream (o mesmo que fail()). ostream* tie(); const Retorna ponteiro para stream de sa´ıda. ostream* tie(ostream* obj); Conecta a stream com uma stream de sa´ıda (ex: cin.tie(cout);). iostate rdstate(); Retorna o estado da stream. iostate exceptions(iostate b); Liga o bit de estado que faz com que clear() dispare uma exce¸caõ. No exemplo a seguir a chamada a clear() ir´ a disparar uma exce¸caõ se o failbit estiver true. Veremos exce¸co˜es no Cap´ıtulo 26 – Exce¸co˜es. Exemplo: cin.exceptions(ios::failbit); streambuf* rdbuf(); Acesso ao buffer da stream.

22.6.1

Senten¸cas para

Veja a seguir como usar métodos de para saber o estado de cin. • Para saber se est´ a no final do arquivo. cin.eof(); • Os caracteres foram lidos, mas o formato é incorreto. cin.fail(); Programa¸caõ Orientada a Objeto com C++


22.7. A CLASSE

417

• Para saber se houve perda de dados. cin.badbit(); • Para saber se tudo ocorreu corretamente. cin.good(); • Para reinicializar os flags para o estado ok. cin.clear(); A classe inclui convers˜ oes para bool. Assim, pode-se usar while(cin > > x) para ler os valores de x. Sempre que a entrada de x for correta, cin > > x retorna verdadeiro e continua o la¸co while. Quando o usu´ ario digitar um ctrl+d , invalidando a entrada de x, o la¸co while ser´ a encerrado.

22.7

A classe

A classe é uma classe para entrada de dados (istream = input stream). Nos diversos exemplos apresentados, você aprendeu a utilizar o objeto cin do tipo para ler dados do teclado. Veremos a seguir alguns métodos fornecidos pela classe . Na descri¸caõ do método nos referimos ao objeto cin, mas o método é válido para qualquer . M´ etodos de int gcount(); Retorna o n´ umero de caracteres extra´ıdos na u ´ ltima opera¸caõ de leitura (v´ alido para get(), getline() e read()). istream& get(char* cstring, streamsize n, char end=’*’); Obtém do teclado até n caracteres, ou até a digita¸caõ do asterisco=’*’ (o ’*’ representa aqui o caractere terminador; pode ser qualquer caractere), ou até a digita¸caõ do retorno de carro(’\n’), o que ocorrer primeiro. O conjunto de caracteres lidos é armazenado em cstring. A fun¸caõ get() lê a stream até o terminador, n˜ ao o incluindo; para pegar o terminador, use um cin.get() adicional. No exemplo a seguir usamos o método get() para ler do teclado até 20 caracteres ou até encontrar o ponto ’.’ e armazenar os dados lidos em nome. Exemplo: char nome[21]; cin.get(nome, 20, ’.’); cin.get(); istream& get(char ch); Obtém um caractere do teclado e armazena em ch. Observe que se o usuário digitou a letra A e em seguida pressionou Enter , a letra ’A’ é armazenada em ch, o enter digitado pelo usuário continua no buffer do teclado. Isto significa que você precisa de um cin.get() adicional para capturar o enter. Observe nos exemplos apresentados que, ap´ os uma leitura do teclado, utilizamos um cin.get() para capturar o enter. Veja que get() retorna uma referência para uma istream. Programa¸caõ Orientada a Objeto com C++


418

22.7. A CLASSE Exemplo: char ch, novaLinha; cin.get(ch); // Captura um caractere e armazena em ch cin.get(novaLinha); // Captura o enter e armazena em novaLinha

int get(); Obtém um u ´ nico caractere do teclado. Retira um caractere do teclado. Exemplo: cin.get(); istream& getline(signed char* cstring, int n, char=’\n’); O método getline() é usado para armazenar uma linha inteira digitada no teclado em uma cstring (string de C). O método getline() pega também o retorno de carro. Observe que ele lê até n-1 caracteres, visto que o u ´ ltimo caractere é utilizado para armazenar o caractere terminador (’\0’). Exemplo: char nome[255]; cin.getline(nome);

// string de C

istream& getline(istream cin, string nome, char end=’\n’); Armazena uma linha inteira digitada no teclado em uma string de C++ . Observe que você inclui a stream cin como parˆ ametro (definida no arquivo de cabe¸calho ). Exemplo: string nome; getline(cin, nome); istream& ignore(streamsize n=1, int delim=EOF); Utilizada para ignorar até n caracteres do fluxo de entrada, ou seja, ela joga fora os próximos n caracteres. Por default ignora um caractere. Exemplo: cin.ignore(); // Ignora 1 caractere cin.ignore(2); // Ignora 2 caracteres istream& read(char *cstring, streamsize n); Utilizada para ler n caracteres sem interpretar o conte´ udo desses caracteres e armazenar em cstring. Desconsidera terminadores e n˜ ao inclui o caractere de termina¸caõ. int readsome(char* cstring, stramsize n); Assemelha-se ao read(), mas retorna o n´ umero de caracteres lidos. long tellg(); Retorna a posi¸caõ atual do fluxo (posi¸caõ do ponteiro get). Veja Se¸caõ 23.5.1. istream& putback(char ch); Devolve o caractere ch ao fluxo de entrada. A próxima letra a ser lida ser´ a ch. Exemplo: char ch = ’k’; cin.putback(ch); Programa¸caõ Orientada a Objeto com C++


22.7. A CLASSE

419

istream& unget(); Devolve para stream o u ´ ltimo caractere lido. int peek(); Retorna o próximo caractere do fluxo sem extra´ı-lo da fila. Equivale a get(ch); putback(ch);. istream& operator > >(); Usada para armazenar uma entrada do teclado em uma vari´ avel. O operador > > lê até o retorno de carro ou até o primeiro espa¸co em branco (nova linha, tabulador, avan¸co de formulário, retorno de carro). Exemplo: cin > > vari´ avel; cin > > x > > y > > z; cin > > oct > > numeroOctal; cin > > hex > > numeroHexadecimal; ostream* tie(ostream* os); Existe uma rela¸caõ entre cin e cout. Observe nas listagens apresentadas que cout n˜ ao est´ a enviando um caractere de nova linha (’\n’), mas, ao executar o programa, a nova ´ simples! O objeto cin envia para linha é inclu´ıda. A pergunta é: como isto funciona? E cout uma nova linha. Você pode utilizar o método tie() da classe para criar uma associa¸caõ entre uma e uma (da mesma forma como ocorre com cin e cout). Exemplo: istream is; ostream os; is.tie(os); Dica: veja exemplos de uso dos métodos de nas listagens 9.4 e 9.8. No exemplo da listagem 22.4, mostramos como obter o n´ umero de linhas, palavras e caracteres digitados pelo usu´ ario. Listing 22.4: Contando n´ umero de linhas, palavras e caracteres. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// C o n t a n d o n´ u mero de linhas , p a l a v r a s e c a r a c t e r e s # include < cctype > # include < iomanip > # include < iostream > # include < string > using namespace std ; int main () { unsigned long nLinhas = 0; unsigned long nPalavras = 0 ; unsigned long nCaracter es = 0; string linhaAtual ; while ( getline ( cin , linhaAtual ) ) { ++ nLinhas ; nCaracter es += linhaAtual . size () + 1;



420 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

bool naPalavra = false ; for ( size_t i = 0; char c = linhaAtual [ i ]; ++ i ) if ( isspace ( static_cast < unsigned char >( c ) ) ) { if ( naPalavra ) ++ nPalavras ; naPalavra = false ; } else if (! naPalavra ) naPalavra = true ; if ( naPalavra ) ++ nPalavras ; } cout << ’\ n ’ << left << nLinhas << ’\ n ’ << left << nPalavras << ’\ n ’ << left << nCaracteres < < return 0;

34 35 36 37

22.7. A CLASSE

setw (15) << " nLinhas : "

<< right << setw (15) <<

setw (15) << " nPalavras : "

<< right << setw (15) <<

setw (15) << " nCaracter es : " << right << setw (15) << endl ;

} C ++ e ´ mesmo uma linguagem de programa c ¸a ~ o sensaciona l . O uso de streans e ´ simples e i n c r i v e l m e n t e pr´ a tico . nLinhas : nPalavras : nCaracte re s :

3 17 107

No exemplo da listagem 22.5, mostramos como controlar a entrada de dados. Listing 22.5: Controle de entrada. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// E x e m p l o com c o n t r o l e de e n t r a d a . # include < iostream > # include < fstream > # include < string > # include < sstream > using namespace std ; int main () { int numero , soma = 0; cout << " Digite valores inteiros ( ctrl + d para encerrar entrada ) : " ; while ( true ) { cin >> numero ; // Se a e n t r a d a foi ok if ( cin . good () ) soma += numero ; // Se chegou o fim do a r q u i v o ( ctrl + d no GNU / Linux , ctrl + z no w i n d o w s) else if ( cin . eof () ) break ; // Se o c o r r e u um erro na e n t r a d a do n´ u mero else { cin . clear () ; string entrada ;



22.7. A CLASSE 29 30 31 32 33 34 35

421

cin >> entrada ; cerr << " Entrada errada , voc^ e digitou : " << entrada << endl ; } cout << " Soma = " << soma << endl ; } return 0; } Digite valores inteiros ( ctrl + d para encerrar entrada ) :1 2 3 4 Soma = 1 Soma = 3 Soma = 6 Soma = 10 [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out Digite valores inteiros ( ctrl + d para encerrar entrada ) :1 2 ee 3 4 r 5 Soma = 1 Soma = 3 Entrada errada , voc^ e digitou : ee Soma = 3 Soma = 6 Soma = 10 Entrada errada , voc^ e digitou : r Soma = 10 Soma = 15

22.7.1

Senten¸cas para

• A classe é uma especializa¸caõ do gabarito para caracteres do tipo char. Para caracteres do tipo wchar_t, utilize a . • O caractere utilizado para encerrar uma entrada de dados é diferente nas plataformas DOS/Windows e Unix, GNU/Linux, MacOS X. Exemplo: // No DOS, um ctrl+z encerra o la¸ co a seguir // No Unix, Mac OS X, GNU/Linux, um ctrl+d encerra o la¸ co a seguir int var; do { cout < < "Entre com um n´ umero:"; } while( cin > > var ); Exemplo: // L^ e os caracteres do teclado usando cin // e joga para tela at´ e que ctrl+d // (no GNU/Linux) ou ctrl +z (no Windows) seja digitado. char ch; while(cin.get(ch)) cout.put(ch); • O operador > >, ao ler uma stream (do teclado, do disco ou de outros dispositivos de entrada) desconsidera espa¸cos em branco ’ ’, nova linha ’\n’, avan¸co de formulário ’\f’ e retorno de carro (enter). Programa¸caõ Orientada a Objeto com C++


422

22.8. A CLASSE

• A fun¸caõ isspace() definida em informa se o caractere é um espa¸co. • A leitura para uma string do C [char*] automaticamente inclui o caractere de termina¸caõ (’\0’). • Veja no exemplo a seguir como sobrecarregar uma istream. Exemplo: istream& operator> > (istream& in, Tipo obj) { in > > obj.atributo; return in; }

22.8

A classe

O arquivo de cabe¸calho inclui as classes ostringstream, istringstream, stringstream e stringbuf. Estas representam um misto de uma classe string e uma classe stream, funcionando ora como uma string, ora como uma stream. Veja a seguir os métodos de . M´ etodos de string str(); Retorna a string corrente. void str(string); Seta a string. stringbuf type* rdbuf() const; Oculta defini¸caõ da classe-base, isto é, oculta ios::rdbuf(). Retorna buffer corrente. operator< <(); Operador de inser¸caõ (< <). operator> >(); Operador de extra¸caõ (> >). As classes ostringstream (output string stream) e istringstream (input string stream) podem ser utilizadas para substituir com vantagens as fun¸co˜es printf() e scanf() de C. A classe stringstream pode ser usada para leitura e escrita. O exemplo da listagem 22.6 mostra como formatar uma string utilizando os métodos de ostringstream e istringstream. Preste aten¸caõ neste exemplo: primeiro criamos um objeto os, utilizado para armazenar os caracteres das strings s1, s2 e os n´ umeros d e i, funcionando como uma stream (como cout). Em seguida, o objeto os é utilizado para mostrar a string na tela com os.str(), ou seja, os.str() retorna uma string. Você pode usar um objeto os para formatar uma sa´ıda de dados em uma string. Observe que a fun¸caõ setf(), os manipuladores de e os ponteiros de posicionamento de leitura e escrita (veja Se¸caõ 23.5.1) podem ser utilizados. No final do exemplo, criamos um objeto in, do tipo istringstream, que recebe como entrada a string formatada em os (os.str()), ou seja, o objeto in atua como uma string. Programa¸caõ Orientada a Objeto com C++


22.9. ENTRADA E SAÍDA – USO AVANCADO ¸

423

A seguir, in é utilizado para enviar os caracteres para as strings s3, s4 e os n´ umeros d2 e i2, atuando como uma stream (como cin). Observe que, com um objeto do tipo ostringstream, pode-se substituir com vantagens a antiga fun¸caõ sprintf() de C, e, com um objeto istringstream, a antiga scanf(). Listing 22.6: Usando sstream (ostringstream e istringstream). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

# include < iostream > # include < string > # include < sstream > using namespace std ;

// s t r e a m s // string de C ++ // stream e string junto

int main () { string s1 ( " oi_tudo " ) , s2 ( " bem " ) ; double d = 1.2345; int i = 5;

// Cria o b j e t o s

// Objeto do tipo o s t r i n g s t r eam , f u n c i o n a ora como stream ora como string o s t r i n g s t r e a m os ; // Abaixo , o objeto " os " f u n c i o n a como uma stream , como cout os << s1 << " " << s2 << " " << d << " " << i ; // A seguir o objeto os f u n c i o n a como uma string , str () r e t o r n a a string cout << " os . str () = " << os . str () << endl ; // Cria objeto do tipo i s t r i n g s t r e a m com nome in , // aqui in f u n c i o n a como uma string i s t r i n g s t r e a m in ( os . str () ) ; // Cria s t r i n g s s3 e s4 e dados n u m ´ e r i c o s d2 e i2 string s3 , s4 ; double d2 ; int i2 ; // Extrai os dados da stream in e a r m a z e n a em s3 , s4 , d2 , i2 // aqui in f u n c i o n a como uma stream , como cin in >> s3 >> s4 >> d2 >> i2 ; cout << " s3 = " << s3 << " \ n " << " s4 = " << s4 << " \ n " << " d2 = " << d2 << " \ n " << " i2 = " << i2 << endl ; return 0; } os . str () = oi_tudo s3 = oi_tudo s4 = bem d2 = 1.2345 i2 = 5

bem 1.2345 5

Nota: veremos outra forma de converter int em string na Se¸caõ ??.

22.9

Entrada e sa´ıda – uso avan¸cado

Veremos nesta se¸caõ alguns temas avan¸cados do uso de entrada e sa´ıda.

22.9.1

Como criar e usar um manipulador

Você pode criar seus próprios manipuladores. Veja o prot´ otipo a seguir. Programa¸caõ Orientada a Objeto com C++



424

Prot´ otipo: istream& NomeManipulador(istream& is) { is > > vari´ avel; return is;} ostream& NomeManipulador(ostream& os) {return os < < Op¸co ˜esDeFormata¸ca õ....;} No exemplo a seguir criamos um manipulador que emite um beep. Exemplo: ostream& beep(ostream& os) { return os < < ’\a’; } Utilizando o manipulador beep definido pelo usu´ ario: Exemplo: cout < < beep; Veja a seguir o exemplo de manipulador usado para ignorar uma linha inteira: Exemplo: inline istream& ignoreline(istream& in) { in.ignore( numeric.limits::max(), ’\n’ ); return in; }

22.9.2

A classe locale2

Com a classe locale você pode definir caracter´ısticas de formata¸caõ relacionadas a uma determinada localidade (pa´ıs, regi˜ ao). Como, por exemplo, a formata¸caõ de n´ umeros (ex.: 1.0 ou 1,0), o c´ odigo postal, datas, telefones etc. Veremos a seguir a classe locale: class std::locale { public: locale(const char*); locale(const locale&);

// Construtor // Construtor de c´ opia // Cria locale a partir de x e y locale(const locale& x, const locale& y); string name(); // Retorna o nome do locale // Recebe novo locale global e retorna antigo static locale global(const locale& ); const locale classic(); // Retorna locale cl´ assico }; Observe que um locale pode ser constru´ıdo a partir de uma cstring (const char *), de um outro locale ou de uma combina¸caõ de locales. Você pode obter o locale-padrão chamando o construtor da classe locale sem parˆ ametros, locale(), também pode construir o locale do usu´ ario chamando locale("");. O método global() é utilizado para definir uma nova localidade-padr˜ ao e retornar a localidade antiga. O método classic() retorna o locale cl´ assico (o mesmo que locale("C")). O método name() retorna uma string com uma série de informa¸co˜es da localidade. eja Tabela 22.4. Programa¸caõ Orientada a Objeto com C++



425

Tabela 22.4: Informa¸co˜es fornecidas pelo método locale.name(). Vari´ avel Descri¸caõ LC CTYPE Classifica¸caõ e convers˜ ao de caracteres. LC COLLATE Ordem como as strings devem ser copiadas. LC MESSAGES Como traduzir mensagens como yes/no. LC NUMERIC Como representar n´ umeros. LC MONETARY Como representar dados monet´ arios. LC TIME Configura¸caõ de data e tempo. Dica: no GNU/Linux Red Hat e Fedora, as informa¸co˜es do locale s˜ ao armazenadas no arquivo /etc/sysconfig/i18n e iniciam-se com as letras LC . Observe na Figura 22.1 que cada stream ao ser criada tem um locale associado – o localepadr˜ ao. Você pode alterar o locale de uma stream chamando o método imbue(). No exemplo da listagem 22.7, vamos criar uma classe TestandoLocale() com três métodos. O método Mostra() mostra as informa¸co˜es dos locales inicial, padr˜ ao, POSIX e C. O método Define() solicita e define o locale a ser utilizado. O método Testa() testa o locale selecionado. Observe na sa´ıda do exemplo os valores da localidade do usu´ ario (lc_usuario). A seguir, definimos o novo locale como pt_BR;. Observe que digitamos uma v´ırgula para definir o separador decimal do novo valor de x (exemplo: 1235,678). O locale-padrão de C exige que o separador decimal de valores numéricos seja digitado com ponto (exemplo: 1235.678). Ap´ os definido o novo locale, setamos as streams cin e cout usando o método imbue(). Nota: o locale do usu´ ario é definido pelo usuário quando se instala o sistema operacional. O uso de exce¸co˜es, bloco try{} throw e catch ser´ a visto no Cap´ıtulo 26 – Exce¸co˜es. Listing 22.7: Usando a classe locale. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# include < iostream > # include < string > # include < iomanip > using namespace std ;

// s t r e a m s // string de C ++ // F o r m a t a ¸ c~ a o de s t r e a m s

// / Cria classe para visualiza¸ c~ a o , ajuste e teste do locale class C T e s t a n d o L o c a l e { public : void Mostra () ; void Define () ; void Testa () ; private : locale lc_usuario ; // O locale s e l e c i o n a d o pelo u s u ´ ario public : // Construtor , seta a t r i b u t o s i n t e r n o s // define locale do u s u ´ a r i o p a s s a n d o uma string vazia "". // O locale do u s u ´ ario ´ e d e f i n i d o em seu s i s t e m a o p e r a c i o n a l . C T e s t a n d o L o c a l e () { lc_usuario = locale ( " " ) ; } };




426 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

// / Mostra a l g u m a s l o c a l i d a d e s p a d r ~ o e s como C , POSIX , a l o c a l i d a d e inicial , // / e a l o c a l i d a d e do u s u ´ a r i o l c _ u s u a r i o . name () . void C T e s t a n d o L o c a l e :: Mostra () { cout << " \ n l o c a l i d a d e _ i n i c i a l = " << locale () . name () << " \ n l o c a l i d a d e _ p a d r a o _ C = " << locale ( " C " ) . name () << " \ n l o c a l i d a d e _ p a d r a o _ P O S I X = " << locale ( " POSIX " ) . name () << " \ n l o c a l i d a d e _ u s u a r i o = " << lc_usuario . name () << endl ; } void C T e s t a n d o L o c a l e :: Define () { string nomeLocale ; // S o l i c i t a nome da l o c a l i d a d e a ser u t i l i z a d a cout << " Entre com o novo locale ( ex : pt_BR , en_US , pt , fr , C ) : " ; getline ( cin , nomeLocale ) ; // Tenta d e f i n i r novo locale a partir da e n t r a d a do u s u ´ ario try { // Define a l o c a l i d a d e do u s u ´ ario lc_usuario = locale ( nomeLocale . c_str () ) ; // Define a l o c a l i d a d e global como sendo a do u s u ´ ario locale :: global ( lc_usuario ) ; // Define a l o c a l i d a d e de cin e cout cout . imbue ( lc_usuario ); cin . imbue ( lc_usuario ); } catch ( ... ) { cerr << " \ n \ a \ aErro ao tentar definir novo locale , o locale - > " << nomeLocale << " deve ser inv´ a lido .\ n " ; } } void C T e s t a n d o L o c a l e :: Testa () { double x = 1.234; cout << " Entre com x ( ex : " << x << " ) : " ; cin >> x ; cin . get () ; cout << " x = " << s e t p r e c i s i o n (10) << x << endl ; } int main () { C T e s t a n d o L o c a l e localidad e ; localidade . Mostra () ;

// Cria objeto // Mostra alguns l o c a l e s

int continuar = 1 ; while ( continuar == 1) { localidade . Define () ; // S o l i c i t a e altera o locale localidade . Testa () ; // Testa o locale s e l e c i o n a d o cout << " \ n \ aTestar novo locale (1) ou sair (0) ?: " ; cin >> continuar ; cin . get () ; } return 0; }




427

localidade_inicial = C localidade_padrao_C = C localidade_padrao_POSIX = C l o c a l i d a d e _ u s u a r i o = pt_BR Entre com o novo locale ( ex : pt_BR , en_US , pt , fr , C ) : C Entre com x ( ex :1.234) :1.2345 x =1.2345 Testar novo locale (1) ou sair (0) ?:1 Entre com o novo locale ( ex : pt_BR , en_US , pt , fr , C ) : pt_BR Entre com x ( ex :1 ,234) :1 ,23456 x =1 ,23456 Testar novo locale (1) ou sair (0) ?:0

22.9.3

Usando facets 2

Um locale pode ser adaptado a uma determinada localidade definindo-se facets (classes que especificam algumas propriedades das streams). Para detalhes do funcionamento de um locale, consulte o livro de [Bjarne, 1999] (3a . edi¸caõ revisada em inglês). Infelizmente, a edi¸caõ traduzida para o português, a terceira, n˜ ao contempla o apêndice sobre locale. Entretanto, o autor disponibilizou no seu site, o Appendix D: Locales, no endere¸cohttp://www.research. att.com/~bs/3rd_loc0.html. No exemplo da listagem 22.8, vamos mostrar o uso de facets. Também mostraremos o uso de wstring e wcout. Listing 22.8: Usando facets. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

// E x e m p l o de uso de facet # include < iostream > # include < fstream > # include < string > # include < sstream > # include < locale > using namespace std ; int main () { // Usando facets // A c h a n d o o s ´ ı m b o l o usado com dolar locale us ( " en_US " ) ; wstring dolar = use_facet < moneypunct < wchar_t > > ( us ) . curr_symbo l () ; wcout << " S´ ı mbolo para dolar = " << dolar << endl ; // A c h a n d o o s ´ ı m b o l o usado com real locale br ( " pt_BR " ) ; wstring real = use_facet < moneypunct < wchar_t > > ( br ) . curr_symb o l () ; wcout << " S´ ı mbolo para real = " << real << endl ; return 0; }

S´ ı mbolo para dolar = $ S´ ı mbolo para real = R$



428

22.10

22.10. SENTENCAS ¸ PARA STREAM

Senten¸cas para stream

• Lembre-se de que, no uso de cin > > mensagem;, caracteres como espa¸co s˜ ao desconsiderados. • A inclus˜ ao de #include fornece, além dos objetos cin e cout, os objetos cerr (mensagens de erro) e clog (mensagens de log) que também s˜ ao conectados à sa´ıdapadr˜ ao do sistema (o monitor). • cout e clog s˜ ao buferizadas; isto significa que os caracteres n˜ ao s˜ ao imediatamente enviados para a tela. Para enviar imediatamente à tela, inclua uma chamada ao método flush(). Exemplo: cout.flush(); // ou cout < < flush; • O objeto cerr n˜ ao é buferizado; isto significa que ele envia os caracteres imediatamente para a tela. Assim como cin, cerr é conectada com o monitor e deve ser utilizada para enviar mensagens de erro para a tela. • Nas suas classes inclua sobrecarga para os operadores de extra¸caõ > > e de inser¸caõ < <. Note que o usuário de sua classe espera que os operadores < < e > > estejam sobrecarregados. • Para ter certeza da sa´ıda do operador de inser¸caõ (< <), utilize parênteses. Exemplo: cout < < (a+b); • Ap´ os uma leitura com cin, utilize cin.get() para retirar o caractere de retorno (o enter ). • Lembre-se de que o manipulador width() se aplica à sa´ıda seguinte. • Como dito, ios é válido para char, e wios para wchar_t. As equivalências s˜ ao: ios>wios, istream->wistream, ostream->wostream, iostream->wiostream, ofstream->wofstream, ifstream->wifstream, fstream->wfstream, streambuf->wstreambuf, e, finalmente, filebuf>wfilebuf. • A classe define um operador void*() que retorna NULL se o bit failbit é true, isto é, se ocorreu um erro na leitura [Lischner, 2003].

22.11


Vimos neste cap´ıtulo a hierarquia de classes fornecidas pelo C++ para entrada e sa´ıda de dados. Aprendemos que a biblioteca-padr˜ ao é bastante extensa e inclui diversas classes para entrada e sa´ıda de dados, classes com e sem buffer. Aprendemos que o uso de buffer é importante pois os mesmos deixam o programa mais r´ apido. Vimos que podemos definir a formata¸caõ de entrada e sa´ıda de dados usando o método setf() ou usando manipuladores. Aprendemos a criar nossos próprios manipuladores. Vimos que a entrada de dados é feita com as classes e . Substitu´ımos o uso da obsoleta printf() e scanf() (de C) pelas classes ostringstream e istringstream. Programa¸caõ Orientada a Objeto com C++


22.12. EXERCÍCIOS

429

Finalmente, aprendemos a definir a localidade a ser utilizada, a usar a classe locale e os facets. A seguir, no Cap´ıtulo 23 – Entrada e Sa´ıda com Arquivos de Disco, aprenderemos a acessar dispositivos de disco e veremos alguns conceitos como redirecionamento de entrada e sa´ıda.

22.12

Exerc´ıcios

1. Inclu´ımos a seguir dois exemplos de fun¸co˜es utilitárias que realizam a convers˜ ao de n´ umeros double para string e vice-versa. Como exerc´ıcio, monte fun¸co˜es equivalentes para int, float, long double. Em seguida, monte uma fun¸caõ template para realizar a mesma coisa para tipos genéricos. // Fun¸ c~ ao global utilit´ aria, convers~ ao double->string string doubleToString(double d) { ostringstream os; os < < d ; return os.str(); } // Fun¸ c~ ao global utilit´ aria, convers~ ao string->double double stringToDouble(string s) { istringstream in( s ); double d; in > > d; if( in.fail() || !in.eof()) return 0.0; return d; } 2. Quais objetos est˜ ao associados ` a sa´ıda e entrada padr˜ ao, à sa´ıda de erro e de logs? Quais s˜ ao buferizados? (falar o nome e para que serve). 3. Qual a diferen¸ca entre ’\n’ e ends? 4. Monte um exemplo que utilize putback() e unget(). 5. Pesquise na internet o uso de facets e, em seguida, modifique a listagem 22.7, incluindo o uso de facets. 6. Monte um exemplo que inclua a defini¸caõ e o uso do manipulador beep. 7. Crie um par de manipuladores que fa¸cam a convers˜ ao de d´ olar para real e de real para d´ olar. 8. Monte um exemplo em que o n´ umero de caracteres lidos seja mostrado na tela a cada opera¸caõ de leitura. 9. Na listagem 22.6, verifique como fica a istringstream depois de usada. 10. Comente o funcionamento l´ ogico da listagem 22.4.



430


22.12. EXERCÍCIOS


Cap´ıtulo 23

Entrada e Sa´ıda com Arquivos de Disco No Cap´ıtulo 22 - Entrada e Sa´ıda com C++, aprendemos a utilizar as classes streams de C++. Neste cap´ıtulo veremos uma introdu¸caõ ao acesso a arquivos de disco (se¸caõ 23.1). Como criar e usar objetos da classe para acessar arquivos de disco (se¸caõ 23.2). Como armazenar e ler objetos inteiros em disco (se¸caõ 23.3). O uso de redirecionamento de entrada e sa´ıda (se¸caõ 23.4). Na se¸caõ entrada e sa´ıda com arquivos de disco - uso avan¸cado (se¸caõ 23.5), veremos: Como posicionar ponteiros de arquivos com seekg(), seekp(), tellg(), tellp() (se¸caõ 23.5.1), o acesso a dispositivos externos como a impressora e a sa´ıda auxiliar (se¸caõ 23.5.2). A cria¸caõ e uso de arquivos de disco bin´ arios (se¸caõ 23.5.3) e como executar e enviar comandos para outros programas usando as classes de (se¸caõ 23.5.4). Nota: neste cap´ıtulo vamos descrever o uso das classes , , , nos referindo ao acesso a arquivos de disco. Mas estas classes podem ser utilizadas para ler/escrever em outros dispositivos.

23.1

Introdu¸ c˜ ao ao acesso a disco

Reveja na Figura 22.1, a hierarquia de classes de entrada e sa´ıda. Herdeira da classe , a classe é utilizada para enviar caracteres para um dispositivo externo, como um arquivo de disco (ofstream = output file stream). Herdeira da classe , a classe é utilizada para ler caracteres de um dispositivo, como um arquivo de disco (ifstream = input file stream). Herdeira da classe , a classe é utilizada para leitura e escrita em arquivos de disco. Para usar o acesso a arquivos de disco, inclua o arquivo de cabe¸calho : Exemplo: #include

23.2

A classe

Veremos a seguir alguns métodos da classe . 431

432

23.2. A CLASSE

M´ etodos de fstream(); Construtor default da classe, cria objeto sem associá-lo a um arquivo de disco. fstream(const char* arq, int = modoDeAbertura, int = modoDeProte¸ c˜ ao); Construtor sobrecarregado, cria objeto e associa-o a um dispositivo, normalmente um arquivo de disco. Se você deseja abrir o arquivo sem eliminar o existente, inclua um ios::app para adicionar caracteres no fim do arquivo. modoDeAbertura Especifica como abrir o arquivo (veja Tabela 23.1). modoDeProte¸caõ Especifica o formato de prote¸caõ do arquivo (veja Tabela 23.2). fstream(int); Construtor sobrecarregado, cria objeto e associa-o a arquivo identificando-o com um n´ umero int (n˜ ao é coberto pelo padr˜ ao Ansi C++, mas é disponibilizado em alguns sistemas). void open (const char *arq, int = modoDeAbertura, int = modoDeProte¸ c˜ ao); O método open() é usado para abrir arquivos de disco. Por default, abre o arquivo eliminando o arquivo existente. Se você deseja abrir o arquivo sem eliminar o existente, inclua um ios::app para adicionar caracteres no fim do arquivo. Exemplo: ofstream fout; fout.open("nomeDoArquivo.dat");

Tabela 23.1: Modos de abertura do método open(). ios::app Acrescenta ao fim do arquivo (modo append ) ios::ate Abre arquivo e vai para o fim dele ios::in Abre o arquivo para entrada (leitura) ios::out Abre o arquivo para sa´ıda (escrita) ios::nocreat N˜ ao cria se o arquivo n˜ ao existe (uma falha) ios::noreplace Se o arquivo j´ a existir, ocorre uma falha ios::binary Abre o arquivo em modo binário ios::trunc Elimina o arquivo se já existir e recria (default )

Tabela 23.2: Modos de prote¸caõ do método open() (atributos de arquivo). 0 Arquivo 1 Apenas leitura 2 Escondido 4 Sistema 8 Ativar o bit do arquivo (backup) Programa¸caõ Orientada a Objeto com C++


23.2. A CLASSE

433

istream & seekg(streamoff deslocamento, seekdir manipulador); Quando uma istream abre um arquivo de disco, o ponteiro de leitura aponta para o in´ıcio do arquivo. A medida que a istream é utilizada, o ponteiro de leitura é deslocado para o próximo dado a ser lido. O método seekg() é utilizado para movimentar o ponteiro de leitura. Podemos mudar a posi¸caõ do ponteiro de leitura sem ter que realizar uma leitura (veja se¸caõ 23.5.1). ostream & seekp(streamoff deslocamento, seekdir manipulador); Movimenta ponteiro de escrita (veja se¸caõ 23.5.1). Veja na Tabela 23.3 os manipuladores que podem ser passados para esses métodos. Exemplo: // Movimenta ponteiro get fin.seekg(deslocamento,manipulador); // Movimenta ponteiro put fout.seekp(deslocamento,manipulador); // Obt´ em posi¸ c~ ao do ponteiro get ios::pos_type pg = fin.tellg(); // Obt´ em posi¸ c~ ao do ponteiro put ios::pos_type pp = fout.tellp(); bool is open(); Retorna verdadeiro se o arquivo esta aberto. void close(); Descarrega o buffer e fecha o arquivo aberto; se já fechado, ignora-o.

Tabela 23.3: Manipuladores seekdir para os métodos seekp() e seekg(). ios::beg Vai para o in´ıcio do arquivo ios::end Vai para o fim do arquivo ios::cur Posi¸caõ corrente ios::fail Opera¸caõ E/S falhou (possivelmente o arquivo est´ a com problemas) ios::bad E/S inválida (possivelmente o arquivo est´ a com problemas) Na listagem 23.1 apresentamos, além da sa´ıda, os arquivos gerados pelo programa (o comando cat do GNU/Linux mostra o conte´ udo de um arquivo). O programa inicia criando o objeto fout. A seguir abre o arquivo de disco "data.dat" e envia para o arquivo a mensagem "Isto vai para o arquivo de disco". Num segundo bloco, abrimos o arquivo de disco "data2.dat", usando o construtor de ofstream que recebe o nome do arquivo a ser aberto. No terceiro bloco, o arquivo "data.dat" é aberto, agora para leitura. O conte´ udo da primeira linha do arquivo é copiada para a string s. Dentro do for, utilizamos um objeto ostringistream para criar arquivos de disco com nomes: nomeDoArquivo-1.dat, nomeDoArquivo-2.dat, nomeDoArquivo-3.dat. Arquivos seq¨ uenciais s˜ ao muito u ´ teis em programas de simula¸caõ cient´ıfica. Como dito anteriormente, os.str(), retorna uma string de C++, já c_str(), converte uma string de C++ em uma string de C (char *). Observe que o funcionamento dos objetos do tipo ofstream e ifstream, é muito semelhante ao uso de cout e cin. Em ambos os casos, o acesso a disco é finalizado quando fechamos a conex˜ ao com o dispositivo de disco com close(). Programa¸caõ Orientada a Objeto com C++


434

23.2. A CLASSE Listing 23.1: Uso de stream de disco (ifstream e ofstream).

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

# include < iostream > # include < fstream > # include < string > # include < sstream > using namespace std ; int main () { { // Cria o objeto do tipo o f s t r e a m ofstream fout ;

com nome fout

// A s s o c i a o objeto fout ao a r q u i v o de disco data . dat fout . open ( " data . dat " ) ; // Se a a b e r t u r a do a r q u i v o falhou , e n c e r r a o p r o g r a m a if ( fout . fail () ) { cout << " N~ a o abriu o arquivo de disco . " << endl ; return 1; } // Se o a r q u i v o abriu corretamente , insere c a r a c t e r e s no a r q u i v o . fout << " Isto vai para o arquivo data . dat \ n " ; // D e s c a r r e g a o buffer e fecha o a r q u i v o. fout . close () ; } { // P o d e m o s criar o objeto fout e associ´ a - lo a um a r q u i v o de disco ofstream fout ( " data2 . dat " ) ; fout << " Isto vai para o arquivo data2 . dat \ n " ; fout . close () ; // D e s c a r r e g a o buffer e fecha o a r q u i v o . } { // Um i f s t r e a m ´ e um f s t r e a m com ios :: in , // a s s o c i a objeto de l e i t u r a fin ao a r q u i v o de disco data . dat ifstream fin ( " data . dat " ) ; string s ; getline ( fin , s ) ; // L^ e a string s do a r q u i v o de disco data . dat cout << " Conte´ u do do arquivo : " << s << endl ; fin . close () ; // Fecha o a r q u i v o } { for ( int i = 0; i < 3; i ++) { // Cria objeto do tipo o s t r i n g s t r e a m o s t r i n g s t r e a m os ; // os f u n c i o n a como uma ostream , e ´ e u t i l i z a d a para criar // o nome do a r q u i v o de disco que ser´ a aberto a seguir os << " nomeDoArquivo - " << i << " . dat " ; // Abre a r q u i v o n o m e D o A r q u ivo -0. dat ,... ofstream fout ( os . str () . c_str () ) ; // A r m a z e n a dados no a r q u i v o aberto fout << " no arquivo de disco : " << os . str () << endl ; cout << " Escrevendo no arquivo de disco : " << os . str () << endl ; fout . close () ; // Fecha o a r q u i v o }



23.2. A CLASSE 62 63 64

435

} return 0; } bash -3.00 $ ./ a . out Conte´ u do do arquivo : Isto Escrevendo no arquivo de Escrevendo no arquivo de Escrevendo no arquivo de

vai para o arquivo data . dat disco : nomeDoArquivo -0. dat disco : nomeDoArquivo -1. dat disco : nomeDoArquivo -2. dat

bash -3.00 $ cat data . dat Isto vai para o arquivo data . dat bash -3.00 $ cat data2 . dat Isto vai para o arquivo data2 . dat bash -3.00 $ no arquivo bash -3.00 $ no arquivo bash -3.00 $ no arquivo

cat nomeDoArquivo -0. dat de disco : nomeDoArquivo -0. dat cat nomeDoArquivo -1. dat de disco : nomeDoArquivo -1. dat cat nomeDoArquivo -2. dat de disco : nomeDoArquivo -2. dat

O exemplo da listagem 23.2 mostra como ler um arquivo de disco com formata¸caõ simples. O programa abre o arquivo de disco "data3.dat" e armazena no arquivo 3 linhas. Na primeira linha um n´ umero inteiro seguido de coment´ ario. A seguir, repete o procedimento para um float e uma string. Depois o arquivo é fechado com close(). Na segunda etapa o programa, abre o arquivo de disco e cria as vari´ aveis que ser˜ ao lidas do arquivo de disco. Na linha fin > > x; o objeto fin percorre o arquivo de disco desconsiderando espa¸cos em branco e retornos de carro. Quando encontra o primeiro caracter válido, verifica se o mesmo é um n´ umero inteiro e copia o mesmo para x. No caso copia o n´ umero 1452 para x. A linha fin.ignore(255,’\n’); é usada para ignorar o restante da linha. O mesmo procedimento é usado para ler y e s. Para ler a1, a2 e a3, usamos fin.ignore(255,’#’); ou seja, ignorar tudo até encontrar o caracter separador, no caso ’#’. Observe na sa´ıda que os valores de x, y, s, a1, a2 e a3 est˜ ao corretos. Listing 23.2: Lendo um arquivo com dados e coment´ arios. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# include < iostream > # include < fstream > # include < string > # include < sstream > using namespace std ; int main () { { // Cria a r q u i v o de disco e a r m a z e n a dados com c o m e n t ´ arios ofstream fout ; fout . open ( " data3 . dat " ) ; // valor # c o m e n t ´ arios fout << 1452 << " # representa bla .. bla .. bla ..1 " << endl ; fout << 0.123 << " # representa bla .. bla .. bla ..2 " << endl ; fout << " msg " << " # representa bla .. bla .. bla ..3 " << endl ; // valor # valor # valor # fout << 12 << " # " << 13 << " # " << 14 << " # " << endl ; fout . close () ; } { // L^ e os dados do a r q u i v o de disco ifstream fin ( " data3 . dat " ) ;



436 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

23.3. ARMAZENANDO E LENDO OBJETOS int x ; float y ; string s ; int a1 , a2 , a3 ; fin >> x ; fin . ignore (255 , ’\ n ’) ; fin >> y ; fin . ignore (255 , ’\ n ’) ; fin >> s ; fin . ignore (255 , ’\ n ’) ; cout << " x = " << x << " y = " << y << " s = " << s << endl ; fin >> a1 ; fin . ignore (255 , ’# ’) ; fin >> a2 ; fin . ignore (255 , ’# ’) ; fin >> a3 ; fin . ignore (255 , ’# ’) ; cout << " a1 = " << a1 << " a2 = " << a2 << " a3 = " << a3 << endl ; fin . close () ;

} return 0; } x = 1452 y = 0.123 s = msg a1 = 12 a2 = 13 a3 = 14

23.3

Armazenando e lendo objetos

Com os métodos read() e write(), podemos armazenar um objeto em disco e posteriormente lê-lo do disco, o que é muito u ´ til para manipula¸caõ de dados (banco de dados). Reveja a seguir o prot´ otipo dos métodos read() e write(). Prot´ otipo: istream & read(char *charbufer, streamsize n); ostream & write (const signed char *charbuffer, int n); A listagem 23.3 mostra um exemplo. O programa inicia-se definindo uma classe CData. Observe a sobrecarga dos operadores de inser¸caõ e extra¸caõ. Dentro de main(), solicita o nome do arquivo de disco e o associa ` a stream fout. Ap´ os verificar se o arquivo de disco foi corretamente aberto, cria um vetor para armazenar objetos do tipo CData. A seguir, entra em um looping while, onde o usuário entra com os dados de cada objeto (x e y). Envia o objeto para o arquivo de disco com fout < < obj; e mostra o objeto na tela, cout < < "Objeto=" < < obj;. No final do do while(), adiciona o objeto no vetor com push_back(obj);. Fora do while(), fecha o arquivo de disco, fout.close(), e mostra todos os objetos do tipo CData que est˜ ao armazenados no vetor d. Na segunda parte do programa, abre um objeto de leitura de arquivo de disco, ifstream fin, e verifica se o arquivo foi corretamente aberto, if (!fin). Para mostrar que os dados que foram armazenados em disco ser˜ ao corretamente lidos, cria-se um segundo vetor, com nome d2. Entra num novo while, onde lê todos os objetos armazenados em disco, mostra-os na tela e armazena no vetor d2. Finalmente mostra o vetor d2. Programa¸caõ Orientada a Objeto com C++


23.3. ARMAZENANDO E LENDO OBJETOS

437

Listing 23.3: Leitura e grava¸caõ de objetos simples usando read() e write(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

# include < string > # include < fstream > # include < vector > # include < iostream > using namespace std ; class CData { int x ; int y ; public : CData () : x (0) , friend istream friend ostream friend ifstream friend ofstream };

// D e c l a r a classe CData

y & & & &

(0) { }; operator operator operator operator

>> << >> <<

( istream & , CData &) ; ( ostream & , CData &) ; ( ifstream & , CData * &) ; ( ofstream & , CData * &) ;

// de in para CData , e x e m p l o: cin >> d ; istream & operator >> ( istream & in , CData & d ) { cout << " \ nx : " ; in >> d . x ; cout << " \ ny : " ; in >> d . y ; return in ; } // de CData para out , e x e m p l o : cout << d ; ostream & operator << ( ostream & out , CData & d ) { out << " ( x = " << d . x << " , y = " << d . y << " ) " << endl ; return out ; } // de in para CData , e x e m p l o: fin >> d ; ifstream & operator >> ( ifstream & in , CData * & d ) { in . read ( r e i n t e r p r e t _ c a s t < char * >( d ) , sizeof ( CData ) ) ; return in ; } // de CData para out , e x e m p l o : fout << d ; ofstream & operator << ( ofstream & out , CData * & d ) { out . write ( r e i n t e r p r e t _ c a s t < const char * >( d ) , sizeof ( CData ) ) ; return out ; } int main () { cout << " Nome do Arquivo : " ; // S o l i c i t a nome do a r q u i v o string nomeArqui vo ; getline ( cin , nomeArqui vo ) ; // Abre a r q u i v o de disco ofstream fout ( nomeArqui v o . c_str () ) ; if (! fout ) // V e r i f i c a se o a r q u i v o foi aberto { // ou use if ( fout . i s _ o p e n () ) cout << " \ n \ nErro na abertura de arquivo " ; exit (1) ; } vector < CData > d ;

// Cria vetor para o b j e t o s do tipo CData



438 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

CData obj ; CData * pobj ; pobj = & obj ;

23.3. ARMAZENANDO E LENDO OBJETOS // Cria objeto do tipo CData com nome obj // Cria p o n t e i r o para CData // A r m a z e n a e n d e r e ¸ c o do objeto no p o n t e i r o

cout << " Entre com os valores de x e y de cada objeto . " << " Para encerrar ctrl + d " << endl ; while ( cin >> obj ) // E n q u a n t o l e i t u r a for c o r r e t a { cin . get () ; fout << pobj ; // A r m a z e n a dados do objeto no a r q u i v o de disco cout << " Objeto = " << obj ; // Mostra dados do objeto lido na tela d . push_back ( obj ) ; // A r m a z e n a objeto no vetor }; cin . clear () ; // Reseta a stream , pronta para p r ´ oxima leitura fout . close () ; // Fecha o a r q u i v o de disco cout << " \ nMostrand o objetos do vetor d \ a " << endl ; for ( int i = 0; i < d . size () ; i ++ ) cout << d [ i ] << endl ; // Mostra todos os o b j e t o s lidos cout << " Vai ler os objetos do disco " << endl ; ifstream fin ( nomeArquiv o . c_str () ) ; if (! fin ) { cout << " \ n \ nErro na Abertura de arquivo " ; exit (1) ; } vector < CData > d2 ; while ( fin >> pobj ) { d2 . push_back ( obj ) ; }; fin . close () ;

// d2 . p u s h _ b a c k (* pobj ) ; // Fecha a r q u i v o de disco

cout << " \ nMostrand o objetos do vetor d2 \ a " << endl ; for ( int i = 0; i < d2 . size () ; i ++) cout << d2 [ i ] << endl ; return 0; } Nome do Arquivo : Teste . txt Entre com os valores de x e y de cada objeto . Para encerrar ctrl + d x : 1 y : 2 Objeto =( x = 1 , y = 2) x : 3 y : 4 Objeto =( x = 3 , y = 4) x : 5 y : 6 Objeto =( x = 5 , y = 6) x : y : Mostrando objetos do vetor d ( x = 1 , y = 2) ( x = 3 , y = 4) ( x = 5 , y = 6) Vai ler os objetos do disco Mostrando objetos do vetor d2 ( x = 1 , y = 2) ( x = 3 , y = 4)



23.4. REDIRECIONAMENTO DE ENTRADA E SAÍDA

439

(x = 5 , y = 6)

Observe que este mecanismo de armazenamento e leitura de arquivos em disco funciona corretamente. Mas se o objeto usar aloca¸caõ dinâmica para atributos internos, o conte´ udo do ponteiro é que ser´ a armazenado em disco. Você ter´ a de usar um outro mecanismo para gerenciar o armazenamento e a leitura de objetos com atributos dinâmicos.

23.4

Redirecionamento de entrada e sa´ıda

Tanto na linha de comando do GNU/Linux como do Mac OS X e do Windows, você pode utilizar os mecanismos de redirecionamento de entrada e sa´ıda de dados. Você já usou o comando ls (ou dir ) para listar o conte´ udo de um diret´ orio. Exemplo (GNU/Linux): ls Exemplo (Windows): dir Entretanto, se a sa´ıda do comando ls (ou dir ) for muito grande e n˜ ao couber na tela, os primeiros diret´ orios e arquivos ir˜ ao desaparecer. Neste caso, você pode usar um comando de redirecionamento como pipe (|), para enviar a sa´ıda do comando ls (ou dir ) para um paginador como o less. No Windows, o equivalente de ls é dir e o equivalente do less é o more (ou type). O programa less é um paginador, pois permite que você navegue em um arquivo. Para sair do less digite a letra q. Veja no exemplo a seguir que pegamos a sa´ıda do programa ls e a enviamos para o programa less. Exemplo (GNU/Linux): ls | less Exemplo (Windows): dir | more Quando você executa um programa a sa´ıda-padr˜ ao é a tela. Você pode redirecionar a sa´ıda do programa para um arquivo de disco utilizando redirecionamento >. Veja o exemplo. Exemplo (GNU/Linux): ls > arquivo.dat cat arquivo.dat Exemplo (Windows): dir > arquivo.dat type arquivo.dat | more No exemplo anterior, você pegou a sa´ıda do programa ls e a enviou para o arquivo arquivo.dat. O programa cat apenas mostrou o conte´ udo do arquivo arquivo.dat. Se o arquivo arquivo.dat for muito grande, utilize novamente o paginador less. Exemplo (GNU/Linux): cat arquivo.dat | less Exemplo (Windows): type arquivo.dat | more Programa¸caõ Orientada a Objeto com C++


23.4. REDIRECIONAMENTO DE ENTRADA E SAÍDA

440

Você pode adicionar a sa´ıda de um programa no final de um arquivo utilizando o operador de concatena¸caõ (> >), ou seja, escrever a sa´ıda de um programa em um arquivo de disco já existente. Exemplo (GNU/Linux): ./Simulacao > resultado.dat ./Simulacao > > resultado.dat Exemplo (Windows): Simula¸ c~ ao.exe > resultado.dat Simula¸ c~ ao.exe > > resultado.dat Neste caso, primeiro, você cria o arquivo resultado.dat que armazenar´ a o resultado da primeira simula¸caõ realizada. Depois, executa novamente o programa ./Simulacao, adicionando os novos resultados no final do arquivo resultado.dat. Outra possibilidade bastante interessante é criar um arquivo de disco com as entradas que ser˜ ao solicitadas por determinado programa. Assim, em vez de esperar o usuário digitar cada entrada, o programa lê as entradas diretamente do arquivo de disco. Veja exemplo a seguir. Exemplo (GNU/Linux): ./Simulacao < entrada.dat Exemplo (Windows): Simulacao.exe < entrada.dat Vamos utilizar o exemplo da listagem 23.4 para mostrar o uso dos mecanismos de redirecionamento. Observe que a listagem 23.4 solicita a entrada de 3 valores. O nome do arquivo, o n´ umero de repeti¸co˜es e a precisão do solver. Depois, mostra os valores lidos. O programa pode ser compilado e executado normalmente. Para rodar este exemplo, você precisa de um arquivo de disco com o nome "teste.dat" com o seguinte conte´ udo: teste.dat 3 0.0001 Para rodar, basta digitar ./nomeDoPrograma < < arquivoComDados. Observe na sa´ıda que executamos o programa sem redirecionamento e a seguir com redirecionamento. Listing 23.4: Usando redirecionamento de arquivo. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include < iostream > # include < fstream > # include < string > using namespace std ; int main () { string n o m e A r q u i v o D i s c o ; cout << " Entre com o nome do arquivo de disco : " ; getline ( cin , n o m e A r q u i v o D i s c o ) ; cout << " Entre com o n´ u mero de repeti¸ co ~ es : " ; int repeticoes = 0; cin >> repeticoes ; cin . get () ;



23.5. ENTRADA E SAÍDA COM ARQUIVOS DE DISCO - USO AVANCADO ¸ 17 18 19 20 21 22 23 24 25 26 27 28

441

cout << " Entre com a precis~ a o do solver : " ; double precisao = 0.0001; cin >> precisao ; cin . get () ; cout << " VALORES I N T R O D U Z I D O S / LIDOS " << " \ nnome do arquivo de disco = " << n o m e A r q u i v o D i s c o << " \ nn´ u mero de repeti¸ co ~ es = " << repeticoe s << " \ nprecisao = " << precisao << endl ; // Aqui e n t r a r i a a s i m u l a ¸ c~ a o em si .... return 0; } Executando o programa sem r e d i r e c i o n a m e n t o -----------------------------------------bash -3.00 $ ./ a . out Entre com o nome do arquivo de disco : teste . dat Entre com o n´ u mero de repeti¸ co ~ es : 4 Entre com a precis~ a o do solver : 0.0005 VALORES I N T R O D U Z I D O S / LIDOS nome do arquivo de disco = teste . dat n´ u mero de repeti¸ co ~ es = 4 precisao = 0.0005 Executando o programa com r e d i r e c i o n a m e n t o -----------------------------------------bash -3.00 $ ./ a . out < teste . dat Entre com o nome do arquivo de disco : Entre com o n´ u mero de repeti¸ co ~ es : Entre com a precis~ a o do solver : VALORES I N T R O D U Z I D O S / LIDOS nome do arquivo de disco = teste . dat n´ u mero de repeti¸ co ~ es = 3 precisao = 0.001

23.5

Entrada e Sa´ıda com Arquivos de Disco - Uso Avancado ¸

Veremos nesta se¸caõ conceitos avan¸cados de entrada e sa´ıda em C++. O acesso a impressora e a sa´ıda auxiliar. O uso de arquivos de disco binários e como executar programas externos e enviar comandos para eles.

23.5.1

Posicionando ponteiros de arquivos2

Quando estamos lendo informa¸co˜es de um arquivo do disco, estamos com o nosso objeto de leitura apontando para uma determinada posi¸caõ do arquivo. Os métodos seekg() e seekp() s˜ ao utilizados para posicionar o ponteiro de leitura (get ) e o de escrita (put ) em um determinado arquivo. Os métodos tellg() e tellp() s˜ ao utilizadas para obter a posi¸caõ dos ponteiros de leitura get() e escrita put(). Veja o uso de seekg(), read(), write() e arquivos binários na listagem 23.5. O programa inicia-se definindo uma classe CA, que tem os atributos x e y e um método de entrada Input(). O método ArmazenaObjeto() cria um objeto do tipo CA e abre um arquivo de disco. A seguir, entra num la¸co while() onde os dados de cada objeto s˜ ao lidos e armazenados em disco. No final do método ArmazenaObjeto(), o arquivo de disco estar´ a com todos os objetos que foram lidos. O método LeObjetos() solicita ao usuário qual objeto deve ser lido. A seguir, abre o arquivo de disco e usa o método seekg() para movimentar o ponteiro get e o posicionar no in´ıcio do objeto a ser lido. A fun¸caõ read() lê o objeto do arquivo de disco. Finalmente o objeto Programa¸caõ Orientada a Objeto com C++


442

23.5. ENTRADA E SAÍDA COM ARQUIVOS DE DISCO - USO AVANCADO ¸

lido é mostrado na tela. Enfim, neste exemplo, criamos uma base de dados, armazenando-a em disco com write() e usamos os métodos seekg() e read() para ler o objeto selecionado. Observe que os objetos s˜ ao armazenados e lidos no formato binário (ios::binary). Listing 23.5: Usando read(), write() e seekg(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

# include < iostream > # include < fstream > using namespace std ; class CA { public : int x ; int y ; CA () : x (0) , y (0) { }; bool Input () { cout << " Entre com x e y ( x espa¸ co y ):" ; cin >> x ; cin . get () ; cin >> y ; cin . get () ; if ( cin . fail () ) { cin . clear () ; return 0; } return 1; } }; // A r m a z e n a o b j e t o s em disco void A r m a z e n a O b j e t o s () { cout << " sizeof ( CA ) = " << sizeof ( CA ) << endl ; CA obja ; ofstream fout ( " readwrite . dat " , ios :: binary ) ; if (! fout ) { cout << " N~ a o consegue abrir arquivo de disco " ; return ; } while ( obja . Input () ) { cout << " obja . x = " << obja . x << " obja . y = " << obja . y << endl ; fout . write ( r e i n t e r p r e t _ c a s t < char * >(& obja ) , sizeof ( CA ) ) ; } fout . close () ; } void LeObjetos () { CA obja ; cout << " \ nQual objeto quer ler ? " ; int i ; cin >> i ; cin . get () ; // Cria objeto fin , que aponta para a r q u i v o r e a d w r i t e . dat ifstream fin ( " readwrite . dat " , ios :: binary ) ;



23.5. ENTRADA E SAÍDA COM ARQUIVOS DE DISCO - USO AVANCADO ¸ 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80

443

if (! fin ) { cout << " N~ a o consegue abrir arquivo de disco " ; return ; } // Vai at´ e a posi¸ c~ a o i n i c i a l do objeto i no disco fin . seekg ( i * sizeof ( CA ) , ios :: beg ) ; // L^ e o objeto i , usando m´ e todo read () fin . read ( r e i n t e r p r e t _ c a s t < char * >(& obja ) , sizeof ( CA ) ) ; fin . close () ; // Mostra a t r i b u t o s do objeto lido cout << " obja . x = " << obja . x << " obja . y = " << obja . y << endl ; } int main () { A r m a z e n a O b j e t o s () ; LeObjetos () ; return 0; } sizeof ( A ) =8 Entre com x e y ( x espa¸ co obja . x = 1 obja . y = 2 Entre com x e y ( x espa¸ co obja . x = 3 obja . y = 4 Entre com x e y ( x espa¸ co obja . x = 5 obja . y = 6 Entre com x e y ( x espa¸ co Qual objeto quer ler ?1 obja . x = 3 obja . y = 4

23.5.2

y ) :1 2 y ) :3 4 y ) :5 6 y):

Acessando a impressora e a sa´ıda auxiliar2

Como dito anteriormente, alguns sistemas aceitam o uso de um construtor de fstream que recebe um inteiro. Um exemplo é o DOS. Para ligar um arquivo diretamente à impressora no DOS, utilize: Prot´ otipo: fstream cprn(4); caux(3);

// cprn é conectado a impressorafstream // caux é conectado a sa´ıda auxiliar.

No exemplo a seguir enviamos para impressora o texto ”Estou escrevendo na impressora”. Exemplo: // Testado no DOS fstream cprn(4); cprn < < Estou escrevendo na impressora ; cprn.close(); fstream caux(3); caux < < Estou enviando texto para sa´ ıda auxiliar ; caux.close(); No GNU/Linux o dispositivo impressora est´ a localizado em ”/dev/lp0”, ”/dev/lp1”,.., etc. Assim, posso criar uma stream e a seguir conect´ a-la ao dispositivo /dev/lp0. Veja o exemplo. Programa¸caõ Orientada a Objeto com C++



444

Exemplo: ofstream fout ("/dev/lp0"); Observe como o uso de objetos streams é surpreendente. O procedimento para enviar uma string para a tela é exatamente o mesmo utilizado para enviar uma string para a impressora, sa´ıda auxiliar, modem ou outro programa.

23.5.3

Arquivos de disco bin´ arios2

Os métodos get() e put() operam byte a byte, sem interpretá-los. Veja a seguir o prot´ otipo. Prot´ otipo: istream & get(char & c); ostream & put(char & c); No exemplo a seguir a string "oi tudo bem” é percorrida com s.at[i]. Enquando o acesso n˜ ao falhar, isto é, se o caracter existe, ent˜ ao o mesmo é enviado para o disco com put(). Exemplo: #include main() { ofstream fout("data.dat", ios::binary); string s = oi tudo bem ; while(s.at[i]) // Enquanto houver algo fout.put(s[i++]); // Escreve no disco em modo binario fout < < end; fout.close(); return 0; }

23.5.4

Executando e enviando comandos para outro programa2

Um exemplo muito interessante e u ´ til do uso das streams de C++ é a execu¸caõ e o envio de comandos para um outro programa. Isto é, o seu programa pode executar um programa B e enviar comandos a ele. Nosso objetivo é desenvolver um programa que ir´ a gerar um conjunto de dados, armazenar estes dados em disco e a seguir executar o programa gnuplot para fazer o gráfico dos dados gerados. O exemplo da listagem 23.6 foi testado na plataforma GNU/Linux/Fedora e utiliza o arquivo de cabe¸calho "pstream.h" que n˜ ao é padr˜ ao e esta disponibilizado em http://pstreams. sourceforge.net/. Veremos no Cap´ıtulo ?? - Introdu¸caõ ao Processamento Paralelo com M´ ultiplos Processos, métodos alternativos ao uso de "pstream.h". A classe opstream localizada no namespace redi, é utilizada para conectar o seu programa com um programa externo. O nome do programa externo deve ser passado para o construtor de opstream dentro de aspas (””). O programa da listagem 23.6 inicia abrindo o arquivo de disco "data.dat", e armazenando neste arquivo um conjunto de dados (x, y = sin(x), z = cos(x)). A seguir o programa executa o programa externo gnuplot na linha redi::opstream gnuplot("gnuplot");. Neste ponto, criamos um objeto do tipo opstream com nome gnuplot, e executamos o programa gnuplot, de forma que poderemos enviar caracteres (”comandos”) diretamente para o gnuplot. Programa¸caõ Orientada a Objeto com C++



445

Depois o programa envia para o gnuplot um conjunto de instru¸co˜es para gerar o gráfico desejado. O programa gnuplot é aberto e o gr´ afico é apresentado (veja Figura 23.1). O gnuplot é um programa utilizado para fazer gráficos. O mesmo est´ a dispon´ıvel no site: http://www.gnuplot.info/. Se você usa GNU/Linux, provavelmente já tem o gnuplot instalado. Depois de instalar o gnuplot abra um terminal, digite gnuplot e a seguir plot sin(x),cos(x) seguido de enter. Pronto, você acaba de gerar um gráfico usando o gnuplot. Quer gerar um gr´ afico em 3D? digite splot sin(x)*cos(x). Você encontra no site https://www.lenep.uenf.br/~bueno/SoftwareLivre, material da disciplina de ”Software Livre”, o que inclui aula sobre o uso do gnuplot (veja Lista das Aulas, e procure por gnuplot ). As instru¸co˜es a seguir s˜ ao utilizadas para plotar, em duas dimensões, os dados do arquivo data.dat. Com estas instru¸co˜es vamos gerar duas curvas, a primeira usando a coluna 1 (x) contra a coluna 2 (y) . A segunda curva vai mostrar os dados da coluna 1 (x) contra os dados da coluna 3 (z). "plot ’data.dat’ using 1:2,’data.dat’ using 1:3 O comando pode ser aperfei¸coado, acrescentando-se t´ıtulos para os dados (title ’dados de y’), e o tipo de linha (with linespoint). "plot ’data.dat’ using 1:2 title ’dados de y’ with linespoint, ’data.dat’ using 1:3 title ’dados de z’ with linespoint"

Figura 23.1: Sa´ıda gerada pelo programa gnuplot. 1 dados de y dados de x 0.8 0.6 0.4 0.2 0 -0.2 -0.4 -0.6 -0.8 -1 -10

-5

0

5

10

Listing 23.6: Executando e enviando comandos para um outro programa (com ). 1




446 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

23.6. SENTENCAS ¸

# include < cstdio > # include < cmath > # include < fstream > # include " pstream . h " // D i s p o n ´ ı v e l em http :// p s t r e a m s . s o u r c e f o r g e . net / using namespace std ; int main () { // Cria a r q u i v o de disco , onde ir´ a a r m a z e n a r os dados de x ,y , z ofstream fout ( " data . dat " ) ; float x , y , z ; // A r m a z e n a um c o n j u n t o de dados em disco for ( x = -10; x <= 10; x += 0.1) { y = sin ( x ) ; z = cos ( x ) ; fout << x << " " << y << " " << z << endl ; } fout . close () ; // Cria objeto g n u p l o t do tipo o p s t r e a m e o c o n e c t a com o p r o g r a m a g n u p l o t redi :: opstream gnuplot ( " gnuplot " ) ; // Envia c o m a n d o para o g n u p l o t gnuplot << " plot ’ data . dat ’ using 1:2 title ’ dados de y ’ with linespoint " << " , ’ data . dat ’ using 1:3 title ’ dados de z ’ with linespoint " << endl ; cout << " \ nPression e enter " << endl ; cin . get () ; // E n c e r r a e x e c u ¸ c~ a o do g n u p l o t gnuplot . close () ; return 0; }

23.6

Senten¸cas

• A equivalência entre os modos de abertura no C e C++ é dada por: "r" equivale a ios::in; "w" a ios::out e ios::out | ios::trunc; "a" a ios::out | ios::app; "rf" a ios::in | ios::out; "w+" a ios::in | ios::out | ios::trunc. • Ap´ os ler um arquivo de disco até EOF - End Off File, use clear() para zerar o estado da stream, antes de usar a stream com outro arquivo.

23.7


No Cap´ıtulo 22 - Entrada e Sa´ıda com C++, aprendemos a utilizar as classes streams de C++. Neste cap´ıtulo vimos uma introdu¸caõ ao acesso a disco, onde aprendemos que um objeto ofstream é utilizado para escrever dados em um arquivo de disco e um arquivo ifstream é utilizado para leitura de dados de um arquivo de disco. Aprendemos que podemos criar um objeto ofstream/ifstream já o associando a dispositivos de disco, ou deixar para fazer esta associa¸caõ depois com o método open(). Vimos que podemos armazenar e ler objetos inteiros em disco, e que podemos posicionar os ponteiros de arquivos com os métodos seekg(), seekp(), tellg(), tellp(). Aprendemos a Programa¸caõ Orientada a Objeto com C++


23.8. EXERCÍCIOS

447

usar redirecionamentos, e vimos que os mesmos funcionam usando > > e < < (da mesma forma que os operadores de inser¸caõ< < e extra¸caõ> >). Aprendemos a acessar a impressora e a sa´ıda aux´ıliar, a criar arquivos de disco binários, e a executar e enviar comandos para outros programas usando as classes de (se¸caõ 23.5.4). No próximo cap´ıtulo, Cap´ıtulo 24 - A Classe string, veremos em detalhes o uso de strings de C++.

23.8

Exerc´ıcios

1. Planilhas eletrˆ onicas como excel, calc, gnumeric, podem importar arquivos de texto com dados em ASCII. Monte um programa que gera um conjunto de dados (x,y,z) e a seguir importe os dados usando uma destas planilhas. A seguir monte gráficos x versus y, e x versus z. 2. Criar uma classe CEstat´ ıstica, que é utilizada para calcular a média e o desvio padr˜ ao de um conjunto de dados passados pelo usuário usando cin, ou armazenados em um arquivo de disco. 3. Tenho um arquivo de disco com um nome qualquer, que tem o formato abaixo. Criar uma classe CData1D, em que os valores de uma coluna, como a coluna x, possam ser armazenados. CData1D deve armazenar o nome da coluna, a média, o desvio padr˜ ao, a variˆ ancia, o valor m´ınimo, e o valor máximo. Observe que para o arquivo a seguir, iremos precisar de 3 objetos do tipo CData1D. 3 # o n´ umero 3 indica o n´ umero de colunas x y z # nome das vari´ aveis, utilizado como t´ ıtulos dos gr´ aficos 123 432 254 321 765 987 .... 890 543 780 4. Criar um programa que usa CData1D e o programa externo gnuplot para plotar os dados. 5. Modifique a listagem 23.1, acrescente a possibilidade de se criar um arquivo de disco em que o nome muda de acordo com dois ´ındices, i e j. 6. Modifique a listagem 23.2, de forma que a mesma possa ler um arquivo de texto exportado por uma planilha usando como separador um caracter qualquer definido pelo usuário (precisa solicitar o nome do separador (ex: ”;”,”-”). 7. Modifique a listagem 23.3 , acrescentando o uso de seekg() e seekp(). 8. Modifique a listagem 23.3, adaptando as mesmas para um caso que seja de seu interesse. 9. Modifique a listagem 23.5, substitua ArmazenaObjeto pelo operador < < e LeObjeto pelo operador > >. 10. Modifique a listagem 22.4 de forma a obter o n´ umero de linhas, palavras e caracteres de um arquivo do disco. Programa¸caõ Orientada a Objeto com C++


448

23.8. EXERCÍCIOS

11. Montar exemplo que envia para impressora um arquivo postscript (nome.ps). Usar ofstream fout ("/dev/lp0");. 12. Na se¸caõ 23.5.3, o exemplo usa s.at[i], para acessar a posi¸caõ i e depois s[i++], esta l´ ogica esta correta? justifique. 13. Modifique a listagem 23.6, acrescente uma classe polinomio de grau n. O programa deve solicitar ao usuário os coeficientes do polinônio e a seguir gerar o gráfico no intervalo especificado.



Cap´ıtulo 24

A Classe A classe foi brevemente apresentada na se¸caõ 9.4.1 e utilizada em nossos exemplos. Neste cap´ıtulo, vamos nos aprofundar nos conceitos da classe . Veremos uma introdu¸caõ ` as strings de C++ (se¸caõ 24.1), discutiremos os diferentes métodos de (se¸caõ 24.2), seus construtores (se¸caõ 24.2.1), iteradores (se¸caõ 24.2.2), a manipula¸caõ do tamanho da (se¸caõ 24.2.3), os operadores de acesso (se¸caõ 24.2.4), a atribui¸caõ e concatena¸caõ (se¸caõ 24.2.5), a inser¸caõ, remo¸caõ e substitui¸caõ (se¸caõ 24.2.6). A compara¸caõ de strings (se¸caõ 24.2.7), e o uso de substrings (se¸caõ 24.2.8). Como fazer pesquisas em uma com find e rfind (se¸caõ 24.2.9). Um exemplo (se¸caõ 24.3). Finalizamos o cap´ıtulo apresentando algumas senten¸cas para strings de C++ (se¸caõ 24.4).

24.1

Introdu¸ c˜ ao ` as strings

A classe basic_string é uma classe template que pode manipular um conjunto de caracteres genéricos. Normalmente precisamos de caracteres ASCII de 8 bits, ou caracteres de 16 bits. Para satisfazer a estas necessidades, foram definidos os seguintes apelidos: typedef basic_string< char, string_char_traits > typedef basic_string< wchar_t > wstring;

string;

Assim, é um apelido para basic_string >, é utilizada para manipular caracteres do tipo char. J´ a a classe é utilizada para manipular caracteres do tipo wchar_t. Nos exemplos que ser˜ ao apresentados nos referimos a , mas os conceitos s˜ ao válidos para . Para utilizar a classe , inclua o arquivo de cabe¸calho . Exemplo: #include

Nota: nos prot´ otipos que ser˜ ao apresentados usamos para representar basic_string e char para representar um caracter qualquer. Usamos first (ou begin()) para indicar um iterador (ou ponteiro) para o in´ıcio da string e last (ou end()) para indicar o fim do intervalo (posi¸caõ n). Num vetor de dimensão n, podemos acessar da casa 0, até a casa n-1. Lembre-se this refere-se ao objeto que chama o método. 449

´ 24.2. METODOS DE

450

24.2

M´ etodos de

Veja a seguir os diferentes construtores fornecidos pela classe .

24.2.1

Construtores e destrutor

Um objeto pode ser constru´ıdo vazio, a partir de uma outra (de C ou C++), a partir de um caracter ou mesmo de uma sub-string. Observe que alguns construtores recebem o tipo de alocador a ser utilizado. inline string(); Constr´ oi uma string vazia. explicit string (const Alloc a); Constr´ oi uma string vazia, recebe o tipo de alocador a ser utilizado. string (const string &src); Construtor de c´ opia. string (const string& src, size type pos, size type n = npos); Constr´ oi uma c´ opia de src a partir da posi¸caõ pos até a posi¸caõ npos. string (const string & src, size type pos, size type n, const Alloc & a); Constr´ oi string a partir da posi¸caõ pos da string src, considerando n caracteres. string (size type n, char c, const Alloc& a = Alloc()); Constr´ oi string de tamanho n, com n c´ opias do caracter c. string (InputIterator beg, InputIterator end, const Alloc & a = Alloc ()); Constr´ oi string considerando iteradores beg() e end(). Os iteradores ser˜ ao descritos na se¸caõ 31.3. Veja a seguir um exemplo. Exemplo: // Cria string com nome s1 string s1; // Cria string com nome s2 e armazena "a classe string" string s2 ("a classe string"); // Cria string com nome s3 e inicializa com " ´ e legal" // utiliza construtor de c´ opia string s3 = " ´ e legal"; // Cria string com nome s4 uma c´ opia de s3 // utiliza construtor de c´ opia string s4 (s3); // Cria string s5, com espa¸ co para 10 caracteres, preenche com b string s5 (10, ’b’); // Cria string s6, uma c´ opia de s4. // s4.begin() aponta para o in´ ıcio de s4 // s4.end() aponta para o fim de s4 string s6 (s4.begin(), s4.end()); Programa¸caõ Orientada a Objeto com C++


´ 24.2. METODOS DE

24.2.2

451

Iteradores

Como dito, a classe , tem semelhan¸cas com as classes containers da STL. Nesta se¸caõ descrevemos os métodos de utilizados para obten¸caõ de iteradores, ponteiros inteligentes, para partes da . Os iteradores ser˜ ao descritos na se¸caõ 31.3. iterator begin (); Retorna um iterador para in´ıcio da string. Utilizado para varrer a string do in´ıcio para o fim. iterator end (); Retorna um iterador para fim da string. Utilizado para informar que chegamos ao fim da string. Exemplo: string s = "oi tudo bem!"; for(string::iterator i = s.begin(); i != s.end(); i++) cout < < s[i] ; reverse iterator rbegin (); Retorna um iterador reverso para fim da string. Utilizado para varrer a string do fim para o in´ıcio. reverse iterator rend (); Retorna um iterador reverso para in´ıcio da string.

24.2.3

Manipula¸c˜ ao do tamanho da string

A classe tem um conjunto de métodos para manipula¸caõ do tamanho da string. Veremos os métodos size(), length(), capacity(), max_size(), resize(), reserve(), clear(), empty(). size type size () const; Retorna dimensão utilizada. size type length () const; Retorna dimensão utilizada (uso obsoleto). size type capacity () const; Retorna capacidade alocada. Exemplo: string msg(100); // Tem capacidade para armazenar 100 caracteres msg = "123456789"; // Mas o size() ´ e de 9 caracteres size type max size () const; Retorna maior dimensão poss´ıvel para a string, limitada pela quantidade de memória dispon´ıvel em seu computador. void resize (size type n); Redimensiona a string para o tamanho n. Programa¸caõ Orientada a Objeto com C++


´ 24.2. METODOS DE

452

void resize (size type n, char c); Redimensiona a string para o tamanho n. Se forem criados novos caracteres os mesmos ser˜ ao preenchidos com o caracter c. void reserve (size type res arg = 0); Reserva espa¸co de mem´ oria adicional, muda a capacidade da string. void clear (); Zera a string. O size() da string passa a ser zero. bool empty () const; Returna true se a string estiver vazia Veja a seguir um exemplo. Exemplo: // Cria string com nome s6 e a seguir redimensiona string s6 ("eu terei espa¸ co para 100 caracteres"); s6.resize(100); if(s6.empty()) // Verifica se a string esta vazia cout < < "A string s6 esta vazia.";

24.2.4

Operadores de acesso

O operador [] foi sobrecarregado para acessar cada casa da string. Assim, podemos usar s[i] para acessar o elemento i da string s (da mesma forma que usamos ). O método s.at[i] faz o mesmo que s[i], a diferen¸ca é que se a casa i n˜ ao existe, s.at[i] lan¸ca uma exce¸caõ e s[i] causa um estouro de pilha. reference operator[] (size type pos); Acesso a posi¸caõ i, usando []. Retorna uma referência para i. reference at (size type n); Retorna uma referência para posi¸caõ i. Se a casa i n˜ ao existe, lan¸ca uma exce¸caõ. const reference operator[] (size type pos) const; Acesso a posi¸caõ i, usando []. Retorna uma referência constante para i. const reference at (size type n) const; Retorna uma referência constante para posi¸caõ i. Se a casa i n˜ ao existe, lan¸ca uma exce¸caõ.

24.2.5

Atribui¸c˜ ao e concatena¸c˜ ao

O método assign() é usado para atribuir uma string assign(string); uma parte de uma string, assign(string,inicio,n); uma string de C, assign(cstring); ou um caracter, assign(ch) a uma string de C++. string & assign (const string & str); Atribui a string str, para string this. string & assign (const string & str, size type pos, size type n); Atribui a string str, a partir da posi¸caõ pos, considerando n caracteres. Programa¸caõ Orientada a Objeto com C++


´ 24.2. METODOS DE

24.2.6

453

Inser¸c˜ ao, remo¸c˜ ao, substitui¸c˜ ao, c´ opia

Você pode remover, remove(), ou substituir, replace(), partes da string. Pode inserir novos caracteres, insert(), ou substrings em uma string existente. void insert (iterator p, size type n, char c); Insere a partir da posi¸caõ p, n caracteres do tipo c. void insert (iterator p, InputIterator beg, InputIterator end); Insere a partir da posi¸caõ p, a sub-string acessada por beg e end. string & erase (size type pos = 0, size type n = npos); Apaga bloco de dados a partir da posi¸caõ pos considerando n caracteres. iterator erase (iterator pos); Apaga caracter na posi¸caõ dada por pos. iterator erase (iterator begin(), iterator end()); Apaga caracteres no intervalo dado pelos iteradores begin() e end(). string & replace (size type pos, size type n, const string & str); A partir da posi¸caõ pos, considerando n caracteres, coloca a string str. size type copy (char * s, size type n, size type pos = 0) const; Copia n caracteres de s para posi¸caõ pos. void swap (string & s); Troca o conte´ udo das strings. Veja a seguir um exemplo. Exemplo: string s1 = "0123456789"; string s2 = "abcdefghijklmnopqrst"; cout < < s1 < < "\t" < < s2 < < endl; s1.erase(s1.begin()+3); s2.swap(s1); cout < < s1 < < ’\t’ < < s2 < < endl;

24.2.7

Compara¸c˜ ao

Você pode comparar strings utilizando os operadores: ==, !=, >, <, >=, <=, ou o método compare(). Se compare() retorna 0 as strings s˜ ao iguais. Se o retorno é menor que zero s1 é maior que s2, se o retorno é maior que zero, s1 é menor que s2. int compare (const string & str) const; Compara string this com str. int compare (size type pos, size type n, const string & str) const; Compara string this com str, a partir da posi¸caõ pos, considerando n caracteres. Programa¸caõ Orientada a Objeto com C++


´ 24.2. METODOS DE

454

24.2.8

Substrings

Pode-se criar e manipular sub-strings a partir de uma string. string substr (size type pos = 0, size type n = npos) const; Cria uma sub-string a partir da posi¸caõ pos, considerando n casas. const char* c str(); Retona uma string no estilo de C (uma cstring). Exemplo: string s = "Palmeiras campe~ ao mundial 1951"; string sub = s.substr(0,10);

24.2.9

Pesquisa

A classe fornece fun¸co˜es de pesquisa como find() e pesquisa invertida com rfind(). O método find("seq") localiza a primeira ocorrência de "seq" na string. Pode-se especificar com um inteiro a posi¸caõ inicial da busca. O método rfind() busca da posi¸caõ final para a inicial, ou seja, faz pesquisa reversa. Outros métodos de pesquisa find_first_of(), find_last_of(), find_first_not_of() e find_last_not_of() tratam a string argumento como um conjunto de caracteres. A posi¸caõ do primeiro caractere encontrado é retornada e, se n˜ ao encontrar, retorna uma exce¸caõ do tipo out_of_range. O prot´ otipo destes métodos é apresentado a seguir, veja exemplo na listagem ??. size type find (const string & str, size type pos = 0) const; Procura a primeira ocorrência da string str, a pesquisa inicia em pos. size type find (const char * str, size type pos, size type n) const; Procura a primeira ocorrência da cstring str, a pesquisa inicia em pos e considera até n caracteres. size type rfind (const string & str, size type pos = npos) const; Procura a primeira ocorrência da string str, a pesquisa inicia em pos e é feita do fim de this para o in´ıcio (pesquisa reversa). size type find first of (const string & str, size type pos =0) const; Procura a primeira ocorrência da string str, a pesquisa inicia em pos. size type find last of (const string & str, size type pos = npos) const; Procura a u ´ ltima ocorrência da string str, a pesquisa inicia em pos. size type find first not of (const string & str, size type pos=0) const; Procura a primeira n˜ ao ocorrência da string str, a pesquisa inicia em pos. size type find last not of (const string & str, size type pos = npos) const; Procura a u ´ ltima n˜ ao ocorrência da string str, a pesquisa inicia em pos e é invertida. Programa¸caõ Orientada a Objeto com C++


24.3. EXEMPLOS DE USO DE

24.3

455

Exemplos de uso de

Na listagem 24.1, alguns métodos da classe s˜ ao testados. O c´ odigo esta documentado. Listing 24.1: Usando a classe de C++. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

# include < iostream > # include < string > # include < cstring > using namespace std ; int main () { // Cria string com nome s1 string s1 ; s1 = " Oi , tudo bem " ; // Cria string com nome s2 e a r m a z e n a " C ++ ´ e legal " string s2 ( " C ++ e ´ legal " ) ; // Cria string com nome s3 e i n i c i a l i z a com " demais " string s3 = " demais " ; // Cria string com nome s4 uma c´ o pia de s3 ( usa c o n s t r u t o r de c´ o pia ) string s4 ( s3 ) ; // Cria string com nome s5 e define t a m a n h o como sendo 100 c a r a c t e r e s string s5 = " eu tenho espa¸ c o para 100 caracteres " ; // R e d i m e n s i o n a a string s5 s5 . resize (100) ; cout << " Conte´ u do das strings :\ ns1 = " << s1 << " \ ns2 = " << s2 << " \ ns3 = " << s3 << " \ ns4 = " << s4 << " \ ns5 = " << s5 << endl ; // Tamanho , c a p a c i d a d e e cout << " s5 . size () = " << " s5 . capacity () = " << " s5 . max_size () = "

t a m a n h o m´ a ximo da string s5 << s5 . size () << s5 . capacity () << s5 . max_size () << endl ;

// Cria a string s7 e p r e e n c h e com o c a r a c t e r e ’a ’ string s7 (10 , ’a ’ ) ; cout << " s7 . size () = " << s7 . size () << " s7 = " << s7 << endl ; // R e d i m e n s i o n a s7 . resize (15 , ’t ’ ) ; cout << " Depois de s7 . resize (15 , ’t ’) ; s7 . size () = " << s7 . size () << " s7 . length () = " << s7 . length () << " s7 = " << s7 << endl ; // R e t o r n a true se a string s7 e s t i v e r vazia if ( s7 . empty () ) cout << " A string s7 est´ a vazia " << endl ; // C´ o pia de s t r i n g s s1 = s2 ; cout << " Ap´ o s s1 = s2 , s1 = " << s1 << " , s2 = " << s2 << endl ; // A t r i b u i ¸ c~ a o de uma string de C s4 = " - p r o f i s s i o n a l " ; // A t r i b u i ¸ c~ a o de um ´ u nico c a r a c t e r e s5 = ’ - ’; cout << " s4 = " << s4 << " \ t s5 = " << s5 << endl ;



456 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118


// A d i c i o n a r a string e x i s t e n t e ( c o n c a t e n a r ) s5 += " Inclui a STL - e e ´ "; cout << " s4 = " << s4 << " \ t s5 = " << s5 << endl ; // A d i c i o n a ao final de s5 , 6 c a r a c t e r e s de s3 , a partir da p o s i ¸ c~ a o 1 de s3 . s5 . append ( s3 , 1 , 6) ; cout << " Ap´ o s s5 . append ( s3 , 1 , 6) ; s5 = " << s5 << endl ; // Cria uma c´ o pia de s2 , a d i c i o n a s4 , s5 , e mostra na tela cout << " ( s2 + s4 + s5 ) = " << ( s2 + s4 + s5 ) << endl ; // Troca o c o n t e ´ u d o das s t r i n g s s1 e s5 s5 . swap ( s1 ) ; cout << " Ap´ o s s5 . swap ( s1 ) ; " << endl << " s1 = " << s1 << " \ ns5 = " << s5 << " \ nDo caracter s1 [11] at´ e s1 [14]= " ; // Acessa a p o s i ¸ c~ a o i da string ( como em v e t o r e s) for ( int i = 11; i < 14; i ++) cout << s1 [ i ]; cout << endl ; // Coloca a letra P na p o s i ¸ c~ ao 2 s4 [2] = ’P ’; cout << " Ap´ o s s4 [2]= P , s4 [2]= " << s4 [2] << " s4 = " << s4 << endl ; // O mesmo que s4 [2] , acessa p o s i ¸ c~ a o 2 ( com at (2) v e r i f i c a acesso ) cout << " s4 . at (2) = " << s4 . at (2) << endl ; // Cria uma string no padr~ a o C , uma c s t r i n g char cstring [256]; // Copia a string s4 para cstring , usa fun¸ c~ a o strcpy do a r q u i v o de // c a b e ¸ c a l h o < cstring > strcpy ( cstring , s4 . c_str () ) ; cout << " cstring = " << cstring << endl ; // Uso de r e p l a c e e insert s5 . replace (9 , 1 , " t " ) ; s4 = " para as outras linguagens " ; s3 . insert ( s3 . end () , s4 . begin () , s4 . end () ) ; cout << s5 << s3 << endl ; s5 = " tem " ; // S u b s t i t u i c a r a c t e r e s de s1 [17] at´ e s1 [22] por s5 s1 . replace ( s1 . begin () +17 , s1 . begin () +22 , s5 . begin () , s5 . end () ) ; cout << s1 + " - e ´ m u l t i p l a t a f o r m a " << endl ; // A d i c i o n a " p r o g r a m a ¸ c~ ao gen´ erica e " s1 . insert (10 , " programa¸ ca ~ o gen´ e rica e " ) ; cout << s1 << endl ; // Cria uma s u b s t r i n g de s1 , a partir da p o s i ¸ c~ a o 10 at´ e o final de s1 cout << " s1 . substr (10) = " << s1 . substr (10) << endl ; // Cria uma s u b s t r i n g de s4 cout << " s1 . substr (10 , 12) = " << s1 . substr (10 , 12) << endl ; // C o n c a t e n a n d o s t r i n g s com append // append aceita uma v a r i e d a d e de c o m b i n a ¸ c~ oes string s10 ( " Oi " ) ; cout << s10 << endl ;



24.3. EXEMPLOS DE USO DE 119 120 121 122 123 124 125 126 127 128 129 130 131 132

457

s10 . append ( " , tudo Bem ! " ) ; cout << s10 << endl ; // O m´ e todo copy pode ser u t i l i z a d o para copiar parte da string // para uma c s t r i n g. copy ( char * , int size , int p o s I n i c i a l =0) ; char teste [255]; s10 . copy ( teste , s10 . size () , 0) ; cout << " teste = " << teste << endl ; // O m´ e todo c o m p a r e ´ e u t i l i z a d o para c o m p a r a r s t r i n g s ou partes de s t r i n g s cout << s10 . compare ( teste ) << endl ; return 0; } Conte´ u do das strings : s1 = Oi , tudo bem s2 = C ++ e ´ legal s3 = demais s4 = demais s5 = eu tenho espa¸ c o para 100 caracteres s5 . size () =100 s5 . capacity () =100 s5 . max_size () = 4 6 1 1 6 8 6 0 1 8 4 2 7 3 8 7 8 9 7 s7 . size () =10 s7 = aaaaaaaaa a Depois de s7 . resize (15 , ’t ’) ; s7 . size () =15 s7 . length () =15 s7 = a a a a a a a a a a t t t t t Ap´ o s s1 = s2 , s1 = C ++ e ´ legal , s2 = C ++ e ´ legal s4 = - p r o f i s s i o n a l s5 = s4 = - p r o f i s s i o n a l s5 = - Inclui a STL - e e ´ Ap´ o s s5 . append ( s3 , 1 , 6) ; s5 = - Inclui a STL - e e ´ demais ( s2 + s4 + s5 ) = C ++ e ´ legal - p r o f i s s i o n a l - Inclui a STL - e e ´ demais Ap´ o s s5 . swap ( s1 ) ; s1 = - Inclui a STL - e e ´ demais s5 = C ++ e ´ legal Do caracter s1 [11] at´ e s1 [14]= STL Ap´ o s s4 [2]= P , s4 [2]= P s4 = - P r o f i s s i o n a l s4 . at (2) = P cstring = - P r o f i s s i o n a l C ++ e ´ letal demais para as outras linguagens - Inclui a STL - e tem mais - e ´ multiplataforma - Inclui a programa¸ ca ~ o gen´ e rica e STL - e tem mais s1 . substr (10) = programa¸ ca ~ o gen´ e rica e STL - e tem mais s1 . substr (10 , 12) = programa¸ ca ~o Oi Oi , tudo Bem ! teste = Oi , tudo Bem !* -1

Na listagem 24.2, os métodos find(), rfind(), find_first_of(), find_first_not_of(), replace() da classe s˜ ao testados. Observe que mostramos como trocar espa¸cos por ” ”, o que é util para renomear arquivos. Também mostramos como trocar a extensão de um arquivo. Listing 24.2: Usando os métodos de pesquisa da classe string de C++. 1 2 3 4 5 6 7

# include < iostream > # include < string > # include < cstring > using namespace std ; int main () {



458 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39


// Usando find () e rfind () string s1 = " cascavel / parana " ; cout << " s1 = " << s1 << " \ ns1 . find (\" ca \") = " << " \ ts1 . find (\" ca \" , 1) = " << " \ ns1 . rfind (\" ca \") = " << " \ ts1 . rfind (\" ca \" , 2) = "

// s1 [0]= c , s1 [1]= a ,.. << << << <<

s1 . find ( " ca " ) s1 . find ( " ca " , 1) s1 . rfind ( " ca " ) s1 . rfind ( " ca " , 2) << endl ;

// P r o c u r a a p r i m e i r a o c o r r ^ e n c i a de aeiou int i = s1 . f i n d _ f i r s t _ o f ( " aeiou " ) ; cout << " f i n d _ f i r s t _ o f aeiou = " << i ; // P r ´ o x i m a n~ a o vogal int j = s1 . f i n d _ f i r s t _ n o t _ o f ( " aeiou " , i ) ; cout << " \ n f i n d _ f i r s t _ n o t _ o f aeiou = " << j

<< endl ;

// Para trocar c a r a c t e r e s em uma string string n o m e A r q u i v o C o m E s p a c o s ( " Nome de Arquivo Com Espacos . txt " ) ; cout << n o m e A r q u i v o C o m E s p a c o s << endl ; // Troca os e s p a c o s " " por " _ " int pos = 0; while (( pos = n o m e A r q u i v o C o m E s p a c o s . find ( " " , pos ) ) > 0) n o m e A r q u i v o C o m E s p a c o s . replace ( pos ,1 , " _ " ) ; // Para s u b s t i t u i r a e x t e n s ~ a o de um a r q u i v o pos = n o m e A r q u i v o C o m E s p a c o s . rfind ( " . " ) ; n o m e A r q u i v o C o m E s p a c o s . replace ( pos , 4 , " . dat " ) ; cout << n o m e A r q u i v o C o m E s p a c o s << endl ; return 0; } s1 = cascavel / parana s1 . find (" ca ") = 0 s1 . find (" ca " , 1) = 3 s1 . rfind (" ca ") = 3 s1 . rfind (" ca " , 2) = 0 f i n d _ f i r s t _ o f aeiou = 1 f i n d _ f i r s t _ n o t _ o f aeiou = 2 Nome de Arquivo Com Espacos . txt N o m e _ d e _ A r q u i v o _ C o m _ E s p a c o s . dat

Veja na listagem 24.3 a utiliza¸caõ das classes , sstream e ifstream para executar um programa do shell. O programa cria um arquivo de disco com o nome lixo, onde s˜ ao armazenados os nomes dos arquivos que têm extensão *.jpg. A seguir, monta a linha de comando a ser executada. Finalmente, realiza a convers˜ ao de imagens no formato *.jpg para o formato *.ps executando o programa convert (um programa do GNU/Linux usado para converter imagens de um formato para outro). Observe que o programa usa a fun¸caõ system() para executar comandos do shell. Neste exemplo, o comando os.str() retorna um objeto da classe . Para obter uma string no estilo de C, chama-se adicionalmente o método c_str(). Nota: este exemplo é meramente did´ atico, visto que existem maneiras mais inteligentes de converter arquivos. Listing 24.3: Usando as classes e sstream para executar comandos do shell. 1 2 3

# include < iostream > # include < fstream > # include < string >



24.4. SENTENCAS ¸ PARA STRINGS DE C++ 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

459

# include < sstream > int main ( int argc , char * argv ) { // Lista dos a r q u i v o s com e x t e n s ~ a o jpg // Nota : voc^ e pode s u b s t i t u i r ls pelo c o m a n d o find () . system ( " ls *. jpg > lixo " ) ; std :: string arq ; std :: ifstream fin ( " lixo " ) ; if ( fin . good () ) // E n q u a n t o tiver algo no a r q u i v o de disco , ler o nome do a r q u i v o while ( fin >> arq ) { int posicao = arq . rfind ( " jpg " ) ; // D e t e r m i n a p o s i ¸ c~ a o do jpg std :: o s t r i n g s t r e a m os ; os << " convert " << arq ; // In´ ı cio do c o m a n d o " c o n v e r t arq . jpg " arq . replace ( posicao , 3 , " ps " ) ; // S u b s t i t u i e x t e n s ~ a o jpg por ps os << " > " << arq ; // Fim do c o m a n d o " > arq . ps " std :: cout << os . str () << " \ n \ n " ; system ( os . str () . c_str () ) ; // E x e c u t a o c o m a n d o } // E l i m i n a o a r q u i v o lixo system ( " rm -f lixo " ) ; return 0; }

24.4

Senten¸cas para strings de C++

• As fun¸co˜es insert() e remove() s˜ ao similares as de vetores. A fun¸caõ replace() é uma combina¸caõ de remove() e insert(), substituindo o intervalo especificado por novo valor. • A fun¸caõ compare() raramente é acessada diretamente; normalmente utilizamos os operadores de compara¸caõ (<, <=, ==, !=, >= e >). Pode-se comparar duas strings de C++ ou uma string de C++ com uma string de c (uma cstring). • Em C++ o operador == verifica se duas strings s˜ ao iguais (se o conte´ udo é igual). Em Java este operador verifica se as duas strings s˜ ao a mesma (ocupam o mesmo espa¸co de memória). • O operador endere¸co (&) aplicado a s[0] n˜ ao é um ponteiro para o primeiro elemento da string. Isto é, a string n˜ ao tem um ponteiro para o primeiro elemento. Para manipula¸caõ avan¸cada de strings, utilize iteradores (veja Parte III - Introdu¸caõ à STL). • Se a string for redimensionalizada, possivelmente os iteradores existentes ir˜ ao apontar para um monte de lixo (iteradores s˜ ao descritos no Cap´ıtulo 31). • Observe que se uma string for muito grande, você pode quebr´ a-la no c´ odigo usando \. Exemplo: string s = "Releia o cap´ ıtulo com aten¸ c~ ao, cada linha e verifique \ como esta pode ser utilizada em seus programas"; Programa¸caõ Orientada a Objeto com C++



460

24.5


Vimos uma breve descri¸caõ da classe na se¸caõ 9.4.1, neste cap´ıtulo aprendemos novos métodos da classe . Discutimos os diferentes tipos de construtores, o uso de iteradores, operadores de acesso e operadores de compara¸caõ de strings. A classe tem um conjunto de métodos para manipula¸caõ do tamanho da string. Pode-se obter o tamanho utilizado com size() e a capacidade real da string com capacity(). Pode-se redimensionalizar a string com resize(). O método max_size() retorna o tamanho da maior string que pode ser constru´ıda. O método length() é definido para manter compatibilidade com vers˜ oes antigas da classe . Vimos o uso de substrings. No final do cap´ıtulo aprendemos a fazer pesquisas em uma com find(), rfind(). E ainda vimos o arquivo da biblioteca padr˜ ao. Nota: Os livros de C++ procuram explicar apenas parte das fun¸co˜es/métodos da biblioteca padr˜ ao. Isto se deve ` a necessidade de se limitar o n´ umero de p´ aginas dos livros. Se fôssemos incluir todos os métodos os livros passariam de 2000 p´ aginas. A dica é: para conhecer em detalhes determinada classe da biblioteca padr˜ ao, abra e leia o arquivo correspondente.

24.6

Exerc´ıcios

1. Monte um exemplo em que a lista de arquivos de um diret´ orio é armazenada em um arquivo de disco. A seguir pergunte para o usuário qual arquivo quer localizar. Depois abra o arquivo e use os métodos de para localizar e mostrar partes do arquivo que foi aberto. 2. Adicione ao programa anterior a possibilidade de renomear arquivos. 3. Adicione ao programa anterior a possibilidade de mudar a extensão dos arquivos. 4. Crie um programa que calcula o tamanho m´ınimo, máximo e médio dos arquivos em um determinado diret´ orio. 5. Criar um programa que recebe um arquivo de disco e calcula: o n´ umero de letras, palavras e frases. A freq¨ uência de ocorrência de cada letra (visualizar o histograma utilizando o programa gnuplot ). 6. Monte um programa que troque: ” ” por ” ”, ”¸c” por ”c”, ”ã” por ”a”. 7. Corrigir o exemplo da listagem 24.3, de forma que os arquivos que tenham espa¸co ” ” no nome possam ser convertidos corretamente. 8. Criar exemplo que use as diferentes vers˜ oes de: find(), rfind(), find_first_of() e find_first_not_of(). 9. Leia agora o arquivo /usr/include/c++/4.1.1/bits/basic string.h, da biblioteca padr˜ ao.



Cap´ıtulo 25

Convers˜ oes Neste cap´ıtulo mostraremos o prot´ otipo para convers˜ oes entre objetos (se¸caõ 25.1) e sua necessidade (se¸caõ 25.2). A seguir veremos o construtor de convers˜ ao (se¸caõ 25.3), o operador de convers˜ ao (se¸caõ 25.4) e o uso de explicit em construtores (se¸caõ 25.5). Discutiremos ainda a utiliza¸caõ de static_cast<> (se¸caõ 25.6), dynamic_cast<> (se¸caõ 25.7), const_cast<> (se¸caõ 25.8) e reinterpret_cast (se¸caõ 25.9). Finalmente veremos algumas senten¸cas para convers˜ oes (se¸caõ 25.10).

25.1

Prot´ otipo para convers˜ oes

Na vida real estamos o tempo todo adaptando os objetos para uso diferente do inicialmente projetado. Poder´ıamos citar milhares de casos, mas vamos mostrar apenas alguns poucos, bem comuns: • Você precisa de um abridor de latas, mas s´ o tem uma faca, o que você faz? – A resposta é simples e direta, usa a faca como abridor de lata. • Você precisa de uma chave de fenda, mas s´ o tem uma faca, o que você faz? – A resposta é simples e direta, usa a faca como chave de fenda. Quando temos um programa real nos deparamos com diversas situa¸co˜es onde precisamos utilizar um objeto para uma fun¸caõ ”alternativa”. De um modo geral, o objeto pode ser utilizado para uma fun¸caõ n˜ ao previamente planejada, desde que tenha funcionalidades semelhantes ao objeto a ser substitu´ıdo. Um caso usual de convers˜ oes é a convers˜ ao entre n´ umeros, de inteiro (int) para flutuante (float) e vice-versa. Outro exemplo é a convers˜ ao de classes-derivadas em classes-base. Veja a seguir o prot´ otipo para defini¸caõ e uso dos construtores de convers˜ ao e dos operadores de convers˜ ao. Ao longo deste cap´ıtulo os mesmos ser˜ ao detalhados. Prot´ otipo: class Base { // Declara¸ca õ de construtor com explicit (veja se¸ca õ 25.5) explicit Base (parˆ ametros); }; 461

˜ 25.2. NECESSIDADE DE CONVERSAO

462

class Derivada : public Base { // Construtor de convers˜ ao (veja se¸ca õ 25.3) // Cria objeto da classe-derivada a partir de objeto da classe-base Derivada(const Base& obj){}; // Declara¸ca õ de operador de convers˜ ao para classe-base (veja se¸ca õ 25.4) operator Base(); // Declara¸ca õ de operador de convers˜ ao, converte para outro tipo (veja se¸ca õ 25.4) operator Tipo(); }; // Defini¸ca õ do método de convers˜ ao Tipo Derivada::operator Tipo() { // Descri¸ca õ de como se processa a convers˜ ao return(Tipo); }; ... // Utiliza¸ca õ de static cast<> (veja se¸ca õ 25.6) Derivada der; Base base = static cast (der); // Utiliza¸ca õ de dynamic cast<> (veja se¸ca õ 25.7) Base* ptrBase = new Derivada; Derivada* ptrDerivada = dynamic cast (ptrBase); // Utiliza¸ca õ de referências e dynamic cast<> (veja se¸ca õ 25.7.1) Tipo& ref = dynamyc cast(r); õ 25.8) // Utiliza¸ca õ de const cast<> (veja se¸ca Tipo* ptr = const cast (const ptr);

25.2

Necessidade de convers˜ ao

Você já sabe que existe uma hierarquia de classes para os tipos numéricos e um sistema de convers˜ ao entre os diferentes tipos numéricos. Assim, um int pode ser convertido em double (sem perda de dados) e um double pode ser convertido em int (com poss´ıvel perda de dados). Da mesma forma, os tipos definidos pelo programador também podem ser convertidos, devendo o programador definir a forma como esta convers˜ ao deve ser realizada. Observe o seguinte exemplo: digamos que exista uma classe B e uma classe-derivada D, e que foi criado o objeto b1 do tipo B e o objeto d1 do tipo D. Criamos também os objetos b2, fazendo B b2 = d1; e um objeto b3, fazendo B b3 = b1;. Como a classe D é derivada da classe B, um objeto do tipo D pode ser convertido para B. Entretanto, n˜ ao é poss´ıvel criar um objeto do tipo D a partir de um objeto do tipo B, (fazendo D d2 = b1;), porque B é menor que D. A listagem 25.1 esclarece melhor esta situa¸caõ. Listing 25.1: Mostrando a necessidade de convers˜ oes. 1 2 3 4 5 6 7 8

// Define tipo B class B { public : int x ; }; // Define tipo D class D : public B



˜ 25.3. CONSTRUTOR DE CONVERSAO 9 10 11 12 13 14 15 16 17 18 19 20 21

463

{ public : int y ; }; int main () { B b1 ; D d1 ; B b2 = d1 ; B b3 = b1 ; D d2 = b1 ; return 0; }

// // // // //

Cria objeto do tipo B com nome b1 Cria objeto do tipo D com nome d1 Ok Ok Erro , b1 n~ a o p r e e n c h e d2 ( b1 n~ a o tem y ) .

n e c e s s i d a d e C o n v e r s a o . cpp : In function ’ int main () ’: n e c e s s i d a d e C o n v e r s a o . cpp :19: error : conversion from ’B ’ to non - scalar type ’D ’ requested

Na linha B b2 = d1; o c´ odigo funciona porque d1 tem os atributos x e y e o compilador faz b2.x = d1.x;. Na linha D d2 = b1; b1 s´ o tem o atributo x, e d2 precisa de um x e um y. Como b1 n˜ ao tem y, o compilador acusa o erro. A solu¸caõ para este tipo de problema é a utiliza¸caõ de construtores de convers˜ ao, descritos a seguir.

25.3

Construtor de convers˜ ao

Um construtor de convers˜ ao é utilizado para construir um objeto do tipo D a partir de um objeto do tipo B. Isto é, recebe um objeto do tipo base e constr´ oi um objeto do tipo derivado. Veja no exemplo a seguir que o construtor do objeto D, faz y = 0;. Exemplo: class D: public B { int y; // Construtor de convers~ ao, recebe um B e constr´ oi um D D(const& B obj) { this->x = obj.x; this->y = 0; } }; Com o construtor de convers˜ ao do exemplo acima, resolvemos o problema da linha D d2 = b1; preenchendo o valor de y com zero (this->y = 0;). Entretanto, se tivermos Programa¸caõ Orientada a Objeto com C++


˜ - CAST 25.4. OPERADOR DE CONVERSAO

464 B b; D d; d = b;

o objeto b e o objeto d j´ a foram criados. Neste caso é necess´ ario um método que converta o objeto b em d. Para solucionar este problema, utiliza-se um operador de convers˜ ao descrito na se¸caõ 25.4.

25.4

Operador de convers˜ ao - cast

Um operador de convers˜ ao é utilizado para converter um objeto de um tipo em outro. Observe que o método n˜ ao precisa ser da mesma hierarquia. O prot´ otipo é dado a seguir. Veja que o método operator Tipo(); deve converter de CNome para Tipo. Observe o uso da palavra-chave operator, seguida do nome do tipo a ser criado a partir de CNome. Prot´ otipo: class CNome {... // Declara¸ca õ de método de convers˜ ao operator Tipo(); }; No exemplo a seguir o operator B() é utilizado para converter um objeto do tipo B num objeto do tipo D. Note que para utilizar o método de convers˜ ao, podemos ter uma convers˜ ao impl´ıcita ou explicita. Exemplo: class D { public: int y; operator B() { B* b = new B(); b->x = this->x; return *b; } }; int main() { B b; D d; b = d; // b = (B) d; // // tico de C++ b = static_cast< return 0; }

// Converte da classe D para classe B // Cria objeto do tipo B // Preenche atributos do objeto b // Retorna objeto

Impl´ ıcita, converte de d para b Expl´ ıcita, com a utiliza¸ c~ ao de cast de d Expl´ ıcita, com a utiliza¸ c~ ao do cast est´ aB > (d);

Veremos o uso de static_cast< >(); na se¸caõ 25.6. Programa¸caõ Orientada a Objeto com C++


˜ EXPLICITA NOS CONSTRUTORES COM EXPLICIT 25.5. CONVERSAO

25.5

465

Convers˜ ao explicita nos construtores com explicit

Em algumas hierarquias as convers˜ oes ocorrem automaticamente. Se você n˜ ao quiser que isso ocorra, ou seja, quiser ter controle das convers˜ oes, utilize a palavra-chave explicit na declara¸caõ do construtor. Veja na listagem 25.2 exemplo de uso de construtor com explicit. Observe que na linha Saida(10); deveria ocorrer um erro, pois Saida() recebe como parˆ ametro um CData, e estamos passando um int. Mas como existe um construtor de CData que recebe um int, o compilador vai criar automaticamente um objeto CData e a seguir chamar Saida(). Observe na sa´ıda que ao trocar o construtor CData por explicit CData o compilador n˜ ao realiza a convers˜ ao autom´ atica e emite o erro de inicializa¸caõ incorreta. Veja na sa´ıda que quando o construtor n˜ ao usa explicit, a linha Saida(10); funciona, pois o compilador troca automaticamente a linha Saida(10); por Saida(CData(10)); ou seja, cria um CData a partir do n´ umero 10 e a seguir executa o método Saida(). Listing 25.2: Usando construtor com explicit. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# include < iostream > using namespace std ; class CData { public : int x ; // C o n s t r u t o r sem uso de e x p l i c i t CData ( int _x = 10) : x ( _x ) { }; // C o n s t r u t o r com uso de e x p l i c i t // e x p l i c i t CData ( int _x = 10) : x ( _x ) { } }; // Fun¸ c~ a o global , recebe um objeto do tipo CData void Saida ( const CData & dat ) { cout << dat . x << endl ; } int main () { int i = 5; CData data ( i ) ; cout << " Saida ( data ) ; " ; Saida ( data ) ; cout << " Saida ( 10 ) ; " ; Saida ( 10 ) ; return 0; }

// Cria CData // I m p r i m e data

Sa´ ı da sem uso de explicit : ------------------------bash -3.00 $ ./ a . out Saida ( data ) ; 5 Saida ( 10 ) ; 10



˜ ESTATICA ´ 25.6. CONVERSAO COM STATIC_CAST<>

466

Sa´ ı da com uso de explicit : ------------------------bash -3.00 $ g ++ Usando - explicit . cpp Usando - explicit . cpp : In function ’ int main () ’: Usando - explicit . cpp :37: error : invalid i n i t i a l i z a t i o n of reference of type ’ const CData & ’ from expression of type ’ int ’ Usando - explicit . cpp :19: error : in passing argument 1 of ’ void Saida ( const CData &) ’

25.6

Convers˜ ao est´ atica com static_cast<>

Na linguagem C uma vari´ avel int pode ser convertida para double usando-se cast. Exemplo: int x = 3; float y = (float) x; Neste exemplo o cast é o trecho de c´ odigo (float), que for¸ca a convers˜ ao de x do tipo int para float. ´ como se Note que o uso de cast subverte o controle de tipos realizados pelo compilador. E o programador dissece para o compilador ”fica tranquilo, eu sei o que estou fazendo”. Ou seja, a responsabilidade pelo uso do cast é toda do programador. Para implementar o conceito de cast em C++, usamos a palavra-chave static_cast<>. Veja prot´ otipo a seguir. Note que static_cast<> é utilizado para convers˜ oes de tipos em tempo de compila¸caõ. Se a convers˜ ao for ilegal, o compilador acusa o erro, o que n˜ ao é feito no cast de C. Prot´ otipo: TipoA obja; TipoB objb = static cast (obja); No exemplo a seguir, static_cast<> converte de float para double. Exemplo: float fpi = 3.141516; double dpi = static_cast(fpi);

25.7

Convers˜ ao dinˆ amica com dynamic_cast<>

Quando temos uma hierarquia de classes, podemos criar um ponteiro para a classe-base e fazer com que esse ponteiro aponte para um objeto de uma classe-derivada (veja Cap´ıtulo 19 Polimorfismo). Em algumas ocasiões é necess´ ario converter o ponteiro da classe-base em um ponteiro de classe-derivada. Isto é feito com o uso de cast dinˆ amico, um cast realizado em tempo de execu¸caõ e que utiliza a palavra-chave dynamic_cast<>. No prot´ otipo a seguir converte o ponteiro ptrBase para um ponteiro do tipo TipoDerivado. Funciona se TipoDerivado é derivado direta ou indiretamente do TipoBase, caso contr´ ario retorna uma exce¸caõ do tipo bad_cast (veremos exce¸co˜es no Cap´ıtulo 26 - Exce¸co˜es). Programa¸caõ Orientada a Objeto com C++


˜ DINAMICA ˆ 25.7. CONVERSAO COM DYNAMIC_CAST<>

467

Prot´ otipo: TipoBase* ptrBase; ptrBase = new TipoDerivado; TipoDerivado* ptr = dynamic cast (ptrBase); No exemplo a seguir, cria-se um ponteiro pm que aponta para um objeto TImagem (derivado). Posteriormente cria TImagem* im a partir de pm, utilizando dynamic_cast<>. Funciona porque o objeto criado e apontado por pm é um objeto do tipo TImagem. Exemplo: class TMatriz{}; // Classe-base class TImagem: public TMatriz{}; // Classe-derivada TMatriz* pm; // Ponteiro para classe-base pm = new TImagem(); // Aponta para objeto derivado .................... // pm ´ e usado // Converte pm para im usando dynamic_cast<> TImagem * im = dynamic_cast < TImagem* > (pm); Veja no exemplo da listagem 25.3 a utiliza¸caõ de dynamic_cast<>. Listing 25.3: Usando dynamic_cast e typeid. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// E x t r a ´ ı d o do HELP do B o r l a n d C ++ 5.0 e a d a p t a d o # include < iostream > # include < typeinfo > using namespace std ; class Base1 { virtual void f () }; class Base2 {};

// Base1 {

};

// Base2

// D e r i v a d a class Derivada : public Base1 , public Base2 { }; int main () { Derivada d ; // Cria objeto d Derivada * pd = 0; // P o n t e i r o para D e r i v a d a Base1 * pb1 = & d ; // P o n t e i r o para Base1 , aponta para objeto d cout << " Tipo do ponteiro resultante = " << typeid ( pb1 ) . name () << endl ; cout << " Realiza um cast din^ a mico ( downcast ) de Base1 para Derivada .\ n " ; if (( pd = d y n a m i c _ c a s t < Derivada * >( pb1 ) ) != 0) { cout << " Tipo do ponteiro resultante = " << typeid ( pd ) . name () << endl ; } // Fique atento a h i e r a r q u i a da classe . // Cast de uma classe B1 para D e depois de D para B2 . Base2 * pb2 = 0; cout << " Realiza um cast din^ a mico ( croscast ) de Base1 para Base2 . " << endl ; if (( pb2 = d y n a m i c _ c a s t < Base2 * >( pb1 ) ) != 0) {



˜ COM CONST_CAST<> 25.8. CONVERSAO

468 38 39 40 41 42

cout << " Tipo do ponteiro resultante = " << typeid ( pb2 ) . name () << endl ; } return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out Tipo do ponteiro resultante = P5Base1 Realiza um cast din^ a mico ( downcast ) de Base1 para Derivada . Tipo do ponteiro resultante = P8Derivada Realiza um cast din^ a mico ( croscast ) de Base1 para Base2 . Tipo do ponteiro resultante = P5Base2

Para uso do cast dinˆ amico é necess´ aria a passagem do parˆ ametro - RTTI para o compilador (leia informa¸co˜es de seu compilador). A sigla RTTI significa ”Run-Time Type Information”, ou seja, informa¸co˜es sobre os objetos criados em tempo de execu¸caõ. A utiliza¸caõ do RTTI e do dynamic_cast<> implica c´ odigos maiores e mais lentos.

25.7.1

dynamic_cast<> e referˆ encias

O dynamic_cast<> também pode ser utilizado com referências, veja o prot´ otipo. Se o dynamic_cast<> para uma referência falha, uma exce¸caõ do tipo bad_cast é lan¸cada. Veremos o uso de exce¸co˜es no Cap´ıtulo 26 - Exce¸co˜es. Prot´ otipo: Tipo& ref = dynamic cast< Tipo& >(r);

25.8

Convers˜ ao com const_cast<>

Quando o ponteiro é const, dynamic_cast<> e static_cast<> n˜ ao podem ser utilizados. Neste caso, você deve utilizar const_cast<>. Veja a seguir o prot´ otipo e um exemplo. Observe que o ponteiro ptr vai ser convertido para T*. Prot´ otipo: const T* constptr; T* ptr = const cast (constptr); Exemplo: void f(const T* constptr ) { T* ptr = const_cast (constptr ); .... }

25.9

Convers˜ ao com reinterpret_cast<>

A palavra-chave reinterpret_cast<> permite reinterpretar um cast. Veja exemplo na listagem 21.4. Note que com reinterpret_cast<> podemos for¸car qualquer tipo de convers˜ ao entre tipos (semelhante ao antigo cast de C). Prot´ otipo: T* p = reinterpret cast (ptr); Programa¸caõ Orientada a Objeto com C++


˜ 25.10. SENTENCAS ¸ PARA CONVERSOES

469

Exemplo: int main() { int a = 3; int* pa = &a; cout < < "pa=" < < *pa < < endl; // Imprime o caracter ! cout < < *reinterpret_cast(pa) < < endl; return 0; } Dica: n˜ ao use reinterpret_cast<>. Se em algum momento precisar dele é sinal de que sua modelagem esta com problemas.

25.10

Senten¸cas para convers˜ oes

• Lembre-se um cast subverte o sistema de verifica¸caõ de tipo, devendo ser evitado. • Convers˜ oes definidas pelo programador somente s˜ ao utilizadas implicitamente se forem n˜ ao amb´ıguas. • Um n´ umero inteiro com valor 0 é convertido para false. Qualquer n´ umero diferente de zero é convertido para true. • Métodos de convers˜ ao podem ser virtuais. • A biblioteca-padr˜ ao utiliza métodos de convers˜ ao. No exemplo a seguir o operador while espera um bool (0 ou != 0), enquanto a chamada a cin > > x;, for realizada corretamente; cin é convertido em true, se cin > > x; falha, cin é convertido em false. Exemplo: while( cin > > x ) cout < < "objeto :" < < x < < " lido."; • Tente ocultar do usu´ ario o uso de cast. • Segundo [Lischner, 2003], um lvalue é convertido automaticamente para rvalue, se o contexto requer um rvalue. • Um valor de uma enumera¸caõ é convertido automaticamente para int, mas um int n˜ ao é convertido automaticamente para uma enumera¸caõ. Para converter um int para uma enumera¸caõ usamos static_cast<>. Veja exemplo na listagem G.2. • Um método de convers˜ ao em uma classe-derivada n˜ ao oculta um método de convers˜ ao em uma classe-básica, a menos que os dois métodos convertam para o mesmo tipo. • Seja cauteloso com o uso de convers˜ oes impl´ıcitas, pois elas podem funcionar de modo inesperado. Ou seja, use explicit e evite surpresas. • Reduza o n´ umero de métodos construtores utilizando argumentos pré-definidos. • Com a palavra-chave explicit, o construtor s´ o ser´ a chamado de forma expl´ıcita. • Sempre testar o ponteiro ap´ os o dynamic_cast<>. Programa¸caõ Orientada a Objeto com C++



470

• Se o ponteiro for const, você deve utilizar const_cast<>. • Pode-se reduzir o uso de dynamic_cast<> (que é lento), incluindo-se na classe-base o método que desejamos acessar. • Se a classe destino for privada ou protegida, o dynamic_cast<> falha. • Observe que você n˜ ao deve usar RTTI com o tipo void*. • Prefira dynamic_cast<> a typeid(). • O tempo de processamento para verificar um dynamic_cast<> (ou typeid()) é maior que o usado para localizar um método virtual. • Se numa hierarquia você tiver classes duplicadas, bases virtuais acess´ıveis por mais de um caminho, deve verificar se o cast desejado n˜ ao é amb´ıguo. Se for amb´ıguo, o dynamic_cast<> retorna 0 (ou bad_cast). • Um cast para classe-derivada é chamado dowcast, e para classe-base upcast. • 3 Para converter da classe C para a classe H (sendo H n˜ ao herdeira de C), deve-se criar uma fun¸caõ de convers˜ ao dentro da classe C, e declarar como friend dentro de H. • 3 Convers˜ oes impl´ıcitas e fun¸co˜es friend n˜ ao podem ser criadas com referências simples (&). Exemplo: friend ...return X& ; // Erro // Mas podem ser criados para friend...return ...const X& ; friend....return...X;

25.11


Neste cap´ıtulo entendemos a necessidade das convers˜ oes. Aprendemos os diferentes prot´ otipos para realizar convers˜ oes entre objetos. Vimos que podemos realizar convers˜ oes com construtores e com métodos de convers˜ ao. Vimos ainda que o construtor de convers˜ ao pode ser utilizado para criar objetos novos a partir de objetos de diferentes tipos. Aprendemos a utilizar o operador de convers˜ ao para converter um objeto existente para outros tipos. Eliminamos as convers˜ oes autom´ aticas nos construtores com o uso de explicit. Aprendemos ainda a utilizar os operadores de convers˜ ao: static_cast<>, const_cast<> e reinterpret_cast<>. Aprendemos a criar um ponteiro para uma classe herdeira da classe-base a partir de um ponteiro para classe-base usando dynamic_cast<>.

25.12

Exerc´ıcios

1. Tente descrever exemplos práticos onde o uso de conversões é importante. 2. Implemente os exemplos da se¸caõ 25.2, e veja as mensagens de erro. 3. Modifique a listagem 25.2. Programa¸caõ Orientada a Objeto com C++


25.12. EXERCÍCIOS

471

4. Ampliar a hierarquia da listagem 25.3. 5. Monte um exemplo para convers˜ ao de moedas de diferentes pa´ıses.



472


25.12. EXERCÍCIOS


Cap´ıtulo 26

Exce¸ c˜ oes Neste cap´ıtulo apresentaremos os conceitos b´ asicos e a utiliza¸caõ de exce¸co˜es. Como fica a seq¨ uência de controle em um programa com exce¸co˜es. Iniciamos com uma introdu¸caõ ` as exce¸co˜es (se¸caõ 26.1). A seguir veremos o prot´ otipo para exce¸co˜es (se¸caõ 26.2), e seus conceitos b´ asicos de exce¸co˜es (se¸caõ 26.3), como o uso de try (se¸caõ 26.3.1), throw (se¸caõ 26.3.2) e catch (se¸caõ 26.3.3). Veremos ainda uma lista com as exce¸co˜es-padr˜ ao (se¸caõ 26.4). A seq¨ uencia de execu¸caõ do programa (se¸caõ 26.5), sem (se¸cão 26.5.1) e com exce¸caõ (se¸caõ 26.5.2). Como fica a pilha (heap) em um programa com exce¸co˜es (se¸caõ 26.6). O que ocorre com exce¸co˜es n˜ ao tratadas (se¸caõ 26.7)? Na se¸caõ uso avan¸cado de exce¸co˜es (se¸caõ 26.8) veremos temas como: exce¸caõ para new (se¸caõ 26.8.1), controlando entrada com exce¸co˜es (se¸caõ 26.8.1), e uma pol´ıtica para uso de exce¸co˜es(se¸caõ 26.8.1).

26.1

Introdu¸ c˜ ao ` as exce¸c˜ oes

A utiliza¸caõ de exce¸co˜es permite a constru¸caõ de programas mais robustos, com maior tolerˆ ancia a falhas. O exemplo da listagem 26.1 mostra um problema usual em programas, a divisão por zero. Observe na sa´ıda que o valor de c, de acordo com o padr˜ ao ANSI C++, é igual a inf, representando um valor muito grande (infinito). Listing 26.1: Exce¸co˜es: Divis˜ ao por zero. 1 2 3 4 5 6 7 8 9 10 11 12 13

// Uma d i v i s ~ a o por zero sem c o n t r o l e de erro # include < iostream > int main () { float a = 3.0; float b = 0.0; float c = a / b ; float d = c ; std :: cout << " a = " << a << " b = " << b << " c = a / b = " << c << " d = " << d << std :: endl ; return 0; }

[ a n d r e @ m e r c u r i o ] $ ./ a . out a =3 b =0 c = a / b = inf d = inf

473

´ ˜ 26.2. PROTOTIPO PARA EXCEC ¸ OES

474

A solu¸caõ usualmente adotada para resolver este problema é algo como apresentado na listagem 26.2. Observe que embora o programa n˜ ao tenha mais um bug, h´ a a necessidade de se criar um conjunto de flags e verifica¸co˜es adicionais. Listing 26.2: Exce¸co˜es: Divis˜ ao por zero com controle simples. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# include < iostream > using namespace std ; int main () { float a = 3.0; float b ; float c ;

// Uma d i v i s ~ a o por zero com c o n t r o l e de erro

cout << " Entre com b : " ; cin >> b ; cin . get () ; if ( b == 0 ) // c o n t r o l e cout << " Erro b == 0 " << endl ; else { c = a / b; cout << " c = a / b = " << c << endl ; } return 0; } bash -3.00 $ ./ a . out Entre com b :7 c = a / b = 0.428571 bash -3.00 $ ./ a . out Entre com b :0 Erro b == 0

De uma maneira geral, o controle de erros em um programa pode ser feito de duas formas. • No meio do c´ odigo (forma usual), controlando a entrada de dados e os fluxos do programa. Esta metodologia de controle deixa o c´ odigo mais confuso, pois o tratamento dos erros fica no meio do c´ odigo. • Utilizando as técnicas de tratamento de exce¸co˜es, que permitem uma formula¸caõ mais robusta para o tratamento e a verifica¸caõ de erros em um programa. O uso das técnicas de tratamento de exce¸co˜es é o foco deste cap´ıtulo.

26.2

Prot´ otipo para exce¸c˜ oes

Veja a seguir o prot´ otipo para uso de exce¸co˜es. Observe que o bloco try tenta executar um bloco de c´ odigo. Se neste bloco ocorrer algum problema, uma exce¸caõ é lan¸cada com throw. A exce¸caõ é capturada e tratada (processada) pelo bloco catch. Prot´ otipo: ... try { ... Tipo obj;... Programa¸caõ Orientada a Objeto com C++


´ ˜ 26.3. CONCEITOS BASICOS DE EXCEC ¸ OES

475

throw obj; } catch(Tipo & obj) { ...tratamento da exce¸ca õ... }

26.3

Conceitos b´ asicos de exce¸c˜ oes

Uma exce¸caõ é uma condi¸caõ excepcional que ocorre em um programa, o que exige um ´ composta basicamente de três elementos: tratamento especial. E • Um bloco try que contém o bloco de c´ odigo a ser executado (veja se¸caõ 26.3.1). • Uma ou mais chamadas a throw, anunciando que ocorreu a exce¸caõ. O throw lan¸ca uma exce¸caõ, lan¸ca um objeto que ser´ a capturado por um bloco catch (veja se¸caõ 26.3.2). • Um ou mais blocos catch, que s˜ ao respons´ aveis pelo tratamento das exce¸co˜es lan¸cadas com throw (veja se¸caõ 26.3.3). O exemplo da listagem 26.3 ilustra o processo. Neste exemplo inclu´ımos o tratamento de exce¸co˜es. Dentro do bloco try se b == 0, o programa lan¸ca uma exce¸caõ do tipo out_of_range. A exce¸caõ lan¸cada com throw é capturado pelo bloco catch(out_of_range). Observe que colocamos vários blocos catch. Ou seja, podemos lan¸car vários tipos de exce¸co˜es com throw e cada exce¸caõ lan¸cada deve ser capturada com o bloco catch correspondente (se¸caõ 26.3.3). Por exemplo, um throw domain_error; é capturado pelo catch (domain_error obj). Um throw out_of_range; é capturado pelo catch (out_of_range obj). Observe na sa´ıda que quando b == 0, o bloco catch (out_of_range obj) é executado. Listing 26.3: Exce¸co˜es: Divis˜ ao por zero com exce¸co˜es. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# include < iostream > # include < string > # include < exception > # include < stdexcept > using namespace std ; // Uma d i v i s ~ a o por zero com t r a t a m e n t o de e x c e ¸ c~ oes int main () { float a = 3.0; float b ; float c ; // Bloco try try { cout << " Entre com b : " ; cin >> b ; cin . get () ; if ( b == 0) // Lan¸ ca a exce¸ c~ a o do tipo o u t _ o f _ r a n g e throw o u t _ o f _ r a n g e ( " divis~ a o por zero " ) ; c = a / b; cout << " c = a / b = " << c << endl ; } // C a p t u r a e x c e ¸ c~ a o do tipo o u t _ o f _ r a n g e ( fora do i n t e r v a l o )




476 27 28 29 30 31 32 33 34 35 36 37

catch ( o u t _ o f _ r a n g e obj ) { cout << " Exce¸ ca ~ o o u t _ o f _ r a n g e : " << obj . what () << endl ; } // C a p t u r a e x c e ¸ c~ a o do tipo d o m a i n _ e r r o r ( erro de d o m ´ ınio) catch ( d o m a i n _ e r r o r obj ) { cout << " Exce¸ ca ~ o d o m a i n _ e r r o r : " << obj . what () << endl ;} // C a p t u r a q u a l q u e r tipo de exce¸ c~ a o , devendo , // por este motivo ser o ´ u ltimo catch . catch (...) { cout << " Ocorreu uma exce¸ ca ~ o diferentes de o u t _ o f _ r a n g e . " ; } return 0; } bash -3.00 $ ./ a . out Entre com b :1 c = a / b = 3 bash -3.00 $ ./ a . out Entre com b :0 Exce¸ ca ~ o o u t _ o f _ r a n g e : divis~ a o por zero

Veja a seguir a descri¸caõ dos três componentes de uma exce¸caõ, o uso de try (se¸caõ 26.3.1), throw (se¸caõ 26.3.2) e catch (se¸caõ 26.3.3)

26.3.1

try

Os blocos try podem lan¸car uma ou mais exce¸co˜es, lan¸cando diferentes tipos de objetos. Dentro do bloco try você pode lan¸car diretamente uma exce¸caõ com throw ou chamar métodos - que podem ser encadeados - e que em algum momento lancem uma exce¸caõ com throw. Exemplo: try { M1(); M1(){ M2(); M2(){ M3(); M3(){ throw

}; }; }; "erro"; };

// // // //

Tenta executar o bloco que chama M1() M1() chama M2() M2() chama M3() M3() lan¸ ca uma exce¸ c~ ao

• O lan¸camento de uma exce¸caõ por um método finaliza imediatamente a execu¸caõ do método, e chama o próximo bloco catch que recebe o tipo de objeto lan¸cado. • Observe que uma exce¸caõ permite a um método ter um retorno diferente do especificado, alterando a linha de execu¸caõ do programa (veja se¸caõ 26.6).

26.3.2

throw

O throw é usado para lan¸car um objeto, indicando que uma exce¸caõ ocorreu. O uso de throw é similar a chamada de um método. Se um método lan¸ca uma exce¸caõ com throw, você pode mudar sua declara¸caõ, incluindo as exce¸co˜es que podem ser lan¸cadas. A vantagem em se declarar os tipos de exce¸co˜es que um método pode lan¸car é que o compilador confere e impede que o método lance uma exce¸caõ n˜ ao declarada em seu prot´ otipo. Veremos exemplo na listagem 26.5. Prot´ otipo: retorno NomeMétodo(parˆ ametros) throw (tipoExce¸ca õ1, tipoExce¸ca õ2, ...); Exemplo: // Declara¸ c~ ao de m´ etodo informando a exce¸ c~ ao que pode ser lan¸ cada Programa¸caõ Orientada a Objeto com C++



477

void M1() throw (out_of_range& ob); // Declara¸ c~ ao de m´ etodo que pode lan¸ car mais de um tipo de exce¸ c~ ao void M2() throw (out_of_range& ob, string &s); • O throw funciona como um retorno multin´ıvel, visto que o retorno do método é diferente do especificado. • De um modo geral os objetos lan¸cados com throw s˜ ao const tipo&. • Disparar uma exce¸caõ com throw fora de um bloco try provoca o encerramento do programa, executando a fun¸caõ terminate(). Veja se¸caõ 26.7. • Uma exce¸caõ lan¸cada com throw é considerada tratada (encerrada), assim que entra no bloco catch. • A especifica¸caõ dos tipos de exce¸co˜es que podem ser lan¸cadas n˜ ao fazem parte da assinatura do método (verificada em tempo de compila¸caõ). Isto indica, que os mesmos s´ o s˜ ao considerados na execu¸caõ, devendo ser evitados.

26.3.3

catch

O catch é o tratador de exce¸co˜es. O bloco catch ir´ a capturar o objeto lan¸cado com throw e realizará os processamentos necess´ arios. Logo ap´ os o bloco try, você deve ter o bloco catch. • Como um bloco try pode lan¸car mais de um tipo de exce¸caõ, você pode ter mais de um bloco catch, um para cada tipo de objeto lan¸cado. Exemplo: // Captura exce¸ c~ ao do tipo string catch(string s) {......}; // Captura exce¸ c~ ao do tipo int catch(int i) {......}; // Captura exce¸ c~ ao do tipo domain_error (erro de dom´ ınio) catch (domain_error obj) { cout < < "Exce¸ c~ ao domain_error: " < < obj.what() < < endl;} // Captura exce¸ c~ ao do tipo invalid_argument (argumento inv´ alido) catch (invalid_argument obj) { cout < < "Exce¸ c~ ao invalid_argument: " < < obj.what() < < endl;} // Captura exce¸ c~ ao do tipo out_of_range (fora do intervalo) catch (out_of_range obj) { cout < < "Exce¸ c~ ao out_of_range: " < < obj.what() < < endl;} // Captura exce¸ c~ ao do tipo range_error (erro no intervalo) catch (range_error obj) { cout < < "Exce¸ c~ ao range_error: " < < obj.what() < < endl;} // Captura exce¸ c~ ao do tipo overflow_error (n´ umero muito grande) catch (overflow_error obj) { cout < < "Exce¸ c~ ao overflow_error: " < < obj.what() < < endl;} // Captura exce¸ c~ ao do tipo underflow_error (n´ umero muito pequeno) catch (underflow_error obj) { cout < < "Exce¸ c~ ao underflow_error: " < < obj.what() < < endl;} Programa¸caõ Orientada a Objeto com C++


˜ ˜ 26.4. EXCEC ¸ OES-PADR AO

478

// Trata qualquer tipo de exce¸ c~ ao (deve ser o ´ ultimo catch) catch(...) {......}; • Observe que o bloco catch s´ o é executado se tiver sido lan¸cada uma exce¸caõ com throw. • Se foi lan¸cado um objeto do tipo T, o bloco catch a ser executado é aquele que trata um objeto do tipo T. • Um grupo de tratamento catch se assemelha a um if..else encadeado. • Um catch pode receber um objeto, uma referência a um objeto, um objeto constante ou um ponteiro para um objeto. • Como um catch(...) trata qualquer tipo de exce¸caõ, este deve ser o u ´ ltimo catch. Observe ainda que como catch(...) n˜ ao recebe nenhum objeto, n˜ ao tem muita eficácia. • Dentro de um bloco catch, você pode relan¸car a exce¸caõ chamando apenas throw.

26.4

Exce¸ c˜ oes-padr˜ ao

Veremos a seguir algumas exce¸co˜es-padr˜ ao do C++. As mesmas est˜ ao listadas nos arquivos de cabe¸calho e (veja Figura 26.1). Estas exce¸co˜es s˜ ao lan¸cadas automaticamente pelo sistema. Por exemplo, se ocorre uma falha de aloca¸caõ uma exce¸caõ padr˜ ao do tipo bad_aloc é lan¸cada. Se o argumento de uma fun¸caõ é inválido, uma exce¸caõ invalid_argument é lan¸cada. Se uma opera¸caõ matemática gera um n´ umero muito grande, uma exce¸caõ do tipo overflow_error é lan¸cada. Ou seja, C++ tem um conjunto de exce¸co˜espadr˜ ao, quando a falha ocorre, a exce¸caõ é lan¸cada. • Exce¸co˜es: bad_alloc (falha aloca¸caõ), bad_cast (falha convers˜ ao), bad_typeid (falha verifica¸caõ de tipo), bad_exception (falha de exce¸caõ). • Para indicar erros l´ ogicos: invalid_argument (argumento inválido), lenght_error (dimensão errada), out_of_range (fora do intervalo), domain_error (fora do dom´ınio). • Para indicar erros em tempo de execu¸caõ: overflow_error (n´ umero muito grande), underflow_error (n´ umero muito pequeno), range_error (erro em opera¸co˜es matemáticas). Observe que as exce¸co˜es padr˜ ao formam uma hierarquia. Da mesma forma, você pode criar hierarquias de classes que far˜ ao o tratamento das exce¸co˜es lan¸cadas. Assim, o c´ odigo para tratamento de erro pode ser reaproveitado. Outra vantagem é que a declara¸caõ do método que lan¸ca a exce¸caõ pode conter apenas a classe base da hierarquia de exce¸co˜es, veja o prot´ otipo. Prot´ otipo: retorno NomeMétodo(parˆ ametros) throw (nomeClasseBase);

26.5

Sequ ao ¨ encia de execu¸c˜

A seq¨ uência de execu¸caõ do programa pode ser normal, isto é, sem ocorrência de exce¸co˜es (se¸caõ 26.5.1) ou com ocorrência de exce¸caõ (se¸caõ 26.5.2). Programa¸caõ Orientada a Objeto com C++


26.6. COMO FICA A PILHA (HEAP)

479

Figura 26.1: Hierarquia de exce¸co˜es-padrao. exception +

logic_error +

bad_alloc +

bad_cast +

bad_exception +

bad_typeid +
ios_base::failure +

out_of_range +

lenght_error +

invalid_argument +

underflow_error +

26.5.1

domain_error +

overflow_error +

runtime_error +

range_error +

Sequ ao sem exce¸c˜ ao ëncia de execu¸c˜

No exemplo ilustrado na Figura 26.2, quando n˜ ao ocorre nenhuma exce¸caõ, a seq¨ uência executada é dada pelo ´ıtem (a). Observe que como n˜ ao ocorre a exce¸caõ, isto é, a linha throw B; n˜ ao é executada. Depois do bloco try, o programa executa a linha que segue o u ´ ltimo bloco catch, ou seja, “restante do c´ odigo”.

26.5.2

Sequ ao com exce¸c˜ ao ëncia de execu¸c˜

No caso em que ocorre uma exce¸caõ a seq¨ uencia de execu¸caõ é modificada, veja o ´ıtem (b) da Figura 26.2. Observe que como ocorre a exce¸caõ do tipo B, isto é, a linha throw B; é executada. O bloco try é encerrado na linha em que ocorre o throw, a seguir é executado o bloco catch (B) e depois a seq¨ uencia continua em restante do c´ odigo.

26.6

Como fica a pilha (heap)

Quando uma exce¸caõ é lan¸cada, os objetos locais criados dentro do bloco try e os objetos dinâmicos alocados com auto_ptr1 s˜ ao destru´ıdos. A seguir, o próximo catch que trata a exce¸caõ lan¸cada é executado. Se este catch n˜ ao existe no escopo do try que lan¸cou a exce¸caõ, todas as demais chamadas de métodos que est˜ ao penduradas na pilha e que foram inclu´ıdas neste bloco try s˜ ao desempilhadas (desconsideradas). Releia o par´ agrafo anterior e veja que faz sentido, pois se houve problemas no bloco try, suas subrotinas devem ser descartadas. Veja no exemplo da listagem 26.4 que a classe Teste tem três métodos: M1(), M2(), M3(). Observe que M1() chama M2() e que M2() chama M3(). 1 Veremos

o uso de auto_ptr na se¸ca õ F.5.



480


Figura 26.2: Seq¨ uência de execu¸caõ sem exce¸caõ (a) e com exce¸caõ (b). (a) Seqüência de execução sem exceção.

exceção = false; int main() { try { ..diversos.. if(exceção) trow B; ... } catch(A) {...} catch (B) {...} catch (C) {...} restante do código... ... }


(b) Seqüência de execução com exceção.

exceção = true; int main() { try { ..diversos.. if(exceção) trow B; ... } catch(A) {...} catch (B) {...........} catch (C) {...} restante do código... ... }



481

Observe que dentro de main(), n˜ ao existe uma linha throw, a linha com throw fica dentro de M3(). Veja na sa´ıda a execu¸caõ com e sem exce¸caõ. Observe que quando o usuário selecionou a op¸caõ 0, sem exce¸caõ, a seq¨ uência executada é a normal. Quando o usuário seleciona a op¸caõ 1, a exce¸caõ é lan¸cada dentro de M3(), n˜ ao retornando para M3(), M2() e M1() (n˜ ao escreve ”Fim M3”, ”Fim M2”, ”Fim M1”). Ou seja, os retornos dos métodos M3(), M2() e M1() s˜ ao retirados da pilha e desconsiderados. Listing 26.4: Exce¸co˜es e desempilhamento. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

# include < iostream > # include < stdexcept > # include < string > using namespace std ; class Teste { public : void M3 ( int resp ) { cout << " In´ ı cio M3 . " << endl ; if ( resp == 1) throw ( string ( " M´ e todo 3 " ) ) ; cout << " Fim M3 . " << endl ; } void M2 ( int resp ) { cout << " In´ ı cio M2 . " << endl ; M3 ( resp ) ; cout << " Fim M2 . " << endl ; } void M1 ( int resp ) { cout << " In´ ı cio M1 . " << endl ; M2 ( resp ) ; cout << " Fim M1 . " << endl ; } }; int main () { int resp ; cout << " \ nDeseja executar sem exce¸ ca ~ o (0) ou com exce¸ ca ~ o (1) : " ; cin >> resp ; cin . get () ; Teste obj ; try { obj . M1 ( resp ) ; } catch ( string s ) { cout << " \ nOcorreu Exce¸ ca ~ o no M´ e todo : " << s << endl ; } return 0; } [ b u e n o @ l d s c 0 5 ] $ ./ a . out Deseja executar sem exce¸ ca ~ o (0) ou com exce¸ ca ~ o (1) :0 In´ ı cio M1 .



˜ ˜ TRATADAS 26.7. EXCEC ¸ OES NAO

482 In´ ı cio M2 . In´ ı cio M3 . Fim M3 . Fim M2 . Fim M1 .

[ b u e n o @ l d s c 0 5 ] $ ./ a . out Deseja executar sem exce¸ ca ~ o (0) ou com exce¸ ca ~ o (1) :1 In´ ı cio M1 . In´ ı cio M2 . In´ ı cio M3 . Ocorreu Exce¸ ca ~ o no M´ e todo : M´ e todo 3

26.7

Exce¸ c˜ oes n˜ ao tratadas

As exce¸co˜es n˜ ao tratadas terminam a execu¸caõ do programa. Quando uma exce¸caõ é lan¸cada e n˜ ao capturada, as seguintes fun¸co˜es s˜ ao executadas: unexpected(), que chama terminate(), que chama abort(), que finaliza o programa. Você pode criar suas próprias fun¸co˜es unexpected() e terminate(), e substituir as default com as fun¸co˜es set_terminate() e set_unexpected(). Veja o exemplo a seguir. Exemplo: // Cria uma fun¸ c~ ao sem retorno e sem par^ ametro void minhaFuncaoTerminate() { std::cerr < < "Programa encerrado, a exce¸ c~ ao n~ ao foi capturada\n"; }; // Define como terminate set_terminate(minhaFuncaoTerminate); Veja exemplo na listagem 26.5. Observe que a fun¸caõ Teste(), lan¸ca uma exce¸caõ n˜ ao declarada. Comprovando que o controle das exce¸co˜es lan¸cadas é feito em tempo de execu¸caõ e n˜ ao de compila¸caõ. Listing 26.5: Usando set_unexpected() e set_terminate(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# include < iostream > # include < exception > # include < stdexcept > using namespace std ; // Fun¸ c~ a o de teste da lista de e x c e ¸ c~ oes void Teste () throw ( string ) { throw 5; // N~ ao inclu´ ı d a na l i s t a g e m de throw , vai chamar u n e x p e c t e d } void M i n h a F u n c a o U n e x p e c t e d () { cerr << " Minha fun¸ ca ~ o unexpected foi chamada porque Teste () \ n " << " lan¸ c a uma exce¸ ca ~ o n~ a o inclu´ ı da em sua lista .\ n " ; } void M i n h a F u n c a o T e r m i n a t e () { cerr << " Minha fun¸ ca ~ o terminate foi executada .\ n " ; }



˜ 26.8. EXCEC ¸ OES - USO AVANCADO ¸ 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

483

int main () { cout << " Este programa compila , mas ocorre um erro na execu¸ ca ~ o .\ n " << endl ; // Posso d e f i n i r a fun¸ c~ a o u n e x p e c t e d a ser e x e c u t a d a . u n e x p e c t e d _ h a n d l e r old = s e t _ u n e x p e c t e d ( M i n h a F u n c a o U n e x p e c t e d ) ; // Posso d e f i n i r a fun¸ c~ a o t e r m i n a t e a ser e x e c u t a d a set_terminate ( MinhaFuncaoTerminate ); try {

// Inicia bloco try

Teste () ; } catch ( string ) { cerr << " Exce¸ ca ~ o para string ocorreu . " ; } cout << " fim do programa " ; return 0; } Este programa compila , mas ocorre um erro na execu¸ ca ~o . Minha fun¸ ca ~ o unexpected foi chamada porque Teste () lan¸ c a uma exce¸ ca ~ o n~ a o inclu´ ı da em sua lista . Minha fun¸ ca ~ o terminate foi executada . Abortado

26.8

Exce¸ c˜ oes - Uso avan¸cado

Veremos nesta se¸caõ o uso avan¸cado de exce¸co˜es.

26.8.1

Exce¸c˜ ao para new2

O operador new foi apresentado na se¸caõ 15.3.1 e a sobrecarga de new na se¸caõ 21.8. De uma maneira geral new tenta alocar a memória solicitada; Nas vers˜ oes antigas de C++, quando new falhava retornava o ponteiro 0 (NULL) . Nos novos compiladores (Ansi C++), quando new falha, em vez de retornar 0, lan¸ca uma exce¸caõ do tipo bad_alloc (throw(bad_alloc)). Se o programa n˜ ao tiver tratamento para exce¸caõ lan¸cada, o mesmo é encerrado (veja se¸caõ 26.7). Veja na listagem 26.6 um exemplo. O programa define uma estrutura s. A seguir, dentro de main(), cria um vetor. No bloco do for infinito, aloca uma estrutura dinamicamente e acrescenta-a ao vetor. Quando a mem´ oria de seu computador terminar, ocorre uma exce¸caõ do tipo bad_alloc, e o bloco catch (bad_alloc) é executado. Note que a sa´ıda depende da quantidade de mem´ oria de seu computador. Listing 26.6: Exce¸caõ para new. 1 2 3 4 5 6 7

# include < iostream > # include < new > # include < vector > # include < stdexcept > using namespace std ; // Define uma e s t r u t u r a



˜ 26.8. EXCEC ¸ OES - USO AVANCADO ¸

484 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

struct S { int indicador [50000]; double valor [50000]; }; int main () { vector < S > v ; try {

// Cria vetor para a r m a z e n a r // e s t r u t u r a s do tipo S // Uso de try

long int i = 0; for (;;) // Um for i n f i n i t o { S * ptr_s = new S () ; // Aloca m e m ´ oria v . push_back (* ptr_s ) ; // A d i c i o n a no vetor cout << " \ nv [ " << i << " ] alocada " << endl ; i ++; } } catch ( bad_alloc erro ) // T r a t a m e n t o de erro { cout << " \ nExce¸ ca ~ o " << erro . what () << endl ; } } ... v [8190] alocada v [8191] alocada Exce¸ ca ~o St9bad_alloc

Se quiser desativar a chamada da exce¸caõ para new, use a palavra-chave nothrow. Exemplo: S* ptrS = new (nothrow) S(); Você pode criar uma fun¸caõ f() para tratar a aloca¸caõ com new, esta deve receber e retornar um void e pode ser ativada com set_new_handler(f). Como você redefiniu o tratamento para new, a exce¸caõ para new deixa de ser lan¸cada e sua fun¸caõ f() é executada.

26.8.2

Controlando entrada com exce¸c˜ oes2

No exemplo da listagem 26.7, usamos exce¸co˜es para controle da entrada e sa´ıda de dados. Observe que ativamos as exce¸co˜es para erros com cin e cout. Isto é, se ocorrer um erro de entrada/sa´ıda, uma exce¸caõ ser´ a lan¸cada e tratada. Observe na sa´ıda que as palavras aparecem ordenadas. Nota: o uso de map ser´ a descrito no Cap´ıtulo 34 - Os Containers Associativos , , e . Um map armazena uma chave e um valor. Neste exemplo usamos a palavra como um ´ındice que é utilizado para acessar o map e a seguir incrementar o contador associado a palavra. Listing 26.7: Usando exce¸co˜es para controle de entrada e sa´ıda. 1 2 3

// C o n t r o l e de e n t r a d a e saida ( p r o b l e m a s de I / O ) // A d a p t a d o de C ++ in a n u t s h e l l # include < algorithm >



˜ 26.8. EXCEC ¸ OES - USO AVANCADO ¸ 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

# include # include # include # include # include # include

485

< cstddef > < exception > < iostream > < map > < string > < utility >

void Saida ( const std :: pair < std :: string , std :: size_t >& p ) { std :: cout < contador ; cin . exceptions ( ios_base :: badbit ) ; cout . exceptions ( ios_base :: badbit ) ; while ( cin >> palavra ) ++ contador [ palavra ]; ~ d a === " << endl ; cout << " ==== S a A for_each ( contador . begin () , contador . end () , Saida ) ; } catch ( ios_base :: failure & ex ) { std :: cerr << " Erro de E / S : " << ex . what () << ’\ n ’; return 1; } catch ( exception & ex ) { std :: cerr << " Erro fatal : " << ex . what () << ’\ n ’; return 2; } catch (...) { A o diferente de failure e exception : Disastre toral .\ n " std :: cerr << " E x c e ~ A ~ ; return 3; } return 0; } O uso de exce¸ co ~ es e de controle de entrada e sa´ ı da facilita o d e s e n v o l v i m e n t o de softwares amig´ a veis e a prova de erro . O 1 a 1 amig´ a veis 1 controle 1 de 5 desenvolvimento 1 e 3 entrada 1 erro . 1 exce¸ co ~ es 1 facilita 1



˜ 26.9. SENTENCAS ¸ PARA EXCEC ¸ OES

486 o 1 prova 1 sa´ ı da 1 softwares uso 1

26.8.3

1

Adotando uma pol´ıtica para uso de exce¸c˜ oes2

´ preciso adotar uma pol´ıtica clara para uso de tratamento de exce¸co˜es e esta pol´ıtica deve E ser respeitada pela equipe de desenvolvimento. Veja a seguir dicas de [Sutter, 2006], para uma pol´ıtica de exce¸co˜es: • ”Determine uma pol´ıtica global de tratamento de erro para sua aplica¸ca õ ou subsistema e a mantenha”. – Informe o tipo de erro. – Defina como vai ser a propaga¸caõ dos erros. – Defina como ser´ a o tratamento do erro (API). • ”Escreva throw nos lugares que detectar um erro e n˜ ao puder lidar com ele”. • ”Escreva try ou catch nos lugares que tem conhecimento suficiente para tratar o erro”. Finalmente é bom lembrar que todo sistema de controle de erro deve ser amplamente documentado. O que inclui ´ıtens como o que? porque? como? quando?

26.9

Senten¸cas para exce¸c˜ oes

• Somente utilize exce¸caõ para casos cr´ıticos; evite sua utiliza¸caõ como mais um mecanismo de programa¸caõ. • Uma exce¸caõ n˜ ao resolve os destinos do seu programa; esta tarefa ainda é sua. • Os métodos para tratamento de exce¸co˜es e aqueles de tomada de decis˜ ao devem ser separados do c´ odigo numérico. • Observe que em um sistema tradicional de tratamento de erros, as instru¸co˜es de tratamento de erro ficam misturadas no c´ odigo. Com o uso de try, throw e catch, você separa a a´rea do c´ odigo da ´ area de tratamento de erros. • Depois de um bloco try ou catch n˜ ao coloque o ; (ponto-e-v´ırgula). • A seq¨ uência dos catchs deve respeitar a hierarquia das classes. Preste aten¸caõ no exemplo a seguir, o catch da classe-derivada deve vir antes do da classe-base. Exemplo: // Errado catch(Base b) {...} catch(Derivada1 d1) catch(Derivada2 d2) // Correto catch(Derivada2 d2) catch(Derivada1 d1) catch(Base b) {...}

{...} {...} {...} {...}



˜ 26.9. SENTENCAS ¸ PARA EXCEC ¸ OES

487

• Uma fun¸caõ/método declarada com throw é uma fun¸caõ/método que n˜ ao lan¸ca exce¸co˜es. • Se um bloco de c´ odigo pode estar gerando uma exce¸caõ, coloque-o dentro de um bloco try. • Dentro de um método, você pode declarar objetos locais, que ser˜ ao eliminados quando do encerramento do método. Mas se dentro do método for lan¸cada uma exce¸caõ com throw, o método n˜ ao termina e os objetos locais n˜ ao ser˜ ao eliminados. Para resolver este problema, deve-se ativar a op¸caõ RTTI do compilador, que assegura que os objetos locais tenham seus destrutores chamados. • Mesmo ativando a op¸caõ RTTI, somente os objetos locais que n˜ ao s˜ ao dinâmicos s˜ ao destru´ıdos. Objetos dinˆ amicos devem ser destru´ıdos antes do lan¸camento da exce¸caõ, pelo programador, ou devem ser criados usando auto_ptr<> veja se¸caõ F.5. • Você pode lan¸car uma exce¸caõ dentro de um construtor; se esta ocorrer, os demais objetos n˜ ao s˜ ao criados, deixando de ser destru´ıdos. • Se throw lan¸ca um const, catch deve capturar um const. • Pode-se construir sequênciar try...catch,...,try...catch.. • Se você dispara com um throw um ponteiro ou referência de um objeto do tipo A, esta deve ser capturada por um catch que recebe um ponteiro ou referência do tipo A. Por isso, você conclui que um catch (void*) captura todos os lan¸camentos de ponteiros e deve ser o u ´ ltimo deste tipo. • Um bloco try praticamente n˜ ao apresenta custo computacional, mas o lan¸camento de uma exce¸caõ com throw tem um custo de performance elevado, [Lischner, 2003]. • Segundo [Meyers, 2005], um método/fun¸caõ seguro deve garantir: – Se ocorrer uma exce¸caõ todo o restante do programa continua num estado válido (n˜ ao ocorreram corrup¸co˜es de dados). – Uma garantia forte promete que se uma exce¸caõ é lan¸cada, o estado do programa n˜ ao é alterado. Ou seja, a chamada a fun¸caõ/método é um processo atômico, no sentido de que se ocorrer sucesso, o mesmo é completo, e se ocorrer um fracasso, o programa n˜ ao é alterado (como se a fun¸caõ nunca tivesse sido chamada). • Um construtor pode incluir um bloco try, veja no exemplo a seguir o prot´ otipo: Exemplo: CNomeClasse(par^ ametros) try : atributo1(valor1),atributo2(valor2),... { ...c´ odigo do construtor... } catch () {... } • A diferen¸ca entre as fun¸co˜es exit() e abort(), é que abort() emite uma mensagem de erro. Programa¸caõ Orientada a Objeto com C++



488 • Um destrutor n˜ ao deve lan¸car exce¸co˜es.

• Embora um método possa informar quais ser˜ ao as exce¸co˜es que podem ser lan¸cadas em tempo de execu¸caõ, isto deve ser evitado. O motivo é simples, esta verifica¸caõ n˜ ao é feita em tempo de compila¸caõ mas em tempo de execu¸caõ. Ent˜ ao, para ter mais robustes no seu c´ odigo, evite o uso da declara¸caõ da exce¸caõ que pode ser lan¸cada. Para maiores detalhes, consulte [Sutter, 2006]. • Evite usar new (nothrow). • Segundo [Sutter, 2006], em sistemas operacionais modernos, que utilizam memória virtual, a verifica¸caõ da aloca¸caõ ap´ os o uso de new tem pouco sentido prático, pois, geralmente, o sistema tem mem´ oria. Ou ir´ a travar, antes de new retornar um bad_alloc, em fun¸caõ do excesso de pagina¸caõ. [Sutter, 2006] parte do princ´ıpio de que as falhas na aloca¸caõ com new s˜ ao raras. De um modo geral o problema esta em definir o que ser´ a feito se o sistema n˜ ao tem mais mem´ oria. • Note que a afirma¸caõ acima n˜ ao tem sentido quando falamos de programa¸caõ cient´ıfica. • 3 N˜ ao é poss´ıvel criar um ponteiro para uma fun¸caõ que tenha a informa¸caõ do tipo de exce¸caõ a ser lan¸cada usando-se typedef. Mas é poss´ıvel criar o ponteiro diretamente, sem o typedef. Veja o exemplo. Exemplo: typedef void (*pf)()throw(C1,C2,..); // Erro void (*pf)()throw(C1,C2,..); // ok pf = f; // ok • Veja na se¸caõ ?? a utiliza¸caõ da instru¸caõ assert.

26.10


A quest˜ ao do tratamento de exce¸co˜es esta diretamente associada ao controle da execu¸caõ do programa. O que fazer quando o usu´ ario entra com um dado errado? o que fazer se a memória do sistema acabou? o que fazer se um dispositivo, como o disco r´ıgido come¸ca a apresentar problemas? Vimos que o controle das exce¸co˜es pode ser feito no meio do c´ odigo, método antigo, ou utilizando o conceito de exce¸co˜es, método novo. A vantagem do uso de exce¸co˜es é que o tratamento das condi¸co˜es de erro é separado do processamento normal, além disso, a biblioteca padr˜ ao já fornece um conjunto de classes para os tratamentos mais comuns de erros. Iniciamos o cap´ıtulo com uma introdu¸caõ ` as exce¸co˜es. Vimos os conceitos b´ asicos de exce¸co˜es , o uso de try, throw e catch. A seq¨ uencia de execu¸caõ do programa, com e sem exce¸co˜es. Como fica a pilha (heap). O que ocorre com exce¸co˜es n˜ ao tratadas, exce¸caõ para new e uma lista com as exce¸co˜es-padr˜ ao. Dica: releia os exemplos apresentados com aten¸caõ, e veja que o uso de exce¸co˜es é simples.

26.11

Exerc´ıcios

1. Qual a vantagem do uso de exce¸co˜es? Programa¸caõ Orientada a Objeto com C++


26.11. EXERCÍCIOS

489

2. No seu cotidiano, qual tipo de programa pode se beneficiar do uso de exce¸co˜es? 3. Acrescentar a listagem 26.1 ocorrências de outros tipos de erros. 4. Reveja o exemplo da listagem 22.7. 5. Modifique a listagem 26.3, acrescentando novos tipos de lan¸camentos com throw. 6. Na listagem 26.4 coloque um coment´ ario no bloco catch e veja o que acontece. 7. Acrescentar no exerc´ıcio anterior uma fun¸caõ terminate() (veja se¸caõ 26.7). 8. Monte exerc´ıcio que use set_new_handler(f). 9. Modifique as listagens da se¸caõ 19.6, acrescentando o uso de exce¸co˜es. 10. Modifique a listagem 26.6, substituindo S *ptr_s = new S(); por S* ptr_s = new (nothrow) S();. 11. Na listagem 26.5, modifique as fun¸co˜es MinhaFuncaoUnexpected() e MinhaFuncaoTerminate(). 12. Modifique a listagem 26.6, retire a linha try() e veja o que acontece. 13. No exerc´ıcio anterior, acrescente uma fun¸caõ f() para tratar a aloca¸caõ com new usando set_new_handler(f).



490


26.11. EXERCÍCIOS


Cap´ıtulo 27

Templates ou Gabaritos Os conceitos mais u ´ teis e extraordin´ arios de C++ s˜ ao os de classes, de polimorfismo e de templates. Veremos neste cap´ıtulo o conceito e uso de templates. Veremos uma introdu¸caõ aos templates (gabaritos) (se¸caõ 27.1), e a seguir: • Fun¸co˜es templates (se¸caõ 27.2): o prot´ otipo para fun¸co˜es templates (se¸caõ 27.2.1), a instancia¸caõ e dedu¸caõ de argumentos (se¸caõ 27.2.2), a declara¸caõ expl´ıcita de fun¸caõ template (se¸caõ 27.2.3), como resolver problemas de convers˜ oes (se¸caõ 27.2.4), como implementar a sobrecarga de fun¸caõ template (se¸caõ 27.2.5), como criar objetos est´ aticos dentro de uma fun¸caõ template (se¸caõ 27.2.6). • Classes templates ou tipos paramétricos (se¸caõ 27.3): o prot´ otipo para classes templates (se¸caõ 27.3.1), regras gerais para classes templates (se¸caõ 27.3.2), e o uso de argumentos pré-definidos em classes templates (se¸caõ 27.3.3). • No final do cap´ıtulo veremos algumas senten¸cas para templates (se¸caõ 27.4) e alguns exerc´ıcios. No próximo cap´ıtulo veremos: • Uso avan¸cado de fun¸co˜es template (se¸caõ 28.1): especializa¸caõ de fun¸co˜es template (se¸caõ 28.1.1), o que s˜ ao fun¸co˜es expandidas em tempo de compila¸caõ (se¸caõ 28.1.2), como mapear fun¸co˜es template utilizando especializa¸co˜es (se¸caõ 28.1.4), uso de typename com templates (se¸caõ 28.1.3). • Uso avan¸cado de classes template (se¸caõ 28.2): templates dentro de classes template (se¸caõ 28.2.1), como especializar classes (se¸caõ 28.2.2). Nota: veremos neste cap´ıtulo que a constru¸caõ de fun¸co˜es e classes templates podem incluir parˆ ametros a serem definidos em tempo de compila¸caõ. Como as fun¸co˜es e métodos também tem seus próprios parˆ ametros, a palavra parˆ ametro teria dois usos semelhantes conceitualmente mas diferentes do ponto de vista da implementa¸caõ. Para facilitar o entendimento e a diferencia¸caõ dos parˆ ametros de templates dos parˆ ametros de uma fun¸caõ/método, vamos utilizar a seguinte nomenclatura: Parˆ ametro Refere-se aos parˆ ametros de um método/fun¸caõ, passados dentro de (). Argumento Refere-se ao argumento de um template, definido em tempo de compila¸caõ, passado dentro de <>. 491

˜ AOS TEMPLATES (GABARITOS) 27.1. INTRODUC ¸ AO

492

27.1

Introdu¸ c˜ ao aos templates (gabaritos)

No Cap´ıtulo 14 - Sobrecarga de Métodos, verificamos que a sobrecarga permite criar métodos com mesmo nome para manipular diferentes tipos de argumentos: Exemplo: float f(float x) int f(int x) double f(double x)

{ return ( x*x ); } { return ( x*x ); } { return ( x*x ); }

Observe como as fun¸co˜es s˜ ao semelhantes; a u ´ nica diferen¸ca s˜ ao os tipos dos parˆ ametros e do retorno que est˜ ao sendo tratados. No exemplo, o programador cria a fun¸caõ f() para float, depois para int e double. O ideal seria escrever uma fun¸caõ genérica da forma: Tipo

f(Tipo x)

{ return ( x*x ); }

Fun¸co˜es template de C++ funcionam exatamente assim. Uma fun¸caõ template é uma fun¸caõ definida para um (ou mais) tipo(s) genérico(s) em tempo de compila¸caõ. No exemplo anterior, se a fun¸caõ f() for chamada tendo como parˆ ametro um int, o compilador cria uma fun¸caõ f() para int; se o parˆ ametro for double, o compilador cria uma fun¸caõ f() para double, e assim por diante. Ou seja, o compilador ir´ a gerar uma c´ opia da fun¸caõ f() para cada tipo para a qual ela venha a ser chamada. As fun¸co˜es template (ou gabaritos de C++) possibilitam a constru¸caõ de algor´ıtmos com c´ odigo independente do tipo de dado a ser manipulado (Ornellas et all. (2002)). Segundo o mesmo autor, “O principio de trabalho dos gabaritos é fornecer um modelo de algor´ıtmo que é automaticamente replicado pelo compilador, em tempo de compila¸ca õ, de forma a gerar todas as instˆ ancias da fun¸ca õ necess´ arias para atender todas as chamadas realizadas”. Assim, podemos definir que um template é um gabarito para cria¸caõ - em tempo de compila¸caõ - de classes e fun¸co˜es como instâncias do template. A programa¸caõ usando o conceito de templates é conhecida como programa¸caõ genérica ou metaprograma¸caõ, [Lischner, 2003].

27.2

Fun¸ c˜ oes templates

Nesta se¸caõ veremos como implementar o conceito de fun¸cões template.

27.2.1

Prot´ otipo para fun¸c˜ oes templates

Veja a seguir o prot´ otipo para fun¸co˜es templates. Observe na linha anterior à declara¸caõ do nome da fun¸caõ, que colocamos a palavra-chave template, seguida de <, a palavra-chave typename, os tipos genéricos (Tipo1, Tipo2,..,Tipon) e >. Estes elementos criam os tipos genéricos Tipo1, Tipo2,..., Tipon, que ser˜ ao utilizados dentro do bloco da fun¸caõ template. Prot´ otipo: template Tipoi NomeFun¸ca õ(Tipoi nome,...,Tipon nomen) {....// Defini¸ca õ da fun¸ca õ template return Tipoi; } Programa¸caõ Orientada a Objeto com C++


˜ 27.2. FUNC ¸ OES TEMPLATES

493

A fun¸caõ template do exemplo a seguir recebe um objeto do tipo T e retorna o resultado da multiplica¸caõ de x por x, que também é um objeto do tipo T. Exemplo: template T f(T x) { return ( x*x ); } Tudo bem, você ainda n˜ ao entendeu como funciona o template. Bem, template pode ser traduzido para o português como gabarito. ´ traduzido como gabarito, mas funciona como um gabarito? Exatamente. E E como C++ implementa esses gabaritos? ´ simples, é como um copiar/colar inteligente. Ao encontrar a declara¸caõ de uma funE çaõ template, o compilador verifica se a declara¸caõ est´ a correta. Se esta estiver correta, o compilador armazena a declara¸caõ em um buffer (na memória). Quando você chama a fun¸caõ declarada com o template, passando como parˆ ametro um int, o compilador reescreve toda a fun¸caõ, substituindo o tipo genérico T pelo tipo real int. O compilador faz substituir (T) por (int). Essa busca e substitui¸caõ é repetida para cada tipo. Veja no exemplo a seguir que o template da fun¸caõ T f(T x) { return x * x; } para o tipo int ap´ os o search(T) replace(int) resulta em int f(int obj) { return x * x; }. Exemplo: int f(int x)

{ return ( x*x ); }

Da mesma forma, ap´ os o search(T) replace(float) fica da forma Exemplo: float f(float x){ return ( x*x ); } Dica: como um template espera a defini¸caõ do tipo dentro de <>, e podemos ter um template recebendo outro, você deve incluir um espa¸co antes de >. Evita-se também a ambiguidade com o operador > >. Veja o exemplo: Exemplo: complex< double > c; vector< complex > v;

27.2.2

Instˆ ancias de fun¸c˜ oes template e dedu¸c˜ ao de argumentos

Definimos anteriormente que um objeto é uma instância de uma classe. A classe é a planta para cria¸caõ de um ou mais objetos. Da mesma forma, um template de uma fun¸caõ é uma planta para implementa¸caõ de uma ou mais fun¸co˜es, ou seja, o template da fun¸caõ n˜ ao é a fun¸caõ em s´ı, apenas um prot´ otipo. Isto significa que para que o c´ odigo da fun¸caõ seja efetivamente escrito, a fun¸caõ template precisa ser instanciada. Um template da forma Exemplo: template< typename T > T f(T x) { return ( x*x ); } para ser instanciado precisa receber em tempo de compila¸cão o argumento T, e o parˆ ametro x. Ou seja Programa¸caõ Orientada a Objeto com C++



494 Exemplo: int x = 4; int resultado = f(x);

note que passamos dentro de <> o argumento do template (o tipo T) e dentro de () o parˆ ametro da fun¸caõ f(). No exemplo acima o compilador vai criar uma vers˜ ao da fun¸caõ f() da seguinte forma: Exemplo: int f(int x)

{ return ( x*x ); }

note que o uso de f(x);, embora seja simples e claro, inclui a necessidade de se passar o argumento . Para reduzir a necessidade de digita¸caõ os compiladores de C++ podem, em alguns casos, deduzir automaticamento o tipo a ser passado para o template. No exemplo a seguir o tipo é deduzido automaticamente. Exemplo: int x = 4; int resultado = f(x); Note que em alguns casos o template precisa receber vários argumentos, e nem todos poder˜ ao ser automaticamente identificados. Nestes casos os argumentos mais a esquerda precisam ser passados. Funciona de forma semelhante ao que ocorre com fun¸co˜es/métodos com parˆ ametros pré-definidos (se¸caõ 13.6.4). Exemplo: template< typename T1, typename T2> T1 f(T1 x, T2 y) { std::cout < < x < < " " < < y < < std::endl; } .. char c = ’C’; f(5, c); // Argumentos identificados automaticamente Poder´ıamos chamar f() da seguinte forma Exemplo: char c = ’C’; f(5, c); note que o argumento é passado explicitamente e o argumento char é deduzido automaticamente pelo compilador. “Quando a defini¸ca õ da fun¸ca õ gabarito apresentar v´ arios parˆ ametros abstratos e houver necessidade de instanci´ a-los explicitamente, n˜ ao é preciso especificar todos os tipos de dados na chamada, mas somente aqueles que puderem apresentar problemas” (Ornellas et al. 2002).

27.2.3

Declara¸ c˜ ao expl´ıcita de fun¸c˜ ao template

Vimos que a fun¸caõ template s´ o ser´ a implementada para inteiros quando o compilador encontrar uma chamada da fun¸caõ que utilize inteiros. Se você deseja que uma fun¸caõ template tenha obrigatoriamente uma vers˜ ao para inteiros, basta declarar explicitamente a fun¸caõ para inteiros. Programa¸caõ Orientada a Objeto com C++



495

Exemplo: int f(int); // Declara¸ c~ ao explicita da fun¸ c~ ao f() para int Observe que você est´ a apenas declarando a fun¸caõ; sua defini¸caõ ser´ a dada automaticamente pelo compilador, tendo como base a defini¸caõ da fun¸caõ template. No exemplo a seguir, criamos um operador < < utilizando um tipo genérico T. A seguir, instanciamos o operator< < para o tipo efetivo int, depois para float e depois para char. Observe nesse exemplo que o segundo argumento const int size n˜ ao muda. Exemplo: // Defini¸ c~ ao da fun¸ c~ ao template template < typename T > void operator< <(const T * vetor, const int size) { for ( int i = 0; i < size; i++ ) cout < < vetor[i] < < endl; } // Declara¸ c~ ao expl´ ıcita da fun¸ c~ ao operator< <() para int, float e char* void operator< <(const int* vetor, const int size); void operator< <(const float*vetor, const int size); void operator< <(const char** vetor, const int size);

27.2.4

Resolvendo problemas de convers˜ oes

Quando uma chamada a uma fun¸caõ template n˜ ao puder ser resolvida pelas convers˜ oes padr˜ oes (ou do usu´ ario), você precisa informar explicitamente a vers˜ ao a ser utilizada. Veja o exemplo. Exemplo: int Minimo(int x, int y) { return x < y ? x:y; }

// (1)

// (2) unsigned int Minimo(unsigned int x, unsigned int y) { return x < y ? x : y; } unsigned int x = 18; unsigned int minimo = Minimo(x,19); // Ambiguidade, usar (1) ou (2)? O n´ umero 19 é convertido para int. Como existem duas vers˜ oes para Minimo(), uma para int (1) e outra para unsigned int (2), o compilador fica confuso e n˜ ao sabe qual fun¸caõ Minimo() chamar, causando uma ambig¨ uidade. Você pode resolver este problema especificando diretamente, dentro de <> a vers˜ ao a ser utilizada, veja exemplo abaixo. Exemplo: unsigned int minimo = Minimo< unsigned int >(x,19); // (2)

27.2.5

Sobrecarga de fun¸c˜ ao template

Se você deseja que uma fun¸caõ tenha o mesmo nome de uma fun¸caõ definida como template, mas que receba um n´ umero de parˆ ametros diferente, n˜ ao h´ a problema, visto que você est´ a sobrecarregando a fun¸caõ template. Observe, entretanto, que o n´ umero de parˆ ametros de entrada deve ser diferente, sen˜ ao o compilador vai acusar ambig¨ uidade. Programa¸caõ Orientada a Objeto com C++


´ 27.3. CLASSES TEMPLATES OU TIPOS PARAMETRICOS

496

Exemplo: template< typename T > T f(T a, T b) // (1) { return a + b; } template< typename T > T f(T a, T b, T c) // (2) Sobrecarga { return a + b + c; } Note que as fun¸co˜es (1) e (2) s˜ ao fun¸co˜es com mesmo nome, mas n´ umero de parˆ ametros diferentes. Veja a seguir exemplo de uso das fun¸co˜es (1) e (2). Exemplo: int xi = 3, yi = 4, zi = 5; f(xi,yi); // Cria uma c´ opia da fun¸ c~ ao float xf = 3.1, yf = 4.2, zf = 5.3; f(xf,yf); // Cria uma c´ opia da fun¸ c~ ao f(xi,yi,zi); // Cria uma c´ opia da fun¸ c~ ao f(xf,yf,zf); // Cria uma c´ opia da fun¸ c~ ao

(1) para o tipo int (1) para o tipo float (2) para o tipo int (2) para o tipo float

Note que as fun¸co˜es s˜ ao separadas, uma n˜ ao interfere em nada na outra.

27.2.6

Fun¸c˜ ao template com objeto est´ atico

Dentro de uma fun¸caõ template, você pode definir um objeto est´ atico do tipo T. Ao criar uma fun¸caõ para inteiros, cria um int est´ atico. Ao criar uma fun¸caõ para float, cria um float est´ atico. Esses objetos n˜ ao se interferem, pois est˜ ao em fun¸co˜es distintas. Exemplo: template< typename T > T f(T a, T b) { static T c = 0.0; // Vari´ avel T est´ atica, com valor pr´ e-definido ...resto da fun¸ c~ ao... } Nota: veremos na se¸caõ 28.1 o uso avan¸cado de fun¸co˜es template.

27.3

Classes templates ou tipos param´ etricos

A idéia de funcionamento de classes templates é semelhante ao de fun¸co˜es template, mas neste caso, vários atributos e métodos ser˜ ao definidos a partir dos tipos genéricos. Ou seja, uma classe template implementa o conceito de uma classe genérica. Uma classe que pode ser constru´ıda para mais de um tipo, mas que tem a mesma forma (estrutura, gabarito). Uma classe template também pode ser chamada de classe parametrizada ou classe gabarito. Veja a seguir o prot´ otipo para declarar e definir uma classe template.

27.3.1

Prot´ otipo para classes template

Veja a seguir o prot´ otipo para classes templates. Observe que na defini¸caõ dos métodos da classe template é preciso especificar novamente cada tipo genérico. Programa¸caõ Orientada a Objeto com C++



497

Prot´ otipo: // Declara¸ca õ da classe template template < typename Tipo1, typename Tipo2,.... > class TCNome { public: // Declara atributos Tipo1 atributo1; Tipo2 atributo2; // Declara e define o construtor default TCNome(){....}; // Declara métodos Tipo1 NomeMétodo(Tipo1 & obj,...); Tipo2 NomeMétodo(Tipo2 & obj,...); }; // Defini¸ca õ dos métodos da classe template template < typename Tipo1, typename Tipo2,.... > Tipo1 TCNome::NomeMétodo(Tipo1 & obj,...) {...} template < typename Tipo1, typename Tipo2,.... > Tipo2 TCNome::NomeMétodo(Tipo2 & obj,...) {...} // Utiliza¸ca õ da classe template TCNome< Tipo1, Tipo2,.... > nomeObjeto;

27.3.2

Regras gerais para classes template

Uma das idéias b´ asicas do uso de templates é que o tipo genérico T, passa a se comportar, sob certos aspectos, como sendo um argumento do template. Funcionando de forma semelhante ao parˆ ametro de um método. Isto significa que o resultado da execu¸caõ do programa vai depender além das vari´ aveis/atributos definidos pelo usuário, do tipo T das classes criadas e utilizadas como argumentos dos templates. Se novos tipos T forem definidos, isto é, novas classes do usuário, os mesmos poder˜ ao ser utilizados para instancia¸caõ de novas classes templates. Neste caso o programa precisa ser recompilado, e as novas classes devem ser efetivamente instanciadas. • Para construir o template, para um u ´ nico tipo genérico T, devemos iniciar a defini¸caõ da classe template usando a seguinte linha. Exemplo: template class TCNome { ..uso de T... }; • Para criar um objeto da classe TCNome, devemos passar o tipo T a ser utilizado. Ou seja, T funciona como um argumento. Exemplo: TCNome obj; Programa¸caõ Orientada a Objeto com C++


498


• Se o tipo genérico n˜ ao for passado dentro de <>, o compilador acusa o erro Exemplo: TCNome obj; // Erro ...class template require template argument list. TCNome<> obj; // Erro ...wrong number of template arguments. • Dentro da classe TCNome podemos criar criar atributos e métodos que usam o tipo genérico T. Exemplo: template class TCNome { // M´ etodos T& Atributo1() { return atributo1; } const T& Atributo1() const { return atributo1; } // Atributos T atributo1; T atributo2; }; • Para construir o template, para mais de um tipo genérico T, devemos iniciar a defini¸caõ da classe template usando a seguinte linha. Exemplo: template class TCNome { ..uso de T1, T2, T3, ...Tn... }; • Sempre que referênciarmos, dentro da classe TCNome, um objeto do tipo TCNome, devemos usar TCNome. Observe a forma como declaramos o operador de atribui¸caõ. Exemplo: template class TCNome { public: T atributo1 , atributo2; // Construtor TCNome():atributo1(0), atributo2(0){} void IgualaAtributos() { atributo1 = atributo2; }; // Operador de atribui¸ c~ ao TCNome& operator=(const TCNome& src); }; Programa¸caõ Orientada a Objeto com C++



499

• No método IgualaAtributos(), igualamos os atributos T atributo1 e T atributo2 (atributo1 = atributo2;). Mas o que acontece se o tipo a ser efetivamente utilizado n˜ ao tiver o operador de igualdade? Neste caso, quando IgualaAtributos() for instanciada, o compilador ir´ a acusar o erro. Exemplo: TCNome objInt; objInt.IgualaAtributos(); // ok, int tem sobrecarga para = TCNome objEndereco; objEndereco.IgualaAtributos(); // Erro, TEndere¸ co n~ ao tem o operador = • Quando compilamos o arquivo de implementa¸caõ da classe (*.cpp), todos os atributos e métodos s˜ ao inclu´ıdos no arquivo objeto (*.o). Entretanto, quando linkamos vários arquivos para gerar um programa execut´ avel, somente os trechos de c´ odigo efetivamente utilizados s˜ ao inclu´ıdos no execut´ avel final. Isto significa que se n˜ ao chamarmos objEndereco.IgualaAtributos();, ent˜ ao o c´ odigo abaixo ir´ a funcionar. Exemplo: TCNome objInt; objInt.IgualaAtributos(); // ok, int tem sobrecarga para = TCNome objEndereco; // ok, n~ ao vamos usar IgualaAtributos • Alguns compiladores exigem que todo c´ odigo de uma classe template seja definido na classe .h. Exemplo // Arquivo TCNome.h // Inclui defini¸ c~ ao da classe e dos m´ etodos da classe. • Para estes compiladores, pode-se usar o truque abaixo. Note que o arquivo ”TCNome.cpp” é inclu´ıdo dentro do arquivo ”TCNome.h”, Exemplo: // Arquivo TCNome.h, defini¸ c~ ao da classe #ifndef TCNome_h #define TCNome_h template class TCNome { public: void M(); }; #include "TCNome.cpp" #endif O arquivo TCNome.cpp, inclui a defini¸caõ dos métodos da classe: template void TCNome::M() Programa¸caõ Orientada a Objeto com C++



500 {

std::cout < < "Usando m´ etodo M()." < < std::endl; } No Cap´ıtulo 30 - As Classes , e as Fun¸co˜es Matem´ aticas de , descreveremos a classe template . Um objeto da classe representa um n´ umero complexo que pode ser constru´ıdo para n´ umeros float, double e long double, ou seja, se você quiser um n´ umero complexo com precisão de float, utilize complex, e se quiser um n´ umero complexo com precisão de double, utilize complex.

27.3.3

Argumentos pr´ e-definidos em classes templates

Uma classe template também pode ser definida com argumentos pré-definidos, de forma semelhante a fun¸co˜es com parˆ ametros pré-definidos (veja se¸caõ 13.6.4). Veja no prot´ otipo a seguir que se o Tipo2 n˜ ao for passado, vai assumir Tipo2 = Tipo1. Prot´ otipo: template class TCNome {... }; Neste prot´ otipo, a classe TCNome pode ser constru´ıda passando-se os dois tipos (Tipo1 e Tipo2), como no exemplo abaixo: TCNome obj1; Ou passando-se apenas o tipo mais a esquerda (Tipo1), como em: TCNome obj2; O exemplo da listagem 27.1 mostra a defini¸caõ de uma classe template que tem argumentos pré-definidos. Listing 27.1: Defini¸caõ de classe template com argumentos pré-definidos . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/* * @ c o p y r i g h t ( C ) Andre Duarte Bueno , Vitor S e r a p h i m */ # include < iostream > using namespace std ; // Cria classe t e m p l a t e para p o l i n ^ omios. // Usa p a r ^ a m e t r o com valor pr´ e - definido , por padr~ a o size ´ e 3 template < typename T , const int size = 3 > class TCPolinomi o { T p [ size ]; public : TCPolinom i o () ; // (1) TCPolinom i o ( const TCPolinomio & src ) ; // (2) const int Size () { return size ;} // (3) const T & operator () ( T x ) const ; // (4) T& operator []( int i ) ; // (5) const T & operator []( int i ) const ; // (6) TCPolinomio & operator =( const TCPolinomio & src ) ; // (7) }; # include " C l a s s e T e m p l a t e C o m A r g u m e n t o s P r e - Definidos . cpp "




501

Observe na listagem 27.2 a forma de implementa¸caõ dos métodos da classe template. Note que os argumentos do template devem ser utilizados também na defini¸caõ dos métodos da classe (devem ser passados para cada método). Isto é necess´ ario, mesmo quando os argumentos do template n˜ ao s˜ ao tipos genéricos (no exemplo, o segundo argumento tem tipo definido, const int). Observe ainda que utilizamos o conceito de argumento com valor pré-definido, no caso, size = 3. Listing 27.2: Defini¸caõ dos métodos da classe template com argumentos pré-definidos. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

/* * @ c o p y r i g h t ( C ) Andre Duarte Bueno , Vitor S e r a p h i m M o n t a d o tendo como base tipos f l u t u a n t e s */ // (1) C o n s t r u t o r d e f a u l t template < typename T , const int size > TCPolinomio :: TCPolinomi o () { for ( int i =0; i < size ; i ++) p [ i ] = i ;}; // (2) C o n s t r u t o r de c´ o pia template < typename T , const int size > TCPolinomio :: TCPolinomi o ( const TCPolinomio & src ) { for ( int i =0; i < size ; i ++) p [ i ] = src . p [ i ];}; // (4) S o b r e c a r g a do o p e r a d o r () // o b s e r v e que pow recebe long double template < typename T , const int size > const T & TCPolinomio :: operator () ( T x ) const { T * y = new T (0) ; for ( int i = 0 ; i < size ; i ++) (* y ) += p [ i ] * pow ( static_cast < long double > ( x ) , i ) ; return * y ; }; // (5) S o b r e c a r g a do o p e r a d o r [] template < typename T , const int size > T& TCPolinomio :: operator []( int i ) { return p [ i ]; }; // (6) S o b r e c a r g a do o p e r a d o r [] template < typename T , const int size > const T & TCPolinomio :: operator []( int i ) const { return p [ i ]; }; // (7) S o b r e c a r g a do o p e r a d o r = template < typename T , const int size > TCPolinomio & TCPolinomio :: operator =( const TCPolinomio & src ) { for ( int i =0; i < size ; i ++) p [ i ] = src . p [ i ]; return * this ; }

Observe na listagem 27.3 a forma de uso dos métodos da classe template. Listing 27.3: Usando a classe template com argumentos pré-definidos. 1 2 3 4 5 6

# include < cmath > # include < iostream > using namespace std ; # include " C l a s s e T e m p l a t e C o m A r g u m e n t o s P r e - Definidos . h " // Usando a classe T C P o l i n o m i o



502 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61


int main () { const int size = 3; int x = 5; cout << " x = " << x << endl ; cout << " Criando polin^ o mio TCPolinomio < int > pInt1 ; " << endl ; TCPolinomio < int > pInt1 ; // (1) cout << " C o e f i c i e n t e s de pInt1 = " ; for ( int i =0; i < size ; i ++) cout << pInt1 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " pInt1 ( x ) = " << pInt1 ( x ) << endl ; // (3) int r = pInt1 [0]; cout << " r = " << r << endl ; const int rc = pInt1 [0]; cout << " rc = " << rc << endl ;

// (5) // (6)

cout << " Criando polin^ o mio TCPolinomio < int > pInt2 ; " << endl ; TCPolinomio < int , size > pInt2 ( pInt1 ) ; // (2) pInt2 [0] = 1; cout << " C o e f i c i e n t e s de pInt2 = " ; for ( int i =0; i < size ; i ++) cout << pInt2 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " pInt2 ( x ) = " << pInt2 ( x ) << endl ; // (3) cout << " \ nCriando polin^ o mio TCPolinomio < int , size > pInt3 ( pInt2 ) ; " " usa construto r copia " << endl ; TCPolinomio < int , size > pInt3 ( pInt2 ) ; // (2) cout << " C o e f i c i e n t e s de pInt3 = " ; for ( int i =0; i < size ; i ++) cout << pInt3 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " \ nIgualand o polin^ o mios pInt1 = pInt2 ; " << endl ; pInt1 = pInt2 ; // (7) cout << " C o e f i c i e n t e s de pInt1 = " ; for ( int i =0; i < size ; i ++) cout << pInt1 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " \ nCriando polin^ o mio TCPolinomio < float , size > pFloat1 ; " << endl ; TCPolinomio < float , size > pFloat1 ; // (1) cout << " C o e f i c i e n t e s de pFloat1 = " ; for ( int i =0; i < size ; i ++) cout << pFloat1 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " pFloat1 ( x ) = " << pFloat1 ( x ) << endl ; // (3) // cout << " I g u a l a n d o p o l i n ^ o m i o s de tipos d i f e r e n t e s " // pInt1 = p F l o a t 1 ; // (6) // Erro return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out x = 5 Criando polin^ o mio TCPolinomio < int > pInt1 ; C o e f i c i e n t e s de pInt1 = 0 1 2 pInt1 ( x ) = 55 r = 0 rc = 0



27.4. SENTENCAS ¸ PARA TEMPLATES

503

Criando polin^ o mio TCPolinomio < int > pInt2 ; C o e f i c i e n t e s de pInt2 = 1 1 2 pInt2 ( x ) = 56 Criando polin^ o mio TCPolinomio < int , size > pInt3 ( pInt2 ) ; usa construtor copia C o e f i c i e n t e s de pInt3 = 1 1 2 Igualando polin^ o mios pInt1 = pInt2 ; C o e f i c i e n t e s de pInt1 = 1 1

2

Criando polin^ o mio TCPolinomio < float , size > pFloat1 ; C o e f i c i e n t e s de pFloat1 = 0 1 2 pFloat1 ( x ) = 55

Veja outros exemplos de classes template nas listagens 33.2 e 33.4. Nota: a STL usa o mecanismo de argumentos pré-definidos extensivamente. Por exemplo, a classe espera como argumento o tipo de objeto a ser armazenado no vetor e o tipo de alocador de mem´ oria a ser utilizado. Normalmente passamos apenas o primeiro argumento, isto é, o tipo do objeto a ser armazenado no container .

27.4

Senten¸cas para templates

• N˜ ao é aconselh´ avel a utiliza¸caõ de fun¸co˜es globais; isso também é válido para fun¸co˜es template globais. • N˜ ao crie classes com templates antes de ter total confian¸ca no c´ odigo, isto é, primeiro crie classes normais e fa¸ca todos os testes que forem necess´ arios. • Lembre-se que uma fun¸caõ pode ter mais de uma declara¸caõ, mas somente uma defini¸caõ. O mesmo conceito é válido para fun¸co˜es template. • O conceito de friend também pode ser utilizado com templates (se¸caõ 28.1.5). • Observe que com a utiliza¸caõ de templates, você pode desenvolver programas genéricos, com tipos genéricos. • Para diferenciar classes comuns de classes gabaritos, costuma-se colocar o nome das classes gabaritos dentro de <>, como em , . • A alguns anos usávamos template, como a palavra-chave class já é utilizada para declarar uma classe, prefira typename para declarar os templates. • Um template de fun¸caõ (ou classe) pode aceitar argumentos com tipo pré-definido. No exemplo a seguir const int, é o tipo pré-definido. Exemplo: template class TCNome{...}; // Para criar um objeto de TCNome usa-se: TCNome nomeObjeto; • Os argumentos com tipo definido em um template (como o int n do exemplo anterior) ser˜ ao sempre const. Programa¸caõ Orientada a Objeto com C++


504

27.4. SENTENCAS ¸ PARA TEMPLATES

• Como uma classe template é apenas reescrita para cada tipo, esta ir´ a aceitar heran¸ca de uma classe comum, heran¸ca de uma classe gabarito e heran¸ca de uma classe gabarito para uma classe comum. Veja no exemplo a seguir a defini¸caõ de uma classe template TCPolinomioDerivado. A mesma acrescenta uma hipotética fun¸caõ de deslocamento (os coeficientes do polinômio s˜ ao deslocados). // TCPolinomioDerivado.h template class TCPolinomioDerivado: public TCPolinomio { ... T* p; void Shift(int deslocamento); // Novidade }; // TCPolinomioDerivado.cpp #include "TCPolinomioDerivado.h" template void TCPolinomioDerivado::Shift(int d) { T cp[size]; for(int i = 0; i < size ; i++) cp[i] = p[i]; for(int i = 0; i < size ; i++) { if( i + d < size) p[i] = cp[i + d]; else p[i] = cp[size - i - d ] } } • 2 Nas classes templates, os métodos devem ser definidos dentro da classe, ou em arquivos .cpp (inclu´ıdos no .h), ou ainda usando a palavra-chave export. Embora os métodos sejam inclu´ıdos dentro da classe, é aconselh´ avel o uso da palavra-chave inline quando você deseja que o método seja em linha. • 2 Na defini¸caõ de uma classe template podemos incluir argumentos com valores prédefinidos (como o tipo int no exemplo abaixo). Mas na implementa¸caõ dos métodos da classe template somente o tipo dos argumentos devem ser definidos, os valores prédefinidos n˜ ao. Observe no exemplo abaixo que o argumento T2 tem como valor pré-definido o tipo int. Exemplo: template class TCNome { // Declara¸ c~ ao do construtor TCNome(T1, T2); }; Mas na defini¸caõ do método construtor, o tipo pré-definido n˜ ao deve ser passado. Programa¸caõ Orientada a Objeto com C++


27.5. RESUMO DO CAPÍTULO // Defini¸ c~ ao do construtor template::TCNome(T1, T2) {};

505

>

Se o argumento pré-definido for inclu´ıdo na defini¸caõ, ocorrerá erro na compila¸caõ, veja abaixo mensagem de erro. – XXX.cpp:19: error: default template arguments may not be used in function templates

27.5


Agora o leitor pode compreender as vantagens da programa¸caõ orientada a objeto com C++. A utiliza¸caõ de conceitos abstratos como classes, que permitem a cria¸caõ de tipos do usuário, adequados à solu¸caõ de seus problemas, do polimorfismo, que permitem que o c´ odigo fique altamente genérico e pequeno, da sobrecarga de operadores, que possibilitam ao programador definir opera¸co˜es conhecidas como + - * /, e de templates, que tornam o c´ odigo genérico, fazem de C++ uma linguagem de programa¸caõ extremamente poderosa e moderna. Neste cap´ıtulo aprendemos a usar o conceito de fun¸co˜es e classes templates, e suas diversas varia¸co˜es. Vimos o prot´ otipo e o uso de fun¸co˜es template. Aprendemos que podemos estanciar explicitamente as fun¸co˜es e classes template. Como uma fun¸caõ template é um prot´ otipo, podemos implementar conceitos como argumentos pré-definidos, sobrecarga de fun¸caõ template, uso de objetos est´ aticos. Aprendemos ainda a usar classes templates ou tipos paramétricos, vimos seu prot´ otipo e um conjunto de regras para uso de classes templates. Classes template também podem ter argumentos pré-definidos. Dica: a biblioteca STL utiliza extensivamente o conceito de templates, veja Cap´ıtulo 31 Introdu¸caõ a Biblioteca Padr˜ ao de Gabaritos de C++.

27.6

Exerc´ıcios

1. Transformar a hierarquia da classe CPonto em uma hierarquia de classes template. O tipo T dos valores de x, y, r1, r2 deve poder ser int, float, double, long double. 2. O exemplo que usa o método Shift() na se¸caõ 27.4, pode ser otimizado, substitua o vetor cp por uma vari´ avel tempor´ aria. 3. No exemplo da listagem 27.1, incluir sobrecarga para operador< < e operador> >. Fa¸ca com que na sa´ıda o polinômio seja escrito da forma: y = p[0] + p[1]x + p[2]x ∧ 2 + .... Dica: veja maiores detalhes de templates na referência Nicolai M. Josuttis e David Vandevoorde´s, ”C++ Templates - The Complete Guide”, [Vandevoorde and Josuttis, 2002].



506

27.6. EXERCÍCIOS



Cap´ıtulo 28

Templates - Uso Avan¸ cado No Cap´ıtulo 27 - Templates ou Gabaritos, vimos os conceitos b´ asicos de templates. Neste cap´ıtulo veremos o uso avan¸cado de fun¸co˜es e classes templates. Aprenderemos como especializar classes e fun¸co˜es template. No caso das classes a especializa¸caõ pode ser total (a classe é inteiramente redeclarada e redefinida) ou parcial (apenas alguns membros existentes na declara¸caõ original s˜ ao redefinidos). Uma fun¸caõ s´ o pode ser inteiramente redefinida. • Uso avan¸cado de fun¸co˜es template (se¸caõ 28.1), – especializa¸caõ de fun¸co˜es template (se¸caõ 28.1.1), – o que s˜ ao fun¸co˜es expandidas em tempo de compila¸caõ (se¸caõ 28.1.2), – uso de typename com templates (se¸caõ 28.1.3), – como mapear fun¸co˜es template utilizando especializa¸co˜es (se¸caõ 28.1.4), – Fun¸co˜es template e friend (se¸caõ 28.1.5). • Uso avan¸cado de classes template (se¸caõ 28.2) – templates dentro de classes template (se¸caõ 28.2.1), – como especializar classes (se¸caõ 28.2.2), – a instancia¸caõ de classes template (se¸caõ 28.2.3). • Uso de export com templates (se¸caõ 28.3). Nota: este cap´ıtulo é destinado a usu´ arios avan¸cados de C++. Numa primeira leitura deste livro o mesmo pode ser pulado sem perda de sequência.

28.1

Fun¸ c˜ oes template uso avan¸cado

Nesta se¸caõ veremos o uso avan¸cado de fun¸co˜es template.

28.1.1

Especializa¸ c˜ ao de fun¸c˜ oes template

Como vimos, um template de fun¸caõ ou classe é uma defini¸caõ genérica. A quest˜ ao é, esta defini¸caõ geral é válida em todas as situa¸co˜es? Em algumas situa¸co˜es, um dado template funcionará para a maioria dos tipos e falhar´ a para um tipo espec´ıfico. Vamos a um exemplo, uma fun¸caõ Menor() da forma: 507

˜ 28.1. FUNC ¸ OES TEMPLATE USO AVANCADO ¸

508 Exemplo: template < typename Tipo > bool Menor(Tipo obj1, Tipo obj2) { return obj1 < obj2; }

Funcionará para int, float e double, e falhar´ a para char* (cstring). Pois para comparar uma cstring devemos utilizar a fun¸caõ strcmp()1 da biblioteca de C. Neste caso, poderemos criar uma especializa¸caõ para a fun¸caõ template. A especializa¸caõ ir´ a tratar especificamente do caso de char*. Observe no exemplo a seguir o uso de template<> sem argumentos e ap´ os o nome da fun¸caõ o tipo especializado dentro de <, ou seja, < const char* >. Exemplo: // Especializa¸ c~ ao de Menor para o tipo const char* template<> bool Menor< const char* >(const char* cstring1,const char* cstring2) { return strcmp(cstring1,cstring2) < 0; } A especializa¸caõ nada mais é do que a redefini¸caõ da fun¸caõ/classe template para um tipo espec´ıfico. Veja a seguir prot´ otipo para especializa¸caõ de fun¸caõ template. Prot´ otipo: template<> Retorno NomeFun¸ca õ < TipoEspecializado > (parˆ ametros) { ...fun¸ca õ em s´ı... } Note que a fun¸caõ especializada pode ser totalmente diferente da original. Veja exemplo na listagem 28.1. Embora fun¸co˜es template possam ser especializadas, seu uso deve ser evitado, por quest˜ oes de robustes e portabilidade do sistema. [Sutter, 2006], apresenta exemplos em que o uso de fun¸co˜es template especializadas apresenta problemas apenas em fun¸caõ da ordem em que as mesmas foram declaradas. Isto ocorre em fun¸caõ da ordem em que as fun¸co˜es s˜ ao consideradas na avalia¸caõ da chamada da fun¸caõ: i) primeiro s˜ ao chamadas as fun¸co˜es sem template, ii) a seguir s˜ ao chamadas as fun¸co˜es com template, iii) em terceiro lugar s˜ ao consideradas as fun¸co˜es com template que foram especializadas. A solu¸caõ para este problema é simples, como fun¸co˜es comuns se encaixam em (i), em vez de especializar a fun¸caõ template para um tipo X, reescreva a fun¸caõ para o tipo X usando uma fun¸caõ comum (n˜ ao template). Outro problema do uso de especializa¸co˜es de fun¸co˜es template é que eles viabilizam a quebra do encapsulamento da classe. Pois se temos uma fun¸caõ template f, um outro programador - com más inten¸co˜es - sempre poder´ a especializar a fun¸caõ por n´ os definida para uma tipo definido por ele (uma classe criada por ele). Como a fun¸caõ especializada ser´ a reescrita pelo outro programador, o mesmo poder´ a acessar atributos e métodos privados da classe, pois a fun¸caõ especializada esta no mesmo escopo da classe. Veja maiores detalhes em [Sutter, 2006]. 1 A fun¸ ca õ strcmp() ´ e uma fun¸ca õ de C que compara duas strings no formato const char*. Veja Apˆ endice K - Arquivos de Cabe¸calho.




509

Apresentam-se a seguir dois exemplos de otimiza¸caõ de programas utilizando-se conceitos avan¸cados de templates.

28.1.2

Fun¸ c˜ oes expandidas em tempo de compila¸c˜ ao

Você pode utilizar templates e especializa¸caõ de templates para criar fun¸co˜es que s˜ ao expandidas em tempo de compila¸caõ. No exemplo da listagem 28.1, a fun¸caõ f<>() tem como argumento um int N e chama a si mesma passando N-1 (chamadas recursivas). Quando N = 0, chama a vers˜ ao especializada da fun¸caõ f<>(), que termina o processo recursivo. Observe que a fun¸caõ f<>() é criada em tempo de compila¸caõ pela expans˜ ao recursiva da fun¸caõ template. Este mecanismo torna a fun¸caõ muito r´ apida, pois elimina a chamada recursiva. A contrapartida é o aumento do tamanho do programa execut´ avel. Observe na sa´ıda que os valores aparecem na ordem 0,1,2....,10, pois colocamos cout < < ”N=” < < N < < ’\t’; depois da chamada de f();. Listing 28.1: Exemplo de fun¸caõ expandida em tempo de compila¸caõ. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# include < iostream > using namespace std ; // Fun¸ c~ ao template recursiva template < int N > void f () { f () ; // Recurs~ a o , chama a si mesma cout << " N = " << N << ’\ t ’; } // E s p e c i a l i z a ¸ c~ a o da fun¸ c~ a o t e m p l a t e para o tipo int == 0 template < > void f <0 >() { cout << " N = " << 0 << ’\ t ’; // Aqui f i n a l i z a a r e c u r s ~ ao } int main () { f <10 >() ; cout << endl ; return 0; } bash -3.00 $ ./ a . out N =0 N =1 N =2 N =3

// Cria i n s t ^ a n c i a da fun¸ c~ ao // t e m p l a t e com N =10

N =4

N =5

N =6

N =7

N =8

N =9

N =10

No exemplo da listagem 28.2, adaptado de [Lischner, 2003], a fun¸caõ Arredondar() é usada para arredondar um n´ umero flutuante para n casas decimais, e este processo é feito em tempo de compila¸caõ. A fun¸caõ, double floor(double x);, definida no arquivo de cabe¸calho (se¸caõ 30.1.1), retorna o maior inteiro n˜ ao maior que x (arredonda para baixo). A estrutura power_xy<> cria uma enumera¸caõ cujo valor é o resultado de xy . Observe que a chamada a power_xy<> é recursiva. Note que o programa cria vers˜ oes especializadas para x0 , 0y e 00 . Observe na sa´ıda que o n´ umero 1.23456789 é arredondado para 2, 4 e 6 casas decimais. Listing 28.2: Fun¸caõ potência expandida em tempo de compila¸caõ. 1 2 3

// A d a p t a d o de C ++ in a n u t s h e l l de Ray L i s c h n e r # include < cmath > # include < iostream >




510 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// Fun¸ c~ ao template - defini¸ c~ a o geral - x ^ y template < int x , unsigned y > struct power_xy { enum { valor = x * power_xy :: valor }; }; // Fun¸ c~ ao template - especializa¸ c~ a o para x ^0 template < int x > struct power_xy { enum { valor = 1 }; }; // Fun¸ c~ ao template - especializa¸ c~ a o para 0^ y template < unsigned y > struct power_xy <0 , y > { enum { valor = 0 }; }; // Fun¸ c~ ao template - especializa¸ c~ a o para 0^0 template < > struct power_xy <0 , 0 > {}; // A fun¸ c~ a o abaixo a r r e d o n d a um n´ u mero f l u t u a n t e // c o n s i d e r a n d o n casas d e c i m a i s template < unsigned n , typename T > T Arredondar ( T x ) { if ( x < 0.0) return std :: floor ( x * power_xy <10 , n >:: valor - 0.5) / power_xy <10 , n >:: valor ; else return std :: floor ( x * power_xy <10 , n >:: valor + 0.5) / power_xy <10 , n >:: valor ; } int main () { std :: cout << Arredondar <2 >(1.23456789) << std :: endl ; std :: cout << Arredondar <4 >(1.23456789) << std :: endl ; std :: cout << Arredondar <6 >(1.23456789) << std :: endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out 1.23 1.2346 1.23457

28.1.3

Usando typename com templates

Em alguns casos, a defini¸caõ de um template pode ser correta, mas amb´ıgua para o compilador. Veja o exemplo: Exemplo: template < typename T > void f( T obj ) {... Programa¸caõ Orientada a Objeto com C++



511

T::X(par^ ametro); T::X* ptr; } Se X for um tipo (uma classe aninhada de T), o comando T::X(par^ ametro) é uma chamada de construtor. Neste caso, vai criar um objeto anˆ onimo (sem atribu´ı-lo a alguém). Mas X também pode ser uma fun¸caõ membro est´ atica. Assim, o compilador ficar´ a em d´ uvida: X é um tipo e devo chamar seu construtor ou X é uma fun¸caõ membro est´ atica? Da mesma forma, se X for um tipo ptr é um ponteiro para o tipo X. Se X for um atributo est´ atico de T, T::X *ptr; é a multiplica¸caõ de X por ptr. Para resolver estas ambig¨ uidades o compilador assume por padr˜ ao (default ) que X n˜ ao é um tipo. Para que X seja considerado um tipo, você deve usar a palavra-chave typename. Veja o exemplo: Exemplo: template < typename T > void f( T obj) {... typename T::X obj(par^ ametro); } Veja outro exemplo na listagem 28.3.

28.1.4

Mapeando fun¸c˜ oes template utilizando especializa¸c˜ oes

Você pode mapear vari´ aveis de fun¸co˜es template utilizando especializa¸co˜es. No exemplo a seguir, uma fun¸caõ Media() recebe um vetor e determina a média de seus elementos. Exemplo: double Media (const double* vetor, int numeroElementos) { double soma = 0; for( int i = 0; i < numeroElementos; i++) soma += vetor[i]; return soma / numeroElementos; } Pode-se criar um template para esta fun¸caõ da forma: Exemplo: template< typename T > T Media (const T* vetor, int numeroElementos) { T soma = 0; for(int i = 0; i < numeroElementos; i++) soma += vetor[i]; return soma / numeroElementos; } Entretanto, quando a fun¸caõ template anteriormente definida for criada para int, ir´ a apresentar um erro, pois a divisão soma / numeroElementos ser´ a truncada (a divisão entre dois n´ umeros inteiros é sempre truncada, por exemplo 3/2 = 1). Programa¸caõ Orientada a Objeto com C++



512

Pode-se resolver este problema criando-se um template de uma estrutura que inclua um typedef de um tipo T que ser´ a especializado para double quando o tipo T for int. O exemplo da listagem 28.3 esclarece melhor este caso. Observe que a vari´ avel double_trait< T > ser´ a do tipo correto. Se T for double, T_double ser´ a do tipo double, se T for int T_double também ser´ a do tipo double. Veja na sa´ıda que a fun¸caõ Media() funciona para int e para double. Listing 28.3: Exemplo de mapeamento de tipo com templates. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

# include < iostream > using namespace std ; // A e s t r u t u r a d o u b l e _ t r a i t cria um t y p e d e f para o tipo T template < typename T > struct d o u b l e _ t r a i t { typedef T T_double ; }; // E s p e c i a l i z a ¸ c~ a o da e s t r u t u r a d o u b l e _ t r a i t para int // Se o tipo T for int , T _ d o u b l e deve ser do tipo double template < > struct double_trait < int > { typedef double T_double ; }; // Uma fun¸ c~ a o t e m p l a t e que usa a e s t r u t u r a d o u b l e _ t r a i t acima d e f i n i d a // o r e t o r n o ´ e double_trait :: T _ d o u b l e // o nome ´ e Media // e os p a r ^ a m e t r o s const T * vetor , int n u m e r o E l e m e n t o s template < typename T > typename double_trait < T >:: T_double Media ( const T * vetor , int n u m e r o E l e m e n t o s ) { typename double_trait :: T_double soma = 0; for ( int i =0; i < n u m e r o E l e m e n t o s ; i ++) soma += vetor [ i ]; return soma / n u m e r o E l e m e n t o s ; } // Usando a fun¸ c~ a o t e m p l a t e Media () int main () { int * vetor_int = new int (4) ; for ( int i = 0; i < 4; i ++) vetor_int [ i ] = i ; double media ; media = Media ( vetor_int , 4) ; cout << " M´ e dia do vetor_int = " << media << endl ; delete [] vetor_int ; double * v e t o r _ d o u b l e = new double (4) ; for ( int i = 0; i < 4; i ++) vetor_double[i] = i; media = Media ( v e t o r _ d o u b l e , 4) ; delete [] v e t o r _ d o u b l e ; cout << " M´ e dia do v e t o r _ d o u b l e = " << media << endl ; cout << " ( int 3) /( int 2) = " << 3/2 << endl ; return 0; }



28.2. CLASSES TEMPLATE USO AVANCADO ¸

513

bash -3.00 $ ./ a . out media vetor_int = 1.5 media v e t o r _ d o u b l e = 1.5 ( int 3) /( int 2) = 1

28.1.5

Fun¸ c˜ oes template e friend

Uma fun¸caõ template pode ser indicada como uma fun¸caõ amiga, veja o exemplo: Exemplo: void F_Global(); template void G_Global(T obj); namespace N1 { template void f(T& c) {...} }

// Declara fun¸ c~ ao global F // // // //

Declara fun¸ c~ ao template global G Define um namespace Define um template Define uma fun¸ c~ ao dentro do namespace

class CNome{ friend void F_Global(); template friend void G_Global(T obj); friend void N1::f(CNome&); plate como amiga ...};

// Define uma classe // F_Global() ´ e amiga // G_Global() ´ e amiga // Declara uma fun¸ c~ ao tem-

Neste exemplo definimos uma fun¸caõ template f(), e informamos que a mesma é amiga de CNome. Embora dentro dos padr˜ oes, alguns compiladores n˜ ao aceitam esta declara¸caõ da fun¸caõ friend. Uma das poss´ıveis solu¸co˜es é usar: Exemplo: // Declara uma fun¸ c~ ao template como amiga friend void N1::f(CNome& c);

28.2

Classes template uso avan¸cado

Nesta se¸caõ veremos o uso avan¸cado de classes template.

28.2.1

Templates dentro de uma classe template

A listagem 28.4 mostra a cria¸caõ de um método template dentro de uma classe normal. Note que criamos dois métodos, um normal e outro est´ atico. Listing 28.4: Problema na chamada a métodos template. 1 2 3 4 5 6 7 8

# include < iostream > class TCNome { public : template < int n > int M () { std :: cout << " normal : "

<< n << std :: endl ; }



514 9 10 11 12 13 14 15 16 17 18 19 20


template < int n > static int SM () { std :: cout << " estatica : " << n << std :: endl ; } }; int main () { TCNome obj ; obj . M <3 >() ; TCNome :: SM <4 >() ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out normal :3 estatica :4

Usando as listagens 27.1 e 27.2 podemos criar objetos polinˆ omios usando int, float, etc. Podemos igualar objetos. Exemplo: TCPolinomio< int > TCPolinomio< int > p1Int = p2Int;

p1Int; p2Int;

// Cria polin^ omio para tipo inteiro // Cria polin^ omio para tipo inteiro // ok, iguala polin^ omios

Mas se em algum momento quiséssemos igualar dois polinômios com tipos diferentes, ter´ıamos um erro. O erro ocorre mesmo tendo implementado o operador igualdade, pois o mesmo é válido para TCPolinomio< int > = TCPolinomio< int > ou TCPolinomio< float > = TCPolinomio< float >. Mas n˜ ao pode ser usado para pFloat = pInt;. Observe na listagem 27.2, no final da fun¸caõ main(), que colocamos o seguinte c´ odigo: Exemplo: TCPolinomio< float,size > pFloat; // pInt1 = pFloat1;

// Cria polin^ omio para tipo float // Erro, tipos diferentes

Se retirarmos o coment´ ario da linha // pInt1 = pFloat1;, o compilador ir´ a apresentar a mensagem de erro apresentada na listagem ??. [ b u e n o @ l d s c 0 5 Parte - II ] $ g ++ T e m p l a t e s C o m E r r o . cpp : In function ’ int main () ’: :102: error : no match for ’ operator = ’ in ’ pInt1 = pFloat1 ’ :44: note : candidates are : TCPolinomio & TCPolinomio :: operator =( const TCPolinomio &) [ with T = int , int size = 3] : In member function ’ const T & TCPolinomio :: operator () ( T ) const [ with T = int , int size = 3] ’: :63: i n s t a n t i a t e d from here :27: warning : converting to ’ int ’ from ’ long double ’

Para resolver este problema, devemos criar uma camada adicional de template. Um template extra dentro da defini¸caõ da classe TCPolinomio, veja exemplo nas listagens 28.5 e 28.6. Observe no final da defini¸caõ da classe TCPolinomio, a inclus˜ ao de um construtor de c´ opia e de um operador de atribui¸caõ. Listing 28.5: Defini¸caõ de classe template com template adicional. 1 2 3 4

/* * Inclui t e m p l a t e s a d i c i o n a i s */ // Cria classe t e m p l a t e para polinomios , // Usa p a r ^ a m e t r o com valor pr´ e - definido , por padr~ a o size ´ e 3 template < typename T , const int size = 3 >



28.2. CLASSES TEMPLATE USO AVANCADO ¸ 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class TCPolinom io { T p [ size ]; public : TCPolinom i o () ; // (1) TCPolinom i o ( const TCPolinomio & src ) ; // (2)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// (1) C o n s t r u t o r d e f a u l t template < typename T , const int size > TCPolinomio :: TCPolinomi o () { for ( int i = 0; i < size ; i ++) p [ i ] = i ;};

515

const int Size () { return size ;} // (3) const T & operator () ( T x ) const ; // (4) T& operator []( int i ) ; // (5) const T & operator []( int i ) const ; // (6) TCPolinomio & operator =( const TCPolinomio & src ) ; // (7) // C o n s t r u t o r de c´ o pia - T e m p l a t e a d i c i o n a l template < typename E > TCPolinom i o ( const TCPolinomio & src ) ; // (8) // O p e r a d o r de a t r i b u i ¸ c~ ao - Template adicional template < typename E > // (9) TCPolinomio & operator =( const TCPolinomio & src ) ; }; # include " T e m p l a t e C o m T e m p l a t e A d i c i o n a l . cpp "

Listing 28.6: Implementa¸caõ dos métodos da classe template com template adicional.

// (2) C o n s t r u t o r de c´ o pia template < typename T , const int size > TCPolinomio :: TCPolinomi o ( const TCPolinomio & src ) { for ( int i = 0; i < size ; i ++) p [ i ] = src [ i ];}; // (4) S o b r e c a r g a do o p e r a d o r () // o b s e r v e que pow recebe long double template < typename T , const int size > const T & TCPolinomio :: operator () ( T x ) const { T * poli = new T (0) ; for ( int i = 0 ; i < size ; i ++) (* poli ) += p [ i ] * pow ( static_cast < long double > ( x ) , i ) ; return * poli ; }; // (5) S o b r e c a r g a do o p e r a d o r [] template < typename T , const int size > T& TCPolinomio :: operator []( int i ) { return p [ i ]; }; // (6) S o b r e c a r g a do o p e r a d o r [] template < typename T , const int size > const T & TCPolinomio :: operator []( int i ) const { return p [ i ]; }; // (7) S o b r e c a r g a do o p e r a d o r = template < typename T , const int size > TCPolinomio & TCPolinomio :: operator =( const TCPolinomio & src ) { for ( int i = 0; i < size ; i ++) p [ i ] = src [ i ];



516 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57


return * this ; } // (8) C o n s t r u t o r de c´ o pia - T e m p l a t e a d i c i o n a l template < typename T , const int size > template < typename E > TCPolinomio :: TCPolinom i o ( const TCPolinomio & src ) { for ( int i = 0; i < size ; i ++) p [ i ] = src [ i ];}; // (9) O p e r a d o r de a t r i b u i ¸ c~ ao - Template adicional template < typename T , const int size > template < typename E > TCPolinomio & TCPolinomio :: operator =( const TCPolinomio & src ) { for ( int i = 0; i < size ; i ++) p [ i ] = src [ i ]; return * this ; }

Veja na listagem 28.7 o uso da classe template criada. Listing 28.7: Uso de classe template com template adicional. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

# include < iostream > # include < cmath > # include " T e m p l a t e C o m T e m p l a t e A d i c i o n a l . h " using namespace std ; // Usando a classe T C P o l i n o m i o int main () { const int size = 3; int x = 5; cout << " x = " << x << endl ; cout << " Criando polin^ o mio TCPolinomio < int > pInt1 ; " << endl ; TCPolinomio < int > pInt1 ; // (1) cout << " C o e f i c i e n t e s de pInt1 = " ; for ( int i =0; i < size ; i ++) cout << pInt1 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " pInt1 ( x ) = " << pInt1 ( x ) << endl ; // (4) cout << " \ nCriando polin^ o mio TCPolinomio < float , size > pFloat1 ; " << endl ; TCPolinomio < float , size > pFloat1 ; // (1) cout << " C o e f i c i e n t e s de pFloat1 = " ; for ( int i =0; i < size ; i ++) cout << pFloat1 [ i ] << ’\ t ’; // (5) cout << endl ; cout << " pFloat1 ( x ) = " << pFloat1 ( x ) << endl ; // (4) cout << " Igualando polin^ o mio s de tipos diferentes ... pInt1 = pFloat1 ; // (9) cout << " ... ok \ n " ; cout << " pInt1 ( x ) = " << pInt1 ( x ) << endl ; // (4)

";

return 0; } [ b u e n o @ l d s c 0 5 Cap -28] $ ./ Usando - T e m p l a t e C o m T e m p l a t e A d i c i o n a l




517

x = 5 Criando polin^ o mio TCPolinomio < int > pInt1 ; C o e f i c i e n t e s de pInt1 = 0 1 2 pInt1 ( x ) = 55 Criando polin^ o mio TCPolinomio < float , size > pFloat1 ; C o e f i c i e n t e s de pFloat1 = 0 1 2 pFloat1 ( x ) = 55 Igualando polin^ o mios de tipos diferentes ... ... ok pInt1 ( x ) = 55

28.2.2

Especializa¸ c˜ ao de classes templates

Podemos usar especializa¸co˜es para reescrever toda uma classe para um tipo espec´ıfico, em fun¸caõ deste n˜ ao ter o comportamento esperado (ou padr˜ ao). A especializa¸caõ customiza a classe template para um tipo espec´ıfico. Veja a seguir o prot´ otipo utilizado na especializa¸caõ de classes templates. Prot´ otipo: // Defini¸ca õ da classe template padr˜ ao template< typename Tipo > class TCNome {...}; // Defini¸ca õ da classe template especializada template<> class TCNome< TipoEspecializado > {...}; Com o uso de especializa¸co˜es, você pode criar vers˜ oes otimizadas da fun¸caõ/classe template. Note, entretanto, que se você especializar uma classe template, ter´ a de especializar todos os métodos da classe. Ou seja, ao criar uma especializa¸caõ de uma classe, a classe ter´ a de ser totalmente reescrita. Veja no exemplo a seguir como criar uma classe template TCNome que é especializada para o tipo Tipo* (ponteiro genérico) e para o tipo void* (ponteiro espec´ıfico void*). Veremos o uso de ponteiros void* na se¸caõ F.2. Exemplo // Defini¸ c~ ao da classe template template< typename Tipo > class TCNome {...}; // Especializa¸ c~ ao para Tipo* (qualquer ponteiro) template< typename Tipo > class TCNome< Tipo * > {....}; // Especializa¸ c~ ao espec´ ıfica para void* template<> class TCNome< void * > {.....}; Se uma classe com atributos est´ aticos foi especializada, n˜ ao se esque¸ca de definir externamente cada atributo est´ atico para o tipo especializado. Programa¸caõ Orientada a Objeto com C++


518

28.2. CLASSES TEMPLATE USO AVANCADO ¸ Exemplo: // Defini¸ c~ ao da classe template template < typename T > class TCNome { static T atributoEstatico; }; // Defin¸ c~ ao do atributoEstatico template < typename T > T TCNome::atributoEstatico = 0; // Especializa¸ c~ ao da classe para o tipo int // Defini¸ c~ ao da classe template template < int > class TCNome { static int atributoEstatico; }; // Defin¸ c~ ao do atributoEstatico especializado template<> int TCNome::atributoEstatico = 0;

28.2.3

Instanciando fun¸c˜ oes e classes template2

O c´ odigo da listagem 28.8, adaptado de [Lischner, 2003], mostra o uso de fun¸co˜es e classes template, como as mesmas podem ser instanciadas. Listing 28.8: Exemplo: Instanciando fun¸co˜es e classes template. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// A d a p t a d o de C ++ in a nutshell , de Ray L i s c h n e r // I n s t a n c i a n d o f u n ¸ c~ oes e classes templates # include < iomanip > # include < iostream > # include < ostream > const double pi = 3 . 1 4 1 5 9 2 6 5 3 5 8 9 7 9 2 ; // Fun¸ c~ ao template template < typename T > void Saida ( T obj ) { std :: cout << obj << ’\ n ’; } // Fun¸ c~ ao template template < typename T > T sqr ( T x ) { return x * x ; } // I n s t a n c i a ¸ c~ ao expl´ ı c i t a de sqr para o tipo int template int sqr < int >( int ) ; // Erro : ap´ os instancia¸ c~ a o de sqr < double > , uso ilegal do mesmo . template < > double sqr ( double x )



28.2. CLASSES TEMPLATE USO AVANCADO ¸ 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

519

{ return x * x ; } // Classe t e m p l a t e template < typename T > class TCCirculo { public : TCCirculo ( T r ) : raio ( r ) {} // O b s e r v e que sqr < > ´ e i n s t a n c i a d o quando TCCirculo < > ´ e instanciado. T Area () const { return pi * sqr ( raio ) ; } T Raio () const { return raio ; } private : T raio ; }; // S o b r e c a r g a da Fun¸ c~ a o t e m p l a t e Saida () template < typename T > void Saida ( const TCCirculo < T >& c ) { std :: cout << " TCCirculo ( " << c . Raio () << " ) \ n " ; } // I n s t a n c i a ¸ c~ a o e x p l i c i t a de TCCirculo < double > , e // i n s t a n c i a ¸ c~ ao impl´ ı c i t a sqr < double > template class TCCirculo < double >; int main () { using namespace std ; cout << " Chamando Saida (42) " << endl ; Saida (42) ; cout << " i sqr ( i ) " << endl ; for ( int i = 0; i < 5; ++ i ) // I n s t a n c i a ¸ c~ ao impl´ ı c i t a de sqr < int > cout << setw (2) < e de sqr < float > TCCirculo < float > o b j _ T C C i r c u l o F l o a t (1.0 f ) ; // I n s t a n c i a ¸ c~ ao impl´ ı c i t a de Saida < TCCirculo < float > > cout << " Chamando Saida ( o b j _ T C C i r c u l o F l o a t ) " << endl ; Saida ( o b j _ T C C i r c u l o F l o a t ) ; }

[ b u e n o @ l d s c 0 5 ] $ ./ a . out Chamando Saida (42) 42 i sqr ( i ) 0 0 1 1 2 4 3 9 4 16 Chamando Saida ( o b j _ T C C i r c u l o F l o a t ) TCCirculo (1)



28.3. USO DE EXPORT COM TEMPLATES3

520

28.3

Uso de export com templates3

A inclus˜ ao da palavra-chave export, foi alvo de grandes debates no comitê Ansi/ISO C++. Isto ocorreu porque, de um modo geral, primeiro os programadores desenvolvem novos conceitos que s˜ ao posteriormente incorporados nos compiladores e na linguagem padr˜ ao. Com export, o processo foi invertido. Os membros do comitê aprovaram o uso de export sem que nenhum compilador o suporta-se. Somente recentemente alguns poucos compiladores come¸caram a suportar o uso de export. A idéia por trás do uso de export é fornecer dois modelos distintos de organiza¸caõ do c´ odigo fonte. O primeiro, clássico, é conhecido como modelo de inclus˜ ao. O segundo, novo, é conhecido como modelo de separa¸ca õ. Veremos as diferen¸cas nesta se¸caõ. No modelo atual podemos declarar um método n˜ ao template no arquivo .h e defin´ı-lo do .cpp. Podemos compilar o programa tendo apenas a informa¸caõ disponibilizada no arquivo .h. Mas isto n˜ ao é poss´ıvel com templates. • No modelo de inclus˜ ao o c´ odigo fonte completo do template deve estar vis´ıvel para quem vai o utilizar. Isto tem sido feito incluindo todo c´ odigo do template no arquivo .h ou incluindo no final do arquivo .h o arquivo .cpp. • No modelo de separa¸caõ pretende-se permitir a compila¸cão separada de templates. Neste caso, a defini¸caõ do template n˜ ao precisa estar vis´ıvel para quem o chama. A idéia é permitir que um arquivo que use o template seja compilado sem ter sua defini¸caõ. Mas o que esta por trás desta mudan¸ca e porque isto ainda n˜ ao foi colocado em prática? Um dos objetivos desta mudan¸ca é eliminar a necessidade do c´ odigo-fonte (*.cpp). Seria fornecido diretamente o arquivo .h e o arquivo objeto. Desta forma impede-se o acesso do usu´ ario da biblioteca ao c´ odigo-fonte da biblioteca (templates), sendo este um claro interesse da ind´ ustria de software propriet´ ario. O segundo objetivo, este sim válido, consiste em aumentar a velocidade de compila¸caõ. A segunda quest˜ ao, esta associada ao fato de que pouqu´ıssimos compiladores tem suporte a export. Em resumo, evite usar export. Espere a próxima vers˜ ao do C++, C++0x, e o posicionamento dos ”gurus” de C++, para ver se export, vai ou n˜ ao ser adotado pela comunidade. Para maiores detalhes, consulte [Sutter, 2006].

28.4

Senten¸cas para uso avan¸ cado de templates

• No in´ıcio, C++ permitia o uso de fun¸co˜es template e de classes template globais. Você n˜ ao podia declarar uma classe normal com um método template. Agora isto é permitido, isto é, um método membro da classe pode ser definido como template. Neste caso, os argumentos do template s˜ ao definidos mediante a an´ alise dos parˆ ametros do método (listagem 28.4). • A instancia¸caõ de uma classe template n˜ ao garante que todos os membros sejam instanciados. Os membros ser˜ ao instanciados se forem efetivamente utilizados ou se forem necess´ arios para resolu¸caõ de alguma sobrecarga de operador. • Se numa classe template temos um método M() que tem erros de sintaxe, mas o método n˜ ao é utilizado, ent˜ ao alguns compiladores acusam o erro, outros n˜ ao. Programa¸caõ Orientada a Objeto com C++


28.4. SENTENCAS ¸ PARA USO AVANCADO ¸ DE TEMPLATES

521

• Quando uma classe é especializada, teremos a vers˜ ao padrão e as vers˜ oes especializadas. Quando criamos um objeto da classe template, passando seus argumentos, o compilador procura dentro das vers˜ oes especializadas qual tem maior coincidência. Se n˜ ao for encontrada uma vers˜ ao especializada, ent˜ ao a vers˜ ao padr˜ ao é utilizada. Se duas vers˜ oes especializadas tiverem o mesmo grau de coincidência ent˜ ao o compilador acusa uma ambiguidade, [Lischner, 2003]. • Quando criamos métodos template dentro de classes, a chamada ao método pode ficar inviabilizada pois o compilador, em alguns casos, confunde o operador < como sendo o operador menor que. A solu¸caõ é informar explicitamente que estamos tratando com um método template. Exemplo: class CNome { public: template< int n > int M(); template< int n > static int SM(); }; int main() { CNome obj; obj.template M<3>(); CNome::template SM<4>(); return 0; } • Note que um atributo privado pode ser acessado por qualquer método da classe, incluindo os métodos/fun¸co˜es amigas. Na prática, isto significa que estes métodos podem repassar - de forma oculta - este acesso para terceiros. Por exemplo, um método da classe pode retornar uma referência para um atributo privado, violando o conceito de invariˆ ancia da classe. Como um template de fun¸caõ pode ser especializado, o mesmo pode ser utilizado para violar o conceito de invariˆ ancia da classe. Veja se¸caõ 28.1.1. • 3 Segundo [Meyers, 2005], em classes templates derivadas use referências a nomes da classebase utilizando this, usando declara¸co˜es using, ou via qualifica¸caõ explicita da classebase. • 3 Um template dentro de uma classe normal ou de uma classe template é conhecido como ”membro template”. Segundo [Lischner, 2003], um ”membro template” tem as seguintes restri¸co˜es: – – – –

classes locais n˜ ao podem ter ”membro template”. uma fun¸caõ membro template n˜ ao pode ser um construtor. uma fun¸caõ membro template n˜ ao pode ser virtual. se a classe-base tem um método virtual, um método membro template com o mesmo nome e parˆ ametros numa classe-derivada n˜ ao oculta o método da classe-base.

• 3 Segundo [Sutter, 2006], export n˜ ao implica em compila¸caõ separada, export apenas oculta dependências, n˜ ao as elimina. • 3 Como export, ainda n˜ ao é devidamente compreendido e n˜ ao é suportado em vários compiladores, seu uso deve ser evitado. Principalmente em c´ odigos multiplataforma. Programa¸caõ Orientada a Objeto com C++



522

28.5


Neste cap´ıtulo aprendemos a utilizar conceitos avan¸cados de templates, o uso de fun¸co˜es e classes template especializadas. Para atender a casos espec´ıficos, aprendemos a criar especializa¸co˜es de fun¸co˜es template. Também aprendemos a otimizar o programa utilizando fun¸co˜es expandidas em tempo de compila¸caõ. Vimos ainda que podemos mapear fun¸co˜es template utilizando especializa¸co˜es, e que em casos especiais precisamos usar a palavra-chave typename para identificar com clareza o que queremos. Aprendemos ainda a criar templates dentro de classes template e a especializa¸caõ de classes. Finalmente, vimos que ainda n˜ ao devemos usar export. Dica: a biblioteca boost (veja Cap´ıtulo ?? - A biblioteca Boost ), e a biblioteca Blitz++ (veja Cap´ıtulo ?? - A biblioteca Blitz++), usam extensivamente os conceitos avan¸cados de templates, sendo boas referências para aprendizado e uso de templates. Dica: veja maiores detalhes de templates na referência Nicolai M. Josuttis e David Vandevoorde´s, ”C++ Templates - The Complete Guide”, [Vandevoorde and Josuttis, 2002].

28.6

Exerc´ıcios

1. Implementar a fun¸caõ Media(), da se¸caõ 28.1.4, usando o conceito de especializa¸caõ, se¸caõ 28.2.2. Ou seja, sem usar a struct double_trait. 2. Comentar o c´ odigo da listagem 28.8. 3. Na listagem 28.1, fazer com que a sa´ıda seja em ordem decrescente. 4. Explique o funcionamento da listagem 28.2. 5. Leia o manual da biblioteca Blitz++ (se¸caõ ??). 6. Usu´ arios avan¸cados devem ler o livro ”C++ Templates - The Complete Guide”, [Vandevoorde and Josuttis, 2002].



Cap´ıtulo 29

Implementando Associa¸ c˜ oes em C++ Como visto na Parte I - Filosofia e Modelagem Orientada a Objetos, existem relacionamentos entre objetos distintos. A esses relacionamentos damos o nome de associa¸co˜es ou dependências. Discutiremos neste cap´ıtulo a implementa¸caõ de associa¸co˜es utilizando C++. Veremos uma introdu¸caõ ` as associa¸co˜es em C++ (se¸caõ 29.1), o uso de associa¸caõ sem atributo (se¸caõ 29.2), e o uso de associa¸caõ com atributo (se¸caõ 29.3).

29.1

Introdu¸ c˜ ao ` as associa¸c˜ oes em C++

Uma associa¸caõ pode ser unidirecional, bidirecional e pode (ou n˜ ao) ter atributos. De um modo geral, pode ser implementada de três formas: • Implementar a associa¸caõ por meio de ponteiros para os objetos. • A cria¸caõ de uma classe que representa a associa¸caõ; neste caso, ser˜ ao necess´ arios ponteiros para a classe associa¸caõ partindo dos objetos associados (veja se¸caõ 6.4.5). • Utiliza¸caõ de fun¸co˜es friend (veja Cap´ıtulo 20 - Friend).

29.2

Associa¸c˜ ao sem atributo

Se a associa¸caõ for unidirecional e sem atributo de associa¸caõ, poder´ a ser implementada com um ponteiro na classe que faz o acesso. No exemplo a seguir a classe A acessa a classe B. Exemplo: class B; class A {... B* ptr_para_b; }; class B {... }; 523

˜ COM ATRIBUTO 29.3. ASSOCIAC ¸ AO

524

Se a associa¸caõ for bidirecional, ser˜ ao necess´ arios ponteiros em ambas as classes. No exemplo a seguir, a classe A acessa a classe B e a classe B acessa a classe A. Exemplo: class B; class A {... B* ptr_para_b; }; class B {... A* ptr_para_a; }; Se a associa¸caõ entre as duas classes for do tipo ”um para muitos”, cardinalidade um A para muitos Bs, ent˜ ao na classe que acessa ”muitos” deve ser implementado um vetor de ponteiros. Exemplo: class B; class A { vector< B* > vetor_b(N); }; class B { A* ptr_para_a; }; Se a associa¸caõ tiver uma cardinalidade ”muitos para muitos”, uma das solu¸co˜es é criar um dicion´ ario. Veremos como implementar um dicion´ ario usando na se¸caõ 34.4. Dica: no programa umbrello, quando modelar uma associa¸caõ, indicar na linha da associa¸caõ o nome do papel.

29.3

Associa¸c˜ ao com atributo

Vimos na se¸caõ 6.4.5 que uma associa¸caõ entre duas classes pode gerar uma classe de associa¸caõ. Veremos na listagem 29.1 como implementar uma classe de associa¸caõ. Observe que a classe de associa¸caõ pode ser declarada como amiga de A e B. Listing 29.1: Associa¸caõ com atributo de liga¸caõ. 1 2 3 4 5 6 7 8 9 10 11 12

# include < iostream > using namespace std ; class Associacao ; class A { int a ; public : Associacao * p t r A s s o c i a c a o ; friend class Associaca o ; };



29.4. RESUMO DO CAPÍTULO 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

525

class B { int b ; public : Associacao * p t r A s s o c i a c a o ; friend class Associacao ; }; class Associacao { int a t r i b u t o A s s o c i a c a o ; A * ptr_A ; B * ptr_B ; public : Associacao () : a t r i b u t o A s s o c i a c a o (0) , ptr_A (0) , ptr_B (0)

{

};

int A t r i b u t o A s s o c i a c a o () { return a t r i b u t o A s s o c i a c a o ; }; friend class A ; friend class B ; }; int main () { B b; Associacao associacao ; b . p t r A s s o c i a c a o = & associacao ; cout << " b . ptrAssociacao - > A t r i b u t o A s s o c i a c a o () = " < A t r i b u t o A s s o c i a c a o () << endl ; return 0; } [ b u e n o @ l d s c 0 5 ] $ ./ a . out b. ptr_associacao - > A t r i b u t o A s s o c i a c a o () =0

29.4


Neste cap´ıtulo aprendemos a implementar associa¸co˜es em C++, associa¸co˜es sem atributo e associa¸co˜es com atributo.

29.5

Exerc´ıcios

1. Modifique a listagem 29.1. 2. Monte um diagrama de classes no umbrello que inclua diferentes tipos de associa¸co˜es. N˜ ao se esque¸ca de nomear as associa¸co˜es, pois o umbrello usa o nome da associa¸caõ para gerar o c´ odigo. Gere os c´ odigos, veja se¸caõ 6.8.2. A seguir fa¸ca uma an´ alise dos c´ odigos gerados pelo umbrello.



526

29.5. EXERCÍCIOS



Cap´ıtulo 30

As Classes , e as Fun¸c˜ oes Matem´ aticas de Neste cap´ıtulo, veremos: • as fun¸co˜es matemáticas definidas no arquivo de cabe¸calho (se¸caõ 30.1), suas fun¸co˜es (se¸caõ 30.1.1), e exemplos de uso (se¸caõ 30.1.2). • a classe (se¸caõ 30.2), seus métodos (se¸caõ 30.2.1), exemplo de uso de (se¸caõ 30.2.2) e um resumo do arquivo da biblioteca padr˜ ao (se¸caõ 30.2.3). • a classe (se¸caõ 30.3), seus métodos (se¸caõ 30.3.1), e exemplos de uso de (se¸caõ 30.3.2) e com (se¸caõ 30.3.3).

30.1

Introdu¸ c˜ ao ` a biblioteca de C

Veremos nesta se¸caõ a utiliza¸caõ da biblioteca de C, a mesma fornece fun¸co˜es matemáticas.

30.1.1

Fun¸ coes de

Veja a seguir as fun¸co˜es de . Observe que nos prot´ otipos abaixo utilizamos o tipo double, mas estas fun¸co˜es s˜ ao definidas para float, double e long double. Prot´ otipo: double abs(double); Fun¸caõ valor absoluto. double ceil(double x); Fun¸caõ menor inteiro n˜ ao menor que x (arredonda para cima). double floor(double x); Fun¸caõ maior inteiro n˜ ao maior que x (arredonda para baixo). 527

528

˜ A ` BIBLIOTECA DE C 30.1. INTRODUC ¸ AO

double sqrt(double x); Fun¸caõ raiz quadrada de x. double pow(double x, int y); Fun¸caõ x elevado a potência de y. double cos(double x); Fun¸caõ cosseno. double sin(double x); Fun¸caõ seno. double tan(double x); Fun¸caõ tangente. double acos(double x); Fun¸caõ arco cosseno. double asin(double x); Fun¸caõ arco seno. double atan(double x); Fun¸caõ arco tangente. double atan2(double x, double y); Fun¸caõ atan de x/y. double cosh(double x); Fun¸caõ cosseno hiperb´ olico. double sinh(double x); Fun¸caõ seno hiperb´ olico. double tanh(double x); Fun¸caõ tangente hiperb´ olico. double exp(double x); Fun¸caõ expoente na base e de x. double log(double x); Fun¸caõ logaritmo neperiano, x > 0. double log10(double x); Fun¸caõ logaritmo na base 10, x > 0. double modf(double x, int* y); Fun¸caõ parte fracion´ aria em x, parte inteira em y. Nota: podemos utilizar (escopo global, usado por programas em C) ou (escopo da std, formato utilizado por programas em C++). Com , podemos chamar sin(30), cos(45) diretamente (pois as fun¸co˜es sin() e cos() est˜ ao no escopo global). Com , estamos no escopo da std, da´ı precisamos usar std::sin(30), std::cos(45). Programa¸caõ Orientada a Objeto com C++


˜ A ` BIBLIOTECA DE C 30.1. INTRODUC ¸ AO

30.1.2

529

Exemplos de uso de

Veja na listagem 30.1 exemplo de uso da biblioteca de C. Listing 30.1: Usando fun¸co˜es matemáticas de . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

# include < iostream > # include < iomanip > # include < cmath > using namespace std ; int main () { cout << setiosfla g s ( ios :: fixed | ios :: showpoint ) << s e t p r e c i s i o n ( 1 ) << " Raiz quadrada sqrt (700.0) = " << sqrt ( 700.0 ) << " \ n " << " Exponencia l neperiana ( e ^ x ) << s e t p r e c i s i o n (6)

exp (1.0) = " << exp (1.0) << " \ n "

<< " logaritmo neperiano log (2.718282) = " << s e t p r e c i s i o n (1) << log (2.718282) << " \ n " << " Logaritmo na base 10 log10 (1.0) = " << log10 ( 1.0 ) << " , log10 (10.0) = " << log10 ( 10.0 ) << " , log10 (100.0) = " << log10 ( 100.0 ) << " \ n " << " Fun¸ ca ~ o valor absoluto , m´ o dulo fabs (13.5) = " << fabs ( 13.5 ) << " \ n " << " , fabs (0.0) = " << fabs ( 0.0 ) << " , fabs ( -13.5) = " << fabs ( -13.5 ) << " \ n " << " Truncament o ceil (9.2) = " << " , ceil ( -9.8) = "

<< ceil ( 9.2 ) << ceil ( -9.8 ) << " \ n "

<< " A r r e d o n d a m e n t o floor (9.2) = " << " , floor ( -9.8) = "

<< floor ( 9.2 ) << floor ( -9.8 ) << " \ n "

<< " Potencia¸ ca ~ o x ^ y pow (2.0 ,7.0) = " << " fmod (13.675 , 2.333) = " << s e t p r e c i s i o n ( 1 ) << " \ n "

<< pow ( 2.0 , 7.0 ) << fmod ( 13.675 , 2.333 )

<< " Fun¸ co ~ es trigonom´ e trica s , sin , cos , tan \ n " << " sin (0.0) = " << sin ( 0.0 ) << " , cos (0.0) = " << cos ( 0.0 ) << " , tan (0.0) = " << tan ( 0.0 ) << endl ; return 0; }

Raiz quadrada sqrt (700.0) = 26.5 Exponenci al neperiana ( e ^ x ) exp (1.0) = 2.718282 logaritmo neperiano log (2.718282) = 1.0 Logaritmo na base 10 log10 (1.0) = 0.0 , log10 (10.0) = 1.0 , log10 (100.0) = 2.0 Fun¸ ca ~ o valor absoluto , m´ o dulo fabs (13.5) =13.5 , fabs (0.0) =0.0 , fabs ( -13.5) =13.5 Truncamen to ceil (9.2) = 10.0 , ceil ( -9.8) = -9.0 A r r e d o n d a m e n t o floor (9.2) = 9.0 , floor ( -9.8) = -10.0 Potencia¸ ca ~ o x ^ y pow (2.0 ,7.0) = 128.0 fmod (13.675 , 2.333) = 2.0 Fun¸ co ~ es trigonom´ e tric as , sin , cos , tan sin (0.0) = 0.0 , cos (0.0) = 1.0 , tan (0.0) = 0.0



˜ A ` CLASSE 30.2. INTRODUC ¸ AO

530

30.2


A classe é uma classe que suporta n´ umeros complexos, com a parte real e a imagin´ aria. Com a classe , você pode trabalhar com n´ umeros complexos diretamente, utilizando os operadores e métodos sobrecarregados. Pode igualar dois n´ umeros complexos, fazer compara¸co˜es, realizar opera¸co˜es aritméticas (+-*/), exponencia¸caõ, obter logaritmos, potência, entre outros. Os objetos podem ter precisão float, double e long double. Para criar um n´ umero complexo, você precisa incluir o arquivo de cabe¸calho e, a seguir, definir a precisão do n´ umero complexo. Veja o exemplo. Exemplo: #include int main() { complex cf; complex cd; complex cld; return 0; }

30.2.1

M´ etodos de

Veja a seguir os métodos da classe . Construtores e destrutor Como a classe representa um n´ umero complexo, você pode construir um n´ umero complexo a partir da parte real, ou a partir da parte real e da imaginária. complex (const Tipo& real = Tipo(), const Tipo & img = Tipo()); Recebe como parˆ ametro a parte real e a parte imaginária. Observe que o construtor tem parˆ ametros pré-definidos, de forma que se os mesmos n˜ ao forem passados, assume o valor default para o tipo, 0 para os tipos numéricos. Note ainda que podemos construir um n´ umero complexo apenas com a parte real. complex (const complex&); Construtor de c´ opia. ˜complex (); Destrutor. Veja o exemplo. Exemplo: // Cria um n´ umero complexo, do tipo float com nome cf complex cf; // Cria um n´ umero complexo, do tipo double e passa parte real double parteReal = 3.4; complex cd( parteReal ); // Cria um n´ umero complexo e passa a parte real e a parte imagin´ aria double parteImg = 21.5; Programa¸caõ Orientada a Objeto com C++



531

complex cld( parteReal , parteImg ); // Construtor de c´ opia, cria c´ opia de cf complex cf2( cf ); M´ etodos utilit´ arios A classe fornece um conjunto de métodos que possibilitam a obten¸caõ de propriedades deste, como o módulo, o argumento, a norma, o conjugado, entre outros. Tipo& real(); Retorna a parte real de um n´ umero complexo. Tipo& imag(); Retorna a parte imagin´ aria de um n´ umero complexo. Tipo abs(const complex&); Retorna magnitude. Tipo arg(const complex&); Retorna angulo de fase. Tipo norm(const complex&); Retorna magnitude ao quadrado. complex conj(const complex&); Retorna n´ umero complexo conjugado. complex polar(const Tipo& rho, const Tipo& theta= 0); Retorna n´ umero complexo com magnitude rho e angulo theta. Veja a seguir um exemplo. Exemplo: float real = cf.real(); // Retorna parte real float img = cf.imag(); // Retorna parte imagin´ aria float abs = cf.abs( ); // Retorna m´ odulo float arg = cf.arg(); // Retorna argumento // Soma dos quadrados da parte real e da imagin´ aria float norm = cf.norm(); // A magnitude e o ^ angulo de fase const float magnitude =3; const float fase =45; float p = cf.polar (magnitude, fase); // Retorna o conjugado complex cf_conjugado = cf.conj(); M´ etodos trancendentais A classe fornece um conjunto de métodos transcendentais, como acos, asin, atan, atan2, cos, cosh, exp, log, log10, pow, sin, sinh, sqrt, tan, tanh. Veremos na listagem 30.3 um resumo da classe fornecida pela biblioteca padr˜ ao de C++, o que inclui o prot´ otipo dos métodos trancendentais. Programa¸caõ Orientada a Objeto com C++



532 Operadores sobrecarregados

Diversos operadores foram sobrecarregados para a classe , a lista é dada por: +, -, *, /, += ,-= , *= , -, * ,+ , -. Também foram definidos operadores de compara¸caõ (==, !=) e operadores de inser¸caõ e extra¸caõ (stream), ou seja, podemos enviar n´ umeros complexos diretamente para tela com cout. Veremos na listagem 30.2 exemplos de uso dos operadores que foram sobrecarregados. template plex& template plex&

30.2.2

istream& operator > > (istream& is, comx); ostream& operator < < (ostream& os, const comx);

Exemplo de uso de

Veja na listagem 30.2 um exemplo da utiliza¸caõ da classe , observe a forma como a classe complexo sobrecarregou os operadores < < e > >. O n´ umero complexo aparece dentro de parênteses. Listing 30.2: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# include < iostream > # include < complex > using namespace std ; int main () { complex < double > c1 (1.2 , 3.4) ; complex < double > c2 ( -9.8 , -7.6) ; cout << " c1 = " << c1 << " , c2 = " << c2 << endl ; c1 += c2 ; c2 /= sin ( c2 ) * cos ( c1 ) ; cout << " c1 = " << c1 << " , c2 = " << c2 << endl ; c2 *= log ( c1 ) + pow ( c2 , c1 ) ; c1 -= c1 / c2 ; cout << " c1 = " << c1 << " , c2 = " << c2 << endl ; cout << " Entre com o complexo c1 ( real , imag ) : " ; cin >> c1 ; cin . get () ; cout << " Conte´ u do de c1 = " << c1 << endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - II ] $ ./ a . out c1 = (1.2 ,3.4) , c2 = ( -9.8 , -7.6) c1 = ( -8.6 , -4.2) , c2 = (7.77139 e -05 , -0.000364079) c1 = ( -8.6 , -4.2) , c2 = (3.37075 e +23 , -1.75436 e +23) Entre com o complexo c1 ( real , imag ) : (3 ,4) Conte´ u do de c1 = (3 ,4)

30.2.3

Resumo da classe fornecida pela biblioteca padr˜ ao

Veja na listagem 30.3 um resumo da classe fornecida pela biblioteca padr˜ ao de C++. Programa¸caõ Orientada a Objeto com C++



533

Listing 30.3: A classe da biblioteca padr˜ ao. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

// Resumo do a r q u i v o c o m p l e x da b i b l i o t e c a padr~ a o de C ++ // As d e f i n i ¸ c~ o e s de t e m p l a t e foram t i r a d a s para maior b r e v i d a d e // Cria v e r s ~ o e s de n ´ u m e r o s c o m p l e x o s para float , double , long double class complex ; template < > class complex < float >; template < > class complex < double >; template < > class complex < long double >; // A classe c o m p l e x struct complex { private : Tipo _M_real ; // / Parte real Tipo _M_imag ; // / Parte i m a g i n ´ aria public : // / D e f i n i ¸ c~ a o do t y p e d e f para v a l u e _ t y p e . typedef Tipo value_type ; // / C o n s t r u t o r padr~ ao . O primeiro par^ ametro ´ e a parte real , // / o s e g u n d o a parte i m a g i n ´ aria. // / P a r ^ a m e t r o s n~ a o d e f i n i d o s a s s u m e m valor 0. complex ( const Tipo & = Tipo () , const Tipo & = Tipo () ) ; // / C o n s t r u t o r de c´ o pia . complex ( const complex < Tipo2 >&) ; // / R e t o r n a parte real do n´ u mero c o m p l e x o Tipo & real () ; const Tipo & real () const ; // / R e t o r n a parte i m a g i n ´ a r i a do n´ u mero c o m p l e x o Tipo & imag () ; const Tipo & imag () const ; // / O p e r a d o r e s complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >& complex < Tipo >&

sobrecarregados ( m´ e t o d o s membro ) operator =( const Tipo &) ; operator +=( const Tipo &) ; operator -=( const Tipo &) ; operator *=( const Tipo &) ; operator /=( const Tipo &) ; operator =( const complex < Tipo2 >&) ; operator +=( const complex < Tipo2 >&) ; operator -=( const complex < Tipo2 >&) ; operator *=( const complex < Tipo2 >&) ; operator /=( const complex < Tipo2 >&) ;

// / O p e r a d o r e s s o b r e c a r r e g a d o s ( f u n ¸ c~ o e s amigas ) operator +( const complex < Tipo >& __x , const complex < Tipo >& __y ) ; operator +( const complex < Tipo >& __x , const Tipo & __y ) ; operator +( const Tipo & __x , const complex < Tipo >& __y ) ; operator -( const complex < Tipo >& __x , const complex < Tipo >& __y ) ; operator -( const complex < Tipo >& __x , const Tipo & __y ) ; operator -( const Tipo & __x , const complex < Tipo >& __y ) ; operator *( const complex < Tipo >& __x , const complex < Tipo >& __y ) ; operator *( const complex < Tipo >& __x , const Tipo & __y ) ; operator *( const Tipo & __x , const complex < Tipo >& __y ) ; operator /( const complex < Tipo >& __x , const complex < Tipo >& __y ) ; operator /( const complex < Tipo >& __x , const Tipo & __y ) ;




534 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

operator /( const Tipo & __x , const complex < Tipo >& __y ) ; operator +( const complex < Tipo >& __x ) ; operator -( const complex < Tipo >& __x ) ; operator > >( basic_istream < _CharT , _Traits >& __is , complex < Tipo >& __x ) ; operator < <( basic_ostream < _CharT , _Traits >& __os , const complex < Tipo >& __x ) ; // F u n ¸ c~ oes matem´ a t i c a s para n ´ umeros complexos // / R e t o r n a m a g n i t u d e Tipo abs ( const complex < Tipo >&) ; // / R e t o r n a angulo de fase Tipo arg ( const complex < Tipo >&) ; // / R e t o r n a m a g n i t u d e ao q u a d r a d o Tipo norm ( const complex < Tipo >&) ; // / R e t o r n a n´ u mero c o m p l e x o c o n j u g a d o complex < Tipo > conj ( const complex < Tipo >&) ; // / R e t o r n a n´ u mero c o m p l e x o com m a g n i t u d e rho e angulo theta . complex < Tipo > polar ( const Tipo & , const Tipo & = 0) ; // / M ´ etodos transcendentais: complex < Tipo > cos ( const complex < Tipo >&) ; complex < Tipo > cosh ( const complex < Tipo >&) ; complex < Tipo > exp ( const complex < Tipo >&) ; complex < Tipo > log ( const complex < Tipo >&) ; complex < Tipo > log10 ( const complex < Tipo >&) ; complex < Tipo > pow ( const complex < Tipo >& , int ) ; complex < Tipo > pow ( const complex < Tipo >& , const Tipo &) ; complex < Tipo > pow ( const complex < Tipo >& , const complex < Tipo >&) ; complex < Tipo > pow ( const Tipo & , const complex < Tipo >&) ; complex < Tipo > sin ( const complex < Tipo >&) ; complex < Tipo > sinh ( const complex < Tipo >&) ; complex < Tipo > sqrt ( const complex < Tipo >&) ; complex < Tipo > tan ( const complex < Tipo >&) ; complex < Tipo > tanh ( const complex < Tipo >&) ; };

30.3


Apresentaremos nesta se¸caõ a classe , uma classe criada para manipula¸caõ de vetores de bits. Você vai aprender a criar e usar um vetor de bits com tamanho definido durante a compila¸caõ. Veja a seguir algumas dicas para uso de . • O tamanho do vetor de bits deve ser definido em tempo de compila¸caõ, ou seja, um objeto é um objeto est´ atico. • O valor default de cada bit é 0. • Um pode ser constru´ıdo a partir de uma string de zeros (0) e um (1). • Todo acesso b[i] é verificado; se i est´ a fora do intervalo, uma exce¸caõ do tipo out_of_range é lan¸cada. • N˜ ao confunda um operador sobre bits (& e |) com operadores l´ ogicos (&& e ||). • A grande vantagem de é a possibilidade de manipular um vetor de flags (0, 1), consumindo pouca mem´ oria. • Para criar um objeto , inclua o arquivo de cabe¸calho . Programa¸caõ Orientada a Objeto com C++



30.3.1

535

M´ etodos de

void set(n); Seta o bit n para true. void reset(n); Seta o bit n para false. void flip(n); Inverte o valor do bit n. void set(); Seta todos os bits para true. void reset(); Seta todos os bits para false. void flip(); Inverte o valor de todos os bits. int size(); Retorna a dimensão do . int count(); Retorna o n´ umero de bits ativos. bool any(); Retorna true se tiver pelo menos um bit ativo. bool none(); Retorna true se todos inativos operator< <(); Rotaciona os bits para esquerda. operator> >(); Rotaciona os bits para direita. operator[] (int i); Retorna o valor do bit na posi¸caõ i.

30.3.2

Exemplos de uso da classe

Veremos uma breve descri¸caõ de cada método da classe no exemplo da listagem 30.4. A listagem é auto-explicativa. Na sa´ıda mostramos que o b consome 8 bytes em uma plataforma de 64 bits. Listing 30.4: Exemplo descritivo da classe . 1 2 3 4 5 6 7 8

# include < bitset > # include < iostream > using namespace std ; int main () { const int size = 5; cout << " Cria objeto do tipo bitset com tamanho size " << size




536 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

<< " e nome b . " << endl ; std :: bitset < size > b ; long unsigned int n ; cout << " Entre com o bit que deseja modificar n = " ; cin >> n ; cin . get () ; cout << " Seta o bit n = " << n << " para true --> " ; b . set ( n ) ; cout < " ; b . reset ( n ) ; cout < " ; b . set () ; cout < " ; b . reset () ; cout < " ; b . flip ( n ) ; cout < " ; b . flip () ; cout << b << endl ; cout << " Usa m´ e todo teste ( n ) , com n = " << n ; bool t = b . test ( n ) ; cout << " bool t = b . test ( n ) ; t = " << t << endl ; cout << << << << << << cout <<

" Tamanho do bitset - - > b . size () = " << b . size () " \ nN´ u mero de bits ativados b . count () = " << b . count () " \ nRetorna true se tem pelo menos um bit esta ativo b . any () = " b . any () " \ nRetorna true se todos os bits est~ a o inativos b . none () = " b . none () << endl ; " Cria bitset b1 e b2 e faz b1 [ n ] = 1; " << endl ;

std :: bitset < size > b1 ; std :: bitset < size > b2 ; b1 [ n ] = 1; if ( b1 cout if ( b1 cout

== << != <<

b2 ) " b1 == b2 " << endl ; b2 ) " b1 != b2 " << endl ;

cout << " Realiza um AND bit a bit e armazena em b1 : b1 &= b2 ; " << endl ; b1 &= b2 ; cout << " b1 - - > " << b1 << " b2 - - > " << b2 << endl ; cout << " Realiza um OR bit a bit e armazena em b1 : b1 [1] = 1; b1 != b2 ; " << endl ; b1 [1] = 1; b1 != b2 ; cout << " b1 - - > " << b1 << " b2 - - > " << b2 << endl ;



˜ A ` CLASSE 30.3. INTRODUC ¸ AO 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

537

cout << " Realiza um XOR bit a bit e armazena em b1 : b1 ^= b2 ; " << endl ; b1 ^= b2 ; cout << " b1 - - > " << b1 << " b2 - - > " << b2 << endl ; b1 . reset () ; b1 [ n ] = 1; b1 > >= n ; cout << " Ap´ o s b1 . reset () ; b1 [ n ] = 1; b1 > >= n ; " << " b1 - - > " << b1 << endl ; b1 < <= n ; cout << b1 << endl ; cout << " Ap´ o s b1 < <= n ; " << " b1 - - > " << b1 << endl ; cout << " Veja que o bitset b consome apenas " << sizeof ( b ) << " bytes \ n " ; return 0; } [ b u e n o @ l d s c 0 5 Cap -30] $ ./ E x e m p l o D e s c r i t i v o D a C l a s s e b i t s e t Cria objeto do tipo bitset com tamanho size 5 e nome b . Entre com o bit que deseja modificar n =1 Seta o bit n =1 para true - - >00010 Seta o bit n =1 para false - - >00000 Seta todos os bits para true - - >11111 Seta todos os bits para false - - >00000 Inverte o bit n =1 - - >00010 Inverte todos os bits - - >11101 Usa m´ e todo teste ( n ) , com n =1 bool t = b . test ( n ) ; t = 0 Tamanho do bitset - - > b . size () =5 N´ u mero de bits ativados b . count () =4 Retorna true se tem pelo menos um bit esta ativo b . any () =1 Retorna true se todos os bits est~ a o inativos b . none () =0 Cria bitset b1 e b2 e faz b1 [ n ] = 1; b1 != b2 Realiza um AND bit a bit e armazena em b1 : b1 &= b2 ; b1 - - >00000 b2 - - >00000 Realiza um OR bit a bit e armazena em b1 : b1 [1] = 1; b1 != b2 ; b1 - - >00010 b2 - - >00000 Realiza um XOR bit a bit e armazena em b1 : b1 ^= b2 ; b1 - - >00010 b2 - - >00000 Ap´ o s b1 . reset () ; b1 [ n ] = 1; b1 > >= n ; b1 - - >00001 00010 Ap´ o s b1 < <= n ; b1 - - >00010 Veja que o bitset b consome apenas 8 bytes

30.3.3

Exemplo de uso de com 2

Apresenta-se na listagem 30.5 o uso da classe com a classe container . O container é descrito em detalhes no Cap´ıtulo 32 - Os Containers Sequênciais , , . O programa cria um vetor com dimensão nbitsets, sendo cada célula do vetor um bitset com tamanho nbits. Lembre-se que para criar um vetor de 50 inteiros, utiliza-se vector v(50);. Para criar um vetor de 50 objetos do tipo bitset, deve-se fazer vector< bitset > v(50);. Com v[i], acessa o objeto bitset [i], e com v[i][j] acessa-se objeto [i], bit [j]. Usamos um for para setar os valores de cada elemento da matriz de bits que criamos. No final o programa solicita a posi¸caõ do vetor e a posi¸caõ do bit que deve ser alterado.




538

Listing 30.5: Usando com , criando uma matriz de bits. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

# include < iostream > # include < cmath > # include < bitset > # include < vector > using namespace std ; int main () { // Dimens~ a o fixa do vetor de bits const int nbits = 24; // Dimens~ a o vari´ a vel do vetor cout << " Entre com o numero de bitsets :"; int nbitsets ; cin >> nbitsets ; cin . get () ; // Cria o vetor de bitsets , observe que nbits e ´ constante vector < bitset < nbits > > v ( nbitsets ) ; // v [ i ] acessa o bitset i , v [ i ][ j ] acessa o bitset i posi¸ ca ~o j for ( int i = 0; i < v . size () ; i ++) for ( int j = 0; j < nbits ; j ++) v [ i ][ j ] = ( rand () % 2) ; for ( int i = 0; i < v . size () ; i ++) cout << v [ i ] << ’ ’; cout << endl ; int d ; do { int bitset_i , bit_j ; cout << "\ nEntre com o bitset que deseja alterar 0 - >" << v . size () -1 << ": "; cin >> bitset_i ; cout << " Entre com o bit que deseja alterar de 0 - >" << nbits - 1 << ": "; cin >> bit_j ; cout << " Entre com o novo valor do bit (0 ou 1) , >1 encerra programa : "; cin >> d ; cin . get () ; v [ bitset_i ][ bit_j ] = d ; cout << "\ nbitset " << bitset_i << " bit " << bit_j << " valor =" << v [ bitset_i ][ bit_j ] << endl ; for ( int i = 0; i < v . size () ; i ++) cout << v [ i ] << " "; } while ( d <= 1) ; return 0; } [ b u e n o @ l d s c 0 5 ] $ ./ a . out Entre com o numero de bitsets :3 110100000110101100111101 001011110101110001111000 101110101011100010010101 Entre com o bitset que deseja alterar 0 - >2: 1 Entre com o bit que deseja alterar de 0 - >23: 3 Entre com o novo valor do bit (0 ou 1) , >1 encerra programa : 0




539

bitset 1 bit 3 valor =0 110100000110101100111101 001011110101110001110000 101110101011100010010101 Entre com o bitset que deseja alterar 0 - >2:

Dica: a STL criou uma especializa¸caõ para vector que é utilizada para armazenar verdadeiro/falso (true/false). A vantagem de vector em rela¸caõ a é que o mesmo pode ser redimensionado, quando n˜ ao.

30.4


Neste cap´ıtulo aprendemos a usar a classe da biblioteca padr˜ ao de C++. A classe é muito u ´ til para solu¸caõ de problemas matemáticos e de engenharia, e o fato da classe ter diversos operadores e métodos trancendentais facilita seu uso. Adicionalmente, os métodos real(); imag(); abs(); arg() norm(); conj(); polar(); s˜ ao fáceis de usar, o que pode ser verificado através dos exemplos apresentados. Vimos que a classe representa um vetor de bits com tamanho definido em tempo de compila¸caõ. Os métodos de , set(n); reset(n); flip(n); set(); reset(); flip(); size(); count(); any(); none(); também s˜ ao bastante simples. Finalmente vimos as fun¸co˜es matemáticas definidas no arquivo de cabe¸calho , seus prot´ otipos e exemplos de uso.

30.5

Exerc´ıcios

1. Modifique a listagem 30.2 , acrescentando novos usos de . 2. Modifique as listagens 30.4, acrescentando novos usos de . 3. Monte um programa que utilize as fun¸co˜es matemáticas de . 4. Implementar a hieraraquia de classes da Figura 30.1. Observe que temos três hierarquias de classes, Solver, Funcao e Integral. A classe de teste vai criar um objeto fun¸caõ e a seguir usar um objeto do tipo Solver para achar o zero de equa¸co˜es.



30.5. EXERCÍCIOS

540

soevgotr*al():bolPIn e lverr solverV+ PVVaydlcixm atce ointg er/agN arlm elspaceTIntVV+ edalgiA rIxm antSInleugf:pr(:dpadooFt)eubublrnvlcIan o:tSItenoe/fN apur:bdlm eioutbslpeaceSoS f21T~ TestFauS(In)nT c a : l t e g r a i t o s n : * ) d b l F u c a o o u e : f«+ 1y(_v)p td raZterfo1 p v:e i+ Sup:douS bo lelv)e:rdouble«esF m d»foInub:ledouble,_im i t n m s o n I S p ( * ) d b l A F F t r e a p r u c a o u c a o u e : : f + u n c a o i T t n r a z o I p ( * ) d b l A F F t r e a p r u c o u n c a o u e : : i + t t r e o » p u n c a T F u n c a o l i G T P 1 lnfo::lvdeuruN i,,__tlo B o n m o o vbbelrw sim cn e a o d b l x o e : S V d b l 1 a o u e : y u V (+ l+ iZeerroo(__lim fInS d Sm lR d b ) d b l Z Im uSaupp u e o u e :h ::sdon 2 ( ) d b l ) d b l t p r a x o e o u e : : + 0 T F n c # ( ) d b l ) d b l t p e r x o u e o u e : : o + ~ l i G 0 d b l ) T P 1 1 o n m a a o u e : i i b A , u e s _ _ a ( ) d b l ) d b l t o p e r a x o u e o u e : : + G u :+ uble):double+ fTYXPxF((uv)cano:ltudoe/N l:adm bueslpea)ceV# l:d_oau0ble)o:idnum 2 G T P o o 32pP:eduriaontuo:bm l(e)x2G aToG ,b_lea1:double,_a2:double)

Figura 30.1: Pequena hierarquia de métodos numéricos (solver e integral numérica de fun¸co˜es do tipo polinômios).



Parte III

Introdu¸c˜ ao a STL

541

Cap´ıtulo 31

Introdu¸c˜ ao a Biblioteca Padr˜ ao de Gabaritos de C++ - STL No Cap´ıtulo 9, aprendemos que C++ é fundamentada na utiliza¸caõ de tipos, os quais se subdividem em tipos b´ asicos de C++ (char, int, double etc.), tipos definidos pelo usuário (SPessoa, UPropriedade, EDia, CPonto, CCirculo etc.) e tipos definidos em bibliotecas externas. Como exemplos de bibliotecas, abordamos a utiliza¸caõ de strings, de n´ umeros complexos e a hierarquia de streams (entrada e sa´ıda de dados). Neste cap´ıtulo, veremos a biblioteca-padr˜ ao de gabaritos, a STL - Standard Template Library. Iniciamos este cap´ıtulo definindo o que é a STL (se¸caõ 31.1), suas caracter´ısticas (se¸caõ 31.1.1) e componentes (se¸caõ 31.1.2). A seguir, apresentamos uma introdu¸caõ aos diferentes tipos de containers (se¸caõ 31.2). Os containers seq¨ uenciais , e (se¸caõ 31.2.1), os containers adaptativos , e (se¸caõ 31.2.2), e os containers associativos , , e (se¸caõ 31.2.3). Descreveremos os métodos e operadores comuns aos diversos container’s (se¸caõ 31.2.4), os métodos válidos apenas para os container’s seq¨ uenciais (se¸caõ 31.2.5), e os typedef’s comuns aos diversos containers (se¸caõ 31.2.6). Finalmente, veremos uma introdu¸caõ aos iteradores (iterators) (se¸caõ 31.3), os tipos de iteradores (se¸caõ 31.3.1) e opera¸co˜es comuns com iteradores (se¸caõ 31.3.2). Veremos ainda as fun¸co˜es predicado (se¸caõ 31.6). Nota: uma descri¸caõ adicional da STL pode ser obtida em http://www.cplusplus.com/ reference/stl/.

31.1

O que ´ e a STL?

A STL, ou Standard Template Library, é uma biblioteca de objetos avan¸cada e u ´ til, desenvolvida por Alexander Stepanov, Meng Lee e David Musser, utilizando os conceitos mais modernos da programa¸caõ orientada a objeto. Todo desenvolvimento da STL foi acompanhado e aprovado pelo comitê de padroniza¸caõ do C++, o ANSI C++ (veja se¸caõ 7.3). A biblioteca-padr˜ ao de C++ inclui as classes string, streams, internacionaliza¸caõ, exce¸co˜es, classes matemáticas (complex, valarray), utilitários (auto_ptr), gerenciamento de memória (new e delete) e as classes da STL. Ou seja, a STL é uma parte da biblioteca-padr˜ ao de C++. Veja na Figura 31.1 uma ilustra¸caõ da biblioteca padr˜ ao de C++. Nota: as classes , , string, wstring, valarray, e vector s˜ ao pseudo-container, porque suportam apenas parte dos algoritmos genéricos. 543

´ A STL? 31.1. O QUE E

544

Figura 31.1: Diagrama UML da biblioteca padr˜ ao de C++. streans

stl sequenciais

associativos

ios_base

adaptativos

locale

matemáticas

exceções

exception

logic_error

out_of_range

31.1.1

bad_alloc

bad_cast

lenght_error

bad_exception

bad_typeid

invalid_argument

domain_error

underflow_error

overflow_error

runtime_error

ios_base::failure

range_error

Caracter´ısticas da STL

• N˜ ao utiliza polimorfismo em fun¸caõ do desempenho. • Utiliza extensivamente os templates (veja Cap´ıtulo 27 - Templates). • Constru´ıda basicamente sobre três conceitos: containers, iteradores e programa¸caõ genérica (se¸caõ 31.1.2).

31.1.2

Componentes da STL

• Containers: objeto utilizado para armazenar grupos de objetos (como ). Veja introdu¸caõ aos containers na se¸caõ 31.2 e detalhes nos Cap´ıtulos 32, 33 e 34. • Iteradores: Vimos no Cap´ıtulo 15 - Utiliza¸caõ de Ponteiros e Referências o uso de ponteiros. Veremos na se¸caõ 31.3 que iteradores s˜ ao ponteiros inteligentes. • Programa¸ c˜ ao gen´ erica: conjunto de fun¸co˜es que podem ser utilizadas com objetos e containers com os mais variados e genéricos tipos de dados. Inclui fun¸co˜es para preenchimento, compara¸caõ, remo¸caõ, troca, mistura, pesquisa, ordena¸caõ, classifica¸caõ e Programa¸caõ Orientada a Objeto com C++


˜ AOS CONTAINERS 31.2. INTRODUC ¸ AO

545

transforma¸caõ dos containers e de seus elementos (veja Cap´ıtulo 35 - Programa¸caõ Genérica).

31.2

Introdu¸ c˜ ao aos containers

Se você tem um grupo de objetos do mesmo tipo ou de uma mesma hierarquia, pode organizá-los por meio de um container. Um container é uma espécie de caixa onde objetos do mesmo tipo podem ser armazenados. Existem diferentes tipos de containers e a escolha do container mais adequado vai depender do que você pretende realizar sobre o seu grupo de objetos. Os containers podem ser divididos em três categorias: os seq¨ uenciais (se¸caõ 31.2.1), os associativos (se¸caõ 31.2.2) e os adaptativos (se¸caõ 31.2.3). Estes containers e suas principais caracter´ısticas s˜ ao descritos a seguir.

31.2.1

Container’s sequ ëncias

Os containers seq¨ uenciais s˜ ao , e . Estes s˜ ao u ´ teis para armazenar estruturas de dados (ou objetos) que est˜ ao normalmente em seq¨ uência. Ser˜ ao descritos no Cap´ıtulo 32 - Containers Seq¨ uenciais , e . Veja na Figura 31.2 uma ilustra¸caõ dos containers seq¨ uenciais. Figura 31.2: Container’s seq¨ uenciais - , , .

Containers vector

0

list

0

deque

0

Sequenciais 1

2

3

1

1

2

...

...

3

...

n-2 n-1

n-2

n-1

n-2 n-1

Descrevemos a seguir o nome do container, suas caracter´ısticas b´ asicas e os iteradores suportados. O container funciona como um vetor comum permitindo acesso aleat´ orio (Figura 31.2). Tem r´ apida inser¸caõ de objetos no final do vetor e lenta no meio. Suporta iterador de acesso randˆ omico. Ser´ a descrito na se¸caõ 32.1. Utilize o container quando precisar de uma lista de objetos em que novos objetos podem ser inclu´ıdos em qualquer posi¸caõ, ou seja, tem inser¸caõ e dele¸caõ r´ apida em qualquer posi¸caõ (Figura 31.2). Lento para acesso randˆ omico. Suporta iterador de acesso bidirecional. Ser´ a descrito na se¸caõ 32.2. Programa¸caõ Orientada a Objeto com C++



546

Utilize o container quando precisar de uma lista de objetos em que novos objetos podem ser inclu´ıdos em qualquer posi¸caõ (Figura 31.2). Tem as vantagens de ´ uma fila com duas pontas. Permite acesso aleat´ e . E orio. Suporta iterador de acesso randˆ omico. Ser´ a descrito na se¸caõ 32.3.

31.2.2

Container’s associativos

Os containers associativos funcionam com o conceito de chaves (keys). Estes podem ser utilizados para armazenar um grupo de objetos que est˜ ao sempre ordenados (container ), ou para relacionar uma determinada chave com um valor (container ). Os containers associativos est˜ ao sempre ordenados; por default, o operador < é utilizado para ordena¸caõ. Ser˜ ao descritos no Cap´ıtulo 31 - Containers Associativos , , e . Veja na Figura 31.3 uma ilustra¸caõ dos containers associativos. Figura 31.3: Container’s associativos - , , , . Containers

Associativos

Um container armazena um conjunto de chaves (sem repeti¸co˜es) e tem pesquisa r´ apida. Suporta iterador de acesso bidirecional. Ser´ a descrito na se¸caõ 34.2. Um container armazena um conjunto de chaves (com repeti¸co˜es) e tem pesquisa r´ apida. Suporta iterador de acesso bidirecional. Ser´ a descrito na se¸caõ 34.3. Programa¸caõ Orientada a Objeto com C++



547

Um container armazena um conjunto de pares [chave, objeto] (sem repeti¸co˜es). Suporta iterador de acesso bidirecional. Ser´ a descrito na se¸caõ 34.4. Um container armazena um conjunto de pares [chave,objeto] (com repeti¸co˜es dos objetos, isto é, relacionamentos um para muitos, uma chave para muitos objetos). Suporta iterador de acesso bidirecional. Ser´ a descrito na se¸caõ 34.5.

31.2.3

Container’s adaptativos

S˜ ao containers criados a partir da adapta¸caõ de um container de seq¨ uência, ou seja, pode ser constru´ıdo tendo como base um , um ou um . Ser˜ ao descritos no Cap´ıtulo 30 - Containers Adaptativos , e . Um container funciona como uma pilha LIFO (last in, first out ) (o u ´ ltimo que entra é o primeiro que sai). Semelhante à pilha de uma calculadora HP. Pode ser constru´ıdo tendo como base um , (default ) ou . N˜ ao suporta iteradores. Ser´ a descrito na se¸caõ 33.1. Um container funciona como uma fila FIFO (first in, first out ) (o primeiro que entra é o primeiro que sai). Pode ser constru´ıdo tendo como base um , (default ) ou . N˜ ao suporta iteradores. Ser´ a descrito na se¸caõ 33.2. Um container funciona como uma fila ordenada, onde quem sai é sempre o maior valor. Os elementos est˜ ao sempre ordenados. Pode ser constru´ıdo tendo como base um ou um (default ). N˜ ao suporta iteradores. Ser´ a descrito na se¸caõ 33.3. J´ a descrevemos os diferentes tipos de containers, vamos descrever a seguir alguns métodos/funço˜es e operadores que s˜ ao comuns e est˜ ao presentes em diversos containers.

31.2.4

M´ etodos e operadores comuns aos diversos container’s

Alguns métodos e operadores est˜ ao presentes em todos os containers. Esses métodos e operadores s˜ ao listados na Tabela 31.1 e s˜ ao ilustrados na Figura 31.4. Observe a presen¸ca de métodos para inclus˜ ao e elimina¸caõ de objetos, métodos que retornam a dimensão e capacidade do container. Os métodos push_front() e push_back() s˜ ao utilizados para adicionar ao container objetos no in´ıcio e no fim do container, respectivamente. Os métodos pop_front(), erase() e pop_back() s˜ ao utilizados para apagar objetos do container. Você pode obter c´ opias dos objetos utilizando front(), at() e back(). Para verificar o tamanho alocado do container, utilize capacity(), para obter o n´ umero de elementos utilizados, use size(), e para obter o limite máximo que o container pode ter, utilize max_size().

31.2.5

M´ etodos v´ alidos apenas para os container’s sequ ënciais

Alguns métodos s˜ ao válidos apenas para os containers seq¨ uenciais e associativos. Esses métodos s˜ ao listadas a seguir. Os métodos begin(), end(), rbegin() e rend() retornam iteradores. Veremos na se¸caõ 31.3 que iteradores s˜ ao objetos ponteiros.




548

Tabela 31.1: Métodos e operadores comuns a todos os containers. Método construtor default construtor de c´ opia destrutor empty() max_size() size() swap() operator= operator< operator<= operator> operator>= operator== operator!=

31.2.6

Descri¸caõ Cada container tem um conjunto de construtores válidos. Cria um container novo, uma c´ opia de um existente. Destr´ oi o container. Retorna true se o container estiver vazio. Retorna o n´ umero máximo de elementos do container (valor alocado). Retorna o n´ umero de elementos utilizados. Troca todos os elementos do container. Atribue os elementos de um container a outro. Retorna true se C A é menor que C B (C A é o container A e C B o container B). Uso C A < C B. Retorna true se C A é menor ou igual a C B. Uso C A <= C B. Retorna true se C A é maior que C B. Uso C A > C B. Retorna true se C A é maior ou igual a C B. Uso C A >= C B. Retorna true se C A é igual a C B. Uso C A == C B. Retorna true se C A é diferente de C B. Uso C A != C B.

Typedef´s comuns aos diversos containers2

Vimos na se¸caõ 9.5.1 que podemos usar typedef’s para criar apelidos. Como as classes templates s˜ ao usadas para criar tipos genéricos (ex.: complex c1;), para criar um objeto de uma classe template, tenho de usar NomeClasseGabarito nomeObjeto; como no exemplo set< double, less > objeto_double_set; posso criar um typedef para o comando anterior, typedef set< double, less > double_set; podendo criar um objeto double_set usando: double_set objeto_double_set; Ou seja, com o uso de typedef’s, podemos criar apelidos abreviados, o que facilita a digita¸caõ do programa. Pensando nisso, os elaboradores da STL inclu´ıram dentro das classes containers várias instru¸co˜es do tipo typedef, estando algumas delas presentes em todos os containers. Estes typedef’s s˜ ao listados na Tabela 31.3. No exemplo a seguir usamos um typedef pré-definido para criar um iterador para os elementos do container. A seguir usamos o iterador criado para varrer o container criado do in´ıcio até o fim e enviar os valores do vetor para tela. Observe que o typedef, vector::iterator é um apelido para im iterador. Programa¸caõ Orientada a Objeto com C++


˜ AOS ITERADORES - ITERATORS 31.3. INTRODUC ¸ AO

549

Figura 31.4: Exemplos de métodos presentes em alguns containers. Inclusão de Objetos: 0

1

2

3

...

n-2 n-1

n

push_back()

push_front()

Eliminação de Objetos: 0

1

2

3

...

i

n-2 n-1

erase(i)

pop_front()

pop_back()

Obtenção de Objetos: 0

1

2

3

...

n-2 n-1

back() front()

at(3)

Dimensões e capacidades: size() capacity() max_size()

Exemplo: vector v(10); // Cria vetor vector::iterator it; // Cria iterador for(it = v.begin(); it != v.end(); it++) // Usa iterador cout < < *it < < endl; Nota: os iteradores ser˜ ao descritos na se¸caõ 31.3.

31.3

Introdu¸ c˜ ao aos iteradores - iterators

O que é um iterador? Um iterador é um ponteiro inteligente, um objeto ponteiro. Os iteradores foram desenvolvidos para dar suporte aos containers j´ a descritos (veja se¸caõ 31.2). Lembre-se de que um ponteiro aponta para determinada posi¸caõ da memória, podendo ser utilizado para percorrer um vetor de objetos. Um iterador funciona da mesma maneira. Veja a seguir os diferentes tipos de iteradores e os operadores que s˜ ao sobrecarregados para os iteradores.

31.3.1

Tipos de iteradores

Existe uma certa hierarquia entre os iteradores. Os dois mais simples s˜ ao o input e o output, pois permitem apenas opera¸co˜es de leitura e escrita (respectivamente). A seguir vem o forward, que permite leitura e escrita (mas somente para frente). O iterador bidirecional permite leitura Programa¸caõ Orientada a Objeto com C++



550

Tabela 31.2: Iteradores e métodos dos containers sequenciais. Método begin() end()

rbegin() rend()

erase() clear()

Descri¸caõ Retorna um iterador (iterator ou const_iterator) para o primeiro objeto do container (posi¸caõ 0). Retorna um iterador (iterator ou const_iterator) para uma posi¸caõ posterior ao u ´ ltimo objeto do container (este elemento n˜ ao é utilizado e est´ a na posi¸caõ n). Retorna um iterador (iterator ou const_iterator) para o u ´ ltimo objeto do container (posi¸caõ n - 1). Retorna um iterador (iterator ou const_iterator) para uma posi¸caõ anterior ao primeiro objeto do container (elemento n˜ ao utilizado localizado na posi¸caõ -1). Apaga um ou mais objetos do container. Apaga todos os objetos do container.

e escrita tanto para frente quanto para tr´ as. O iterador mais poderoso é o random, que permite a leitura e escrita randomicamente. input

forward

bidirecional

random

output

Veja a seguir as caracter´ısticas dos iteradores: • InputIterator: Lê um objeto do container, move-se do in´ıcio para o fim do container (suporta somente uma passagem). • OutputIterator: Escreve um objeto no container, move-se do in´ıcio para o fim do container (suporta somente uma passagem). • ForwardIterator: Leitura e escrita somente para frente (suporta somente uma passagem). • BidirecionalIterator: Leitura e escrita para frente e para trás (suporta m´ ultiplas passagens). • RandomAcessIterator: Leitura e escrita acessando randomicamente qualquer objeto do container. Dica: o acesso aos elementos de um container (como , , ) é mais r´ apido quando se usa um iterador. A excess˜ ao é que é acessado mais rapidamente utilizando-se o operator[].

31.3.2

Opera¸c˜ oes comuns com iteradores2

Algumas opera¸co˜es comuns aos diferentes tipos de iteradores s˜ ao listadas a seguir: Programa¸caõ Orientada a Objeto com C++



551

Tabela 31.3: Typedef´s comuns aos diversos containers. typedef value_type size_type reference pointer iterator reverse_iterator alocator_type difference_type

const_pointer const_iterator const_reverse_ iterator

Descri¸caõ O tipo de elemento armazenado no container. Tipo usado para contar itens no container e indexar uma seq¨ uência de containers. Inválido para . Uma referência para o tipo armazenado no container. Um ponteiro para o tipo armazenado no container. Um iterador para o tipo armazenado no container. Um iterador reverso para o tipo armazenado no container. Tipo de gerenciamento de memória utilizado. N´ umero de elementos entre dois iteradores. N˜ ao definido para os containers e adaptativos (, , ). Um ponteiro constante para o tipo armazenado no container. Um iterador constante para o tipo armazenado no container. Um iterador reverso constante para o tipo armazenado no container.

Iteradores de leitura (InputIterator) ++it

Pré-incremento (avan¸ca para próximo elemento do container).

it++

P´ os-incremento (avan¸ca para próximo elemento do container).

*it

Retorna objeto (desreferencia ponteiro).

it = it1

Atribue um iterador a outro.

it == it1

Compara se dois iteradores s˜ ao iguais.

it != it1

Compara se dois iteradores s˜ ao diferentes.

Iteradores de escrita (OutputIterator) ++it

Pré-incremento.

it++

Pos-incremento.

*it


it = it1


Iteradores de avan¸ co (ForwardIterator) ++it

Pré-incremento.

it++

Pos-incremento.

*it


it = it1




2 31.4. ITERADORES - USO AVANCADO ¸

552 it == it1

Compara se dois iteradores s˜ ao iguais.

it != it1

Compara se dois iteradores s˜ ao diferentes.

Iteradores bidirecionais (BidirecionalIterator) ++it

Pré-incremento.

it++

Pos-incremento.

- -it

Pré-decremento (retorna para elemento anterior do container).

it- -

P´ os-decremento.

Iteradores randomicos (RandomAcessIterator) ++it

Pré-incremento.

it++

Pos-incremento.

it += i

Iterador avan¸ca i posi¸co˜es.

it -= i

Iterador recua i posi¸co˜es.

it + i

Retorna iterador avan¸cado i posi¸co˜es de it.

it - i

Retorna iterador recuado i posi¸co˜es de it.

it[i]

Retorna referência ao objeto i.

it1 < it2

Verdadeiro, se it1 aponta para elemento anterior a it2.

it1<= it2 Verdadeiro, se it1 aponta para elemento anterior/igual a it2. it1 > it2

Verdadeiro, se it1 aponta para elemento acima de it2.

it1 >= it2 Verdadeiro, se it1 aponta para elemento acima/igual a it2. A utiliza¸caõ dos iteradores ser´ a esclarecida por meio dos exemplos, veja listagens 32.1, 34.2, 32.3, 35.1.

31.4

Iteradores - Uso avan¸ cado2

Veremos nesta se¸caõ algumas dicas avan¸cadas para iteradores.

31.4.1

Iteradores de inser¸c˜ ao

Algoritmos genéricos como copy() n˜ ao inserem novos elementos no container, os mesmos substituem os elementos antigos pelos novos. Com o objetivo de possibilitar a inclus˜ ao de novos elementos em um container, a STL inclui iteradores espec´ıficos para inser¸caõ de elementos, s˜ ao eles: insert iterator(); Chama insert(pos,valor), para inserir o valor na posi¸caõ pos. Programa¸caõ Orientada a Objeto com C++


2 31.4. ITERADORES - USO AVANCADO ¸

553

back insert iterator(); Chama push_back(valor), para inserir o valor no final do container. front insert iterator(); Chama push_front(valor), para inserir o valor no in´ıcio do container. O exemplo da listagem ?? mostra o uso de insert_iterator e de fun¸caõ predicado. Criamos a fun¸caõ predicado bool MaiorQue50(int valor), que retorna verdadeiro se valor for maior que 50. A seguir definimos uma fun¸caõ SeparaValores(), a mesma usa o iterador it do tipo back_insert_iterator. A fun¸caõ genérica remove_copy_if() recebe v1, o iterador it e a fun¸caõ predicado, quando MaiorQue50() retorna verdadeiro, o valor de v1 é copiado para v2. Observe na sa´ıda que os valores de v1 que n˜ ao satisfazem a fun¸caõ predicado s˜ ao inseridos em v2. Listing 31.1: Usando insert_iterator e fun¸caõ predicado. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

# include < iostream > # include < iomanip > # include < vector > # include < algorithm > # include < iterator > # include < functional > using namespace std ; // Fun¸ c~ a o predicado , r e t o r n a true se valor > 50 bool MaiorQue50 ( int valor ) { return valor > 50; } // Recebe um vetor v1 e r e t o r n a v2 . vector < int > S e p a r a V e t o r e s ( vector < int >* v1 ) { vector < int > v2 ; // Cria i t e r a d o r de i n s e r ¸ c~ a o para v2 back_insert _ it e ra t o r < vector < int > > it ( v2 ) ; r e m o v e _ c o p y _ i f ( v1 - > begin () , v1 - > end () , it , MaiorQue50 ) ; return v2 ; } // S o b r e c a r g a operador < < como fun¸ c~ ao template template < typename T > ostream & operator < <( ostream & os , vector v ) { for ( int i = 0; i < v . size () ; i ++) os << v [ i ] << endl ; return os ; } int main () { // T e s t a n t o a fun¸ c~ ao predicado cout << " MaiorQue50 (100) = " << MaiorQue50 (100) << " \ nMaiorQue5 0 ( 10) = " << MaiorQue50 ( 10) << endl ; // Cria v1 e a d i c i o n a v a l o r e s vector < int > v1 ; int data ; do { cout << " \ nEntre com o dado ( " << setw (3) << v1 . size () << " ) : " ; cin >> data ; cin . get () ;



554 46 47 48 49 50 51 52 53 54 55

31.5. SENTENCAS ¸ PARA STL E ITERADORES if ( cin . good () ) v1 . push_back ( data ) ; } while ( cin . good () ) ;

cout << " \ nVetor v1 antes de S e p a r a V e t o r e s () :\ n " << v1 << endl ; vector < int > v2 ( S e p a r a V e t o r e s (& v1 ) ) ; cout << " Vetor v1 depois de S e p a r a V e t o r e s () :\ n " << v1 << " Vetor v2 depois de S e p a r a V e t o r e s () :\ n " << v2 << endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ a . out MaiorQue5 0 (100) = 1 MaiorQue5 0 ( 10) = 0 Entre Entre Entre Entre Entre

com com com com com

o o o o o

dado dado dado dado dado

Vetor v1 antes de 50 100 150 30

( ( ( ( (

0) :50 1) :100 2) :150 3) :30 4) : S e p a r a V e t o r e s () :

Vetor v1 depois de S e p a r a V e t o r e s () : 50 100 150 30 Vetor v2 depois de S e p a r a V e t o r e s () : 50 30

Veja exemplo de uso de istream_iterator, ostream_iterator e back_inserter na listagem 35.3

31.5

Senten¸cas para STL e iteradores

• Sempre compare iteradores usando != e n˜ ao <, pois o operador < s´ o esta sobrecarregado para iteradores randˆ omicos. • Ao usar incremento e decremento com iteradores, prefira as vers˜ oes pré-fixadas. Isto é, troque it++ por ++it e it- - por - -it. • Pode-se iterar do u ´ ltimo elemento para o primeiro elemento do container usando-se um reverse_iterator ou um const_reverse_iterator. • Os containers que suportam o uso de iteradores bidirecionais aceitam o uso de insert_iterator, back_insert_iterator e front_insert_iterator para inserir elementos em um container. Veja listagem listagm 31.1. • Como a STL faz parte da biblioteca-padr˜ ao de C++, todas as distribui¸co˜es de C++ devem inclu´ı-la, de forma que usar a STL garante maior portabilidade aos seus programas. Programa¸caõ Orientada a Objeto com C++


˜ PREDICADO 31.6. FUNC ¸ AO

31.6

555

Fun¸ c˜ ao predicado

Um predicado é uma fun¸caõ que recebe como parˆ ametro um elemento do container, realiza determinada opera¸caõ e retorna o valor true/false. O prot´ otipo e um exemplo de uso de uma fun¸caõ predicado é apresentado a seguir: Prot´ otipo: bool fun¸ c~ aoPredicado(Tipo x); Exemplo: bool MaiorQue10(int x) { return x > 10; }

31.7


Apresentamos neste cap´ıtulo a STL, a biblioteca padr˜ ao de gabaritos de C++, suas caracter´ısticas e componentes. Iniciamos com uma introdu¸caõ aos diferentes tipos de containers: os containers seq¨ uenciais , , , os containers adaptativos , , , e os containers associativos , , , . Aprendemos a diferenciar os containers e a identificar qual devemos utilizar. Vimos ainda os métodos e operadores que s˜ ao comuns aos diversos container’s, isto é, os métodos que est˜ ao presentes em todos os containers, sendo muito utilizados. Observe que o fato de terem os mesmos nomes nos diferentes containers facilita seu uso, pois temos de decorar poucos nomes. Aprendemos que alguns métodos s˜ ao válidos apenas para os container’s seq¨ uenciais. Vimos ainda as defini¸co˜es de tipo - typedefs - que s˜ ao comuns aos diversos containers. No final do cap´ıtulo vimos uma introdu¸caõ aos iteradores (iterators), os famosos - ponteiros inteligentes - seus tipos e opera¸co˜es comuns. Nos próximos cap´ıtulos iremos aprender a utilizar em detalhes os containers, os iteradores e os c´ odigos genéricos. Nota: veja no Apêndice I - Links para Sites em C++, um conjunto de endere¸cos de sites que descrevem a STL em detalhes.

31.8

Exerc´ıcios

1. Comente as caracter´ısticas da STL. 2. Para um sistema de processamento de dados de uma conta corrente de um banco, qual tipo de container deve ser utilizado? 3. Qual o container ideal para acesso aleat´ orio? 4. Preciso incluir e eliminar objetos o tempo todo, qual container devo selecionar? 5. Vou montar um programa que simula uma calculadora HP, qual container devo utilizar? 6. Quais os métodos comuns a todos os containers? 7. O que faz o método begin(). 8. Qual a vantagem do uso de typedef´s com containers? 9. Fa¸ca uma lista dos iteradores e suas caracter´ısticas. Programa¸caõ Orientada a Objeto com C++


556

31.8. EXERCÍCIOS



Cap´ıtulo 32

Os Containers Sequˆ enciais , , Mostraremos neste cap´ıtulo os containers seq¨ uenciais (se¸caõ 32.1), (seçaõ 32.2) e (se¸caõ 32.3). O container ser´ a apresentado em detalhes. Os demais containers ser˜ ao apresentados de forma simplificada, pois as suas caracter´ısticas s˜ ao semelhantes às de . Isto significa que você deve ler este cap´ıtulo com aten¸caõ redobrada, pois seus conceitos se aplicam aos demais containers. Como o conjunto de métodos fornecidos por cada container é grande, n˜ ao tente decorar nada, apenas preste aten¸caõ ao conceito. Com os exemplos, você ir´ a aprender a utilizar as classes container com facilidade.

32.1

A classe container

J´ a apresentamos brevemente a classe container nas se¸co˜es 9.4.2 e 31.2.1. O container funciona como um vetor comum, ou seja, os blocos com os elementos est˜ ao cont´ıguos, permitindo acesso aleat´ orio (iteradores randˆ omicos). Como em vetores comuns de C, n˜ ao verifica os ´ındices. Para usar um objeto container do tipo , inclua o arquivo de cabe¸calho . Exemplo: #include A classe container é uma classe template declarada da forma: template < typename Tipo, typename Allocator=allocator > class vector{...}; ou seja, recebe o tipo de elemento a ser armazenado e o tipo de aloca¸caõ a ser utilizada. Veja a seguir os diversos métodos disponibilizados por . Primeiro, veremos os construtores, os iteradores e as referências, e, depois, os métodos usuais de . A Figura 32.1 apresenta um diagrama mostrando os métodos para inclus˜ ao, obten¸caõ e elimina¸caõ de objetos em um container . 557

558

32.1. A CLASSE CONTAINER

Nota: na descri¸caõ dos métodos, nos prot´ otipos e exemplos apresentados nesta parte do livro procuramos adotar um padr˜ ao. T é um tipo qualquer, um sinˆ onimo para Tipo; size_type é a dimensão dos objetos armazenados no container; x,y,z, e e1,e2,e3, s˜ ao elementos do container; n,pos indica uma posi¸caõ a ser acessada; c,co,c1,c2,c3 s˜ ao objetos containers; cd, d, dest é o container destino; it, it1, it2 s˜ ao iteradores que apontam para elementos do container no intervalo [first, last), ou seja, inclui first e exclue last. O iterador first aponta para o primeiro elemento do container (o mesmo que v.begin()). O iterador last aponta para o elemento n do container, elemento inválido (o mesmo que v.end()). fpred é uma fun¸caõ predicado, é uma fun¸caõ que recebe um elemento do container, realiza determinada opera¸caõ e retorna 0 ou 1. Alloc é um objeto do tipo allocator_type, usado para aloca¸caõ de memória.

Figura 32.1: Métodos disponibilizados para . Inclusão de Objetos: 0

1

2

3

...

n-2

n-1

n

push_back()


1

2

i

3

n-2

n-1

pop_back()

erase(i)


1

2

3

...

n-2

back() front()

at(3)

n-1

espaço reservado

Dimensões e capacidades: size() capacity() max_size() reserve()

32.1.1


vector (); Cria um vetor para o tipo T com tamanho zero. Complexidade constante. Exemplo: Programa¸caõ Orientada a Objeto com C++



559

vector< int > v_int1(); vector (size type n, const T& x = T()); Cria um vetor para o tipo com tamanho n, com n c´ opias do valor T(). Se o valor do elemento x n˜ ao for passado, utiliza o construtor default da classe para construir o objeto. Complexidade linear. No exemplo a seguir v_float1 tem 17 elementos, todos iguais a 3.55. Exemplo: vector< int > v_int2 (15); vector< float > v_float1 (17,3.55); vector (const vector& v); Construtor de c´ opia, cria uma c´ opia do vetor v. Exemplo: vector< float > v_float2 (v_float1); vector (InputIterator first, InputIterator last); Cria um vetor com o tamanho dado pela diferen¸ca last-first, com os valores a partir de first. Observe que first se refere ao primeiro elemento do container a ser considerado, e last se refere ao ultimo elemento (last n˜ ao é inclu´ıdo no container). Complexidade linear. Exemplo: vector< float > v_float3 (v_float1.begin(), v_float1.end()); ˜vector (); Destrutor de < vector >. Complexidade linear.

32.1.2

Iteradores de

A chamada a um método que retorna um iterador, como begin(), ou end() (veja Figura 32.2), ir´ a retornar um const_iterator se o objeto destino é do tipo const. Um const_iterator pode ser utilizado para acessar os elementos do container no modo ”ready-only”. A Figura 32.2 apresenta um diagrama mostrando os métodos que retornam iteradores. Por exemplo, o método begin() retorna um iterator que aponta para o primeiro elemento do container. A maioria das fun¸co˜es genéricas recebe como parˆ ametros os iteradores begin() e end() e usa-os para varrer todo o container. Observe que as fun¸co˜es s˜ ao executadas para begin(), porque begin() aponta para o primeiro elemento do container, e n˜ ao s˜ ao executadas para end(), porque end() aponta para um elemento inválido (veja Figura 32.2). Nota: todos os métodos abaixo tem complexidade constante. iterator begin(); Retorna um iterador randˆ omico para o primeiro objeto do container (veja Figura 32.2). iterator end(); Retorna um iterador randˆ omico para posi¸caõ n (elemento inválido). reverse iterator rbegin(); Retorna um iterador randˆ omico reverso para o u ´ ltimo objeto válido (posi¸caõ n-1). Programa¸caõ Orientada a Objeto com C++


560


Figura 32.2: Métodos que retornam iteradores. rend()

rbegin() Iteradores:

begin()

-1

0

1

2

3

...

end()

n-2

n-1

n

reverse iterator rend(); Retorna um iterador randˆ omico para posi¸caõ -1 (elemento inválido). const iterator begin() const; Retorna um iterador randˆ omico e constante para posi¸caõ 0. const iterator end() const; Retorna um iterador randˆ omico e constante para posi¸caõ n (elemento inválido). const reverse iterator rbegin() const; Retorna um iterador randˆ omico reverso constante para o u ´ ltimo objeto válido (posi¸caõ n-1). const reverse iterator rend() const; Retorna um iterador randˆ omico e constante para posi¸caõ -1 (elemento inválido).

32.1.3

Referˆ encias e acesso

reference front(); Retorna uma referência ao primeiro elemento (veja Figura 32.1). operator[] (size type n); Retorna uma referência ao objeto armazenado na casa n (n˜ ao verifica o intervalo). S´ o é válido para e . at(size type n); Retorna uma referência ao objeto n; at() testa o intervalo. reference back(); Retorna uma referência ao u ´ ltimo elemento. const reference front() const; Retorna uma referência constante ao primeiro elemento. const reference operator[] (size type n) const; Retorna uma referência constante ao objeto n (veja Figura 32.1). const reference at(size type n) const; Retorna uma referência constante ao objeto n (veja Figura 32.1). const reference back() const; Retorna uma referência constante ao u ´ ltimo elemento (veja Figura 32.1). Programa¸caõ Orientada a Objeto com C++



32.1.4

561

Operadores

vector& operator= (const vector& v); Operador de atribui¸caõ. Apaga todos os elementos do container e depois copia os valores de v para o container this. Retorna uma referência para o conjunto. Complexidade linear.

32.1.5

Capacidade e redimensionamento

Todos os métodos desta se¸caõ tem complexidade constante. size type size() const; Retorna o n´ umero de elementos utilizados pelo container (veja Figura 32.1). size type capacity() const; Retorna o tamanho alocado do container (mem´ oria alocada) (veja Figura 32.1). size type max size() const; Retorna o tamanho do maior vetor poss´ıvel. Depende da quantidade de memória dispon´ıvel em seu computador (veja Figura 32.1). void reserve(size type sz); Define a capacidade do container em sz elementos. Muda a capacidade do container mas ´ u n˜ ao muda o size. E ´ til quando você sabe que ir´ a adicionar um determinado n´ umero de elementos ao container, pois evita a realoca¸caõ do container a cada nova inclus˜ ao. Se sz for menor que a capacidade atual do container, a realoca¸caõ n˜ ao é realizada (veja Figura 32.1). void resize(size type sz, T e = T()); Altera o tamanho do container (o size). Se o novo tamanho (sz) for maior que o atual, os novos elementos s˜ ao inseridos no final do vetor. Se o novo tamanho for menor que o atual, os elementos excedentes s˜ ao eliminados. bool empty() const; Retorna true se o container est´ a vazio.

32.1.6

Inser¸c˜ ao, dele¸c˜ ao e atribui¸c˜ ao

A Figura 32.1 apresenta um diagrama mostrando os métodos para inclus˜ ao, obten¸caõ e elimina¸caõ de objetos em um container . iterator insert(iterator pos, const T& x = T()); Insere o objeto x, antes da posi¸caõ pos definida pelo iterador. void insert(iterator pos, size type n, const T& x = T()); Insere n c´ opias de x antes da posi¸caõ pos. void insert(iterator pos, InputIterator first, InputIterator last); Insere c´ opia dos elementos no intervalo [first, last) antes da posi¸caõ pos. void push back(const T& x); Insere uma c´ opia de x no final do container. Programa¸caõ Orientada a Objeto com C++


562


void erase(iterator pos); Remove o elemento da posi¸caõ pos. Exemplo: v.erase ( v.begin() + 5 ); void erase(iterator first, iterator last); Remove os elementos no intervalo [inclusive first, excluindo last), ou seja, de first a last-1. A complexidade é fun¸caõ do tipo de container. void pop back(); Remove o u ´ ltimo elemento (sem retorno). void clear(); Apaga todos os elementos do container. Complexidade linear. void assign(InputIterator first, InputIterator last); Apaga todos os elementos do container e insere os novos elementos do intervalo [first, last). void assign(Size n, const T& x = T()); Apaga todos os elementos do container e insere os n novos elementos com o valor de x. void swap(vector& v); Troca os elementos dos dois containers (é mais r´ apida que a swap genérica). Complexidade constante. Exemplo: v1.swap(v2);

32.1.7

Operadores sobrecarregados

bool operator== (const vector& v1, const vector & v2); O operador == retorna true se o container v1 é igual ao container v2 (se cada elemento é igual). bool operator< (const vector&v1, const vector& v2); O operador < retorna true se os elementos contidos em v1 s˜ ao ”lexicographically” menores que os elementos contidos em v2. Os outros operadores sobrecarregados s˜ ao: !=, <=, >=. Dica: para que qualquer um dos operadores ==, !=, possam ser utilizados, é necess´ ario que o tipo armazenado tenha suporte ao operador (==). Para que qualquer um dos operadores >, <, >=, <=, possam ser utilizados é necess´ ario que o tipo armazenado tenha suporte ao operador <.

32.1.8

Exemplo de

Neste momento, você pode rever o exemplo de apresentado na listagem 9.8. A listagem 32.1 mostra a utiliza¸caõ de .




563

Listing 32.1: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

# include < iostream > # include < iomanip > # include < vector > using namespace std ; // D e c l a r a ¸ c~ a o da s o b r e c a r g a do o p e r a d o r << , uso cout << v ; ostream & operator << ( ostream & os , const vector < int >& v ) ; int main () { vector < int > v ;

// Cria vector , do tipo int , com nome v

int data ; cout << " No DOS um ctrl + z encerra a entrada de dados .\ n " << " No Mac um ctrl + d encerra a entrada de dados .\ n " << " No GNU / Linux um ctrl + d encerra a entrada de dados .\ n " ; do { cout << " \ nEntre com o dado ( " << setw (3) << v . size () << " ) : " ; cin >> data ; cin . get () ; if ( cin . good () ) v . push_back ( data ) ; } while ( cin . good () ) ; cout << " \ n " << v << endl ; v [0] = 23427; v . insert ( v . begin () + 2 , 5463) ; cout << " \ nAp´ o s v [ 0 ] = 23427; e v . insert ( v . begin () + 2 , 5463 ) ;\ n " << v << endl ; // Chama fun¸ c~ a o erase () do objeto v p a s s a n d o p o s i ¸ c~ a o v . begin () v . erase ( v . begin () ) ; cout << " \ nAp´ o s v . erase ( v . begin () ) ;\ n " << v << endl ; // Chama v . erase ( cout << <<

fun¸ c~ a o erase () do objeto v p a s s a n d o v . begin () +1 e v . end () -1 v . begin () +1 , v . end () -1) ; " \ nAp´ o s v . erase ( v . begin () +1 , v . end () -1 ) ;\ n " " o vetor esta " << ( v . empty () ? " vazio " : " com elementos " ) << endl ;

// Chama fun¸ c~ a o clear () v . clear () ; cout << " o vetor esta " << ( v . empty () ? " vazio " : " com elementos " ) << endl ; return 0; } // D e f i n i ¸ c~ a o da s o b r e c a r g a do o p e r a d o r << para m o s t r a r e l e m e n t o s do vetor . ostream & operator < < ( ostream & os , const vector < int >& v ) { for ( int i = 0; i < v . size () ; i ++) os << " v [ " << setw (3) << i << " ]= " << setw (5) << v [ i ] << ’ ’; return os ; }

[ a n d r e @ m e r c u r i o Cap4 - STL ] $ g ++ ex - vector -2. cpp [ a n d r e @ m e r c u r i o Cap4 - STL ] $ ./ a . out No DOS um ctrl + z encerra a entrada de dados . No Mac um ctrl + d encerra a entrada de dados . No GNU / Linux um ctrl + d encerra a entrada de dados . Entre com o dado ( 0) :0 Entre com o dado ( 1) : -1



564


Entre com o dado ( 2) : -2 Entre com o dado ( 3) : -3 Entre com o dado ( 4) : v [ 0]= 0 v [ 1]= -1 v [

2]=

-2 v [

3]=

-3

Ap´ o s v [ 0 ] = 23427; e v . insert ( v . begin () + 2 , 5463 ) ; v [ 0]=23427 v [ 1]= -1 v [ 2]= 5463 v [ 3]= -2 v [ 4]= Ap´ o s v . erase ( v . begin () ) ; v [ 0]= -1 v [ 1]= 5463 v [

2]=

-2 v [

3]=

-3

-3

Ap´ o s v . erase ( v . begin () +1 , v . end () -1 ) ; o vetor esta com elementos o vetor esta vazio

Reveja agora a listagem 30.5 que mostra o uso de com .

32.1.9

Senten¸cas para

• Se n˜ ao for mudar o container, utilize iteradores do tipo const. Note que v.begin() retorna um iterador normal ou constante, veja o exemplo: Exemplo: vector v(10); // Retorna iterador normal vector::iterator it = v.begin(); // Retorna iterador constante vector::const_iterator cit = v.begin(); • Sempre reserve um espa¸co inicial para o vetor, ou seja, procure evitar a realoca¸caõ a cada inser¸caõ, alocando todo o bloco que ir´ a utilizar de uma u ńica vez. • Os métodos devem receber como referência para evitar c´ opias desnecessárias. Exemplo: void funcao(vector & v); • Se a classe n˜ ao tem um construtor default, um s´ o pode ser criado passando-se o construtor com parˆ ametros. Exemplo: // Construtor com par^ ametros class TUsuario{ TUsuario(int x){...}; }; vector< TUsuario > vet( 200, TUsuario(5) ); • Os métodos assign() s˜ ao utilizados complementarmente aos construtores. O n´ umero de elementos do vetor ser´ a aquele passado para assign(). • Se o método espera um iterator, você n˜ ao deve passar um reverse_iterator. • Para converter um reverse_iterator em um iterator, utilize o método base(). Exemplo: reverse_iterator ri; iterator it = ri.base(); Programa¸caõ Orientada a Objeto com C++



565

• Se for inserir objetos no meio do vetor, pense em utilizar uma lista (). • A classe n˜ ao possui os métodos push_front(), pop_front() e front(). • Para retornar um vetor de inteiros como referência: Exemplo: vector& NomeM´ etodo(vector& v) {... return v;} • O operador ++it retorna uma referência ao elemento do container. O operador it++ retorna uma c´ opia do elemento do container. • Para evitar aloca¸co˜es desnecessárias ao usar push_back(), reverve um espa¸co m´ınimo com reserve(). • Para saber o n´ umero de elementos alocados mas n˜ ao utilizados use capacity()-size(). • Observe que a classe string se comporta como um vetor de caracteres. • Os containers j´ a vêm com os operadores < e == sobrecarregados. Você pode sobrecarregar >, !=, <= e >=, ou utilizar o comando using namespace std::rel_ops; para incluir a sobrecarga desses operadores. Exemplo: #include using namespace std::rel_ops; • Observe que e s˜ ao acessados mais rapidamente com o operador[], , , e s˜ ao acessados mais rapidamente utilizando um iterador.

32.2

A classe container

Utilize quando precisar de um container em que novos objetos podem ser inclu´ıdos em qualquer posi¸caõ. A Figura 32.3 mostra os métodos disponibilizados para . • O container é lento para acesso randˆ omico, mas é otimizado para inser¸caõ e remo¸caõ de elementos em qualquer posi¸caõ ( suporta iterador bidirecional). • Um fornece todos os métodos de um , com exce¸caõ de at[], capacity() e reserve(), e acrescenta métodos novos, como front(), push_front(), pop_front() e insert(pos,elem). • n˜ ao tem o operador[], e os iteradores de n˜ ao suportam opera¸co˜es aritméticas, como it+5.

32.2.1


list(); Cria uma lista vazia. list(size type n, const T& x = T()); Cria uma lista com tamanho n, com n c´ opias do valor x. Programa¸caõ Orientada a Objeto com C++


566


Figura 32.3: Métodos disponibilizados para . Inclusão e obtenção de Objetos:

0

1

...

n-2

n-1

n

back()

front() push_front()

push_back()


1

n-2

n-1

pop_back() pop_front()

Dimensões e capacidades: size() max_size()

list(InputIterator first, InputIterator last); Cria uma lista do tamanho de last-first, com os valores de [first a last). list(const list& l); Cria uma c´ opia da lista l (construtor de c´ opia). ˜list(); Destrutor de .

32.2.2

Operadores

list& operator= (const list& l) Operador de atribui¸caõ. Apaga todos os elementos do container e depois copia os valores de l para o container this. Retorna uma referência para o conjunto.

32.2.3

Referˆ encia e acesso

reference front(); Retorna uma referência para o primeiro elemento. Veja Figura 32.3. void pop front(); Remove o primeiro elemento. Veja Figura 32.3. push front(const T& x); Adiciona uma c´ opia de x no in´ıcio da lista (novo primeiro elemento). Veja Figura 32.3.

32.2.4

Inser¸c˜ ao, mistura e ordena¸c˜ ao

void splice(iterator pos, list& l); Insere a lista l antes da posi¸caõ pos definida pelo iterador. Programa¸caõ Orientada a Objeto com C++



567

void splice(iterator pos, list& l, iterator it); Move de list[i] para posi¸caõ pos. void splice(iterator pos, list& l, iterator first, iterator last); Move os elementos no intervalo [first, last) da lista l para esta lista, inserindo o elemento antes da posi¸caõ pos. void merge(list& l); Mistura esta lista com a lista l, os valores s˜ ao ordenados com o operador <. Se existirem elementos iguais nas duas listas, os elementos desta lista precedem, a lista l ficar´ a vazia. void merge(list& l, Compare comp); Mistura esta lista com a lista l; usando fun¸caõ de compara¸caõ. Se existirem elementos iguais nas duas listas, os elementos desta lista (this) precedem, e a lista l ficar´ a vazia. void sort(); Ordena de acordo com o operador <. Elementos iguais s˜ ao mantidos na mesma ordem. void sort(Compare comp); Ordena a lista de acordo com a fun¸caõ de compara¸caõ comp. void insert(iterator pos, Tipo obj); Insere na posi¸caõ pos o objeto.

32.2.5

Remo¸c˜ ao e c´ opia u ńica

void unique(); Move todos os elementos repetidos para o fim do container e seta size como sendo o ´ındice do u ´ ltimo elemento n˜ ao duplicado. Antes de executar unique(), execute um sort(). void unique(Fun¸ c˜ aoPredicado fpred); Apaga elementos consecutivos com a condi¸caõ true dada pela fun¸caõ predicado fpred. A primeira ocorrência n˜ ao é eliminada. Exemplo: bool MaiorQue10(int x) { return x > 10; } ... lista.unique(MaiorQue10); void remove(const T& x); Remove os elementos do container que têm o valor x. c˜ aoPredicado fpred); void remove if(Fun¸ Remove os elementos do container que satisfazem à fun¸caõ predicado fpred. Exemplo: // Remove da lista os objetos que tem a primeira letra ==’p’. list.remove_if( initial(’p’) ); void reverse(); Inverte a ordem dos elementos do container. Programa¸caõ Orientada a Objeto com C++


568

32.2.6


Exemplo de

Veja na listagem 32.2 um exemplo de utiliza¸caõ de . Observe na fun¸caõ de sobrecarga do operador de extra¸caõ (< <) o uso de um iterador. A listagem 32.2 inicia-se declarando a fun¸caõ de sobrecarga do operador < <; esta recebe uma ostream (como cout) e uma referência para um container do tipo lista para n´ umeros float (const std::list& list). Como dito anteriormente, cada container fornece iteradores para acesso aos seus elementos. Neste exemplo, a linha std::list::const_iterator it; é utilizada para criar um iterador do tipo std::list::const_iterator com o nome it. Dentro do for, o iterador it que inicialmente aponta para o primeiro elemento do container it=lista.begin(); é utilizado para percorrer os elementos do container usando it++ e envi´ a-los para a sa´ıda os < < *it < <´ ´;. Quando o iterador it chegar ao fim do container, isto é, it != lista.end(), o for é encerrado. Listing 32.2: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

# include # include # include # include

< iostream > < string > < list > < algorithm >

// Listas // A l g o r i t m o g e n ´ erico

using namespace std ; // D e c l a r a ¸ c~ a o da s o b r e c a r g a do o p e r a d o r de e x t r a ¸ c~ a o << para list // Mostra lista . Com vector foi p o s s ´ ı v e l usar v [ i ] , uma lista n~ a o aceita l [ i ] , // p r e c i s a de um iterator , como a seguir . template < typename T > ostream & operator << ( ostream & os , const std :: list < T >& lista ) { typename std :: list < T >:: c o n s t _ i t e r a t o r it ; for ( it = lista . begin () ; it != lista . end () ; it ++) os << * it << ’ ’; return os ; } // D e f i n i ¸ c~ a o da fun¸ c~ a o main () int main () { string linha = " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ; // C r i a ¸ c~ a o de uma lista para float std :: list < float > clist ; clist . push_front (312.1 f ) ; // Inclui v a l o r e s na lista clist . push_back (313.4 f ) ; clist . push_back (316.7 f ) ; clist . push_front (312.1 f ) ; clist . push_front (313.4 f ) ; clist . push_front (314.1 f ) ; clist . push_front (315.1 f ) ; cout << linha << " Conte´ u do do container : \ n " << clist << linha << endl ; // E l i m i n a p r i m e i r o e l e m e n t o da lista clist . pop_front () ; cout << " Conte´ u do do container ap´ o s : clist . pop_front () ; \ n " << clist << linha << endl ; // E l i m i n a ´ u ltimo e l e m e n t o da lista clist . pop_back () ; cout << " Conte´ u do do container ap´ o s : clist . pop_back () ; \ n " << clist << linha << endl ;



32.2. A CLASSE CONTAINER 45 46 47 48 49 50 51 52 53 54 55 56 57

569

// Ordena o c o n t a i n e r clist . sort () ; cout << " Conte´ u do do container ap´ o s : clist . sort () ; \ n " << clist << linha << endl ; // Move os e l e m e n t o s r e p e t i d o s para o final do c o n t a i n e r // e seta como ´ u ltimo e l e m e n t o v´ a lido , o ´ u ltimo e l e m e n t o n~ ao repetido. clist . unique () ; cout << " Conte´ u do do container ap´ o s : clist . unique () ; \ n " << clist << linha << endl ; return 0; }

[ a n d r e @ m e r c u r i o Cap4 - STL ]# ./ a . out -------------------------------------------------Conte´ u do do container : 315.1 314.1 313.4 312.1 312.1 313.4 316.7 -------------------------------------------------Conte´ u do do container ap´ o s : c o n t a i n e r _ l i s t . pop_front () ; 314.1 313.4 312.1 312.1 313.4 316.7 -------------------------------------------------Conte´ u do do container ap´ o s : c o n t a i n e r _ l i s t . pop_back () ; 314.1 313.4 312.1 312.1 313.4 -------------------------------------------------Conte´ u do do container ap´ o s : c o n t a i n e r _ l i s t . sort () ; 312.1 312.1 313.4 313.4 314.1 -------------------------------------------------Conte´ u do do container ap´ o s : c o n t a i n e r _ l i s t . unique () ; 312.1 313.4 314.1 --------------------------------------------------

Na listagem 32.3 apresentamos o uso de métodos de como sort(), splice(), merge(), unique(), swap(), assign(), e remove(). No Cap´ıtulo 22 - Entrada e Sa´ıda, aprendemos que as streams s˜ ao utilizadas para enviar e receber dados. Que uma ostream é uma stream utilizada para sa´ıda de dados (output stream). Vimos que um iterator é uma espécie de ponteiro inteligente utilizado para acessar os diversos objetos armazenados no container. Da´ı, conclu´ımos que um ostream_iterator é um iterador que ser´ a utilizado para percorrer os elementos do container e os enviar para uma sa´ıda. No exemplo da listagem 32.3, criamos um ostream_iterator na linha: std::ostream_iterator < float > output (cout, " "); e usamos a fun¸caõ genérica copy(), para copiar todos os elementos do container para a sa´ıda out. O caracter " " é utilizado como separador. copy (clist1.begin(), clist1.end(), output); A fun¸caõ copy() é uma fun¸caõ genérica (apresentada no Cap´ıtulo 35 - Algoritmos Genéricos), que ir´ a percorrer o container do in´ıcio (cset.begin()) ao fim (cset.end()), utilizando o iterador out, que envia cada objeto do container para a tela usando cout. Listing 32.3: Usando com as fun¸co˜es genéricas (algoritmos genéricos). 1 2 3 4

# include < iostream > # include < list > # include < iterator > using namespace std ;

// Classe de listas // I t e r a d o r e s // Uso do n a m e s p a c e std



570 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65


int main () // D e f i n i ¸ c~ a o da fun¸ c~ a o main () { // Cria um i t e r a d o r para ostream , usa cout para enviar floats para tela o s t r e a m _ i t e r a t o r < float > output ( cout , " " ) ; // C r i a ¸ c~ a o de duas listas para float std :: list < float > clist1 , clist2 ; // Inclui v a l o r e s na lista clist1 . push_front (312.1 f ) ; clist1 . push_front (312.1 f ) ; clist1 . push_back (313.4 f ) ; clist1 . push_back (316.7 f ) ; // Mostra lista cout << " \ nConte´ u do do container clist1 : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; // Ordena lista clist1 . sort () ; cout << " \ nConte´ u do do container clist1 ap´ o s sort () : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; // A d i c i o n a e l e m e n t o s a lista2 clist2 . push_front (22.0) ; clist2 . push_front (2222.0) ; cout << " \ nConte´ u do do container clist2 ap´ o s push_front () : " ; copy ( clist2 . begin () , clist2 . end () , output ) ; // Fun¸ c~ a o splice ( A d i c i o n a ao final de clist1 os v a l o r e s de clist2 ) clist1 . splice ( clist1 . end () , clist2 ) ; cout << " \ nConte´ u do do container clist1 ap´ o s splice () : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; // M i s t u r a as duas listas , c o l o c a n d o tudo em clist2 clist1 . merge ( clist2 ) ; cout << " \ nConte´ u do do container clist1 ap´ os copy ( clist1 . begin () , clist1 . end () , output cout << " \ nConte´ u do do container clist2 ap´ os copy ( clist2 . begin () , clist2 . end () , output

clist1 e e l i m i n a n d o tudo de

merge () : " ; ); merge () : " ; );

// E l i m i n a v a l o r e s d u p l i c a d o s clist1 . unique () ; cout << " \ nConte´ u do do container clist1 ap´ o s unique () : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; // Chama f u n ¸ c~ oes pop_front e pop_back clist1 . pop_front () ; // E l i m i n a p r i m e i r o e l e m e n t o da lista clist1 . pop_back () ; // E l i m i n a ultimo e l e m e n t o da lista cout << " \ nConte´ u do do container clist1 ap´ o s pop_front () e pop_back () : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; // Troca tudo entre as duas listas clist1 . swap ( clist2 ) ; cout << " \ nConte´ u do do container clist1 ap´ os copy ( clist1 . begin () , clist1 . end () , output cout << " \ nConte´ u do do container clist2 ap´ os copy ( clist2 . begin () , clist2 . end () , output

swap () : " ; ); swap () : " ; );

// A t r i b u i v a l o r e s de clist2 em clist1



32.3. A CLASSE CONTAINER 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

clist1 . assign ( clist2 . begin () , clist2 . end () ) ; cout << " \ nConte´ u do do container clist1 ap´ o s assign () : copy ( clist1 . begin () , clist1 . end () , output ) ;

571

";

// M i s t u r a n o v a m e n t e clist1 . merge ( clist2 ) ; cout << " \ nConte´ u do do container clist1 ap´ o s merge () : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; // Remove e l e m e n t o na p o s i ¸ c~ ao 2 clist1 . remove (2) ; cout << " \ nConte´ u do do container clist1 ap´ o s remove () : " ; copy ( clist1 . begin () , clist1 . end () , output ) ; cout << endl ; return 0; } Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do Conte´ u do

do do do do do do do do do do do do do

container container container container container container container container container container container container container

clist1 : 312.1 312.1 313.4 316.7 clist1 ap´ o s sort () : 312.1 312.1 313.4 316.7 clist2 ap´ o s push_front () : 2222 22 clist1 ap´ o s splice () : 312.1 312.1 313.4 316.7 2222 22 clist1 ap´ o s merge () : 312.1 312.1 313.4 316.7 2222 22 clist2 ap´ o s merge () : clist1 ap´ o s unique () : 312.1 313.4 316.7 2222 22 clist1 ap´ o s pop_front () e pop_back () : 313.4 316.7 2222 clist1 ap´ o s swap () : clist2 ap´ o s swap () : 313.4 316.7 2222 clist1 ap´ o s assign () : 313.4 316.7 2222 clist1 ap´ o s merge () : 313.4 313.4 316.7 316.7 2222 2222 clist1 ap´ o s remove () : 313.4 313.4 316.7 316.7 2222 2222

32.2.7

Senten¸cas para

• Uma lista n˜ ao aceita (iterator + n). Você precisa fazer iterator++, n vezes. • Objetos eliminados de s˜ ao deletados. • n˜ ao aceita subscript[], reserve() e capacity(). • inclui splice(pos,& x); move o objeto x para a posicão pos. • Utilize sempre que precisar de inser¸caõ e remo¸caõ r´ apida. • Utilize merge(list & ); para mesclar listas. • Para criar uma lista de vetores: Exemplo: std::list< std::vector > nomeLista;

32.3

A classe container

Um container é uma fila com duas extremidades. Une parte das vantagens das listas e dos vetores . Tem r´ apida inser¸caõ na frente e atr´ as. De uma maneira geral s˜ ao alocados blocos de mem´ oria que s´ o s˜ ao deletados quando o container é destru´ıdo. Tem os mesmos métodos de , mas adiciona push_front() e pop_front() e suporta iteradores randˆ omicos. A Figura 32.4 mostra os métodos disponibilizados para . Programa¸caõ Orientada a Objeto com C++


572


Figura 32.4: Métodos disponibilizados para . Inclusão de Objetos: 0

1

2

3

...

n-2

n-1

n

push_back()

push_front()


1

2

3

i ...n-2

n-1

pop_front()

pop_back() erase(i)


1

2

3

...

front()

n-2

n-1

back()

Dimensões e capacidades: size() capacity() max_size() reserve()

32.3.1


deque(); Construtor default, cria container vazio. deque(size type n, const T& x = T()); Cria container com n elementos contendo n c´ opias de x. deque(const deque& d); Construtor de c´ opia, cria uma c´ opia do deque d. deque(InputIterator first, InputIterator last); Cria um deque do tamanho de last - first, preenchido com os valores de [first a last). ˜deque(); Destrutor. Nota: os métodos válidos para s˜ ao válidos para . Veja se¸caõ 32.1.

32.3.2

Exemplo de

Veja na listagem 32.4 exemplo de uso de . A listagem inicia com a cria¸caõ de uma fun¸caõ global template que sobrecarrega o operador< <. A fun¸caõ é usada para enviar os elementos do para sa´ıda. Programa¸caõ Orientada a Objeto com C++



573

Listing 32.4: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

# include < iostream > # include < deque > # include < string > using namespace std ; // S o b r e c a r g a do o p e r a d o r << template < typename T > ostream & operator < <( ostream & os , deque < T > & cdeque ) { for ( int i = 0; i < cdeque . size () ; ++ i ) os << cdeque [ i ] << ’ ’; return os ; } int main () { // Cria c o n t a i n e r do tipo deque para string , com o nome cdeque deque < string > cdeque ; // A d i c i o n a n d o o b j e t o s ao deque cdeque . push_front ( " Cidade de sol " ) ; cdeque . push_front (" Floriano ´polis "); cdeque . push_back ( " e mar . " ) ;

// A d i c i o n a r no inicio // A d i c i o n a r no fim

cout << " Dimens~ a o do container deque = " << cdeque . size () << " \ nConte´ u do do container deque : \ n \ t " << cdeque << endl ; // S e t a n d o um e l e m e n t o do c o n t a i n e r d i r e t a m e n t e cdeque [2] = string ( " e mar com belezas sem par . " ) ; cout << " Conte´ u do do container deque ap´ o s atribui¸ ca ~ o direta :\ n \ t " << cdeque << endl ; // R e t i r a n d o p r i m e i r o e l e m e n t o do deque cdeque . pop_front () ; cout << " Conte´ u do do container deque ap´ o s um pop_front () :\ n \ t " ; for ( int i = 0; i < cdeque . size () ; ++ i ) cout << cdeque [ i ] << ’ ’; cout << endl ; return 0; }

Dimens~ a o do container deque = 3 Conte´ u do do container deque : Floriano ´ p o l i s Cidade de sol e mar . Conte´ u do do container deque ap´ o s atribui¸ ca ~ o direta : Floriano ´ p o l i s Cidade de sol e mar com belezas sem par . Conte´ u do do container deque ap´ o s um pop_front () : Cidade de sol e mar com belezas sem par .

32.4


Neste cap´ıtulo aprendemos a utilizar os containers seq¨ uenciais , e . O container foi apresentado em detalhes. Aprendemos a criar um utilizando o construtor default ou o construtor de c´ opia. Vimos que os iteradores mais utilizados s˜ ao retornados pelos métodos begin(); e end();. Com front(); obtemos uma referência ao primeiro elemento, e com at(n); obtemos uma referência ao objeto n;. N˜ ao podemos nos esquecer que podemos acesssar um exaPrograma¸caõ Orientada a Objeto com C++


32.5. EXERCÍCIOS

574

tamente da mesma forma que um vetor em C, utilizando o operator[](); que retorna uma referência ao objeto armazenado na casa n. Apredemos ainda a utilizar os métodos: size() que retorna o n´ umero de elementos utilizados pelo container, capacity() que retorna o tamanho alocado pelo container, e max_size() que retorna o tamanho do maior vetor poss´ıvel (o que depende da quantidade de memória dispon´ıvel em seu computador). Vimos que podemos utilizar reserve(); para definir a capacidade do container, ou resize(); para alterar o tamanho do container. Lembre-se ainda que empty() retorna true se o container estiver vazio. Note que temos diversas vers˜ oes de insert(), as memas s˜ ao utilizadas para inserir novos objetos no container. Um método de inser¸caõ especial é fornecido por push_back();, o mesmo insere um objeto no final do container. Também podemos eliminar objetos do container utilizando erase(n); para eliminar o elemento n, ou pop_back(); para remover o u ´ ltimo elemento do container. J´ a clear(); apaga todo container. O container deve ser utilizado quando precisamos inserir novos elementos em qualquer posi¸caõ do container. Lembre-se é lento para acesso randˆ omico, mas é otimizado para inser¸caõ e remo¸caõ de elementos em qualquer posi¸caõ. Um fornece todos os métodos de um , com exce¸caõ de at[], capacity() e reserve(), e acrescenta métodos novos, como front(), push_front(), pop_front() e insert(pos,elem). Vimos que um container é uma fila com duas extremidades, unindo vantagens de e . Como exemplo a r´ apida inser¸caõ na frente e atr´ as do container. Um tem os mesmos métodos de , mas adiciona push_front(), pop_front() e suporta iteradores randˆ omicos. Dica: como o conjunto de métodos fornecidos por cada container é grande, n˜ ao tente decorar nada, apenas preste aten¸caõ no conceito. Com o tempo você ir´ a aprender a utilizar as classes container com facilidade.

32.5

Exerc´ıcios

1. Diga em poucas linhas, quais as principais diferen¸cas entre os containers , , , , , , , , . 2. Explique o porque da senten¸ca ”Uma lista n˜ ao aceita (iterator + n). Você precisa fazer iterator++ n vezes.”? 3. Porque n˜ ao aceita subscript[]. 4. Comente cada linha da listagem 32.1. 5. Modifique a listagem 32.1. Use streans_iterators para entrada dos dados. Transforme o operador < <, em um operador com template, isto é, com tipo a ser definido. Inclua localiza¸caõ do maior e menor elemento do container. 6. Modifique a listagem 32.2. Mostre na tela o conte´ udo da lista antes e depois de unique(). Verifique que os elementos repetidos n˜ ao s˜ ao eliminados, apenas movidos para o fim do conteiner. Monte um algoritmo para realmente eliminar os elementos repetidos. 7. Modifique a listagem 32.3. Substitua o uso de push_front() e push_back(), por método que possibilite a entrada de dados pelo usu´ ario. Monte um menu em que o usuário vai poder selecionar uma das seguintes op¸co˜es: Incluir novo elemento; Eliminar elemento; Mostrar elemento; Localizar elemento. Mostrar toda lista; Apagar toda lista. Programa¸caõ Orientada a Objeto com C++


32.5. EXERCÍCIOS

575

8. 2 Modifique a listagem 32.4. Substitua o operador< < (que usa template) por um operador sem template, fazendo o inverso de um de nossos exerc´ıcios anteriores. Possibilite ao usuário a entrada de dados. Use fun¸co˜es randˆ omicas para embaralhar o texto, como exemplo as fun¸co˜es next_permutation.



576

32.5. EXERCÍCIOS



Cap´ıtulo 33

Os Containers Adaptativos , e Veremos neste cap´ıtulo os containers adaptativos (se¸caõ 33.1), (se¸caõ 33.2) e (se¸caõ 33.3). Nota: neste momento você pode reler a descri¸caõ dos containers adaptativos apresentada na se¸caõ 31.2.3.

33.1

A classe container

Um é um container adaptado que trabalha como uma pilha LIFO (last in, first out ). O u ´ ltimo elemento colocado na pilha é o primeiro a ser removido, da mesma forma que ocorre com a pilha de uma calculadora HP (veja Figura 33.1). A Figura 33.1 mostra os métodos disponibilizados para . Figura 33.1: Métodos disponibilizados para . push()

top()

pop()

size()

Um é um container adaptado porque é constru´ıdo sobre um container , ou . Se n˜ ao for fornecido um container, por default é utilizado um . A Figura 33.2 mostra que a realiza¸caõ da classe é feita por , , ou 577

578


. Veja a direita outra forma de representar este relacionamemto usando UML, a classe aparece como uma interface de acesso a . Figura 33.2: A classe funciona como uma interface de acesso a , ou . <>

deque

deque

stack vector stack

list

Para utilizar um container , inclua o arquivo de cabe¸calho: #include

33.1.1

M´ etodos de

Apresenta-se a seguir alguns métodos de . void push(const value type& x); Coloca elemento x na pilha. void pop(); Remove elemento da pilha. value type& top(); Retorna o elemento no topo da pilha, sem remover. const value type& top() const; Retorna o elemento no topo da pilha, como valor constante. size type size() const; Retorna o n´ umero de elementos da pilha. bool empty() ; Retorna true se a pilha estiver vazia.

33.1.2

A listagem da classe

Como a classe é pequena e simples, a mesma é apresentada na ´ıntegra. Observe na listagem 33.1 que se você n˜ ao passar o tipo de container a ser utilizado, usa por padr˜ ao o tipo . Listing 33.1: A classe container . 1 2 3 4 5 6 7 8

// A classe c o n t a i n e r stack template < typename T , typename Container = deque > class stack { typedef Container :: value_type value_type ; typedef Container :: size_type size_type ; protected : Container c ;



33.1. A CLASSE CONTAINER 9 10 11 12 13 14 15 16

579

public : void push ( const value_type & x ) ; void pop () ; value_type & top () ; const value_type & top () const ; size_type size () const ; bool empty () ; };

33.1.3

Exemplo de

Veja na listagem 33.2 um exemplo de utiliza¸caõ do container . Como novidades temos, o uso de push() para adicionar elementos e de top() para ver o elemento no topo da pilha. Finalmente, usamos pop() para retirar elementos da pilha. Observe na sa´ıda que o primeiro a entrar é o u ´ ltimo a sair. Listing 33.2: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

# include < iostream > # include < stack > # include < vector > # include < list > # include < string > using namespace std ; int main () { // Cria uma pilha a partir de stack < string > stack < int , vector < int > > stack < float , list < float > >

um c o n t a i n e r deque , vector e list . politicos ; partidos ; notaDoPolitico;

// A d i c i o n a n d o e l e m e n t o s ao c o n t a i n e r char resp ; do { cout << " Entre com o nome do politico : " ; string n o m e _ p o l i t i c o ; getline ( cin , n o m e _ p o l i t i c o ) ; politicos . push ( n o m e _ p o l i t i c o ) ; cout << " Entre com o n´ u mero do partido : " ; int n u m e r o P a r t i d o ; cin >> n u m e r o P a r t i d o ; cin . get () ; partidos . push ( n u m e r o P a r t i d o ) ; cout << " Entre com a nota do politico : " ; int nota ; cin >> nota ; cin . get () ; n o t a D o P o l i t i c o . push ( nota ) ; cout << " Continuar ( c ) ou sair ( q ) : " ; cin >> resp ; cin . get () ; } while ( resp != ’q ’ && resp != ’Q ’ ) ; cout << " \ nRetirando elementos do container : " << endl ; while (! politicos . empty () ) { cout << politicos . top () << ’ ’; politicos . pop () ; cout << partidos . top () << ’ ’;



580 44 45 46 47 48 49 50

33.2. A CLASSE CONTAINER partidos . pop () ; cout << n o t a D o P o l i t i c o . top () << ’ ’ << endl ; n o t a D o P o l i t i c o . pop () ;

} cout << endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ List_30_1 Entre com o nome do politico : Joao da Silva Entre com o numero do partido :456 Entre com a nota do politico :5 Continuar ( c ) ou sair ( q ) : c Entre com o nome do politico : Claudio Siqueira Entre com o numero do partido :654 Entre com a nota do politico :7 Continuar ( c ) ou sair ( q ) : c Entre com o nome do politico : Jos´ e Candido Medeiros Entre com o numero do partido :648 Entre com a nota do politico :8 Continuar ( c ) ou sair ( q ) : q Retirando elementos do container : Jos´ e Candido Medeiros 648 8 Claudio Siqueira 654 7 Joao da Silva 456 5

33.2

A classe container

Um container é um container que trabalha como se fosse uma fila do tipo FIFO (first in, first out ). O primeiro que entra é o primeiro que sai. Um n˜ ao suporta iteradores. Veja Figura 33.3. • Os ´ıtens s˜ ao adicionados na parte de tr´ as (com push()) e removidos da parte da frente (com pop()). • O tipo pode ser adaptado a partir de qualquer container que suporte as opera¸co˜es front(), back(), push_back() e pop_front(). • Normalmente é utilizado com e (default ), pois n˜ ao suporta . • Para usar inclua o header : #include

Figura 33.3: Métodos disponibilizados para . ...

pop()

push()

front()

size()


back()



33.2.1

581

M´ etodos de

Apresenta-se a seguir alguns métodos de . value type& back(); Retorna o objeto do fim da lista (o u ´ ltimo elemento colocado). bool empty() const; Retorna true se a fila estiver vazia. value type& front(); Retorna o elemento da frente da fila. Primeiro ´ıtem que foi colocado na fila. void push(const value type& x); Coloca x na parte de tr´ as da fila. O primeiro que entra é o primeiro a sair. void pop(); Remove o elemento da frente da fila. size type size () const; Retorna o n´ umero de elementos da fila. const value type& back() const; Retorna o objeto do fim da lista (o u ´ ltimo elemento colocado) como const. const value type& front() const; Retorna o elemento da frente da fila como const.

33.2.2

A listagem da classe

Veja a seguir a classe container . Listing 33.3: A classe container . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

template < class T , class Container = deque > class queue { public : typedef typename Container :: value_type value_type ; typedef typename Container :: size_type size_type ; protected : Container c ; public : value_type & back () ; bool empty () const ; value_type & front () ; void push ( const value_type & x ) ; void pop () ; size_type size () const ; const value_type & back () const ; const value_type & front () const ; };



582

33.2.3


Exemplo de

Veja na listagem 33.4 um exemplo de uso do container . Listing 33.4: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# include < iostream > # include < queue > # include < vector > # include < list > # include < iomanip > using namespace std ; int main () { // Cria queue a partir de deque , e list std :: queue < int > c o n t a i n e r Q u e u e D e q u e ; std :: queue < int , std :: list < int > > c o n t a i n e r Q u e u e L i s t ; // A d i c i o n a n d o e l e m e n t o s ao c o n t a i n e r for ( int i = 0; i < 10; ++ i ) { c o n t a i n e r Q u e u e D e q u e . push ( i ) ; c o n t a i n e r Q u e u e L i s t . push ( i * i ) ; } cout << " \ nRetirand o elementos do c o n t a i n e r Q u e u e D e q u e : " ; while (! c o n t a i n e r Q u e u e D e q u e . empty () ) { cout << setw (5) << c o n t a i n e r Q u e u e D e q u e . front () << ’ ’; c o n t a i n e r Q u e u e D e q u e . pop () ; } cout << " \ nRetirand o elementos do c o n t a i n e r Q u e u e L i s t : " ; while (! c o n t a i n e r Q u e u e L i s t . empty () ) { cout << setw (5) << c o n t a i n e r Q u e u e L i s t . front () << ’ ’; c o n t a i n e r Q u e u e L i s t . pop () ; } cout << endl ; return 0; } [ a n d r e @ m e r c u r i o Cap4 - STL ]# ./ a . out Retirando elementos do c o n t a i n e r _ q u e u e _ d e q u e : 0 1 2 3 4 5 6 7 8 9 Retirando elementos do c o n t a i n e r _ q u e u e _ l i s t : 0 1 4 9 16 25 36 49 64 81

33.3

A classe container

Este container funciona da mesma forma que um , a diferen¸ca é que na a fila est´ a sempre ordenada, ou seja, o elemento retirado com pop() é sempre o maior. • Um compara seus elementos utilizando operador <. • Utilize pop() para retornar o maior valor. • Para utilizar , inclua o arquivo de cabe¸calho: #include Programa¸caõ Orientada a Objeto com C++



33.4

583


Neste cap´ıtulo aprendemos a utilizar os containers adaptativos , e , containers que s˜ ao constru´ıdos a partir da adapta¸caõ de um outro container. Lembre-se um é um container adaptado que trabalha como uma pilha LIFO (last in, first out ). O u ´ ltimo elemento colocado na pilha é o primeiro a ser removido, da mesma forma que ocorre com a pilha de uma calculadora HP. Vimos que push() coloca o ´ıtem x na pilha, que pop() remove um ´ıtem da pilha, que top() retorna o ´ıtem no topo da pilha, sem o remover. Vimos que um container é um container que trabalha como se fosse uma fila do tipo FIFO (first in, first out ), o primeiro que entra é o primeiro que sai. Os ´ıtens s˜ ao adicionados na parte de tr´ as com push() e removidos da parte da frente com pop(). O tipo é normalmente utilizado com e (default ), pois n˜ ao suporta . Entre os métodos de temos: back() que retorna o objeto do fim da lista, empty() que retorna true se a fila estiver vazia. front() que retorna o ´ıtem da frente da fila. push() que coloca x na parte de tr´ as da fila. pop() que remove o ´ıtem da frente da fila e size() que retorna o n´ umero de elementos da fila. As classes , e s˜ ao exemplos de classe de interface.

33.5

Exerc´ıcios

1. Explique o funcionamento da listagem 33.2. 2. Modifique a listagem 33.2. 3. Modifique a listagem 33.4. 4. Implementar um exemplo que utilize .



584

33.5. EXERCÍCIOS



Cap´ıtulo 34

Os Containers Associativos , , e Veremos neste cap´ıtulo a classe (se¸caõ 34.1) e os containers associativos (se¸caõ 34.2), (se¸caõ 34.3), (se¸caõ 34.3), e (se¸caõ 34.5). Nota: os containers associativos foram brevemente descritos na se¸caõ 31.2.2.

34.1

A classe

Toda fun¸caõ ou método retorna apenas um objeto. Em muitos casos, você pode querer que um método retorne dois objetos. Nestes casos, podemos utilizar um objeto da classe . A classe é definida no arquivo de cabe¸calho . Um é um objeto composto de dois outros objetos. O mesmo é utilizado em alguns métodos dos containers , e . Veja a seguir o prot´ otipo para criar e utilizar um . Prot´ otipo: Para criar um pair objPar (Tipo1 obj, Tipo2 obj); Para usar um cout < < ”Primeiro objeto = ” < < objPar->first(); cout < < ”Segundo objeto = ” < < objPar->second(); Pode-se construir rapidamente um utilizando-se make_pair(). Veja o exemplo: Exemplo: pair objPair = make_pair( 6 , 7.4 );

34.2

A classe container

O container é um container associativo utilizado para armazenar um conjunto de chaves. Veja a seguir algumas caracter´ısticas do contaier . • As chaves n˜ ao podem ser repetidas. 585

586


• Aceita acesso bidirecional, mas n˜ ao randˆ omico. • Define value_type como sendo a chave. • Inclui sobrecarga para os operadores ==, !=, <, >, <=, >= e swap. • N˜ ao tem o operador []. • Os objetos armazenados em est˜ ao sempre ordenados. • Para utilizar o container , inclua o arquivo de cabe¸calho : #include ´ como um , mas n˜ • E ao armazena um valor, somente a chave. A Figura 34.1 mostra os métodos disponibilizados para . Observe o uso de insert() para incluir uma chave e de erase() para eliminar uma chave. O container inclui os métodos find() para pesquisa de uma determinada chave, count() para contagem de objetos, além de lower_bound(), upper_bound() e equal_range(). Figura 34.1: Métodos disponibilizados para . c

c 0

c

c 1

2

...

c n-2

3

c n-1

erase(chave) insert(chave)

34.2.1

Contrutores e destrutor

set (); Constr˜ oe um set vazio (construtor default ). set (InputIterator first, InputIterator last); Constr˜ oe um set usando o intervalo [first,last).

34.2.2

Trocas

void swap(set& s); Troca o conte´ udo do container s com o conte´ udo deste container (de this).

34.2.3

Inser¸c˜ ao e dele¸c˜ ao

pair insert(const value type& x) ; Insere a chave x no container e retorna um par onde o primeiro elemento é um iterador para posi¸caõ do objeto no container e o segundo elemento um bool que indica sucesso ou fracasso na inser¸caõ. iterator insert(iterator pos, const value type& x); Insere a chave x no container no local indicado pelo iterador pos. Programa¸caõ Orientada a Objeto com C++



587

void erase(iterator pos); Elimina o objeto na posi¸caõ pos. size type erase(const key type& x); Elimina o objeto indicado pela chave x. void erase(iterator first, iterator last); Elimina os elementos do container que est˜ ao no intervalo [first, last). void clear(); Elimina todos os elementos do container.

34.2.4

Pesquisa e contagem

iterator find(const key type& x); Procura pelo elemento associado a chave x. size type count(const key type& x); Conta o n´ umero de elementos associados a chave x. Complexidade log(n)+count. iterator lower bound(const key type& x); Retorna iterador para o primeiro elemento associado a chave x. Complexidade log(n). iterator upper bound(const key type& x); Retorna iterador para o objeto imediatamente ap´ os o u ´ ltimo objeto associado a chave x. Complexidade log(n). pair equal range(const key type& x); Retorna um par de iteradores onde first é o valor retornado por lower_bound() e last o valor retornado por upper_bound(). Complexidade log(n).

34.2.5

Operadores

Os operadores de s˜ ao == e <.

34.2.6

Exemplo de

Veja na listagem 34.1 um exemplo de utiliza¸caõ do container . O programa cria um container , para n´ umeros inteiros, com o nome cset. Note que passamos o operador a ser utilizado para ordena¸caõ do container, std::less. A seguir acrescenta novas chaves no container. Finalmente, criamos um iterador para cout e usamos a fun¸caõ genérica copy() para enviar os elementos do container para tela. Observe que na sa´ıda os dados est˜ ao ordenados, mesmo n˜ ao tendo sido inclu´ıdos de forma ordenada. Listing 34.1: Usando . 1 2 3 4 5 6 7 8 9 10

# include < iostream > # include < set > # include < algorithm > # include < iterator > using namespace std ; int main () { // Cria um c o n t a i n e r set , para tipo int // usa o p e r a d o r de c o m p a r a ¸ c~ a o std :: less < int >



588 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 1 2


set < int , std :: less < int > > cset ; // Insere o b j e t o s no c o n t a i n e r ( sem ordem ) cset . insert (10) ; cset . insert (1000) ; cset . insert (100) ; cset . insert (10000) ; // Cria i t e r a d o r para uma o s t r e a m std :: o s t r e a m _ i t e r a t o r < int > out ( cout , " \ t " ) ; // Copia o c o n t a i n e r para tela usanto o i t e r a d o r out copy ( cset . begin () , cset . end () , out ) ; cout << endl ; return 0; } [ a n d r e @ m e r c u r i o Parte - IV ] $ ./ a . out 10 100 1000 10000

Dica: a classe da STL costuma ser implementada como uma árvore de pesquisa balanceada, em que cada elemento tem três ponteiros. Isto garante performance, mas implica em aumento do consumo de mem´ oria, [Meyers, 2005].

34.3

A classe container

Um container trabalha com um conjunto de chaves que podem ser repetidas. Veja a seguir as caracter´ısticas de . • O mesmo armazena e recupera o valor da chave rapidamente. • O container suporta iterador bidirecional. • As chaves est˜ ao sempre ordenadas, em ordem crescente. ´ um container associativo. • E • Para utilizar , inclua o arquivo de cabe¸calho: #include • A diferen¸ca para é que insert() retorna um iterator e n˜ ao um . A Figura 34.2 mostra alguns métodos disponibilizados para : Figura 34.2: Métodos disponibilizados para . c0

c1

c2

c4

c4

c[n-2]

c[n-1]

erase(ci)

insert(c3) repetidas




34.3.1

589

Contrutores e destrutor

multiset (); Construtor default. multiset (InputIterator first, InputIterator last); Cria um multiset utilizando os valores do intervalo [first,last).

34.3.2

Operadores

operator= (const multiset& x);

34.4

A classe container

Nesta se¸caõ descreveremos o container associativo . Um container trabalha com um conjunto de chaves e de objetos associados a essas chaves, ou seja, trabalha com pares onde a ordena¸caõ e tomada de decis˜ oes é baseada nas chaves. Veja a seguir as caracter´ısticas do container . ´ um container associativo. • E • Em um as chaves n˜ ao podem ser repetidas. • Um fornece iteradores bidirecionais. • Em um , os dados s˜ ao armazenados de forma ordenada, pelo operador menor que (<). • Num , value_type é um pair. • Para usar inclua seu arquivo de cabe¸calho: #include A Figura 34.3 mostra alguns métodos disponibilizados para . O container é muito u ´ til, como veremos na listagem 34.2. Figura 34.3: Métodos disponibilizados para . c0

c1

c2

v[0]

v[1]

v[2]

cj ...

...

v[j]

insert( cj , vj)


v[i]

c[n-2] c[n-1]

chave

v v [n-2] [n-1]

valor

erase( ci )


590


34.4.1


map (); Constr˜ oe um map vazio (construtor default ). Exemplo: map< int, string > meuMap; map (InputIterator first, InputIterator last); Constr˜ oe um map usando o intervalo definido por [first,last).

34.4.2

Operadores

Os operadores de s˜ ao == e <. map& operator=(const map& x); Operador de atribui¸caõ.

34.4.3

Inser¸c˜ ao e dele¸c˜ ao

pair insert(const value type& x); Insere um pair no container (um par(chave,valor)). Exemplo: meuMap.insert(make_pair( 5 , "jo~ ao" ); iterator insert(iterator pos, const value type& x); Insere um pair no container na posi¸caõ indicada. void erase(iterator pos); Apaga elemento localizado na posi¸caõ pos. size type erase(const key type& x); Apaga os elementos com a chave x. void erase(iterator first, iterator last); Apaga os elementos no intervalo [first-last). void clear() ; Apaga todos os elementos do container.

34.4.4

Pesquisa e contagem

iterator find(const key type& x) ; Localiza objeto com a chave x; se n˜ ao achar, retorna end(). size type count(const key type& x) ; Conta o n´ umero de objetos com a chave x. iterator lower bound(const key type& x); Retorna um iterador para primeiro elemento igual a x. Se n˜ ao encontrar x, retorna iterador para primeiro elemento maior que x (ou para end()). Programa¸caõ Orientada a Objeto com C++



591

iterator upper bound(const key type& x) ; Retorna um iterador para o primeiro elemento maior que x. pair equal range(const key type& x) ; Retorna um par onde o primeiro elemento (first ) é o retorno de lower_bound() e o segundo elemento (second ), o retorno de upper_bound(). const iterator find(const key type& x) ; Localiza objeto com a chave x; se n˜ ao achar, retorna end(). Retorna iterador constante. const iterator lower bound(const key type& x) ; Retorna um iterador constante para primeiro elemento igual a x. Se n˜ ao encontrar x, retorna iterador para primeiro elemento maior que x (ou para end()). const iterator upper bound(const key typ& x) ; Retorna um iterador constante para o primeiro elemento maior que x. pair equal range(const key type& x) ; Retorna um par onde o primeiro elemento (first ) é o retorno de lower_bound() e o segundo elemento (second ), o retorno de upper_bound(). Os iterador de pair s˜ ao constantes.

34.4.5

Exemplo de

Veja na listagem 34.2 um exemplo que inclui a utiliza¸caõ de . O c´ odigo esta documentado. Observe na sa´ıda que os objetos do container s˜ ao listados em ordem alfabética. Isto ocorre porque é sempre ordenado; a ordena¸caõ é feita pela chave. Listing 34.2: Usando . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# include < iostream > # include < fstream > # include < iomanip > # include < string > # include < map > using namespace std ; class CTelefone // Tipo telefone , a r m a z e n a o p r e f i x o e o n´ u mero { private : int prefixo ; int numero ; public : // C o n s t r u t o r CTelefone () : prefixo (0) , numero (0) {}; // S o b r e c a r g a de friend istream & friend ostream & friend ofstream &

s t r e a m s como fun¸ c~ a o friend operator >> ( istream & is , CTelefone & t ) ; operator << ( ostream & os , const CTelefone & t ) ; operator << ( ofstream & os , const CTelefone & t ) ;

}; istream & operator > >( istream & is , CTelefone & t ) { is >> t . prefixo ; is >> t . numero ; return is ; }



592 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92


ostream & operator < <( ostream & os , const CTelefone & t ) { os . setf ( ios :: left ) ; os << " ( " << t . prefixo << " ) -" << t . numero << endl ; return os ; } ofstream & operator < <( ofstream & os , const CTelefone & t ) { os . setf ( ios :: left ) ; os << t . prefixo << ’ ’ << t . numero << endl ; return os ; } int main () { // Usa um typedef , um a p e l i d o para std :: map usando string e C T e l e f o n e // A string ´ e a chave e o C T e l e f o n e o valor . typedef std :: map < string , CTelefone > c o n t a i n e r M a p ; // Cria c o n t a i n e r para a r m a z e n a r lista de t e l e f o n e s containerMap listatelefones; CTelefone telefone ; int resp = 0; string linha ( " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ) ; do { string nome ; cout << " Entre com o nome da pessoa / empresa : " << endl ; getline ( cin , nome ) ; cout << " Entre com o telefone ( prefixo n´ u mero ) " << " ( ctrl + d para encerrar entrada ) : " << endl ; cin >> telefone ; cin . get () ; // O b s e r v e a i n s e r ¸ c~ a o da chave ( o nome ) e do valor ( o t e l e f o n e ) . if ( cin . good () ) l i s t a t e l e f o n e s . insert ( c o n t a i n e r M a p :: value_type ( nome , telefone ) ) ; } while ( cin . good () ) ; cin . clear () ; cout << linha << " Conte´ u do do container :\ n " << linha << " \ nChave valor " << endl ; // Sa´ ı da para tela a l i n h a d a a e s q u e r d a cout . setf ( ios :: left ) ; // Cria i t e r a d o r c o n t a i n e r M a p :: c o n s t _ i t e r a t o r iter ; for ( iter = l i s t a t e l e f o n e s . begin () ; iter != l i s t a t e l e f o n e s . end () ; ++ iter ) { cout << setw (5) << iter - > first << ’ ’ << iter - > second ; } cout << endl ; // Sa´ ı da para disco ofstream fout ( " L i s t a _ t e l e f o n e s _ m a p . dat " ) ; if ( fout ) { for ( iter = l i s t a t e l e f o n e s . begin () ; iter != l i s t a t e l e f o n e s . end () ; ++ iter ) fout << iter - > first << ’ ’ << iter - > second ; fout . close () ;



34.4. A CLASSE CONTAINER 93 94 95 96

593

} cout << endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ a . out Entre com o nome da pessoa / empresa : LENEP Entre com o telefone ( prefixo numero ) ( ctrl + d para encerrar entrada ) : 22 27969700 Entre com o nome da pessoa / empresa : LMPT Entre com o telefone ( prefixo numero ) ( ctrl + d para encerrar entrada ) : 48 33317709 Entre com o nome da pessoa / empresa : Entre com o telefone ( prefixo numero ) ( ctrl + d para encerrar entrada ) : ---------------------------------------------------Conte´ u do do container : ---------------------------------------------------Chave valor LENEP (22) -27969700 LMPT (48) -33317709

34.4.6

Senten¸cas para

• Utilize um para implementar um dicion´ ario. • O método begin() aponta para primeira chave ordenada (de forma crescente) e end(), para u ´ ltima chave +1. • O método erase() retorna o n´ umero de objetos deletados. • Se a chave n˜ ao for localizada, insere a chave da pesquisa no , associando o valor a um valor default (zerado). • Se você quer achar um par (chave,valor), mas n˜ ao tem certeza de que a chave est´ a no , use o método find(). Pois, como dito na senten¸ca anterior, se a chave n˜ ao for localizada, ela ser´ a inserida. • A pesquisa no utilizando a chave tem um custo da ordem de ˜log(tamanhoDoMap). • Um construtor de pode receber um método de compara¸caõ, de forma que você pode construir dois mapas e usar o mesmo método de compara¸caõ em ambos. • Na seq¨ uência AAAB, a chamada a lower_bound(A) retorna um iterator para o primeiro A e upper_ bound(A), um iterator para o primeiro elemento depois do u ´ ltimo A, ou seja, para B. Assim, lower_bound() aponta para primeiro elemento na sequência e upper_bound() para u ´ ltimo elemento +1. • Utilize it->first para acessar a chave e it->second para acessar o valor. Exemplo: map::const_iterator it; for(it = obj.begin(); it != obj.end(); it++) cout < < "chave=" < < it->first < < " valor=" < < it>second < < endl; Programa¸caõ Orientada a Objeto com C++


594

34.5


A classe container

O container trabalha com um conjunto de chaves e de objetos associados a essas chaves, ou seja, trabalha com pares. Veja a seguir caracter´ısticas do container . • A ordena¸caõ e a tomada de decis˜ oes s˜ ao baseadas nas chaves. • Em um , as chaves podem ser repetidas. • O container n˜ ao tem operador de subscrito (operator[]). ´ um container associativo. • E • No container , o método insert() retorna um iterator e n˜ ao um . E o uso de insert() sempre ocorre com sucesso pois aceita valores repetidos. • Para acessar os valores que têm a mesma chave, utilizam-se equal_range(), lower_bound() e upper_bound(). Exemplo: // Primeiro valor igual a x. lower_bound(x); // Primeiro valor maior que x. upper_bound(x); // Retorna um par // first = lower_bound(), second = upper_bound(). equal_range(x); • Para utilizar um , inclua o arquivo de cabe¸calho : Exemplo: #include

34.6


Neste cap´ıtulo aprendemos a utilizar a classe , para armazenar pares de dados, e os containers associativos , , , e . Aprendemos a utilizar para armazenar um conjunto de chaves sem repeti¸co˜es, e , para armazenar conjuntos de dados com chaves e valores (sem repeti¸co˜es). Montamos um exemplo que implementa, mesmo que basicamente, uma agenda de telefones.

34.7

Exerc´ıcios

1. Monte um exemplo que utilize make_pair(); 2. Modifique a listagem 34.1, mudando a ordem de ordena¸caõ do container. Ou seja, substituir o operador de compara¸caõ por std::greater. Ver o resultado. 3. Monte um exemplo que utilize . 4. Modifique a listagem 34.2, acrescente uma classe CEndereco (que deve incluir a cidade, cep, rua, telefone e e-mail). Desta forma o programa vai montar uma agenda com todos os dados de seus amigos. Programa¸caõ Orientada a Objeto com C++


34.7. EXERCÍCIOS

595

5. No exemplo da listagem 34.2, substitua containerMap::value_type(nome, telefone) por make_pair(nome, telefone). 6. Modifique o exemplo anterior, usando o endere¸co de e-mail como chave de acesso.



596

34.7. EXERCÍCIOS



Cap´ıtulo 35

Programa¸ c˜ ao Gen´ erica Veremos neste cap´ıtulo um conjunto de fun¸co˜es que s˜ ao utilizadas na programa¸caõ genérica e que s˜ ao fornecidas com a STL. Iniciaremos vendo uma introdu¸caõ ` a programa¸caõ genérica (se¸caõ 35.1). A seguir apresentaremos as diferentes formas de classifica¸caõ das fun¸co˜es genéricas (se¸caõ 35.2), quanto à modifica¸caõ do container (se¸caõ 35.2.1), quanto à categoria dos iteradores (se¸caõ 35.2.2) e quanto às opera¸co˜es realizadas (se¸caõ 35.2.3). As fun¸co˜es genéricas s˜ ao ent˜ ao apresentadas: • Preenchimento (se¸caõ 35.3.1) • Compara¸caõ (se¸caõ 35.3.2) • Remo¸caõ (se¸caõ 35.3.3) • Trocas (se¸caõ 35.3.4) • Misturar/Mesclar/Inverter (se¸caõ 35.3.5) • Pesquisa (se¸caõ 35.3.6) • Ordena¸caõ (se¸caõ 35.3.7) • Classifica¸caõ (se¸caõ 35.3.8) • Transforma¸caõ (se¸caõ 35.3.9) • Matem´ aticos (se¸caõ 35.3.10) • Opera¸co˜es com conjuntos (se¸caõ 35.3.11) • Ordena¸cao de pilhas (heapsort - se¸caõ 35.3.12) finalizaremos o cap´ıtulo vendo exemplos (se¸caõ 35.4) e senten¸cas para c´ odigo genérico (se¸caõ 35.5). Nota: uma descri¸caõ detalhadas das fun¸co˜es genéricas pode ser obtida em http://www.cplusplus. com/reference/algorithm/. 597

598

35.1

˜ A ` PROGRAMAC ˜ GENERICA ´ 35.1. INTRODUC ¸ AO ¸ AO

Introdu¸ c˜ ao ` a programa¸c˜ ao gen´ erica

Embora o conceito de programa¸caõ genérica seja antigo (cerca de 30 anos), seu uso se intensificou com a inclus˜ ao na STL de um conjunto de fun¸co˜es genéricas. Ou seja, a STL fornece, além de uma biblioteca de classes containers, um vasto conjunto de fun¸co˜es para pesquisa, ordena¸caõ, mistura, troca e transforma¸co˜es em um container. • Cada fun¸caõ pode ser aplicada a um conjunto espec´ıfico de containers. • Algumas fun¸co˜es genéricas exigem que a classe container já tenha sido ordenada. • De uma maneira geral, as fun¸co˜es genéricas utilizam iteradores para acessar e manipular os containers. • As fun¸co˜es genéricas foram constru´ıdas de forma a necessitar de um n´ umero reduzido de servi¸cos dos iteradores. • O uso de gabaritos (templates) e de fun¸co˜es genéricas permite a implementa¸caõ de algoritmos independentes do tipo de dados a ser utilizado.

35.2

Classifica¸c˜ ao das fun¸c˜ oes gen´ ericas

Veja a seguir uma classifica¸caõ das fun¸co˜es genéricas quanto à mudan¸ca do container, quanto ao iterador necess´ ario e quanto ao tipo das opera¸co˜es.

35.2.1

Classifica¸c˜ ao quanto ` a modifica¸c˜ ao do container

• Fun¸ co ˜es que n˜ ao mudam o container: accumulate, find, max, adjacent find, find if, max element, binary search, min, count, find first of, for each, min element, count if, includes, mismatch, equal, lexicographical compare, nth element, equal range, lower bound, mismatch, search, search n, find end, upper bound. • Fun¸ co ˜es que mudam o container: copy, remove if, copy backward, replace, fill, replace copy, fill n, replace copy if, generate, replace if, generate n, reverse, inplace merge, reverse copy, iter swap, rotate swap, make heap, rotate copy, merge, set difference, nth element, next permutation, set intersection, set symmetric difference, partial sort, set union, partial sort copy, sort, partition, sort heap, prev permutation, stable partition, push heap, stable sort, pop heap, swap, random shuffle, swap ranges, remove, transform, unique, unique copy, remove copy, remove copy if.

35.2.2

Classifica¸c˜ ao quanto ` a categoria dos iteradores

• Algoritmos que n˜ ao usam iterador: max, min, swap. • Requer somente InputIterator: accumulate, find, mismatch, count, find if, count if, includes, equal, inner product, for each, lexicographical compare. • Requer somente OutputIterator: fill n, generate n. Programa¸caõ Orientada a Objeto com C++


˜ DAS FUNC ˜ ´ 35.2. CLASSIFICAC ¸ AO ¸ OES GENERICAS

599

• Lˆ e de um InputIterator e escreve para um OutputIterator: adjacent difference, replace copy, transform, copy, replace copy if, unique copy, merge, set difference, partial sum, set intersedtion, remove copy, set symmetric difference, remove copy if, set union. • Requer um ForwardIterator: adjacent find, lower bound, rotate, binary search, max element, search, equal range, unique, min element, swap ranges, fill, remove, find first of, remove if, upper bound, generate, replace, iter swap, replace if. • Lˆ e de um ForwardIterator e escreve para um OutputIterator: rotate copy. • Requer um BidirectionalIterator: copy backward, partition, inplace merge, prev permutation, next permutation, reverse, stable permutation. • Lˆ e de um BidirectionalIterator e escreve em um OutputIterator: reverse copy. • Requer um iterator randˆ omico, RandomAccessIterator: make heap, pop heap, sort, nth element, push heap, sort heap, partial sort, random shuffle, stable sort. • Lˆ e de um InputIterator e escreve para um RandomAccessIterator: partial sort copy.

35.2.3

Classifica¸c˜ ao quanto ` as opera¸c˜ oes realizadas

• Opera¸ co ˜es de preenchimento: fill, fill n, copy, copy backward • Opera¸ co ˜es de compara¸ c˜ ao: equal, mismatch, lexicographical compare, includes • Opera¸ co ˜es de remo¸ c˜ ao: remove, remove if, remove copy, remove copy if • Opera¸ co ˜es de troca (swap): swap, swap ranges, iter swap, replace, replace copy, replace copy if, replace if • Opera¸ co ˜es de mistura: inplace merge, merge, reverse, reverse copy, random shuffle, rotate, rotate copy • Opera¸ co ˜es de pesquisa: find, adjacent find, find if, find first of, count if, search, find, binary search, search n, lower bound, equal range, upper bound • Opera¸ co ˜es de ordena¸ c˜ ao: sort, partial sort, stable sort, partial sort copy, nth element • Opera¸ co ˜es de classifica¸ c˜ ao: unique copy, unique Programa¸caõ Orientada a Objeto com C++


˜ ´ 35.3. FUNC ¸ OES GENERICAS

600

• Opera¸ co ˜es de transforma¸ c˜ ao: generate n, generate, for each, transform, partition, stable partition • Opera¸ co ˜es matem´ aticas: max, min, max element, min element, count, count if, accumulate • Opera¸ co ˜es de set (conjuntos): set symmetric difference, set difference, set union, set intersection • Opera¸ co ˜es de pilha: make heap, push heap, pop heap, sort heap, next permutation, prev permutation

35.3

Fun¸ c˜ oes gen´ ericas

Veremos a seguir uma breve descri¸caõ de cada fun¸caõ genérica oferecida pela STL. Se o leitor n˜ ao compreender determinada fun¸caõ, a dica é ver os exemplos apresentados no final deste cap´ıtulo. Observe que apresentamos a forma de uso e n˜ ao o prot´ otipo; o prot´ otipo das fun¸co˜es genéricas é encontrado no arquivo de cabe¸calho ou no site http: //www.sgi.com/tech/stl/.

35.3.1

Preenchimento

As fun¸co˜es fill() e copy() s˜ ao utilizadas para preencher o container. fill (d.begin(), d.end(), valor); Utiliza fill para preencher o container de begin() a end() com o valor. Veja listagem 35.1. fill n (d.begin(), n, valor); A partir da posi¸caõ begin(), preencher n elementos do container com o valor. copy (orig.begin(), orig.end(), out); Copia de first a last para out. Utilize copy() para gerar uma sa´ıda do container ou para gerar um novo container. A fun¸caõ copy() é usada para copiar blocos de dados de um container para outro. Veja listagens 35.2 e 35.3. copy backward (orig.begin(), orig.end(), dest.end()); Copia os elementos de orig para dest; orig[0] é colocado no fim de dest, e assim sucessivamente.

35.3.2

Compara¸c˜ ao

Os algoritmos a seguir s˜ ao utilizados para comparar containers ou elementos de containers. Para comparar elementos de containers do mesmo tipo use == ou <. equal (v1.begin(), v1.end(), v2.begin()); Compara a igualdade de cada elemento dos containers v1 e v2. Retorna true se for tudo igual. mismatch (v1.begin(), v1.end(), v2.begin()); Retorna um par de iteradores que apontam para objetos de v1 e v2 que s˜ ao diferentes. Se v1 == v2, os iteradores apontam para end(). Programa¸caõ Orientada a Objeto com C++



601

lexicographical compare (v1.begin(), v1.end(), v2.begin(), v2.end()); Retorna a posi¸caõ onde os containers v1 e v2 s˜ ao diferentes. includes (a, a+size, b, b+size); Compara os containers ordenados a e b; se qualquer elemento de b estiver presente em a, retorna true. Veja listagem 36.4.

35.3.3

Remo¸c˜ ao

Os algoritmos a seguir s˜ ao utilizados para remover elementos do container. Observe que os elementos n˜ ao s˜ ao de fato removidos, apenas movidos para o fim do container (no intervalo de valores entre size() e capacity()). remove (v.begin(), v.end(), valor); Percorre todo o container (de begin() a end()) e remove os objetos que têm seu conte´ udo igual a valor. c˜ aoPredicado); remove if (v.begin(), v.end(), Fun¸ Remove de begin() a end() se a fun¸caõ predicado retornar true. remove copy (orig.begin(), orig.end(), d.begin(), valor); Remove de begin() a end() o valor e copia para d. Se o container d for pequeno, haverá estouro de pilha. remove copy if (o.begin(), o.end(), d.begin(), fpred); Remove de begin() a end() se a fun¸caõ predicado retornar true e copia para d.

35.3.4

Troca

Os algoritmos a seguir s˜ ao utilizados para trocar elementos de containers. replace (v.begin(), v.end(), valor, novoValor); Troca de begin() a end() valor por novoValor. c˜ aoPredicado, novoValor); replace if (v.begin(), v.end(), Fun¸ Se a fun¸caõ predicado retornar true, troca pelo novoValor. replace copy (orig.begin(), orig.end(), d.begin(), valor, novoValor); Troca de begin() a end() valor por novoValor e copia para d. replace copy if (orig.begin(), orig.end(), d.begin(), Fun¸ c˜ aoPredicado, novoValor); Se a fun¸caõ predicado retornar true, troca por novoValor no destino d. swap (v[0], v[1]); Troca o conte´ udo de v[0] pelo conte´ udo de v[1]. iter swap (it1, it2); Troca os objetos apontados por it1 e it2. swap range (v, v+3, v+4); Troca os objetos no intervalo especificado. O primeiro intervalo vai de v a v+3 (excluindo v+3). O segundo intervalo inicia-se em v+4. Programa¸caõ Orientada a Objeto com C++



602

35.3.5

Misturar/Mesclar/Inverter

Os algoritmos a seguir s˜ ao utilizados para misturar, mesclar ou inverter elementos de diferentes containers. merge (orig1.begin(), orig1.end(), orig2.begin(), orig2.end(), dest.begin()) Pega os containers orig1 e orig2, que devem estar ordenados, e cria um container v3 com todos os elementos de orig1 e orig2. A seguir, copia os elementos de v3 para dest. merge (orig1.begin(), orig1.end(), orig2.begin(), orig2.end(), back inserter(d)) Pega os containers orig1 e orig2, que devem estar ordenados, e cria um container v3 com todos os elementos de orig1 e orig2. Depois copia v3 para d usando push_back(). inplace merge (v.begin(), v.begin()+n, v.end()) Mistura dois conjuntos de dados do mesmo container. Ir´ a misturar os valores de begin() a begin()+n com os valores a partir de begin()+n (sem ultrapassar v.end()). reverse (v.begin(), v.end()); Muda a ordem; o primeiro passa a ser o u ´ ltimo. Veja listagem 36.4. reverse copy (orig.begin(), orig.end(), back inserter(dest)); Inverte os elementos de orig e copia para dest. A fun¸caõ back_inserter() chama a fun¸caõ push_back() de dest para inserir os elementos em dest. rotate (v.begin(), v.end(), v.begin()); Rotaciona ciclicamente. Veja listagem 36.4. random shufle (v.begin(), v.end()); Embaralha os elementos do container randomicamente.

35.3.6

Pesquisa

Os algoritmos a seguir s˜ ao utilizados para pesquisar/localizar determinado valor ou condi¸caõ. Para fazer pesquisa de tr´ as para frente use um reverse_iterator. find (v.begin(), v.end(), valor); O find() procura por valor no intervalo especificado. Veja listagens 35.1 e 35.4. find if (v.begin(), v.end(), Fun¸ c˜ aoPredicado); O find_if() procura no intervalo [first-last) o objeto que satisfa¸ca à fun¸caõ predicado. Veja listagem 35.1. find first of (v1.begin(), v1.end(), v2.begin(), v2.end()); Retorna iterador para elemento de v1 que existe em v2. find end(v1.begin(), v1.end(), v2.begin(), v2.end()); Procura a u ´ ltima ocorrência de uma subsequência em um intervalo. Procura no intervalo [v1.begin(), v1.end()) por uma sub-sequência de valores iguais no intervalo [v2.begin(), v2.end()) e retorna um iterador para primeiro elemento na sub-sequência. adjacent find (v.begin(), v.end()); Procura pelo primeiro par de valores iguais e adjacentes; retorna iterador para o primeiro elemento. Programa¸caõ Orientada a Objeto com C++



603

binary search (v.begin(), v.end(), valor); Retorna true se o valor estiver presente no container. O container deve estar ordenado. lower bound (v.begin(), v.end(), valor); Retorna um iterador para o primeiro elemento igual ao valor. Para manter o container ordenado, inserir valor utilizando o iterador retornado. No exemplo a seguir, se o vetor v tem os elementos 3,4,6,12,34,34,34,50 e valor=34, lower_bound() retorna iterador para o primeiro 34. Exemplo: vector::iterator lower; lower = lower_bound(v.begin(),v.end(),valor); upper bound (v.begin(), v.end(), valor); Retorna um iterador para o primeiro elemento maior que valor. Se tiver 3,4,6,12,34,34,50 e valor=34, retorna iterador para 50. Exemplo : vector::iterator uper = uper_bound(v.begin(),v.end(),valor); equal range (v.begin(), v.end(), valor); Retorna um pair para aplica¸caõ de first=lower_bound() e second=uper_bound(). Exemplo: pair::iterator, vector::iterator> p; p = equal_range(v.begin(),v.end(),valor); search (v.1begin(), v1.end(), v2.begin(), v2.end()); Procura uma seq¨ uência de v1.begin() a v1.end() que exista em v2.begin() a v2.end(). Ou seja, a seq¨ uência do container v1 existe no container v2? Retorna iterador para primeiro objeto no container v1. search (v.begin(), v.end(), Fun¸ c˜ aoPredicado); Procura de v.begin() a v.end() os elementos do container que satisfa¸cam à fun¸caõ predicado. Retorna iterador para primeira ocorrência. search n (v.begin(), v.end(), n, valor) Procura seq¨ uência com n combina¸co˜es de valor. Retorna iterador para primeiro elemento encontrado.

35.3.7

Ordena¸c˜ ao

Os algoritmos a seguir s˜ ao utilizados para ordenar um container. sort (v.begin(), v.end()); Ordena o container v, de v.begin(), até v.end(). O método sort() n˜ ao é dispon´ıvel para ; utilize o sort() do próprio container . A fun¸caõ sort() usa um algoritmo do tipo ”quicksort” e tem um custo computacional proporcional a O(N.log(N)). Veja listagens 35.1, 35.2, 35.3, 36.4. Exemplo: sort(v.begin(), v.end(), std::greater); partial sort (in´ıcio, meio, fim); Ordena do in´ıcio até o meio. Programa¸caõ Orientada a Objeto com C++



604

35.3.8

Classifica¸c˜ ao

Os algoritmos a seguir s˜ ao utilizados para classificar um container. unique copy (orig.begin(), orig.end(), back inserter(dest)); Obtém uma c´ opia de orig, sem elementos repetidos, e copia para dest. unique (v.begin(), v.end()); Elimina os elementos duplicados, movendo-os para o fim do container. Observe que retorna iterador para u ´ ltimo elemento n˜ ao duplicado. Nota: antes de chamar unique(), chame sort(). Apresenta-se no exemplo a seguir uma fun¸caõ genérica que realmente elimina os elementos duplicados. Exemplo: template void unique2(C& c) { // Ordena o container sort(c.begin(),c.end()); // Move para tr´ as elementos duplicados typename C::iterator p = unique(c.begin(),c.end()); // Deleta elementos duplicados c.erase(p,c.end()); }

35.3.9

Transforma¸c˜ ao

Os algoritmos a seguir s˜ ao utilizados para aplicar transforma¸co˜es aos elementos de um container. Os elementos transformados podem ser enviados para o próprio container destino ou um iterador (como ostream_iterator). generate (v.begin(), v.end(), fun¸ c˜ ao); generate() é usada para gerar novos valores para o container. De v.begin() a v.end() executa a fun¸caõ que n˜ ao recebe nenhum parˆ ametro mas retorna um novo elemento para o container. Veja listagem 36.4. c˜ ao); generate n (v.begin(), n, fun¸ De begin() a n executa a fun¸caõ que n˜ ao recebe nada mas retorna um novo elemento para o container. Ou seja, preenche o container de v.begin() até v.begin()+n. Note que v.begin() é um iterador, logo, a fun¸caõ pode ser usada n vezes e a sa´ıda enviada para o iterador. for each (v.begin(), v.end(), fun¸ c˜ ao); Para cada elemento do container executa a fun¸caõ. De v.begin() a v.end() executa a fun¸caõ, utilizada para aplicar uma dada fun¸caõ a cada um dos elementos do container. Observe que for_each() n˜ ao modifica os elementos do container. transform (orig.begin(), orig.end(), dest.begin(), fun¸ c˜ ao); De orig.begin() a orig.end() executa a fun¸caõ e armazena o resultado em dest. Observe que a fun¸caõ deve receber um objeto do container (como const) e deve retornar um objeto Programa¸caõ Orientada a Objeto com C++



605

transformado. Por exemplo, para somar o n´ umero 75 a todos os elementos do container v. Veja outros exemplos nas listagens 36.3, 36.4. No exemplo a seguir o destino é o próprio vetor v. Exemplo: transform(v.begin(), v.end(), d.begin(), rand); transform(v.begin(), v.end(), v.begin(), bin2nd(plus(),75); transform (orig1.begin(), orig1.end(), orig2.begin(), d.begin(), fun¸ c˜ ao); De orig1.begin() a orig1.end() executa a fun¸caõ, usando os dados de orig1 e orig2, e armazena o resultado em d. Observe que a fun¸caõ deve receber um objeto do container orig1 (como const) e um objeto do container orig2 (como const) e deve retornar um objeto transformado. partition (v.begin(), v.end(), Fun¸ c˜ aoPredicado); Uma parti¸caõ ordena o container de acordo com a fun¸caõ predicado. V˜ ao para o in´ıcio do container os objetos que satisfazem ao predicado (retornam true). Veja listagem 36.4. Exemplo: partition(in´ ıcio,fim,predicado); Dica: os algoritmos que mudam o container, como tranform(), retornam um iterador para destino.end().

35.3.10

Matem´ aticos

Os algoritmos a seguir s˜ ao utilizados para realizar opera¸co˜es matemáticas, como exemplo obter o maior valor de um container. Veja o arquivo . max (a, b); Retorna a, se a > b, ou b, se b > a. Retorna o maior valor. min (a, b); Retorna a, se a < b, ou b, se b < a. Retorna o menor valor. max element (v.begin(), v.end()); Retorna o maior elemento. min element (v.begin(), v.end()); Retorna o menor elemento. count (v.begin(), v.end(),valor); Determina o n´ umero de elementos igual a valor. Exemplo: int total = count(v.begin(),v.end(),0); c˜ aoPredicado); count if (v.begin(), v.end(), Fun¸ Determina o n´ umero de elementos que obedecem à fun¸caõ predicado. accumulate (v.begin(), v.end(), valorInicial); Retorna a soma de todos os elementos. Observe que podemos passar o valor inicial do somat´ orio. Veja listagem 36.4. Exemplo: int somat´ orio = accumulate(v.begin(),v.end(),0); Programa¸caõ Orientada a Objeto com C++



606

35.3.11

Opera¸c˜ oes matem´ aticas com conjuntos

set difference (a, a+size, b, b+size, diferen¸ ca); Todos os valores do vetor a que n˜ ao estiverem no vetor b ser˜ ao copiados para o vetor diferen¸ca. Veja listagem 36.4. Exemplo: int diferenca[size]; set_difference ( a, a + size , b , b + size , diferenca ); c˜ ao); set intersection (a, a+size, b, b+size, interse¸ Todos os valores do vetor a que estiverem no vetor b ser˜ ao copiados para o vetor interse¸caõ. Veja listagem 36.4. Exemplo: int intersecao[size]; set_intersection (a,a+size,b,b+size,intersecao); ao); set union (a, a+size, b, b+size, uni˜ Todos os valores do vetor a e b ser˜ ao copiados para o vetor união. Veja listagem 36.4. Exemplo: int uniao[size]; set_union (a,a+size,b,b+size,uniao); set symmetric difference (a, a+size, b, b+size, sym dif ); Determina o conjunto de valores de a que n˜ ao est˜ ao em b e os valores de b que n˜ ao est˜ ao em a, e copia para o vetor sym_dif(). Veja listagem 36.4. Exemplo: int sym_dif[size]; set_symmetric_difference(a, a+size, b,b+size, sym_dif);

35.3.12

Ordena¸c˜ ao de pilhas - heapsort

Um heap armazena os elementos de uma maneira semi-ordenada, de forma que a procura pelo maior elemento tenha um custo constante. A remo¸caõ do maior elemento e adi¸caõ de novos elementos tem tempo de processamento logar´ıtmico. make heap (v.begin(), v.end()); Marca a pilha. O primeiro elemento de v é o maior. sort heap (v.begin(), v.end()); Ordena toda a pilha. push heap (v.begin(), v.end()); Adiciona elemento no container. pop heap (v.begin(), v.end()); Retira elemento do topo da pilha (maior elemento). Programa¸caõ Orientada a Objeto com C++


˜ ´ 35.4. EXEMPLOS DE USO DAS FUNC ¸ OES GENERICAS

35.4

607

Exemplos de uso das fun¸c˜ oes gen´ ericas

Veremos a seguir exemplos de uso das fun¸co˜es genéricas. Na listagem 35.1 apresentamos o uso de fun¸co˜es genéricas como sort(); Listing 35.1: Usando sort(), find(), find_if(), fill(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

# include < iostream > # include < fstream > # include < iomanip > # include < string > # include < vector > # include < algorithm > using namespace std ;

// Classe de vetores // Algoritmos gen´ e ricos // Define o uso do espa¸ c o de nomes std

// Declara¸ ca ~ o de sobrecarg a de << para ostream e vector ostream & operator << ( ostream & os , const vector < int >& v ) { for ( int i = 0; i < v . size () ; i ++) os << " v [" << setw (3) <& v ) { for ( int i = 0; i < v . size () ; i ++) os << setw (10) << v [ i ] << endl ; return os ; } // Declara¸ ca ~ o e defini¸ ca ~ o de fun¸ ca ~ o predicado // Recebe um objeto do tipo armazenado no container // retorna verdadeiro ou falso . bool maiorQue5 ( int valor ) { return valor > 5; } int main () { string linha =" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n "; vector < int > v ; int data ; do { cout << "\ nEntre com o dado (" << setw (3) << v . size () << ") :"; cin >> data ; cin . get () ; if ( cin . good () ) v . push_back ( data ) ; } while ( cin . good () ) ; cin . get () ; cin . clear () ; // Reseta objeto cin para estado ok { ofstream fout (" vector . dat ") ; if (! fout ) return 0; fout << v << endl ; fout . close () ; } cout << "\ n " << linha << v << endl ;



608 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95


int numero ; cout << "\ nEntre com o n´ u mero a ser localizado :"; cin >> numero ; cin . get () ; // Ponteiro para a posi¸ ca ~ o localizada vector < int >:: iterator it = find ( v . begin () , v . end () , numero ) ; cout << "\ nN´ u mero localizad o na posi¸ ca ~ o :" << ( it - v . begin () ) << endl ; // Localiza primeiro elemento que satisfaz a condi¸ ca ~o // dada pela fun¸ ca ~ o maiorQue5 it = find_if ( v . begin () , v . end () , maiorQue5 ) ; cout << "\ nN´ u mero maior que 5 localizado na posi¸ ca ~ o :" << ( it - v . begin () ) << endl ;; // Ordena o container sort ( v . begin () , v . end () ) ; cout << "\ nVetor ap´ o s ordena¸ ca ~ o com sort ( v . begin () ,v . end () ) \ n " << linha << v << endl ; // Preenche com o valor 45 fill ( v . begin () , v . end () , 45) ; cout << "\ nVetor ap´ o s fill ( v . begin () , v . end () , 45) ;\ n " << linha << v << endl ; // Retorna dimens~ a o e capacidade cout << " v . size () =" << v . size () << "\ nv . capacity () =" << v . capacity () << endl ; // R e d i m e n s i o n a o container v . resize (10) ; cout << "\ nVetor ap´ o s resize (10) :\ n " << linha << v << "\ nv . size () =" << v . size () << "\ nv . capacity () =" << v . capacity () << "\ n " << linha << endl ; cin . get () ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ a . out Entre com o dado ( 0) :45 Entre com o dado ( 1) :15 Entre com o dado ( 2) :91 Entre com o dado ( 3) :13 Entre com o dado ( 4) :26 Entre com o dado ( 5) : --------------------------------------------------------------v [ 0]= 45 v [ 1]= 15 v [ 2]= 91 v [ 3]= 13 v [ 4]= 26 Entre com o n´ u mero a ser localizado :91 N´ u mero localizado na posi¸ ca ~ o :2 N´ u mero maior que 5 localizado na posi¸ ca ~ o :0 Vetor ap´ o s ordena¸ ca ~ o com sort ( v . begin () , v . end () ) --------------------------------------------------------------v [ 0]= 13 v [ 1]= 15 v [ 2]= 26 v [ 3]= 45 v [ 4]= 91 Vetor ap´ o s fill ( v . begin () , v . end () , 45) ; --------------------------------------------------------------v [ 0]= 45 v [ 1]= 45 v [ 2]= 45 v [ 3]= 45 v [ 4]= 45 v . size () =5 v . capacity () =8




609

Vetor ap´ o s resize (10) : --------------------------------------------------------------v[ 0]= 45 v [ 1]= 45 v [ 2]= 45 v [ 3]= 45 v [ 4]= 45 v[ 5]= 0 v [ 6]= 0 v [ 7]= 0 v [ 8]= 0 v [ 9]= 0 v. size () =10 v. capacity () =10 ---------------------------------------------------------------

No exemplo da listagem 35.2 mostramos o uso de sort() e copy(). O programa ordena as linhas de texto digitadas pelo usu´ ario ou as linhas de um arquivo de disco usando a fun¸caõ global OrdenaLinhasArquivo(). Listing 35.2: Usando sort() e copy() para ordenar linhas de texto. # include # include # include # include # include # include

< fstream > < iostream > < string > < vector > < iterator > < algorithm >

void O r d e n a L i n h a s A r q u i v o ( std :: istream & in , std :: ostream & out ) { std :: string linha ; std :: vector < std :: string > v ; while ( std :: getline ( in , linha ) ) v . push_back ( linha ) ; std :: sort ( v . begin () ,v . end () ) ; std :: cout << std :: endl ; std :: copy ( v . begin () ,v . end () , std :: ostream_iter at or < std :: string >( out ,"\ n " ) ) ; in . clear () ; return ; } int main () { using namespace std ; // Ordena linhas digitadas cout << " Digite diversas linhas de texto , e depois pressione ctrl + d :\ n "; O r d e n a L i n h a s A r q u i v o ( cin , cout ) ; cout << "\ nEntre com o nome do arquivo a ser ordenado :" < < endl ; string nomeArqui vo ; getline ( cin , nomeArquiv o ) ; ifstream fin ( nomeArquiv o . c_str () ) ; ofstream fout ((" Ordenado " + nomeArqui vo ) . c_str () ) ; O r d e n a L i n h a s A r q u i v o ( fin , fout ) ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ a . out Digite diversas linhas de texto , e depois pressione ctrl + d : Testando a ordem em que o texto vai sair ser´ a que vai dar certo ? Testando a ordem certo ? em que o texto vai sair ser´ a que vai dar Entre com o nome do arquivo a ser ordenado :




610 Entrada . dat

No exemplo da listagem 35.3 usamos copy(), para copiar dados de um arquivo de disco para um vetor. A seguir ordenamos o vetor e o enviamos para tela. Listing 35.3: Usando copy() para copiar dados de um arquivo de disco para um . 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include # include # include # include # include

< algorithm > < fstream > < iostream > < iterator > < vector >

int main () { using namespace std ; ifstream in (" dados . dat ") ; vector < int > v ; copy ( istream_itera to r < int >( in ) , istream_iter at or < int >() , b a c k _ i n s e r t e r ( v ) ) ; sort ( v . begin () ,v . end () ) ; copy ( v . begin () , v . end () , ostream_iter at or < int >( cout , "\ n ") ) ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ a . out 15 25 35 48 65 75 98

Na listagem 35.4 apresentamos o uso de fun¸co˜es genéricas como nth_element() e find() para obter a mediana de um grupo de dados. A listagem é documentada. Note que estamos acostumados a usar container::value_type para obter a informaçaõ do tipo de valor armazenado no container. Mas na fun¸caõ Mediana() n˜ ao temos o container. Temos apenas os iteradores. Ou seja, precisamos obter o container a partir dos iteradores. Este é o motivo para criarmos o apelido typedef typename std::iterator_traits::value_type value_type; Listing 35.4: Usando com algoritmos genéricos: Cálculo da mediana. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# include # include # include # include # include

< iostream > < algorithm > < functional > < iterator > < vector >

template < typename iterador , typename operadorCo mp ar a ca o > iterador Mediana ( iterador first , iterador last , o p e r a d o r C o m p a r a c a o opComp ) { // Cria apelido typedef typename std :: iterator_trai ts < iterador >:: value_type value_type ; std :: vector < value_type > tmp ( first , last ) ; // Determina posi¸ ca ~ o m´ e dia typename std :: vector < value_type >:: size_type posicao = tmp . size () / 2; // Localiza no container recebido o valor da mediana std :: nth_eleme nt ( tmp . begin () , tmp . begin () + posicao , tmp . end () , opComp ) ; return std :: find ( first , last , tmp [ posicao ]) ;



˜ ´ 35.4. EXEMPLOS DE USO DAS FUNC ¸ OES GENERICAS 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

611

} int main () { // Cria vetor e armazena dados std :: vector < int > v ; v . push_back (1243) ; v . push_back (2367) ; v . push_back (7383) ; v . push_back (3928) ; v . push_back (8734) ; v . push_back (7382) ;

v . push_back (7284) ; v . push_back (6032) ; v . push_back (9284) ;

// Determina a mediana e mostra na tela int mediana = * Mediana ( v . begin () , v . end () , std :: less < int >() ) ; std :: cout << mediana << std :: endl ; return 0; } [ b u e n o @ l d s c 0 5 Parte - III ] $ ./ a . out 7284

No exemplo da listagem 35.5 criamos uma classe TCSeries que recebe dois parˆ ametros, o n´ umero de elementos a serem criados e o incremento. Note que o operador() é sobrecarregado, e retorna o próximo valor da série. Ou seja, o objeto TCSeries se comporta como uma fun¸caõ que é chamada n vezes. Um objeto do tipo TCSeries é criado na chamada ao método generat_n(), passamos para o construtor o valorInicial e o incremento. O método generat_n(), executa nRepeti¸co˜es (chamadas) ao operator() do objeto criado, e envia para tela os valores retornados. Listing 35.5: Usando generator_n() para gerar uma série de dados. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

# include < algorithm > # include < iostream > # include < iterator > template < typename T > class TCSeries { public : // Construtor TCSeries ( const T & n =0 , const T & i =1) : proximo (n - i ) , incremento ( i ) {} // Operador s o b r e c a r r e g a d o T operator () () { return proximo += incremento ; } private : T proximo ; T incremento ; }; int main () { int valorInicial , incremento , nRepeticoe s ; std :: cout << " Entre com o valor inicial :"; std :: cin >> v a l o r I n i c i a l ; std :: cin . get () ; std :: cout << " Entre com o valor do incremento :"; std :: cin >> increment o ; std :: cin . get () ; std :: cout << " Entre com o n´ u mero de elementos :"; std :: cin >> nRepeticoe s ; std :: cin . get () ; std :: generate_n ( std :: ostream_itera t or < int >( std :: cout ,"\ n ") , // Destino nRepeticoes , // N´ u mero repeti¸ co ~ es TCSeries < int >( valorInicial , incremento ) // Objeto fun¸ ca ~o ); }



´ ´ 35.5. SENTENCAS ¸ PARA CODIGO GENERICO

612 Entre com o valor inicial :123 Entre com o valor do increment o :3 Entre com o n´ u mero de elementos :6 123 126 129 132 135 138

35.5

Senten¸cas para c´ odigo gen´ erico

• Dê uma olhada na Internet e procure por STL. Você encontrará muitos sites com exemplos interessantes. • next_permutation() e prev_permutation() permutam os elementos do container. Veja listagem 36.4. • No exemplo abaixo, o vetor v1 é adicionado ao fim de v2. A fun¸caõ back_inserter() chama v2.push_back() para cada elemento de v1. copy ( v1.begin(), v1.end(), back_inserter(v2) ); • No exemplo abaixo, o deque d1 é adicionado no fim de d2, front_insert() chama a fun¸caõ push_front() para cada elemento de d2. copy ( d1.begin(), d1.end(), front_inserter(d2) ); • Se um algoritmo qualquer tem uma vers˜ ao genérica e uma c´ opia espec´ıfica para um determinado container (é um método do container), ent˜ ao a vers˜ ao do container é mais r´ apida. • A classe pode ser usada como um vetor. Veja os exemplos. Exemplo: for(int i = 0; i < s.size(); i++) cout < < s[i] < < endl; for(string::const_iterator it = s.begin(); it != s.end(); it++) cout < < *it < < endl; • Você encontra informa¸co˜es e outros exemplos de uso das fun¸co˜es da STL nas referências [Deitel and Deitel, 2002], e sobre programa¸caõ genérica, em [Austern, 1998].

35.6


Neste cap´ıtulo aprendemos a utilizar um conjunto de fun¸co˜es que s˜ ao utilizadas na programa¸caõ genérica e que s˜ ao fornecidas com a STL. Vimos uma introdu¸caõ à programa¸caõ genérica, e a seguir apresentamos a classifica¸caõ das fun¸co˜es genéricas (se modifica ou n˜ ao o container, tipo de iterador utilizado, e tipos de opera¸co˜es suportadas). Vimos que as fun¸co˜es genéricas s˜ ao classificadas da seguinte forma: preenchimento, compara¸caõ, remo¸caõ, trocas, misturar/mesclar/inverter, pesquisa, ordena¸caõ, classifica¸caõ, transforma¸caõ, matemáticos, opera¸co˜es com conjuntos, ordena¸cao de pilhas. No final do cap´ıtulo vimos diversos exemplos. Programa¸caõ Orientada a Objeto com C++


35.7. EXERCÍCIOS

613

Nota: no cap´ıtulo Cap´ıtulo 36 - Objetos Fun¸co˜es da STL, veremos outros exemplos.

35.7

Exerc´ıcios

1. Quais as fun¸co˜es genéricas que n˜ ao mudam o container? 2. Modifique a listagem 35.1. Acrescente o uso de: find first of(); adjacent find(); binary search(); lower bound(); upper bound(); equal range(); search(); search n();. 3. Modifique a listagem 35.2, de tal forma que o usuário possa definir o nome do arquivo de disco e a ordem de ordena¸caõ (ascendente/descendente). 4. S´ o para sentir a diferen¸ca, implemente a listagem 35.3 sem usar a STL. 5. Modifique a listagem 35.4. Adicione o c´ alculo da médio e desvio padr˜ ao. 6. Modifique a listagem 35.5. Crie a possibilidade de se criar séries logar´ıtmicas. 7. Monte um exemplo que leia de um InputIterator e escreva para um OutputIterator. 8. Quais os algoritmos genéricos utilizados para opera¸co˜es de transforma¸caõ? 9. Monte um exemplo que utilize as fun¸co˜es de preenchimento (se¸caõ 35.3.1) e de remo¸caõ (se¸caõ 35.3.3). 10. Monte um exemplo que utilize as fun¸co˜es de compara¸caõ (se¸caõ 35.3.2) e de trocas (se¸caõ 35.3.4). 11. Monte um exemplo que fa¸ca pesquisas em um vetor (se¸caõ 35.3.6) e localize n´ umeros primos. 12. Monte um exemplo que aplique algoritmos de transforma¸caõ em polinômios (se¸caõ 35.3.9). 13. Implemente e teste a fun¸caõ unique2() (veja se¸caõ 35.3.8). 14. Você deve comentar o c´ odigo abaixo, e a seguir dizer o que faz o método M? Exemplo: #include #include void CNome::M(string arqA, string arqB) { std::ifstream fin ( arqA.c_str() ); std::ofstream fout( arqB.c_str() ); std::copy(std::istreambuf_iterator(fin), std::istreambuf_iterator(), std::ostreambuf_iterator(fout)); } 15. Procure na Internet informa¸co˜es sobre os algoritmos stable_partition e stable_sort. 16. Procure na Internet informa¸co˜es sobre os algoritmos next_permutation e prev_permutation.



614

35.7. EXERCÍCIOS



Cap´ıtulo 36

Objetos Fun¸c˜ oes da STL Veremos neste cap´ıtulo os objetos fun¸co˜es da STL, objetos que se comportam como fun¸co˜es. Iniciamos com uma introdu¸caõ aos objetos fun¸co˜es da STL (se¸caõ 36.1). As fun¸co˜es un´ arias (se¸caõ 36.1.1) e bin´ arias (se¸caõ 36.1.2). Os objetos fun¸co˜es fornecidos pela STL (se¸caõ 36.2). As fun¸co˜es aritméticas (se¸caõ 36.2.1), de compara¸cão (se¸caõ 36.2.2), e l´ ogicas (se¸caõ 36.2.3). A se¸caõ dicas avan¸cadas de STL (se¸caõ 36.3), apresenta alguns adaptadores fornecidos pela STL como o adaptador para fun¸caõ objeto bin2nd() (se¸caõ 36.3.1), para fun¸caõ objeto negators() (se¸caõ 36.3.2) e para fun¸caõ membro (se¸caõ 36.3.3). Finalmente descreve-se como extender a STL apresentando um exemplo de especializa¸caõ para std::swap() (se¸caõ 36.3.4).

36.1

Introdu¸ c˜ ao aos objetos fun¸c˜ oes da STL

Algumas classes podem ter o operator() sobrecarregado. Desta forma, pode-se fazer: Tipo NomeObjeto; TipoParametro parametro; int resultado = NomeObjeto(parametro); ou seja, o objeto se comporta como sendo uma fun¸caõ. Como esse procedimento é muito usado, a STL inclui classes para objetos fun¸co˜es. Uma classe para fun¸co˜es que recebem um parˆ ametro (fun¸co˜es un´ arias, se¸caõ 36.1.1) e outra classe para fun¸co˜es que recebem dois parˆ ametros (fun¸co˜es binárias, se¸caõ 36.1.2). Essas fun¸co˜es s˜ ao inclu´ıdas no arquivo de cabe¸calho .

36.1.1

Fun¸ c˜ oes un´ arias

Fun¸co˜es un´ arias recebem apenas um parˆ ametro. Como seu uso é muito comum, a STL inclui a classe template unary_function. Assim, você pode criar suas próprias fun¸co˜es un´ arias fazendo uma heran¸ca de unary_function. Veja o exemplo: Exemplo: #include class seno: public unary_function< double, double > { public: double y; 615

˜ 36.2. OBJETOS FUNC ¸ OES FORNECIDOS PELA STL

616

double operator() (double x) // Operador sobrecarregado { return y = std::sin(x); } };

36.1.2

Fun¸c˜ oes bin´ arias

Fun¸co˜es binárias recebem dois parˆ ametros. Como seu uso também é muito comum, a STL inclui a classe template binary_function. Assim, você pode criar suas próprias fun¸co˜es bin´ arias fazendo uma heran¸ca de binary_function. Veja o exemplo: Exemplo: #include class potencia : public binary_function< double, double, double > { public: double z; double operator() (double x,double y) { return z = std::pow(x,y); } };

36.2

Objetos fun¸c˜ oes fornecidos pela STL

Além das classes unary_function e binary_function, a STL fornece um conjunto de funço˜es objetos de uso comum. Essas fun¸co˜es s˜ ao listadas a seguir.

36.2.1

Fun¸c˜ oes aritm´ eticas

As fun¸co˜es atitméticas podem ser utilizadas em algoritmos genéricos. Por exemplo, a fun¸caõ bin´ aria plus<> realiza a soma de dois elementos do mesmo tipo. Observe que o operador+ precisa ter sido sobrecarregado para o tipo. plus<> Soma (x + y). minus<> Subtra¸caõ (x - y). times<> Multiplica¸caõ (x * y). multiplies<> Multiplica¸caõ (x * y). divides<> Divis˜ ao (x / y). modulus<> M´ odulo (x % y). negate<> Nega¸caõ (- x). Programa¸caõ Orientada a Objeto com C++



617

No exemplo a seguir cria-se um objeto fun¸caõ div, que é usado para realizar a divisão de 20.5 por 3. Listing 36.1: Usando divides<>. 1 2 3 4 5 6 7 8 9 10 11

# include < functional > # include < iostream > int main () { // Cria objeto fun¸ c~ a o para r e a l i z a ¸ c~ a o de d i v i s ~ a o de n ´ u m e r o s float std :: divides < float > div ; std :: cout << div ( 20.5 , 3 ) << std :: endl ; return 0; } 6.83333

No exemplo a seguir usamos a fun¸caõ genérica accumulate() e o objeto fun¸caõ multiplies<>, para calcular a média geométrica de um vetor. . Listing 36.2: Usando multiplies<>. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# include < cmath > # include < vector > # include < numeric > # include < functional > # include < iostream > using namespace std ; double M e d i a G e o m e t r i c a ( const vector < int >& v ) { double temp = accumulate ( v . begin () , v . end () , 1 , multiplies < int >() ) ; return ( pow ( temp ,1.0/ v . size () ) ) ; } int main () { vector < int > v ; int valor ; cout << " Entre com valores inteiros : " << endl ; while ( cin >> valor ) { v . push_back ( valor ) ; } cout << " M´ e dia Geom´ e tric a = " << M e d i a G e o m e t r i c a ( v ) << endl ; return 0; } Entre com valores inteiros : 5 6 7 8 9 4 3 2 1 M´ e dia Geom´ e trica = 4.14717

36.2.2

Fun¸ c˜ oes de compara¸c˜ ao

equal to<> Testa igualdade (x == y). Programa¸caõ Orientada a Objeto com C++



618 not equal to<> Testa diferen¸ca (x != y). greater<> Maior que (x > y). less<> Menor que (x < y).

greater equal<> Maior que ou igual a (x >= y). less equal<> Menor que ou igual a (x <= y). No exemplo a seguir criamos um objeto do tipo priority_queue que ir´ a armazenar n´ umeros do tipo float. O container a ser utilizado é um , e utilizamos greater (maior que) para definir o operador de compara¸caõ a ser utilizado na ordena¸caõ. Exemplo: priority_queue< float, vector, greater > objQueue;

36.2.3

Fun¸c˜ oes l´ ogicas

logical and<> E logico (x & & y). logical or<> Ou l´ ogico (x || y). logical not<> Negacão l´ ogica (!

x)

Veja na listagem 36.3 um exemplo de classe fun¸caõ. O exemplo inicia-se definindo uma classe fun¸caõ objeto CFatorial, herdeira de unary_function. Dentro de main(), cria um com 10 elementos e preenche-os com valores seq¨ uenciais. A seguir, usa a fun¸caõ genérica transform() para executar o objeto fun¸caõ CFatorial para cada elemento do deque d e armazenar o resultado no vetor v. Observe que a fun¸caõ genérica transform() aplica uma transforma¸caõ a cada elemento do d. A seguir, armazena o resultado dessa transforma¸caõ em v. Listing 36.3: Criando e usando uma classe fun¸caõ. 1 2 3 4 5 6 7 8 9 10 11 12 13

# include < iostream > # include < functional > # include < deque > # include < vector > # include < algorithm > # include < iterator > # include < iomanip > using namespace std ; // Classe fun¸ c~ a o , cria uma fun¸ c~ a o objeto a partir de uma fun¸ c~ a o un´ a ria template < typename Parametro , typename Retorno > class TCFatorial : public unary_function < Parametro , Retorno > {



˜ 36.2. OBJETOS FUNC ¸ OES FORNECIDOS PELA STL 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

619

public : Retorno operator () ( const Parametro & arg ) { Retorno r = 1; for ( Parametro i = 2; i <= arg ; i ++ ) r *= i ; return r ; } }; int main () { // Cria um deque deque < int > origem (10) ; // P r e e n c h e o deque for ( int i = 0; i < origem . size () ; i ++) origem [ i ] = i ; // Cria um vetor d e s t i n o para a r m a z e n a r os f a t o r i a i s vector < int > destino (10) ; // D e t e r m i n a o f a t o r i a l dos n ´ u m e r o s a r m a z e n a d o s em origem // e a r m a z e n a no vetor d e s t i n o transform ( origem . begin () , origem . end () , destino . begin () , TCFatorial < int , int >() ) ; cout << " N´ u meros : " ; copy ( origem . begin () , origem . end () , ostream_iter at or < int >( cout , " \ t " ) ) ; cout << " \ ne fatoriais : " ; copy ( destino . begin () , destino . end () , ostream_itera to r < int >( cout , " \ t " ) ) ; cout << endl << endl ; char resp ; TCFatorial < int , int > o b j e t o _ f u n c a o ; do { cout << " Entre com um n´ u mero ( int ) : " ; int numero ; cin >> numero ; cin . get () ; cout << " N´ u mero = " << setw (7) << numero << " fatorial = " << setw (7) << o b j e t o _ f u n c a o ( numero ) << " \ nContinua r ( s / n ) ? " ; cin . get ( resp ) ; cin . get () ; } while ( resp == ’s ’ || resp == ’S ’) ; return 0; }

N´ u meros

: 0

1

2

3

4

5

6

120

720

7

8

9 e fatoriais : 1 362880

1

2

Entre com um n´ u mero ( int ) :5 N´ u mero = 5 fatorial = Continuar ( s / n ) ? n

6

24

5040

40320

120

Veja na listagem 36.4 outro exemplo de uso de fun¸co˜es genéricas. Neste exemplo criamos a classe CTesteFuncoesGenericas, com os métodos EntradaUsuario(), InicializaVetor() e Run(). Os métodos EntradaUsuario() e InicializaVetor(), s˜ ao utilizados para defini¸caõ dos valores do vetor a ser usado nos algoritmos. Programa¸caõ Orientada a Objeto com C++



620

Na primeira parte da fun¸caõ Run(), estamos enviando para tela a lista de fun¸co˜es dispon´ıveis para teste. Observe que o nome das fun¸co˜es s˜ ao armazenadas no vetor fun¸co˜es e que usamos setw() para mostrar de forma organizada a lista de fun¸co˜es. Na segunda parte de Run() diversas fun¸co˜es genéricas s˜ ao testadas. Note que o usuário entra com o n´ umero da fun¸caõ a ser testada e a seguir a fun¸caõ é testada. O exemplo é extenso e mostra o uso de diversas fun¸co˜es genéricas. Listing 36.4: Usando fun¸co˜es genéricas e objetos da STL. # include # include # include # include # include # include # include # include # include

< iostream > < iomanip > < string > < vector > < algorithm > < memory > < cstdlib > < numeric > < functional >

using namespace std ;

// // // // // // // // //

E n t r a d a e sa´ ı da de dados Manipuladores S t r i n g s de C ++ Classe de v e t o r e s Classe para a l g o r i t m o s g e n ´ ericos destroe e construct Fun¸ c~ a o rand Fun¸ c~ ao inner_product Fun¸ c~ oes diversas

// Define o uso do espa¸ c o de nomes std

/* * Classe para teste dos a l g o r i t m o s g e n ´ e r i c o s */ class C T e s t e F u n c o e s G e n e r i c a s { public : vector < int > v , v2 , v3 ; // A t r i b u t o s string msg ; C T e s t e F u n c o e s G e n e r i c a s () // C o n s t r u t o r { InicializaVetor(v); // P r e e n c h e o vetor v com v a l o r e s v3 = v2 = v ; msg = " \n - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ; } // M ´ etodos p´ ublicos void E n t r a d a U s u a r i o ( vector < int >& vetor ) ; void I n i c i a l i z a V e t o r ( vector < int >& vetor , int n = 5 ) ; bool Run () ; private : // M ´ etodos privados void U s o _ d e _ f i l l _ n () ; // P r e e n c h i m e n t o void U s o _ d e _ e q u a l () ; // C o m p a r a ¸ c~ ao void U s o _ d e _ m i s m a t c h () ; void U s o _ d e _ i n c l u d e s () ; void U s o _ d e _ r e m o v e _ c o p y _ i f () ; // R e m o ¸ c~ ao void U s o _ d e _ r e p l a c e _ c o p y _ i f () ; // Trocas void U s o _ d e _ i n p l a c e _ m e r g e () ; // M i s t u r a r / m e s c l a r / i n v e r t e r void U s o _ d e _ r e v e r s e _ c o p y () ; void U s o _ d e _ r a n d o m _ s h u f f l e () ; void U s o _ d e _ f i n d _ i f _ o f f () ; // P e s q u i s a void U s o _ d e _ a d j a c e n t _ d i f f e r e n c e () ; void U s o _ d e _ s e a r c h _ n () ; void U s o _ d e _ b i n a r y _ s e a r c h () ; void U s o _ d e _ a d v a n c e () ; void U s o _ d e _ n e x t _ p e r m u t a t i o n () ; // O r d e n a ¸ c~ ao void U s o _ d e _ r e v e r s e () ; void U s o _ d e _ r o t a t e () ; void U s o _ d e _ g e n e r a t e () ; // T r a n s f o r m a ¸ c~ ao void U s o _ d e _ f o r _ e a c h () ; void U s o _ d e _ t r a n s f o r m () ; void U s o _ d e _ n t h _ e l e m e n t () ; // M a t e m ´ aticos void U s o _ d e _ c o u n f _ i f () ; void U s o _ d e _ a c c u m u l a t e () ; void U s o _ d e _ i n n e r _ p r o d u c t () ;




621

void U s o _ d e _ s e t _ u n i o n () ; void U s o _ d e _ s e t _ i n t e r s e c t i o n () ; void U s o _ d e _ s e t _ d i f f e r e n c e () ; void U s o _ d e _ s e t _ s y m m e t r i c _ d i f f e r e n c e () ; void U s o _ d e _ m a k e _ h e a p () ; // O r d e n a ¸ c~ a o por pilha void Uso_de_pl u s () ; // F u n ¸ c~ o e s objeto void U s o _ d e _ m i n u s () ; void U s o _ d e _ t i m e s () ; void U s o _ d e _ m u l t i p l i e s () ; void U s o _ d e _ d i v i d e s () ; void U s o _ d e _ m o d u l u s () ; void U s o _ d e _ n e g a t e () ; void U s o _ d e _ e q u a l _ t o () ; void U s o _ d e _ n o t _ e q u a l _ t o () ; void U s o _ d e _ g r e a t e r () ; void Uso_de_le s s () ; void U s o _ d e _ g r e a t e r _ e q u a l () ; void U s o _ d e _ l e s s _ e q u a l () ; void U s o _ d e _ l o g i c a l _ a n d () ; // F u n ¸ c~ oes l´ ogicas void U s o _ d e _ l o g i c a l _ o r () ; void U s o _ d e _ l o g i c a l _ n o t () ; void U s o _ d e _ b i n d 2 n d () ; // A d a p t a d o r e s ( not1 f i n d _ i f ) void U s o _ d e _ m e n _ f u n _ r e f ( const vector < string >& s ) ; }; // fim da classe // S o l i c i t a v a l o r e s do vetor void C T e s t e F u n c o e s G e n e r i c a s :: E n t r a d a U s u a r i o ( vector < int >& vetor ) { vetor . clear () ; // Zera o vetor int data ; do { cout << " Entre com o dado ( " << setw (3) << vetor . size () << " ) ( ctrl + d encerra entrada ) : " ; cin >> data ; cin . get () ; if ( cin . good () ) vetor . push_back ( data ) ; } while ( cin . good () ) ; cin . clear () ; // Reseta objeto cin para estado ok } // P r e e n c h e n d o o vetor com uma s e q u ^ e n c i a de v a l o r e s p a d r ~ oes void C T e s t e F u n c o e s G e n e r i c a s :: I n i c i a l i z a V e t o r ( vector & vetor , int n ) { vetor . clear () ; for ( int i = 0; i < n ; i ++) vetor . push_back ( i ) ; } // D e c l a r a ¸ c~ ao e defini¸ c~ a o da s o b r e c a r g a de << template < typename Tipo > ostream & operator < < ( ostream & os , const vector < Tipo >& v ) { for ( int i = 0; i < v . size () ; i ++) os << setw (5) << setfill ( ’ ’) << v [ i ] << ’\ t ’; return os ; } // Fun¸ c~ a o de s e l e ¸ c~ a o da fun¸ c~ a o a ser t e s t a d a bool C T e s t e F u n c o e s G e n e r i c a s :: Run () {



622


char * vs [] = { " fill_n " , " equal " , " mismatch " , " includes " , " r e m o v e _ c o p y _ i f " , " replace_copy_if", " inplace_merge", " reverse_copy", " random_shuffle", " find_if " , " find_if_of f " , " a d j a c e n t _ d i f f e r e n c e " , " search_n " , " b i n a r y _ s e a r c h " , " advance " , " n e x t _ p e r m u t a t i o n " , " reverse " , " rotate " , " generate " , " for_each " , " transform " , " nth_eleme n t " , " counf_if " , " accumulate " , " i n n e r _ p r o d u c t " , " set_union " , " s e t _ i n t e r s e c t i o n " , " s e t _ d i f f e r e n c e " , " s e t _ s y m m e t r i c _ d i f f e r e n c e " , " make_heap " , " plus " , " minus " , " times " , " multiplies " , " divides " , " modulus " , " negate " , " equal_to " , " n o t _ e q u a l _ t o " , " greater " , " less " , " g r e a t e r _ e q u a l " , " less_equal " , " logical_a nd " , " logical_or " , " logical_n o t " , " bind2nd " , " not1 " , " men_fun_r ef " , " Mostra vetor " , " Sair do Programa " }; vector < string > funcoes ; cout << " = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n " << " = = = = = = = = = = = = = Qual fun¸ ca ~ o deseja testar ??? = = = = = = = = = = = = = = = = \ n " << " = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n " ; for ( int i = 0; i < 30 ; i ++ ) { funcoes . push_back ( vs [ i ]) ; if ( funcoes [ i ] != " " ) cout << " Uso de " << funcoes [ i ] << setw (50 - funcoes [ i ]. size () ) << setfill ( ’. ’) <> selecao ; cin . get () ; if ( selecao >= funcoes . size () ) return 0; InicializaVetor(v); cout << setfill ( ’ ’) << " Vetor v = " << v << endl ; if ( funcoes [ selecao ]== " fill_n " ) U s o _ d e _ f i l l _ n () ; else if ( funcoes [ selecao ]== " equal " ) U s o _ d e _ e q u a l () ; else if ( funcoes [ selecao ]== " mismatch " ) U s o _ d e _ m i s m a t c h () ; else if ( funcoes [ selecao ]== " includes " ) U s o _ d e _ i n c l u d e s () ; else if ( funcoes [ selecao ]== " r e m o v e _ c o p y _ i f " ) U s o _ d e _ r e m o v e _ c o p y _ i f () ; else if ( funcoes [ selecao ]== " r e p l a c e _ c o p y _ i f " ) U s o _ d e _ r e p l a c e _ c o p y _ i f () ; else if ( funcoes [ selecao ]== " i n p l a c e _ m e r g e " ) U s o _ d e _ i n p l a c e _ m e r g e () ; else if ( funcoes [ selecao ]== " r e v e r s e _ c o p y " ) U s o _ d e _ r e v e r s e _ c o p y () ; else if ( funcoes [ selecao ]== " r a n d o m _ s h u f f l e " ) U s o _ d e _ r a n d o m _ s h u f f l e () ; else if ( funcoes [ selecao ]== " find_if " ) U s o _ d e _ b i n d 2 n d () ; // Uso de find_if else if ( funcoes [ selecao ]== " find_if_o ff " ) U s o _ d e _ f i n d _ i f _ o f f () ; else if ( funcoes [ selecao ]== " a d j a c e n t _ d i f f e r e n c e " ) U s o _ d e _ a d j a c e n t _ d i f f e r e n c e () ; else if ( funcoes [ selecao ]== " search_n " ) U s o _ d e _ s e a r c h _ n () ; else if ( funcoes [ selecao ]== " b i n a r y _ s e a r c h " ) U s o _ d e _ b i n a r y _ s e a r c h () ; else if ( funcoes [ selecao ]== " advance " ) U s o _ d e _ a d v a n c e () ; else if ( funcoes [ selecao ]== " n e x t _ p e r m u t a t i o n " ) U s o _ d e _ n e x t _ p e r m u t a t i o n () ; else if ( funcoes [ selecao ]== " reverse " ) U s o _ d e _ r e v e r s e () ; else if ( funcoes [ selecao ]== " rotate " ) U s o _ d e _ r o t a t e () ; else if ( funcoes [ selecao ]== " generate " ) U s o _ d e _ g e n e r a t e () ; else if ( funcoes [ selecao ]== " for_each " ) U s o _ d e _ f o r _ e a c h () ; else if ( funcoes [ selecao ]== " transform " ) U s o _ d e _ t r a n s f o r m () ; else if ( funcoes [ selecao ]== " nth_eleme nt " ) U s o _ d e _ n t h _ e l e m e n t () ; else if ( funcoes [ selecao ]== " counf_if " ) U s o _ d e _ c o u n f _ i f () ; else if ( funcoes [ selecao ]== " accumulate " ) U s o _ d e _ a c c u m u l a t e () ; else if ( funcoes [ selecao ]== " i n n e r _ p r o d u c t " ) U s o _ d e _ i n n e r _ p r o d u c t () ; else if ( funcoes [ selecao ]== " set_union " ) U s o _ d e _ s e t _ u n i o n () ; else if ( funcoes [ selecao ]== " s e t _ i n t e r s e c t i o n " ) U s o _ d e _ s e t _ i n t e r s e c t i o n () ; else if ( funcoes [ selecao ]== " s e t _ d i f f e r e n c e " ) U s o _ d e _ s e t _ d i f f e r e n c e () ; else if ( funcoes [ selecao ]== " s e t _ s y m m e t r i c _ d i f f e r e n c e " ) U s o _ d e _ s e t _ s y m m e t r i c _ d i f f e r e n c e () ;



˜ 36.2. OBJETOS FUNC ¸ OES FORNECIDOS PELA STL else else else else else else else else else else else else else else else else else else else

if ( funcoes [ selecao ]== " make_heap " ) if ( funcoes [ selecao ]== " plus " ) if ( funcoes [ selecao ]== " minus " ) if ( funcoes [ selecao ]== " times " ) if ( funcoes [ selecao ]== " multiplies " ) if ( funcoes [ selecao ]== " divides " ) if ( funcoes [ selecao ]== " modulus " ) if ( funcoes [ selecao ]== " negate " ) if ( funcoes [ selecao ]== " equal_to " ) if ( funcoes [ selecao ]== " n o t _ e q u a l _ t o " ) if ( funcoes [ selecao ]== " greater " ) if ( funcoes [ selecao ]== " less " ) if ( funcoes [ selecao ]== " g r e a t e r _ e q u a l " ) if ( funcoes [ selecao ]== " less_equal " ) if ( funcoes [ selecao ]== " logical_a n d " ) if ( funcoes [ selecao ]== " logical_or " ) if ( funcoes [ selecao ]== " logical_n o t " ) if ( funcoes [ selecao ]== " bind2nd " ) if ( funcoes [ selecao ]== " not1 " ) not1 else if ( funcoes [ selecao ]== " men_fun_r e f " )

623

U s o _ d e _ m a k e _ h e a p () ; Uso_de_plu s () ; U s o _ d e _ m i n u s () ; U s o _ d e _ t i m e s () ; U s o _ d e _ m u l t i p l i e s () ; U s o _ d e _ d i v i d e s () ; U s o _ d e _ m o d u l u s () ; U s o _ d e _ n e g a t e () ; U s o _ d e _ e q u a l _ t o () ; U s o _ d e _ n o t _ e q u a l _ t o () ; U s o _ d e _ g r e a t e r () ; Uso_de_les s () ; U s o _ d e _ g r e a t e r _ e q u a l () ; U s o _ d e _ l e s s _ e q u a l () ; U s o _ d e _ l o g i c a l _ a n d () ; U s o _ d e _ l o g i c a l _ o r () ; U s o _ d e _ l o g i c a l _ n o t () ; U s o _ d e _ b i n d 2 n d () ; U s o _ d e _ b i n d 2 n d () ; // Uso de U s o _ d e _ m e n _ f u n _ r e f ( funcoes ) ;

// Mostra o vetor else if ( funcoes [ selecao ]== " Mostra vetor " ) cout << setfill ( ’ ’) << " Vetor v = " << v << endl ; // Sai do p r o g r a m a else if ( funcoes [ selecao ]== " SAIR DO PROGRAMA " ) return 0; cout << " \a - - > Pressione enter para continuar " ; cin . get () ; cin . clear () ; return 1; // Se n~ a o e s c o l h e u sair r e t o r n a v e r d a d e i r o } // P r e e n c h i m e n t o void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ f i l l _ n () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // C o m p a r a ¸ c~ ao void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ e q u a l () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ m i s m a t c h () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ i n c l u d e s void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ i n c l u d e s () { v3 = v2 = v ; v3 . push_back (123) ; v2 . push_back (333) ; cout << setw (30) << " Vetor v2 = " << v2 << endl ; cout << setw (30) << " Vetor v3 = " << v3 << endl ; // cout . imbue ( locale (" pt_BR ") ) ; // o p c i o n a l cout << setw (30) << " v inclui v2 -> " << boolalpha << includes ( v . begin () , v . end () , v2 . begin () , v2 . end () ) << endl ; cout << setw (30) << " v3 inclui v2 -> " << boolalpha << includes ( v3 . begin () , v3 . end () , v2 . begin () , v2 . end () ) << endl ; cout << setw (30) << " v inclui v3 -> " << boolalpha << includes ( v . begin () , v . end () , v3 . begin () , v3 . end () ) << endl ; cout << setw (30) << " v2 inclui v3 -> " << boolalpha << includes ( v2 . begin () , v2 . end () , v3 . begin () , v3 . end () ) << endl ; cout << setw (30) << " v2 inclui v -> " << boolalpha << includes ( v2 . begin () , v2 . end () , v . begin () , v . end () ) << endl ; cout << setw (30) << " v3 inclui v -> " << boolalpha <<



624

˜ 36.2. OBJETOS FUNC ¸ OES FORNECIDOS PELA STL includes ( v3 . begin () , v3 . end () , v . begin () , v . end () )

<< endl ;

} // R e m o ¸ c~ ao void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r e m o v e _ c o p y _ i f () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // Trocas void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r e p l a c e _ c o p y _ i f () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // M i s t u r a r / m e s c l a r/ i n v e r t e r void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ i n p l a c e _ m e r g e () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r e v e r s e _ c o p y () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // E m b a r a l h a os e l e m e n t o s do c o n t a i n e r void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r a n d o m _ s h u f f l e () { r a n d o m _ s h u f f l e ( v . begin () ,v . end () ) ; cout << " Vetor v ap´ o s r a n d o m _ s h u f l e = " << v << endl ; sort ( v . begin () ,v . end () ) ; cout << " Vetor v ap´ o s sort = " << v << endl ; } // P e s q u i s a void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ f i n d _ i f _ o f f () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ a d j a c e n t _ d i f f e r e n c e void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ a d j a c e n t _ d i f f e r e n c e () { cout << " uso de a d j a c e n t _ d i f f e r e n c e : " ; a d j a c e n t _ d i f f e r e n c e ( v . begin () , v . end () , ostream_itera to r < int >( cout , " " ) ) ; cout << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e a r c h _ n () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ b i n a r y _ s e a r c h // R e t o r n a v e r d a d e i r o se o valor for e n c o n t r a d o void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ b i n a r y _ s e a r c h () { cout << " Valor " << 3 << ( b i n a r y _ s e a r c h ( v . begin () ,v . end () ,3) ? " encontrado " : " n~ a o encontrado " ) << endl ; cout << " Valor " << 22 << ( b i n a r y _ s e a r c h ( v . begin () ,v . end () ,22) ? " encontrado " : " n~ a o encontrado " ) << endl ; } // Avan¸ ca o iterador void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ a d v a n c e () { cout << " A partir da posi¸ ca ~ o 0 , devo avan¸ c ar quantas casas ( maximo = " << v . size () << " ) : " ; int n ; cin >> n ; cin . get () ; vector < int >:: iterator it = v . begin () ; advance ( it , n ) ; cout << " O iterador aponta agora para o elemento na posi¸ ca ~o "




625

<< ( it -v . begin () ) << " com o valor " << * it << endl ; } // O r d e n a ¸ c~ ao // R e a l i z a p e r m u t a ¸ c~ a o dos e l e m e n t o s do c o n t a i n e r void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ n e x t _ p e r m u t a t i o n () { for ( int i = 0; i < v . size () * v . size () ; i ++) { n e x t _ p e r m u t a t i o n ( v . begin () ,v . end () ) ; cout << " Vetor v ap´ o s n e x t _ p e r m u t a t i o n = " << v << endl ; } } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r e v e r s e () { reverse ( v . begin () , v . end () ) ; cout << " Vetor v ap´ o s reverse = " << v << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r o t a t e void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ r o t a t e () { rotate ( v . begin () ,v . begin () + v . size () /2 , v . end () ) ; cout << " Vetor v ap´ o s rotate ( v . begin () , v . begin () + v . size () /2 , " << " v . end () ) = " << v << endl ; } // T r a n s f o r m a ¸ c~ ao // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ g e n e r a t e : a fun¸ c~ a o c h a m a d a por g e n e r a t e n~ ao // recebe p a r ^ a m e t r o e r e t o r n a um e l e m e n t o para o c o n t a i n e r no e x e m p l o a // seguir chama a fun¸ c~ a o rand para p r e e n c h e r o c o n t a i n e r com n ´ umeros aleat´ orios void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ g e n e r a t e () { generate ( v . begin () ,v . end () , rand ) ; cout << " Vetor de n´ u meros aleat´ o rios v = " << v << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ f o r _ e a c h () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ t r a n s f o r m () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // M a t e m ´ aticos void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ n t h _ e l e m e n t () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ c o u n f _ i f () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // A c u m u l a v a l o r e s no i n t e r v a l o e s p e c i f i c a d o void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ a c c u m u l a t e () { for ( int i = 0; i < v . size () ; i ++ ) cout << " Valor acumulado at´ e " << i << " = " << accumulate ( v . begin () ,v . begin () ,0 ) << endl ; // + 1 } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ i n n e r _ p r o d u c t () { cout << " ENTRE COM OS DADOS DO VETOR v \ n " ;



626


EntradaUsuario(v); // E n t r a d a dos dados do vetor v cout << " \ nENTRE COM OS DADOS DO VETOR v2 \ n " ; E n t r a d a U s u a r i o ( v2 ) ; // E n t r a d a dos dados do vetor v2 cout << " \ n " << " Vetor v = " << v << " \ nVetor v2 = " << v2 << " \ n P r o d u t o I n t e r n o v . v2 = " << i n n e r _ p r o d u c t ( v . begin () ,v . end () , v2 . begin () ,0) << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ u n i o n () { v3 = v2 = v ; v3 . push_back (123) ; v2 . push_back (333) ; cout << " Vetor v2 = " << v2 << " \ nVetor v3 = " << v3 << " \ nUni~ a o de v2 e v3 = " ; set_union ( v3 . begin () , v3 . end () , v2 . begin () , v2 . end () , ostream_iter at or < int >( cout , " \ t " ) ) ; cout << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ i n t e r s e c t i o n void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ i n t e r s e c t i o n () { cout << " Interse¸ ca ~ o de v e v2 = " ; s e t _ i n t e r s e c t i o n ( v . begin () ,v . end () , v2 . begin () , v2 . end () , ostream_itera to r < int >( cout , " \ t " ) ) ; cout << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ d i f f e r e n c e void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ d i f f e r e n c e () { cout << " diferen¸ c a de v2 e v3 ( tem em v2 e n~ a o tem em v3 ) = " ; s e t _ d i f f e r e n c e ( v2 . begin () , v2 . end () , v3 . begin () , v3 . end () , ostream_itera to r < int >( cout , " \ t " ) ) ; cout << endl ; } // C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ s y m m e t r i c _ d i f f e r e n c e void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ s e t _ s y m m e t r i c _ d i f f e r e n c e () { cout << " diferen¸ c a sim´ e trica de v2 e v3 ( tem em v2 e n~ a o tem em v3 " ; cout << " ou tem em v3 e n~ a o tem em v2 ) = " ; s e t _ s y m m e t r i c _ d i f f e r e n c e ( v2 . begin () , v2 . end () , v3 . begin () , v3 . end () , ostream_iter at or < int >( cout , " \ t " ) ) ; cout << endl ; } // O r d e n a ¸ c~ a o por pilha void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ m a k e _ h e a p () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // F u n ¸ c~ o e s objeto // Uso da fun¸ c~ ao bin´ a r i a plus e de t r a n s f o r m void C T e s t e F u n c o e s G e n e r i c a s :: Uso_de_pl us () { cout << " Vetor v = " << v << " \ nVetor v2 = " << v2 << endl ; transform ( v . begin () ,v . end () , v2 . begin () , v3 . begin () , plus < int >() ) ; cout << " Vetor v3 = v + v2 = " << v3 << endl ; }




627

// C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ f u n ¸ c~ ao bin´ a r i a da stl // Uso da fun¸ c~ ao bin´ a r i a minus e de t r a n s f o r m void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ m i n u s () { cout << " Vetor v2 = " << v2 << endl ; transform ( v . begin () ,v . end () , v2 . begin () , v3 . begin () , minus < int >() ) ; cout << " Vetor v3 = v - v2 = " << v3 << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ t i m e s () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // Uso da fun¸ c~ ao bin´ a r i a m u l t i p l i e s e de t r a n s f o r m void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ m u l t i p l i e s () { cout << " Vetor v = " << v << " \ nVetor v2 = " << v2 << endl ; v . size () > v2 . size () ? v3 = v : v3 = v2 ; transform ( v . begin () ,v . end () , v2 . begin () , v3 . begin () , multiplies < int >() ) ; cout << " Vetor v3 [ i ] = v [ i ] * v2 [ i ] = " << v3 << endl ; } // Uso da fun¸ c~ ao bin´ a r i a divides , t r a n s f o r m e b i n d 2 n d void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ d i v i d e s () { // Cada e l e m e n t o do vetor ´ e d i v i d i d o pelo valor c o n s t a n t e const float valor = 2; vector < float > vd ( v . size () ) ; transform ( v . begin () , v . end () , vd . begin () , bind2nd ( divides < float >() , valor ) ) ; cout << " Vetor de n´ u meros float vd [ i ]= v [ i ]/2.0= " << vd << endl ; } // Cada e l e m e n t o do vetor ´ e d i v i d i d o pelo valor constante , // r e t o r n a o m´ o dulo void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ m o d u l u s () { const float valor = 2; vector < float > vd ( v . size () ) ; transform ( v . begin () , v . end () , vd . begin () , bind2nd ( modulus < int >() , valor ) ) ; cout << " Vetor de n´ u meros vd = %( v / 2.0) = " << vd << endl ; } // Cada e l e m e n t o do vetor ´ e negado void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ n e g a t e () { transform ( v . begin () , v . end () , v . begin () , negate < int >() ) ; cout << " Vetor v ap´ o s negate = " << v << endl ; } // Cada e l e m e n t o do vetor que for igual a 2 ir´ a para o in´ ı cio do vetor void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ e q u a l _ t o () { InicializaVetor(v); const float valor = 2; partition ( v . begin () , v . end () , bind2nd ( equal_to < int >() , valor ) ) ; cout << " Rearranja o vetor de forma que todos os elementos " << " \ niguais a 2 v~ a o para o in´ ı cio " << " \ nVetor v ap´ o s equal_to < int >(2) = " << v << endl ; } // Cada e l e m e n t o do vetor que for d i f e r e n t e de 2



628


// ir´ a para o in´ ı cio do vetor void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ n o t _ e q u a l _ t o () { InicializaVetor(v); const float valor = 2; partition ( v . begin () , v . end () , bind2nd ( not_equal_to < int >() , valor ) ) ; cout << " Rearranja o vetor de forma que todos os elementos " << " \ ndiferente s de 2 v~ a o para o in´ ı cio " << " \ nVetor v ap´ o s not_equal_to < int >(2) = " << v << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ g r e a t e r () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // Cada e l e m e n t o do vetor menor que 2 ir´ a para o in´ ı cio void C T e s t e F u n c o e s G e n e r i c a s :: Uso_de_le ss () { InicializaVetor(v); const float valor = 2; partition ( v . begin () , v . end () , bind2nd ( less < int >() , valor ) ) ; cout << " Rearranja o vetor de forma que todos os elementos " << " \ nmenores que 2 v~ a o para o in´ ı cio " << " \ nVetor v ap´ o s less < int >(2) = " << v << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ g r e a t e r _ e q u a l () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ l e s s _ e q u a l () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // F u n ¸ c~ oes l´ ogicas void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ l o g i c a l _ a n d () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ l o g i c a l _ o r () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ l o g i c a l _ n o t () { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } // A d a p t a d o r e s void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ b i n d 2 n d () { vector < int >:: iterator it = find_if ( v . begin () ,v . end () , not1 ( bind2nd ( greater_equal < int >() ,20) ) ) ; cout << " Valor maior que 20 localizado na posi¸ ca ~ o " << ( it - v . begin () ) << " com o valor " << * it ; } void C T e s t e F u n c o e s G e n e r i c a s :: U s o _ d e _ m e n _ f u n _ r e f ( const vector < string >& s ) { { cout << msg << " Exerc´ ı cio : Montar este exemplo . " << msg << endl ; } /* vector < string >:: c o n s t _ i t e r a t o r it = f i n d _ i f( s . begin () ,s . end () , m e n _ f u n _ r e f (& string :: empty ) ) ; cout << " String vazia na p o s i ¸ c~ a o :" << it - s . begin () << endl ; */ } int main () { C T e s t e F u n c o e s G e n e r i c a s obj ; while ( obj . Run () ) ;



36.3. STL - USO AVANCADO ¸

629

return 0; }

Nota: você encontra a sa´ıda da listagem 36.4 no arquivo UsandoFuncoesGenericasEObjetosDaSTL.out.

36.3

STL - Uso Avan¸ cado

Apresenta-se nesta se¸caõ algumas dicas de uso avan¸cado da STL.

36.3.1

O adaptador bin2nd()

Alguns objetos fun¸co˜es, como greater_equal() precisam receber dois parˆ ametros. Exemplo: greater_equal(20,30); Se uma fun¸caõ genérica varre o container e utiliza apenas um parˆ ametro, ent˜ ao o uso de fun¸co˜es como greater_equal() fica inviabilizado. Para resolver este problema a STL incluiu o método bin2nd(). O mesmo recebe a fun¸caõ genérica a ser executada e o segundo parˆ ametro a ser utilizado. O primeiro parˆ ametro é obtido do container. Veja exemplos de uso de bind2nd nos métodos Uso_de_bind2nd(); e Uso_de_divides(); da listagem 36.4.

36.3.2

Os adaptadores not1(),not2()

A fun¸caõ genérica not1() é usada para negar uma fun¸caõ un´ aria e not2() para negar uma fun¸caõ binária. Podemos usar not1() para negar o resultado de uma fun¸caõ predicado. Veja exemplo de uso de not1() no método Uso_de_bind2nd() da listagem 36.4.

36.3.3

Os adaptadores - men_fun(), men_fun_ptr() e men_fun_ref()

O conjunto de fun¸co˜es men_fun s˜ ao adaptadores da biblioteca padr˜ ao, que possibilitam a aplica¸caõ de algoritmos da biblioteca padr˜ ao aos métodos de objetos definidos pelo usuário. A fun¸caõ men_fun ref() é um adaptador que possibilita a aplica¸caõ de algoritmos da biblioteca padr˜ ao a métodos de objetos definidos pelo usuário. No exemplo a seguir, criamos um vetor de endere¸cos e a seguir executamos o método Saida() de cada objeto do vetor usando o algoritmo for_each(): Exemplo: std vector< CEndereco > ve; ... std::for_each(ve.begin(), ve.end(), std::men_fun_ref(&CEndereco::Saida)); Note no exemplo acima que o vetor armazena objetos do tipo CEndereco e n˜ ao ponteiros para CEndereco. A pergunta que fica é, e se tivêssemos um vetor de ponteiros, como executar´ıamos for_each()? A solu¸caõ é usar o algoritmo men_fun(). Veja o exemplo: Programa¸caõ Orientada a Objeto com C++



630

Exemplo: std vector< CEndereco* > vpe; std::for_each(vpe.begin(), vpe.end(), std::men_fun(&CEndereco::Saida)). J´ a a fun¸caõ men_fun_ptr() é utilizada para retornar um ponteiro para uma fun¸caõ membro (diferenciando um ponteiro de fun¸caõ de um objeto fun¸caõ). Na listagem 36.4, a fun¸caõ men_fun_ref() é usada para converter o ponteiro de método string::empty, em uma referencia para fun¸caõ (veja o método Uso_de_men_fun_ref()). Lembre-se, a maneira como devemos passar um ponteiro para um método membro (se¸caõ F.7) é diferente da maneira como passamos um ponteiro de fun¸caõ (se¸caõ F.6). Nota: a biblioteca Boost, Cap´ıtulo ?? - A Biblioteca Boost, inclui vers˜ oes mais elaboradas dos adaptadores men_fun(). Consulte o manual da biblioteca.

36.3.4

Extendendo a STL - especializa¸c˜ ao para std::swap

Podemos criar nossos próprios algor´ıtmos genéricos. O exemplo a seguir, adaptado de [Solter and Kleper, 2005] mostra uma fun¸caõ genérica. A fun¸caõ padr˜ ao std::swap(A,B); troca o conte´ udo de A por B usando um objeto tempor´ ario, o que pode ser lento, pois todos os atributos de A e B precisam ser copiados. Em alguns casos você quer trocar apenas parte do objeto. Isto pode ser resolvido usando-se uma especializa¸caõ de swap (o que é mais r´ apido). Veja no exemplo a seguir a especializa¸caõ de swap para uma classe Tipo que tem um atributo x, o atributo que queremos trocar: Exemplo: // Especializa¸ c~ ao de swap template<> void swap( Tipo A, Tipo B ) { swap(A.x,B.x); // Troca o conte´ udo de A.x por B.x }

36.4


Apresentamos neste cap´ıtulo uma introdu¸caõ aos objetos fun¸co˜es da STL. A seguir vimos as fun¸co˜es un´ arias (recebem um parˆ ametro) e bin´ arias (recebem dois parˆ ametros). Aprendemos a utilizar os objetos fun¸co˜es fornecidos pela STL, as fun¸co˜es aritméticas, de compara¸caõ, e l´ ogicas. Vimos ainda uma se¸caõ com dicas avan¸cadas de STL, onde apresentamos alguns adaptadores fornecidos pela STL como o adaptador para fun¸caõ objeto bin2nd(), os adaptadores not1(), not2(), e men_fun(). Finalmente aprendemos a extender a STL apresentando um exemplo de especializa¸caõ para std::swap(). Nota: como a STL é muito ampla n˜ ao podemos esgotar todos os seus tópicos neste livro. A dica é: consulte o manual disponibilizado em http://www.sgi.com/tech/stl/, para ampliar seus conhecimento da STL. Programa¸caõ Orientada a Objeto com C++


36.5. EXERCÍCIOS

36.5

631

Exerc´ıcios

1. Adicione novas fun¸co˜es genéricas na listagem 36.4. 2. Transforma a classe CTesteFuncoesGenericas da listagem 36.4 em uma classe template. 3. Note que a listagem 36.4 apresenta diversos métodos incompletos, sua tarefa é completar esta listagem.



632

36.5. EXERCÍCIOS



Referˆ encias Bibliogr´ aficas [Amadeo., 2003] Amadeo., S. (2003). Software Livre e Inclus˜ ao Digital. CONRAD, S˜ ao Paulo. [Anais, 2000] Anais (2000). Anais do 1 F´ orum Internacional de Software Livre 2000. UNISINOS, Porto Alegre. [Aris, 1978] Aris, R. (1978). Mathematical Modelling Techniques. dover. [Austern, 1998] Austern, M. H. (1998). Generic Programming and the STL: Using and Extending the C++ Standart Template Library. Addison-Wesley. [Bender, 1978] Bender, E. A. (1978). An Introduction to Mathematical Modeling. dover. [Bjarne, 1999] Bjarne, S. (1999). C++ The Programming Language, volume 1. John Wiley Sons, 3 edition. [Blaha and Rumbaugh, 2006] Blaha, M. and Rumbaugh, J. (2006). Modelagem e Projetos Baseados em Objetos com UML 2. Campus, Rio de Janeiro. [Boente, 2006] Boente, A. (2006). Constru¸ca õ de Algoritmos. Saraiva. [Booch, 1986] Booch, G., editor (1986). Object-oriented development, volume 12 of IEEE Transactions on Software Engineering. [Booch et al., 2000] Booch, G., Rumbaugh, J., and Jacobson, I. (2000). UML - Guia do Usu´ ario. Edit. Campus, Rio de Janeiro. [Coad and Yourdon, 1993] Coad, P. and Yourdon, E. (1993). An´ alise Orientada a Objeto. Campus, S˜ ao Paulo. [Comunidade-GNU, 1996] Comunidade-GNU (1996). http://www.gnu.org/philosophy/free-sw.pt.html.

O

que

é

o

software

livre?

[Comunidade-Software-Livre, 1996] Comunidade-Software-Livre (1996). Declaraçaõ de barcelona - desafios para amplia¸caõ e consolidad¸caõ do software livre. http://www.softwarelivre.org/forum2004/news/2297. [Cormen et al., 2002] Cormen, T. H., Charles E, L., Rivest, R. L., and Stein, C. (2002). Algoritmos. Campus. [da Silva Neto and Neto, 2005] da Silva Neto, A. J. and Neto, F. D. M. (2005). Problemas Inversos - Conceitos Fundamentais e Aplica¸co ˜es. Editora UERJ. [Deitel and Deitel, 2002] Deitel, H. and Deitel, P. (2002). C++ HOW TO PROGRAM. PRENTICE HALL, Porto Alegre, 4 edition. 633

634

ˆ ´ REFERENCIAS BIBLIOGRAFICAS

[Emerson Rios, 2004] Emerson Rios, T. R. (2004). Projeto e Engenharia de Software - Teste de Software. Alta Books. [Fowler and Scott, 2000] Fowler, M. and Scott, K. (2000). UML Essencial. Bookman, S˜ ao Paulo. [Guedes, 2004] Guedes, G. T. A. (2004). UML Uma Abordagem Pr´ atica. novatec, S˜ ao Paulo. [GuiaLivre, 2004] GuiaLivre (2004). Guia livre - referência de migra¸caõ para software livre do governo federal. Technical report, Governo Federal. http://www.governoeletronico.gov.br. [Holloway, 2006] Holloway, J. P. (2006). Introdu¸ca õ a ` Programa¸ca õ para Engenharia. LTC. [http://www.fsl.org, 2004] http://www.fsl.org (2004). Filosofia de Software Livre. [Johnson and Foote, 1998] Johnson, R. E. and Foote, B. (1998). Designing reusable classes. JOOP - Journal of Object-Oriented Programming, pages 22–35. [Kernighan and Ritchie, 1988] Kernighan, B. W. and Ritchie, D. M. (1988). The C Programming Language, Second Edition. Prentice Hall. [Korson and Macgregor, 92] Korson, T. and Macgregor, J. D. (92). Technical criteria for the specification and evaluation of object oriented libraries. Software Engineering journal, pages 85–94. ˜ AO RUP - Rational Unified Process. [Kruchten, 2003] Kruchten, P. (2003). INTRODUC ¸ AO Ciência Moderna, S˜ ao Paulo. [Lischner, 2003] Lischner, R. (2003). C++ in a Nutshell - A Language & Library Reference. Oreilly. [Martin and McClure, 1993] Martin, J. and McClure, C. (1993). CASE. MacGraw-Hill, S˜ ao Paulo.

Técnicas Estruturadas e

[Meyers, 2005] Meyers, S. (2005). Effective C++ : 55 Specific Ways to Improve Your Programs and Designs. Addison-Wesley. [Parga, 2006] Parga, D. F. (2006). Introdu¸caõ a java. Revista inform, pages 10–19. [Pressman, 2002] Pressman, R. S. (2002). Engenharia de Software. MCGraw Hill, Rio de Janeiro, 5 edition. [Queiroz, 2002] Queiroz, R. (2002). Porque usar software livre. RDL. [Rezende, 2002] Rezende, D. A. (2002). Engenharia de Software e Sistemas de Informa¸ca õ. Brasport, Rio de Janeiro. [Rumbaugh et al., 1994] Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., and Lorensen, W. (1994). Modelagem e Projetos Baseados em Objetos. Edit. Campus, Rio de Janeiro. [Solter and Kleper, 2005] Solter, N. A. and Kleper, S. J. (2005). Professional C++. Wrox. [Sonerviile, 1993] Sonerviile (1993). Engenharia de Software. MacGraw-Hill, S˜ ao Paulo. [Stroustrup, 2005] Stroustrup, B. (2005). The design of c++0x. C/C++ Users Journal. [Sutter, 2006] Sutter, H. (2006). Programa¸ca õ Avan¸cada em C++. Pearson - Mahron Books. Programa¸caõ Orientada a Objeto com C++



635

[Teles, 2004] Teles, V. (2004). Extreme Programming. Novatec, S˜ ao Paulo. [Teles, 2006] Teles, V. (2006). Extreme programming. Revista inform, pages 42–49. [Vandevoorde and Josuttis, 2002] Vandevoorde, D. and Josuttis, N. M. (2002). C++ Templates: The Complete Guide. Addison Wesley Professional. [Wikipedia, 2007] Wikipedia (2007). ”wikipedia - http://www.wikipedia.org/”. In Wikipedia. ”http://www.wikipedia.org/”. [Winblad et al., 1993] Winblad, A. L. et al. (1993). Software Orientado a Objeto, volume 1. Makron Books, S˜ ao Paulo.



636




Parte IV

Apˆ endices

637

Apˆ endice A

Diretrizes de Pr´ e-Processador Neste apêndice veremos as diretrizes de pré-processador. As diretrizes de pré-processador s˜ ao orienta¸co˜es, instru¸co˜es que fornecemos para a compilaçaõ do programa (veja se¸caõ A.1). Uma diretriz de pré-processador inicia-se com o s´ımbolo # e é utilizada para inclus˜ ao de arquivos (se¸caõ A.2), compila¸caõ condicional (se¸caõ A.3), uso de macros (se¸caõ A.4) e instru¸co˜es de guarda (se¸caõ A.5).

A.1

Fase de pr´ e-processamento

´ a primeira fase da compila¸caõ, verifica as instru¸co˜es de compila¸caõ passadas com o sinal E # (reveja 7.7). Primeiro verifica as instru¸co˜es de guarda (se¸caõ A.5), a seguir s˜ ao inclu´ıdos os arquivos externos (se¸caõ A.2), depois s˜ ao processadas as macros (se¸caõ A.4). Na fase de pré-processamento, cada letra do arquivo de disco é mapeada para o padr˜ ao Unicode (ISO/IEC 10646) e posteriormente para o conjunto de caracteres de execu¸caõ. O resultado da fase de pré-processamento é uma seq¨ uência de s´ımbolos que chamamos de unidade de tradu¸caõ. A unidade de tradu¸caõ é independente de outros arquivos (veja Figura 7.1). Note ainda que cada arquivo do programa é compilado separadamente. No exemplo a seguir a unidade de tradu¸caõ vai incluir o arquivo . Exemplo: // Arquivo Prog.cpp #include int main() { std::cout < < "Oi tudo bem!";

return 0; }

Para gerar o arquivo de pré-processamento digite: g++ -E Prog.cpp > Prog.ii . Note que o arquivo gerado é muito grande.

A.2

Inclus˜ ao de arquivos

Usamos a diretriz #include para incluir arquivos externos. Utilize #include para incluir arquivos da biblioteca, e aspas duplas #include "nome-do-arquivo" para incluir arquivos do diret´ orio atual. A diferen¸ca entre ambas é que a segunda instru¸caõ procura os arquivos no diret´ orio do usuário e depois nos diret´ orios identificados na vari´ avel de ambiente PATH e do compilador (/usr/include). 639

˜ CONDICIONAL A.3. COMPILAC ¸ AO

640

Prot´ otipo: // Para realizar a inclus˜ ao de arquivos. #include #include ”nome-do-arquivo” #include ”caminho/para/o/arquivo/nome-do-arquivo” Observe que usando aspas "" podemos passar o caminho completo do arquivo. Mas este proce´ mais simples setar o caminho da biblioteca na vari´ dimento é inadequado. E avel de ambiente PATH utilizando export PATH=$PATH:caminho/para/biblioteca, veja prot´ otipo a seguir. A vari´ avel PATH também pode ser setada no arquivo oculto .bash profile, que fica localizado no diret´ orio raiz do usuário (cd ˜ && gedit bash profile). Prot´ otipo: # bash export PATH=$PATH:caminho/para/biblioteca/:caminho/para/arquivos/inclus˜ ao # csh setenv PATH=$PATH:caminho/para/biblioteca/:caminho/para/arquivos/inclus˜ ao

A.3

Compila¸ c˜ ao condicional

A compila¸caõ condicional permite que sejam colocadas no c´ odigo do programa instru¸co˜es de compila¸caõ que restringem as ´ areas do arquivo a serem compiladas. Por exemplo, alguns arquivos podem ter nomes diferentes no Windows, no GNU/Linux, Unix ou no MacOS X. Com a compila¸caõ condicional, você pode verificar qual o sistema operacional e especificar os arquivos corretos, assim, podemos incluir instru¸co˜es que diferenciam plataformas. Veja a seguir as instru¸co˜es que podem ser utilizadas para compila¸caõ condicional.

A.3.1

#define

A linguagem C permite a defini¸caõ de vari´ aveis que s˜ ao passadas ao compilador para a realiza¸caõ do processo de compila¸caõ. A instru¸caõ #define, é utilizada para definir uma vari´ avel de compila¸caõ. Veja prot´ otipo a seguir. Prot´ otipo: // Define uma vari´ avel #define var

A.3.2

#ifdef

Depois de definir uma vari´ avel podemos utilizar a instru¸caõ #ifdef. Se a vari´ avel foi definida o bloco é compilado. Prot´ otipo: #ifdef var ..bloco de c´ odigo.. #endif // Finaliza o ..bloco de c´ odigo.. Programa¸caõ Orientada a Objeto com C++



A.3.3

641

#ifndef

Da mesma forma que #ifdef podemos usar #ifndef, ou seja, se a vari´ avel n˜ ao foi definida compile o bloco. Isto é usado em sistemas multiplataforma, por exemplo, se n˜ ao estamos no Windows fa¸ca isto. Prot´ otipo: // Apaga defini¸ca õ da vari´ avel var #ifndef var ..bloco de c´ odigo.. #endif // Finaliza o ..bloco de c´ odigo.., o ifndef

A.3.4

#undef

A instru¸caõ #undef, é utilizada para apagar uma defini¸caõ. Veja prot´ otipo a seguir. Prot´ otipo: #undef var

// Apaga defini¸ca õ da vari´ avel var

As instru¸co˜es #define também permitem a defini¸caõ de vari´ aveis que ser˜ ao substitu´ıdas em tempo de compila¸caõ, funcionando de modo semelhante ao search(vari´ avel)/replace(valor) de seu editor de texto. Prot´ otipo: // Trocar a vari´ avel var pelo valor #define vari´ avel valor No exemplo a seguir, definimos três vari´ aveis de ambiente. Na etapa de pré-processamento toda vez que o compilador encontrar a palavra string1, ir´ a substitu´ı-la por "mensagem_1". Da mesma forma, toda vez que o compilador encontrar a palavra CM_FileSave, ir´ a substitu´ı-la por 2515. Exemplo: #define string1 "mensagem_1" #define CM_FileSave 2515 #define dimensao_x_matriz 10 Dica: o uso de #define para cria¸caõ de constantes, como em #define PI 3.1415 é obsoleto. Use const double pi = 3.1415;. Veja se¸caõ 12.4.

A.3.5

#if

Veja a seguir o prot´ otipo para compila¸caõ condicional com #if. Se a express˜ ao for verdadeira, o compilador compila o c´ odigo dentro do bloco e, se for falsa, pula o bloco. O termo express˜ ao constante indica que a express˜ ao deve ser avaliada em tempo de compila¸caõ (durante a compila¸caõ). Prot´ otipo: #if express˜ ao constante ..bloco de c´ odigo.. #endif Reveja agora o exemplo apresentado na listagem 8.3. Programa¸caõ Orientada a Objeto com C++



642

A.3.6

#ifdef...else

Se a express˜ ao constante for verdadeira, o compilador compila o bloco 1, se for falsa, compila o bloco 2. Veja exemplo na listagem A.1. Prot´ otipo: #ifdef express˜ ao constante .. bloco de c´ odigo1 .. #else .. bloco de c´ odigo2 .. #endif Listing A.1: Pré-processamento: Usando #ifdef..else. 1 2 3 4 5 6 7 8 9 10 11

# include < iostream > int main () { # ifdef DEBUG std :: cout << " Vers~ a o com vari´ a vel debug ativada " << std :: endl ; # else std :: cout << " Vers~ a o com vari´ a vel debug N ~ A O ativada " << std :: endl ; # endif return 0; } [ b u e n o @ s u p o r t e 3 Parte - VI ] $ g ++ if - else . cpp [ b u e n o @ s u p o r t e 3 Parte - VI ] $ ./ a . out Vers~ a o com vari´ a vel debug N ~ A O ativada [ b u e n o @ s u p o r t e 3 Parte - VI ] $ g ++ - DDEBUG if - else . cpp [ b u e n o @ s u p o r t e 3 Parte - VI ] $ ./ a . out Vers~ a o com vari´ a vel debug ativada

A.3.7

#if...else

Se a express˜ ao constante for verdadeira, o compilador compila o bloco 1, se for falsa, compila o bloco 2. Veja exemplo na listagem A.2. Prot´ otipo: #if express˜ ao constante ..bloclo de c´ odigo1 .. #else ..bloclo de c´ odigo2 .. #endif Listing A.2: Pré-processamento: Usando #if..else. 1 2 3 4 5 6 7 8 9 10 11 12

# include < iostream > using namespace std ; int main () { # ifdef __Linux__ cout < < " oi GNU / Linux \ n " ; # else cout << " oi \ n " ; return 0; } # endif



A.4. MACROS

643

oi GNU / Linux

A.3.8

#if...#elif...#elif...#endif

A diretriz de processamento #if...elif é usada para m´ ultiplas verifica¸co˜es. Funciona da mesma forma que if..else (veja se¸caõ D.2.2): Prot´ otipo: #if express˜ ao constante1 ..bloclo de c´ odigo1 .. #elif express˜ ao constante2 ..bloclo de c´ odigo2 .. #elif express˜ ao constante3 ..bloclo de c´ odigo3 .. #endif Dica: os arquivos da biblioteca padr˜ ao costumam incluir exemplos de uso das diretrizes de pré-processador, sendo uma boa referência para estudo.

A.4

Macros

Na linguagem C, você pode utilizar macros, que s˜ ao fun¸co˜es de pré-processamento. Uma macro é implementada com uma diretiva #define. Veja o exemplo. Exemplo: // Defini¸ c~ ao da macro #define soma(x,y) (x+y) int a = 4; int b = 5; // Uso da macro, resultado int z = (a + b); int z = soma(a,b); Na linguagem C++, as macros foram substitu´ıdas pelas fun¸co˜es inline, que s˜ ao mais seguras por fazerem verifica¸caõ de tipo (veja se¸caõ 13.10).

A.4.1

Macros pr´ e-definidas

A linguagem C++ tem um conjunto de macros pré-definidas, veja lista abaixo. A listagem A.3 mostra o uso das macros pré-definidas. LINE

N´ umero da linha compilada.

FILE

Nome do arquivo que esta sendo compilado.

DATE

Data de compila¸caõ.

TIME

Hora minuto e segundo.

STDC

Se é compilador padr˜ ao.



˜ A.5. INSTRUC ¸ OES DE GUARDA

644

Listing A.3: Pré-processamento: Usando macros pré-definidas. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# include < iostream > using namespace std ; int main () { cout << " Arquivo : " << " \ nLinha : " << " \ nData : " << " \ nHora : " << " \ nCompilado r : "

<< << << << <<

__FILE__ __LINE__ __DATE__ __TIME__ __STDC__ << endl ;

# ifdef __GNUCC__ cout << " Compilado r da GNU : " << __GNUCC__ << endl ; # elif __MSC_VER_ _ cout << " Compilado r da Microsoft : " << __MSC_VER _ _ << endl ; # endif } Arquivo : List -A -4 - Macros . cpp Linha : 8 Data : Feb 13 2007 Hora : 11:47:58 Compilado r : 1

Veja a seguir uma macro, a mesma recebe dois parˆ ametros, a e b e chama uma fun¸caõ f, passando o maior valor max(a,b). #define F(a,b)

f( (a) > (b) ? (a) : (b))

Agora, veja o que acontece quando usamos a macro de forma inadvertida. F(++a,++b) O resultado gerado pela macro é dado por: f( (++a) > (++b) ? (++a) : (++b)) Ou seja, a e b s˜ ao incrementados duas vezes, o que n˜ ao desejamos. Este tipo de erro é comum quando se usa as obsoletas macros de C. A dica é simples, elimine o uso de macros, use fun¸co˜es inline de C++ (se¸caõ 13.10). Veja a seguir a fun¸caõ inline que substitue com vantagens as macros. Exemplo: // Defini¸ c~ ao template inline T F(const T&a, const T&b) { f( a > b ? a:b;); } // Uso F(a,b);

A.5

Instru¸ c˜ oes de guarda

As instru¸co˜es de guarda foram apresentadas na se¸caõ 11.4. Programa¸caõ Orientada a Objeto com C++


´ A.6. SENTENCAS ¸ PARA DIRETRIZES DE PRE-PROCESSADOR

A.6

645

Senten¸cas para diretrizes de pr´ e-processador

• Evite utilizar macros; as fun¸co˜es inline do C++ realizam a mesma tarefa de forma mais inteligente. • Substitua o uso de #define por const e enumera¸co˜es. • Você pode identificar qual processador esta utilizando (verifique o manual de seu compilador). _ _CNUCC_ _ Compilador da gnu. _ _MSC_VER_ _ Compilador da Microsoft (Microsoft visual C++).

A.7


Neste apêndice aprendemos a utilizar as diretrizes de pré-processador de C++. Vimos que s˜ ao instru¸co˜es que se iniciam com # e que fornecem instru¸co˜es para a compila¸caõ do programa. Aprendemos ainda a utilizar compila¸caõ condicional, e que n˜ ao devemos usar as antigas macros de C. Entendemos o uso das instru¸co˜es de guarda.

A.8

Exerc´ıcios

1. Diga com suas palavras como funciona a etapa de pré-processamento. 2. Diga o que ocorre com a palavra dimensao x matriz na etapa de pré-processamento do c´ odigo abaixo. #define dimensao_x_matriz 10 3. Nas listagens em que utilizamos arquivos .h separados dos arquivos .cpp, elimine do arquivo .h as instru¸co˜es de guarda e tente compilar novamente o programa. Descreva o que acontece. 4. Modifique a listagem A.1 acrescentando novos blocos ifdef..else. 5. Modifique a listagem A.2 acrescentando novos blocos if..else. 6. Rode o programa A.3 em sua máquina, verifique a sa´ıda obtida. 7. Na se¸caõ A.4 falamos de exemplos de macros que podem apresentar problemas. Monte um programa com os exemplos apresentados na se¸caõ e veja a sa´ıda obtida.



646

A.8. EXERCÍCIOS



Apˆ endice B

´ Conceitos Uteis Para Programa¸ c˜ ao em C Neste apêndice veremos alguns conceitos u ´ teis para programa¸caõ em C. O uso dos especificadores de classes de armazenamento (se¸cão B.1), do especificador de linkagem (se¸caõ B.2), o uso de extern (se¸caõ B.2.1), dos modificadores de acesso (se¸caõ B.3). O escopo das vari´ aveis (se¸caõ B.4). Senten¸cas para classes de armazenamento, escopo e modificadores de acesso (se¸caõ B.5).

B.1

Especificador de classe de armazenamento - tempo de vida

A classe de armazenamento refere-se ao tempo de vida do objeto. A defini¸caõ da classe de armazenamento é o primeiro item da declara¸caõ de uma vari´ avel e instrui o compilador sobre o modo como a vari´ avel ser´ a armazenada. Existem três palavras-chave para definir a classe de armazenamento. As palavras-chave auto e register s˜ ao utilizadas para vari´ aveis que s˜ ao constru´ıdas, utilizadas e destru´ıdas automaticamente pelo compilador; static é utilizado para vari´ aveis que s´ o s˜ ao destru´ıdas quando o programa é encerrado. Note que static também é constru´ıdo e destru´ıdo automaticamente pelo compilador. Objetos criados com new e destru´ıdos com delete, tem seu tempo de vida definido pelo programador. auto: é o método default para armazenamento de vari´ aveis. Quando for encerrada a fun¸caõ ou bloco onde a vari´ avel foi declarada, esta ser´ a eliminada, isto é, destru´ıda automaticamente. Exemplo: { auto int a = 3; // A vari´ avel a ´ e criada } // A vari´ avel a e ´ destru´ ıda register: um processador como um Intel-Pentium ou um AMD-Opteron, tem um bloco onde est˜ ao os registradores. Cada registrador é utilizado, temporariamente, para realiza¸caõ de algum processamento, como uma soma. Assim, quando fazemos c = a + b; , a vari´ avel a é 647

648

B.2. ESPECIFICADOR DE LINKAGEM copiada para o registrador 1, e a vari´ avel b para o registrador 2. O resultado da soma é armazenado no registrador 3 e depois copiado para c. Quando utilizamos a palavra-chave register, estamos pedindo para o compilador colocar a vari´ avel em um registro, que tem processamento mais r´ apido. Quando se encerrar a fun¸caõ ou bloco onde foi declarada, a vari´ avel vai ser eliminada. Os compiladores mais modernos colocam nos registradores as vari´ aveis mais utilizadas. O tempo de vida é o mesmo de uma vari´ avel auto.

static: quanto utilizamos static a vari´ avel passa a existir a partir de sua defini¸caõ e dura toda a execu¸caõ do programa. Se n˜ ao for definido um valor, assume o valor 0 (zero). Em um programa, os objetos est´ aticos s˜ ao os primeiros a serem constru´ıdos e os u ´ ltimos a serem destru´ıdos (se¸caõ 16.6.3). Todas as vari´ aveis globais têm classe de armazenamento est´ atica, isto é, existem por toda a vida do programa. Se dentro de uma fun¸caõ houver uma vari´ avel static, est´ a ser´ a criada quando o programa passar pela fun¸caõ pela primeira vez; na segunda passagem, a vari´ avel n˜ ao é novamente criada. Um objeto ou membro de um objeto pode ser est´ atico, se for declarado explicitamente com static. A palavra-chave static também indica que a linkagem é interna (se¸caõ B.2). Exemplo: int fun¸ c~ ao() { auto int x; // O mesmo que int x; register int y; // Colocar no registro static char Titulo[] = "SAILAnaliseImagens"; // Deixar na mem´ oria return 0; }

B.2

Especificador de linkagem

Todo nome declarado e usado define a necessidade de uma linkagem, isto é, de uma liga¸caõ entre o nome do objeto e o espa¸co de mem´ oria ocupado pelo objeto. Por exemplo, se declaramos Exemplo: extern int x; mas nunca usamos x, ent˜ ao n˜ ao teremos problema de linkagem. Mas se x for usado, o mesmo precisa estar definido em algum arquivo externo. Em C++ uma linkagem pode ser: • Interna: como exemplo podemos citar atributos e métodos de uma classe, vari´ aveis declaradas como static ou const. • Externa: usa a palavra-chave extern, veja exemplo na se¸caõ B.2.1. • Sem linkagem: como exemplo podemos citar vari´ aveis definidas dentro de um bloco ou fun¸caõ. Também podemos especificar que a linkagem deve ser feita utilizando-se padr˜ oes de outras linguagens, como ”C” e ”pascal”. Programa¸caõ Orientada a Objeto com C++


B.2. ESPECIFICADOR DE LINKAGEM

649

”C”: você pode linkar programas em C com programas em C++. No exemplo abaixo informa que a fun¸caõ é uma fun¸caõ de C. Exemplo: extern "C" void cfuncao(); Outra maneira de fazer isto é criar um bloco de fun¸co˜es em C, veja exemplo: Exemplo: extern "C" { void cfuncao1(); void cfuncao2(); .. } ”pascal”: se a fun¸caõ a ser chamada foi desenvolvida utilizando a linguagem de programa¸caõ pascal, você deve incluir na declarara¸caõ da fun¸caõ a palavra-chave pascal. Exemplo: int pascal fun¸ c~ ao(par^ ametros); // Declara .. int pascal fun¸ c~ ao(par^ ametros) // Define { }

B.2.1

Uso de extern

A utiliza¸caõ da palavra-chave extern permite a compila¸caõ separada dos diversos arquivos que compõem um programa. Ou seja, você deve utilizar extern na declara¸caõ de uma fun¸caõ ou vari´ avel que é definida em outros arquivos. O arquivo com a declara¸caõ extern aceita a existência da fun¸caõ de modo que você pode compilar as fun¸co˜es separadamente. Exemplo: // No arquivo A: cria a vari´ avel x (declara e define) int x; // No arquivo B: informa que x j´ a existe (s´ o declara) extern int x; Com a declara¸caõ extern, o arquivo B aceita a existência da vari´ avel int x;, mas n˜ ao aloca espa¸co de armazenamento para esta. Deste modo, você pode compilar os arquivos A e B separadamente. Veja nas listagens B.2 e B.3 exemplos de uso de static, extern e compila¸caõ separada. O exemplo das listagens B.2 e B.3 deixa claro a ordem em que os objetos est´ aticos s˜ ao criados e destru´ıdos. A classe Teste é criada apenas para enviar mensagens para tela. Primeiro s˜ ao criados os objetos globais (definidos ou n˜ ao com static), a seguir os objetos s˜ ao criados de forma autom´ atica, dentro de main() (Arquivo A: T1 main., Arquivo A: static T2 global.) e do for (Arquivo A: T1 for.,Arquivo A: static T2 for.). Observe que T1 for é criado-destru´ıdo, e a seguir criado-destru´ıdo novamente. Ou seja, quando chega o fim do bloco em que foram Programa¸caõ Orientada a Objeto com C++


650

B.2. ESPECIFICADOR DE LINKAGEM

criados, os objetos autom´ aticos s˜ ao destru´ıdos. Com a chamada a funcao1, o objeto (Arquivo atico o mesmo é criado apenas uma vez, na sua primeira B: static T3 for) é criado, como é est´ execu¸caõ. A funcao1() é encerrada, e a seguir a fun¸caõ main(). O objeto autom´ atico (Arquivo aticos. Observe ainda que T2 A: T1 main.) é destru´ıdo, e a seguir todos os outros objetos est´ foi criado duas vezes, e tem escopo de arquivo, n˜ ao podendo ser utilizado no outro arquivo. No arquivo B usamos extern T1, de forma que podemos usar T1 (sem o criar novamente). Da mesma forma, a declara¸caõ extern void funcao1(); colocada no arquivo A, garantiu a chamada a fun¸caõ funcao1() sem que a mesma tivesse sido definida. Listing B.1: Classe Autixliar Cteste. 1 2 3 4 5 6 7 8 9 10 11 12 13

# include < iostream > # include < string >

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// Define classe de CTeste , usada para enviar m e n s a g e n s para tela # include " CTeste . h "

class CTeste { std :: string msg ; public : CTeste ( std :: string s ) : msg ( s ) { std :: cout << " Criou objeto ~ CTeste () { std :: cout <<

: " << msg << std :: endl ; };

" Destruiu objeto : " << msg << std :: endl ; };

};

Listing B.2: Fun¸caõ e escopo A.

// D e c l a r a que existe uma funcao1 , que ´ e d e f i n i d a em outro a r q u i v o extern void funcao1 () ; // Cria objeto global CTeste T1 ( " Arquivo A : T1_global . " ) ; // Cria objeto est´ a tico , v i s ´ ı v e l s o m e n t e neste a r q u i v o static CTeste T2 ( " Arquivo A : static T2_global . " ) ; int main () { std :: cout << " Inicio da fun¸ ca ~ o main () . " << std :: endl ; // Cria objeto v i s ´ ı v e l dentro de main () CTeste T1 ( " Arquivo A : T1_main . " ) ; // Cria objeto est´ a tico , v i s ´ ı v e l s o m e n t e em main () static CTeste T2 ( " Arquivo A : static T2_main . " ) ; // Cria um bloco for for ( int i = 0; i < 2; i ++) { // Cria objeto v i s ´ ı v e l dentro do for CTeste T1 ( " Arquivo A : T1_for . " ) ; // Cria objeto est´ a tico , v i s ´ ı v e l s o m e n t e no for static CTeste T2 ( " Arquivo A : static T2_for . " ) ; } // D e s t r o e T1_for // Chama funcao1 , d e f i n i d a em outro a r q u i v o funcao1 () ;



B.2. ESPECIFICADOR DE LINKAGEM 35 36 37

651

std :: cout << " Fim da fun¸ ca ~ o main () . " << std :: endl ; return 0; }

Listing B.3: Fun¸caõ e escopo B. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# include " CTeste . h " // J´ a existe um objeto T1 extern CTeste T1 ; // Cria v a r i ´ a v e l est´ a tica , v i s ´ ı v e l s o m e n t e neste arquivo , static CTeste T2 ( " Arquivo B : static T2_global . " ) ; // D e f i n i ¸ c~ a o da fun¸ c~ ao funcao1 void funcao1 () { std :: cout << " In´ ı cio da fun¸ ca ~ o funcao1 . " << std :: endl ; // Se tentar usar a linha abaixo , causa erro de linkagem , // pois T2 foi d e f i n i d o como sendo est´ a tico , // s´ o p o d e n d o ser usado no a r q u i v o em que foi d e f i n i d o . // cout << T3 . msg << endl for ( int i = 0; i < 3; i ++) { // Cria T3 na p r i m e i r a p a s s a g e m. static CTeste T3 ( " Arquivo B : static T3_for " ) ; } std :: cout << " Fim da fun¸ ca ~ o funcao1 . " << std :: endl ; } Criou objeto : Arquivo A : Criou objeto : Arquivo A : Criou objeto : Arquivo B : Inicio da fun¸ ca ~ o main . Criou objeto : Arquivo A : Criou objeto : Arquivo A : Criou objeto : Arquivo A : Criou objeto : Arquivo A : Destruiu objeto : Arquivo A : Criou objeto : Arquivo A : Destruiu objeto : Arquivo A : In´ ı cio da fun¸ ca ~ o funcao1 . Criou objeto : Arquivo B : Fim da fun¸ ca ~ o funcao1 . Fim da fun¸ ca ~ o main () . Destruiu objeto : Arquivo A : Destruiu objeto : Arquivo B : Destruiu objeto : Arquivo A : Destruiu objeto : Arquivo A : Destruiu objeto : Arquivo B : Destruiu objeto : Arquivo A : Destruiu objeto : Arquivo A :

T1_global . static T2_global . static T2_global . T1_main . static T2_main . T1_for . static T2_for . T1_for . T1_for . T1_for . static T3_for

T1_main . static T3_for static T2_for . static T2_main . static T2_global . static T2_global . T1_global .

Para compilar este exemplo: g++ -c escopo-b.cpp g++ -c escopo-a.cpp Para compilar e linkar: g++ List-B-2-escopo-a.cpp List-B-3-escopo-b.cpp Programa¸caõ Orientada a Objeto com C++


652

B.3. MODIFICADORES DE ACESSO

Para rodar: ./a.out

B.3

Modificadores de acesso

Vimos na se¸caõ 8.4 que as palavras-chaves static, extern, const, volatile e mutable s˜ ao qualificadores. Os mesmos podem ser divididos em modificadores de acesso (const, volatile e mutable) e especificador de linkagem (static, extern). Os modificadores de acesso s˜ ao palavras-chave utilizadas para modificar o tipo de acesso a determinada vari´ avel. const: uma vari´ avel const é uma vari´ avel constante, que nunca muda. Portanto, seus valores s˜ ao atribu´ıdos uma u ´ nica vez. Vari´ aveis const n˜ ao podem aparecer à esquerda do sinal de igualdade. A palavra-chave const foi criada para substituir as instru¸co˜es #define. A vantagem é que com const existe verifica¸caõ de tipo, o que n˜ ao ocorre com #define. No exemplo da listagem B.4, criamos dois objetos const, um global const double PI = 3.14159265358979; e outro local, const float PI = static_cast < float >(::PI);. observe na sa´ıda que PI local , s´ o preserva os 7 primeiros d´ıgitos, ou seja, 3.141592. Listing B.4: Usando modificadores de acesso. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# include < iostream > # include < iomanip > // C r i a ¸ c~ a o de objeto c o n s t a n t e ( n~ a o pode mudar ) , // global ( v i s ´ ı v e l em todo p r o g r a m a) const double PI = 3 . 1 4 1 5 9 2 6 5 3 5 8 9 7 9 ; int main () { // C r i a ¸ c~ a o de objeto c o n s t a n t e ( n~ a o pode mudar ) , // local ( v i s ´ ı v e l dentro de main ) const float PI = static_cas t < float >(:: PI ) ; std :: cout << std :: s e t p r e c i s i o n (15) << " Conte´ u do de PI local < float > = " << PI << " \ n " << std :: s e t p r e c i s i o n (15) << " Conte´ u do de PI global < double > = " << :: PI << " \ n " ; return 0; } Conte´ u do de PI local < float > = 3 . 1 4 1 5 9 2 7 4 1 0 1 2 5 7 3 2 Conte´ u do de PI global < double > = 3 . 1 4 1 5 9 2 6 5 3 5 8 9 7 9

volatile: vari´ aveis que podem ter seu valor alterado de modo inesperado, n˜ ao detectado pelo compilador (impede o compilador de utilizar otimiza¸co˜es agressivas com esta vari´ avel). Têm utilidade em dispositivos mapeadores de mem´ oria, multitarefa e threads. Veja listagem ??. Exemplo: volatile int tempo; // Uso de volatile const volatile int alfa;// Uso de const volatile Programa¸caõ Orientada a Objeto com C++


´ B.4. ESCOPO DAS VARIAVEIS

653

mutable: quando você quer permitir que um atributo de uma classe/estrutura possa ser modificado, mesmo que o objeto seja declarado como const. Exemplo: struct Funcionario { char nome[30]; mutable int contador; } // Cria objeto do tipo Funcionario com nome func, constante const Funcionario func = {"Pedro",0}; // Abaixo tenta modificar o objeto func que ´ e const strcpy(func.nome,"jo~ ao da silva"); // Erro // Abaixo o acesso ´ e permitido gra¸ cas ao especificador mutable func.contador = 1; const e volatile: no exemplo anterior, alfa é uma constante, e como tem o volatile, o compilador n˜ ao faz qualquer suposi¸caõ sobre os valores de alfa. Um programa externo pode mudar o valor de alfa.

B.4

Escopo das vari´ aveis

J´ a discutimos preliminarmente o conceito de escopo nas se¸co˜es 8.12 e 10.3. Um programa é dividido em n´ıveis/escopos, para melhorar sua organiza¸caõ. Desta forma, quando declaramos uma vari´ avel em determinado ponto do programa, estamos fazendo com que essa vari´ avel possa ser acessada no n´ıvel em que foi declarada e nos n´ıveis seguintes. Ou seja, o escopo de uma vari´ avel define onde ela pode ser utilizada. Existem dois tipos de escopo, com nome e sem nome. Um namespace e uma classe s˜ ao exemplos de escopo com nomes. Um bloco, o corpo de uma fun¸caõ, e um namespace sem nome s˜ ao exemplos de escopo sem nome. Veja a seguir alguns exemplos de escopo. Escopo local (de bloco): quando uma vari´ avel é declarada dentro de um bloco, ela pode ser acessada dentro desse bloco, a partir de sua declara¸caõ, e nos n´ıveis mais baixos. No exemplo abaixo x pode ser acessado a partir de sua defini¸caõ, o que inclui o bloco 2. Exemplo: { // int x = 3; { // int r = 4; } // } //

In´ ıcio bloco 1 In´ ıcio bloco 2 Fim bloco 2 Fim bloco 1

Escopo de fun¸ c˜ ao/m´ etodo: quando uma vari´ avel é declarada dentro de uma fun¸caõ, ela pode ser acessada dentro da fun¸caõ. Se a vari´ avel for declarada como static, ser´ a criada uma u ´ nica vez, mantendo-se Programa¸caõ Orientada a Objeto com C++


654

B.5. SENTENCAS ¸ viva mesmo depois do encerramento da fun¸caõ. Se a vari´ avel n˜ ao for static, deixará de existir quando a fun¸caõ terminar.

Escopo de classe (C++): quando um objeto é declarado dentro de uma classe, como um atributo da classe. Se a especifica¸caõ de acesso for private, o objeto poder´ a ser acessado somente na classe em que foi declarado. Se a especifica¸caõ de acesso for protected, o objeto ser´ a vis´ıvel na classe em que foi declarado e nas classes derivadas. Se a especifica¸caõ de acesso for public, o objeto poder´ a ser acessado em todo o programa. Escopo de namespace: vimos no Cap´ıtulo 10 - Namespace, o uso de namespace para criar um espa¸co de nomes e o uso de using para mudar o escopo. Escopo global: quando declaramos uma vari´ avel fora de todos os blocos, fun¸co˜es e classes, ent˜ ao ela é uma vari´ avel global. Uma vari´ avel global pode ser acessada por todos os arquivos que compõem o programa a partir de sua declara¸caõ. Escopo de arquivo (static): uma vari´ avel ou fun¸caõ static global s´ o é vista no arquivo em que foi declarada (uso obsoleto de static, programas modernos utilizam namespaces. Veja Cap´ıtulo 10 - Namespace). Exemplo de vari´ aveis que s´ o s˜ ao vistas no arquivo em que foram declaradas: • Uma fun¸caõ inline declarada explicitamente. • Uma vari´ avel const. • Uma vari´ avel global est´ atica. Exemplo: // Vari´ avel est´ atica expl´ ıcita define o seu valor static int valor1 = 16; // Vari´ avel est´ atica impl´ ıcita assume o valor 0 static int valor2; // Fun¸ c~ ao est´ atica, vis´ ıvel somente neste arquivo static int soma(int x, int y) { return x + y; }

B.5

Senten¸cas

• Um objeto criado dentro de uma fun¸caõ ou bloco é eliminado quando a fun¸caõ ou o bloco termina, com exce¸caõ dos objetos est´ aticos, que s´ o s˜ ao destru´ıdos quando o programa termina. • A fun¸caõ abort() aborta o programa sem destruir os objetos est´ aticos. • Em C++, todo objeto const deve ser inicializado na sua declara¸caõ. Programa¸caõ Orientada a Objeto com C++


B.6. RESUMO DO CAPÍTULO

655

• Evite utilizar #define; utilize const de C++. • Uma declara¸caõ friend n˜ ao adiciona a fun¸caõ ao escopo da classe (Cap´ıtulo 20 - Friend). • Qualquer uso de um nome deve ser n˜ ao amb´ıguo em seu escopo. Depois de analisada a n˜ ao-ambig¨ uidade é que ser´ a considerada a acessibilidade da vari´ avel. Quando dizemos que uma vari´ avel n˜ ao deve ser amb´ıgua em seu escopo, queremos dizer que o compilador, ao passar por uma vari´ avel, deve ter certeza de qual vari´ avel você quer acessar, n˜ ao podendo ficar em d´ uvida. • A ordem em que os especificadores s˜ ao colocados n˜ ao é importante, mas o padr˜ ao é: Especificador de linkagem (static, extern), especificador de classe de armazenamento (auto, register, static), modificadores de acesso (const, volatile, mutable). • Vari´ aveis extern tem liga¸caõ externa. • Quando for acessar fun¸co˜es de outras linguagens, utilize o exemplo a seguir. Exemplo: extern "C++" retorno nomefun¸ c~ ao(par^ ametros); extern "C" retorno nomefun¸ c~ ao(par^ ametros); extern "FORTRAN" ...; // e n~ ao Fortran extern "Ada"...............; // e n~ ao ADA • Note que se uma fun¸caõ f() tem uma linkagem em "C", ent˜ ao um ponteiro para f() também deve ter linkagem de "C".

B.6


Neste apêndice aprendemos o uso dos especificadores de classes de armazenamento (auto, register e static). Do especificador de linkagem, que pode ser interna, externa ou sem linkagem. Aprendemos a usar a palavra-chave extern. Vimos que os modificadores de acesso de C++ s˜ ao const, volatile e mutable. Aprendemos que o escopo das vari´ aveis pode ser: local (de bloco), de fun¸caõ/método, de classe (C++), de namespace, de arquivo (static) ou global.

B.7

Exerc´ıcios

1. Monte um exemplo que use as palavras-chaves: auto, register, static. 2. Monte um exemplo que use as palavras-chaves: const, volatile e mutable. 3. Quais os problemas do programa abaixo? Exemplo: int main() { int x = 3; int r = x + y; { int y = 4; Programa¸caõ Orientada a Objeto com C++


B.7. EXERCÍCIOS

656 } cout < < r < < ’ ’ < < x < < ’ ’ < < y ; } 4. Monte um exemplo que use o conceito de extern. 5. Porque o uso de extern em C++ é obsoleto? 6. Modifique a listagem B.4. 7. Modifique as listagens B.2 e B.3.



Apˆ endice C

Operadores Neste cap´ıtulo apresentaremos quais os operadores de C/C++ e sua ordem de precedência. Os operadores est˜ ao divididos em: • operadores aritméticos (se¸caõ C.1.1), • de atribui¸caõ (se¸caõ C.1.2), • compostos (se¸caõ C.1.3), • relacionais (se¸caõ C.1.4), • l´ ogicos (se¸caõ C.1.5), • de bits (se¸caõ C.1.6), • condicional (se¸caõ C.1.7), • incremento e decremento (se¸caõ C.1.8), • v´ırgula (se¸caõ C.1.9), • operador módulo % (se¸caõ C.1.10), • new (se¸caõ C.1.11), • delete (se¸caõ C.1.12), • typedef (se¸caõ C.1.13), • sizeof (se¸caõ C.1.14), • size_t (se¸caõ C.1.15), • resolu¸caõ de escopo (se¸caõ C.1.16). 657

˜ AOS OPERADORES C.1. INTRODUC ¸ AO

658

C.1

Introdu¸ c˜ ao aos operadores

Os operadores definidos pela linguagem C++ podem ser utilizados para realizar determinada opera¸caõ entre objetos. Todo operador tem uma precedêndia. Operadores de precedência alta s˜ ao executados antes dos operadores de precedência baixa. Apresentamos na Tabela C.1 a precedência dos operadores. O operador de mais alta prioridade é o de resolu¸caõ de escopo (::), a seguir os parênteses () e depois os colchetes []. O operador de mais baixa prioridade é o operador v´ırgula(,). Nota: normalmente alteramos a ordem de precedência de determinada opera¸caõ matemática utilizando parenteses extras.

1 :: () [] . -> i++ i- typeid

C.1.1

Tabela C.1: Precedência dos 2 3 4 dynamic cast ! delete static cast ˜ delete[] reinterpret cast (tipo) .* const cast sizeof ->* ++i & * - -i * / + new % new[] +

operadores. 5 6 != < < & and >> ˆ or < | ou <= && e > || ou >= ?: == =

7 += -= *= /= %= &= ˆ= |=

8 < <= > >= ,

Operadores aritm´ eticos (+,-,*,/,%)

Os operadores aritméticos como +,-,*,/ s˜ ao usuais em diversas linguagens de programa¸caõ. C acrescentou o operador módulo (%), o qual retorna o resto de uma divisão. Prot´ otipo +

Soma.

-

Subtra¸ca õ.

*

Multiplica¸ca õ.

/

Divis˜ ao.

%

Resto da divis˜ ao.

Veja a seguir um exemplo: Exemplo: #include using namespace std; int main() { int A = 1, B = 2, C A = B + C; // A = 18 - C; // B = 4 *( A / C); //

= A A B

3; = 5 = 15 = 20



˜ AOS OPERADORES C.1. INTRODUC ¸ AO A = B % C; return 0;

659

// A = 5

} Dica: a exponencia¸caõ xy pode ser realizada com a fun¸caõ pow(x,y) do arquivo de cabe¸calho . O uso de x^y ou x**y n˜ ao é válido em C++.

C.1.2

Operadores de atribui¸c˜ ao (=)

No exemplo a seguir, o operador de atribui¸caõ é utilizado para atribuir o conte´ udo de B a A. Exemplo: A = B; A = B = C = D = 0;

C.1.3

Operadores compostos (+=, -=, *=, /=)

Os operadores compostos aumentam a eficiência dos programas, pois s´ o acessam o objeto uma u ´ nica vez. Exemplo: A += B; A -= B; A /= B; A *= B;

C.1.4

// // // //

O O O O

mesmo mesmo mesmo mesmo

que que que que

A A A A

= = = =

A A A A

+ / *

B; B; B; B;

Operadores relacionais (>, >=, <, <=, ==, !=)

Os operadores relacionais s˜ ao utilizados para comparar objetos. Veja a seguir seu prot´ otipo: Prot´ otipo >

maior.

>=

maior ou igual.

<

menor.

<=

menor ou igual.

==

igual.

!=

diferente.

Um exemplo de uso dos operadores de compara¸caõ é apresentado na listagem C.1. Listing C.1: Usando os operadores de compara¸caõ, incremento, decremento, e os operadores compostos. 1 2 3 4 5 6 7 8 9

# include < iostream > void compara ( int a , int b ) ;

// Fun¸ c~ ao

int main () { int a , b ; std :: cout << " Entre com dois numeros inteiros ( a espa¸ c o b enter ) : " ; // O b s e r v e abaixo a l e i t u r a de duas v a r i a v e i s em uma unica linha .




660 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// Isto deve ser e v i t a d o. std :: cin >> a >> b ; std :: cin . get () ; compara (a , b ) ; a += 5; compara (a , b ) ; b - -; compara (a , b ) ; a *= ++ b ; compara (a , b ) ; return 0;

// Pega o enter // O p e r a d o r c o m p o s t o . // O p e r a d o r de d e c r e m e n t o . // O p e r a d o r de i n c r e m e n t o e c o m p o s t o .

} void compara ( int a , int b ) { if ( a == b ) // O p e r a d o r de c o m p a r a ¸ c~ ao std :: cout << a << " == " < b ) std :: cout << a << " > " <= b ) std :: cout << a << " >= " < 4 8 >= 4 8 != 3 8 > 3 8 >= 3 32 != 4 32 > 4 32 >= 4

C.1.5

Operadores l´ ogicos (&&, ||, !, ==, !=)

Os operadores l´ ogicos s˜ ao utilizados para testar determinadas condi¸co˜es. Prot´ otipo &&

e.

and

e.

||

ou.

or

ou.

!

nega¸ca õ, inverte o resultado.

not

nega¸ca õ, inverte o resultado.

Na listagem C.2, se x for maior que y ou x maior que z, faz x = y + z; Programa¸caõ Orientada a Objeto com C++



661

Listing C.2: Usando os operadores l´ ogicos. 1 2 3 4 5 6 7 8 9 10 11 12 13 14

# include < iostream > int main () { int x = 5; int y = 3;

int z = 4;

if ( x > y || x > z ) x = y + z; std :: cout << " x = " << x << std :: endl ; if ( x < y or x < z ) x = y + z; std :: cout << " x = " << x << std :: endl ; return 0; }

C.1.6

Operadores de bits (&, |)

Os operadores de bits s˜ ao utilizados para testar determinadas condi¸co˜es. Prot´ otipo &

Opera¸ca õ and para bits. Se os bits x e y s˜ ao 1, ent˜ ao retorna 1.

bitand

Opera¸ca õ and para bits.

^

Opera¸ca õ ou exclusiva. Se os bits x e y forem diferentes, retorna 1.

xor

Opera¸ca õ ou exclusiva.

|

Opera¸ca õ ou inclusiva. Se os bits x e y s˜ ao 0 retorna 0.

bitor

Opera¸ca õ ou inclusiva.

>>

Rotaciona bits para direita.

<<

Rotaciona bits para esquerda.

Veja exemplo de uso de operadores de bits na listagem C.3. Listing C.3: Usando os operadores de bits. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# include < iostream > using namespace std ; int main () { int n u m e r o I n t e i r o ; int mascara = 1 << 31; // Um l o o p i n g i n f i n i t o while ( true ) { cout << " \ nDigite um n´ u mero inteiro ( ctrl + c para encerrar ) : \ n " ; cin >> n u m e r o I n t e i r o ; cout << " N´ u mero = " << n u m e r o I n t e i r o << " , e sua r e p r e s e n t a c ¸a ~ o em bits = " ; // P e r c o r r e os 32 bits for ( int i = 1; i <= 32; i ++) { // C o m p a r a n´ u mero com a m ´ ascara char ch = ( n u m e r o I n t e i r o & mascara ) ? ’1 ’: ’0 ’;




662 22 23 24 25 26 27 28 29 30 31

// Envia r e s u l t a d o para tela cout << ch ; // R o t a c i o n a o n´ u mero em 1 bit a e s q u e r d a n u m e r o I n t e i r o < <= 1; // Espa¸ c o para s e p a r a r dados if ( i %8 == 0 && i != 32) cout << ’ ’ ; } } return 0; } Digite 0 N´ u mero Digite 1 N´ u mero Digite 10 N´ u mero Digite

C.1.7

um n´ u mero inteiro ( ctrl + c para encerrar ) : = 0 , e sua r e p r e s e n t a c ¸a ~ o em bits = 00000000 00000000 00000000 00000000 um n´ u mero inteiro ( ctrl + c para encerrar ) : = 1 , e sua r e p r e s e n t a c ¸a ~ o em bits = 00000000 00000000 00000000 00000001 um n´ u mero inteiro ( ctrl + c para encerrar ) : = 10 , e sua r e p r e s e n t a c ¸a ~ o em bits = 00000000 00000000 00000000 00001010 um n´ u mero inteiro ( ctrl + c para encerrar ) :

Operador condicional (?)

O operador condicional é o u ´ nico operador tern´ ario do C++. Veja o prot´ otipo. Se a condi¸caõ a a express˜ ao falsa. for verdadeira, executar´ a a express˜ ao verdadeira, e se for falsa, executar´ Prot´ otipo: ao falsa); (condi¸ca õ)? (express˜ ao verdadeira): (express˜ Exemplo: int maior = x > y ? x : y;

C.1.8

Operador incremento (++) e decremento (--)

Se você tem uma vari´ avel inteira e quer increment´ a-la de 1 (somar a 1), utilize o operador de incremento ++; para diminuir de 1, utilize o operador decremento --. Para obter: valor = valor + 1; , fa¸ca: ++valor;. Para obter: valor = valor - 1;, fa¸ca: --valor;. As opera¸co˜es de incremento/decremento podem ser do tipo postfix ou prefix, veja exemplo. A opera¸caõ postfix (++y), utiliza o valor de y para calcular x e depois incrementa y. A opera¸caõ prefix (++y), primeiro incrementa o valor de y e depois utiliza o valor de y para calcular z. Exemplo: int y = 5; // Define y = 5. int x = 5 + y++; // Faz x = 10 e depois y = 6. int z = 5 * ++y; // Faz y = 7 e depois z = 5*7 = 35. Um exemplo de uso do operador incremento é apresentado na listagem C.4. Listing C.4: Usando operador de incremento. 1 2 3 4

# include < iostream > using namespace std ; int main ()



˜ AOS OPERADORES C.1. INTRODUC ¸ AO 5 6 7 8 9 10 11 12 13 14 15

663

{ int contador = 0; cout << contador << endl << ( contador ++) << endl << contador << endl ; contador = 0; cout << contador << endl << (++ contador ) << endl << contador << endl ; return 0;

// E s c r e v e 0 na tela // E s c r e v e 0 e depois faz c o n t a d o r =1 // E s c r e v e 1 // E s c r e v e 0 // I n c r e m e n t a c o n t a d o r e e s c r e v e na tela // E s c r e v e 1

}

C.1.9

Operador v´ırgula (a,b)

O operador v´ırgula avalia duas express˜ oes onde a sintaxe s´ o permite uma. Prot´ otipo: ao da direita) (express˜ ao da esquerda),(express˜ Exemplo: int x,y,z; for( int min = 0 , int max = 10 ; min < max ; min++ , { cout < < min < < " " < < max < < " "; }

max- )

Observe dentro do for a declara¸caõ de dois inteiros utilizando o separador v´ırgula: int min = 0 , int max = 10

C.1.10

Operador m´ odulo (%)

O operador módulo (%) retorna o resto de uma divisão. No prot´ otipo a seguir, o resultado é o resto da divisão de a por b. Prot´ otipo: A%B

Retorna o resto da divis˜ ao de A por B.

Veja no exemplo a seguir a utiliza¸caõ da fun¸caõ rand() da biblioteca matemática-padr˜ ao de C e do operador módulo. Exemplo: #include int a = 7, b = 4; int x = a % b; // x = 3 ´ e o resto da divis~ ao de a por b x = rand() % 6; // x ´ e um valor rand^ omico entre 0 e 5 // N´ umero rand^ omico entre min e min + max int n = min + rand() % (max + 1 -min); Veja na listagem C.5 exemplo de uso do operador módulo (%) e do operador tern´ ario (?). Programa¸caõ Orientada a Objeto com C++



664

Listing C.5: Usando operador módulo % e operador tern´ ario ? 1 2 3 4 5 6 7 8 9 10 11 12 13

# include < iostream > int main () { int contador = 1; std :: cout << " 5%4 int x = 5; int y = 3; int z = x > y ? x std :: cout << " \ nx << " z =

= " << (5 % 4) << std :: endl ;

: y; = 5, y = 3, z = x > y ? x : y ;" " << z << std :: endl ;

return 0; } 5%4=1 x =5 , y =3 , z = x > y ? x : y ; z =5

C.1.11

Operador new

Veja descri¸caõ do operador new na se¸caõ 15.3.1.

C.1.12

Operador delete

Veja descri¸caõ do operador delete na se¸caõ 15.3.2.

C.1.13

Operador typedef

Veja descri¸caõ do operador typedef na se¸caõ 9.5.1.

C.1.14

Operador sizeof

Veja a descri¸caõ do operador sizeof na se¸caõ 9.5.3. Veja na listagem ?? exemplo de uso de sizeof.

C.1.15

Operador size_t

Veja descri¸caõ do operador size_t na se¸caõ 9.5.2.

C.1.16

Operador de resolu¸c˜ ao de escopo (::)

O operador de resolu¸caõ de escopo é utilizado para informar o compilador que queremos acessar a vari´ avel global. Se utilizarmos o operador de resolu¸caõ de escopo dentro de uma fun¸caõ, estaremos acessando a vari´ avel global externa a` fun¸caõ. Veja o exemplo: Exemplo: int x = 70; int main() { int x = 56; int y = x; // y = 56 int z = ::x; // z = 70 pega o x externo a fun¸ c~ ao main() Programa¸caõ Orientada a Objeto com C++


C.2. SENTENCAS ¸ PARA OPERADORES

665

return 0; }

C.2

Senten¸cas para operadores

• Performance: em testes de compara¸caõ, sempre teste em primeiro lugar as condi¸co˜es mais prováveis. • BUG: é um erro comum utilizar = para comparar dois valores, como na express˜ ao if(x = 3); quando o correto é if(x == 3) ´ um erro comum utilizar =! em vez de !=. • E • Para inverter um bool, utilize !. • Se precisar, utilize parênteses extras para deixar o c´ odigo mais claro. • N˜ ao confunda um operador sobre bits (& e |) com operadores l´ ogicos (&& e ||). • bool pode assumir true(!= 0) ou false(== 0); assim 1 é true, 5 é true, 0 é false.

C.3


Neste apêndice aprendemos a usar o operadores de C++. Os operadores aritméticos, de atribui¸caõ, compostos, relacionais, l´ ogicos, de bits, condicional, de incremento e decremento, v´ırgula, operador módulo. Operadores de aloca¸caõ e dele¸caõ de memória (new e delete). O uso de typedef para criar apelidos, e o uso de sizeof e size_t. Finalmente, vimos o operador de resolu¸caõ de escopo.

C.4

Exerc´ıcios

1. Dados os operadores (), new e ==, qual tem maior precedência? 2. Monte um exemplo que utilize todos os operadores aritméticos. 3. Explique a diferen¸ca entre o operador de atribui¸caõ e os operadores compostos. 4. Compilar e rodar o exemplo da listagem C.1, usando diferentes valores de a e b. Depois, modifique o exemplo da listagem C.1. 5. Modifique o exemplo da listagem C.2. 6. Modifique o exemplo da listagem C.3. 7. Modifique o exemplo da listagem C.4. 8. Modifique o exemplo da listagem C.5. 9. Modifique o exemplo da listagem ??.



666

C.4. EXERCÍCIOS



Apˆ endice D

Estruturas de Controle Apresenta-se neste apêndice uma introdu¸caõ às estruturas de controle (se¸caõ D.1). Veremos as estruturas condicionais (se¸caõ D.2) e as estruturas de repeti¸caõ (se¸caõ D.3). No final do cap´ıtulo s˜ ao listados alguns programas que mostram o uso prático das estruturas de controle.

D.1

Introdu¸ c˜ ao ` as estruturas de controle

Um programa sem estruturas de controle é um programa sequêncial, em que uma linha é executada ap´ os a outra. De um modo geral as linguagens de programa¸caõ oferecem dois tipos de estruturas de controle, ` as condicionais e as de repeti¸caõ. Ambas podem ser utilizadas para alterar a sequência de execu¸caõ do programa. Nas estruturas condicionais a sequência de execu¸caõ é alterada em fun¸caõ de decis˜ oes que s˜ ao tomadas durante a execu¸caõ do programa. J´ a as estruturas de repeti¸caõ s˜ ao utilizadas para realiza¸caõ de repeti¸co˜es (la¸cos/loopings) de um determinado bloco de c´ odigo. As estruturas de controle de C++ s˜ ao: • Estruturas condicionais – if (veja se¸caõ D.2.1), – if..else (veja se¸caõ D.2.2), – if..else..if..else (veja se¸caõ D.2.3), – switch..case (veja se¸caõ D.2.4), – operador? (veja se¸caõ D.2.5). • Estruturas de repeti¸caõ – for (veja se¸caõ D.3.1), – while (veja se¸caõ D.3.2), – do..while (veja se¸caõ D.3.3), – break (veja se¸caõ D.3.4), – continue (veja se¸caõ D.3.5). Bem, antes de come¸car vale a pena lembrar que uma express˜ ao é verdadeira se retorna um n´ umero diferente de 0 (ou true), e é falsa se retorna 0 (ou false). 667

668

D.2. ESTRUTURAS CONDICIONAIS

D.2

Estruturas condicionais

Nas estruturas condicionais a sequência de execu¸caõ é alterada em fun¸caõ de decis˜ oes que s˜ ao tomadas durante a execu¸caõ do programa.

D.2.1

if

Um instru¸caõ if é utilizada para garantir que determinada a¸caõ s´ o ser´ a executada se a express˜ ao condicional for verdadeira. No prot´ otipo a seguir, se a express˜ ao for verdadeira vai executar a próximo linha (ou bloco). Prot´ otipo: if(express˜ ao condicional) a¸ca õ; Prot´ otipo: if(express˜ ao condicional) { a¸ca õ1; a¸ca õ2;...a¸ca õN; } Exemplo: int x = 0, y = 1; if( x > y ) cout < < x > y. ;

D.2.2

if.....else

Uma estrutura de controle do tipo if..else é utilizada quando a a¸caõ a ser executada depende de uma condi¸caõ. Veja no prot´ otipo a seguir que numa estrutura de controle do tipo if..else, se a express˜ ao for verdadeira vai executar a a¸ c~ ao1, se for falsa vai executar a a¸ c~ ao2. No exemplo, como x n˜ ao é maior ou igual a y, vai imprimir x < y. Prot´ otipo: if(express˜ ao condicional) a¸ca õ1; else a¸ca õ2; Exemplo: int x = 0; int y = 1; if( x >= y ) { cout < < "x >= y"< < endl; } else { cout < < "x < y"< < endl; } Programa¸caõ Orientada a Objeto com C++


D.2. ESTRUTURAS CONDICIONAIS

D.2.3

669

if......else if......else if......else

Outra estrutura de controle condicional, if..else..if..., é utilizada quando a a¸caõ a ser executada além de depender de uma condi¸caõ espec´ıfica, esta relacionada as demais condi¸co˜es e a¸co˜es. O uso de if..else..if..else, produz um c´ odigo r´ apido. Sempre coloque no in´ıcio da sequência de if..else os ´ıtens com maior probabilidade de ocorrência. O primeiro if que for verdadeiro vai ser executado, os demais s˜ ao pulados. Cada else esta associado ao if imediatamente acima. Prot´ otipo: if(express˜ ao condicional1) ...a¸ca õ1...; else if (express˜ ao condicional2) a¸ca õ2; ... else if (express˜ ao condicional n) a¸ca õ n; No exemplo a seguir se a idade é menor do que 12 ent˜ ao a sa´ıda ser´ a ”crian¸ca”. Se a idade é maior que 12 e menor do que 18 ent˜ ao a sa´ıda ser´ a ”adolescente”. Se a idade for maior que 18 a sa´ıda ser´ a ”adulto”. Exemplo: if( idade < 12 ) cout < < "crian¸ ca"; else if ( idade < 18 ) cout < < "adolescente"; else cout < < "adulto";

D.2.4

switch....case

A instru¸caõ switch case é utilizada quando se deseja fazer uma sele¸caõ entre uma série de ´ semelhante a uma sequência if..else. Se nenhuma op¸caõ satisfazer a condi¸caõ vai op¸co˜es. E realizar a instru¸caõ default. Veja prot´ otipo a seguir. Note que resposta deve ser inteiro ou ser convertido para inteiro. Observe que o fim de uma instru¸caõ case: n˜ ao é automaticamente delimitado pelo in´ıcio do próximo case, precisamos incluir a palavra-chave break. Prot´ otipo: switch (resposta) { case ’a’: intru¸co ˜es1; break; case ’b’: intru¸co ˜es2; break; default: instru¸ca õ default; }

// Se resposta == ’a’ // Realiza instru¸co ˜es 1 // Encerra o switch // Se resposta == ’b’ // Realiza instru¸co ˜es 2 // Encerra o switch // Opcional (sempre a u ´ltima)

A listagem D.1 mostra o uso de switch. Veremos o uso de for na se¸caõ D.3.1. Programa¸caõ Orientada a Objeto com C++


670

D.2. ESTRUTURAS CONDICIONAIS Listing D.1: Usando switch.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

# include < vector > # include < iostream > # include < iomanip > # include < string > using namespace std ; int main () { vector < string > time ; time . push_back ( string time . push_back ( string time . push_back ( string time . push_back ( string

( " Palmeiras " ) ) ; ( " Corintians " ) ) ; ( " S~ a o Paulo " ) ) ; ( " Santos " ) ) ;

cout << " Para encerrar , digite o caractere de fim de arquivo .\ n " << " No Windows / DOS ( ctrl + z ) no GNU / Linux , Unix ( ctrl + d ) :\ n " << " --> Qual o seu time do cora¸ ca ~ o < - -:\ n " ; for ( int i = 0; i < time . size () ; i ++) cout << setw (20) << time [ i ] << " ( " << setw (2) <> resp ) { cin . get () ; string osite ( " O site de seu time est´ a em : \ n " ) ; switch ( resp ) { case 0: cout << " Parab´ e ns , voc^ e escolheu um t e t r a c a m p e a ~ o Brasileiro . " << osite << " http :// www . palmeiras . com . br / " << endl ; break ; case 1: cout << " Parab´ e ns , voc^ e escolheu um tricampe~ a o Brasileiro . " << osite << " http :// www . corinthia n s . com . br / " << endl ; break ; case 2: cout << " Parab´ e ns , voc^ e escolheu um tricampe~ a o Brasileiro " << osite << " http :// www . spfc . com . br / " << endl ; break ; case 3: cout << " Parab´ e ns , voc^ e escolheu um campe~ a o Brasileiro . " << osite << " http :// www . s a n t o s f u t e b o l c l u b e . com . br / " << endl ; break ; default : cout << " Entrou na op¸ ca ~ o default do switch , ou seja , voc^ e entrou " << " com uma op¸ ca ~ o errada , repita a opera¸ ca ~ o . " << endl ; break ; // Break o p c i o n a l } } return 0; } Para encerrar , digite o caracter de fim de arquivo . No windows / DOS ( ctrl + z ) no unix / linux / mac ( ctrl + d ) : --> Qual o seu time do cora¸ ca ~ o < - -:



˜ D.3. ESTRUTURAS DE REPETIC ¸ AO

671

Palmeiras ( 0) : Corintians ( 1) : S~ a o Paulo ( 2) : Santos ( 3) : 0 Parab´ e ns , voc^ e escolheu um tetra - campe~ a o Brasileiro . O site de seu time esta em : http :// www . palmeiras . com . br /

D.2.5

express~ ao_condicional?

a¸ c~ ao_verdadeira :

a¸ c~ ao_falsa;

O operador condicional ? é o u ´ nico operador tern´ ario do C++, o mesmo foi descrito na se¸caõ C.1.7.

D.3

Estruturas de repeti¸ c˜ ao

Nas estruturas de repeti¸caõ um determinado bloco de c´ odigo é repetido um determinado n´ umero de vezes. As estruturas de repeti¸caõ s˜ ao utilizadas para realiza¸caõ la¸cos/loopings. O objetivo das estruturas de controle é possibilitar o controle e as tomadas de decis˜ oes nos programas.

D.3.1

for ( in´ ıcializa¸ c~ ao ; condi¸ c~ ao ; a¸ c~ ao2 ) a¸ c~ ao1;

O for é uma estrutura de controle de repeti¸caõ utilizado para a realiza¸caõ de la¸cos (loopings). O prot´ otipo a seguir ilustra a forma de uso do for. O primeiro ´ıtem é a inicializa¸caõ da vari´ avel de controle do la¸co. O segundo ´ıtem é a condi¸caõ utilizada para continuar no la¸co. Se a condi¸caõ for falsa o la¸co é encerrado. O terceiro ´ıtem, a a¸ c~ ao1 é a opera¸caõ que vai ser executada a cada la¸co. J´ a a a¸ c~ ao2, é utilizada, geralmente, para modificar a vari´ avel de controle. Prot´ otipo: for( inicializa¸ca õ; condi¸ca õ; a¸ca õ2 ) a¸ca õ1; No exemplo abaixo, cria uma vari´ avel cont do tipo int e inicializa com o valor 3. A seguir testa se cont é menor que 20. Depois do teste, entra dentro do bloco e executa a linha (cout < < "\nO valor de cont ´ e agora = " < < cont;). Depois de realizada a execu¸caõ do bloco, a a¸ c~ ao2 é executada, isto é, cont++. Exemplo: for ( int cont = 3; cont < 20; cont++ ) { cout < < "\nO valor de cont ´ e agora = " < < cont ; } cout < < \nfor encerrado < < endl; Veja abaixo a seq¨ uencia de execu¸caõ: int cont = 3; cont < 20 ? cout < < "\nO valor de cont ´ e agora = " < < cont; cont++; Programa¸caõ Orientada a Objeto com C++



672

cont < 20 ? cout < < "\nO valor de cont ´ e agora = " < < cont; cont ++; cont < 20 ? cout < < "\nO valor de cont ´ e agora = " < < cont; cont++; .... // Quando cont = = 20 o for ´ e encerrado. cout < < \nfor encerrado < < endl; Reveja agora as listagens 8.4 e 8.5.

D.3.2

while (condi¸ c~ ao) {a¸ c~ ao;};

Enquanto a condi¸caõ for verdadeira executa a a¸caõ. O comando while pode ser usado no lugar de for, veja o prot´ otipo e exemplo a seguir. Prot´ otipo: while ( condi¸ca õ ) { a¸ca õ; }; Exemplo: // O for abaixo, for( inicio ; condi¸ c~ ao ; a¸ c~ ao2 ) { a¸ c~ ao1; } // Pode ser realizado usando while desta forma inicio; while( condi¸ c~ ao ) { a¸ c~ ao1; a¸ c~ ao2; } Veja exemplos de uso de while nas listagens 8.6 e D.2. Listing D.2: Usando while. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include < iostream > using std :: cout ; using std :: endl ; int main () { int y , x = 1 , total = 0; while ( x <= 5) { y = x * x; cout << x << " \ t " << y << endl ; total += y ; ++ x ; } cout << " Total = " << total << endl ; return 0; }




673

1 1 2 4 3 9 4 16 5 25 Total = 55

D.3.3

do {a¸ c~ ao} while (condi¸ c~ ao);

O comando do while, realiza a a¸caõ e somente depois testa a condi¸caõ. Desta forma a a¸caõ é executada pelo menos uma vez. Veja a seguir o prot´ otipo e na listagem D.3 um exemplo. Prot´ otipo: do { a¸ca õ; } while ( express˜ ao condicional ); Listing D.3: Usando do..while. 1 2 3 4 5 6 7 8 9 10 11 12 13

# include < iostream > int main () { int i = 1; do { // Sempre r e a l i z a o l o o p i n g pelo menos 1 vez . std :: cout << i << " " ; } while (++ i <= 10) ; std :: cout << std :: endl ; return 0; } 1

2

3

D.3.4

4

5

6

7

8

9

10

break

Um break pode ser usado dentro de um for, em um while, do...while, ou switch. Quando um break é encontrado, o bloco é encerrado. No prot´ otipo a seguir, se a condi¸caõ2 for verdadeira a a¸ c~ ao2 n˜ ao ser´ a executada, e o for é encerrado. Prot´ otipo: for( inicio; condi¸ca õ ; a¸ca õ3 ) { a¸ca õ1; if( condi¸ca õ2 ) break; a¸ca õ2; } Veja a seguir um exemplo. Exemplo: for( int i = 0; i < 10 ; i++ ) { Programa¸caõ Orientada a Objeto com C++



674 cout < < "valor de i = " < < i < < endl; if( i == 5 ) break; cout < < "Passou pelo break" < < endl; }

D.3.5

continue

O controle continue (usado em for, while, do..while), faz com que o programa pule as próximas linhas e prossiga na express˜ ao que controla o la¸co. Isto é, quando continue é executado todos os próximos passos s˜ ao pulados e o próximo la¸co é executado. Se assemelha a um comando goto. No prot´ otipo a seguir, se a condi¸caõ for verdadeira, a a¸ c~ ao2 n˜ ao é executada, o próximo passo a ser executado é a a¸ c~ ao3 e a seguir a condi¸caõ. Prot´ otipo: for( inicio; condi¸ca õ; a¸ca õ3 ) { a¸ca õ1; if( condi¸ca õ ) continue; a¸ca õ2; } Veja exemplo de uso de break e continue na listagem D.4. Listing D.4: Usando break, continue, do..while, e switch. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# include < iostream > using namespace std ; void T e s t a n d o _ b r e a k () ; void T e s t a n d o _ c o n t i n u e () ; int main () { char resp ; do { cout << " Testar o break ( b ) ou o continue ( c ) , ( q ) para sair : " ; cin . get ( resp ) ; cin . get () ; switch ( resp ) { case ’b ’: case ’B ’: T e s t a n d o _ b r e a k () ; break ; case ’c ’: case ’C ’: T e s t a n d o _ c o n t i n u e () ; break ; case ’q ’: case ’Q ’: cout << " Tchau . " << endl ; break ;



D.4. SENTENCAS ¸ PARA ESTRUTURAS DE CONTROLE 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

675

default : cout << " Op¸ ca ~ o inv´ a lida : " << endl ; } } while ( resp != ’q ’ && resp != ’Q ’ ) ; return 0; } void T e s t a n d o _ b r e a k () { for ( int x = 1; x <= 10; x ++ ) { if ( x == 5) break ; // E n c e r r a o l o o p i n g quando x ==5 cout << x << ’ ’; } cout << " \ nQuando x ==5 , executa o break e sai do looping . " << endl ; } void T e s t a n d o _ c o n t i n u e () { for ( int x = 1; x <= 20; x += 1 ) { if ( x == 5) continue ; // Pula para p r ´ o x i m o passo do l o o p i n g quando x ==5 cout << x << " ; " ; } cout << " \ nUm continue continua o looping , mas pula todas as linhas abaixo . " << " \ nObserve acima que n~ a o imprimiu o n´ u mero 5. " << endl ; } Testar o break ( b ) ou o continue ( c ) , ( q ) para sair : b 1 2 3 4 Quando x ==5 , executa o break e sai do looping . Testar o break ( b ) ou o continue ( c ) , ( q ) para sair : c 1;2;3;4;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20; Um continue continua o looping , mas pula todas as linhas abaixo . Observe acima que n~ a o imprimiu o n´ u mero 5. Testar o break ( b ) ou o continue ( c ) , ( q ) para sair : q Tchau .

D.4

Senten¸cas para estruturas de controle

• As estruturas de controle s˜ ao utilizadas em la¸cos (loopings), na realiza¸caõ de contagens, na escolha entre diferentes blocos de instru¸co˜es. • Os objetos declarados dentro do for s´ o s˜ ao vis´ıveis dentro do for. • Evite o uso de do...while();. • Enquanto break encerra o la¸co, continue continua sem executar as linhas que est˜ ao abaixo.

D.5


Neste apêndice aprendemos a usar as estruturas de controle de C++. As estruturas condicionais, if, if..else, if..else..if..else, switch..case, e o operador ?. Vimos ainda as Programa¸caõ Orientada a Objeto com C++


D.6. EXERCÍCIOS

676 estruturas de repeti¸caõ, for, while, do..while, break, e continue.

D.6

Exerc´ıcios

1. Comece modificando os exemplos das listagens deste cap´ıtulo. 2. Na listagem D.1 acrescente dados do seu time de cora¸caõ. 3. Na listagem D.1 elimine os break e veja o que acontece. 4. Na listagem 8.4 mude os valores iniciais e finais do la¸co e veja o que acontece. 5. Modifique a listagem 8.5. Fa¸ca a mesma coisa usando dentro do primeiro for um while. 6. Modifique a listagem 8.6 acrescentando uma mensagem de erro e um break caso o valor da potencia ultrapasse o limite suportado para um int. 7. Na listagem D.2 modifique os valores iniciais de x, e a condi¸caõ de sa´ıda do while. Pense em acrescentar dentro do while um for. 8. Na listagem D.3 modifique o valor inicial de i e a condi¸caõ de sa´ıda. Pe¸ca para o usuário entrar com estes dados. 9. Monte um pequeno programa de cadastro de alunos de um colégio. O programa deve: (a) ter fun¸co˜es para adicionar/eliminar novos alunos. (b) ter uma fun¸caõ de entrada que deve solicitar os seguintes dados: Nome do aluno, idade, n´ umero de registro no colégio, coeficienteDeRendimento. (c) ter duas fun¸co˜es de sa´ıda. A primeira deve mostrar na tela a lista de alunos em ordem crescente usando a idade como parˆ ametro classificador. A segunda fun¸caõ deve usar o n´ umero de registro como parˆ ametro classificador. (d) a sele¸caõ do tipo de fun¸caõ a ser executada deve ser feita utilizando-se um switch. 10. Para o programa acima descrito monte uma fun¸caõ que recebe dois alunos como parˆ ametros. A fun¸caõ deve imprimir na tela os dados do aluno que tem o maior coeficienteDeRendimento. Esta fun¸caõ ser´ a utilizada para efeitos de classifica¸caõ dos alunos quando os mesmos solicitarem alguma bolsa de aux´ılio. 11. Para o programa acima descrito monte uma fun¸caõ que mostra na tela a lista de alunos aprovados (notaM´ edia >= 6) e a lista de alunos reprovados (notaM´ edia < 6). Nota: você encontra na referência [Holloway, 2006], diversos exemplos de algoritmos em C++, e nas referências [Cormen et al., 2002, Boente, 2006] exemplos genéricos de algoritmos.



Apˆ endice E

Fun¸c˜ oes - Uso Avan¸ cado Veremos neste apêndice uma complementa¸caõ dos conceitos vistos no Cap´ıtulo 13 - Métodos. Iniciamos apresentando a fun¸caõ main() e a entrada na linha de comando (se¸caõ E.1). A seguir discutimos o processamento dos parˆ ametros de main() com getopt() (se¸caõ E.2). Veremos ainda as fun¸co˜es recursivas, (se¸caõ E.3) e o uso de elipse ... em fun¸co˜es (se¸caõ E.4). Finalmente veremos algumas senten¸cas para fun¸co˜es (se¸caõ E.5).

E.1

A fun¸c˜ ao main() e a entrada na linha de comando

A fun¸caõ principal de um programa é chamada main(). Quando um programa é executado na linha de comando do DOS, Unix, GNU/Linux, Mac OS X, Windows, o sistema operacional chama a fun¸caõ main() do programa e passa para o programa dois argumentos: o texto da linha de comando e o n´ umero de strings da linha de comando. Assim, você pode utilizar a linha de comando para entrada de informa¸co˜es para seu programa. Veja a seguir o prot´ otipo da fun¸caõ main(). O parˆ ametro argc é o n´ umero de elementos da linha de comando e argv[] o vetor para as strings digitadas na linha de comando. Prot´ otipo: int main(int argc, const char *argv[]) {...... return 0;} No exemplo a seguir, o programa recebe um vetor com as strings {”cp”, ”funcoes.lyx”, ”funcoes.lyx~”} e o n´ umero de argumentos da linha de comando que é 3. Exemplo: // Na linha de comando do GNU/Linux digitou-se: cp funcoes.lyx funcoes.lyx~ // O programa interpreta o seguinte: // argc = 3 // argv[0] = "cp" // argv[1] = "funcoes.lyx" // argv[2] = "funcoes.lyx~" Veja na listagem E.1 exemplo de uso de entrada na linha de comando. Listing E.1: Fun¸caõ main() e a entrada na linha de comando. 1 2

# include < iostream > using namespace std ;

677

ˆ E.2. PROCESSANDO PARAMETROS DE MAIN() COM GETOPT()

678 3 4 5 6 7 8 9 10 11

int main ( int argc , char ** argv ) { cout << " argc = " << argc << endl ; int cont = argc ; while ( cont - -) cout << " argv [ " << cont << " ]= " << argv [ cont ] << endl ; return 0; } [ b u e n o @ s u p o r t e 3 Parte - VI ] $ ./ a . out opcao1 opcao2 opcao3 argc =4 argv [3]= opcao3 argv [2]= opcao2 argv [1]= opcao1 argv [0]=./ a . out

E.2

Processando parˆ ametros de main() com getopt()

A fun¸caõ getopt(), declarada no arquivo de cabe¸calho /usr/include/unistd.h, fornece um mecanismo simples para processar a linha de comando. Veja a seguir o prot´ otipo da fun¸caõ getopt(). Como existem casos e necessidades especiais, também foram definidas um conjunto de vari´ aveis globais que s˜ ao utilizadas por getopt(): Prot´ otipo: extern char *optarg; // Ponteiro para pr´ oxima string extern int optind; // Indice para pr´ oximo argumento extern int opterr; // Flag de erro extern int optopt; // Caracter inv´ alido const char* optstring; // Lista de parˆ ametros v´ alidos int getopt ( int argc, char* argv[], const char* optstring ); A fun¸caõ getopt() recebe os parˆ ametros argc e argv[], e uma string de C (const char* optstring) com a lista de parˆ ametros válidos (ex: ”-abc:d”). Se o parˆ ametro é válido o mesmo é retornado. Se o parˆ ametro é inválido o retorno é o caracter ’?’ e optopt é setado com o caracter inválido. Se o parˆ ametro requer um valor adicional (ex: -c arq.dat) e o mesmo n˜ ao é fornecido, retorna ’:’. Se n˜ ao existem mais parˆ ametros retorna -1. Em alguns sistemas, quando um parˆ ametro n˜ ao é válido, uma mensagem de erro é enviada para sa´ıda de erro. O exemplo da listagem E.2 mostra o uso de getopt(). Observe que a cada chamada getopt() processa uma nova op¸caõ. O uso de ’:’ depois de ’c’ indica que ’c’ recebe um argumento string, a mesma é recuperada com optarg. Listing E.2: Processando parˆ ametros de main() com getopt(). 1 2 3 4 5 6 7 8 9 10

# include < unistd .h > # include < iostream > using namespace std ; int main ( int argc , char * argv []) { int opt ; // E n q u a n t o o r e t o r n o da fun¸ c~ a o getopt () for d i f e r e n t e de -1 // p r o c e s s a linha de c o m a n d o while (( opt = getopt ( argc , argv , " abc : d " ) ) != -1)



˜ E.3. FUNC ¸ OES RECURSIVAS 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

679

{ switch ( opt ) { case ’a ’: cout << break ; case ’b ’: cout << break ; case ’c ’: cout << << break ; case ’d ’: cout << break ; case ’? ’: cout << break ; case ’: ’: cout << break ; }

" Op¸ ca ~ o = " << static_cast < char >( opt ) << endl ;

" Op¸ ca ~ o = " << static_cast < char >( opt ) << endl ; // inclui a r g u m e n t o adicional , uso de optarg " Op¸ ca ~ o = " << static_cast < char >( opt ) " Argumento = " << optarg << endl ;

" Op¸ ca ~ o = " << static_cast < char >( opt )

<< endl ;

// Indica op¸ c~ ao inv´ alida " Op¸ ca ~ o Inv´ a lida = " << static_cast < char >( optopt ) << endl ; // Indica falta de a r g u m e n t o s " Falta de argumentos . " << endl ;

} // Lista de a r g u m e n t o s errados , m o v i d o s para o fim de argv for (; optind < argc ; optind ++) cout << " Op¸ ca ~ o inv´ a lida argv [ " << optind << " ]= " << argv [ optind ] << endl ; // R e s t a n t e do p r o g r a m a ... return 0; } bash -3.00 $ ./ a . out - a Op¸ ca ~o = a bash -3.00 $ ./ a . out - abc Op¸ ca ~o = a Op¸ ca ~o = b ./ a . out : option requires an argument -- c Op¸ ca ~ o Inv´ a lida = c bash -3.00 $ ./ a . out - abc arg . dat Op¸ ca ~o = a Op¸ ca ~o = b Op¸ ca ~ o = c Argumento = arg . dat bash -3.00 $ ./ a . out - ab -c arg . dat -f Op¸ ca ~o = a Op¸ ca ~o = b Op¸ ca ~ o = c Argumento = arg . dat ./ a . out : invalid option -- f Op¸ ca ~ o Inv´ a lida = f

E.3

Fun¸ c˜ oes recursivas

Uma fun¸caõ recursiva é uma fun¸caõ que chama a s´ı mesma. Veja a seguir um exemplo de fun¸caõ recursiva. A mesma é utilizada para calcular o n´ umero de Fibonaci. Observe que dentro do else a fun¸caõ é chamada de forma recursiva. Exemplo: // N´ umeros de Fibonaci long fibonaci(long n) Programa¸caõ Orientada a Objeto com C++


˜ E.4. USO DE ELIPSE ... EM FUNC ¸ OES

680

{ if(n==0 || n==1) return n; else return fibonaci(n-1) + fibonaci(n-2); // Observe a recurs~ ao } Observe que em fun¸co˜es recursivas existe um excesso de chamadas de fun¸co˜es, o que diminui a performance do sistema. O exemplo da listagem E.3 apresenta uma fun¸caõ recursiva que calcula o fatorial de um n´ umero. Listing E.3: Fun¸caõ recursiva: c´ alculo do fatorial. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# include < iostream > # include < iomanip > using namespace std ; long int fatorial ( long int ) ;

// D e c l a r a ¸ c~ a o da fun¸ c~ ao

int main () { long int min ; cout << " Entre com o valor m´ ı nimo ( min ) : " ; cin >> min ; long int max ; cout << " Entre com o valor m´ a ximo ( max ) : " ; cin >> max ; cin . get () ; // Pega o enter for ( long int i = min ; i <= max ; i ++) cout << setw (2) << i << " ! = " << fatorial ( i ) << endl ; return 0; } // D e f i n i ¸ c~ a o da fun¸ c~ a o ( lembre - se , f a t o r i a l 5 = 5 * 4 * 3 * 2 * 1 ) long int fatorial ( long int n ) { if ( n <= 1) // Se for menor ou igual a 1 r e t o r n a 1 ( f i n a l i z a ) return 1; else // Se for >1 chama fun¸ c~ ao fatorial novamente ( recurs~ a o) return n * fatorial ( n - 1) ; } Entre com o valor m´ ı nimo ( min ) : 5 Entre com o valor m´ a ximo ( max ) : 9 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880

E.4

Uso de elipse ... em fun¸c˜ oes

A elipse refere-se a três pontos como parˆ ametro de uma fun¸caõ. Uma elipse numa lista de parˆ ametros significa que a fun¸caõ pode receber mais parˆ ametros. Um exemplo de fun¸caõ que Programa¸caõ Orientada a Objeto com C++


˜ E.5. SENTENCAS ¸ PARA FUNC ¸ OES

681

utiliza elipses é a printf() (de C), que pode receber um n´ umero variado de parˆ ametros. Para maiores informa¸co˜es, veja a fun¸caõ printf() e o help de seu ambiente de desenvolvimento. Veja na listagem E.4 exemplo de uso de elipse. Observe que a fun¸caõ va_start inicializa a retirada de vari´ aveis da pilha, a fun¸caõ va_arg retira uma vari´ avel da pilha, especificando o tamanho em bytes da vari´ avel (o que é feito passando o double), e a fun¸caõ va_end finaliza a retirada de dados da pilha. Isto significa que a utiliza¸caõ de elipse altera o estado da pilha e sua utiliza¸caõ deve ser evitada, ou utilizada somente ap´ os a fun¸caõ ter sido extensivamente testada. Listing E.4: Usando elipses (...) : fun¸caõ média. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

# include < cstdarg > # include < iostream > # include < cmath > // D e c l a r a ¸ c~ a o da fun¸ c~ a o Media double Media ( int n ,...) ; // n ´ e o n´ u mero de e l e m e n t o s int main () { double media ; int n =4; double i =1 , j =2 , k =3 , l =4; std :: cout << " M´ e dia = " << Media (n ,i ,j ,k , l ) ; return 0; } // D e f i n i ¸ c~ a o da fun¸ c~ a o Media () , o b s e r v e o uso de elipse ... double Media ( int n ,...) { double total = 0; va_list variavel ; // Cria lista v a r i ´ avel va_start ( variavel , n ) ; // I n i c i a l i z a lista v a r i ´ avel for ( int j = 1 ; j <= n ; j ++ ) { double valor = va_arg ( variavel , double ) ; std :: cout << " valor lido = " << valor << std :: endl ; total += valor ; } va_end ( variavel ) ; // E n c e r r a lista return total / n ; } valor valor valor valor M´ e dia

E.5

lido = lido = lido = lido = = 2.5

1 2 3 4

Senten¸cas para fun¸c˜ oes

• Objetos grandes devem ser passados por referência ou por ponteiros. • O nome de uma fun¸caõ é um ponteiro para fun¸caõ com endere¸co constante, definido na compila¸caõ. • Em C++ podemos declarar a fun¸caõ assim: void NomedaFuncao(); // C++ void NomedaFuncao(void); // C Programa¸caõ Orientada a Objeto com C++


E.6. RESUMO DO CAPÍTULO

682

• Quando utilizamos uma matriz como argumento de uma fun¸caõ, os valores s˜ ao passados por referência e n˜ ao por c´ opia. Se a matriz estiver dentro de uma estrutura, ela ser´ a passada por c´ opia. • Como as fun¸co˜es de C++ definidas em um arquivo podem ser utilizadas em outro arquivo, as mesmas tem uma liga¸caõ extern por default. • Performance: parˆ ametros passados por referência aumentam a eficiência, pois os valores n˜ ao s˜ ao copiados. • Na fun¸caõ main(), o retorno do valor 0 informa ao sistema operacional que o programa foi finalizado com êxito. Qualquer valor diferente de zero indica um erro. • Dentro da fun¸caõ main(), inclua um mecanismo simples de tratamento de exce¸co˜es. Veja Cap´ıtulo 26 - Exce¸co˜es. • Quando main() é encerrada com return(); ou exit(); os objetos est´ aticos s˜ ao destru´ıdos na ordem inversa em que foram constru´ıdos. • Seguran¸ca: se você quer ter certeza de que o parˆ ametro n˜ ao ser´ a alterado, deve passá-lo como referência constante. Veja o exemplo a seguir. O especificador const informa que a vari´ avel é constante e n˜ ao pode ser alterada dentro da fun¸caõ. Deste modo, a fun¸caõ pode acessar a vari´ avel, mas n˜ ao pode modific´ a-la. Exemplo: fun¸ c~ ao(const tipo& vari´ avel);

E.6


Neste apêndice aprendemos a utilizar a fun¸caõ main() e a entrada na linha de comando. Aprendemos que main() é a fun¸caõ de entrada em um programa em C/C++ e que seus parâmetros podem ser processados com getopt(). Vimos ainda as fun¸co˜es recursivas, e o uso de elipse ... em fun¸co˜es.

E.7

Exerc´ıcios

1. Modifique a listagem 8.11 de forma que a lista de n´ umeros aleat´ orios seja salva em disco. 2. Use o find de seu computador para localizar a biblioteca cstdlib (no gnu/linux fica em /usr/include/c++/vers˜ ao do compilador). Veja o arquivo e localize a declara¸caõ das fun¸co˜es srand() e rand(). 3. Modifique a listagem E.1, fa¸ca com que a mesma receba uma lista de n´ umeros inteiros e mostre na tela os valores recebidos e a sua média aritmética. 4. Modifique o exemplo da listagem E.2, de forma que a op¸caõ passada seja utilizada para executar uma fun¸caõ interna. Por exemplo, ’m’ ir´ a calcular a média dos elementos recebidos, ’s’ ir´ a calcular o desvio padr˜ ao, ’i’ os valores deverão ser passados pelo usuário. 5. Modifique a listagem E.3, alertando o usu´ ario quando o n´ umero for muito grande. 6. Modifique o exemplo da listagem E.4, acrescentando o c´ alculo do desvio padr˜ ao e a possibilidade de entrada dos dados. Programa¸caõ Orientada a Objeto com C++


E.7. EXERCÍCIOS

683

7. Modifique a listagem 8.8 de forma que o usuário entre com o valor do expoente. 8. Modifique a listagem 8.11 acrescentando o uso de outras fun¸co˜es das bibliotecas de C. 9. Implementar fun¸caõ para c´ alculo do n´ umero de Fibonaci (veja se¸caõ E.3).



684


E.7. EXERCÍCIOS


Apˆ endice F

Ponteiros - Uso Avan¸ cado Os ponteiros foram vistos no Cap´ıtulo 15 - Utiliza¸caõ de Ponteiros e Referências. Veremos neste apêndice conceitos adicionais sobre ponteiros. • Opera¸co˜es com ponteiros (+/-) (se¸caõ F.1). • Ponteiro void* (se¸caõ F.2). • Ponteiro para ponteiro (se¸caõ F.3). • Convers˜ ao de ponteiros (se¸caõ F.4). • Utilizando auto_ptr (se¸caõ F.5). • Ponteiro de fun¸caõ (se¸caõ F.6). • Ponteiros para métodos e atributos da classe (se¸caõ F.7). • Ponteiros em hierarquias (se¸caõ F.8).

F.1

Opera¸c˜ oes com ponteiros (+/-)

Opera¸co˜es que podem ser realizadas com ponteiros: • A subtra¸caõ de dois ponteiros retorna o n´ umero de elementos entre os dois ponteiros. Exemplo: int array = {0,1,2,3,4}; int* ptr1 = &array[0]; int* ptr2 = &array[4]; No exemplo abaixo, o n´ umero n é o n´ umero de objetos entre ptr1 e ptr2 int n = ptr2 - ptr1; cout < < "N´ umero de objetos entre ptr2 e ptr1 = " < < n < <

endl;

• Podemos comparar ponteiros com os operadores relacionais (> , >=, <, <= , = =, !=): 685

686

F.2. PONTEIRO VOID* Exemplo: if(ptr == ptr2) cout < < "ptr2 e ptr1 apontam para o mesmo objeto." < <

endl;

• Podemos incrementar (ptr++) e decrementar (ptr--) um ponteiro. • No exemplo a seguir, se ptr aponta para o elemento 0 de um vetor, ptr++, faz com que passe a apontar para o elemento 1 do vetor. O valor numérico do incremento é definido pelo valor retornado por sizeof: Exemplo: cout < < "O ptr1++; cout < < "O cout < < "O ptr2--; cout < < "O

ponteiro ptr1 aponta para " < < // Incrementa ptr ponteiro ptr1 aponta para " < < ponteiro ptr2 aponta para " < < // Decrementa ptr ponteiro ptr2 aponta para " < <

*ptr1 < < endl; *ptr1 < < endl; *ptr2 < < endl; *ptr2 < < endl;

• Podemos somar ou subtrair um ponteiro de um inteiro. No exemplo abaixo, 3 significa 3 vari´ aveis à frente, e n˜ ao 3 bytes. ptr1 = ptr + 3; cout < < "O ponteiro ptr1 aponta para " < < *ptr1 < < endl;

F.2

Ponteiro void*

Um ponteiro void* é um ponteiro de prop´ osito geral, que aponta para qualquer tipo de objeto e é usualmente utilizado como parˆ ametro de fun¸co˜es de prop´ osito geral. Para ser desreferenciado, um ponteiro void deve ser convertido para um tipo conhecido em tempo de compila¸caõ, pois um ponteiro void* n˜ ao tem a informa¸caõ do tipo do objeto para o qual est´ a apontando. Se um ponteiro é do tipo int*, o objeto apontado tem o tamanho de um inteiro, assim o compilador sabe quantos bytes deve ler a partir do endere¸co especificado pelo ponteiro. Quando um ponteiro é do tipo void*, o compilador s´ o sabe a posi¸caõ para a qual ele aponta, mas n˜ ao sabe a quantidade de bytes que deve ser lida (ou escrita). Veja no exemplo a seguir que tenta colocar 7 em i, mas ocorre um erro, pois void n˜ ao ´ necess´ pode utilizar o operador desreferencia¸caõ *. E ario formatar o ponteiro void*, definindo o tamanho da memória que vai ser acessada. Exemplo: // ptr_void ´ e um ponteiro para qualquer coisa. void* ptr_void; // Ponteiro para int int * ptr_int; // Cria objeto do tipo int, com nome i e valor 5 int i = 5; // Endere¸ co do objeto i ´ e armazenado em ptr_int ptr_int = & i; // Endere¸ co do objeto i ´ e armazenado em ptr_void ptr_void = & i; Programa¸caõ Orientada a Objeto com C++


F.3. PONTEIRO PARA PONTEIRO

687

// Coloca o valor 5 em i *ptr_int = 5; // Tenta colocar 7 em i usando ptr_void (ocorre um erro) *ptr_void = 7; // ok, converte ptr_void para int* e depois desrefer^ encia. *(int*) ptr_void = 7; // C *(static_cast (ptr_void) = 7; // C++

F.3

Ponteiro para ponteiro

Um ponteiro é utilizado para referência indireta a um determinado objeto, armazenando o endere¸co do objeto. Um ponteiro também é um objeto. Logo, um ponteiro pode apontar para outro ponteiro. Veja o exemplo. Listing F.1: Ponteiro de ponteiro. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# include < iostream > using namespace std ; int main () { int variavel = 33; int * ptr1 ;

// P o n t e i r o com e n d e r e ¸ camento indireto simples

int ** ptr2 ;

// P o n t e i r o com e n d e r e ¸ c a m e n t o i n d i r e t o duplo

int *** ptr3 ;

// P o n t e i r o com e n d e r e ¸ c a m e n t o i n d i r e t o triplo

ptr1 =& variavel ; // Coloca e n d e r e ¸ c o da v a r i ´ a v e l em ptr1 , // ou seja , ptr1 aponta para v a r i ´ avel ptr2 = & ptr1 ;

// ptr2 aponta para ptr1

ptr3 = & ptr2 ; // ptr3 aponta para ptr2 cout << " vari´ a vel = " << variavel << endl ; * ptr1 = 5; // A r m a z e n a o valor 5 em v a r i ´ a v e l ( usando ptr1 ) cout << " vari´ a vel = " << variavel << endl ; ** ptr2 = 7; // A r m a z e n a o valor 7 em v a r i ´ a v e l ( usando ptr2 ) cout << " vari´ a vel = " << variavel << endl ; *** ptr3 = 14; // A r m a z e n a o valor 14 em v a r i ´ a v e l ( usando ptr3 ) cout << " vari´ a vel = " << variavel << endl ; return 0; } vari´ a vel vari´ a vel vari´ a vel vari´ a vel

= = = =

33 5 7 14

Vamos relatar este u ´ ltimo caso ***ptr3 = 14; utilizando novamente a met´ afora do carteiro. Programa¸caõ Orientada a Objeto com C++


˜ DE PONTEIROS F.4. CONVERSAO

688

O pobre do carteiro tem muito trabalho. Ele pega o n´ umero 14 e vai até a casa de ptr3. Chegando l´ a, recebe ordem para ir até a casa de ptr2; já cansado, chega até a casa de ptr2 e, para sua surpresa, recebe ordem para ir até ptr1. Chateado e com fome, vai até a casa de ptr1;. Para sua desgra¸ca, recebe ordem para ir até a casa da vari´ avel; o pobre coitado leva o n´ umero 14 até a casa da vari´ avel e, como n˜ ao é de ferro, descansa. Em resumo: • Quando você faz Tipo *ptr; est´ a criando um ponteiro para o Tipo. • Quando você utiliza ptr1= &algo;, est´ a armazenando o endere¸co da vari´ avel no ponteiro. • Quando você utiliza int **ptr2= &ptr1;, est´ a criando um ponteiro de ponteiro com nome ptr2, e armazenando o endere¸co de ptr1 em ptr2. • Quando você utiliza int ***ptr3 = &ptr2;, o ponteiro de ponteiro de ponteiro ptr3 vai apontar para a mesma vari´ avel que ptr2. • Quando você utiliza ptr=& x; *ptr=55;, est´ a armazenando o valor 55 na vari´ avel apontada por ptr, no caso a vari´ avel x.

F.4

Convers˜ ao de ponteiros

A Tabela F.1 mostra a convers˜ ao de ponteiros. Na primeira linha, um Tipo é convertido em uma referência para o tipo (Tipo&). A compreensão dessa Tabela é importante. Leia cada linha com cuidado.

De Tipo Tipo& Tipo[] Tipo(argumentos) Tipo Tipo Tipo* Tipo*

F.5

Tabela F.1: Convers˜ ao de ponteiros. Para Descri¸caõ Tipo& de Tipo para referência Tipo de referência para Tipo Tipo * converte um vetor const para um ponteiro Tipo(*)(argumentos) de fun¸caõ para ponteiro de fun¸caõ const Tipo de Tipo para const Tipo volatile Tipo de Tipo para volatile Tipo const Tipo* de Tipo* para const Tipo* volatile Tipo* de Tipo* para volatile Tipo*

Utilizando auto_ptr

Como descrito no Cap´ıtulo 26 - Exce¸co˜es, se você tem um objeto dinâmico (por ex.: int* ptr = new int[30];) e ocorre uma exce¸caõ, você deve fornecer mecanismos para apagar os objetos dinâmicos. Esta pode ser uma situa¸caõ complicada. O auto_ptr é uma classe ponteiro que tem uma rela¸caõ ´ıntima com a RTTI (tabela de informa¸co˜es em tempo de execu¸caõ), de forma que se ocorrer uma exce¸caõ ap´ os a aloca¸caõ de um objeto dinâmico, este se auto-deleta. Ou seja, ao sair de escopo um ponteiro auto_ptr, automaticamente chama o destrutor do objeto. A classe auto_ptr é definida no arquivo de cabe¸calho . Veja o exemplo da listagem F.2. Observe que o mais f´ acil de usar e o mais vers´ atil é o da STL. Programa¸caõ Orientada a Objeto com C++


F.5. UTILIZANDO AUTO_PTR

689

Note na sa´ıda a presen¸ca de valores negativos. Isto ocorre porque quando constru´ımos um vetor, o primeiro objeto é constru´ıdo usando construtor default, e os demais usando o construtor de c´ opia. Ou seja, para eliminar os valores negativos é necess´ ario implementar o construtor de c´ opia. Listing F.2: Comparando o uso de vetores est´ aticos de C, dinâmicos de C++, com auto_ptr de C++ e da stl. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

# include < iostream > # include < memory > # include < vector > using namespace std ; class CTipo { public : int t ; static int cont ; CTipo () { cont ++; cout << " Construtor do objeto , cont = " << cont << endl ; } ~ CTipo () { cout << " Destrutor do objeto , cont = " << cont << endl ; cont - -; } }; int CTipo :: cont = 0; int main () { cout << " ----- vetor est´ a tico de C : " << endl ; { CTipo v_static [2]; // Cria vetor e s t ´ a t i c o com 2 e l e m e n t o s } // D e s t r ´ o i vetor ao sair de escopo cout << " ----- vetor din^ a mico em C ++ sem STL : " << endl ; { CTipo * v_dinamico = new CTipo [3]; // ..... U t i l i z a o vetor ... delete [] v_dinamico ; // P r e c i s a do delete [] } // Usando auto_ptr , a u t o _ p t r n~ a o deve a p o n t a r para um vetor . cout << " ----- Objeto din^ a mico em C ++ com auto_ptr : " << endl ; { auto_ptr < CTipo > v_autoptr ( new CTipo ) ; v_autoptr - > t = 77; // ..... U T i l i z a o vetor ... cout << " t = " << v_autoptr - > t << endl ; } // a p a g a d o a u t o m a t i c a m e n t e cout << " ----- vetor din^ a mico em C ++ com STL : " << { vector < CTipo > v_stl (4 , CTipo () ) ; // for ( int i = 0; i < v_stl . size () ; i ++) { v_stl [ i ]. t = i ; cout << i << " = " << v_stl [ i ]. t << endl ; } } // D e s t r ´ o i objeto


endl ; E´ d i n ^ amico

ao sair de escopo


690 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

F.5. UTILIZANDO AUTO_PTR

cout << " ----- vetor de ponteiros em C ++ com STL : " << endl ; { vector < CTipo * > v_stl (5) ; // Cria vetor de p o n t e i r o s for ( int i = 0; i < v_stl . size () ; i ++) { v_stl [ i ] = new CTipo () ; // Cria objeto v_stl [ i ] - > t = i ; // Usa objeto cout << " i = " < t << endl ; } for ( int i = 0; i < v_stl . size () ; i ++) delete v_stl [ i ]; // Deleta o b j e t o s } return 0; }

----- vetor est´ a tico de C : Construto r do objeto , cont = 1 Construto r do objeto , cont = 2 Destrutor do objeto , cont = 2 Destrutor do objeto , cont = 1 ----- vetor din^ a mico em C ++ sem STL : Construto r do objeto , cont = 1 Construto r do objeto , cont = 2 Construto r do objeto , cont = 3 Destrutor do objeto , cont = 3 Destrutor do objeto , cont = 2 Destrutor do objeto , cont = 1 ----- Objeto din^ a mico em C ++ com auto_ptr : Construto r do objeto , cont = 1 t = 77 Destrutor do objeto , cont = 1 ----- vetor din^ a mico em C ++ com STL : Construto r do objeto , cont = 1 Destrutor do objeto , cont = 1 0 = 0 1 = 1 2 = 2 3 = 3 Destrutor do objeto , cont = 0 Destrutor do objeto , cont = -1 Destrutor do objeto , cont = -2 Destrutor do objeto , cont = -3 ----- vetor de ponteiros em C ++ com STL : Construto r do objeto , cont = 1 i = 0 t = 0 Construto r do objeto , cont = 2 i = 1 t = 1 Construto r do objeto , cont = 3 i = 2 t = 2 Construto r do objeto , cont = 4 i = 3 t = 3 Construto r do objeto , cont = 5 i = 4 t = 4 Destrutor do objeto , cont = 5 Destrutor do objeto , cont = 4 Destrutor do objeto , cont = 3 Destrutor do objeto , cont = 2 Destrutor do objeto , cont = 1



˜ F.6. PONTEIRO DE FUNC ¸ AO

691

Problemas com auto_ptr Observe que dois objetos auto_ptr n˜ ao podem apontar para o mesmo objeto, por isso, o construtor de c´ opia e o operador de c´ opia de auto_ptr tem um comportamento estranho. Exemplo: // Cria objeto int apontado por aptr1 void auto_ptr aptr1(new int()); // Abaixo faz aptr2 apontar para o objeto int e aptr1 para NULL!! auto_ptr aptr2(aptr1); Desta forma, quando aptr2 sair de escopo o objeto criado é deletado, e quanto aptr1 sair de escopo nada acontece, evitando-se a destrui¸caõ repetida do objeto criado. Observe que esta solu¸caõ elimina a destrui¸caõ dupla do objeto criado, mas aptr1 e aptr2 n˜ ao tem o comportamento esperado. Por este motivo aconselha-se a substitui¸caõ do uso de auto_ptr por shared_ptr da biblioteca boost++ (veja se¸caõ ??). Dica: substitua o uso de auto_ptr por shared_ptr da biblioteca boost++, veja se¸caõ ??.

F.6

Ponteiro de fun¸c˜ ao

Você pode criar um ponteiro para uma fun¸caõ e usar o ponteiro para chamar a fun¸caõ. A listagem F.3 mostra um exemplo. Listing F.3: Usando ponteiro de fun¸caõ. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# include < iostream > using namespace std ; double cubo ( double x ) ; // D e c l a r a ¸ c~ a o da fun¸ c~ ao int main () { // Define tipo ptr_funcao , um p o n t e i r o de fun¸ c~ ao // que tem como p a r a m e t r o um double e como r e t o r n o um double . typedef double (* ptr_funcao ) ( double x ) ; // A r m a z e n a o e n d e r e ¸ c o da fun¸ c~ a o no p o n t e i r o ptr_funcao ptr = cubo ; // U t i l i z a o p o n t e i r o de fun¸ c~ a o para e x e c u t a r a fun¸ c~ a o cubo . double x = 3; cout << " resultado = " << ptr ( x ) << endl ; return 0; } // D e f i n i ¸ c~ a o da fun¸ c~ ao double cubo ( double x ) { return x * x * x ; } resultado = 27

O exemplo a seguir, adaptado de [Lischner, 2003], mostra outros poss´ıveis usos de ponteiros para fun¸co˜es. Seja a fun¸caõ f(), que retorna um int* e recebe um int*. int* f(int*); Programa¸caõ Orientada a Objeto com C++


´ F.7. PONTEIROS PARA METODOS E ATRIBUTOS DA CLASSE

692

e a fun¸caõ G(), que retorna um int* e recebe um ponteiro para f(), ptr_f, e um int. int* G(int*(*ptr_f)(int*), int); Para criar um array com 10 ponteiros de fun¸caõ para fun¸caõ G() podemos usar: int* (*vptr_G[10])(int*(*)(int*), int); Note que a sintaxe do exemplo acima é confusa para usuários iniciantes. Uma alternativa seria usar a sequência abaixo. Primeiro usa typedef para declarar um apelido para int* typedef int* ptrInt; A seguir, usa typedef para declarar um apelido para o ponteiro de fun¸caõ que retorna um ponteiro para int e recebe como parˆ ametro um ponteiro para int. typedef ptrInt (*ptr_f)(ptrInt); Finamente, cria um array com 10 ponteiros de fun¸caõ para G(). ptrInt (*vptr_G[10]) (ptr_f,int);

F.7

Ponteiros para m´ etodos e atributos da classe

Este é um t´ıtulo de n´ıvel 3, isto significa que s´ o deve ser lido por usuário experiente. Em determinados casos, muito especiais (raros), você pode querer ter um ponteiro para um atributo ou método de uma classe. Esta se¸caõ mostra, por meio de um exemplo, como você deve proceder. Exemplo: class A { static int x; // Atributo void Mx(); // M´ etodo } // Criando ponteiro para m´ etodo fx() da classe A void(A::*ptrMx)() = & A::Mx(); // Ponteiro para atributo x da classe A int A::*ptr_x = & A::x; cout < < (*ptr_x) < < endl; Veja exemplo na listagem F.4. Observe a forma como o ponteiro é criado e usado. Note que o como o método é virtual e o objeto usado é do tipo derivado, o método executado é o método da classe derivada. Listing F.4: Ponteiro para métodos da classe. 1 2 3 4 5 6 7

# include < iostream > class Base { public : Base ( int i ) : x_ ( i ) {} virtual ~ Base () {}



F.8. PONTEIROS EM HIERARQUIAS 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

693

virtual void Metodo () { std :: cout << " Base :: Metodo () \ n " ; } private : int x_ ; }; class Derivada : public Base { public : Derivada ( int i ) : Base ( i ) {} virtual void Metodo () { std :: cout << " Derivada :: Metodo () \ n " ; } }; int main () { Base * obj_b = new Derivada (42) ; void ( Base ::* ptrMetodo ) () = & Base :: Metodo ; ( obj_b - >* ptrMetodo ) () ; // E x e c u t a D e r i v a d a :: Metodo () } Derivada :: Metodo ()

F.8

Ponteiros em hierarquias

Quando usamos ponteiros em uma hierarquia, o endere¸co apontado pode variar, um offset (deslocamento) pode ocorrer em tempo de execu¸caõ, veja listagem F.5. Listing F.5: Ponteiro em hierarquias e offset. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# include < iostream > using namespace std ; class Base {}; class Derivada : public Base {}; int main () { Derivada d ; Base * pb = & d ; Derivada * pd = & d ; if ( pb == pd ) cout << " pb = " << pb << " pd = " << pd << " pb == pd " << endl ; else cout << " pb != pd " << endl ; return 0; } pb =0 x 7 f f f a e b 9 4 0 9 f pd =0 x 7 f f f a e b 9 4 0 9 f pb == pd



694

F.9. SENTENCAS ¸ PARA PONTEIROS

Na listagem F.6 apresenta-se a utiliza¸caõ do operador de endere¸co e sizeof. Observe na sa´ıda que nome aponta para o vetor, mostrando a sa´ıda "LDSC - Laborat´ orio Desenvolvimento Software Cient´ ıfico" . O conte´ udo de *nome é o caracter L e o endere¸co de nome um endere¸co de memória. Como o conte´ udo de *nome é o caracter n, quando convertemos para int, obtemos o valor 76. Observe ainda que sizeof(&nome) é 8, ou seja o ponteiro nome consome 8 bytes. J´ a o sizeof de nome é 57, indicando que consumimos 57 caracteres (56 caracteres mais o caracter terminador \0). Nota: observe que estes valores variam de plataforma para plataforma, estes resultados s˜ ao obtidos em um GNU/Linux/Fedora 6 com uma SUN-Ultra40 (processadores AMD-Opteron de 64 bits). Listing F.6: Usando operador de endere¸co (&) e sizeof(). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# include < iostream > using namespace std ; int main () { char nome [] = " LDSC - Laborat´ o r i o D e s e n v o l v i m e n t o Software Cient´ ı fico " ; cout << " nome = " << nome ; cout << " \ n * nome = " << * nome ; cout << " \ n & nome = " << & nome ; cout << " \ n & nome [0] = " << & nome [0]; cout << " \ n nome [0] = " << nome [0]; cout << " \ n ( int ) * nome = " << ( int ) * nome ; cout << " \ n sizeof (& nome ) = " << sizeof (& nome ) ; cout << " \ n sizeof ( nome ) = " << sizeof ( nome ) << endl ; return 0; } nome = LDSC - Laborat´ o ri o D e s e n v o l v i m e n t o Software Cient´ ı fico * nome = L & nome = 0 x 7 f f f 9 9 9 f b d f 0 & nome [0] = LDSC - Laborat´ o ri o D e s e n v o l v i m e n t o Software Cient´ ı fico nome [0] = L ( int ) * nome = 76 sizeof (& nome ) = 8 sizeof ( nome ) = 57

F.9

Senten¸cas para ponteiros

• O ponteiro void* n˜ ao permite o uso do operador de localiza¸caõ(*) e endere¸camento(&). • O conte´ udo de void* s´ o pode ser acessado depois da defini¸caõ do tipo de objeto para o qual o ponteiro aponta. • Um ponteiro void* pode ser igualado a outros ponteiros e vice-versa. • Observe a utiliza¸caõ da mesma palavra-chave para diferentes prop´ ositos: – para lista de argumentos, void = nenhum argumento; – para retorno de fun¸caõ, void = nenhum retorno; – para ponteiros, void = ponteiro para qualquer tipo de objeto. Programa¸caõ Orientada a Objeto com C++


F.10. RESUMO DO CAPÍTULO

695

• Um ponteiro qualquer (desde que n˜ ao seja const e volatile) pode ser convertido para void*. • Um ponteiro pode ser convertido em qualquer tipo integral que seja suficientemente grande para contê-lo. • Um ponteiro de um objeto de tamanho n pode ser convertido para ponteiro do objeto de tamanho m, se n > m. • Sempre inicializar os ponteiros ( ptr = NULL; ). • Sempre destruir os objetos alocados com new com delete. • Um ponteiro para uma classe-derivada pode ser convertido em ponteiro para a classe-base. • 3 Um ponteiro para um objeto B (de uma classe-base) pode ser convertido em ponteiro para o objeto D (de uma classe-derivada) se a convers˜ ao for direta e n˜ ao amb´ıgua, e se B n˜ ao é classe-base virtual. • 3 Uma referência a uma classe pode ser convertida em uma referência a uma classe-base acess´ıvel.

F.10


Neste apêndice aprendemos conceitos adicionais sobre ponteiros, como a soma e a subtra¸caõ de ponteiros. O uso do ponteiro void*, e de ponteiro para ponteiro. Como fazer para converter ponteiros. Exemplo de uso de auto_ptr. Como criar e usar um ponteiro de fun¸caõ, e ponteiros para métodos e atributos da classe. Finalmente vimos o uso de ponteiros em hierarquias.

F.11

Exerc´ıcios

1. Na se¸caõ F.1 apresentamos um exemplo. Transforme o mesmo em listagem, teste, e depois fa¸ca modifica¸co˜es e aperfei¸coamentos. 2. Monte um exemplo com ponteiro void (se¸caõ F.2). 3. Monte um exemplo que utilize os conceitos apresentados na se¸caõ F.3. 4. Monte um exemplo com convers˜ ao de ponteiros (se¸caõ F.4). 5. Modifique a listagem F.3, acrescentando novas fun¸co˜es. 6. Modifique a listagem F.6, acrescentando o uso de sizeof() para tipos padr˜ oes da linguagem. (a) Ex: sizeof (int). 7. Na listagem F.2 acrescentar o construtor de c´ opia. 8. No exemplo de uso de dinâmico da STL, o construtor est´ a criando o objeto uma u ´ nica vez (visto que s´ o é executado uma vez), mas est´ a deletando o objeto quatro vezes. Como proceder para corrigir este problema? Tente implementar na classe Tipo o construtor de c´ opia.



696

F.11. EXERCÍCIOS



Apˆ endice G

Estruturas, Uni˜ oes, e Enumera¸ c˜ oes Veremos neste apêndice o uso de estruturas (se¸caõ G.1), uniões (se¸caõ G.2), e enumera¸co˜es (se¸caõ G.3).

G.1

Estruturas - struct

Vimos no Cap´ıtulo 11 - Classes, a utiliza¸caõ de classes para criar o conceito de objeto com seus atributos e métodos. A linguagem C utiliza a palavra-chave struct para criar entidades que s˜ ao utilizadas para armazenar somente vari´ aveis (sem fun¸co˜es). Assim, uma estrutura permite reunir um conjunto de vari´ aveis, dentro de uma entidade u ´ nica. • Uma struct é um conjunto de vari´ aveis ou objetos reunidos. • Os objetos que compõem a struct podem ser de diferentes tipos. • C++ estendeu as structs de C e estas podem ser utilizadas para incluir fun¸co˜es. A dica é utilizar a palavra chave struct apenas para reunir atributos (de acordo com sua defini¸caõ inicial) e deixar para as classes a reunião de atributos e métodos.

G.1.1

Prot´ otipo para declarar e definir estruturas

O prot´ otipo para defini¸caõ de uma estrutura inicia-se com a palavra-chave struct e, a seguir, o nome da estrutura e o bloco com a defini¸caõ dos atributos que fazem parte da estrutura. N˜ ao se esque¸ca do ponto e v´ırgula ap´ os o final do bloco. Prot´ otipo: struct SNomeEstrutura { avel1; Tipo 1 vari´ avel2; Tipo 2 vari´ ... aveln; Tipo n vari´ }; 697

698

G.1. ESTRUTURAS - STRUCT

Depois de definida uma estrutura, o seu nome passa a ser um tipo do usuário, ou seja, a estrutura pode ser utilizada da mesma forma que qualquer outro tipo de C++. Veja a seguir como criar e utilizar uma struct de C. Criando um objeto de uma estrutura Pode-se criar um objeto de uma estrutura do mesmo modo que se cria um objeto qualquer de C. Veja a seguir o prot´ otipo e um exemplo. Prot´ otipo: SNomeEstrutura nomeObjeto; // Cria um objeto SNomeEstrutura v[n]; // Pode-se criar um vetor de estruturas. Exemplo: SPonto { int x,y; } int main() { SPonto p1 = {}; // x = y = 0 SPonto p2 = {3, 2}; // x = 3; y = 2; } Acessando atributos de uma estrutura Para acessar um atributo de uma estrutura, utiliza-se o operador ponto (.) se esta for est´ atica, e o operador seta (->) se esta for dinˆ amica. Prot´ otipo: SNomeEstrutura nomeObjeto; nomeObjeto.atributo; Prot´ otipo: SNomeEstrutura* ptr; ptr = new SNomeEstrutura; ptr ->atributo; delete ptr; Reveja agora o exemplo da listagem 9.4.

G.1.2

Estruturas e fun¸c˜ oes

Pode-se passar uma estrutura por c´ opia, por referência ou por ponteiro para uma fun¸caõ. Veja o exemplo. Exemplo: Tipo Fun¸ c~ ao( SNomeEstrutura obj1); // Por c´ opia Tipo Fun¸ c~ ao( SNomeEstrutura & obj2); // Por refer^ encia Tipo Fun¸ c~ ao( SNomeEstrutura * obj2); // Por ponteiro Programa¸caõ Orientada a Objeto com C++


G.1. ESTRUTURAS - STRUCT

G.1.3

699

Estruturas aninhadas

Quando temos uma estrutura dentro de outra temos uma estrutura aninhada. Veja exemplo de uso de estruturas aninhadas na listagem G.1. Listing G.1: Usando estruturas aninhadas. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# include < iostream > # include < string > using namespace std ; // Define uma e s t r u t u r a S P e s s o a struct SPessoa { public : string nome ; int idade ; // Define uma e s t r u t u r a a n i n h a d a // a e s t r u t u r a S F a m i l i a dentro de S P e s s o a struct SFamilia { string sobrenome ; int n u m e r o I r m a o s ; } SFamilia ; }; int main () { // Cria objeto do tipo Pessoa SPessoa Joao ; Joao . nome = " Jo~ ao " ; Joao . idade = 21; Joao . SFamilia . n u m e r o I r m a o s = 3; Joao . SFamilia . sobrenome = " da Silva " ; cout << Joao . nome << " " << Joao . SFamilia . sobrenome << " \ n " << Joao . idade << " anos " << endl << " tem " << Joao . SFamilia . n u m e r o I r m a o s << " irmaos " << endl ; return 0; } Jo~ a o da Silva 21 anos tem 3 irmaos

G.1.4

Senten¸cas para estruturas

• Uni˜ oes e estruturas dentro de classes s˜ ao sempre public. • Inicialmente n˜ ao era permitida a inclus˜ ao de fun¸co˜es dentro da estrutura; hoje, uma struct aceita fun¸co˜es. Se quiser colocar fun¸co˜es dentro da estrutura, utilize classes. • Uma struct X n˜ ao pode conter uma instância de si mesma (mas pode ter um ponteiro para X). • Por default, os elementos de uma struct s˜ ao p´ ublicos (public:); para classes, o default é privado (private:). Programa¸caõ Orientada a Objeto com C++


˜ G.2. UNIOES - UNION

700

• O sizeof de uma estrutura pode ser maior que a soma do sizeof de seus elementos. Isto provoca pequenos desperd´ıcios de mem´ oria, que podem ser reduzidos colocando-se no in´ıcio da estrutura os objetos maiores e, a seguir, os menores (por ordem de tamanho). Veja se¸caõ 15.7. • Ao contrário de C++, em C uma estrutura n˜ ao define um tipo do usuário. Para criarmos um objeto da estrutura usamos a palavra-chave typedef. Exemplo: struct SNome {int x}; SNome objeto_do_tipo_SNome; // C++ struct SNome objeto_do_tipo_SNome; // C

G.2

Uni˜ oes - union

Uma união (union) permite a um conjunto de objetos ocupar o mesmo local na mem´ oria. Observe que somente um objeto pode ser utilizado por vez. • Uma união pode ser considerada uma estrutura onde todos os objetos têm deslocamento zero e cujo tamanho é suficiente para conter o seu maior membro. Ou seja, o espa¸co ocupado por uma union é correspondente ao do maior objeto definido. • Depois de definida uma union, o seu nome passa a ser um tipo do usuário. • Como uma union pode armazenar objetos de diferentes tipos, ela n˜ ao pode armazenar uma classe com construtor, com destruidor ou operador de c´ opia. O motivo é simples: se uma union tiver um int e um CPonto (listagem 13.5), quando a union sair de escopo, deverá destruir o objeto int ou o objeto CPonto?. Veja se¸co˜es 11.5.5 e 11.5.6. • Uni˜ oes n˜ ao suportam heran¸ca, mas podem ter construtores. • Segundo [Lischner, 2003], uma uni˜ ao é semelhante a uma estrutura, mas com as seguintes restri¸co˜es. – N˜ ao deve ter uma classe-base, e n˜ ao pode ser uma classe-base. – N˜ ao deve ter métodos virtuais nem membros est´ aticos. – Membros de dados n˜ ao podem ser referências. – Todos os seus membros de dados devem ser triviais (veja se¸cão 11.5.6). • As classes triviais descritas na se¸caõ 11.5.6, s˜ ao importantes porque uniões s´ o podem ter membros triviais.

G.2.1

Prot´ otipo para declarar e definir uni˜ oes

Veja a seguir o prot´ otipo de uma union. Prot´ otipo: union UNomeUniao { Tipo1 v1; Tipo2 v2; Programa¸caõ Orientada a Objeto com C++


˜ G.3. ENUMERAC ¸ OES - ENUM

701

}; // Para criar um objeto da uni˜ ao fa¸ca: UNomeUniao obj; // Para armazenar valores na uni˜ ao: Tipo1 x; obj.v1 = x; // Para acessar os atributos da uni˜ ao fa¸ca: Tipo1 y = obj.v1; Veja a seguir exemplo de uso de uma union. Observe que a union armazena dois objetos, um int e um double. Logo, a union ter´ a o tamanho de um double. Exemplo: union UData { int x; double y; } UData obj1; obj1.x = 5; UData obj2; obj2.y = 5.0 + obj1.x ; Observe que podemos colocar dois objetos definidos pelo usu´ ario dentro de uma union, mas s´ o podemos utilizar um de cada vez. Em alguns casos, um objeto pode ter o mesmo objetivo geral, mas seria interessante poder ter dois nomes. No exemplo a seguir, dois objetos do tipo double s˜ ao declarados dentro da ´ importante union. Assim, podemos utilizar dois nomes para o mesmo endere¸co de memória. E lembrar que o mesmo também pode ser feito com referências. Exemplo: union UPropriedade { double condut^ ancia; double raioHidraulico; }; Você pode criar uni˜ oes sem um nome, pois deste modo as variáveis definidas dentro da union podem ser acessadas diretamente, sem a utiliza¸caõ do ponto (.). A esta união damos o nome de união anˆ onima. Obviamente, como os nomes definidos dentro dessa união podem ser utilizados diretamente no escopo em que foram declarados, vari´ aveis com o mesmo nome causar˜ ao ambig¨ uidade.

G.3

Enumera¸c˜ oes - enum

Uma enumera¸caõ é uma seq¨ uência de valores que tem como objetivo enumerar algum processo. Uma enumera¸caõ é um tipo discreto, definido pelo usuário é um tipo do usuário. Os valores podem ser definidos pelo programador (como em seg=2) ou serem definidos automaticamente pelo sistema.

G.3.1

Prot´ otipo para declarar e definir enumera¸c˜ oes

No prot´ otipo a seguir v1 , v2 , v3 ,..., vn , s˜ ao os valores, ENome é o nome da enumera¸caõ. Programa¸caõ Orientada a Objeto com C++



702 Prot´ otipo: enum ENome { v1, v2, v3,...,vn }; Veja no exemplo a seguir como declarar uma enumera¸caõ.

Exemplo: enum EDia { dom, seg, ter, qua, qui, sex, sab }; Onde EDia é o nome da enumera¸caõ e dom = 1, seg = 2, ter = 3, qua = 4, qui = 5, sex = 6, sab = 7, os valores da enumera¸caõ. Observe que os valores de cada elemento da enumera¸caõ s˜ ao incrementados de 1. Veja no exemplo a seguir outros exemplos de enumera¸co˜es. Exemplo: enum ECor {r = 1 , g = 2 , b = 3 }; Exemplo: enum EResposta {nao = 0, sim = 1 , sei = 3 , nunca = 4};

talves = 2 , nao-

Veja no exemplo da listagem G.2 a cria¸caõ e uso de um objeto do tipo EDia com nome d. O programa pergunta que dia é hoje (n´ umero do mês e dia da semana). A seguir cria um objeto do tipo da enumera¸caõ e usa o mesmo para imprimir um calend´ ario para os próximos 30 dias. Listing G.2: Usando enumera¸co˜es: Um calend´ ario. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# include < iostream > # include < string > # include < iomanip > using namespace std ; // Cria uma e n u m e r a ¸ c~ a o com o nome EDia enum EDia { dom =1 , seg , ter , qua , qui , sex , sab }; // Abaixo s o b r e c a r r e g a o o p e r a d o r ++ EDia & operator ++( EDia & d , int ) { if ( d == sab ) { d = dom ; return d ; } else { int x = static_cast < int >( d ); x ++; d = static_cast < EDia >( x ); return d ; } } int main () { cout << " Que dia do m^ es e ´ hoje ( n´ u mero ): " ; int x ; cin >> x ; cin . get (); cout << " Que dia da semana e ´ hoje ( dom =1 , seg =2 , ter =3 ,.. , sab =7): " ; int y ;



˜ G.3. ENUMERAC ¸ OES - ENUM 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

703

cin >> y ; cin . get (); EDia d ( static_cast < EDia >( y ) ); cout << " Calend´ a rio para os pr´ o ximos 31 dias :\ n " << " Dom Seg Ter Qua Qui Sex Sab " << endl ; for ( int i = 1 ; i < y ; i ++ ) cout << setw (5) << " " ; for ( int i = x , j = x ; i < ( x + 31); i ++ , j ++) { cout << setw (5) << j ; d ++; if ( d == dom ) cout << endl ; // Muda linha if ( j > 30) // Impede mais de 31 dias j = 0; } cout << " \ a \ a " << endl ; return 0; } Que dia do m^ es e ´ hoje ( n´ u mero ) :19 Que dia da semana e ´ hoje ( dom =1 , seg =2 , ter =3 ,.. , sab =7) :3 Calend´ a rio para os pr´ o ximos 31 dias : Dom Seg Ter Qua Qui Sex Sab 19 20 21 22 23 24 25 26 27 28 29 30 31 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Você pode criar uma enumera¸caõ sem um nome, neste caso os atributos internos podem ser acessados diretamente. Veja listagem G.3. Listing G.3: Usando enumera¸caõ anonima. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# include < iostream > using namespace std ; // C r i a n d o uma e n u m e r a ¸ c~ ao an^ onima enum { jan = 1 , fev , mar , abr , mai , jun , jul , ago , set , out , nov , dez }; int main () { for ( int i = 1; i <= 12; i ++) {

cout << " \ nmes = " << i << " = " ; switch ( i ) { case jan : case fev : case mar : case abr : case mai : case jun : case jul : case ago : case set : case out : case nov : case dez :

cout cout cout cout cout cout cout cout cout cout cout cout

<< << << << << << << << << << << <<

" " " " " " " " " " " "

janeiro " ; fevereiro " ; mar¸ co "; abril " ; maio " ; junho " ; julho " ; agosto " ; setembro " ; outubro " ; novembro " ; dezembo " ;


break ; break ; break ; break ; break ; break ; break ; break ; break ; break ; break ; break ;



704 27 28 29 30 31

}; } cout << endl ; return 0; } mes mes mes mes mes mes mes mes mes mes mes mes

= = = = = = = = = = = =

G.3.2

janeiro fevereiro mar¸ co abril maio junho julho agosto setembro outubro novembro dezembo

Senten¸cas para enumera¸c˜ oes

• Por default uma enumera¸caõ inicia-se com 0. • Em opera¸co˜es aritméticas, os elementos de uma enumera¸caõ s˜ ao convertidos automaticamente para int. Mas um inteiro n˜ ao é automaticamente convertido para enumera¸caõ, neste caso precisamos usar um static_cast<> (veja se¸caõ 25.6). • Os elementos de uma enumera¸caõ (ex.: {dom = 1, seg, ter, qua, qui, sex, sab}) s˜ ao constantes e n˜ ao podem ser alterados. • Uma enumera¸caõ é um tipo u ´ nico, um tipo do usuário, e pode ser utilizada para criar objetos do tipo da enumera¸caõ, o que inclui atributos est´ aticos. Veja o exemplo. Exemplo: class T { public: enum EColor { black = 0, white = 1 }; static EColor sc; }; T::Ecolor T::sc = white; int main() { T::EColor c; ... return 0; } • Uma enumera¸caõ permite sobrecarga de operador. • Você pode usar enumera¸co˜es para armazenar n´ umeros inteiros, mas lembre-se, você n˜ ao pode obter o endere¸co de uma enumera¸caõ. • Uma enumera¸caõ declarada dentro de uma classe, coloca os membros da enumera¸caõ no escopo da classe. Veja exemplo a seguir. Note que podemos declarar a enumera¸caõ dentro da classe Base, podemos declarar e definir o valor de um objeto ECor est´ atico dentro da classe Botao, ou somente declarar dentro de Dialogo e definir posteriormente. Programa¸caõ Orientada a Objeto com C++


G.4. RESUMO DO CAPÍTULO

705

Exemplo: class Base { public: enum ECor {preto, branco, vermelho, verde, azul}; }; class Botao : public Base { const ECor cor = verde; }; class Dialogo : public Base { static const ECor cor ; }; Base::ECor Dialogo::cor = Base::azul;

G.4


Neste apêndice aprendemos em mais detalhes como usar as estruturas de C. Aprendemos que uma struct é um conjunto de vari´ aveis ou objetos reunidos. Falamos que embora C++ atual permita que uma estrutura tenha métodos, devemos incluir métodos apenas nas classes. Ou seja, as estruturas devem ter apenas atributos (dados/vari´ aveis). Vimos que as uni˜ oes podem ser utilizadas da mesma forma que as estruturas, mas que somente uma vari´ avel deve ser utilizada por vez. Aprendemos que o espa¸co de memória ocupado pela estrutura é o do seu maior objeto. Finalmente, aprendemos que uma enumera¸caõ é uma seq¨ uência de valores que tem como objetivo enumerar algum processo.

G.5

Exerc´ıcios

1. O exemplo da listagem G.2 tem problemas. O aluno deve tentar corrigir os problemas. Por exemplo, acrescentar verifica¸caõ do final do mes 30 ou 31 dias? Melhorar a l´ ogica do algoritmo. 2. Para os exerc´ıcios que fizemos anteriormente, classes CPonto, CCirculo, CElipse, CAluno, CFuncion´ ario, etc, verifique se o sizeof() da classe é igual a soma do sizeof() dos seus atributos.



706

G.5. EXERCÍCIOS



Apˆ endice H

Vetores e Matrizes - Arrays Veremos neste apêndice o uso de vetores e matrizes - Arrays. Iniciamos apresentando uma introdu¸caõ aos vetores e matrizes de C (se¸caõ H.1), a seguir veremos • Como criar e usar vetores unidimensionais (se¸caõ H.2), • Como criar e usar matrizes bidimensionais (se¸caõ H.3). • Exemplo de uso de vetores e matrizes (arrays) (se¸caõ H.4).

H.1

Introdu¸ c˜ ao aos vetores e matrizes de C

Um vetor ou array no estilo de C é um bloco de memória alocado para armazenamento de objetos cont´ıguos e do mesmo Tipo. O tamanho (ou size) de um array deve ser conhecido em tempo de compila¸caõ. Veja a seguir o prot´ otipo para criar arrays no estilo de C. Prot´ otipo: // Unidimensional Tipo nome [ dimens˜ ao ] ; // Bidimensional Tipo nome [ dimens˜ ao1 ] [ dimens˜ ao2 ] ; // Tridimensional Tipo nome [ dimens˜ ao1 ] [ dimens˜ ao2 ] [ dimens˜ ao3 ] ; // Ndimensional Tipo nome [ dimens˜ ao1 ] [ dimens˜ ao2 ] [ dimens˜ ao3 ] ... [dimens˜ aoN];

H.2

Como criar e usar vetores unidimensionais

No exemplo a seguir criamos um vetor unidimensional com 10 elementos. Observe que os valores do vetor s˜ ao indefinidos. Exemplo: int v0[10] ; Se o array for est´ atico, todos os valores s˜ ao inicializados com 0. No exemplo a seguir criamos um vetor unidimensional est´ atico com 5 elementos iguais a 0. 707

708

H.3. COMO CRIAR E USAR MATRIZES BIDIMENSIONAIS Exemplo: static int v1[5] ;

No exemplo abaixo, criamos um vetor unidimensional v2 com 4 elementos. A seguir inicializamos seus valores um a um. Exemplo: int v2[4]; v2[0] = 11, v2[1] = 22, v2[2] = 0, v2[3] = 0.0; No exemplo abaixo criamos os vetores v3 e v4. Os mesmos s˜ ao inicializados na cria¸caõ usando {}. Exemplo: int v3[5] int v4[4]

= { 11, 22, 33, 44, 55 }; = { 11, 22 };

A dimensão do array pode ser omitida se o compilador puder calcular a dimensão. No exemplo a seguir o vetor v5 vai ter 3 elementos, isto é, v5[0] = 0, v5[1] = 11, v5[2] = 22. Exemplo: int v5[] = { 0, 11, 22 }; Podemos inicilizar todos os elementos com zero. Exemplo: int v6[5] = { };

H.3

Como criar e usar matrizes bidimensionais

Um array ndimensional também pode ser criado, no exemplo a seguir criamos um array bidimensional. Observe a forma como podemos criar a matriz identidade. Exemplo: int matriz[4][3] = { {0,1,2} {3,4,5} {6,7,8} {9,10,11} }; int imagem[4][3] = { { 0, 1, 2 } { 3, 4, 5 } { 6, 7, 8 } { 9,10,11 } }; int matrizIdentidade3x3[3][3] = { {1} {0,1} {0,0,1} };

H.4

Exemplo de uso de vetores e matrizes

O programa da listagem H.1 realiza a binariza¸caõ de imagens, isto é, a convers˜ ao de imagens em tons de cinza em imagens bin´ arias. O mesmo usa arrays (vetores e matrizes) com aloca¸caõ dinˆ amica e enumera¸co˜es. A sa´ıda do programa é ilustrada nas imagens da Figura H.1. Em (a) a imagem de origem em tons de cinza, em (c) o gr´ afico do histograma de n´ıveis de cinza e em (b) a imagem binarizada. Programa¸caõ Orientada a Objeto com C++


H.4. EXEMPLO DE USO DE VETORES E MATRIZES

709

Como pré-requisitos o programa precisa do arquivo "pstream.h" dispon´ıvel no endere¸co http://pstreams.sourceforge.net/ e anexado nas listagens do livro. O mesmo é utilizado em nosso programa para obter acesso direto ao programa gnuplot utilizando streans. Um objeto opstream esta no namespace redi. Um objeto redi::opstream é usado para enviar sequências de comandos para programas externos. O programa usa ainda o programa externo display para visualizar as imagens. Os programas gnuplot e display est˜ ao dispon´ıveis na maioria das distribui¸co˜es GNU/Linux. Como o programa trabalha com imagens, selecionamos os formatos .pgm (para imagens em tons de cinza) e .pbm (para imagens em preto e branco). Estes formatos trabalham com dados em ASCII. Veja a seguir como s˜ ao os formato .pgm e .pbm. // Formato dos arquivos PBM ( Nome . pbm ) P1 ny nx dados // Formato dos arquivos PGM ( Nome . pgm ) P2 ny nx nCores dados

Um arquivo .pgm pode ser gerado usando o programa import ou o programa convert (ambos programas de terminal). O programa import é usado para capturar uma tela (exemplo: abra um terminal e digite: import nomeImagem.pgm, a seguir selecione a região da imagem a ser capturada), o programa convert é usado para converter arquivos de imagens (exemplo: convert nomeImagem.jpg nomeImagem.pgm). Inclui nas listagens do livro a imagem imagemExterna.pgm. Os arquivos de imagens (incluindo o formato .pgm e .pbm) podem ser visualizados com o programa display ou outro visualizador qualquer. Definidos os pré-requisitos e o Tipo do arquivo de imagem, vamos a descri¸caõ do programa. O programa inicia solicitando o nome da imagem a ser aberta, no formato pgm, um formato ASCII fácil de manipular. Lê os dados de cabe¸calho do arquivo de disco, como formato e dimensões da imagem. A seguir aloca dinamicamente uma imagem 2D e seta seus valores com os dados do arquivo de disco. Para mostrar a imagem usa-se o programa display, acessado diretamente utilizando-se a fun¸caõ system("nomeDoComando"); Um vetor histograma é criado e zerado. O histograma e calculado em um for duplo, que varre toda imagem e para cada p´ıxel da imagem acumula seu valor no histograma. O gráfico do histograma é mostrado usando-se o programa externo gnuplot. A seguir o programa solicita ao usu´ ario o valor de corte (n´ıvel de cinza) e realiza a binariza¸caõ. A imagem binarizada é salva em disco. A fun¸caõ Write() é usada para salvar a imagem em disco. A mesma recebe o nome da imagem, um ponteiro para imagem, suas dimensões, além do formato da imagem. O formato pode ser PBM ou PGM, conforme definido na enumera¸caõ. A fun¸caõ AlocaMatriz2D() é usada para alocar dinamicamente uma matriz com duas dimensões. DesalocaMatriz2D() é usada para desalocar a matriz. Listing H.1: Usando arrays: Um programa de binariza¸caõ. 1 2 3 4 5 6

# include < string > # include < fstream > # include < iostream > # include < cstdlib > # include " pstream . h " using namespace std ;

// D i s p o n ´ ı v e l em http :// p s t r e a m s . s o u r c e f o r g e . net /



710 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

H.4. EXEMPLO DE USO DE VETORES E MATRIZES

// Cria e n u m e r a ¸ c~ ao enum { PBM , // = 1 PGM // = 2 }; // Salva imagem em disco bool Write ( string nomeImagem , int ** imagem , int nx , int ny , int formato = PGM ); // Aloca d i n a m i c a m e n t e m a t r i z 2 D int ** A l o c a M a t r i z 2 D ( int nx , int ny ); // D e s a l o c a d i n a m i c a m e n t e matriz 2 D bool D e s a l o c a M a t r i z 2 D ( int **& dat , int nx , int ny ); int main ( int argc , char * argv []) { int nx = 680; int ny = 480; int nCores = 256; int ** imagem = NULL ; string formato ; string nomeImagem ; cout << " Entre com o nome do arquivo de disco com a imagem ( formato pbm ou pgm ): " ; getline ( cin , nomeImagem ); // L^ e dados do a r q u i v o de disco ( formato , nx , ny , nCores ) // c_str () c o n v e r t e string de C ++ para C ifstream fin ( nomeImagem . c_str () ); if ( fin . fail ()) { cerr << " Falha abertura arquivo : " ; exit (0); } fin >> formato ; // P1 ou P2 fin >> nx ; fin >> ny ; if ( formato == " P2 " ) // PGM fin >> nCores ; imagem = A l o c a M a t r i z 2 D ( nx , ny ); // Aloca a matriz imagem // L^ e os dados da imagem do a r q u i v o de disco for ( int i = 0 ; i < nx ; i ++ ) for ( int j = 0 ; j < ny ; j ++ ) fin >> imagem [ i ][ j ]; // E x e c u t a c o m a n d o que mostra a imagem usando o p r o g r a m a d i s p l a y string comando = " display " + nomeImagem + " & " ; system ( comando . c_str ()); // e x e c u t a c o m a n d o do shell // Cria h i s t o g r a m a int * vhistogra ma = NULL ; vhistogra m a = new int [ nCores ]; if ( vhistogra ma == NULL ) { cerr << " Falha aloca¸ ca ~ o histograma : " ; exit (0); } // Zera o h i s t o g r a m a for ( int i = 0; i < nCores ; i ++ )



H.4. EXEMPLO DE USO DE VETORES E MATRIZES 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

711

vhistogra m a [ i ] = 0; // Varre a imagem e c a l c u l a h i s t o g r a m a for ( int i = 0 ; i < nx ; i ++ ) for ( int j = 0; j < ny ; j ++ ) vhistogram a [ imagem [ i ][ j ] ]++; // Salva o h i s t o g r a m a em disco ofstream a r q u i v o H i s t o g r a m a ( " histograma . dat " ); for ( int i = 0 ; i < nCores ; i ++ ) { a r q u i v o H i s t o g r a m a << vhistogram a [ i ] << endl ; } a r q u i v o H i s t o g r a m a . close (); // Cria objeto do tipo opstream , que esta no n a m e s p a c e redi . // o objeto com o nome gnuplot , vai e x e c u t a r o p r o g r a m a " g n u p l o t " redi :: opstream gnuplot ( " gnuplot " ); // Envia s e q u ^ e n c i a de c o m a n d o s d i r e t a m e n t e para o g n u p l o t // usando o objeto g n u p l o t gnuplot << " plot ’ histogram a . dat ’ title ’ Histograma de n´ ı veis de cinza ’ << " with linespoint " << endl ;

"

// S o l i c i t a o valor de corte int valorCorte ; cout << " Entre com o valor de corte : " << endl ; cin >> valorCorte ; cin . get (); // B i n a r i z a imagem for ( int i = 0 ; i < nx ; i ++) for ( int j = 0 ; j < ny ; j ++) if ( imagem [ i ][ j ] < valorCorte ) imagem [ i ][ j ] = 1; else imagem [ i ][ j ] = 0;

// Salva imagem b i n a r i z a d a Write ( string ( " i m a g e m E x t e r n a B i n a r i z a d a " ) , imagem , system ( " display i m a g e m E x t e r n a B i n a r i z a d a . pbm & " ); return 0;

nx ,

ny , PBM );

} // Salva imagem em disco bool Write ( string nomeImagem , int ** imagem , int nx , int ny , int formato ) { ofstream fout ; switch ( formato ) { case PGM : // Salva imagem no f o r m a t o pgm fout . open ( ( nomeImagem + " . pgm " ). c_str () ); if ( fout . fail ()) return 0; fout << " P2 " << endl ; fout << nx << " " << ny << " " << sizeof ( int ) << endl ; break ; case PBM : // Salva imagem no f o r m a t o pbm fout . open ( ( nomeImagem + " . pbm " ). c_str () );



712 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186

H.4. EXEMPLO DE USO DE VETORES E MATRIZES if ( fout . fail ()) return 0; fout << " P1 " << endl ; fout << nx << " " << ny << endl ; break ; }

// Salva dados de cor em disco for ( int i = 0 ; i < nx ; i ++) { for ( int j = 0; j < ny ; j ++ ) fout << imagem [ i ][ j ] << ’ ’; fout << endl ; } fout . close (); return 1; } // Aloca d i n a m i c a m e n t e m a t r i z 2 D int ** A l o c a M a t r i z 2 D ( int nx , int ny ) { int i ; // int ** dat = NULL ; // Cria p o n t e i r o nulo dat = new int *[ nx ]; // Passo 1: aloca eixo x if ( dat ) // se alocou dat c o r r e t a m e n t e { for ( i = 0; i < nx ; i ++) // zera todos os p o n t e i r o s dat [ i ] dat [ i ] = NULL ; // porque se a a l o c a c a o der errado for ( i = 0; i < nx ; i ++) // vai chamar d e s a l o c a { dat [ i ] = new int [ ny ]; // Passo 2: aloca linhas y if ( dat [ i ] == NULL ) // Se a linha nao foi a l o c a d a { // chama D e s a l o c a Para evitar D e s a l o c a M a t r i z 2 D ( dat , nx , ny ); // v a z a m e n t o de m e m o r i a return 0; } } // O que nao foi a l o c a d o esta com NULL e return dat ; // pode ser d e l e t a d o } } // D e s a l o c a d i n a m i c a m e n t e matriz 2 D bool D e s a l o c a M a t r i z 2 D ( int **& dat , int nx , int ny ) { if ( dat != NULL ) { for ( int i = 0; i < nx ; i ++) if ( dat [ i ]) delete [] dat [ i ]; // Passo 1: apaga linhas y delete [] dat ; dat = NULL ; return 1;

// Passo 2: apaga eixo x

} return 0; }

Veja na Figura H.1 as sa´ıdas geradas pelo programa de binariza¸caõ da listagem H.1. Programa¸caõ Orientada a Objeto com C++


H.5. RESUMO DO CAPÍTULO

H.5

713


Neste cap´ıtulo aprendemos a criar e usar vetores e matrizes - arrays - no estilo de C. Embora C++ apresente o container (apresentado no Cap´ıtulo 32 - Os Containers Sequênciais , , ), e as diversas fun¸co˜es genéricas (vistas no Cap´ıtulo 35 - Programa¸caõ Genérica) o uso de vetores e matrizes no estilo de C se justifica em fun¸caõ da necessidade de maior performance. Adicionalmente, aprender a usar vetores e matrizes no estilo de C se justifica em fun¸caõ da necessidade de se adaptar c´ odigos legados - c´ odigos antigos - utilizados em diversos programas de engenharia. O Cap´ıtulo ?? - A biblioteca Blitz++, apresenta a biblioteca de matrizes Blitz++, a mesma alia caracter´ısticas de boa performance e facilidade de uso.

H.6

Exerc´ıcios

1. Mude o programa da listagem H.1 de forma que o nome da imagem possa ser passado através da linha de comando (veja se¸caõ E.1).

2. Substitua o uso de display por elementos da biblioteca Magick++ (veja se¸caõ ??).

3. Crie uma máscara (uma matriz 3x3), defina seus valores como sendo 1. Crie uma imagem do tamanho da imagem original, zerada. A seguir percorra toda imagem e aplique um filtro de passa-baixa sobre a imagem. Isto é, algo parecido com:

Exemplo: int masc[3][3]={{1,1,1}{1,1,1}{1,1,1}}; for i // Varre a imagem for j. for k // Varre a m´ ascara for l imagemFiltrada[i][j] += imagem[i][j]*masc[k][l];

Nota: o c´ odigo da listagem acima esta incorreto, é parte do trabalho do aluno montar o algoritmo correto para aplicar o filtro. Programa¸caõ Orientada a Objeto com C++


H.6. EXERCÍCIOS

714

Figura H.1: As sa´ıdas do programa de binariza¸caõ.

(a) Imagem em tons de cinza

(b) Imagem binarizada

(c) O histograma da imagem em tons de cinza



Apˆ endice I

Gloss´ ario Abstra¸ c˜ ao: processo de criar uma superclasse pela extra¸caõ de qualidades comuns ou caracter´ısticas gerais de uma ou mais classes ou objetos espec´ıficos. A¸ c˜ ao: usada em modelagem dinˆ amica, se refere a opera¸caõ instantˆ anea associada a um evento. Agente: veja objeto ativo. Agrega¸ c˜ ao: forma especial de associa¸caõ entre o todo e suas partes, no qual o todo é composto de partes. Agregado fixo: quando o n´ umero de partes é definido. Agregado recursivo: quando o objeto pode conter a si próprio. Agregado vari´ avel: quando o n´ umero de partes é indefinido. Algoritmo: conjunto de etapas ordenadas de forma espec´ıfica, utilizadas para solucionar um problema, tal como uma f´ ormula matemática ou uma série de instru¸co˜es de um programa. Ambiente de janelas: interface gr´ afica com janelas m´ ultiplas na tela de um computador. Ambiente windows: veja ambiente de janelas. Amigo: classes amigas permitem o compartilhamento de métodos e atributos. An´ alise orientada a objeto: an´ alise dos requisitos de um sistema em termos de objetos reais. Realizada sem considerar os requisitos de implementa¸caõ. Ancestral imediato: aquele que é identificado na declara¸caõ do objeto. Arquitetura: estrutura geral de um sistema, incluindo a sua divisão em subsistemas e suas aloca¸co˜es para tarefas e processadores. Assinatura: para um atributo, o tipo do atributo, para uma opera¸caõ (método ou fun¸caõ), o nome da opera¸caõ, seus parˆ ametros e o tipo de retorno. Associa¸ c˜ ao derivada: definida em termos de outras associa¸co˜es. Associa¸ c˜ ao qualificada: associa¸caõ que relaciona duas classes e um qualificador. Associa¸ c˜ ao tern´ aria: associa¸caõ entre três classes. 715

716 Associa¸ c˜ ao: relacionamento entre duas ou mais classes descrevendo um grupo de liga¸co˜es com estruturas e semânticas comuns. Atividade (em modelagem dinˆ amica): opera¸caõ que leva tempo para terminar. Est´ a relacionada a estados e representa acontecimentos do mundo real. Atributo de classe: atributo que existe na classe e n˜ ao nos objetos. Todos os objetos da classe têm acesso ao atributo de classe, mas este é u ´ nico. Ator: objeto ativo que pode gerar eventos. Atributo: uma propriedade ou caracter´ıstica de um objeto. Atributo de evento: dados transportados por um evento. Atributo de associa¸ c˜ ao: atributo que existe em fun¸caõ de uma associa¸caõ entre dois objetos. Atributo derivado: atributo que é calculado a partir de outros atributos. Banco de dados: uma cole¸caõ de dados armazenados e gerenciados eletronicamente. Biblioteca de classes: uma cole¸caõ de classes genéricas que podem ser adaptadas para uma aplica¸caõ particular. Caixa-preta: met´ afora utilizada em engenharia para descrever um dispositivo em que os componentes internos s˜ ao desconhecidos pelo usu´ ario. Os objetos s˜ ao como caixas-pretas em que seus funcionamentos internos ficam ocultos aos usuários e programadores. Cancelar: definir um método em uma classe-derivada que substitui o método ancestral. Caracter´ıstica: é uma palavra genérica para atributos e métodos. Cen´ ario (em modelagem dinˆ amica): seq¨ uência de eventos que ocorre durante uma determinada execu¸caõ do sistema. Classes: sinˆ onimo de tipos de objeto (f´ abrica de objetos). Classe abstrata: classe que n˜ ao pode gerar objetos. Classe concreta: classe que pode gerar objetos. Classe-base: classe que tem classes herdeiras (tem uma ou mais classes filhas). Classe-derivada: classe herdeira (tem um ou mais pais). Classe-filho: o mesmo que classe-derivada. Classe-pai: o mesmo que classe-base. CORBA: Common Object Request Broker Arquiteture. CREW: Concurrent Read, Exclusive Write. CRCW: Concurrent Read, Concurrent Write. C´ odigo aberto: express˜ ao utilizada para indicar que você pode ver o c´ odigo-fonte do programa. Entretanto, nada pode ser dito a respeito das condi¸co˜es sob as quais o c´ odigofonte se encontra. Existem programas de c´ odigo aberto que n˜ ao s˜ ao livres, pois o usuário, dependendo da licen¸ca, pode ser proibido de alterar e publicar o c´ odigo. Programa¸caõ Orientada a Objeto com C++


717 C´ odigo reentrante: c´ odigo usado em bibliotecas compartilhadas. O mesmo c´ odigo pode ser usado por diferentes programas ao mesmo tempo (n˜ ao usa internamente vari´ aveis est´ aticas). Coerˆ encia: propriedade de uma entidade, como uma classe, uma opera¸caõ ou módulo, tal que ela se organize em um plano consistente e todas as suas partes se ajustem no sentido de um objetivo comum. Cole¸ c˜ ao de lixo: rotina de gerenciamento de memória que pesquisa a memória por segmentos de programa, dados ou objetos que n˜ ao se encontram mais ativos, e recupera o espa¸co n˜ ao utilizado. Compilador: programa que traduz uma linguagem de programa¸caõ para a linguagem de máquina. Concorrˆ encia: a capacidade de programas orientados a objeto de se comunicarem em multitarefa. Concorrente: duas ou mais tarefas, atividades ou eventos cujas execu¸co˜es podem se sobrepˆ or no tempo. Condi¸ c˜ ao: usada em modelagem dinˆ amica, se refere a fun¸caõ booleana de valores de objetos válidos durante um intervalo de tempo. Construtor: método especial que é utilizado para inicializar todos os atributos de um objeto. Consulta: é uma opera¸caõ (método) que, quando executada n˜ ao altera o objeto. Dados persistentes: dados que continuam existindo mesmo ap´ os encerrada a execu¸caõ de um programa. Debuger: programa que permite ao usu´ ario corrigir erros de software por intermédio do exame e altera¸caõ do conte´ udo da mem´ oria, e iniciar ou parar a execu¸caõ em um local predeterminado ou breakpoint. Serve para localizar e alterar erros de l´ ogica de um programa ou para corre¸co˜es em um programa. Depurador: veja Debuger. Delega¸ c˜ ao: mecanismo de implementa¸caõ no qual um objeto, em resposta a uma opera¸caõ nele próprio, repassa a opera¸caõ para outro objeto. Projeto orientado a objeto: tradu¸caõ da estrutura l´ ogica de um sistema em uma estrutura f´ısica composta de objetos de software. Destrutor: libera os objetos dinamicamente alocados e destr´ oi o objeto. Podem ser expl´ıcitos ou impl´ıcitos; se expl´ıcitos (declarados), podem liberar outros tipos de dados e realizar outras fun¸co˜es. Diagrama de seq¨ uˆ encia: diagrama que mostra o remetente e o receptor (eventos e mensagens). Diagrama de atividade: diagrama que mostra o movimento de dados e seu processamento manual ou por computador. Diagrama de objetos: representa¸caõ gr´ afica de objetos mostrando os relacionamentos, atributos e opera¸co˜es. Diagrama que mostra o relacionamento de objetos entre si. Programa¸caõ Orientada a Objeto com C++


718 Dicion´ ario de dados: par´ agrafo que descreve uma classe, seus atributos, métodos e associaço˜es. Discordˆ ancia de nome: conflito que pode ocorrer em hereditariedade m´ ultipla quando o mesmo método ou atributo de instância for herdado de m´ ultiplas classes. DCS: Decomposition, communication, and synchrinization. Encapsulamento: casamento do c´ odigo com os dados dentro de uma unidade de objeto. Isto representa a modularidade aplicada aos dados. O encapsulamento torna invis´ıveis os dados para o usuário, embora os métodos permane¸cam vis´ıveis. Escala: o relacionamento entre três elementos é chamado escala. Escalabilidade: possibilidade de alterar as configura¸co˜es do sistema de acordo com as necessidades. Especializa¸ c˜ ao: a cria¸caõ de classes-derivadas (subclasses) a partir de uma classe-base (ou superclasse) por meio do refinamento da classe-base. EREW: Exclusive Read, Exclusive Write. ERCW: Exclusive Read, Concurrent Write. Estado: valores dos atributos e liga¸co˜es de um objeto em um determinado momento. Evento: usado em modelagem dinˆ amica, se refere a algo que acontece instantaneamente. Expansibilidade: expandir um programa sem ter em mãos o c´ odigo-fonte. Extens˜ ao (em generaliza¸caõ): o acréscimo de novas caracter´ısticas por meio de uma subclasse. Extensibilidade: habilidade de um programa ou sistema em ser facilmente alterado para que possa tratar novas classes de entrada. Folha: mecanismo de subdivisão de um modelo de objetos em uma série de p´ aginas. Framework: uma biblioteca de classe ”afinada”especialmente para uma determinada categoria de aplica¸caõ. M´ etodo virtual: método especial chamado por intermédio de uma referência de classe b´ asica ou indicador, carregado dinamicamente em tempo de execu¸caõ. GNU: acrˆ onimo para ”GNU n˜ ao é Unix”. GNU é o nome de um sistema operacional completo e compat´ıvel com Unix escrito a partir de 1983, por Richard Stallman e in´ umeros hackers da comunidade de software livre espalhados pela Internet. O GNU é um sistema totalmente livre, ou seja, ele fornece as quatro liberdades b´ asicas do software livre: a liberdade de uso, modifica¸caõ, c´ opia e publica¸caõ de vers˜ oes modificadas. Atualmente o sistema GNU é largamente utilizado, especialmente na sua variante GNU/Linux. GNU/Linux: sistema operacional GNU totalmente livre que utiliza o Linux como kernel. GNU/Linux é a variante mais conhecida do sistema GNU. O sistema GNU original às vezes é referenciado como GNU/Hurd para maior clareza. Programa¸caõ Orientada a Objeto com C++


719 GPL: licen¸ca de software livre mais utilizada no mundo. Caracteriza-se por ser uma licen¸ca com ”Copy-left”, ou seja, qualquer trabalho derivado de qualquer parte de um software livre licenciado sob GPL obrigatoriamente deve permanecer livre. A GPL pode ser obtida em http://www.gnu.org/licenses/gpl.html. Gerenciamento de mem´ oria: a maneira pela qual o computador trata a sua memória. Inclui prote¸caõ de mem´ oria e quaisquer outras técnicas de memória virtual. Gr´ aficos orientados a objeto: programas que têm a fun¸caõ de desenhar e que s˜ ao apresentados ao usu´ ario sob a forma de objetos na tela. Heran¸ ca: a propriedade de todos os tipos de objetos que permite a um tipo ser definido como herdando todas os atributos e métodos contidos no pai. Handle: vari´ avel utilizada pelo sistema operacional para identificar um objeto. Heran¸ ca m´ ultipla: permite a um objeto herdar métodos e atributos de mais de um pai. Heran¸ ca repetida: quando um objeto é descendente de outro por mais de um caminho. Hereditariedade: mecanismo usado para compartilhar métodos e tipos de dados automaticamente entre classes, subclasses e objetos. N˜ ao é encontrado em sistemas de procedures. Permite programar apenas as diferen¸cas de classes previamente definidas. Hierarquia: descri¸caõ de um sistema que conta com uma estrutura constru´ıda em n´ıveis diferentes. Os n´ıveis mais altos controlam os mais baixos. Hierarquia de objetos (estrutura): diagrama que mostra o relacionamento dos objetos. ´ Icone: representa¸caõ gr´ afica de um objeto. Identidade do objeto: algo sobre o objeto que permanece invari´ avel entre todas as possibilidades de modifica¸caõ de seu estado. Pode ser usado para indicar um objeto. Informa¸ c˜ ao escondida/oculta: recurso de programa¸caõ pelo qual a informa¸caõ dentro de um módulo permanece privada a ele. Estratégia de design que visa a maximizar a modularidade ocultando o maior n´ umero poss´ıvel de informa¸co˜es dentro dos componentes de um design. Instˆ ancia: objeto que faz parte de uma classe. Instancia¸ c˜ ao: processo de cria¸caõ de instâncias a partir de classes. Invariante: declara¸caõ sobre alguma condi¸caõ ou relacionamento que deve ser sempre verdadeiro. Janela: área de visualiza¸caõ separada em uma tela de exibi¸caõ fornecida pelo software. Os ambientes gr´ aficos dos sistemas operacionais podem mostrar janelas m´ ultiplas na tela, permitindo que o usu´ ario mantenha vários programas aplicativos ativados e vis´ıveis ao mesmo tempo. Os programas aplicativos individuais também contam com janelas m´ ultiplas, oferecendo capacidade de visualiza¸caõ para mais de um documento, planilha ou arquivo de dados. Kernel : parte fundamental de um programa como um sistema operacional, residente todo o tempo em mem´ oria. Programa¸caõ Orientada a Objeto com C++


720 Largura de banda: n´ umero de ”canos” por onde os dados fluem. Quanto maior a largura de banda, maior a velocidade com que os dados fluem do processador para a memória e para os dispositivos (placa de rede, monitor). Latˆ encia: tempo perdido com a comunica¸caõ entre os diversos dispositivos. Linux: clone livre do kernel do Unix, escrito a partir do zero por Linus Torvalds, com a ajuda de um grupo de programadores espalhado pela Internet. Ele objetiva estar em conformidade com o POSIX e com a Single Unix Specification. Ap´ os mostrar-se mais est´ avel e simples que o HURD (kernel original do GNU), o Linux foi inclu´ıdo no sistema GNU tornando-o pronto para conquistar o mercado com a variante GNU/Linux. Liga¸ c˜ ao: processo de organizar um programa para solucionar todas as conex˜ oes entre seus componentes. Estaticamente, as liga¸co˜es s˜ ao definidas na compila¸caõ. Dinamicamente, a liga¸caõ ocorre quando o programa est´ a rodando. Liga¸ c˜ ao a posteriori (dinˆ amica): um método que permite chamar outros métodos cujo endere¸co n˜ ao é conhecido em tempo de compila¸caõ/linkedi¸caõ. O endere¸co s´ o é conhecido durante a execu¸caõ. Liga¸ c˜ ao a priori/anterior: método tradicional de compila¸caõ pelo qual os endere¸cos dos métodos e fun¸co˜es s˜ ao determinados na etapa de linkagem. Liga¸ c˜ ao est´ atica: veja liga¸caõ a priori. Linguagem concorrente: linguagem que permite a execu¸caõ simultˆ anea de objetos m´ ultiplos, geralmente com arquitetura de hardware paralela. Linguagem n˜ ao procedural: linguagem de programa¸caõ que gera a l´ ogica para o programa diretamente a partir da descri¸caõ do problema pelo usuário, em vez de um conjunto de procedures baseadas em l´ ogica de programa¸caõ tradicional. Linguagem orientada a objeto: linguagem de computador que suporta objetos, classes, métodos, mensagens e hereditariedade. As caracter´ısticas secundárias podem incluir hereditariedade m´ ultipla, liga¸caõ dinˆ amica e polimorfismo. Linguagem procedural: linguagem de programa¸caõ como COBOL, FORTRAN, BASIC, C e Pascal, baseada na utiliza¸caõ de ordem particular de a¸co˜es e que tem conhecimento das opera¸co˜es de processamento de dados e técnicas de programa¸caõ. Manuten¸ c˜ ao: capacidade de um programa ou sistema para transformar reparos de bugs e aumentar a funcionalidade a fim de satisfazer ` as necessidades do usuário. MIMD: Multiple Instruction Stream, Multiple Data Stream. Cada processador atua de forma independente. Implementado utilizando cluster. Mem´ oria compartilhada: em máquinas com mais de um processador - SMP, a memória costuma ser compartilhada (os processadores podem acessar a mesma memória). Multitasking: o conceito de ”multitasking” gerenciado pelo sistemas operacional (ex: GNU/Linux), possibilitando que m´ ultiplas tarefas sejam executadas simultaneamente através da divisão do tempo do(s) processador (es). Se você tem ”n” tarefas em um sistema o ideal é ter ”n” processadores no mesmo sistema ou utilizar um cluster que lhe ofere¸ca n processadores. O Sistema operacional controla a troca dos processos dando a cada um deles uma por¸caõ de tempo. Quando o tempo do processo encerra, o SO salva os dados do processo que esta sendo executado e passa a execu¸caõ para o próximo processo. Programa¸caõ Orientada a Objeto com C++


721 Multi tasking operating system: sistema operacional que roda mais de uma tarefa de cada vez. Cada tarefa utiliza o processador por um determinado tempo. Multi tasking operating system em sistemas multiprocessados: o sistema operacional é multitarefa e o computador tem mais de um processador. Ex.: Sun-Solaris rodando em uma esta¸caõ de trabalho SUN-Enterprise E450. Multisession: um sistema operacional multisession admite que mais de um usuário esteja logado, rodando mais de uma se¸caõ (ex: GNU/Linux). Multiprocessing: um sistema operacional que possibilita a execu¸caõ de mais de um processo por se¸caõ. Multithreading: um sistema operacional que possibilita que um processo tenha mais de uma thread. Mensagem: solicita¸caõ enviada a um objeto para alterar seu estado ou retornar um valor. A mesma mensagem pode ser enviada para objetos diferentes porque eles simplesmente informam a um objeto o que fazer. Os métodos definidos dentro de um objeto receptor determinam como ser´ a executada a solicita¸caõ. Veja método/polimorfismo. Metaclasse: classe que descreve outras classes. Metadados: s˜ ao dados que descrevem outros dados. Por exemplo, uma defini¸caõ de uma classe. M´ etodo: um método é uma fun¸caõ que é definida como pertencendo a um tipo de objeto. Implementa a resposta quando uma mensagem é enviada a um objeto. Os métodos determinam como um objeto responderá a uma mensagem. Veja mensagens. M´ etodo de implementa¸ c˜ ao (estilo): método que realiza o processamento de dados sem realizar qualquer tomada de decis˜ oes. M´ etodo est´ atico: implementado usando a liga¸caõ a priori. M´ etodo pol´ıtico: método que realiza o processamento de tomadas de decis˜ oes. N˜ ao realiza processamento de dados. M´ etodo virtual: implementado usando a liga¸caõ a posteriori. Metodologia: em engenharia de software, é o processo de produ¸caõ organizada de um programa, utilizando técnicas e conven¸co˜es conhecidas. Movimento pelo software livre: movimento surgido na década de 1970 em conseq¨ uência da crescente press˜ ao recebida para a ado¸caõ de softwares propriet´ arios e assinaturas de tratados de n˜ ao-divulga¸caõ. O movimento intensificou-se a partir da década de 1980 com o projeto GNU que libertava os usuários dos sistemas UNIX propriet´ arios. O GNU consolidou-se na década de 1990 como um sistema completo e funcional, atingindo uma qualidade técnica comparável aos melhores sistemas operacionais propriet´ arios. Modelo funcional: descri¸caõ dos aspectos de um sistema que transforma valores utilizando fun¸co˜es, mapeamentos, restri¸co˜es e dependências funcionais. Modularidade: a constru¸caõ de um programa em módulos. Programa¸caõ Orientada a Objeto com C++


722 Multiplicidade: n´ umero de instâncias de uma classe que podem relacionar-se a uma u ´ nica instância de outra classe. MPP: massive parallel processing (um computador com vários processadores). Objeto: elemento prim´ ario em um programa orientado a objeto. Objetos s˜ ao entidades que encapsulam dentro de si próprios os dados que descrevem o objeto e as instru¸co˜es para operar esses dados. Objeto ativo: um objeto que monitora eventos ocorrendo em uma aplica¸caõ e assume a a¸caõ ` vezes chamado de agente. por si próprio. As Objeto passivo: objeto que atua somente por solicita¸caõ. Objeto polim´ orfico: o descendente herda a forma do ancestral (métodos), mas pode redefinir os métodos assumindo outras formas (polimorfismo). Open source initiative: grupo desmembrado do movimento pelo software livre em 1998, que rejeita a luta pela liberdade no uso do software. Seu objetivo é disseminar a idéia de que c´ odigo-fonte dispon´ıvel e com modifica¸caõ permitida gera melhores programas. Apesar de n˜ ao endossar o esp´ırito de liberdade, esse grupo costuma recomendar o uso da licen¸ca GPL. Opera¸ c˜ ao abstrata: opera¸caõ declarada, mas n˜ ao implementada. Opera¸ c˜ ao de classe: opera¸caõ que é realizada pela classe e n˜ ao pelas instâncias desta. S´ o pode manipular os atributos de classe. Opera¸ c˜ ao: fun¸caõ ou método que pode ser aplicado por um objeto. Orientado por objeto: termo para prática de programa¸caõ ou compiladores que agrupam elementos individuais de programa¸caõ em hierarquias de classes, permitindo que objetos do programa compartilhem o acesso a dados e procedimentos sem redefini¸caõ. POSIX: Portable Operation System Interface - IEEE-STD 1003.1-2001. Pai-filho: maneira de expressar a rela¸caõ entre classes e subclasses. As classes-filho ou subclasses herdam os métodos e atributos de instância da classe-pai. Por meio da hereditariedade m´ ultipla, um filho pode ter diversos pais. Papel: uma extremidade de uma associa¸caõ. Paradigma: Extra´ıdo de http://pt.wikipedia.org/wiki/Paradigma. Paradigma é a repre´ um pressuposto filos´ senta¸ca õ do padr˜ ao de modelos a serem seguidos. E ofico matriz, ou seja, uma teoria, um conhecimento que origina o estudo de um campo cient´ıfico; uma realiza¸ca õ cient´ıfica com métodos e valores que s˜ ao concebidos como modelo; uma referência inicial como base de modelo para estudos e pesquisas. Na filosofia grega, paradigma era considerado a fluência de um pensamento, pois através de v´ arios pensamentos do mesmo assunto é que se concluia a idéia, seja ela intelectual ou material, depois dela realizada surgiam outras idéias até chegar a uma conclus˜ ao final. Paradigmas h´ıbridos: linguagens h´ıbridas como o C++, que fazem uso de técnicas de programa¸caõ OOP e estruturada. Pilha: a´rvore binária completa em que os nodos contêm chaves de pesquisa organizadas em ordem descendente. Programa¸caõ Orientada a Objeto com C++


723 Polimorfismo: propriedade de compartilhar uma a¸caõ simples. Cada classe-derivada implementa os métodos de forma apropriada as suas necessidades. Habilidade de a mesma mensagem ser interpretada de maneiras diferentes quando recebida por objetos diferentes. Por exemplo, a impressão de uma mensagem, quando enviada a uma figura ou diagrama, aciona um método ou implementa¸caõ diferente daquele que a mesma mensagem de impressão envia a um documento. Pr´ e-processador: programa de software que executa procedimentos preliminares na entrada de dados antes da execu¸caõ do programa principal. Por exemplo, o c´ odigo-fonte C++ é comumente pré-processado e traduzido para o c´ odigo-fonte C antes de ser compilado. Privado: os métodos e atributos pertencentes a uma classe s˜ ao privados por default. Os elementos privados s´ o podem ser acessados por métodos que perten¸cam à classe, desde que esta n˜ ao seja descendente (s´ o acessado pela classe). Processamento distribu´ıdo: sistema de computadores ligados por uma rede de comunica¸co˜es com cada sistema gerenciando sua própria carga local e a rede suportando o sistema como um todo. Processo: alguma coisa que transforma valores de dados. Programa: conjunto de instru¸co˜es que informam ao computador o que fazer. Um programa é escrito em uma linguagem de programa¸caõ e é convertido em linguagem de máquina por meio de softwares chamados montadores e compiladores. Programa¸ c˜ ao estruturada: filosofia de programa¸caõ voltada ao gerenciamento de complexidade por meio da formaliza¸caõ e padroniza¸caõ da metodologia de programa¸caõ. A programa¸caõ estruturada é caracterizada pela sua apresenta¸caõ top-down. Programa¸ c˜ ao orientada ao objeto: metodologia usada para a cria¸caõ de programas por intermédio da utiliza¸caõ de objetos auto-suficientes com dados e o comportamento encapsulados e que atuam por meio de solicita¸caõ e interagem com outros, enviando e devolvendo mensagens. Programa¸ c˜ ao top-down: metodologia que cria um programa modular de estrutura hier´ arquica. Primeiro, o desenhista projeta, codifica e testa um m´ odulo que representa a estrutura do programa e depois continua da mesma maneira criando módulos de n´ıvel mais baixo, que representam suas subfun¸co˜es. Programa¸ c˜ ao visual: categoria genérica de aplicativos que executam programa¸caõ gráfica e seus efeitos visuais ao usu´ ario. Por exemplo, em pacotes de desenho os objetos podem ser desenhados, aumentados e até modificados por meio de manipula¸co˜es diretas da imagem na tela e n˜ ao pela altera¸caõ de dados numéricos em uma tabela de dimensões. Protegido: podem ser acessados pela classe e pelas classes derivadas. Protocolo: conjunto de mensagens as quais o objeto pode responder. P´ ublico: os métodos declarados como public podem ser acessados pela classe, classe derivadas, e por aplica¸co˜es (dentro de main(), por exemplo). Qualificador: atributo de um objeto que faz a distin¸caõ entre o conjunto de objetos na extremidade muitos de uma associa¸caõ. Recurs˜ ao: habilidade de uma sub-rotina ou módulo de programa em chamar a si mesmo. Programa¸caõ Orientada a Objeto com C++


724 Redefini¸ c˜ ao: propriedade das classes derivadas de modificar os métodos da classe-pai. Assim, duas classes-irm˜ as (filhas do mesmo pai) podem ter métodos com o mesmo nome, mas com realiza¸co˜es diferentes. Restri¸ c˜ ao: usado em generaliza¸co˜es, se refere a limita¸caõ que uma subclasse coloca no valor de um atributo contido em uma superclasse. Robusto: um software robusto n˜ ao é facilmente destru´ıdo por erros em seus pressupostos. Conta com verifica¸co˜es internas que objetivam eliminar bugs. Simula¸ c˜ ao: representa¸caõ matemática da intera¸caõ de objetos do mundo real. Software livre: software que garante ao usu´ ario plenas liberdades de uso, modifica¸caõ, c´ opia e publica¸caõ de vers˜ oes modificadas. A defini¸caõ de software livre pode ser encontrada em http://www.gnu.org/philosophy/free-sw.html. Sobrecarga de operador: defini¸caõ da forma como o operador atua sobre os atributos da classe. Subclasse: refinamento de uma classe em uma outra mais especializada (classe-derivada ou filho). Superclasse: em uma hierarquia, uma classe mais genérica que armazena atributos e métodos que podem ser herdados por outras classes. Algumas vezes tratada como classe-base ou pai. SMP: single multiple processor (com mem´ oria compartilhada). SIMD: Single Instruction Stream, Multiple Data. Todos os processadores executam a mesma opera¸caõ ao mesmo tempo. Muito utilizado no processamento de vetores e matrizes, fácil de implementar. Implementado utilizando swar ou smp. SPMD: Single Program, Multiple Data. Todos os processadores rodam o mesmo programa. Implementado utilizando cluster. Single tasking operating system: sistema operacional que roda somente uma tarefa de cada vez. Ex.: DOS. Tabelas dos m´ etodos virtuais (VMT): tabela que aparece no segmento de dados de cada tipo de objeto virtual. A VMT contém o tamanho do objeto (tamanho do registro) e os ponteiros para os métodos. this: ponteiro para o objeto definido implicitamente. Usado para resolver conflitos de nomes dentro de um método da classe. Tipifica¸ c˜ ao: propriedade de uma linguagem de distinguir com clareza os tipos definidos. A tipifica¸caõ forte (C++) ajuda a desenvolver softwares mais robustos. Tipo ancestral: todo tipo herdado por qualquer outro tipo de objeto. Tipo de dados abstratos: conjunto de estruturas de dados (tipos de dados) definido em termos de recursos de estruturas e de opera¸co˜es executadas sobre elas. Na POO, os tipos de objetos s˜ ao tipos de dados abstratos. Programa¸caõ Orientada a Objeto com C++


725 Troca de mensagens: Sistema pelo qual o processamento é distribu´ıdo pelas várias máquinas do cluster. Os dados s˜ ao enviados de uma máquina para outra, processados e devolvidos. As bibliotecas para troca de mensagem mais utilizadas s˜ ao o MPI e o PVM. Unix: sistema operacional multiusuário e multitarefa que trata os dados que foram designados a ele até aparecer um novo valor ou o programa terminar sua execu¸caõ. Vari´ avel de instˆ ancia: dado contido em um objeto que descreve propriedades do objeto que a possui. Vari´ avel global: vari´ avel acess´ıvel a todos os módulos de um programa. Vari´ avel: uma estrutura em mem´ oria que trata os dados que foram designados a ela até aparecer um novo valor ou o programa terminar a sua execu¸caõ. Virtual: ambiente simulado ou conceitual. Realidade virtual, por exemplo, é uma realizada simulada. Windows: veja janela. WBS: Work Breakdown Structure.



726



Apˆ endice J

Links Para Sites em C++ Apresenta-se a seguir uma lista de links relacionados a programa¸caõ em C++, e aos diversos temas apresentados neste livro.

J.1

Bookmark

O bookmark que utilizo para acessar diversos sites de programa¸caõ, incluindo os links apresentados neste cap´ıtulo est´ a disponibilizado em: • http://www.lenep.uenf.br/~bueno/bookmarks-prog.html Uma c´ opia do mesmo é distribu´ıda juntamente com as listagens de programas deste livro. Nota: é importante lembrar que sites de internet mudam constantemente, de forma que alguns links podem n˜ ao estar mais dispon´ıveis.

J.2

HOWTO - Como fazer

Veremos a seguir uma lista de HOWTOs relacionados direta ou indiretamente com programa¸caõ em C++, desenvolvimento de software livre, software multiplataforma, cluster de computadores e programa¸caõ paralela. • C++ Programming HOWTO. • C++ Beautiful HOWTO. • CVS RCS HOWTO (document for Linux Source Code Control System). • GCC HOWTO. • Program Library HOWTO. • Kernel HOWTO (kernel do GNU/Linux). • Beowulf HOWTO. • Parallel Processing HOWTO. • Serial Programming HOWTO. 727

728

J.3. SITES UML

• Glibc 2 HOWTO. • Software Release Practice HOWTO. • Bash Prog Intro HOWTO. • BASH Programming Introduction HOWTO. • C editing with VIM HOWTO. • Emacs Beginner HOWTO. Esses HOWTOs podem ser obtidos nos sites: • http://www.tldp.org/HOWTO/HOWTO-INDEX/howtos.html, • http://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/ps/.

J.3

Sites UML

• UML no Brasil: http://www.uml.com.br • Object management group: http://www.omg.org • Referência r´ apida: http://www.rational.com/uml/resources/quick/ • UML Tutorial in 7 days: http://odl-skopje.etf.ukim.edu.mk/UML-Help/ • Softwares de modelagem: – http://www.microgold.com – http://www.rational.com/products/rose – http://www.visual-paradigm.com – http://www.gnome.org/gnome-office/dia.shtm – http://bouml.free.fr/ • Programa¸caõ Orientada para Objeto em C++ no Ambiente Windows: http://www.fea.usp.br/Fia/livros/95/liv95-ProgOrientC++.html • Object-Oriented Technologies Ltd : http://www.realobj.demon.co.uk/ • Welcome to OOP’s world : http://oop.rosweb.ru/ • Bibliografia: http://liinwww.ira.uka.de/bibliography/Object/index.html Programa¸caõ Orientada a Objeto com C++


J.4. SITES C++

J.4 J.4.1

729

Sites C++ Ambientes de desenvolvimento

• Kdevelop, ambiente multiplataforma e multilinguagem, completo, com uso da biblioteca QT ou KDE: kdevelop http: // www. kdevelop. org/ • Bloodshed Dev-C++(Windows, GNU/Linux): http://www.bloodshed.net/dev/devcpp.html • The Source-Navigator IDE, (GNU/Linux, Unix): http://sources.redhat.com/sourcenav/ • Kylix, ambiente com uso da biblioteca VCL (Visual Class Library) (GNU/Linux, Unix, Windows): http://www.borland.com/kylix/index.html • Code Warrior Metroworks, ambiente com uso da biblioteca code warrior : http://www.metrowerks.com • Qt - designer, desenho de interfaces gráficas usando a biblioteca Qt (Windows, GNU/Linux, Unix, Mac): http://www.trolltech.com • Veja uma pequena reportagem sobre o Qtdesigner na Revista do Linux, edi¸caõ 31: http://www.revistadolinux.com.br/ed/031/assinantes/programacao.php3 • glade, desenho de interfaces gr´ aficas usando a biblioteca gtk++ (GNU/Linux, Unix): http://glade.gnome.org/ • GTK+ - The GIMP Toolkit: http://www.gtk.org/ • Source-Navigator(TM): http://sources.redhat.com/sourcenav/ • Anjuta [DevStudio] : http://www.anjuta.org/ • Eclipse: http://www.eclipse.org/

J.4.2

Compiladores

• Intel: http://www.intel.com/software/products/compilers/ • Borland: http://www.borland.com/cbuilder • Metroworks: http://www.metrowerks.com/ • Microsoft Visual C++: http://msdn2.microsoft.com/en-us/visualc/default.aspx Programa¸caõ Orientada a Objeto com C++


730

J.4.3

J.4. SITES C++

Exemplos

Você pode baixar um conjunto de exemplos de programas em C++ em: • www.deitel.com • ftp://ftp.cs.rpi.edu/pub/stl • http://www.tempest-sw.com/cpp • Outros exemplos no site da disciplina de programa¸caõ prática: https://www.lenep.uenf.br/~bueno/DisciplinaProgramacaoPratica/

J.4.4

Tutoriais

Uma lista completa de tutoriais pode ser encontrada em: • http://www.mysteries-megasite.com/linux/tutorials.html • Tutorial de C++ para programadores de C: http://www.4p8.com/eric.brasseur/cppcen.html • GTK: http://www.gtk.org/tutorial/ • NIST Course on C++ Programming for Scientists: http://math.nist.gov/~RPozo/c++class/ • Diversos: – http://www.freetutorials.com/ – http://www.mysteries-megasite.com/linux/tutorials.html – http://www.cplusplus.com/doc/tutorial/ – http://www.intap.net/~drw/cpp/index.htm

J.4.5

FAQ

• http://help-site.com/c.m/prog/lang/cpp/ • http://www.jamesd.demon.co.uk/csc/faq.html

J.4.6

Usu´ arios avan¸cados de C++

• Você encontra em http://www.gotw.ca/publications/, diversas dicas de links do autor Herb Sutter. De um modo geral s˜ ao dicas avan¸cadas. • Dicas de gerenciamento de mem´ oria: http://www.arnaut.eti.br/op/CPPFL16.htm. Programa¸caõ Orientada a Objeto com C++


J.5. SITES STL - STANDART TEMPLATE LIBRARY

J.5

731

Sites STL - Standart Template Library

• Comite Ansi C++: http://www.open-std.org/jtc1/sc22/WG21/ • Guia STL da GNU: http://gcc.gnu.org/onlinedocs/libstdc++/documentation.html • Guia STL: http://www.sgi.com/tech/stl/ • Phil Ottewell’s STL Tutorial : http://www.yrl.co.uk/~phil/stl/stl.htmlx • Standard C++ Library User Guide and Tutorial : http://www.roguewave.com/support/docs/stdug/index.cfm • STL Quick Reference: http://yotam.freehosting.net/stl/stl.html

J.6 J.6.1

Sites Programa¸c˜ ao multiplataforma (GNU/Linux) Software Livre

• GNU: – http://www.gnu.org – ftp://ftp.matrix.com.br/pub/gnu/ • Open-source: http://www.opensource.org • Reposit´ orio de programas livres: http://www.sourceforge.net • Software Livre - Unicamp (Nou-Rau): – http://www.dicas-l.unicamp.br – http://www.rau-tu.unicamp.br/nou-rau/softwarelivre/ – http://www.softwarelivre.unicamp.br/sl – http://www.rau-tu.unicamp.br/ – http://www.rau-tu.unicamp.br/linux/ • Site com referências para comandos do shell: http://www.ss64.com/index.html • Linux pdfs: http://users.urbi.com.br/ricardomartins/Linux/ • Idéias/Discuss˜ oes: http://www.dicas-l.com.br/brod/ Programa¸caõ Orientada a Objeto com C++


732

J.6.2

˜ MULTIPLATAFORMA (GNU/LINUX) J.6. SITES PROGRAMAC ¸ AO

Portabilidade

• Guia de Portabilidade: http://www.angelfire.com/country/aldev0/cpphowto/cpp_PortabilityGuide.html

J.6.3

Software multiplataforma

• GCC Home Page - GNU Project - Free Software Foundation (FSF): http://gcc.gnu.org/ • Mirror da GNU : ftp://ftp.matrix.com.br/pub/gnu/ • autoconf : http://www.gnu.org/software/autoconf/ • automake: http://www.gnu.org/software/automake/ • libtool : http://www.gnu.org/software/libtool/ • GNU Autoconf, Automake and Libtool : http://sources.redhat.com/autobook/ • GNU Coding Standards (FSF): http://www.gnu.org/prep/standards_toc.html • Autoconf, Automake, and Libtool: C Language Portability: http://sources.redhat.com/autobook/autobook/autobook_111.html • LUV talk: An introduction to Linux/Unix programming: http://www.luv.asn.au/overheads/prog/

J.6.4

Auditoria e profiler

Programas de auditoria e profilers • valgrind : http://valgrind.org/ • callgrind : http://spi.cern.ch/extsoft/packages.php?pkg=callgrind • oprofile: http://oprofile.sourceforge.net/ • kcachegrind : http://kcachegrind.sourceforge.net/cgi-bin/show.cgi • Manual do gprof : http://www.delorie.com/gnu/docs/binutils/gprof_toc.html Programa¸caõ Orientada a Objeto com C++


˜ PARALELA J.7. SITES CLUSTER E PROGRAMAC ¸ AO

J.6.5

733

CVS

• A casa do cvs: http://www.cvshome.org/ • Interface gr´ afica para o cvs: – http://www.cvsgui.org/download.html – http://www.lincvs.org • Interface gr´ afica para o cvs no GNU/LINUX: – http://cervisia.sourceforge.net/

J.6.6

Documenta¸c˜ ao

• Doxygen: http://www.stack.nl/~dimitri/doxygen/index.html • DocBook - Linux Productivity Magazine: http://www.troubleshooters.com/lpm/200210/200210.htm • DocBook with LyX: http://bgu.chez.tiscali.fr/doc/db4lyx/ • emacs - reportagem: http://bazar.conectiva.com.br/~godoy/emacs/psgml/ • sgml - reportagem: http://bazar.conectiva.com.br/~godoy/sgml/docbook/porque/ • Welcome to GraphViz : http://www.graphviz.org/ • Graphviz - Diagramas UML: http://www.research.att.com/sw/tools/graphviz/refs.html

J.7

Sites Cluster e Programa¸c˜ ao Paralela

• PVM - Parallel Virtual Machine http://www.epm.ornl.gov/pvm/pvm_home.html. • LAM/MPI (Local Area Multicomputer / Message Passing Interface http://www.mpi.nd.edu/lam • OOMPI : http://www.osl.iu.edu/research/oompi/ • Threads http://www.humanfactor.com/pthreads/ • Beowulf : – http://www.beowulf.org Programa¸caõ Orientada a Objeto com C++


734

J.8. SITES BIBLIOTECAS – – – –

http://beowulf-underground.org [email protected] http://beowulf.gsfc.nasa.gov/software/software.html http://www.cacr.caltech.edu/beowulf/tutorial/building.html

• Extreme Linux Software from Red Hat : http://www.redhat.com/extreme,http://www.extremelinux.org • Jacek’s Beowulf-utils: ftp://ftp.sci.usq.edu.au/pub/jacek/beowulf-utils • bWatch - cluster monitoring tool : http://www.sci.usq.edu.au/staff/jacek/bWatch • UTC - Tutorial de Unified Parallel C http://anahy.org/Tools/UnifiedParallelC/index.html, http://upc.gwu.edu/ • Informa¸co˜es gerais sobre cluster: http://www.buyya.com/cluster

J.8

Sites Bibliotecas

J.8.1

Bibliotecas e ferramentas

• Lista de bibliotecas: – http://www.trumphurst.com/cpplibs1.html – http://www.thefreecountry.com/developercity/freelib.html • Biblioteca Common c++: http://www.voxilla.org/projects/projape.html • boost: http://www.boost.org/ • blitz++: http://oonumerics.org/blitz/ • Ferramentas de C++: http://development.freeservers.com • redhat.com|Cygwin: http://www.redhat.com/software/tools/cygwin/ • Qt: – http://trolltech.com.br/. – http://doc.trolltech.com/4.2/index.html • Bibliotecas matemáticas e cient´ıficas da GNU: – http://www.files-library.com/library/gnu-scientific-library.html – http://gfemlib.sourceforge.net/ – http://sscilib.sourceforge.net/ Programa¸caõ Orientada a Objeto com C++


J.9. SITES GRUPOS

J.8.2

735

Programa¸c˜ ao cient´ıfica

• SAL - Numerical Analysis - Miscellaneous Software: http://lem.ch.unito.it/linux/B/0/ • SourceForge.net: Project Info - Common C++ Libraries: http://sourceforge.net/projects/cplusplus/ • Biblioteca matpack++: http://www.matpack.de/ • HPC++: http://www.extreme.indiana.edu/hpc++/index.html • Blitz++ Home Page: http://oonumerics.org/blitz/ • The Graph Template Library (GTL): http://www.infosun.fmi.uni-passau.de/GTL/ • sl++ project : http://ldeniau.home.cern.ch/ldeniau/html/sl++.html • PLAPACK: http://www.cs.utexas.edu/users/plapack/ • Numerical Recipes Home Page: http://www.nr.com/ • Iterative Methods Library in C++: http://math.nist.gov/iml++/ • The Object-Oriented Numerics Page: http://oonumerics.org/oon/#libraries • GNU Scientific Library: http://www.gnu.org/directory/GNU/GNUsl.html • Signal Processing Using C++ Classes: http://spuc.sourceforge.net/ • The Programming Sharehouse: http://development.freeservers.com/

J.9

Sites Grupos

• Grupo de discuss˜ ao de C++: comp.lang.c++, alt.comp.lang.learn.c-c++ • Diversas listas de discuss˜ ao de software livre est˜ ao disponibilizadas em: http://listas.softwarelivre.org/ • Grupo de GNU/Linux na UFSC: – http://www.softwarelivre.ufsc.br Programa¸caõ Orientada a Objeto com C++


736

J.10. SITES REVISTAS – http://www.engnux.ufsc.br/

• Yahoo! Groups : linux-prog: http://groups.yahoo.com/group/linux-prog/

J.10

Sites Revistas

• http://www.revistadolinux.com.br/ • http://www.gazetadolinux.com/contenido_gaceta/html_revistas • http://ldp.pop-rn.rnp.br/LDP/LG/ • http://www.uol.com.br/olinux/ • http://www.linux-magazine.com.br/ • http://www.revistapcecia.com.br/

J.11

Livros de C++

• . • . • .

J.12

Fedora

• http://www.fedora.org.br/ • http://forum.fedoraforum.org/ • http://fedora.redhat.com/docs/install-guide/fc6/.



Apˆ endice K

Arquivos de Cabe¸ calho Apresentaremos neste apêndice uma lista de arquivos de cabe¸calho e sua descri¸caõ.

K.1

Introdu¸ c˜ ao aos arquivos de cabe¸calho

A linguagem C/C++ possui um conjunto extenso de arquivos denominados arquivos de cabe¸calho. Estes arquivos incluem as fun¸co˜es e classes da biblioteca padr˜ ao de C e C++. Em sistemas GNU/Linux estes arquivos est˜ ao localizados em /usr/include/ (arquivos de cabe¸calho de C) e /usr/include/c++/vers˜ aoCompilador/ (arquivos de cabe¸calho de C++). Nos ambientes de desenvolvimento do Windows, os arquivos de cabe¸calho costumam ser instalados no mesmo diret´ orio do compilador. Veremos a seguir os arquivos de cabe¸calho relacionados a: • STL (veja se¸caõ K.4). – Objetos fun¸co˜es e algoritmos genéricos (veja se¸caõ K.4.2). – Tratamento de erro, exce¸co˜es (veja se¸caõ K.5). – Matem´ aticos, numéricos (veja se¸caõ K.4.3). • Utilitários (veja se¸caõ K.6). • Entrada e sa´ıda (streams) (veja se¸caõ K.2). • Strings de C++ (veja se¸caõ K.3). • Bibliotecas de C (veja se¸caõ K.7). • Unix, GNU/Linux (veja se¸caõ K.8).

K.2

Entrada e sa´ıda (streams)

Classe para considera¸caõ de localidades (aspectos regionais, culturais) (se¸caõ 22.9.2). Buffers para streams (Cap´ıtulo 22).

Classe-base para hierarquia de streams (se¸caõ 22.3). 737

738

K.3. STRINGS DE C++

Manipuladores (se¸caõ 22.4). Classe gabarito para entrada de dados (se¸caõ 22.7). Classe gabarito para sa´ıda de dados (se¸caõ 22.5). Entrada e sa´ıda com streams (Cap´ıtulo 22, se¸co˜es 22.7 e 22.5). Classes para manipula¸caõ de strings/streams em conjunto (se¸caõ 22.8). Entrada e sa´ıda com arquivos de disco (se¸caõ 23.2). Recursos de E/S. "pstream.h" O arquivo de cabe¸calho pstream.h descrito na se¸caõ 23.5.4 (n˜ ao é um arquivo padr˜ ao). O mesmo é inclu´ıdo junto com as listagem do livro. Também pode ser obtido em http://pstreams.sourceforge.net.

K.3

Strings de C++

A classe string (Cap´ıtulo 24).

K.4 K.4.1

STL Containers da STL

Vetor unidimensional (se¸caõ 32.1).

Listas duplamente encadeadas (se¸caõ 32.2).

Fila de duas pontas (se¸caõ 32.3).

Pilha do tipo LIFO, primeiro que entra é o ultimo que sai (se¸caõ 33.1).

Fila do tipo FIFO, primeiro que entra é o primeiro que sai (se¸caõ 33.2).

Par associativo chave-valor, inclue as classes (se¸caõ 34.4) e (34.5).

Conjunto de chaves, inclue as classes (se¸caõ 34.2) e (se¸caõ 34.3).

Vetor de valores booleanos (se¸caõ 30.3). Iteradores (se¸caõ 31.3). Classes de vetores de alto desempenho (a dica é usar a biblioteca Blitz++,). Programa¸caõ Orientada a Objeto com C++


˜ K.5. TRATAMENTO DE ERRO, EXCEC ¸ OES

K.4.2

739

Objetos fun¸c˜ oes e algoritmos gen´ ericos

Operadores e pares. Objetos fun¸co˜es (Cap´ıtulo 36). Algoritmos genéricos, fun¸co˜es genéricas (Cap´ıtulo 35). Opera¸co˜es genéricas (Cap´ıtulo 35).

K.4.3

Matem´ aticos, num´ ericos

Defini¸caõ de limites numéricos (Cap´ıtulo 9.1, veja exemplo na listagem 9.3). Classe dos n´ umeros complexos (se¸caõ 30.2). Classes de vetores de alto desempenho. Opera¸co˜es genéricas (se¸caõ 35.3).

K.5

Tratamento de erro, exce¸c˜ oes

Tratamento de exce¸co˜es, classes de exce¸caõ (Cap´ıtulo 26). Exce¸co˜es-padr˜ ao (Cap´ıtulo 26).

K.6

Utilit´ arios Aloca¸caõ dinˆ amica de mem´ oria (se¸caõ 15.3.1).

Aloca¸caõ de mem´ oria e containers. Identifica¸caõ de tipos em tempo de execu¸caõ.

K.7

Bibliotecas de C

Observe que em vers˜ oes antigas de C, estes arquivos de cabe¸calho n˜ ao tinham a letra inicial ć´ e inclu´ıam uma extensão .h. Por exemplo, o arquivo de cabe¸calho se chamava . Nota: é nesta se¸caõ colocamos apenas uma breve descri¸caõ da fun¸caõ. Para maiores detalhes ´ importante lembrar que algumas classes de bibliotecas consulte os manuais e sites de C. E externas, como Blitz++, substituem com vantagens estas fun¸co˜es. Programa¸caõ Orientada a Objeto com C++


740

K.7.1

K.7. BIBLIOTECAS DE C

Fun¸co˜es padr˜ oes de C. Veja http://www.cplusplus.com/ref/. abort()

Aborta o processor currente e retorna c´ odigo de erro.

abs()

Retorna o valor absoluto de um n´ umero inteiro passado como parˆ ametro.

atexit() Especifica a fun¸caõ a ser executada quando exit() é chamada. atof()

Converte string para double.

atoi()

Converte string para int.

atol()

Converte string para long.

bsearch() Pesquisa binaria. calloc() Aloca um array de mem´ oria. div()

Divide dois n´ umeros inteiros.

*ecvt()

Converte n´ umeros floating point para string.

exit()

Termina o processo.

*fcvt()


free()

Desaloca memoria alocada dinamicamente.

*gcvt()


getenv() Obtém string do meio ambiente. *itoa()

Converte n´ umero inteiro para string.

labs()

Retourna valor absoluto de parˆ ametro long int.

ldiv()

Divide dois n´ umeros long int.

*lfind() Pesquisa linear. *lsearch() Pesquisa linear. *ltoa()

Converte n´ umero long int para string.

malloc() Aloca bloco de mem´ oria. *max()

Retorna o maior valor de dois parametros.

*min()

Retorna o menor valor de dois parametros.

*putenv() Cria ou modifica vari´ avel de ambiente. qsort()

Ordena¸caõ usando algoritmo tipo quicksort.

rand()

Gera n´ umero randomico.

realloc() Realoca bloco de mem´ oria. srand()

Inicializa gerador de n´ umeros randˆ omicos.

strtod() Converte string para double. strtol() Converte string para long int. strtoul() Converte string para unsigned long int. Programa¸caõ Orientada a Objeto com C++


K.7. BIBLIOTECAS DE C *swab()

741

Troca bytes.

system() Executa comando. *ultoa() Converte unsigned long int para string.

K.7.2

Fun¸co˜es de entrada e sa´ıda de C. Veja http://www.cplusplus.com/ref/. clearerr() Reseta o indicador de erros. fclose() Fecha a stream. feof()

Checa se End Of File ocorreu.

ferror() Checa por erros. fflush() Descarrega a stream. fgetc()

Obtém o próximo caracter da stream.

fgetpos() Obtém posi¸caõ da stream (ponteiro get). fgets() Obtém uma string a partir de uma stream. fopen()

Abre arquivo.

fprintf() Imprime dados formados para uma stream. fputc()

Escreve um caracter em uma stream.

fputchar() Escreve um caracter em stdout. fputs()

Escreve uma string em uma stream.

fread()

Lê um bloco de dados de uma stream.

freopen() Reabre um arquivo usando outro modo de abertura. fscanf() Lê dados formatados de uma stream. fseek()

Reposiciona posi¸caõ do ponteiro de leitura (stream ’s position indicator ).

fsetpos() Reposiciona ponteiro para arquivo salvo numa determinada localiza¸caõ. ftell()

Retorna posi¸caõ corrente do ponteiro de arquivo.

fwrite() Escreve um bloco de dados em uma stream. getc()

Obtém próximo caracter.

getchar() Obtém próximo caracter de stdin. gets()

Obtém uma string de stdin.

getw()

Obtém o próximo valor de uma stream.

perror() Imprime mensagem de erro. printf() Imprime dados formatados para stdout. Programa¸caõ Orientada a Objeto com C++


742

K.7. BIBLIOTECAS DE C putc()

Escreve um caracter para stream.

putchar() Escreve um caracter para stdout. puts()

Escreve uma string para stdout.

putw()

Escreve um inteiro em uma stream.

remove() Apaga um arquivo. rename() Renomeia um arquivo ou diret´ orio. rewind() Reposiciona ponteiro de arquivo a partir do in´ıcio da stream. scanf()

Lê dados formatados de stdin.

setbuf() Muda stream buferizada. setvbuf() Muda stream buferizada. sprintf() Formata dados para string. sscanf() Lê dados formatados da string. tmpfile() Abre temporariamente um arquivo. tmpnam() Gera um arquivo tempor´ ario e u ´ nico. ungetc() Coloca um caracter de volta na stream.

K.7.3

Data e hora no formato de C, rel´ ogio do sistema (antigo time.h). Veja http: //www.cplusplus.com/ref/. asctime() Converte uma estrutura tm para string. clock()

Retorna o n´ umero de clock ticks desde que o processo foi iniciado.

ctime()

Converte time_t para string.

difftime() Retorna a diferen¸ca entre dois time_t. gmtime() Converte o valor time_t para uma estrutura UTC. localtime() Converte o valor time_t para uma estrutura tm como hora local. mktime() Converte uma estrutura tm para time_t. time()

K.7.4

Obtém tempo corrente.

Antigas fun¸co˜es para tratamento de strings de C. Veja http://www.cplusplus.com/ref/. memchr() Procura caracter no buffer. memcmp() Compara dois buffers. memcpy() Copia bytes de um buffer para outro buffer. Programa¸caõ Orientada a Objeto com C++


K.7. BIBLIOTECAS DE C

743

memmove() Copia bytes de um buffer para outro buffer. memset() Preenche o buffer com o caracter especificado. strcat() Adiciona cstring no modo append. strchr() Procura caracter numa cstring. strcmp() Compara duas cstrings. strcoll() Compara duas cstrings usando informa¸co˜es do locale. strcpy() Copia cstrings. strcspn() Search string for occurrence of charcter set strerror() Obtém ponteiro para mensagem de erro da cstring. strlen() Retorna dimensão da cstring. strncat() Adiciona substring em uma cstring. strncmp() Compara alguns caracteres das duas strings. strncpy() Copia caracteres de uma string para outra. strpbrk() Procura na cstring caracteres especificados. strrchr() Procura u ´ ltima ocorrência de um caracter na cstring. strspn() Obtém a dimensão da substring. strstr() Procura substring. strtok() Trunca a cstring sequencialmente se o delimitador foi localizado. strxfrm() Transforma a cstring usando caracter´ısticas do locale.

K.7.5

Diversos

Inclui a macro assert. Tratamento de erro. Defini¸caõ de caracteres (classifica¸caõ). Defini¸caõ de caracteres longos (classifica¸caõ). Antigas fun¸co˜es para tratamento de strings de C longas. Fun¸co˜es para considera¸caõ de localidades (aspectos regionais, culturais). Defini¸caõ de limites numéricos. Macros de limites numéricos (ponto flutuante). Suporte de linguagem. Tratamento de argumentos (lista de argumentos). Tratamento de sinais.

Fun¸co˜es matemáticas padr˜ oes (se¸caõ 30.1).

Fun¸co˜es padr˜ oes do Unix, GNU/Linux. Inclui fun¸co˜es como: chown, link, unlink, symlink, rmdir, chdir. Veja listagem ??. Programa¸caõ Orientada a Objeto com C++


744

K.8

K.8. UNIX, GNU/LINUX

Unix, GNU/Linux

Fun¸co˜es diversas de Unix, GNU/Linux (veja Parte ?? - Programa¸caõ Multiplataforma com Software Livre e Parte ?? Cluster de Computadores e Processamento Paralelo. Fun¸co˜es Unix, incluindo: chmod(), mkdir(), getcwd().



Apˆ endice L

Licen¸ca P´ ublica Geral GNU Vers˜ ao 2, junho de 1991. This is an unofficial translation of the GNU General Public License into Brazilian Portuguese. It was not published by the Free Software Foundation, and does not legally state the distribution terms for software that uses the GNU GPL – only the original English text of the GNU GPL does that. However, we hope that this translation will help Brazilian Portuguese speakers understand the GNU GPL better. Esta é uma tradu¸caõ n˜ ao-oficial da Licen¸ca P´ ublica Geral GNU (”GPL GNU”) para o português do Brasil. Ela n˜ ao foi publicada pela Free Software Foundation, e legalmente n˜ ao afirma os termos de distribui¸caõ de software que utiliza a GPL GNU – apenas o texto original da GPL GNU, em inglês, faz isso. Contudo, esperamos que esta tradu¸caõ ajude aos que utilizam o português do Brasil a entender melhor a GPL GNU. Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA A qualquer pessoa ´ e permitido copiar e distribuir c´ opias desse documento de licen¸ ca, desde que sem qualquer altera¸ ca õ.

L.1

Introdu¸ c˜ ao

As licen¸cas de muitos software s˜ ao desenvolvidas para restringir sua liberdade de compartilh´ alo e mud´ a-lo. Contr´ aria a isso, a Licen¸ca P´ ublica Geral GNU pretende garantir sua liberdade de compartilhar e alterar software livres – garantindo que o software ser´ a livre e gratuito para os seus usuários. Esta Licen¸ca P´ ublica Geral aplica-se à maioria dos software da Free Software Foundation e a qualquer outro programa cujo autor decida aplic´ a-la. (Alguns outros software da FSF s˜ ao cobertos pela Licen¸ca P´ ublica Geral de Bibliotecas, no entanto.) Você pode aplic´ a-la também aos seus programas. Quando nos referimos a software livre, estamos nos referindo a liberdade e n˜ ao a pre¸co. Nossa Licen¸ca P´ ublica Geral foi desenvolvida para garantir que você tenha a liberdade de distribuir c´ opias de software livre (e cobrar por isso, se quiser); que você receba o c´ odigo-fonte ou tenha acesso a ele, se quiser; que você possa mudar o software ou utilizar partes dele em novos programas livres e gratuitos; e que você saiba que pode fazer tudo isso. Para proteger seus direitos, precisamos fazer restri¸co˜es que impe¸cam a qualquer um negar estes direitos ou solicitar que você deles abdique. Estas restri¸co˜es traduzem-se em certas responsabilidades para você, se você for distribuir c´ opias do software ou modific´ a-lo. 745

´ ˜ ´ ˜ E L.2. LICENCA ¸ PUBLICA GERAL GNU CONDIC ¸ OES PARA COPIA, DISTRIBUIC ¸ AO ˜ 746 MODIFICAC ¸ AO Por exemplo, se você distribuir c´ opias de um programa, gratuitamente ou por alguma quantia, você tem que fornecer aos recebedores todos os direitos que você possui. Você tem que garantir que eles também recebam ou possam obter o c´ odigo-fonte. E você tem que mostrarlhes estes termos para que eles possam conhecer seus direitos. N´ os protegemos seus direitos em dois passos: (1) com copyright do software e (2) com a oferta desta licen¸ca, que lhe d´ a permiss˜ ao legal para copiar, distribuir e/ou modificar o software. Além disso, tanto para a prote¸caõ do autor quanto a nossa, gostar´ıamos de certificar-nos que todos entendam que n˜ ao h´ a qualquer garantia nestes software livres. Se o software é modificado por alguém mais e passado adiante, queremos que seus recebedores saibam que o que eles obtiveram n˜ ao é original, de forma que qualquer problema introduzido por terceiros n˜ ao interfira na reputa¸caõ do autor original. Finalmente, qualquer programa é amea¸cado constantemente por patentes de software. Queremos evitar o perigo de que distribuidores de software livre obtenham patentes individuais, o que tem o efeito de tornar o programa propriet´ ario. Para prevenir isso, deixamos claro que qualquer patente tem que ser licenciada para uso livre e gratuito por qualquer pessoa, ou ent˜ ao que nem necessite ser licenciada. Os termos e condi¸co˜es precisas para c´ opia, distribui¸cão e modifica¸caõ se encontram abaixo:

L.2

Licen¸ca p´ ublica geral GNU condi¸c˜ oes para c´ opia, distribui¸c˜ ao e modifica¸c˜ ao

0. Esta licen¸ca se aplica a qualquer programa ou outro trabalho que contenha um aviso colocado pelo detentor dos direitos autorais informando que aquele pode ser distribu´ıdo sob as condi¸co˜es desta Licen¸ca P´ ublica Geral. O ”Programa” abaixo refere-se a qualquer programa ou trabalho, e ”trabalho baseado no Programa” significa tanto o Programa em si como quaisquer trabalhos derivados, de acordo com a lei de direitos autorais: isto quer dizer um trabalho que contenha o Programa ou parte dele, tanto originalmente ou com modifica¸co˜es, e/ou tradu¸caõ para outros idiomas. (Doravante o processo de tradu¸caõ est´ a inclu´ıdo sem limites no termo ”modifica¸caõ”.) Cada licenciado é mencionado como ”você”. Atividades outras que a c´ opia, a distribui¸caõ e modifica¸caõ n˜ ao est˜ ao cobertas por esta Licen¸ca; elas est˜ ao fora de seu escopo. O ato de executar o Programa n˜ ao é restringido e o resultado do Programa é coberto apenas se seu conte´ udo contenha trabalhos baseados no Programa (independentemente de terem sido gerados pela execu¸caõ do Programa). Se isso é verdadeiro depende do que o programa faz. 1. Você pode copiar e distribuir c´ opias fiéis do c´ odigo-fonte do Programa da mesma forma que você o recebeu, usando qualquer meio, deste que você consp´ıcua e apropriadamente publique em cada c´ opia um aviso de direitos autorais e uma declara¸caõ de inexistência de garantias; mantenha intactas todos os avisos que se referem a esta Licen¸ca e à ausência total de garantias; e forne¸ca a outros recebedores do Programa uma c´ opia desta Licen¸ca, junto com o Programa. 2. Você pode modificar sua c´ opia ou c´ opias do Programa, ou qualquer parte dele, assim gerando um trabalho baseado no Programa, e copiar e distribuir essas modifica¸co˜es ou trabalhos sob os temos da se¸caõ 1 acima, desde que você também se enquadre em todas estas condi¸co˜es: a)

Você tem que fazer com que os arquivos modificados levem avisos proeminentes afirmando que você alterou os arquivos, incluindo a data de qualquer altera¸caõ.



´ ˜ ´ ˜ E L.2. LICENCA ¸ PUBLICA GERAL GNU CONDIC ¸ OES PARA COPIA, DISTRIBUIC ¸ AO ˜ MODIFICAC ¸ AO 747 b)

Você tem que fazer com que quaisquer trabalhos que você distribua ou publique, e que integralmente ou em partes contenham ou sejam derivados do Programa ou de suas partes, sejam licenciados, integralmente e sem custo algum para quaisquer terceiros, sob os termos desta Licen¸ca.

c)

Se qualquer programa modificado normalmente lê comandos interativamente quando executados, você tem que fazer com que, quando iniciado tal uso interativo da forma mais simples, seja impresso ou mostrado um an´ uncio de que n˜ ao h´ a qualquer garantia (ou ent˜ ao que você fornece a garantia) e que os usu´ arios podem redistribuir o programa sob estas condi¸co˜es, ainda informando os usu´ arios como consultar uma c´ opia desta Licen¸ca. (Exce¸caõ: se o Programa em si é interativo mas normalmente n˜ ao imprime estes tipos de an´ uncios, seu trabalho baseado no Programa n˜ ao precisa imprimir um an´ uncio.)

Estas exigências aplicam-se ao trabalho modificado como um todo. Se se¸co˜es identific´ aveis de tal trabalho n˜ ao s˜ ao derivadas do Programa, e podem ser razoavelmente consideradas trabalhos independentes e separados por si s´ o, ent˜ ao esta Licen¸ca, e seus termos, n˜ ao se aplicam a estas se¸co˜es quando você distribui-las como trabalhos em separado. Mas quando você distribuir as mesmas se¸co˜es como parte de um todo que é trabalho baseado no Programa, a distribui¸caõ como um todo tem que se enquadrar nos termos desta Licen¸ca, cujas permiss˜ oes para outros licenciados se estendem ao todo, portanto também para cada e toda parte independente de quem a escreveu. Desta forma, esta se¸caõ n˜ ao tem a inten¸caõ de reclamar direitos os contestar seus direitos sobre o trabalho escrito completamente por você; ao invés disso, a inten¸caõ é a de exercitar o direito de controlar a distribui¸caõ de trabalhos, derivados ou coletivos, baseados no Programa. Adicionalmente, a mera adi¸caõ ao Programa de outro trabalho n˜ ao baseado no Programa (ou de trabalho baseado no Programa) em um volume de armazenamento ou meio de distribui¸caõ n˜ ao faz o outro trabalho parte do escopo desta Licen¸ca. 3. Você pode copiar e distribuir o Programa (ou trabalho baseado nele, conforme descrito na Se¸caõ 2) em c´ odigo-objeto ou em forma execut´ avel sob os termos das Se¸co˜es 1 e 2 acima, desde que você fa¸ca um dos seguintes: a)

O acompanhe com o c´ odigo-fonte completo e em forma acess´ıvel por máquinas, que tem que ser distribu´ıdo sob os termos das Se¸co˜es 1 e 2 acima e em meio normalmente utilizado para o intercâmbio de software; ou,

b)

O acompanhe com uma oferta escrita, válida por pelo menos três anos, de fornecer a qualquer um, com um custo n˜ ao superior ao custo de distribui¸caõ f´ısica do material, uma c´ opia do c´ odigo-fonte completo e em forma acess´ıvel por máquinas, que tem que ser distribu´ıdo sob os termos das Se¸co˜es 1 e 2 acima e em meio normalmente utilizado para o intercâmbio de software; ou,

c)

O acompanhe com a informa¸caõ que você recebeu em rela¸caõ à oferta de distribui¸caõ do c´ odigo-fonte correspondente. (Esta alternativa é permitida somente em distribui¸caõ n˜ ao comerciais, e apenas se você recebeu o programa em forma de c´ odigo-objeto ou execut´ avel, com oferta de acordo com a Subse¸caõ b acima.)

O c´ odigo-fonte de um trabalho corresponde à forma de trabalho preferida para se fazer modifica¸co˜es. Para um trabalho em forma execut´ avel, o c´ odigo-fonte completo significa Programa¸caõ Orientada a Objeto com C++


´ ˜ ´ ˜ E L.2. LICENCA ¸ PUBLICA GERAL GNU CONDIC ¸ OES PARA COPIA, DISTRIBUIC ¸ AO ˜ 748 MODIFICAC ¸ AO todo o c´ odigo-fonte de todos os módulos que ele contém, mais quaisquer arquivos de defini¸caõ de ”interface”, mais os ”scripts” utilizados para se controlar a compila¸caõ e a instala¸caõ do execut´ avel. Contudo, como exce¸caõ especial, o c´ odigo-fonte distribu´ıdo n˜ ao precisa incluir qualquer componente normalmente distribu´ıdo (tanto em forma original quanto binária) com os maiores componentes (o compilador, o ”kernel” etc.) do sistema operacional sob o qual o execut´ avel funciona, a menos que o componente em si acompanhe o execut´ avel. Se a distribui¸caõ do execut´ avel ou c´ odigo-objeto é feita através da oferta de acesso a c´ opias de algum lugar, ent˜ ao ofertar o acesso equivalente a c´ opia, do mesmo lugar, do c´ odigofonte equivale à distribui¸caõ do c´ odigo-fonte, mesmo que terceiros n˜ ao sejam compelidos a copiar o c´ odigo-fonte com o c´ odigo-objeto. 4. Você n˜ ao pode copiar, modificar, sub-licenciar ou distribuir o Programa, exceto de acordo com as condi¸co˜es expressas nesta Licen¸ca. Qualquer outra tentativa de c´ opia, modifica¸caõ, sub-licenciamento ou distribui¸caõ do Programa n˜ ao é valida, e cancelar´ a automaticamente os direitos que lhe foram fornecidos por esta Licen¸ca. No entanto, terceiros que de você receberam c´ opias ou direitos, fornecidos sob os termos desta Licen¸ca, n˜ ao ter˜ ao suas licen¸cas terminadas, desde que permane¸cam em total concordˆ ancia com ela. 5. Você n˜ ao é obrigado a aceitar esta Licen¸ca j´ a que n˜ ao a assinou. No entanto, nada mais o dar´ a permiss˜ ao para modificar ou distribuir o Programa ou trabalhos derivados deste. Estas a¸co˜es s˜ ao proibidas por lei, caso você n˜ ao aceite esta Licen¸ca. Desta forma, ao modificar ou distribuir o Programa (ou qualquer trabalho derivado do Programa), você estar´ a indicando sua total aceita¸caõ desta Licen¸ca para fazê-los, e todos os seus termos e condi¸co˜es para copiar, distribuir ou modificar o Programa, ou trabalhos baseados nele. 6. Cada vez que você redistribuir o Programa (ou qualquer trabalho baseado nele), os recebedores adquirir˜ ao automaticamente do licenciador original uma licen¸ca para copiar, distribuir ou modificar o Programa, sujeitos a estes termos e condi¸co˜es. Você n˜ ao poder´ a impor aos recebedores qualquer outra restri¸caõ ao exerc´ıcio dos direitos ent˜ ao adquiridos. Você n˜ ao é respons´ avel em garantir a concordˆ ancia de terceiros a esta Licen¸ca. 7. Se, em conseq¨ uência de decis˜ oes judiciais ou alega¸co˜es de infringimento de patentes ou quaisquer outras raz˜ oes (n˜ ao limitadas a assuntos relacionados a patentes), condi¸co˜es forem impostas a você (por ordem judicial, acordos ou outras formas) e que contradigam as condi¸co˜es desta Licen¸ca, elas n˜ ao o livram das condi¸co˜es desta Licen¸ca. Se você n˜ ao puder distribuir de forma a satisfazer simultaneamente suas obriga¸co˜es para com esta Licen¸ca e para com as outras obriga¸co˜es pertinentes, ent˜ ao como conseq¨ uência você n˜ ao poder´ a distribuir o Programa. Por exemplo, se uma licen¸ca de patente n˜ ao permitirá a redistribui¸caõ, livre de ”royalties”, do Programa, por todos aqueles que receberem c´ opias direta ou indiretamente de você, ent˜ ao a u ´ nica forma de você satisfazer a ela e a esta Licen¸ca seria a de desistir completamente de distribuir o Programa. Se qualquer parte desta se¸caõ for considerada inválida ou n˜ ao aplic´ avel em qualquer circunstˆ ancia particular, o restante da se¸caõ se aplica, e a se¸caõ como um todo se aplica em outras circunstˆ ancias. O prop´ osito desta se¸caõ n˜ ao é o de induzi-lo a infringir quaisquer patentes ou reivindica¸caõ de direitos de propriedade outros, ou a contestar a validade de quaisquer dessas reivindica¸co˜es; esta se¸caõ tem como u ´ nico prop´ osito proteger a integridade dos sistemas de distribui¸caõ de software livres, o que é implementado pela prática de licen¸cas p´ ublicas. Programa¸caõ Orientada a Objeto com C++


´ ˜ ´ ˜ E L.2. LICENCA ¸ PUBLICA GERAL GNU CONDIC ¸ OES PARA COPIA, DISTRIBUIC ¸ AO ˜ MODIFICAC ¸ AO 749 V´ arias pessoas têm contribu´ıdo generosamente e em grande escala para os software distribu´ıdos usando este sistema, na certeza de que sua aplica¸cão é feita de forma consistente; fica a critério do autor/doador decidir se ele ou ela est´ a disposto a distribuir software utilizando outro sistema, e um licenciado n˜ ao pode impor qualquer escolha. Esta se¸caõ destina-se a tornar bastante claro o que se acredita ser conseq¨ uência do restante desta Licen¸ca. 8. Se a distribui¸caõ e/ou uso do Programa s˜ ao restringidos em certos pa´ıses por patentes ou direitos autorais, o detentor dos direitos autorais original, e que colocou o Programa sob esta Licen¸ca, pode incluir uma limita¸caõ geogr´ afica de distribui¸caõ, excluindo aqueles pa´ıses de forma a tornar a distribui¸caõ permitida apenas naqueles ou entre aqueles pa´ıses ent˜ ao n˜ ao exclu´ıdos. Nestes casos, esta Licen¸ca incorpora a limita¸caõ como se a mesma constasse escrita nesta Licen¸ca. 9. A Free Software Foundation pode publicar vers˜ oes revisadas e/ou novas da Licen¸ca P´ ublica Geral de tempos em tempos. Estas novas vers˜ oes ser˜ ao similares em esp´ırito à vers˜ ao atual, mas podem diferir em detalhes que resolvem novos problemas ou situa¸co˜es. A cada vers˜ ao é dada um n´ umero distinto. Se o Programa especifica um n´ umero de vers˜ ao espec´ıfico desta Licen¸ca que se aplica a ele e a ”qualquer nova vers˜ ao”, você tem a op¸caõ de aceitar os termos e condi¸co˜es daquela vers˜ ao ou de qualquer outra vers˜ ao publicada pela Free Software Foundation. Se o programa n˜ ao especifica um n´ umero de vers˜ ao desta Licen¸ca, você pode escolher qualquer vers˜ ao já publicada pela Free Software Foundation. 10. Se você pretende incorporar partes do Programa em outros programas livres cujas condiço˜es de distribui¸caõ s˜ ao diferentes, escreva ao autor e solicite permiss˜ ao. Para o software que a Free Software Foundation detém direitos autorais, escreva à Free Software Foundation; às vezes n´ os permitimos exce¸co˜es a este caso. Nossa decis˜ ao ser´ a guiada pelos dois objetivos de preservar a condi¸caõ de liberdade de todas as deriva¸co˜es do nosso software livre, e de promover o compartilhamento e reutiliza¸caõ de software em aspectos gerais. ˆ AUSENCIA DE GARANTIAS ´ LICENCIADO SEM ONUS, ˆ ˜ HA ´ QUALQUER 11. UMA VEZ QUE O PROGRAMA E NAO ˜ GARANTIA PARA O PROGRAMA, NA EXTENSAO PERMITIDA PELAS LEIS ´ APLICAVEIS. EXCETO QUANDO EXPRESSADO DE FORMA ESCRITA, OS DETENTORES DOS DIREITOS AUTORAIS E/OU TERCEIROS DISPONIBILIZAM O PROGRAMA ”NO ESTADO”, SEM QUALQUER TIPO DE GARANTIAS, EXPRES˜ LIMITADO A, AS GARANTIAS IMSAS OU IMPLÍCITAS, INCLUINDO, MAS NAO ´ ˜ ˜ A QUALQUER PROPLICITAS DE COMERCIALIZAC ¸ AO E AS DE ADEQUAC ¸ AO ´ POSITO. O RISCO TOTAL COM A QUALIDADE E DESEMPENHO DO PROGRAMA ´ SEU. SE O PROGRAMA SE MOSTRAR DEFEITUOSO, VOCE ˆ ASSUME OS CUSE ˜ ˜ TOS DE TODAS AS MANUTENC ¸ OES, REPAROS E CORREC ¸ OES. ˜ A MENOS QUE EXIGIDO PELAS LEIS APLICAVEIS ´ 12. EM NENHUMA OCASIAO, OU ACORDO ESCRITO, OS DETENTORES DOS DIREITOS AUTORAIS, OU QUALQUER OUTRA PARTE QUE POSSA MODIFICAR E/OU REDISTRIBUIR O PRO˜ RESPONSABILIZADOS POR GRAMA CONFORME PERMITIDO ACIMA, SERAO ˆ VOCE POR DANOS, INCLUINDO QUALQUER DANO EM GERAL, ESPECIAL, ACI¨ DENTAL OU CONSEQUENTE, RESULTANTES DO USO OU INCAPACIDADE DE ˜ LIMITADO A, A PERDA DE DAUSO DO PROGRAMA (INCLUINDO, MAS NAO ˆ DOS OU DADOS TORNADOS INCORRETOS, OU PERDAS SOFRIDAS POR VOCE Programa¸caõ Orientada a Objeto com C++


750

L.3. COMO APLICAR ESTES TERMOS AOS SEUS NOVOS PROGRAMAS OU POR OUTRAS PARTES, OU FALHAS DO PROGRAMA AO OPERAR COM QUALQUER OUTRO PROGRAMA), MESMO QUE TAL DETENTOR OU PARTE TENHAM SIDO AVISADOS DA POSSIBILIDADE DE TAIS DANOS. ˜ FIM DOS TERMOS E CONDIC ¸ OES

L.3

Como aplicar estes termos aos seus novos programas

Se você desenvolver um novo programa, e quer que ele seja utilizado amplamente pelo p´ ublico, a melhor forma de alcan¸car este objetivo é torn´ a-lo software livre que qualquer um pode redistribuir e alterar, sob estes termos. ´ mais seguro anexá-los logo no in´ıcio de Para isso, anexe os seguintes avisos ao programa. E cada arquivo-fonte para refor¸carem mais efetivamente a inexistência de garantias; e cada arquivo deve possuir pelo menos a linha de ”copyright” e uma indica¸caõ de onde o texto completo se encontra. Copyright (C) Este programa é software livre; você pode redistribu´ı-lo e/ou modific´ a-lo sob os termos da Licen¸ca P´ ublica Geral GNU, conforme publicada pela Free Software Foundation; tanto a vers˜ ao 2 da Licen¸ca como (a seu critério) qualquer vers˜ ao mais nova. Este programa é distribu´ıdo na expectativa de ser u ´ til, mas SEM QUALQUER GARANTIA; ˜ ou de ADEQUAC ˜ A QUALsem mesmo a garantia impl´ıcita de COMERCIALIZAC ¸ AO ¸ AO ´ QUER PROPOSITO EM PARTICULAR. Consulte a Licen¸ca P´ ublica Geral GNU para obter mais detalhes. Você deve ter recebido uma c´ opia da Licen¸ca P´ ublica Geral GNU junto com este programa; se n˜ ao, escreva para a Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. Inclua também informa¸co˜es sobre como contact´ a-lo eletronicamente e por carta. Se o programa é interativo, fa¸ca-o mostrar um aviso breve como este, ao iniciar um modo interativo: Gnomovision vers˜ ao 69, Copyright (C) ano nome do autor O Gnomovision n˜ ao possui QUALQUER GARANTIA; para obter mais detalhes digite ‘show w’. Ele é software livre e você est´ a convidado a redistribui-lo sob certas condi¸co˜es; digite ‘show c’ para obter detalhes. Os comandos hipotéticos ‘show w’ e ‘show c’ devem mostrar as partes apropriadas da Licen¸ca P´ ublica Geral. Claro, os comandos que você usar podem ser ativados de outra forma que ‘show w’ e ‘show c’; eles podem até ser cliques do mouse ou itens de um menu – o que melhor se adequar ao programa. Você também deve obter do seu empregador (se você trabalha como programador) ou escola, se houver, uma ”declara¸caõ de ausência de direitos autorais” sobre o programa, se necess´ ario. Aqui est´ a um exemplo; altere os nomes: Yoyodyne, Inc., aqui declara a ausência de quaisquer direitos autorais sobre o programa ‘Gnomovision’ (que executa interpreta¸co˜es em compiladores) escrito por James Hacker. , 1o. de abril de 1989 Ty Con, Vice-presidente Esta Licen¸ca P´ ublica Geral n˜ ao permite incorporar seu programa em programas propriet´ arios. Se seu programa é uma biblioteca de sub-rotinas, você deve considerar mais u ´ til permitir ligar aplica¸co˜es propriet´ arias com a biblioteca. Se isto é o que você deseja, use a Licen¸ca P´ ublica Geral de Bibliotecas GNU, ao invés desta Licen¸ca.



Índice Remissivo , 737 , 736 , 525 , 737 , 739 , 738 , 740 , 740 , 736 , 737 , 736 , 737 , 736 , 735 , 736 , 736 , 736 , 736 , 737 , 736 , 735 , 736 , 737 , 737 , 737 , 736 , 736 , 736 , 736 , 736 , 737 , 735 , 736 , 742 , 737 , 742 , 737 , 736, 737 , 736 #define, 638

#if, 639 #if...#elif...#elif...#endif, 641 #if...#else, 640 #ifdef, 638 #ifdef...#else, 640 #ifndef, 639 #undef, 639 Abstra¸caõ, 69 abstratas, 77 acesso a disco, 429 Agrega¸caõ, 125 Algoritmos genéricos, 595 Ambiente gráfico, 151 Ambientes de desenvolvimento, 151, 152, 727 Ambiguidade, 327 Ambiguidade em heran¸ca m´ ultipla, 347 An´ alise de dom´ınio, 115 An´ alise orientada a objeto, 105, 119 Ansi C, 183 Ansi C++, 183 AOO, 105, 119, 133 Armazenando e lendo objetos, 434 Arquivo de cabe¸calho, 187 Arquivo de implementa¸caõ, 188 Arquivo de projeto, 187 Arquivos de Cabe¸calho, 735 Arquivos de disco, 429 Arquivos de disco binários, 442 Assinatura, 77 associa¸caõ, 112 Associa¸co˜es, 124, 157, 521 Associa¸co˜es - identifica¸caõ, 122 Assuntos, 116 assuntos, 116 Atividade, 79 ator, 111 Atribui¸caõ, 194 Atributo de liga¸caõ, 521 Atributos, 73, 259 751

752 atributos, 120, 156 Atributos - identifica¸caõ, 120 Atributos - Uso avan¸cado, 264 Atributos com mutable, 264 Atributos com volatile, 265 Atributos const, 263 Atributos de classe, 261 Atributos de objeto, 260 Atributos est´ aticos, 261 auto ptr, 686 Base comum, 347 Biblioteca gráfica, 151 biblioteca gráfica, 151 Biblioteca padr˜ ao - stl, 541 Bibliotecas, 402 bibliotecas, 150, 174 Bibliotecas de C, 525 Blocos, 195 break, 671 C´ odigo Aberto, 53 Cancelamento, 78 Casos de uso, 111 casos de uso, 111 cast, 462 catch, 475 Cen´ ario, 111 Chamada explicita do construtor, 340 class , 532 class , 528 class , 569 class , 429 class , 409 class , 413 class , 403 class , 415 class , 563 class , 587 class , 592 class , 586 class , 412 class , 580 class , 578 class , 583 class , 420 class , 575 class , 447 class , 555 Classe, 125 Programa¸caõ Orientada a Objeto com C++

ÍNDICE REMISSIVO Classe de associa¸caõ, 125 Classes, 72, 249 Classes abstratas, 129, 367 Classes aninhadas, 254 Classes de armazenamento, 195, 645 Classes friend, 381 Classes identifica¸caõ, 119 Classes templates, 494, 511 Classifica¸caõ, 77, 602 colabora¸caõ, 136 Coment´ arios, 193 Compara¸caõ, 598 Compartilhamento, 77 Compila¸caõ condicional, 638 Compilador - mensagens de erro, 357 Compilar, 185 Compondo namespace, 246 Composi¸co˜es, 125 composi¸co˜es, 126 composta, 131 comunica¸caõ, 136 Concep¸caõ, 105, 110 conjuntos, 604 const, 651 Construtor de c´ opia, 317 Construtor de convers˜ ao, 461 Construtor default, 315 Construtor e Ambiguidade, 327 Containers, 543 continue, 672 Controle, 147, 665 controle, 149 Conven¸caõ para nomes de objetos, 197 Convers˜ ao com reinterpret cast, 466 Convers˜ ao de ponteiros, 686 Convers˜ ao dinâmica, 464 Convers˜ ao est´ atica, 464 Convers˜ ao explicita, 463 Convers˜ oes, 78, 459 CRC, 171 Cria¸caõ e destrui¸caõ dos objetos, 349 Debugar, 185 Declara¸caõ, 194 Declara¸caõ de um método, 269 Declara¸co˜es, 211 declara¸co˜es, 197 Defini¸caõ, 194 Defini¸caõ de um método, 270 defini¸co˜es, 198 André Duarte Bueno

ÍNDICE REMISSIVO Definindo um namespace, 243 Delega¸caõ, 76 delete, 300 Dependências, 130 Destrutores, 314 Dev C++, 153 dia, 93 Diagrama de atividade, 142 Diagrama de atividades com raios de nata¸caõ, 144 Diagrama de caso de uso, 111 Diagrama de classes, 122 Diagrama de classes com associa¸co˜es, 124 Diagrama de classes com heran¸cas, 128 Diagrama de colabora¸caõ, 136 Diagrama de componentes, 158 Diagrama de estados compostos ou sub-estados, 139 Diagrama de estrutura composta, 131 Diagrama de execu¸caõ, 159 Diagrama de intera¸caõ geral, 145 Diagrama de máquina de estado, 138 Diagrama de objetos, 130 Diagrama de pacotes, 116 Diagrama de pacotes (assuntos), 116 Diagrama de sequência, 134 Diagrama de tempo, 145 Diagramas da UML, 85 Diagramas de estados concorrentes, 140 Diagramas UML, 93 Dicionário, 171 Diretrizes de pré-processador, 637 Diretrizes de pré-processamento, 196 Diversos, 741 do a¸caõ while (teste);, 671 Documenta¸caõ, 106, 167 Documenta¸caõ do programa, 167 dynamic cast, 464 Efeitos do projeto nas associa¸co˜es, 157 Efeitos do projeto nas heran¸cas, 157 Efeitos do projeto nos métodos, 156 Elabora¸caõ, 105, 114 Elementos da UML, 88 elipse..., 678 Empacotamento, 172 empacotamento, 172 Encapsulamento, 70, 250, 253 Engenharia de Software, 99 engenharia de software, 101 Programa¸caõ Orientada a Objeto com C++

753 Entrada e sa´ıda, 401, 735 Entrada e sa´ıda no C++, 401 Entrada na linha de comando, 675 Enumera¸co˜es, 699 enumerated, 699 Enviando comandos para outro programa, 442 escala, 83, 175 Escopo, 195, 651 escopo, 211 Especializa¸caõ, 112 especifica¸caõ, 110 Especifica¸co˜es, 110 Especificador, 195 Especificador de acesso, 250 Especificador de heran¸ca, 337 estado, 138 estados, 137 Estados identifica¸caõ, 137 Estereótipos, 89 Estruturas, 695 Estruturas aninhadas, 697 Etapas de desenvolvimento de um programa, 109 Evento, 79 Eventos, 133, 134 Exce¸co˜es, 79 exce¸co˜es-padr˜ ao, 476 Excess˜ oes, 471 Exemplos de objetos, 62 explicit, 463 express˜ ao? a¸ca˜-verdadeira : a¸caõ-falsa;, 669 Extensão, 113 eXtreme Programming, 104 FAQ, 728 fase de pré-processamento, 637 FIFO, 578 for(in´ıcio;teste;incremento) a¸caõ;, 669 Framework, 174 framework, 174 Friend, 379 friend, 78 Fun¸caõ main(), 675 Fun¸co˜es, 73, 675 Fun¸co˜es friend, 382 Fun¸co˜es genéricas, 598 Fun¸co˜es objetos, 613 Fun¸co˜es recursivas, 677 Fun¸co˜es template, 492 André Duarte Bueno

ÍNDICE REMISSIVO

754 Gabaritos, 489, 505 Generaliza¸caõ, 112 Generaliza¸caõ e heran¸ca, 128 get(), 442 GNU, 53 GNU//Linux, 53 GNU/Linux (Unix), 151 GPL, 52 heap, 477 Heapsort, 604 Heran¸ca, 74, 335 Heran¸ca m´ ultipla, 75, 345, 355 heran¸ca m´ ultipla, 127 Heran¸ca m´ ultipla virtual, 350 Heran¸ca simples, 355 Heran¸cas, 157 heran¸cas, 127, 157 Heran¸cas - identifica¸caõ, 127 Hereditariedade, 74 Hist´ oria de C++, 181 HOWTO, 725 IDE, 151 Identidade, 76 Identifica¸caõ de agrega¸co˜es, 125 Identifica¸caõ de associa¸co˜es, 122 Identifica¸caõ de classes, 119 Identifica¸caõ de composi¸co˜es, 125 Identifica¸caõ de estados, 137 Identifica¸caõ de eventos e mensagens, 133 Identifica¸caõ de heran¸cas, 127 Identifica¸caõ de pacotes, 116 Identificadores, 193, 197 if, 666 if......else if......else if......else, 667 if.....else, 666 Implementa¸caõ, 160 Implementa¸caõ do programa, 106 Impressora, 441 Inclus˜ ao, 113 Inclus˜ ao de arquivos, 637 Inicializa¸caõ dos atributos, 316 Instˆ ancia, 63, 76 Instru¸co˜es de guarda, 642 Interface, 77, 128, 148 interface, 54, 117 Inverter, 600 Itera¸caõ, 132, 145 Iteradores, 547 Programa¸caõ Orientada a Objeto com C++

Iterator’s, 547 kdevelop, 154 kernel numérico, 55 Liga¸caõ dinâmica, 78 Liga¸caõ est´ atica, 78 linguagem de modelagem unificada, 85 linha de comando, 55 Linkar, 185 Links, 725 Linux, 53 Literais, 194 locale, 422 Lvalues, 196 Métodos, 73, 267 métodos, 121, 156 Métodos - identifica¸caõ, 121 Métodos const, 279 Métodos construtores, 313 Métodos de convers˜ ao, 462 Métodos destrutores, 314 Métodos est´ aticos, 282, 361 Métodos friend, 381 Métodos inline, 284 Métodos n˜ ao virtuais, 361 Métodos normais, 276, 361 Métodos virtuais, 363 Métodos virtuais puros, 367 módulos, 116 Mac OS System X, 151 Macros, 641 Macros pré-definidas, 641 Manuten¸caõ, 172 Manuten¸caõ do programa, 106 Matem´ aticos, 603 mecanismo de recupera¸caõ, 56 Mensagens, 133, 134 Mesclar, 600 Metodologia, 162 Misturar, 600 Modelagem, 81 Modelagem Orientada a Objeto, 49, 81 Modelagem orientada a objeto, 84 Modelo, 81 modelo, 133, 156 Modelo baseado em prototipagem, 102 Modelo de objetos, 119 Modelo dinâmico, 133 André Duarte Bueno

ÍNDICE REMISSIVO Modelo espiral, 102 Modelo funcional, 142 Modelo incremental, 102 Modelo iterativo, 102 Modelo RAD, 102 Modelo RUP, 103 Modelo selecionado, 105 Modelo sequencial linear, 101 Modelo TMO, 103 Modelo XP, 104 modelos, 101 Modificadores de acesso, 650 modo gráfico, 57 modo texto, 56 Modularidade, 79 Namespace, 241 Necessidade de convers˜ ao, 460 new, 300, 481 Nome dos objetos, 197 Nomes, 193 Nomes de classe, 77 NonVirtual Interface, 253 Novidades e vantagens de C++, 183 NVI, 253 O que é engenharia de software, 99 Objeto, 63 objetos, 61 Objetos dinâmicos, 299 Objetos fun¸co˜es, 613 Objetos identifica¸caõ, 130 Oculta¸caõ, 70 Open Source Initiative, 53 Operador condicional, 660 Operador de resolu¸caõ de escopo, 662 Operador decremento, 660 Operador delete, 662 Operador incremento, 660 Operador módulo, 661 Operador new, 662 Operador size t, 234, 662 Operador sizeof, 662 Operador typedef, 662 Operador v´ırgula, 661 Operadores, 194, 655 Operadores aritiméticos, 656 Operadores bits, 659 Operadores compostos, 657 Operadores de atribui¸caõ, 657 Programa¸caõ Orientada a Objeto com C++

755 Operadores l´ ogicos, 658 Operadores relacionais, 657 Operadores sobrecarregados, 386 Ordem de cria¸caõ, 351 Ordem de cria¸caõ e destrui¸caõ dos objetos, 325 Ordem de destrui¸caõ, 351 Ordena¸caõ, 601 otimiza¸co˜es, 157 Pacotes, 79 pair, 583 Palavras chaves, 193 Palavras chaves do C++, 196 Parâmetros por c´ opia, 272 Parâmetros por ponteiro, 273 Parâmetros por referência, 272 Persistência, 76 Pesquisar, 600 Pilhas, 604 Plataforma de programa¸caõ, 149 Plataformas, 147 plataformas, 149 Polimorfismo, 75, 361, 365 Ponteiro de fun¸caõ, 689 Ponteiro para métodos, 690 Ponteiro para ponteiro, 685 Ponteiro this, 302 Ponteiro void, 684 Ponteiros, 78, 297, 683 Ponteiros const, 303 Ponteiros para const, 303 POO, 61, 64, 156 Precedência dos operadores, 656 Preenchimento, 598 Profiler, 185 programa, 51 Programa¸caõ em grande escala, 175 Programa¸caõ estruturada, 63 Programa¸caõ orientada a objeto, 64 Programas, 51 Projeto do sistema, 105, 147 Projeto orientado a objeto, 106, 156 Propriedades, 73 prot´ otipo, 117 Protótipo catch, 472 Protótipo classe template, 495 Protótipo const cast, 466 Protótipo construtor, 314 Protótipo convers˜ oes, 459 Protótipo destrutor, 314 André Duarte Bueno

ÍNDICE REMISSIVO

756 Protótipo dynamic cast, 465, 466 Protótipo exce¸co˜es, 476 Protótipo fun¸co˜es template, 490 Protótipo heran¸ca m´ ultipla, 345 Protótipo heran¸ca m´ ultipla virtual, 350 Protótipo método convers˜ ao, 462 Protótipo para construtores e destrutores, 314 Protótipo para declarar e definir atributos, 259 Protótipo para declarar e definir classes, 249 Protótipo para declarar e definir métodos, 268 Protótipo para enumera¸co˜es, 227, 700 Protótipo para friend, 380 Protótipo para heran¸ca, 335 Protótipo para heran¸ca m´ ultipla, 345 Protótipo para templates, 490 Protótipo referências, 305 Protótipo reinterpret cast, 466 Protótipo sizeof, 234 Protótipo sobrecarga de operador, 386, 394, 397 Protótipo static cast, 464 Protótipo template e argumentos pré-definidos, 498 Protótipo throw, 472 Protótipo try, 472 Protótipos de sobrecarga, 394 Protótipos para convers˜ oes, 459 Protótipo struct, 224, 695 Protocolos, 77, 147, 148 Prototipo delete, 301 Prototipo new, 300 pstream.h, 736 put(), 442 Rapid Application Development, 102 Rational Unified Process, 103 read(), 434 Realiza¸caõ, 130 Recursos, 147 Redeclara¸caõ, 340 Redirecionamento, 437 Referências, 78, 297, 304 referências, 297 Referências e dynamic cast, 466 reinterpret cast, 466 Remo¸caõ, 599 Responsabilidades, 77 Restri¸co˜es, 130 Retorno de um método, 271 Reusabilidade, 172 Programa¸caõ Orientada a Objeto com C++

Reuso, 172 reuso de classes, 172 reuso de métodos, 173 Revistas, 734 robustes de c´ odigo, 253 RUP, 103 S´ımbolos, 193 Sa´ıda aux´ıliar, 441 seekg(), seekp(), 439 Sele¸caõ de bibliotecas externas, 150 Sequência de controle, 476 Sinergia, 79 Sintaxe de Cpp, 193 sizeof, 234, 355 Sobrecarga de Métodos, 293 sobrecarga de métodos, 78 Sobrecarga de operador, 385 sobrecarga de operador, 78 Sobrecarga de operador como fun¸caõ friend, 387 Sobrecarga de operador como método membro da classe, 388 software, 51 Software Livre, 52 software livre, 52 Software propriet´ ario, 52 softwares, 51 static, 652 static cast, 464 std, 242 STL, 539 stl, 541 strings de C++, 447 Superclasse, 77 switch....case, 667 Tecnologia de Modelagem de Objetos, 103 tellg(),tellp(), 439 Templates, 79, 489, 505 Teste, 161 Teste de Software, 161 Teste e depura¸caõ, 106 throw, 474 Tipifica¸caõ, 76, 237 Tipos, 215 Tipos de programa¸caõ em C++, 184 Tipos definidos em bibliotecas externas, 228 Tipos derivados, 195 Tipos do usuário, 223 André Duarte Bueno

ÍNDICE REMISSIVO

757

Tipos e intervalos, 217 Tipos paramétricos, 494, 511 Tipos pré-definidos, 195 Transforma¸caõ, 602 Trocas, 599 try, 474 Tutoriais, 728 Typedef’s, 546 typeid, 236 umbrello, 94 UML, 85, 726 Uni˜ oes, 698 union, 698 Uso de tipos pré-definidos de C++, 215 Vari´ aveis, 73 Vis˜ ao desorganizada, 64 Vis˜ ao orientada a objeto, 64 Vis˜ oes da UML, 85 Visual Paradigm, 96 volatile, 651 while (teste)instru¸caõ;;, 670 Windows, 151 write(), 434 XP, 104

LivroCpp-2nd-novatec

Recommend Documents