apostila programação c++ v04, Notas de estudo de Informática

Baixe apostila programação c++ v04 e outras Notas de estudo em PDF para Informática, somente na Docsity! LABORATÓRIO DE MEIOS POROSOS E PROPRIEDADES TERMOFÍSICAS e NÚCLEO DE PESQUISA EM CONSTRUÇÃO Apostila de Programação Orientada a Objeto em C++ André Duarte Bueno, UFSC-LMPT-NPC http://www.lmpt.ufsc.br/~andre email: andre@lmpt.ufsc.br Versão 0.4 22 de agosto de 2002 Apostila de Programação Orientada a Objeto em C++. Versão 0.4. Distribuída na forma GPL (http://www.gnu.org). Copyright (C) 2002 - André Duarte Bueno. Esta apostila é software livre; você pode redistribuí-la e/ou modicá-la sob os termos da Licença Pública Geral GNU, conforme publicada pela Free Software Foundation; tanto a versão 2 da Licença como (a seu critério) qualquer versão mais nova. Desenvolvida no Laboratório de Meios Porosos e Propriedades Termofísicas (http://www.lmpt.ufsc.br) e no Núcleo de Pesquisa em Construção (http://www.npc.ufsc.br), com apoio do Curso de Pós-Graduação em Engenharia Mecanica (http://www.posmec.ufsc.br) e da Universidade Federal de Santa Catarina (http://www.ufsc.br). 2 SUMÁRIO 5 9.4 Atributos const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 9.5 Atributos com mutable2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 9.6 Atributos com volatile3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 9.7 Inicialização dos atributos da classe nos contrutores2 . . . . . . . . . . . . . . . . 103 9.8 Sentenças para atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 10 Métodos 105 10.1 Protótipo para declarar e denir métodos . . . . . . . . . . . . . . . . . . . . . . . 105 10.2 Declaração, denição e retorno de um métodos . . . . . . . . . . . . . . . . . . . . 106 10.2.1 Declaração de um método . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 10.2.2 Denição de um método . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 10.2.3 Retorno de um método . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 10.3 Passagem dos parâmetros por cópia, por referência e por ponteiro . . . . . . . . . 107 10.3.1 Uso de argumentos pré-denidos (inicializadores) . . . . . . . . . . . . . . 110 10.3.2 Sentenças para declaração, denição e retorno de métodos . . . . . . . . . 110 10.4 Métodos normais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 10.5 Métodos const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 10.6 Métodos estáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 10.7 Métodos inline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 10.8 Sentenças para métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 11 Sobrecarga de Métodos 125 11.1 O que é a sobrecarga de métodos ? . . . . . . . . . . . . . . . . . . . . . . . . . . 125 11.2 Exemplos de sobrecarga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 12 Uso de Ponteiros e Referências 127 12.1 Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 12.2 Criação e uso de objetos dinâmicos com ponteiros . . . . . . . . . . . . . . . . . . 129 12.2.1 Porque usar objetos dinâmicos ? . . . . . . . . . . . . . . . . . . . . . . . . 129 12.2.2 Controle da criação e deleção de objetos com ponteiros2 . . . . . . . . . . . 131 12.3 Ponteiros const e ponteiros para const . . . . . . . . . . . . . . . . . . . . . . . . 131 12.4 Conversão de ponteiros2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 12.5 Ponteiro this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 12.5.1 Sentenças para ponteiro this . . . . . . . . . . . . . . . . . . . . . . . . . . 133 12.6 Usando auto_ptr2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 12.7 Ponteiros para métodos e atributos da classe3 . . . . . . . . . . . . . . . . . . . . 136 12.8 Sentenças para ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 12.9 Referências (&) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 12.9.1 Diferenças entre referência e ponteiro . . . . . . . . . . . . . . . . . . . . . 137 12.9.2 Referências para ponteiros2 . . . . . . . . . . . . . . . . . . . . . . . . . . 138 12.9.3 Sentenças para referências . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 13 Métodos Construtores e Destrutores 141 13.1 Protótipo para construtores e destrutores . . . . . . . . . . . . . . . . . . . . . . . 141 13.2 Métodos construtores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 13.2.1 Sentenças para construtores . . . . . . . . . . . . . . . . . . . . . . . . . . 142 13.3 Construtor default . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 6 SUMÁRIO 13.3.1 Sentenças para construtor default . . . . . . . . . . . . . . . . . . . . . . . 143 13.4 Construtor de cópia X(const X& obj) . . . . . . . . . . . . . . . . . . . . . . . . . 143 13.5 Métodos destrutores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 13.5.1 Sentenças para destrutores . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 13.5.2 Ordem de criação e destruição dos objetos . . . . . . . . . . . . . . . . . . 153 13.6 Sentenças para construtores e destrutores . . . . . . . . . . . . . . . . . . . . . . . 154 14 Herança 155 14.1 Protótipo para herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 14.2 Especicador de herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 14.3 Chamando construtores da classe base explicitamente . . . . . . . . . . . . . . . . 159 14.4 Ambigüidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 14.4.1 Senteças para herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 15 Herança Múltipla2 163 15.1 Protótipo para herança múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 15.2 Herança múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 15.3 Ambiguidade em herança múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 15.3.1 Herança múltipla com base comum . . . . . . . . . . . . . . . . . . . . . . 165 15.4 Herança múltipla virtual2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 15.4.1 Sentenças para herança múltipla . . . . . . . . . . . . . . . . . . . . . . . . 168 15.5 Ordem de criação e destruição dos objetos em heranças . . . . . . . . . . . . . . . 169 15.5.1 Ordem de criação e destruição dos objetos em heranças virtuais . . . . . . 169 15.6 Redeclaração de método ou atributo na classe derivada . . . . . . . . . . . . . . . 171 15.6.1 Sentenças para redeclarações . . . . . . . . . . . . . . . . . . . . . . . . . . 172 15.7 Exemplo de herança simples e herança múltipla . . . . . . . . . . . . . . . . . . . 172 15.8 Análise dos erros emitidos pelo compilador2 . . . . . . . . . . . . . . . . . . . . . 177 16 Polimorsmo2 179 16.1 Métodos não virtuais (normais, estáticos) . . . . . . . . . . . . . . . . . . . . . . . 179 16.2 Métodos virtuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 16.2.1 Sentenças para métodos virtuais . . . . . . . . . . . . . . . . . . . . . . . . 181 16.3 Como implementar o polimorsmo . . . . . . . . . . . . . . . . . . . . . . . . . . 182 16.3.1 Sentenças para polimorsmo . . . . . . . . . . . . . . . . . . . . . . . . . . 185 16.4 Métodos virtuais puros (Classes abstratas)210.1 . . . . . . . . . . . . . . . . . . . 186 16.4.1 Sentenças para métodos virtuais puros (classes abstratas) . . . . . . . . . . 186 16.5 Exemplo completo com polimorsmo . . . . . . . . . . . . . . . . . . . . . . . . . 186 17 Friend 211 17.1 Introdução ao conteito de friend . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 17.2 Classes friend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 17.3 Métodos friend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 17.4 Sentenças para friend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ SUMÁRIO 7 18 Sobrecarga de Operador 215 18.1 Introdução a sobrecarga de operadores . . . . . . . . . . . . . . . . . . . . . . . . 215 18.2 Operadores que podem ser sobrecarregados . . . . . . . . . . . . . . . . . . . . . . 216 18.3 Sobrecarga de operador como função friend . . . . . . . . . . . . . . . . . . . . . . 216 18.4 Sobrecarga de operador como método membro da classe . . . . . . . . . . . . . . . 217 18.5 Sentenças para sobrecarga de operador . . . . . . . . . . . . . . . . . . . . . . . . 218 18.6 Usar funções friend ou funções membro ? . . . . . . . . . . . . . . . . . . . . . . . 219 18.7 Protótipos de sobrecarga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 19 Implementando Associações em C++ 227 19.1 Introdução as associações em C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 227 19.2 Associação sem atributo de ligação . . . . . . . . . . . . . . . . . . . . . . . . . . 227 19.3 Associação com atributo de ligação . . . . . . . . . . . . . . . . . . . . . . . . . . 228 20 Conversões 231 20.1 Protótipos para conversões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 20.2 Necessidade de conversão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 20.3 Construtor de conversão2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 20.4 Métodos de conversão (cast) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 20.5 Conversão explicita nos construtores com explicit2 . . . . . . . . . . . . . . . . . . 234 20.6 Sentenças para construtor e métodos de conversão . . . . . . . . . . . . . . . . . . 235 20.7 Conversão dinâmica com dynamic_cast . . . . . . . . . . . . . . . . . . . . . . . . 236 20.7.1 Sentenças para cast dinâmico . . . . . . . . . . . . . . . . . . . . . . . . . 238 20.8 Conversão estática com static_cast . . . . . . . . . . . . . . . . . . . . . . . . . . 239 20.9 Conversão com reinterpret_cast . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 20.10Usando Typeid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 20.11Vericação do tamanho de um objeto com sizeof . . . . . . . . . . . . . . . . . . . 241 20.12Referências e dynamic_cast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 21 Excessões 243 21.1 Introdução as excessões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 21.2 Conceitos básicos de excessões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 21.2.1 try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 21.2.2 throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 21.2.3 catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 21.3 Sequência de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 21.3.1 Sequência de controle sem excessão . . . . . . . . . . . . . . . . . . . . . . 247 21.3.2 Sequência de controle com excessão . . . . . . . . . . . . . . . . . . . . . . 247 21.4 Como ca a pilha (heap)2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 21.5 Excessões não tratadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 21.6 Excessão para new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 21.7 Excessões padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 21.8 Sentenças para excessões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 10 SUMÁRIO 39.3.7 Classicação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 39.3.8 Matemáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 39.3.9 Operações matemáticas com conjuntos . . . . . . . . . . . . . . . . . . . . 374 39.3.10Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 39.3.11Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 40 Objetos Funções da STL 383 40.1 Introdução aos objetos funções da STL . . . . . . . . . . . . . . . . . . . . . . . . 383 40.1.1 Funções aritméticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 40.1.2 Funções de comparação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 40.1.3 Funções lógicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 V Programação Para Linux/Unix 387 41 Introdução a Programação GNU/Linux/Unix 389 41.1 O básico do GNU/Linux/Unix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 41.1.1 Comandos do shell úteis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 41.1.2 Expressões regulares3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396 41.1.3 Programas telnet e ftp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 41.2 Diretórios úteis para programadores . . . . . . . . . . . . . . . . . . . . . . . . . . 400 41.3 Programas úteis para programadores . . . . . . . . . . . . . . . . . . . . . . . . . 400 42 Edição de Texto Emacs e VI 403 42.1 Comandos do editor emacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 42.1.1 Help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 42.1.2 Movimento do cursor (use as setas de direção) . . . . . . . . . . . . . . . . 403 42.1.3 Cut/Copy/Paste/Undo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 42.1.4 Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 42.1.5 Pesquisa e substituição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 42.1.6 Múltiplas janelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 42.1.7 Encerrando seção do Emacs . . . . . . . . . . . . . . . . . . . . . . . . . . 405 42.2 Comando do editor vi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406 43 Os programas di, patch, indent 409 43.1 O programa di . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409 43.1.1 Sentenças para o di . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 43.2 O programa patch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 43.3 O programa indent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412 44 Compilando com gcc, g++ 415 44.1 Protótipo e parâmetros do gcc/g++ . . . . . . . . . . . . . . . . . . . . . . . . . . 415 44.2 Arquivos gerados pelo gcc/g++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 44.3 Exemplo de uso do gcc/g++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ SUMÁRIO 11 45 Make 419 45.1 Um arquivo de projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419 45.2 Protótipo e parâmetros do make . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 45.3 Formato de um arquivo Makele . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 45.3.1 Criando variáveis em um arquivo Makele . . . . . . . . . . . . . . . . . . 420 45.3.2 Criando alvos em um arquivo Makele . . . . . . . . . . . . . . . . . . . . 421 45.4 Exemplo de um arquivo Makele . . . . . . . . . . . . . . . . . . . . . . . . . . . 421 45.5 Sentenças para o make . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423 46 Bibliotecas 425 46.1 Introdução a montagem de bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . 425 46.1.1 ar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425 46.1.2 ranlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 46.1.3 nm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 46.1.4 objdump . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 46.1.5 ldd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 46.1.6 ldcong . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429 46.2 Convenção de nomes para bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . . 429 46.3 Bibliotecas usuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429 46.4 Montando uma biblioteca estática (libNome.a) . . . . . . . . . . . . . . . . . . . . 429 46.4.1 Usando uma biblioteca estática . . . . . . . . . . . . . . . . . . . . . . . . 430 46.5 Montando uma biblioteca dinâmica (libNome.so) . . . . . . . . . . . . . . . . . . . 431 46.5.1 Vantagens/desvantagens da biblioteca dinâmica . . . . . . . . . . . . . . . 432 46.5.2 Usando uma biblioteca dinâmica . . . . . . . . . . . . . . . . . . . . . . . 435 46.6 Sentenças para bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 47 Libtool 437 47.1 Introdução ao libtool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437 47.2 Forma de uso do libtool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437 47.3 Criando uma biblioteca sem o libtool . . . . . . . . . . . . . . . . . . . . . . . . . 438 47.4 Criando uma biblioteca estática com o libtool . . . . . . . . . . . . . . . . . . . . 438 47.5 Criando uma biblioteca dinâmica com o libtool . . . . . . . . . . . . . . . . . . . . 439 47.6 Linkando executáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439 47.7 Instalando a biblioteca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439 47.8 Modos do libtool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440 47.9 Sentenças para o libtool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440 48 Debug (Depuradores, Debuggers) 443 48.1 Comandos do gbd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 48.2 Exemplo de uso do gdb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 48.3 Sentenças para o gdb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 49 Proler (gprof) 445 49.1 Sentenças para o proler: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 12 SUMÁRIO 50 Versão de Depuração, Final e de Distribuição 447 50.1 Versão debug, release e de distribuição . . . . . . . . . . . . . . . . . . . . . . . . 447 50.1.1 Versão debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447 50.1.2 Versão nal (release) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447 50.1.3 Distribuição dos programas e bibliotecas . . . . . . . . . . . . . . . . . . . 447 50.2 Sentenças para distribuição de código fonte . . . . . . . . . . . . . . . . . . . . . . 450 51 Documentação de Programas Usando Ferramentas Linux 451 51.1 Introdução a documentação de programas . . . . . . . . . . . . . . . . . . . . . . 451 51.2 Documentação embutida no código com JAVA_DOC . . . . . . . . . . . . . . . . 451 51.2.1 Exemplo de código documentado . . . . . . . . . . . . . . . . . . . . . . . 451 51.2.2 Sentenças para documentação java_doc . . . . . . . . . . . . . . . . . . . 452 51.3 Tutorial de conguração e uso do DOXYGEN . . . . . . . . . . . . . . . . . . . . 453 51.4 Exemplo de programa documentado . . . . . . . . . . . . . . . . . . . . . . . . . . 455 51.5 Exemplo de diagramas gerados pelo doxygen . . . . . . . . . . . . . . . . . . . . . 457 51.6 Documentação prossional com sgml/xml (LYX) . . . . . . . . . . . . . . . . . . . 458 52 Sequência de Montagem de Um Programa GNU 461 52.1 Introdução a programação multiplataforma com GNU . . . . . . . . . . . . . . . . 461 52.2 aclocal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463 52.3 ifnames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463 52.4 autoscan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463 52.4.1 Roteiro do autoscan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 52.5 autoheader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 52.5.1 Roteiro do autoheader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 52.6 automake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465 52.6.1 Introdução ao automake . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465 52.6.2 Sentenças para o automake . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 52.7 autoconf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 52.7.1 Introdução ao autoconf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 52.7.2 Protótipo do autoconf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 52.7.3 Roteiro do autoconf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 52.7.4 Estrutura de um arquivo congure.in . . . . . . . . . . . . . . . . . . . . . 469 52.7.5 Exemplo de um arquivo congure.in . . . . . . . . . . . . . . . . . . . . . . 470 52.7.6 Macros do autoconf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470 52.7.7 Como aproveitar os resultados das pesquisas realizadas pelo autoconf . . . 473 52.7.8 Variáveis denidas no arquivo congure.in e que serão substituídas no ar- quivo Makele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475 52.8 autoreconf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476 52.9 ./congure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477 52.10Como incluir instruções do libtool em seu pacote gnu . . . . . . . . . . . . . . . . 477 52.10.1Exemplo de arquivo makele.am usando o libtool . . . . . . . . . . . . . . 477 52.10.2Exemplo de arquivo congure.in usando o libtool . . . . . . . . . . . . . . 478 52.11Exemplo Completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ SUMÁRIO 15 56.7.3 Métodos->otimização de desempenho . . . . . . . . . . . . . . . . . . . . . 530 56.7.4 Ajustes nas heranças . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530 56.7.5 Ajustes nas associações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530 56.7.6 Ajustes nos atributos de ligação . . . . . . . . . . . . . . . . . . . . . . . . 531 56.7.7 Empacotamento físico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531 56.7.8 O projeto de algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531 56.8 Implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531 56.9 Testes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532 56.10Documentação de um programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532 56.10.1Documentação do sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . 532 56.10.2Documentação dos assuntos . . . . . . . . . . . . . . . . . . . . . . . . . . 533 56.10.3Documentação das classes . . . . . . . . . . . . . . . . . . . . . . . . . . . 533 56.10.4Documentação das relações . . . . . . . . . . . . . . . . . . . . . . . . . . 533 56.10.5Documentação dos atributos . . . . . . . . . . . . . . . . . . . . . . . . . . 533 56.10.6Documentação dos métodos . . . . . . . . . . . . . . . . . . . . . . . . . . 533 56.11Manutenção . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534 56.11.1Extensibilidade, robustes, reusabilidade2 . . . . . . . . . . . . . . . . . . . 534 Referências Bibliográcas 537 VII Apêndices 539 A Diretrizes de pré-processador 541 A.1 Introdução as diretrizes de pré processador . . . . . . . . . . . . . . . . . . . . . . 541 A.2 Compilação condicional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541 A.2.1 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541 A.2.2 if...else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542 A.2.3 if...elif...elif...endif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542 A.2.4 dene, ifdef, ifndef, undef . . . . . . . . . . . . . . . . . . . . . . . . . . . 542 A.2.5 Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543 B Conceitos Úteis Para Programação em C/C++ 545 B.1 Classes de armazenamento2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545 B.2 Modicadores de acesso2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546 B.3 Escopo das variáveis2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549 B.4 Sentenças para classes de armazenamento, escopo e modicadores de acesso . . . . 551 C Operadores 553 C.1 Introdução aos operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553 C.2 Operadores de uso geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554 C.2.1 Operadores aritiméticos (+,-,*,/,%) . . . . . . . . . . . . . . . . . . . . . . 554 C.2.2 Operadores de atribuição (=) . . . . . . . . . . . . . . . . . . . . . . . . . 554 C.2.3 Operadores compostos (+=, -=, *=, /=) . . . . . . . . . . . . . . . . . . . 554 C.2.4 Operadores relacionais (>, >=, <. <=, ==, !=) . . . . . . . . . . . . . . 554 C.2.5 Operadores lógicos (&&, ||, !, ==, !=) . . . . . . . . . . . . . . . . . . . . 555 C.2.6 Operador condicional (?) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 16 SUMÁRIO C.2.7 Operador incremento (++) e decremento (- -) . . . . . . . . . . . . . . . . 555 C.2.8 Operador vírgula (a,b) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556 C.2.9 Operador módulo (% ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556 C.3 Operadores de uso especíco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557 C.3.1 Operador typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557 C.3.2 Operador sizeof e size_t . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557 C.3.3 Operador de resolução de escopo (::) . . . . . . . . . . . . . . . . . . . . . 557 C.3.4 Sentenças para operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . 557 D Controle 561 D.1 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561 D.2 if.....else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561 D.3 if.. . . ..else if. . . ...else if. . . ...else . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562 D.4 switch....case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562 D.5 expressão? ação_verdadeira : ação_falsa; . . . . . . . . . . . . . . . . . . . . . . 563 D.6 for(início;teste;incremento) ação; . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563 D.7 while (teste){instrução;}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564 D.8 do {ação} while (teste); . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564 D.9 break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565 D.10 continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565 E Funções - Parte II 575 E.1 Uso de argumentos pré-denidos (inicializadores) . . . . . . . . . . . . . . . . . . 575 E.2 A função main() e a entrada na linha de comando2 . . . . . . . . . . . . . . . . . 575 E.3 Funções recursivas2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576 E.4 Uso de elipse ... em funções3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578 E.5 Sentenças para funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578 E.6 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579 F Ponteiros - Parte II 587 F.1 Operações com ponteiros (+/-)2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587 F.2 Ponteiro void2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587 F.2.1 Sentenças para ponteiro void . . . . . . . . . . . . . . . . . . . . . . . . . . 588 F.3 Ponteiro para ponteiro3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588 F.4 Ponteiro de Função3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589 F.5 Sentenças para ponteiros2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590 G Estruturas, Uniões e Enumerações 593 G.1 Estrutura (struct) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 G.1.1 Denindo estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 G.1.2 Criando um objeto de uma estrutura . . . . . . . . . . . . . . . . . . . . . 593 G.1.3 Acessando atributos de uma estrutura . . . . . . . . . . . . . . . . . . . . 594 G.1.4 Estruturas e funções2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596 G.1.5 Lista encadeada2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596 G.1.6 Estruturas aninhadas2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596 G.1.7 Sentenças para estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . 597 G.2 Uniões (union) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ SUMÁRIO 17 G.3 Enumerações (enumerated) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599 H Bibliotecas de C 601 H.1 <cmath> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601 I Portabilidade 603 J Bug / Debug 605 J.1 O que é um bug? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605 J.2 Uso de assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605 J.3 Sentenças para evitar bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606 K Glossário 609 L Links Para Sites em C++ 619 M Licença Pública Geral GNU 621 M.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621 M.2 Licença pública geral GNU termos e condições para cópia, distribuição e modicação622 M.3 Como aplicar estes termos aos seus novos programas . . . . . . . . . . . . . . . . 626 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 20 LISTA DE FIGURAS 29.1 Métodos disponibilizados para vector. . . . . . . . . . . . . . . . . . . . . . . . . . 327 30.1 Métodos disponibilizados para list. . . . . . . . . . . . . . . . . . . . . . . . . . . 334 31.1 Métodos disponibilizados para deque. . . . . . . . . . . . . . . . . . . . . . . . . . 340 32.1 Métodos disponibilizados para stack. . . . . . . . . . . . . . . . . . . . . . . . . . 343 35.1 Métodos disponibilizados para set. . . . . . . . . . . . . . . . . . . . . . . . . . . . 351 36.1 Métodos disponibilizados para multiset. . . . . . . . . . . . . . . . . . . . . . . . . 355 37.1 Métodos disponibilizados para map. . . . . . . . . . . . . . . . . . . . . . . . . . . 358 42.1 O editor de texto emacs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 51.1 Ilustração da hierarquia TMatriz da biblioteca LIB_LMPT. . . . . . . . . . . . . 457 51.2 Ilustração da hierarquia da classe TRotulador3D da biblioteca LIB_LMPT. . . . 458 51.3 Ilustração das dependências do arquivo TRotulador3D. . . . . . . . . . . . . . . . 459 53.1 A tela do kdevelop (http://www.kdevelop.org). . . . . . . . . . . . . . . . . . . 484 54.1 Versões de um arquivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496 54.2 Criando um tag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497 54.3 Criando um release. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499 54.4 Como cam os ramos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 54.5 Um frontend para o cvs (o cervisia). . . . . . . . . . . . . . . . . . . . . . . . . . . 506 54.6 Diagrama com os comandos do cvs. . . . . . . . . . . . . . . . . . . . . . . . . . . 508 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Lista de Tabelas 1 Arquivos da apostila no formato pdf. . . . . . . . . . . . . . . . . . . . . . . . . . 31 4.1 Extensões usuais dos arquivos nas diferentes plataformas. . . . . . . . . . . . . . . 61 4.2 Diferenças na nomenclatura da POO e de C++. . . . . . . . . . . . . . . . . . . . 62 5.1 Palavras chaves do ANSI C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 5.2 Convenção para nomes de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 5.3 Exemplos de declarações. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 6.1 Tipos e intervalos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 6.2 Diferenças de tamanho dos objetos padrões de C++ nas plataformas de 16 e 32 bits. 81 12.1 Conversão de ponteiros objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 14.1 Acesso herdado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 16.1 Métodos com ligação estática. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 16.2 Métodos com ligação dinâmica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 18.1 Operadores que podem ser sobrecarregados. . . . . . . . . . . . . . . . . . . . . . 216 23.1 Flags para o método setf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 23.2 Manipuladores da <iomanip>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 23.3 Caracteres de escape. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 24.1 Modos de abertura do método open. . . . . . . . . . . . . . . . . . . . . . . . . . 280 24.2 Modos de proteção do método open (atributos de arquivo). . . . . . . . . . . . . . 280 24.3 Manipuladores para os métodos seekp e seekg. . . . . . . . . . . . . . . . . . . . . 286 28.1 Iteradores e posição. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 41.1 Diretórios importantes para o programador. . . . . . . . . . . . . . . . . . . . . . 400 41.2 Programas úteis para desenvolvedores de software no ambiente Linux. . . . . . . . 401 46.1 Bibliotecas usuais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430 48.1 Comandos do gdb. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444 52.1 Sequência para montagem de programa GNU. . . . . . . . . . . . . . . . . . . . . 462 52.2 Sequência executada pelo usuário. . . . . . . . . . . . . . . . . . . . . . . . . . . . 462 21 Listagens de Programas LISTA DE TABELAS C.1 Precedência dos operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Listagens de Programas 25 40.1 Usando functional. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 43.1 Arquivo e06a-hello.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409 43.2 Arquivo e06b-hello.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410 43.3 Arquivo di. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410 43.4 Arquivo di -c. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410 43.5 Arquivo di -u. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 43.6 Arquivo ex-vector-1-indent.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413 45.1 Arquivo makele. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421 45.2 Exemplo de uso do programa make. . . . . . . . . . . . . . . . . . . . . . . . . . . 422 46.1 Saída do comando ar help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 46.2 Saída do comando nm help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 46.3 Saída do comando ldd /usr/bin/lyx. . . . . . . . . . . . . . . . . . . . . . . . . . . 428 46.4 Arquivo makele com bibliotecas estáticas e dinâmicas. . . . . . . . . . . . . . . . 432 46.5 Arquivo mostrando o uso do makele. . . . . . . . . . . . . . . . . . . . . . . . . . 434 47.1 Arquivo libtool help. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437 51.1 Saída do comando doxygen help. . . . . . . . . . . . . . . . . . . . . . . . . . . . 455 51.2 Exemplo de código documentado no formato JAVA_DOC para uso com o programa doxygem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455 54.1 Saída do comando: cvs help-options . . . . . . . . . . . . . . . . . . . . . . . . . 486 54.2 Saída do comando: cvs help-commands . . . . . . . . . . . . . . . . . . . . . . . 486 54.3 Saída do comando: cvshelp-synonyms . . . . . . . . . . . . . . . . . . . . . . . . 487 54.4 Saída do comando: cvs -import . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489 54.5 Como ca o repositorio após a importação . . . . . . . . . . . . . . . . . . . . . . 490 54.6 Saída do comando: cvs -H checkout . . . . . . . . . . . . . . . . . . . . . . . . . . 490 54.7 Saída do comando: cvs -H commit . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 54.8 Saída do comando cvs commit após adição de um módulo . . . . . . . . . . . . . . 492 54.9 Saída do comando: cvs -H update . . . . . . . . . . . . . . . . . . . . . . . . . . . 495 54.10Saída do comando: cvs -tag nome . . . . . . . . . . . . . . . . . . . . . . . . . . . 497 54.11Saída do comando: cvs commit -r 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 499 54.12Saída do comando: cvs-di . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 54.13Saída do comando: cvs -log leiame.txt . . . . . . . . . . . . . . . . . . . . . . . . 501 54.14Saída do comando: cvs -status leiame.txt . . . . . . . . . . . . . . . . . . . . . . . 503 B.1 Modicadores de acesso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546 B.2 Função e escopo - e14-escopo-a.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . 550 B.3 Função e escopo -e14-escopo-a.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . 550 C.1 Operadores de comparação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558 C.2 Uso de sizeof. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558 D.1 Uso de for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565 D.2 Uso de for encadeado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566 D.3 Uso de while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566 D.4 Uso de switch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567 D.5 Uso de break. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569 D.6 Uso de continue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569 D.7 Uso do operador de incremento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570 D.8 Uso do operador while, exemplo 1. . . . . . . . . . . . . . . . . . . . . . . . . . . 571 D.9 Uso do operador while, exemplo 2. . . . . . . . . . . . . . . . . . . . . . . . . . . 572 André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Listagens de Programas LISTINGS D.10 Uso do operador módulo e do operador ?. . . . . . . . . . . . . . . . . . . . . . . . 572 E.1 Função recursiva. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576 E.2 Função cubo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579 E.3 Função com void. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580 E.4 Função em linha (volume esfera). . . . . . . . . . . . . . . . . . . . . . . . . . . . 581 E.5 Função em linha exemplo 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583 E.6 Exemplo de uso da biblioteca <cstdlib>. . . . . . . . . . . . . . . . . . . . . . . . 583 F.1 Uso do operador de endereço e sizeof. . . . . . . . . . . . . . . . . . . . . . . . . . 590 F.2 Uso de sizeof 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591 G.1 Uso de struct. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594 G.2 Uso de union. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598 G.3 Uso de union para apelidar atributo. . . . . . . . . . . . . . . . . . . . . . . . . . 599 H.1 Uso de funções matemáticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601 Lista de programas André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Prefácio O desenvolvimento desta apostila teve como princípio a reunião dos conceitos de programação em 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ápida, em que a sintaxe de C++ seria apresentada de forma sucinta e direta. Como o interesse pela programação orientada a objeto cresceu substancialmente, diversos alunos do LMPT1 me solicitaram a realização de cursos rápidos abordando C++. Com a apresentação destes cursos, identicava as maiores deciências dos alunos, e, ao mesmo tempo ampliava a apostila. Com o passar dos anos C++ evoluiu, centenas de novos conceitos foram adicionados. A medida que C++ evoluia, esta apostila também evoluia. Para o desenvolvimento desta apostila foram consultados diversos livros de programação ori- entada a objeto, de C++, e de programação para Linux. As referências são classicadas a seguir.  C++, [Bjarne, 1999, Margaret and Bjarne, 1993, Deitel and Deitel, 1997, Deitel and Deitel, 2001 Je and Keith, 1993, Steven and Group, 1993, Roberto and Fernando, 1994].  UML, [Rumbaugh et al., 1994, Coad and Yourdon, 1993, Ann L. Winblad, 1993] [Martin and McClure, 1993].  STL, [Eckel, 2000, Deitel and Deitel, 2001, Bjarne, 1999].  LINUX,[Kurt Wall, 2001, Radajewski and Eadline, 1998, Vasudevan, 2001b, Vasudevan, 2001a, Dietz, 1998] [Cooper, 1999, Raymond, 2000, Cederqvist, 1993, ?] [Nolden and Kdevelop-Team, 1998, Manika, 1999, Gratti, 1999].  Windows, [Ezzel, , Ezzel, 1991, Borland, 1996a, Borland, 1996b, Ezzel, 1993, Perry, 1995b] [Perry, 1995a, Schildt, 1990, Swan, 1994] [Wiener and Pinson, 1991, Steven and Group, 1993, Pappas and Murray, 1993].  Processamento Paralelo,[Kurt Wall, 2001, Dietz, 1998, Hughs and Hughes, 1997] [Radajewski and Eadline, 1998]. Descreve-se a seguir as versões desenvolvidas. 1LMPT signica Laboratório de Meios Porosos e Propriedades Termofísicas. Veja o site do LMPT, em http://www.lmpt.ufsc.br. 27 Sobre a Apostila LISTINGS 5. Programação para Linux: Descreve conceitos de programação no mundo Linux. Apre- senta um resumo das ferramentas de programação do GNU/Linux, cobrindo g++, make, automake, autoconf, libtool, documentação com doxygen, controle de versões com CVS e programas como di, patch, indent. 6. Modelagem orientada a objeto: Apresenta-se a modelagem orientada a objeto usando TMO. Mostra-se como montar o diagrama de uma Análise Orientada a Objeto (AOO) usando a modelagem TMO. A seguir apresenta-se as etapas de desenvolvimento de um software: a especicação, a análise orientada a objeto, o projeto do sistema, o projeto orientado a objeto, a implementação e teste; a manutenção e a documentação de um software. 7. Apêndices: Conceitos gerais de programação em C/C++: Descreve-se alguns con- ceitos gerais de programação em C/C++ como: diretrizes de pré-processador, classes de armazenamento e modicadores de acesso, funções, ponteiros, referências, estruturas, uniões. 8. Exemplos de aplicações: Apresenta-se um programa totalmente desenvolvido usando a programação orientada a objeto. São apresentadas todas as etapas de desenvolvimento, desde as especicações até o código em C++. Os arquivos com exemplos estão em dois formatos: o primeiro html6, permitindo uma visualização através de um bronser. O segundo no formato ASCII (texto simples) com as extensões *.h (arquivos de declarações) e *.cpp (arquivos de implementação dos códigos). Ao longo da apresentação dos temas, são incluídos exemplos. O aluno deve ler todos os tópicos e vericar o funcionamento com os exemplos. É importante compilar os programas e vericar o seu funcionamento. Como fazer download da apostila Os arquivos no formato pdf, podem ser baixados na home-page: http://www.lmpt.ufsc.br/~andre/. As listagens dos programas para GNU/Linux/Unix/Mac OS X, estão disponíveis em: http://www.lmpt.ufsc.br/~andre/ApostilaProgramacao/listagens.tar.gz. e para DOS/Windows em http://www.lmpt.ufsc.br/~andre/ApostilaProgramacao/listagens.zip. Dica: Crie um diretório apostila de programação em C++ e coloque alí os arquivos pdf e os exemplos descompactados. 6Verique se já existem os arquivos desta versão da apostila, no formato html, no site www.lmpt.ufsc.br/ ~andre. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Como ler esta apostila 31 Tabela 1: Arquivos da apostila no formato pdf. Arquivo Linux/Unix Filosoa de programação orientada a objeto P1-FilosoaDePOO.pdf Programação orientada a objeto usando C++ P2-POOUsandoCpp.pdf Classes quase STL P3-ClassesQuaseSTL.pdf Introdução a STL P4-IntroducaoSTL.pdf Programação para Linux P5-Programacao-GNU-Linux.pdf Apêndices: Conceitos gerais de C/C++ P6-Apendices.pdf Modelagem orientada a objeto P7-ModelagemOMT.pdf Apostila completa ApostilaProgramacao.pdf Listagens de códigos listagens.tar.gz Como ler esta apostila Para facilitar a leitura da apostila, alguns títulos tem um código informando a prioridade do mesmo. Este formato foi adotado por permitir a leitura da apostila por programadores iniciantes, intermediários e avançados. Titulo (Iniciante) O iniciante na programação em C++ NÃO deve ler os títulos (Titulo2, Titulo3). Os títulos 2 e 3 podem incluir referências a conceitos que ainda não foram apresentados e só devem ser lidos por quem tiver experiência em C++ ou numa segunda leitura desta apostila. Titulo2 (Intermediário) Se você já conhece C++ e quer se aperfeiçoar, leia também os títulos de nível 2. Titulo3 (Avançado) Se você ja programa a algum tempo em C++ e quer aperfeiçoar seus conhecimentos, leia os títulos de nível 3. Os títulos de nível 3 abordam aspectos com os quais você vai se deparar depois de já ter feito alguns programas. Também foram acrescentadas dicas gerais, dicas de performance e dicas para evitar bugs, utilizando- se os padrões abaixo. Dica: Ao longo dos capítulos são apresentadas algumas dicas. Performance: São dicas de como aumentar o desempenho de seus programas. As dicas de performance serão reunidas no Capítulo Aumentando a Performance de Seus Programas. BUG: Cuidados para evitar a presença de bugs em seus programas. As dicas para evitar os bugs em seus programas estão sendo reunídas no Capítulo Bugs. Para que o aluno possa xar os conceitos, apresenta-se ao longo do texto protótipos de C++, exemplos e listagens de programas. Protótipo: Dene a sintaxe de determinado comando, aparece em itálico. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Como ler esta apostila LISTINGS Exemplos:  Exemplos textuais podem ser apresentados como ítens. Exemplos: /*Os exemplos não são programas completos, são pedaços de programas. Apenas ilustram determinada característica da linguagem e sua sintaxe. Os exemplos são apresentados em fonte fixa.*/ Exemplo: int x = 2; Listings: São exemplos de programas pequenos mas completos, na sua maioria foram testados. Cada programa é documentado, assim, o aluno vai entender o que cada linha esta fazendo. Veja abaixo um exemplo de listing, nesta listagem apresenta-se um programa funcional, o tradicional hello World. Listing 1: Exemplo de um listing. #include <iostream> void main() { std::cout << "Olá mundo !\n"; } Sentenças:  São regras, exemplos e denições curtas e diretas.  Se você encontrar termos desconhecidos dê uma olhada no glossário.  2Sentença de nível 2 só deve ser lida se você já conhece C++ e quer se aperfeiçoar.  3Sentença de nível 3 só deve ser lida por experts. A Figura 1 mostra um diagrama onde você pode identicar a melhor sequência de leitura da apostila. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Experiência do autor 35 Experiência do autor: Ao longo dos últimos anos trabalhei no desenvolvimento dos programas: Simulat: Programa de simulação de transferência de calor e umidade em telhas. Um programa para DOS, com acesso a tela, impressora, saída em disco e saída gráca. O programa esta disponibilizado em www.lmpt.ufsc.br/andre/programas/simulan2000.exe. Anaimp: Programa educacional de análise de imagens de meios porosos, escrito usando a bib- lioteca OWL (Object Windows Library, da Borland). Um programa para Windows, com janelas, ícones e etc. O programa não foi nalizado, uma versão alfa esta disponível em www.lmpt.ufsc.br/~andre/programas/Anaimp.zip. Imago: Programa prossional de análise de imagens de meios porosos. Desenvolvido pela empresa ESSS (http://www.esss.com) com o comando do Eng. Marcos Cabral Damiani. Desenvolvi os sub-sistemas de determinação da permeabilidade pelo método do grafo de conexão serial e de determinação das congurações de equilíbrio. O programa esta disponibilizado em www.lmpt.ufsc.br/Imago. LIB_LMPT: Uma biblioteca de sub-sistemas que cobre a área de análise de imagens (ltros, caracterização, reconstrução e simulação de processos em meios porosos reconstruídos). Agradecimentos: Gostaria de agradecer aos professores Paulo Cesar Philippi, Roberto Lamberts, Celso Peres Fer- nandes, José Antonio Bellini da Cunha Neto, Nathan Mendes, Fábio Santana Magnani, Saulo Guths, Vicente de Paulo Nicolau, Amir Antônio Martins de Oliveira Junior, Jean François Daian, que em algum momento e de alguma forma contribuíram para o desenvolvimento desta apostila. Aos amigos Liang Zhirong, Luiz Orlando Emerich do Santos, Marcos Cabral Damiani. Aos companheiros Aldomar Pedrini, Anastácio Silva, Fabiano Gilberto Wolf, Luís Adolfo Hegele Júnior, Paulo Cesar Facin, Rogério Vilain, Rodrigo Surmas, Carlos Enrique Pico Ortiz. Aos alunos Adirley André Kramer, Carlos Eduardo Paghi, Diego Silva, Geziel Schaukoski de Oliveira, Henrique Cesar de Gaspari, Jaison Seberino Meiss, Luis Gustavo Bertezini, Saulo Guths, Rodrigo Homann, Roberto Barazzeti Junior. A UFSC, Universidade Federal de Santa Catarina, onde desenvolvi meus estudos. Aos desenvolvedores do GNU/Linux e a idéia do software Livre. Dedicatória: Aos meus pais, Bernardo Bueno e Alice Duarte Bueno. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 36 LISTINGS André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Parte I Filosoa de POO 37 40 1.2. SELEÇÃO DA PLATAFORMA DE PROGRAMAÇÃO Programação estruturada Com o desenvolvimento das técnicas estruturadas, os problemas diminuiram. Na programação estruturada as funções trabalham sobre os dados, mas não tem uma ligação íntima com eles. Programação orientada a objeto Para tentar solucionar o problema do baixo reaproveitamento de código, tomou corpo a idéia da Programação Orientada a Objeto (POO). A POO não é nova, sua formulação inicial data de 1960. Porém, somente a partir dos anos 90 é que passou a ser usada. Hoje, todas as grandes empresas de desenvolvimento de programas tem desenvolvido os seus software's usando a programação orientada a objeto. A programação orientada a objeto difere da programação estruturada. Na programação orientada a objeto, funções e dados estão juntos, formando o objeto. Esta abordagem cria uma nova forma de analisar, projetar e desenvolver programas. De uma forma mais abstrata e genérica, que permite um maior reaproveitamento dos códigos e facilita a manutenção. A programação orientada a objeto não é somente uma nova forma de programar é uma nova forma de pensar um problema, de forma abstrata, utilizando conceitos do mundo real e não con- ceitos computacionais. Os conceitos de objetos devem acompanhar todo o ciclo de desenvolvimento de um software. A programação orientada a objeto também incluí uma nova notação e exige pôr parte do analista/programador o conhecimento desta notação (diagramas). 1.1.3 Futuro Bibliotecas de objetos em áreas especializadas cuidadosamente desenhadas estarão disponíveis para dar suporte a programadores menos sosticados. Os consumidores montarão seus progra- mas unindo as bibliotecas externas com alguns objetos que criou, ou seja, poderão montar suas aplicações rapidamente contando com módulos pré fabricados. O usuário nal verá todos os ícones e janelas da tela como objetos e associará a sua alteração a manipulação destes objetos com as suas propriedades intrínsecas. Exemplo, um ícone impressora representará a impressora de seu sistema computacional e per- mitirá a execução de uma impressão, a seleção do tamanho da página, entre outras operações com este objeto. 1.2 Seleção da plataforma de programação Uma plataforma de computação envolve o hardware, o sistema operacional e a linguagem de programação. Pode-se desenvolver um programa para o PC usando DOS, para o PC usando WINDOWS, para o PC usando UNIX, para estações de trabalho usando UNIX, para MAC usando SYSTEM X, entre outros. Para desenvolver programas em um ambiente gráco como o Windows, o Mac OS X, o Gnome ou o KDE, você vai ter de escolher:  uma biblioteca gráca e  um ambiente de desenvolvimento. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 1.3. AMBIENTES DE DESENVOLVIMENTO 41 Apresenta-se a seguir uma lista de bibliotecas grácas que podem ser utilizadas para o desen- volvimento de programas com janelas. Depois apresenta-se rapidamente alguns ambientes de desenvolvimento. 1.2.1 Seleção do ambiente gráco - GDI (bibliotecas grácas) A alguns anos desenvolvia-se um programa em computadores PC XT, PC AT, usando-se um ambiente em modo texto, não existiam janelas e ícones. Mais recentemente, praticamente todos os programas usam janelas, ícones, menus,. . . ; e são desenvolvidos para ambientes computacionais como o PC/Windows9X/NT/XP, estações de trabalho rodando UNIX, GNU/Linux com interface gráca padrão MOTIF, ou mesmo MAC's rodando MAC OS System X. Desenvolver um programa For Windows, assim que saiu o Windows 3.0 era uma verdadeira calamidade, pois o Windows só fornecia algumas funções básicas e o programador tinha que escrever praticamente tudo o que ia utilizar. O mesmo ocorria com os demais ambientes de janelas. Hoje, desenvolver um programa para um ambiente de janelas cou mais fácil, graças a bib- liotecas de interfaces grácas como a OWL, a VCL, a QT, entre outras, que fornecem toda uma hierarquia de classes e objetos que podem ser imediatamente herdados pelo seu programa. Você pode criar janelas, menus, botões, barras de ferramentas, entre outros objetos, com muita fa- cilidade. Entretanto, para que você possa desenvolver um programa para um ambiente gráco qualquer, você vai ter de saber programação orientada a objeto. Você só vai conseguir herdar e utilizar as bibliotecas fornecidas se compreender a programação orientada a objeto e a sintaxe de C++. Em 2002, as bibliotecas mais utilizadas no ambiente Windows são a VCL do Builder e a MFC da Microsoft. No ambiente Linux as bibliotecas qt (da troll tech) e a biblioteca gtk (do GNU/gnome). Dê preferencia a bibliotecas multiplataforma. 1.3 Ambientes de desenvolvimento Descreve-se a seguir alguns pacotes para desenvolvimento de programas em C++. Windows Em termos de ambientes de desenvolvimento, pode-se dizer que tanto o Borland C++ como o Visual C++ são programas bastante maduros e completos. Contam com geradores automáticos de código (como o AppExpert), em que o código é gerado a partir de algumas respostas fornecidas pelo programador. Contam também com ambientes de alteração das classes (como o ClassEx- pert). Espera-se que alguma versão futura do Builder C++ inclua as facilidades da montagem do programa usando um ambiente visual completo e inter-relacionado. Um programa GPL (software livre) muito bom é o DEVC++.  Microsoft Visual C++, ambiente completo com uso da biblioteca MFC (Microsoft Founda- tion Classes).  Borland C++ 5, ambiente completo com uso da biblioteca OWL (Object Window Library). André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 42 1.3. AMBIENTES DE DESENVOLVIMENTO  Borland C++ Builder, ambiente completo, tipo RAD1 com uso da biblioteca VCL (Visual Class Library).  DevC++(http://www.bloodshed.net/dev/), ambiente visual pequeno e simples de usar, usa as ferramentas da GNU.  Sistema GNU, g++, make, automake, autoconf, libtool (http://www.gnu.org). Mac  Code warrior metroworks, ambiente completo com uso da biblioteca code warrior (?).  Sistema GNU (g++, make, automake, autoconf, libtool). Linux2 (Unix)3 Os usuários novos de Linux/Unix/Mac OS X podem achar que o número de opções destas platafor- mas é reduzido, ledo engano. O número de ferramentas disponíveis é incrivelmente grande, lista-se a seguir, brevemente, alguns destes ambientes.  kylix http://www.borland.com/kylix/index.html. Ambiente com uso da biblioteca VCL (Visual Class Library).  Code Warrior Metroworks, ambiente com uso da biblioteca code warrior (?).  kdevelop http: // www. kdevelop. org/ , ambiente completo com uso da biblioteca qt ou kde.  qt http://www.trolltech.com4 , para o desenho de interfaces grácas usando a biblioteca QT.  glade http://glade.gnome.org/ que utiliza o tolkit do gtk++ http://www.gtk.org/.  dev C++ http://www.bloodshed.net/dev/, ambiente visual pequeno e simples de usar, usa as ferramentas da GNU..  Source navigator http: // sources. redhat. com/ sourcenav/ .  Sistema GNU (g++, make, automake, autoconf, libtool). Pode-se desenvolver os programas com editores de texto simples e usar o make para compilação automatizada. Tem o cvs para controle de versões. Observe que usar o sistema GNU garante uma maior portabilidade e uniformidade no desenvolvi- mento de seus programas, pois o mesmo esta presente em praticamente todas as plataformas. 1RAD= Aplicações de desenvolvimento rápido. 2A programação para LINUX é discutida na parte V desta apostila. 3Veja na Revista do Linux, edição 29, uma lista de ambientes de desenvolvimento para Linux (http://www. revistadolinux.com.br/ed/029/assinantes/desenvolvimento.php3). 4Veja uma pequena reportagem sobre o qt design na Revista do Linux, edição 31. http://www.revistadolinux. com.br/ed/031/assinantes/programacao.php3. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 1.4. EXEMPLOS DE OBJETOS 45  O trabalho desenvolvido vai ser salvo como uma biblioteca de objetos, em um local adequado.  Todo o trabalho desenvolvido é documentado, facilitando o reaproveitamento dos códigos desenvolvidos. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 46 1.4. EXEMPLOS DE OBJETOS André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Capítulo 2 Conceitos Básicos de POO Neste capítulo vamos descrever cada mecanismo da programação orientada a objeto dando uma visão que você já conhece e uma visão associada a programação. A Análise Orientada a Objeto (AOO) tem uma série de conceitos que auxiliam as pessoas a delinear claramente o problema e a identicar os objetos e seus relacionamentos. Descreve-se a seguir os conceitos básicos da análise orientada a objeto, isto é, a abstração, o objeto, as classes, os atributos, os métodos, as heranças e o polimorsmo. 2.1 Abstração No dicionário Aurélio, abstração signica considerar isoladamente coisas que estão unidas, ou seja, partimos do enfoque global de um determinado problema e procuramos separar os elementos fundamentais e colocá-los de uma forma mais próxima da solução. A idéia da abstração é identicar os elementos essenciais de um problema e suas propriedades fundamentais, separando ocorrências e atributos acidentais. Para a análise orientada a objeto, abstração é o processo de identicação dos objetos e seus relacionamentos. A análise orientada a objeto permite ao programador concentrar-se no que um objeto é e faz sem se preocupar em como ele o faz. A abstração se dá em diferentes níveis: inicial- mente abstrai-se o objeto; de um conjunto de objetos cria-se um conjunto de classes relacionadas, de um conjunto de classes cria-se uma biblioteca de classes. 2.2 Objeto (ou Instância) Objetos são coisas do mundo real ou imaginário, que podemos de alguma forma identicar, como uma pedra, uma caneta, um copo, uma fada. Um objeto tem determinadas propriedades que o caracterizam, e que são armazenadas no próprio objeto. As propriedades de um objeto são chamadas ainda de atributos. O objeto interage com o meio e em função de excitações que sofre, realiza determinadas ações que alteram o seu estado (seus atributos). Os atributos de um objeto não são estáticos, eles sofrem alterações com o tempo. Para a POO, um objeto é uma entidade única que reúne atributos e métodos, ou seja, reúne as propriedades do objeto e as reações as excitações que sofre. 47 50 2.6. MÉTODOS (SERVIÇOS/FUNÇÕES) Exemplo: A hora de um relógio. Cada relógio tem uma hora, que pode ou não estar certa. 2.6 Métodos (Serviços/Funções) A todo objeto podemos relacionar determinados comportamentos, ações e reações. As ações ou comportamento dos objetos são chamadas na análise orientada a objeto de méto- dos, assim, um método é uma função, um serviço fornecido pelo objeto. Os comportamentos dos objetos são denidos na classe através dos métodos e servem para manipular e alterar os atributos do objeto (alteram o estado do objeto). Exemplos:  Um automóvel tem o comportamento de se locomover.  Um computador de processar programas.  Uma edicação de dar abrigo.  Um meio poroso de permitir o uxo de massa.  Um equipamento de medição de realizar medidas.  Uma método de conversão de uma imagem colorida em tons de cinza altera o estado da imagem, convertendo cada píxel colorido em um píxel cinza. Mensagens2: Foi falado que um objeto tem determinados atributos (propriedades) e métodos (ações), e que o objeto reage ao meio que o envolve de acordo com as excitações que sofre. Em um programa orientado a objeto as excitações são representadas por mensagens que são enviadas a um objeto. Uma mensagem pode ser gerada pelo usuário, por exemplo, ao clicar o mouse. Protocolo2: 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úblicos da classe. Ligação estática/dinâmica2: Ligação é o processo de identicar a posição dos métodos a serem executados. Na ligação estática o endereço dos métodos é denido durante a compilação do programa. Na ligação dinâmica o endereço dos métodos é denido somente durante a execução do programa. 2.7 Herança (Hereditariedade) A herança esta relacionada as hierarquias e as relações entre os objetos. No dia a dia, quando se fala de herança se refere a transferência de propriedades de um pai aos seus lhos, ou seja, aquilo que é do pai passa a ser do lho. É comum ainda o dito popular puxou o pai, que signica que o lho tem as mesmas carac- terísticas do pai. De uma maneira geral as pessoas sabem que o lho puxou o pai mas não é ele, André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 2.7. HERANÇA (HEREDITARIEDADE) 51 ou seja não são a mesma pessoa. E que o lho apresenta determinadas características diferentes de seu pai. Na análise orientada a objeto, herança é o mecanismo em que uma classe lha compartilha automaticamente todos os métodos e atributos de sua classe pai. A herança permite implementar classes descendentes implementando os métodos e atributos que se diferenciam da classe pai. Herança é a propriedade de podermos criar classes que se ampliam a partir de denições básicas. De classes mais simples e genéricas para classes mais complexas e especícas. Exemplo:  Um Pentium II tem todas as características do Pentium preservadas, mas acrescentou mais memória cache, a memória cache já existia mas foi ampliada.  Uma placa mãe nova apresenta a interface USB, é uma novidade que antes não existia. 2.7.1 Herança simples Quando uma classe herda as propriedades de uma única classe pai. Exemplo:  Herança genética, um menino herda as características genéticas de seus pais. 2.7.2 Herança múltipla A herança múltipla ocorre quando uma classe tem mais de um pai. Exemplo:  Herança de comportamento, muitas vezes dizemos que um menino herdou o seu jeito en- graçado do tio e estudioso do pai. Nomes de classe2: Numa família os lhos e nétos compartilham os nomes de seus ancestrais, da mesma forma, em uma hierarquia de classes os nomes devem ser signicativos, semelhantes e esclarecedores. Superclasse2: Uma superclasse é a classe base de uma hierarquia de classes, é a classe mais alta na hierarquia (é a origem da árvore). Compartilhamento2: As técnicas orientadas a objeto facilitam o compartilhamento de código através dos conceitos de herança. Além de um maior compartilhamento do código a análise orientada a objeto reduz a codicação em função da maior clareza dos diagramas desenvolvi- dos. Cancelamento2: é a substituição de uma método da classe pai por outra na classe lho, pode ocorrer com os seguintes objetivos: cancelamento para extensão (ampliação das tarefas que eram realizadas), cancelamento para restrição (quando a tarefa não é mais necessária), can- celamento para otimização (quando se deseja aumentar a performance). Cancelamento por André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 52 2.8. POLIMORFISMO conveniência (quando o cancelamento pode ser conveniente por um motivo qualquer, deve ser evitada pois é semanticamente errado). Os métodos não podem ser substituídos para terem um comportamento diferente do esperado. 2.8 Polimorsmo A palavra polimorsmo signica muitas formas, e representa o fato de uma determinada cara- cterística (potência do motor do veículo) ser diferente para cada lho (tipo de veículo). Quem já andou de Volks e de Mercedes sabe bem a diferença. Na natureza o conceito de polimorsmo é inerente ao processo de desenvolvimento, os seres evoluem, se modicam. Exemplo:  Num programa de simulação numérica pode-se ter a evolução dos métodos de integração numérica. Do método do Trapésio para o método de Simpson, para o método de Gauss. Em suma, estamos partindo de um objeto mais simples e evoluindo. Mas os conceitos do ob- jeto pai continuam a existir nos objetos descendentes, mesmo que tenham sofrido modicações, aperfeiçoamentos e assumido novas formas (polimorsmo). O conceito de polimorsmo é fundamental para a análise orientada a objeto; sua aplicação se fundamenta no uso de uma superclasse, através do qual vamos desenvolver nossa hierarquia de classes. Sinergia2: Os conceitos da análise orientada a objeto apresentam um efeito de sinergia (soma de qualidades), em que a soma dos diversos conceitos da AOO implicam num resultado mais positivo que o esperado. A partir da versão 0.4 da apostila, o capítulo de Modelagem TMO (UML) e o capitulo Etapas de Desenvolvimento de Um Programa foram movidos para o nal da apostila. Também foram movidos para o nal da apostila tudo o que diz respeito a linguagem de programação C. Um curso de C++ é longo, e a experiência mostrou que iniciar com modelagem e depois abordar conceitos de C não funciona. Perde-se a relação de objeto conceitual (modelagem) com objeto da linguagem C++. O curso ca confuso. Como o número de conceitos novos é grande, ao chegar na parte interessante de C++, polimorsmo e STL, o aluno já não tinha mais capacidade de aprendizado. Deve-se ressaltar que os seus primeiros programas usando POO consumirão o mesmo tempo que os desenvolvidos usando técnicas estruturadas. As vantagens do reaproveitamento aparecem a medida que os programas vão sendo desenvolvidos. Ou quando você já dispõe de uma biblioteca e pode desenvolver o programa a partir desta biblioteca. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 3.2. DIAGRAMAS UML USANDO O PROGRAMA DIA 55 Classe +atributo +método() Representação de uma herança Classe +atributo +método() Classe +atributo +método() «Estereótipo» NomeHerança Classe +atributo +método() Classe +atributo +método() Representação de uma associação NomeAssociação ma mb Classe +atributo +método() Classe +atributo +método() NomeAgregação Representação de uma agregação Figura 3.4: Representação de heranças, associações e agregações. Ator use case life_line object «estereótipo» [estado] mensagem «estereotipo componente» node estereótipo de uma classe state machine um branch Figura 3.5: Representações diversas. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 56 3.2. DIAGRAMAS UML USANDO O PROGRAMA DIA André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Parte II POO usando C++ 57 60 4.2. O QUE É O ANSI C++? 4.2 O que é o Ansi C++? OANSI C++1 é um comitê que estabelece os conceitos básicos da linguagemC++. Principalmente os referentes a sintaxe de C++. Se você desenvolver um programa compatível com o ANSI C++, pode ter certeza de que ele pode ser compilado por diferentes compiladores de C++ para diferentes plataformas. Em 1990 foi aprovado o ANSI/ISO2 9899 que é o ANSI C. Em 1998 foi aprovado o ANSI/ISO C++. 4.3 Quais as novidade e vantagens de C++? A linguagemC++ é uma das melhores linguagens de programação existentes por conseguir agrupar uma funcionalidade que envolve formulações altamente abstratas como classes, que permitem um trabalho de alto nível (trabalha-se a nível de conceitos) e formulações de baixo nível, como o uso de chamadas de interrupções que realizam tarefas altamente especícas. Como novidades de C++ em relação ao C, podemos citar: O uso de classes, funções inline, conversão de tipo, vericação de argumentos de função, operadores para gerenciamento de memória (new/delete), referências, constantes, sobrecarga de operador, sobrecarga de funções, polimorsmo, templates (gabaritos), tratamento de exceções e espaços de nomes (namespace). Destes novos conceitos os que mais se destacam são o uso de classes, do polimorsmo e os gaba- ritos. Como vantagens de C++ em relação ao C, podemos citar: Aumento da produtividade, maior reaproveitamento de código, maior qualidade geral do projeto, facilidade de extensão e manutenção. Maior compreensão geral por toda equipe de desenvolvimento. Dica: Com C++ um único programador consegue gerenciar uma quantidade maior de código. 4.4 Tipos de programação em C++ Como visto, C++ é um superconjunto de C e foi desenvolvido para dar suporte a programação orientada a objeto. Qual a implicação dessa herança de C e C++ ? Você vai se deparar com programas nos seguintes estados: Programa estruturado escrito em C: Uso os conceitos básicos de C, dados e funções separados. Programa estruturado escrito em C++: Usa alguns conceitos de C++ como cin/cout, switch, funções inline, const, referências. Ou seja, usa alguns acréscimos de C++. 1ANSI = American National Standart Institute (Instituto Americano de Padrões e Medidas). 2ISO = Organização de Padrões Internacionais. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 4.5. COMPILAR, LINKAR, DEBUGAR E PROFILER 61 Programa baseado em objeto usando C++: Usa os conceitos de classes e heranças. Inclue controle de acesso, funções friend. Inclue o conceito fundamental de classes. Programa orientado a objeto em C++: Inclue o conceito de polimorsmo, pode incluir o uso de conceitos da STL como containers e iteradores. Inclue o conceito fundamental de polimorsmo. Programação genérica: Inclue o uso de funções genéricas da STL, uso intensivo de containers e iteradores. Inclue o conceito de código genérico. Esta apostila tem seu foco nos dois últimos tipos de programação. 4.5 Compilar, linkar, debugar e proler Descreve-se a seguir alguns conceitos gerais sobre programas. Um programa: É composto de um ou mais arquivos encadeados. Um arquivo é composto por um conjunto de instruções de programação (em ASCII). Fase de pré-processamento: É a primeira fase da compilação, verica as instruções de compilação passadas com o sinal # ; Primeiro são incluídos os arquivos externos, depois são processadas as macros. O resultado da fase de pré-processamento é uma seqüência de símbolos que chamamos de unidade de tradução. Compilador: O compilador encontra os erros de sintaxe do programa e realiza a tradução do código em linguagem de máquina. Depois de compilado o programa passa a ter um arquivo *.obj (*.o no Unix/Linux). Linker: O linker transforma um ou mais arquivos *.obj (*.o) em um arquivo executável. Os arquivos que serão unidos são denidos em um arquivo de projeto ou em um arquivo makele. Depois de linkado um programa tem um arquivo executável *.exe no Windows, a.out no Linux. Os erros de ligação são detectados pelo linker. Veja na Tabela 4.1 as extensões dos arquivos gerados nas diferentes plataformas. Debuger: O debuger é um programa que ajuda o programador a encontra os erros de progra- mação, os famosos bug's. Proler: O proler é um programa que ajuda a identicar os pontos do programa que con- somem mais tempo (onde o programa esta sendo lento); de posse dessa informação pode-se mel- horar a qualidade do programa e a sua velocidade. Apenas rode o programa de dentro do proler e analise os resultados de tempo de execução de cada função. Tabela 4.1: Extensões usuais dos arquivos nas diferentes plataformas. Situação dos/Windows Unix/Linux Mac antes de compilar nome.h/nome.cpp nome.h/nome.cpp nome.h/nome.cpp depois de compilar nome.obj nome.o nome.o depois de linkar nome.exe nome nome André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 62 4.6. DIFERENÇAS DE NOMENCLATURA (POO E C++) 4.6 Diferenças de nomenclatura (POO e C++) A Tabela 4.2 mostra as diferenças na nomenclatura da programação orientada a objeto e a nomen- clatura de C++. Nesta apostila procurei usar sempre os nomes objeto, atributo e método. Mas em algumas ocasiões uso os os termos funções e variáveis. Vou chamar de função apenas as funções globais e funções de C. Vou chamar de método as funções que são implementadas como parte de uma classe. O objetivo é aproximar os conceitos da POO dos de programação em C++. Tabela 4.2: Diferenças na nomenclatura da POO e de C++. Nomenclatura POO Nomenclatura C++ Objeto Objeto Classe Classe Método Função/método Atributo Atributo, variável Mensagem Chamada de função Subclasse Classe derivada Superclasse Classe base Hereditariedade Derivação 4.7 Layout de um programa O desenvolvimento de um programa inicia com a denição do arquivo de projeto, a seguir são criados os arquivos de cabeçalho (*.h) e os arquivos de implementação (*.cpp). 4.7.1 Arquivo de projeto O arquivo de projeto dene quais arquivos fazem parte do programa e em que sequência devem ser compilados, ou seja, contém uma lista com os nomes dos arquivos de cabeçalho (*.h) e de implementação (*.cpp) e a forma como os mesmos serão compilados. A organização dos programas separando o código em diversos arquivos facilita a manutenção do programa e possibilita um maior entendimento da estrutura dos programas. Todo processo de compilação/recompilação ca mais rápido. Um arquivo de projeto tem a extensão *.ide ou *.prj (no Borland), *.mfc (no MFC), *.kdevelop (no kdevelop), e *.? (no Dev C++), podendo ser ainda um arquivo makele3 (no Unix/Linux). 4.7.2 Arquivo de cabeçalho da classe (*.h) A denição da classe é armazenada em arquivos de cabeçalho com a extensão *.h, veja o exemplo a seguir. 3Veja exemplo de arquivo makele na seção 45.4. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 4.8. EXEMPLO DE UM PROGRAMA ORIENTADO A OBJETO EM C++ 65 -Inclusão de bibliotecas #include <iostream> -Saída para tela std::cout << "Bem vindo ao C++!"; */ /* Dica: Para compilar este arquivo no Linux, abra um terminal, vá ao diretório com o arquivo e01-TAplicacao.cpp e execute o comando abaixo: g++ -c e01-TAplicacao.cpp */ Listing 4.3: Exemplo básico - Arquivo programa.cpp. // ----------------------------------------programa.cpp //Inclue o arquivo "TAplicacao.h" que tem a definição do objeto TAplicacao #include "TAplicacao.h" //A função main, retorna um inteiro, se chama main e não tem nenhum parâmetro int main() { //Cria objeto do tipo TAplicacao TAplicacao ap; //Executa o método Run do objeto ap ap.Run(); //A função deve retornar um inteiro o 0 indica que o programa terminou bem return 0; } /* Novidade: -A instrução #include <iostream> é usada para incluir o acesso a biblioteca padrão de entrada e saída de dados do C++. -A instrução #include "TAplicacao.h" é usada para incluir um arquivo, procurando primeiro no diretório corrente e depois na path do ambiente de desenvolvimento. -O objeto cout é usado para enviar caracteres para a tela. -Dentro da função main a criação do objeto TAplicacao -A execução do método Run do objeto TAplicacao -O retorno da função main return 0; */ /* Dica: Para compilar o programa no Linux g++ programa.cpp TAplicacao.cpp André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 66 4.8. EXEMPLO DE UM PROGRAMA ORIENTADO A OBJETO EM C++ Para executar o programa no Linux ./a.out */ /* Saída: ------ Bem vindo ao C++! */ Dica: C++ é extensivamente utilizado em aplicações cientícas, em programas com interface gráca e com muita interação com o usuário. Dica2: Programas de engenharia, físicos, e matemáticos são bem representados em C++, pois as diferentes áreas da matemática são facilmente modeladas como classes em C++. Isto é, faz-se uma associação clara entre conceitos matemáticos e classes de C++. Dica: Ao nal de cada capítulo dedique cerca de 5 minutos para fazer uma revisão rápida dos conceitos apresentados. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Capítulo 5 Conceitos Básicos de C++ Apresenta-se neste capítulo alguns conceitos básicos de C++. As palavras chaves do C++, como você deve nomear seus objetos e como declarar e denir objetos. 5.1 Sobre a sintaxe de C++ Descrever todos os detalhes da sintaxe de C++ em programas orientados a objeto é um trabalho complexo e que levaria várias centenas de páginas. Para que esta apostila não casse muito grande, admite-se que o leitor tenha o acompanhamento de um programador para esclarecer suas dúvidas, ou que já tenha experiência em outras linguagens de programação. A descrição da sintaxe de C++ segue dois modelos; No primeiro é descrita a sintaxe e apre- sentado ou um exemplo ou alguma informação extra. Na segunda é apresentada apenas a sintaxe, sem informações adicionais. Por ser tão poderosa, a linguagem C++ tem um excesso de regras, o que ocasiona um apren- dizado mais lento. Mas em C++ os programas tem um ganho de qualidade e versatilidade indis- cutível em relação as linguagens mais simples como Basic, Pascal, Visual Basic e Delphi. 5.2 Conceitos básicos de C++ Apresenta-se a seguir alguns conceitos básicos de C++. Estes conceitos serão melhor compreen- didos posteriormente, com as listagens de programas que são apresentadas. Arquivo: É um texto contendo código fonte em C++ e comandos para o pré-processador. Comentários: Um comentário em C usa os caracteres /* para iniciar o comentário e */ para encerrar o comentário. Exemplo: /* comentário*/ Um comentário em C++ usa duas barras (//). Exemplo: 67 70 5.3. PALAVRAS CHAVES DO C++ Exemplo: int x; //int é o especificador inline void f() //inline é o especificador {cout < <saida< < endl;} typedef float racional; //typedef é o especificador 5.3 Palavras chaves do C++ Uma linguagem de programação faz uso extensivo de determinadas palavras, denominadas palavras chaves. Estas palavras foram denidas para a linguagem C++, e são usadas pelo programador com algum objetivo especíco. Como estas palavras já tem um signicado pré denido para a linguagem, você não 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 nas palavras, algumas palavras chaves tem mais de uma util- idade. Como exemplo a palavra chave virtual, a mesma pode especicar uma função virtual ou uma herança virtual. Outro exemplo é void, que para ponteiros é um ponteiro para qualquer coisa, e para funções signica ausência de parâmetros ou ausência de retorno. Lista-se as palavras chaves do ANSI C++ na Tabela 5.1. As palavras chaves estão classicadas de acordo com seu uso. 5.4 Nome dos objetos (identicadores) O nome de um objeto deve começar com uma letra (a-z, A-Z, ou underscore_). A linguagem C++ difere maiúsculas e minúsculas, ou seja, AA é diferente de aa. Caracteres válidos: a-z A-Z 0-9 +-*/=,.:;?n" '  j!# $ & ()[]{}@ Caracteres inválidos: ++  == & & // << >> >= <= += -= *= /= ?: :: /** 5.4.1 Convenção para nomes de objetos Para facilitar a leitura do programa, estabelece-se uma convenção de como os objetos devem ser nomeados, veja na Tabela 5.2 uma convenção para nomes de objetos. Apresenta-se a seguir um outro exemplo, observe ao nal a seção novidades e a seção saída. A seção novidades descreve alguma coisa nova que foi utilizada. A seção saída mostra a saída gerada pelo programa. Listing 5.1: Usando saída para tela e nova linha. #include <iostream> int main() { //'\n' coloca uma quebra de linha std::cout << "Welcome\n "; André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 5.4. NOME DOS OBJETOS (IDENTIFICADORES) 71 //'\a' emite um beep std::cout << "to C++!\n\a"; //'\t' coloca um tab std::cout << "Bem" << '\t' << "Vindo!"; //cada \n coloca uma quebra de linha std::cout << "\nB\ne\nm\n\nV\ni\nn\nd\no\n\na\no\n\nC++\n!\n"; return 0; } /* Novidades: ---------- Uso de \a para emitir um beep, std::cout << "to C++!\n\a"; Uso de \t para acrescentar um tab, std::cout << "Bem" << '\t' << " Vindo!"; Observe que usa "Welcome" com aspas duplas para uma palavra ou frase e '\t' aspas simples para um único caractere. */ /* Saída: ----- Welcome to C++! Bem Vindo! B e m V i n d o a o C++ ! */ O programa inicia incluindo a biblioteca padrão de C++, a <iostream>, na linha #in- clude <iostream>. A <iostream> é uma biblioteca usada para entrada e saída de dados. A <iostream> fornece o objeto std::cout, o mesmo é usado para enviar uma mensagem para a tela. Observe o uso do operador <<, que indica, envie estes caracteres para saída (cout = C out). O exemplo inclue ainda a função int main(). A função main é a função inicial de um programa em C++. Dentro da função main, envia para a tela a mensagem Welcome\n. O caracter \n é usado André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 72 5.5. DECLARAÇÕES para colocar uma quebra de linha depois da palavra Welcome. A seguir envia para a tela a mensagem  to C++ e Bem \tVindo O caracter \t é usado para colocar uma tabulação entre a palavra Bem e a palavra Vindo. Na penúltima linha envia para a tela a mensagem Bem Vindo ao C++, incluindo, entre cada caracter uma nova linha '\n'. A última linha da função main é a return 0;, a mesma é usada para nalizar a função main e o programa, retornando para o sistema operacional o valor 0, que indica sucesso na execução do programa. Observe no nal da listagem como cou a saída. Apresenta-se a seguir como declarar e denir objetos em C++. 5.5 Declarações Uma declaração introduz um ou mais nomes em um programa e especica como esses nomes devem ser interpretados. Uma declaração não reserva memória para o objeto, apenas diz que ele existe. Uma declaração tem dois componentes os especicadores2 e os declaradores3. Protótipo: Especicador Declarador; Especicador, especica o tipo do objeto. Declarador, é o nome do objeto. Exemplo: class Point; //introduz um nome de classe typedef int I; //introduz um sinônimo para int int x; //introduz um objeto do tipo int com nome x Declaração simples: Consiste em declarar um objeto de cada vez. Exemplo: int x; Declaração múltipla: Consiste em declarar vários objeto de uma única vez. Exemplo: float r,s,t; Declaração com inicialização: Consiste em declarar um objeto e ao mesmo tempo atribuir um valor a este objeto. Exemplo: int u = 7; float x = 5.2; 2Especicadores: Os especicadores indicam o tipo fundamental, a classe de armazenamento ou outras pro- priedades dos objetos declarados. 3Declaradores: Os declaradores especicam o nome dos objetos e opcionalmente modicam o tipo com um *. Um declarador pode especicar um valor inicial para o identicador que esta sendo declarado (=). André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 5.6. DEFINIÇÕES 75 return 0; } /* Novidade: --------- -Declaração de objetos -Entrada de dados -Saída de dados -Realização de conta O objeto cin, declarado no arquivo <iostream> é usado para armazenar dados digitados no teclado em um objeto do usuário. cin é usada na linha: std::cin >> a; */ /* Saída: ------ [andre@mercurio Cap2-Sintaxe]$ ./a.out Entre com a:5 Entre com b:6 Soma =11 */ Dica: Os programas foram compilados e rodados em um PC usando Linux. O compilador utilizado é o g++, o compilador da GNU. Por default, o compilador da GNU gera um executável com nome a.out. Para compilar o programa abra um terminal, vá para o diretório onde o programa esta localizado e digite g++ nomePrograma.cpp. Para executar o programa digita-se ./a.out. Para compilar e executar o programa no ambiente Windows consulte os manuais de seu ambiente de desenvolvimento. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 76 5.6. DEFINIÇÕES Tabela 5.1: Palavras chaves do ANSI C++. Tipos char double enum oat int long short Modicadores de tipos auto const extern register signed static typedef unsigned volatile static Controle break case continue default do else for goto if return switch while Lógicos and and_eq bitand bitor not not_eq xor xor_eq or or_eq Memória new delete Controle de acesso public private protected Conversões const_cast dynamic_cast static_cast reinterpret_cast Excessões try throw catch Diversos asm class explicit friend namespace operator register typename typeid this using struct sizeof union void André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 5.6. DEFINIÇÕES 77 Tabela 5.2: Convenção para nomes de objetos. Tipo de objeto Formato do nome Variáveis constantes: CONTADOR; Nome de classes: TNomeClasse; Nome de métodos/funções: Minúsculas(); Atributos: minúsculas; Atributos estáticos: $minúsculas; Nome de classes derivadas: Deve lembrar a classe base. Tabela 5.3: Exemplos de declarações. Sintaxe da declaração Tipo efetivo Exemplo tipo nome[]; matriz do tipo int count[]; tipo nome[3]; matriz do tipo c/ 3 elementos int count[3]; //0,1,2 tipo* nome; ponteiro para tipo int* count; tipo* nome[]; matriz de ponteiros para tipo int* count[]; tipo* (nome[]); matriz de ponteiros para tipo int* count[]; tipo (*nome)[]; ponteiro para matriz do tipo int (*count)[]; tipo& nome; referência para o tipo int& count; tipo nome(); função que retorna o tipo int count(); tipo*nome(); função que retorna ponteiro tipo* int* count(); tipo*( nome()); função que retorna ponteiro tipo* int*(count()); tipo (*nome)(); Ponteiro para função que retorna o tipo int (*count)() André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 80 6.2. USO DE TIPOS PRÉ-DEFINIDOS DE C++ bool, char, unsigned char short int, unsigned short int, unsigned int, long, unsigned long, int* long long, double, float Figura 6.1: Tipos de dados e dimensões (sizeof). Dê uma olhada no arquivo de biblioteca <limits>1. Este arquivo contém variáveis que denem os limites para os tipos pré-denidos da linguagem. Tabela 6.1: Tipos e intervalos. Tipos Básicos Características bytes Valor mínimo valor máximo bool boleano 1 0 1 char caracteres 1 -128 127 unsigned char caracteres s/ sinal 1 0 255 short inteiros 2 -32768 32767 unsigned short int, peq. s/sinal 2 0 65535 int inteiros 4 -2.147.483.648 +2.147.483.648 unsigned int inteiro sem sinal 4 0 +4.294.295.000 long inteiro grande 4 -2.147.483.648 +2.147.483.648 unsigned long int,gde.c/sinal 4 0 +4.294.295.000 oat precisão simples,7 digitos 4 3.4e-38 3.4e+38 double precisão dupla, 15 digitos 8 1.7e-308 1.7e+308 long double precisão dupla, 18 digitos 10 3.4e-4932 3.4e+4932 enum enumerados 2 -2.147.483.648 +2.147.483.648 A Tabela 6.2 mostra as diferenças entre as plataformas de 16 e 32 bits. Para oat, double, long double os tamanhos não mudam. Dica: O compilador g++ da gnu suporta o tipo long long, que representa um inteiro de 64 bits. O compilador da GNU é descrito no Capítulo 44. Apresenta-se a seguir um programa que usa os tipos padrões de C++. Observe que este exemplo não tem nem entrada, nem saída de dados, não sendo necessária a inclusão (#include) de arquivos externos. Listing 6.1: Tipos numéricos de C++. 1Veja no manual do seu ambiente de desenvolvimento onde estão armazenados os arquivos da biblioteca de C++. No Linux estão em /usr/include/g++. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 6.2. USO DE TIPOS PRÉ-DEFINIDOS DE C++ 81 Tabela 6.2: Diferenças de tamanho dos objetos padrões de C++ nas plataformas de 16 e 32 bits. 16 bits 16 bits 32 bits 32 bits enum -32768 +32768 -2.147.483.648 +2.147.483.648 unsigned int 0 65535 0 4.294.967.295 int -32768 +32768 -2.147.483.648 +2.147.483.648 int main () { //Tipos padrões da linguagem //Tipo booleano //Intervalo 0 ou 1 //1 bytes bool flag = 0; //Tipo char //Intervalo -128 -> +127 //1 bytes char ch = 'b'; //Tipo int //2 byts (16 bits), Intervalo (16bits)~ - 32768 -> + 32767 //4 byts (32 bits), Intervalo (32bits)~ -2147483648 -> +2147483648 int int_x = 777; //Tipo float //Intervalo +/- 3.4.e+/-38 (7 digitos precisão) //4 bytes float float_y = 3.212f; //Tipo double //Intervalo +/- 1.7e+/-308 (15 digitos precisão) //8 bytes double double_z = 12312.12312e5; //Tipo long double //Intervalo +/- 3.4e+/-4932 (18 digitos precisão) //10 bytes long double long_double_r = 1.2e-18; return 0; } /* Novidade: -------- Tipos: A linguagem C++ é altamente prototipada, ou seja, dá uma importância muito grande ao tipo dos objetos. Uso dos tipos padrões de C++ bool, char, int, float, double, long double André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 82 6.2. USO DE TIPOS PRÉ-DEFINIDOS DE C++ Criação de objetos numéricos e atribuição de valores a estes objetos. Saída: ----- Este exemplo não inclue saída de dados. */ Observe no exemplo a seguir o uso e as diferenças dos tipos int e unsigned int. Listing 6.2: Diferenças no uso de inteiro com sinal (signed) e sem sinal (unsigned). #include <iostream> void main() { { std::cout << "---------->Testando uso de int"<<std::endl; int x, y, z; std::cout <<"Entre com int x (ex: 300):"; cin >> x; std::cout <<"Entre com int y (ex: 500):"; cin >> y; 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 uso de unsigned int"<<std::endl; unsigned int x,y,z; std::cout <<"Entre com unsigned int x (ex: 300):"; cin >> x; std::cout <<"Entre com unsigned int y (ex: 500):"; cin >> y; 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; //faz o teste abaixo, de forma a retornar o modulo da diferença //se x > y retorna z = x - y //se x <= y retorna z = y - x if( x > y) z = x - y ; else z = y - x ; //armazena a informação do sinal int sinal = x > y ? +1 : -1 ; //Cria objeto int para armazenar o resultado, observe que sinal é do tipo int int valor_z = sinal * z ; std::cout <<"z=| x - y |=" << z << std:: endl; std::cout <<"sinal de x - y =" << sinal << std:: endl; André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 6.3. USO DE TIPOS DO USUÁRIO 85 }; //Atributos double x, y; //Coordenadas x e y }; //Exemplo de definição de um método da classe Complexo //Exemplo que soma z=A+B, o número complexo A com B Complexo & Complexo::operator+ ( Complexo & p) { Complexo* z = new Complexo; z->x = x + p.x; z->y = y + p.y; return (*z); } //Exemplo de criação e uso de um objeto do tipo Complexo int main () { //Cria objetos a e b do tipo Complexo Complexo a, b; //Chama função Set do objeto a e b a.Set (5, 4); b.Set (2, 3); //cria um novo objeto complexo Complexo c; //soma dois complexos e armazena em c c = a + b; std::cout << "c(" << c.x << "," << c.y << ") = " << "a(" << a.x << "," << a.y << ") + " << "b(" << b.x << "," << b.y << ") " << std::endl; return 0; } /* Novidade: -Declaração de classe do usuário, a classe Complexo. -Criação dos objetos Complexo a, b, c. -Uso dos objetos criados c = a + b */ /* Saída: ----- [andre@mercurio Parte-II]$ ./a.out c(7,7) = a(5,5) + b(2,2) */ Neste exemplo foi utilizado o conceito de sobrecarga de operador. Veja o conceito de operadores na seção C na página 553 e de sobrecarga de operadores na seção 18 na página 215. Agora você já sabe usar os tipos padrões de C++ (char, int, oat...), já tem idéia de como se André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 86 6.4. USO DE TIPOS DEFINIDOS EM BIBLIOTECAS EXTERNAS (STL) declara e se dene um tipo do usuário. A seguir vamos ver um exemplo de uso de uma biblioteca externa, isto é, uso da biblioteca STL, a biblioteca standart de C++. 6.4 Uso de tipos denidos em bibliotecas externas (STL) Uma biblioteca é um conjunto de objetos reunidos em um único arquivo. Você pode criar e usar suas próprias bibliotecas ou usar bibliotecas desenvolvidas por terceiros. Veremos como criar bibliotecas no Capítulo 46. A standart template library (ou STL), é uma biblioteca avançada de C++. Todas as dis- tribuições padrões de C++ incluem a STL. No exemplo a seguir você verá o uso da classe vector, uma classe extremamente útil disponibi- lizada pela STL. Com a classe vector você elimina totalmente o uso de vetores e arrays no estilo de C. No exemplo a seguir cria um vetor e solicita ao usuário a entrada de dados. Cada novo valor que o usuário entra é armazenado no vetor. Para encerrar a entrada de dados o usuário digita (ctrl + d, no Linux) e (ctrl + z, no Windows). A seguir o programa mostra os valores do vector. O programa usa estruturas de controle, as mesmas são desccritas no apêndice D. Listing 6.4: Exemplo preliminar de uso da classe vector da biblioteca STL //Classes para entrada e saída de dados #include <iostream> //Classe de vetores, do container vector #include <vector> //Definição da função main int main () { //Cria vector, do tipo int, com nome v, um vetor de inteiros vector < int > v; int data; std::cout << "No DOS um ctrl+z encerra a entrada de dados." << std::endl; std::cout << "No Mac um ctrl+d encerra a entrada de dados." << std::endl; std::cout << "No Linux um ctrl+d encerra a entrada de dados." << std::endl; do { std::cout << "\nEntre com o dado (" << v.size () << "):"; cin >> data; cin.get (); //acidiona ao final do vetor v o objeto data if (cin.good ()) v.push_back (data); } while (cin.good ()); //Acessa partes do vector usando funções front e back std::cout << "\nPrimeiro elemento do vetor= " << v.front () << "\nÚltimo elemento do vetor= " << v.back () << std::endl; //Mostra o vetor André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 6.4. USO DE TIPOS DEFINIDOS EM BIBLIOTECAS EXTERNAS (STL) 87 for (int i = 0; i < v.size (); i++) { std::cout << "v[" << i << "]=" << v[i] << ' '; } std::cout << std::endl; std::cout << (v.empty ()? "O vetor esta vazio" : "O vetor não esta vazio") << std::endl; //Chama função clear, que zera o vetor v.clear (); std::cout << (v.empty ()? "O vetor esta vazio" : "O vetor não esta vazio") << std::endl; std::cout << std::endl; cin.get (); return 0; } /* Novidade: Uso do container vector. Uso dos métodos: push_back, size, empty, clear, Uso dos operadores do..while e de for Uso de cin.good() para verificar se a entrada foi correta. O Operador de controle do ...while(); ------------------------------------- O operador de controle do..while executa a sequência de comandos dentro do bloco pelo menos 1 vez. A seguir verifica a expressão dentro do while . do { comandos_a_executar } while (expressão); enquanto a expressão for verdadeira executa a sequência de comandos dentro do do{}while. Observe a presença de ponto e vírgula após o while. O operador de controle for: --------------------------- Um comando for é utilizado para realizar um looping, uma repetição de determinado comando diversas vezes. O protocolo de um comando for é da forma: for (inicializacao; teste; incremento) {} Exemplo: for ( int i = 0; i < 10; i++ ) std::cout << " i = " i << std::endl; André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 90 6.6. SENTENÇAS PARA TIPOS André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Capítulo 7 Namespace Neste capítulo apresenta-se o que é um namespace, como usar o espaço de nomes da biblioteca padrão de C++ (std), como denir e usar um namespace. 7.1 O que é um namespace ? Como o próprio nome diz, signica espaço para nomes. Quando você monta seu programa uti- lizando bibliotecas externas podem ocorrer duplicações de nomes, isto é, um objeto denido em uma das bibliotecas tem o mesmo nome de um objeto denido por você. Exemplo: Você criou as funções min() e max(), que retornam o menor e maior valor de um vetor. Mas a STL já tem estas funções. Desta forma o compilador não sabe função qual min() você quer chamar. Solucionar o problema da duplicação de nomes pode ser complexo, pois se estes nomes pertencerem a bibliotecas externas, você precisaria contactar os desenvolvedores destas bibliotecas para resolver os conitos, ou renomear seus objetos e funções. O namespace veio para resolver este problema. 7.2 Usando o espaço de nomes da biblioteca padrão de C++ (std) Para usar os objetos standart de C++ é preciso incluir a palavra std e a seguir o operador de resolução de escopo, isto é: //Para usar uma função da std você usa std::nomeFuncao(); //Para usar um objeto std::nomeObjeto; //Para chamar uma função da std com parâmetros std::nomefuncao(std::nomeObjeto); Nas listagens de código ja apresentadas usamos: 91 92 7.3. DEFININDO UM NAMESPACE2 int x = 3 ; std::cout < <  entre com x : ; std::cin > > x ; std::cin.get(); std::cout < <  x =  < < x < < std::endl; Pode-se utilizar os objetos standarts de C++ diretamente, isto é, sem o uso de std::, para tal basta colocar a declaração using namespace std no início do programa. Exemplo: //Declara que vai usar os objetos standart de C++ using namespace std; int x = 3 ; cout < <  entre com x : ; cin > > x ; cin.get(); cout < <  x =  < < x < < endl; 7.3 Denindo um namespace2 Todo arquivo de código, deve ter uma declaração namespace indicando um nome geral para os códigos que estão sendo desenvolvidos. Veja o protótipo. Protótipo: namespace NomeNamespace { //Declarações de atributos e métodos tipo nome; retorno Nomefunção ( parâmetros ); } //Denindo métodos de um namespace void retorno NomeNamespaceNomefunção ( parâmetros ) {...}; Veja na listagem a seguir um exemplo de denição e uso de um namespace. Listing 7.1: Denindo e usando um namespace. //Exemplo: Definindo e usando um namespace #include <iostream> //Objeto x global int x = 3; //cria um bloco namespace com o nome teste namespace teste { const int x = 7; void Print (); André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ Capítulo 8 Classes Vimos no capítulo 1 que a classe é a unidade de encapsulamento dos atributos e dos métodos. Dentro da classe é que declaramos os atributos, os métodos e seus controles de acesso. Neste capítulo vamos ver o protótipo para declarar e denir uma classe. Como usar as palavras chaves public, protected e private para encapsular os atributos e métodos da classe. 8.1 Protótipo para declarar e denir classes Veja a seguir o protótipo geral para declaração de uma classe, de seus atributos e métodos. Verique que existem diferentes tipos de atributos e de métodos. Ao lado do formato um comentário informando a seção onde o mesmo vai ser apresentado. Protótipo: class TNome { //Atributos tipo nome; //atributos de objeto, seção 9.2 static tipo nome; //atributos estáticos seção 9.3 const tipo nome; //atributos const, seção 9.4 mutable tipo nome; //atributos mutable, seção 9.5 volatile tipo nome; //atributos com volatile, seção 9.6 //Métodos tipo função(parâmetros); //métodos normais seção 10.4 tipo função(parâmetros) const ; //métodos const, seção 10.5 static tipo função(parâmetros); //métodos estáticos, seção 10.6 inline tipo função(parâmetros); //métodos inline, seção 10.7 virtual tipo função(parâmetros); //métodos virtuais, seção 16.2 virtual tipo função(parâmetros)=0; //métodos virtuais puros, seção }; Importante, observe a presença de (;) no nal do bloco que declara a classe. Exemplo: //----------------------------------TEndereco.h 95 96 8.2. ENCAPSULAMENTO EM C++ USANDO O ESPECIFICADOR DE ACESSO #include <string> class TEndereco { //----------------------------------Atributo int numero; string rua; //----------------------------------Métodos int Getnumero(); string Getrua(); }; 8.2 Encapsulamento em C++ usando o especicador de acesso Para a análise orientada a objeto, encapsulamento é o ato de esconder do usuário informações que não são de seu interesse. O objeto é como uma caixa preta, que realiza determinada operação mas o usuário não sabe, e não precisa saber, exatamente como. Ou seja, o encapsulamento envolve a separação dos elementos visíveis de um objeto dos invisíveis. A vantagem do encapsulamento surge quando ocorre a necessidade de se modicar um pro- grama existente. Para implementar o conceito de encapsulamento, C++ oferece as palavras chaves public, pro- tect e private. Veja a seguir quando utilizar public, protected e private em suas classes. public: signica que o atributo ou método faz parte da interface do objeto, podendo ser acessada a qualquer instante. protected: signica protegida de acesso externo. Só pode ser acessada pelos métodos da classe e pelos métodos das classes derivadas. private: só pode ser acessada pelos métodos da classe (métodos internos da classe e métodos friend1). Para aumentar o encapsulamento da classe, declare tudo como privado. Só deixe como público o que for essencial e zer parte da interface da classe. Evite atributos protegidos, atributos protegidos podem ser usados em diversas classes derivadas, sendo difícel identicar o impacto de mudanças no mesmo. Não existem restrições para métodos protegidos. O uso de public, protected e private será esclarecido através dos exemplos apresentados. 8.3 Classes aninhadas2 Podemos declarar classes aninhadas (classes dentro de classes). Exemplo: class A { 1Métodos friend serão descritos no capítulo 17. André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++ 8.4. SENTENÇAS PARA CLASSES 97 int x; class XX {int y;}; //classe aninhada }; 8.4 Sentenças para classes  Para identicar as classes e seus relacionamentos, faça associações diretas com conceitos do mundo real.  Uma classe denida pelo usuário é um tipo do usuário.  Quando você cria uma classe esta denindo um novo tipo. Você deve incluir na documentação do programa o conceito e a forma de uso do novo tipo.  Todos os membros de uma classe tem de ser declarados em seu interior.  Um mesmo nome não pode ser dado a um método e a um atributo.  Uma classe A qualquer, não pode conter um objeto do tipo A, mas somente um ponteiro para A. Antes do nal da declaração de uma classe seu nome só pode ser utilizado se o tamanho da classe não for necessário.  Crie classes pequenas para realizar tarefaz pequenas.  Ao criar suas classes dê a élas um formato simples. Uma classe TSolver deve representar um solver.  Em problemas de engenharia, associe classes a conceitos reais. Exemplo: uma classe edificio, janela, porta,.., e assim por diante.  Uma classe é um conjunto de atributos (variáveis ou objetos) reunidos com um conjunto de métodos (funções). Os atributos que incluo na classe são aqueles que fazem sentido a classe. O mesmo para os métodos.  A classe não é um objeto, é uma descrição do objeto (denição da forma e conteúdo do objeto).  Os atributos que compõem a classe podem ser de diferentes tipos. No exemplo usa duas strings e um int.  2 Uma classe com atributos const ou referências tem de ter obrigatoriamente um construtor para inicializar estes atributos.  2 Se um método tem inicializadores, isto é, atributos com valores pré-denidos. Os inicial- izadores devem car visíveis na classe (arquivo *.h), pois quem usa a classe olha o arquivo de cabeçalho (*.h), e nem sempre tem acesso ao arquivo de implementação (*.cpp). André Duarte Bueno - www.lmpt.ufsc.br Apostila de Programação em C++