Apostila de Programação Orientada a Objeto em C++

[#phobia]

Uma pequena apostila de C++ para os interessados!  ;)

I Filoso_a de POO 37
1 Introdução a Programação Orientada a Objeto 39
1.1 Passado/Presente/Futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.1.1 Passado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.1.2 Presente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.1.3 Futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.2 Seleção da plataforma de programação . . . . . . . . . . . . . . . . . . . . . . . . 40
1.2.1 Seleção do ambiente grá_co - GDI (bibliotecas grá_cas) . . . . . . . . . . . 41
1.3 Ambientes de desenvolvimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.4 Exemplos de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.4.1 Um relógio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.4.2 Um programa de integração numérica . . . . . . . . . . . . . . . . . . . . . 44
2 Conceitos Básicos de POO 47
2.1 Abstração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.2 Objeto (ou Instância) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.4 Encapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.5 Atributos (Propriedades/Variáveis) . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.6 Métodos (Serviços/Funções) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.7 Herança (Hereditariedade) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.7.1 Herança simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.7.2 Herança múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.8 Polimor_smo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3 Diagramas UML 53
3.1 Programas para desenho dos diagramas . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2 Diagramas UML usando o programa dia . . . . . . . . . . . . . . . . . . . . . . . 53
II POO usando C++ 57
4 Introdução ao C++ 59
4.1 Um pouco de história . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2 O que é o Ansi C++? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.3 Quais as novidade e vantagens de C++? . . . . . . . . . . . . . . . . . . . . . . . 60
3
4 SUMÁRIO
4.4 Tipos de programação em C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.5 Compilar, linkar, debugar e pro_ler . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6 Diferenças de nomenclatura (POO e C++) . . . . . . . . . . . . . . . . . . . . . . 62
4.7 Layout de um programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.7.1 Arquivo de projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.7.2 Arquivo de cabeçalho da classe (*.h) . . . . . . . . . . . . . . . . . . . . . 62
4.7.3 Arquivo de implementação da classe (*.cpp) . . . . . . . . . . . . . . . . . 63
4.7.4 Arquivo de implementação da função main (programa.cpp) . . . . . . . . . 63
4.8 Exemplo de um programa orientado a objeto em C++ . . . . . . . . . . . . . . . 64
5 Conceitos Básicos de C++ 67
5.1 Sobre a sintaxe de C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.2 Conceitos básicos de C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.3 Palavras chaves do C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.4 Nome dos objetos (identi_cadores) . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.4.1 Convenção para nomes de objetos . . . . . . . . . . . . . . . . . . . . . . . 70
5.5 Declarações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.5.1 Sentenças para declarações . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.5.2 Exemplos de declarações2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.6 De_nições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
6 Tipos 79
6.1 Introdução ao conceito de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.2 Uso de tipos pré-de_nidos de C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.3 Uso de tipos do usuário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.4 Uso de tipos de_nidos em bibliotecas externas (STL) . . . . . . . . . . . . . . . . 86
6.5 Vantagem da tipi_cação forte do C++ . . . . . . . . . . . . . . . . . . . . . . . . 88
6.6 Sentenças para tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
7 Namespace 91
7.1 O que é um namespace ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.2 Usando o espaço de nomes da biblioteca padrão de C++ (std) . . . . . . . . . . . 91
7.3 De_nindo um namespace2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7.4 Compondo namespace2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.5 Sentenças para namespace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
8 Classes 95
8.1 Protótipo para declarar e de_nir classes . . . . . . . . . . . . . . . . . . . . . . . . 95
8.2 Encapsulamento em C++ usando o especi_cador de acesso . . . . . . . . . . . . . 96
8.3 Classes aninhadas2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.4 Sentenças para classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
9 Atributos 99
9.1 Protótipo para declarar e de_nir atributos . . . . . . . . . . . . . . . . . . . . . . 99
9.2 Atributos de objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
9.3 Atributos de classe (estáticos) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
9.3.1 Sentenças para atributos de classe . . . . . . . . . . . . . . . . . . . . . . . 102
 
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 de_nir métodos . . . . . . . . . . . . . . . . . . . . . . . 105
10.2 Declaração, de_nição e retorno de um métodos . . . . . . . . . . . . . . . . . . . . 106
10.2.1 Declaração de um método . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
10.2.2 De_niçã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é-de_nidos (inicializadores) . . . . . . . . . . . . . . 110
10.3.2 Sentenças para declaração, de_niçã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
 
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 Especi_cador 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 Polimor_smo2 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 polimor_smo . . . . . . . . . . . . . . . . . . . . . . . . . . 182
16.3.1 Sentenças para polimor_smo . . . . . . . . . . . . . . . . . . . . . . . . . . 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 polimor_smo . . . . . . . . . . . . . . . . . . . . . . . . . 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
 
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.11Veri_caçã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
 
8 SUMÁRIO
22 Templates ou Gabaritos 255
22.1 Introdução aos templates (gabaritos) . . . . . . . . . . . . . . . . . . . . . . . . . 255
22.2 Protótipo para templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
22.2.1 Declaração explícita de função template . . . . . . . . . . . . . . . . . . . 257
22.2.2 Sobrecarga de função template . . . . . . . . . . . . . . . . . . . . . . . . . 257
22.2.3 Função template com objeto estático . . . . . . . . . . . . . . . . . . . . . 257
22.3 Classes templates (ou tipos paramétricos) . . . . . . . . . . . . . . . . . . . . . . 257
22.4 Sentenças para templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
III Classes Quase STL 259
23 Entrada e Saída com C++ 261
23.1 Introdução a entrada e saída de dados no c++ . . . . . . . . . . . . . . . . . . . . 261
23.1.1 Biblioteca de entrada e saída . . . . . . . . . . . . . . . . . . . . . . . . . . 261
23.2 O que é um locale ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
23.3 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
23.4 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
23.5 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
23.6 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
23.7 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
23.8 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
23.9 Sentenças para stream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
24 Entrada e Saída com Arquivos de Disco 279
24.1 Introdução ao acesso a disco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
24.2 A classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
24.3 Armazenando e lendo objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
24.4 Posicionando ponteiros de arquivos com
seekg(), seekp(), tellg(),tellp()2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
24.5 Acessando a impressora e a saída auxíliar3 . . . . . . . . . . . . . . . . . . . . . . 287
24.6 Arquivos de disco binários3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
24.7 Executando e enviando comandos para um outro programa . . . . . . . . . . . . . 288
24.8 Redirecionamento de entrada e saída . . . . . . . . . . . . . . . . . . . . . . . . . 289
25 class 293
25.1 Sentenças para strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
26 class 301
27 class 305
IV Introdução a STL 311
28 Introdução a Biblioteca Padrão de C++ (STL) 313
28.1 O que é a STL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
 
SUMÁRIO 9
28.1.1 Características da STL: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
28.1.2 Componentes da STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
28.2 Introdução aos containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
28.2.1 Tipos de Container's . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
28.2.2 Métodos comuns aos diversos container's . . . . . . . . . . . . . . . . . . . 316
28.2.3 Typedef's para containers2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
28.3 Introdução aos iteradores (iterator's) . . . . . . . . . . . . . . . . . . . . . . . . . 319
28.3.1 Tipos de iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
28.3.2 Operações comuns com iteradores2 . . . . . . . . . . . . . . . . . . . . . . 320
29 class 323
29.1 Sentenças para vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
30 class 333
30.1 Sentenças para list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
31 class 339
32 class 343
33 class 347
34 class 349
35 class 351
36 class 355
37 class

Code Select Expand

#phobia >> wWw.darkers.com.br

[Alienaqtor]

Baixando .... tava estudando C++ consegui o livro C++ : como programar 3 edicao do Deitel , mas apartir do 3 capitulo tava todo errado, paragrafos cortados etc, agora com esse apostila vamos ver se continuo meus estudos , se alguem conseguir o livro do deitel posta ae e vlw pela apostila phobia , flw