Livrocpp PDF

10 0 0
00 1 1 011 01 1 00 0
1
1
1 1
000 0 11 1111 1 10 1 010
1 0 1
1 01 1
1
1
1
11 11 0 10 0
0 00 0 01 1 10
1 0 0 1 01 1
0 1 1
0 00 0 1 0 01 0 0 110 0 0
01 1
1 11
00 0 1 101 1 1 0
10
0 1
1 0 1
0 1 0 0 1 1 1 1
11 11 11 0 01
10
0
1 0 0
01
10 0
0
1
00
1
0 11
0
1 0 0
111 0 0 11 1
1 1 0 1 10 10 1 1
1
0
1
1
10 1 110
1Introduo1 1 Programao
11 0
0 0 1
00 0 0 11 0 1 01 0
0
1
0
11 0 1 10Curso 1 em0C++
0 1 1 00
0
10 0 0
1
10
1
1
1 1
0
1
1 1 1
0
Dr. Alan
1
1
10
R. R. de Freitas
1
0
0
00 1
11
0 0
11
0
1
0
11 11 1 1 1
0 0
0 0 01
0 0 0 0 1
0 1 0 0
1 1 0 1 1 1
0 10 0 0 110 1 1
1 0 1
000
1
1
0
01 0 0 00 1 0 1 01 01
0 1
0 000
0
1 1
11 00 1 001 100 1 000 1

10 1 10 1
0 0 0
0 1 1
1 11 01 0 010
01 0 11
0 0 1 1 0 10 0
0 0 0 0
0 1 01 1 1 11 0 10 1 0 0
1 1
1
01 0 0 101 11 0 11
0 1 1
1
0
0 1
Copyright
c 2015 Alan R. R. de Freitas
ALANDEFREITAS . COM
Edio: 19 de Maro de 2015

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 10
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 10
1
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 01 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
1 0
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
00
1
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 11
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 1
00
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 00
0
Contedo
1
1
0
1
0
0 0
1
110 0 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 01 0 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
10
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 00
0 1 010 1 1 1 0 01 1 11
I Programao Estruturada
1 Introduo ao C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1 Porqu Programar 13
1.2 Linguagem C++ 13
1.3 Compilador 14
1.4 Tipos Fundamentais de Dados 14
2 Estruturas sequenciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1 Primeiros programas 17
2.2 Segundo programa em C++ e espao de nomes padro 18
2.3 Comentrios 18
2.4 Criando variveis 19
3 Operadores bsicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.1 Operador de atribuio 21
3.2 Fluxo de entrada 22
3.2.1 Alteraes possveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 Operadores aritmticos 25
3.4 Operadores de atribuio aritmticos 27
3.5 Operadores de incremento e decremento 30
3.6 Dados lgicos e comparaes 34
3.7 Operadores relacionais 34
3.8 Operadores lgicos 37
3.8.1 Resumo dos operadores lgicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.8.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.9 Exerccios 41
4 Estruturas condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.1 Condicional se 43
4.1.1 Sintaxe do se . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.1.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.2 Se-seno 46
4.2.1 Se-seno sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.2.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.3 Se-seno aninhados 47
4.3.1 Se-seno alinhados- sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.3.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.4 Outros operadores condicionais 50
4.4.1 Operador ternrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.4.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.5 Exerccios 51
5 Operador de endereo e arranjos . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

5.1 Operador de endereo 55
5.2 Arranjos simples 57
5.3 Cadeias de caracteres 59
5.4 Classe string 61
5.5 Arranjos multidimensionais 62
5.6 Exerccios 66
6 Estruturas de repetio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
6.1 Laos com contadores 69
6.1.1 Controle de fluxo-For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
6.1.2 Repetio controlada por contador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.2 Repeties determinadas pelo usurio 72
6.3 Repetio de processos similares 73
6.4 Alterando variveis externas 75
6.5 Aninhando estruturas de controles 77
6.6 Condies de inicializao 78
6.7 Condies de incremento 79
6.8 Percorrer arranjos 82
6.9 Laos aninhados 86
6.10 Percorrendo arranjos de arranjos 88
6.11 Utilizando apenas critrio de parada 93
6.11.1 Relao entre while e for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.11.2 Laos infinitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6.12 Adiando o critrio de parada 96
6.12.1 Relao entre do-while e while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.13 Exerccios 97
7 Escopo de variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

7.1 Exerccios 107
8 Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.1 Expresses com ponteiros 113
8.2 Aritmtica com ponteiros 113
8.3 Ponteiros para ponteiros 113
8.4 Ponteiros e arranjos 115
8.5 Exerccios 119
9 Modularizao de programas com funes . . . . . . . . . . . . . . . . 121

9.1 Funes simples 122
9.1.1 Minha primeira funo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
9.2 Cabealhos de funo 124
9.3 Funes e suas variveis 124
9.4 Retorno de valor 126
9.5 Parmetros de funo 127
9.6 Passagem de parmetros 132
9.6.1 Passagem de parmetros por valor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
9.6.2 Passagem de parmetros por referrencia . . . . . . . . . . . . . . . . . . . . . . . . . 133
9.7 Omitindo a varivel de retorno 135
9.8 Retornando vrios valores 137
9.9 Arranjos como parmetros 139
9.10 Ponteiros como parmetros 141
9.11 Recurso 143
9.11.1 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
10 Estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
10.1 Arranjos de estruturas 155
10.2 Estruturas e ponteiros 157
11 Alocao de memria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

11.1 Alocao automtica de memria 161
11.2 Alocao dinmica de memria 162
11.3 Alocao dinmica de arranjos 166
11.4 Alocao dinmica de arranjos multidimensionais 170
12 Processamento de arquivos sequenciais . . . . . . . . . . . . . . . . . . . . 173

12.1 Exerccios 178
13 Resumo de comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
13.1 Estrutura base de programas 181
13.2 Tipos fundamentais de dados 181
13.4 Operadores bsicos 182
13.7 Estruturas condicionais 182
13.8 Estruturas de Repetio 183
13.9 Entrada e sada 184
13.10 Arranjos (Alocao automtica, de tamanho fixo) 184
13.11 Arranjos multidimensionais (Alocao automtica, de tamanho fixo)184
13.12 Ponteiros 184
13.13 Funes 184
13.14 Passagem por valor e referncia 184
13.15 Estruturas ou Registros 184
13.17 Entrada e sada de arquivos 185
II Comparando Algoritmos
14 Anlise de Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

14.1 Algoritmos 189
14.2 Modelos de Comparao 190
14.3 Complexidade dos algoritmos 190
14.4 Melhor caso, pior caso e caso mdio 191
14.5 Notao O e dominao assinttica 191
14.5.1 Notao O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
14.5.2 Limites fortes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
14.5.3 Operaes com notao O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
14.6 Classes de algoritmos 194
14.7 Exerccios 195
15 Busca em arranjos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

15.1 Busca sequencial 198
15.1.1 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
15.2 Busca binria 199
15.2.1 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
15.3 Exerccios 204
16 Ordenao de arranjos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
16.1 Conceitos de ordenao de arranjos 208
16.1.1 Estabilidade de ordenao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
16.1.2 Complexidade de tempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
16.1.3 Complexidade de memria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
16.2 Algoritmos simples de ordenao 211
16.2.1 Ordenao por seleo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
16.2.2 Ordenao por insero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
16.2.3 Comparao entre algoritmos simples de ordenao . . . . . . . . . . . . . . . . 226
16.2.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
16.3 Algoritmos eficientes de ordenao 233
16.3.1 Merge sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
16.3.2 Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
16.3.3 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
16.4 Comparando algoritmos de ordenao 262
16.5 Concluso 265
16.6 Outros algoritmos de ordenao 266
III Estruturas de Dados

17 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
17.1 Standard Template Library 272
18 Containers Sequenciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

18.1 Containers 273
18.2 Containers sequenciais 274
18.3 Vector 274
18.3.1 Utilizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
18.3.2 Como funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
18.4 Deque 279
18.4.1 Utilizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
18.4.2 Como funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
18.5 List 282
18.5.1 Como funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
19 Percorrendo containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

19.1 Subscritos 285
19.1.1 Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
19.1.2 Deque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
19.1.3 List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
19.1.4 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
19.2 Iteradores 289
19.2.1 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
19.2.2 Categorias de Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
19.2.3 Funes com iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
20 Anlise dos Containers Sequenciais . . . . . . . . . . . . . . . . . . . . . . . . 297
20.1 Vector 297
20.2 Deque 297
20.3 List 298
20.4 Comparao 298
20.5 Exerccios 300
21 Containers Associativos e Conjuntos . . . . . . . . . . . . . . . . . . . . . . . 305

21.1 Containers Associativos Ordenados 305
21.1.1 Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
21.1.2 Multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
21.1.3 Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
21.1.4 Multimap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
21.1.5 Como funcionam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
21.1.6 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
21.2 Containers Associativos Desordenados 319
21.2.1 Como funcionam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
21.2.2 Tratamento de Colises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
21.2.3 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
21.3 Anlise dos Containers Associativos 325
21.3.1 Dicas de utilizao de containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
21.4 Exerccios 328
22 Adaptadores de Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

22.1 Stack 333
22.1.1 Utilizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
22.1.2 Como funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
22.2 Queue 337
22.2.1 Utilizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
22.2.2 Como funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
22.3 Priority queue 342
22.3.1 Utilizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
22.3.2 Como funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
23 Algoritmos da STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

23.1 Algoritmos modificadores da STL 345
23.2 Algoritmos no modificadores da STL 348
23.3 Algoritmos numricos da STL 351
23.4 Exerccios 352
IV Programao Orientada a Objetos
24 Classes e Instncias de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

24.1 Introduo 359
24.2 Classes e Instncias de Objetos 359
24.3 Instanciando objetos 362
24.4 Ponteiros para objetos 363
24.5 Arranjos de objetos 364
24.6 POO em sistemas complexos 366
25 Definindo classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

25.1 Contrutores 367
25.2 Sobrecarga de construtores 368
25.2.1 Construtor de Cpia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
25.3 Sobrecarga de operadores 371
25.4 Setters e Getters 372
25.5 Destrutores 374
26 Relaes entre objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

26.1 Composio de objetos 377
26.1.1 Destrutores de objetos membros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
26.1.2 Construtores de objetos membros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
26.2 Herana 380
26.2.1 Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
27 Recursos de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

27.1 Templates de Objetos 385
27.2 Operador de Converso 388
27.3 Interface e Implementao 390
27.4 Exerccios 392
V Prticas de Programao em C++
28 Prticas Comuns de Programao em C++ . . . . . . . . . . . . . . . . . 399

28.1 Ponteiros inteligentes 399
28.2 Deduo do tipo de dado 400
28.3 Objetos de funo 400
28.4 Funes annimas 401
28.5 For baseado em intervalo 403
28.6 Tuplas 403
28.7 Programao com iteradores 404
28.8 Operador de cpia e movimento 405
28.9 Threads 407
28.10 Medindo tempo 408
28.11 Nmeros aleatrios 409
29 Algoritmos Eficientes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
29.1 Busca em arranjo 411
29.1.1 Busca sequencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
29.1.2 Busca binria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
29.2 Ordenao 412
29.2.1 Ordenao por seleo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
29.2.2 Ordenao por insero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
29.2.3 Merge sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
29.2.4 Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
ndice Remissivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

I
Programao Estruturada
1 Introduo ao C++ . . . . . . . . . . . . . . . . . . 13
2 Estruturas sequenciais . . . . . . . . . . . . . . . 17
3 Operadores bsicos . . . . . . . . . . . . . . . . . 21
4 Estruturas condicionais . . . . . . . . . . . . . . 43
5 Operador de endereo e arranjos . . . . 55
6 Estruturas de repetio . . . . . . . . . . . . . . 69
7 Escopo de variveis . . . . . . . . . . . . . . . . 103
8 Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9 Modularizao de programas com fun-

es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
10 Estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . 153
11 Alocao de memria . . . . . . . . . . . . . 161
12 Processamento de arquivos sequenciais

173
13 Resumo de comandos . . . . . . . . . . . . . . 181

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 1.0Introduo
0
1 0
1
0 ao 0C++
1
0
0 0
1
110 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 01 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
1.1 Porqu Programar

Sabemos que a utilizao de computadores claramente uma vantagem em nossas vidas. O
computador um facilitador da nossa comunicao, do nosso planejamento e essa praticidade nos
permite trabalhar menos e nos fornece diverso. Mas por que fazer nossos prprios programas?
Uma resposta simples para isso que tudo uma questo de automatizao. Programadores
tm muitas vezes a reputao de serem preguiosos, mas muitas vezes pessoas preguiosas so
aquelas boas em encontrar solues fceis e eficientes para problemas difceis.
Sendo assim, voc j parou para pensar em quantas tarefas repetitivas temos em nossas vidas?
Em nossa profisso? Na famlia? Ns programadores costumamos ter ferramentas prprias para
o dia-a-dia: calendrios, lembretes, processadores de dados, e vrias outras.
A programao necessria em tarefas avanadas de todas as reas do conhecimento.
Clculo uma delas. Muitos problemas matemticos s puderam ser resolvidos por causa da
capacidade dos computadores atuais. Todo ano, milhares de problemas novos e mais difceis so
solucionados.
Outra vantagem de se saber programar saber por que um computador pode falhar. Ns
programadores, usualmente, reconhecemos o motivo de erros em programas. Isso s acontece
porque j passamos pelos mesmos erros em nossos prprios programas.
Alm disso, a programao te ajuda a pensar e a quebrar problemas grandes em partes
menores. O nico limite no seu programa vai ser a sua imaginao. Uma ideia simples pode
mudar a vida de milhes de pessoas.
1.2 Linguagem C++

A linguagem C++ foi desenvolvida por Bjarne Stroustrup quando trabalhava para a Bell Labs,
durante a dcada de 1980. Nesta poca, o Unix, sistema operacional tambm desenvolvido pela
Bell Labs, era desenvolvido na linguagem C. Era importante que fosse mantida compatibilidade
entre a nova linguagem C++ e a antiga linguagem C.
Ento em 1983 o nome da linguagem foi alterado de C com Classes, C with Classes em
14 Captulo 1. Introduo ao C++
ingls, para C++. Uma novidade importante da linguagem C++ que ela contm uma biblioteca
padro de recursos que tambm foi sendo melhorada ao longo do tempo.
Uma caracterstica importante do C++ ser considerada de mdio nvel. Isso que dizer que
ela no to distante da linguagem da mquina, a lngua dos computadores. Ao mesmo tempo
ela tambm no to distante de uma linguagem com um alto nvel de abstrao, a tornando
acessvel a ns humanos.
Estas caractersticas tornam o C++ uma linguagem altamente eficiente e a fazem uma das
linguagens comerciais mais populares atualmente.
! Como referncia para leitores que j so programadores porm no esto acostumados

com a linguagem C++, recomendamos a leitura direta da Seo 13, onde so apresentados
os principais comandos da linguagem.
1.3 Compilador
Como faremos para conversar com computadores se falamos lnguas to diferentes? Esta a
tarefa de um programa de computador chamado compilador.
O compilador uma ferramenta que nos serve como uma ponte para fazer esta comunicao.
De modo breve, a comunicao funciona da seguinte maneira:
1. Escreveremos nossa mensagem para o computador em uma linguagem de programao
preferncial. Neste curso, utilizaremos a linguagem C++.
2. O compilador, por sua vez, recebe esse cdigo que , ento, transformado em linguagem
de mquina.
3. O novo cdigo em linguagem de mquina pode ser utilizado diretamente pelo computador,
finalizando assim nossa comunicao.
1.4 Tipos Fundamentais de Dados

Uma linguagem de mquina, que entendida pelo computador, cheia de 0s e 1s mas no
bem assim que ns nos comunicamos com nossos programas. Se enviarmos 0100110101 para
um computador, como ele conseguir identificar se o que queremos um letra minscula ou uma
letra maiscula? Ou como diferenciar um nmero inteiro de um nmero real?
Para isto precisamos identificar os tipos de dados. H diferentes tipos de dados que podemos
usar e eles tm diferentes tamanhos. Na Tabela 1.1 temos os quatro tipos fundamentais de dados
e suas respectivas palavras-chave que as representam em C++.
Tipos de dados Palavra-Chave Exemplos

Tipo lgico bool V ou F
Nmeros inteiros short < int < long ... -3, -2, -1, 0, 1, 2, 3 ...
Nmeros reais float < double 3.32, 4.78, 7.24, -3.14, 0.01
Caracteres char a, b, c, d, e, f ...#, $, [, ., \ ..
Tabela 1.1: Tipos Fundamentais de Dados em C++
O tipo lgico, que possui bool como palavra chave, representa valores que so verdadeiros
ou falsos. O verdadeiro representado pela palavra-chave true e o falso representado pela
palavra-chave false.
Os nmeros inteiros, possuem short, int e long como palavras-chave. short utilizado
para nmeros inteiros menores, int, para nmeros inteiros que podem ser maiores e long, para
1.4 Tipos Fundamentais de Dados 15
nmeros que podem ser ainda maiores. Estes tipos de dados podem representar valores como 7,
-5, -1, 0, +3, -2, ou 10.
J os nmeros reais possuem as palavras-chave float e double. Da mesma maneira,
ambas as palavras indicam a capacidade do nmero. Exemplos desse tipo de dados so nmeros
como 3.32, 4.78, 7.24, -3.14 ou 0.01.
Por ltimo, temos os caracteres, que podem representar letras ou smbolos. Eles possuem
char como palavra-chave, e servem para representar dados como: h, @, C, r, e, f, #, $ ou }.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 2.0Estruturas
0
1 0 sequenciais
1
0 0 1
0
01 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
2.1 Primeiros programas

Para criarmos nosso primeiro programa em C++ comearemos com este cdigo.
1 # include < iostream >

2
3 int main (){
4 std :: cout << " Ol mundo ! " << std :: endl ;
5 return 0;
6 }
O comando apresentado na primeira linha, #include <iostream>, inclui a biblioteca

com recursos para fluxo de entrada e sada, chamados tambm de in and out stream. Quando
dizemos entrada, essa ser feita usualmente via teclado. Quando dizemos sada, essa ser feita
pelo monitor.
na terceira linha que comea a funo principal do nosso programa, chamada de main()
em ingls. As chaves indicam onde comea e termina essa funo.
Logo em seguida temos o comando cout. Dizemos que cout um objeto que faz sada
de dados para o monitor. Esses dados so enviados para ele em cadeia com os operadores de
insero ( << ), que esto a sua direita.
Para evitar um possvel conflito entre os nomes, os recursos do C++ so divididos em espaos
de nomes. O cout, por exemplo, precedido de std e dois pontos seguidos (::) para indicar
que ele pertence ao espao de nomes padro da linguagem, conhecido tambm como standard.
Temos agora a linha 4, onde o operador de insero ento utilizado para enviar a frase
Ol, Mundo! para cout. Cada letra desta frase um dado do tipo char, que representa um
caractere. Lembre-se dos tipos fundamentais de dados apresentados na Tabela 1.1. No cdigo
acima, o smbolo indica uma barra de espaos dentro de uma sequncia de caracteres.
As aspas ao redor da expresso Ol, Mundo! indicam que este um conjunto de chars,
e no uma palavra especial que reservada da linguagem.
18 Captulo 2. Estruturas sequenciais
Alm desta frase, uma quebra de linha tambm enviada para cout. Essa quebra de linha
representada pelo comando endl, que tambm pertence ao espao de nomes std.
Todos os comandos em C++ devem ser acompanhados de um ponto e vrgula indicando a
onde termina aquele comando.
O comando return (retornar, em ingls), indica que a funo main retorna daquele ponto,
finalizando assim o programa. Mas esse comando no s encerra o programa como tambm re-
torna um valor do tipo int, que no caso um 0. Este 0 utilizado usualmente por programadores
para indicar que o programa encerrou sem erros.
O comando int, antes da definio main() na linha 3, indica que a prpria funo main ir
retornar um int. Discutiremos o significado desse comando em lies futuras sobre funes.
Lembre-se que a funo main obrigatria em todos os programas.
Este o resultado do programa acima:
Ol, Mundo!
2.2 Segundo programa em C++ e espao de nomes padro

Veja o cdigo abaixo:
2
3 using namespace std ;
4
5 int main (){
6 cout << " Ol , Mundo " << endl ;
7 return 0;
8 }
Na linha 3 deste segundo programa em C++, indicamos com o comando namespace que
o espao de nomes std deve ser utilizado se nenhum outro espao de nomes for mencionado.
Eliminamos assim os vrios stss e seguindos de dois pontos (::) em nosso cdigo.
Como podem ver, as variveis em C++ so organizadas nestes espaos de nomes para evitar
conflito entre duas variveis que por acaso tenham o mesmo nome identificador.
Assim como nosso primeiro programa, o programa acima ir mostrar na tela a seguinte
mensagem:
Ol, Mundo!
2.3 Comentrios
Em alguns casos, um cdigo pode se tornar to complexo que nem o prprio programador
consegue entend-lo. Em casos como este, bom deixar comentrios para outros programadores
ou mesmo para si mesmo.
No se preocupe, pois os comentrios so partes do cdigo que so ignoradas pelo compilador
e servem apenas para deixar lembretes ou informaes sobre o cdigo para outros programadores.
O comando usado para marcar o incio de um comentrio de uma linha so duas barras para a
direita (//). J os comandos barra-asterisco (/* e asterisco-barra (*/) so utilizados para iniciar
e encerrar um bloco de comentrios, respectivamente. Veja o exemplo abaixo:
2.4 Criando variveis 19

2
4
5 int main (){
6 cout << " Ol , Mundo ! " << endl ; // Tudo isto ignorado
7 // cout << " Ol , Mundo !" << endl ;
8 cout << " Ol , Mais uma vez " << endl ;
9 /* Aqui se inicia um bloco de coment rios .
10 Tudo dentro do bloco ignorado . */
11 // cout << " Este " Ol , Mundo !" n o sera impresso !" << endl ;
12 return 0;
13 }
Temos acima mais um exemplo de programa em C++. Neste programa, temos comandos que
imprimem a frase Ol, Mundo!, mas temos tambm vrios comentrios. Estes comentrios
so trechos no cdigo que sero ignorados.
Logo na linha 6, a mensagem Ol, Mundo! enviada para o monitor. Aps o comando,
porm, h uma mensagem que ignorada pelo computador por ser um comentrio.
Ao fim da linha 6, a seguinte mensagem ter sido mostrada no monitor:
Ol, Mundo!
Como a linha 7 toda um comentrio, ela totalmente ignorada. Passamos ento direto para
a linha 8 do cdigo, que imprime novamente uma mensagem:
Ol, Mundo! Ol! Mais uma vez!
Temos em seguida nas linhas 9 e 10, todo um bloco de comentrios entre os comandos /* e
*/ que tambm ignorado. A linha 11 tambm um comentrio de uma linha inteira feito com
o comando //. O programa retorna da linha 12 com o comando return 0.
2.4 Criando variveis

Os dados do nosso programa sero guardados em variveis, que so espaos alocados na
memria do computador para nossos dados, como representado na Figura 2.1
Para cada varivel necessrio informar qual o seu tipo de dado e dar a ela um nome
identificador que a referencia.
2
4
5 int main (){
6 // criando uma vari vel do tipo inteira com nome x
7 int numero ;
8 // criando uma vari vel do tipo char com o nome letra
9 char letra ;
10 // criando uma vari vel do tipo double com nome num_real
20 Captulo 2. Estruturas sequenciais
4 5.7
7.2 a
varivel
c true
false 20
Figura 2.1: Uma varivel um espao alocado na memria do computador para guardarmos
dados
11 double num_real ;
12 // criando uma vari vel do tipo bool com nome teste
13 bool teste ;
14 cout << " Este programa criou 4 vari veis ! " << endl ;
15 return 0;
16 }
Neste exemplo, temos um programa onde 4 variveis so criadas. A primeira delas, criada
na linha 5, ir guardar um nmero inteiro (int) e seu nome identificador numero. Note que o
nome que identifica a varivel numero no contm acentos.
Na linha 9 criamos uma varivel chamada letra, para dados do tipo char. Na linha 7, uma
varivel do tipo double, que pode armazenar nmeros reais. Por fim, na linha 8, uma varivel
do tipo bool, que pode guardar dados lgicos. Lembre-se dos tipos de dados apresentados na
Seo 1.4.
Por enquanto, nosso programa no utilizou as variveis criadas para armazenar dados. Por
isto elas so representadas por caixas que ainda esto fazias, j que nenhum valor foi definido
para as variveis. Aps a linha 13 do cdigo isto seria representado como na Figura 2.2.
numero letra num_real teste
Figura 2.2: Quatro variveis criadas que ainda no tm valores especificados.
Finalmente na prxima linha, este programa imprime uma mensagem simples, como j temos
feito at agora.
Este programa criou 4 variveis!
Os identificadores so usados para dar nomes s variveis ou funes que criamos. Estudare-
mos as funes mais adiante. Neste programa criamos variveis com os identificadores numero,
letra, num_real e teste.
Exitem algumas regras para identificadores:
O primeiro caractere de um identificador deve ser uma letra ou sinal de sublinha (_). Isto
quer dizer que nomes como 8nome ou @nome no so vlidos.
As letras minsculas e maisculas tambm so identificadas de formas diferentes. Ou seja,
para o C++, uma varivel x minsculo diferente de uma varivel X maisculo.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 3.0Operadores
0
1
00 1
0 01
bsicos 1
1
0
0
1
110 1
0
0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Os operadores so muito importantes em programao, pois eles alteram o valor das variveis
ou usam variveis existentes para criarem novas, como apresentado na Figura 3.2.
variavel1 8 variavel1 4 variavel2 6
variavel3 9 variavel3 10
Figura 3.1: Exemplos de operadores. Operadores podem alterar o valor de uma varivel ou criar
novas variveis a partir de variveis existentes.
3.1 Operador de atribuio

O operador representado pelo sinal de igualdade (=) em C++ no diz que dois valores so
iguais. Ele na verdade, atribui o valor da direta varivel. Por isto, chamamos ele de operador
de atribuio. Sendo assim, no confunda este operador de atribuio com um operador de
igualdade. Ele transfere um valor a uma varivel e esse valor pode ser utilizado posteriormente.
Quando fazemos isto, o valor antigo da varivel perdido.
Neste cdigo utilizaremos um operador de atribuio para dar um valor a uma varivel:
2
4
5 int main (){
22 Captulo 3. Operadores bsicos
6 int numero ;
7 numero = 4;
8 cout << " A vari vel numero do tipo int tem valor " ;
9 cout << numero << endl ;
10 return 0;
11 }
Logo no incio do cdigo, na linha 6, criamos uma varivel chamada numero, para dados do
tipo int. Na linha 7, esta varivel recebe o valor 4 atravs do operador de atribuio. Assim
temos o seguinte estado da varivel:
numero 4
O operador = utilizado na linha 7 disse que atribuiremos varivel numero o valor 4, mas
no diz que o numero igual a 4. Se atriburmos outro valor varivel, o valor 4 ser substitudo
pelo novo valor.
Ao imprimir a mensagem, o identificador numero enviado para cout e substitudo pelo
valor da varivel numero.
A varivel numero do tipo int tem valor 4
3.2 Fluxo de entrada

De modo anlogo a cout, o cin um objeto global definido em iostream e utilizado para
que o usurio possa fazer entradas no programa. Assim, dados podem ser atribudos diretamente
s variveis, como apresentado na Figura 3.2.
varivel
Figura 3.2: O fluxo de entrada utilizado para que o usurio possa dar valores a variveis.
Esse mecanismo importante para a interao com a pessoa que utiliza o programa. Dessa
forma ele complementar ao operador de atribuio para dar valor s variveis.
Neste exemplo, temos um cdigo onde utilizamos o fluxo de entrada para dar valor s
variveis:
3.2 Fluxo de entrada 23

2
4
5 int main (){
6 double numero1 ;
7 double numero2 ;
8 double soma ;
9 cout << " digite o primeiro numero : " ;
10 cin >> numero1 ;
11 cout << " digite o segundo numero : " ;
12 cin >> numero2 ;
13 soma = numero1 + numero2 ;
14 cout << " A soma dos numeros " << soma << endl ;
15 return 0;
16 }
Logo no incio do cdigo, nas linhas 6 a 8, criamos 3 variveis que recebero seus valores
atravs do fluxo de entrada:
numero1 numero2 soma
O comando que aparece na linha 9 imprime uma mensagem pedindo ao usurio que execute
uma ao. Repare que no h o comando endl para passar para a prxima linha. Isso quer dizer
que qualquer outro texto aparecer na mesma linha pois no houve uma quebra de linha.
digite o primeiro numero:
O cin, aps a linha 8, usado para obter um valor que vir do usurio pelo teclado. Por isto,
o programa fica parado at que o usurio digite um valor e aperte a tecla Enter. Vamos supor que
o valor 3.14 tenha sido digitado. Como no houve quebra de linha no comando anterior, o valor
3.14 aparece em frente ao ltimo texto apresentado e o valor , ento, guardado na varivel
numero1, como indicado para o cin.
digite o primeiro numero: 3.14
numero1 3.14 numero2 soma
Vamos agora para o prximo passo na linha 10. Da mesma maneira, o programa espera uma
entrada de dados do usurio novamente e recebe desta vez o valor 2.7, por exemplo.

digite o segundo numero: 2.7
numero1 3.14 numero2 2.7 soma

Logo aps, na linha 12, atribuido varivel soma o valor numero1 somado com o valor
numero2. De modo que a cada varivel h um valor atribudo agora.
numero1 3.14 numero2 2.7 soma 5.84
O programa finaliza com uma ltima mensagem.

digite o segundo numero: 2.7
A soma dos numeros 5.84
3.2.1 Alteraes possveis

Vejamos agora algumas alteraes possveis no programa apresentado.
possvel termos uma lista separada por vrgulas para declarao das variveis do mesmo
tipo, como a acontece na linha 6 do programa a seguir.
2
4
5 int main (){
6 double numero1 , numero2 , soma ;
8 cin >> numero1 ;
10 cin >> numero2 ;
11 soma = numero1 + numero2 ;
12 cout << " A soma dos numeros " << soma << endl ;
13 return 0;
14 }
Apesar de possvel, mais interessante fazer a declarao de variveis separadamente, pois
isso nos permite inserir comentrios mais facilmente e deixa o cdigo mais legvel.
H ainda uma segunda alterao possvel. Neste cdigo a seguir, fizemos a adio dos dois
nmeros diretamente nos parmetros do cout, na linha 12:
2
4
5 int main (){
6 double numero1 , numero2 ;
8 cin >> numero1 ;
10 cin >> numero2 ;
11 cout << " A soma dos numeros " ;
12 cout << numero1 + numero2 << endl ;
13 return 0;
14 }
3.3 Operadores aritmticos 25
Assim, utilizamos uma varivel a menos. O resultado da soma fica armazenado temporaria-
mente para que o cout possa utiliz-lo. Ao fazer isto, aps o comando com o cout, o resultado
da soma descartado.
3.3 Operadores aritmticos

Alm do operador de atribuio, representado por um sinal de igualdade (=), existem os
operadores aritmticos. Esses so utilizados principalmente para tipos de dados que representam
nmeros.
J utilizamos um operador aritmtico de soma, representado pelo prprio sinal de mais (+),
no exemplo anterior. A Figura 3.3 representa como um operador aritmtico utiliza os valores de
duas variveis para criar uma nova varivel.
varivel1 4 varivel2 7
varivel3 11
Figura 3.3: Exemplo de operador aritmtico. Os valores de duas variveis so utilizados para a
criao de uma nova varivel.
A Tabela 3.1 apresenta os operadores aritmticos.
Operador Comando
Adio +
Subtrao -
Multiplicao *
Diviso /
Resto da diviso inteira %
Tabela 3.1: Tipos Fundamentais de Dados em C++
Neste exemplo, utilizaremos os operadores apresentados na Tabela:

3
4 int main (){
5 int numero1 ;
6 int numero2 ;
7 int r ;
9 cin >> numero1 ;
11 cin >> numero2 ;
12 r = numero1 + numero2 ;
13 cout << " Adi o dos numeros = " << r << endl ;
14 r = numero1 - numero2 ;
15 cout << " Subtra o dos numeros = " << r << endl ;
16 r = numero1 * numero2 ;
17 cout << " Multiplica o dos numeros = " << r << endl ;
18 r = numero1 / numero2 ;
19 cout << " Divis o dos numeros = " << r << endl ;
20 r = numero1 % numero2 ;
21 cout << " Resto da divis o = " << r << endl ;
22 return 0;
23 }
Como usual, criamos as variveis que sero utilizadas no programa, nas linhas 5 a 7. Em
seguida, nas linhas 8 a 11, o prprio usurio atribui valores s variveis numero1 e numero2,
como j aprendemos na Seo 3.2. Neste exemplo, vamos supor que o usurio escolheu os
valores 7 e 2:
Digite o primeiro numero 7

Digite o segundo numero 2
numero1 7 numero2 2 r
Veja na linha 12 o operador de adio, utilizado para fazer a soma que atribuda ar.
O comando com um cout imprime o resultado r, na linha 13, em seguida.

Adio dos numeros = 9
numero1 7 numero2 2 r 9
Fazemos o mesmo com o operador de subtrao, nas linhas 13 e 14:

Subtrao dos numeros = 5
Fazemos o mesmo com o operador de multiplicao, nas linhas 15 e 16:

Multiplicao dos numeros = 14
Fazemos o mesmo com o operador de diviso, nas linhas 17 e 18:

Diviso dos numeros = 3
Repare que o resultado da diviso de 7 por 2 3 e no 3.5. Isto acontece porque r uma
varivel do tipo int, que representa apenas nmeros inteiros.
Veja enfim, na linha 20, o operador de resto da diviso inteira, que tem o seu resultado
apresentado na linha 21.

Diviso dos numeros = 3
Resto da diviso = 1
O programa apresenta o resto da diviso inteira de 7 por 2, que igual a 1. Este operador s
est disponvel para dados de tipo inteiro, como int. Isso ocorre pois no existe resto da diviso
inteira para dados que representam nmeros reais, como double.
! Os operadores aritmticos so usualmente utilizados para dados aritmticos, como int e

double. Porm, os operadores aritmticos podem tambm ser utilizados para outros tipos
de dados, como bool e char. Nestes casos, os operadores tm outros significados.
3.4 Operadores de atribuio aritmticos

Existem outros operadores de atribuio alm do operador representado pelo sinal de igual-
dade =. Esses outros operadores de atribuio so utilizados para abreviar expresses aritmticas
e devem ser utilizados sempre que possvel. A alterao dos valores se d como apresentado na
Figura 3.4.
Imagine qualquer instruo onde somamos o valor de uma varivel x a 2 e atribumos o
resultado prpria varivel x. Isto pode ser convertido na forma x = x + 2. De forma mais
geral, considere qualquer comando onde atribumos prpria varivel o valor de uma varivel x
somado a uma constante c. Isto pode ser convertido em um comando da forma x = x + c.
Um operador de atribuio aritmtico permite que um comando x = x + c seja substitudo

por um comando na forma x += c. O comando x = x + c cria uma nova varivel temporria
com o valor de x + c, que ser atribudo a x. Por outro lado, o comando x += c apenas
incrementa o valor dex.
A Tabela 3.4 apresenta todos os operadores de atribuio artmticos e a mesma operao
poderia ser feita com um comando que utilizasse operadores comuns aritmticos e de atribuio.
Operador Exemplo Comando Equivalente

+= x += 6 x = x + 6
-= x -= 3 x = x -3
*= x *= 2 x = x * 2
/= x /= 4 x = x / 2
%= x %= 7 x = x % 7
Tabela 3.2: Operadores de Atribuio Aritmticos
Neste exemplo, utilizamos os operadores de atribuio aritmticos:

2
4
5 int main (){
6 int numero1 ;
7 int numero2 ;
9 cin >> numero1 ;
11 cin >> numero2 ;
12 numero1 += numero2 ;
13 cout << " Somando " ;
14 cout << numero2 << " ->" << numero1 << endl ;
15 numero1 -= numero2 ;
16 cout << " Subtraindo " ;
18 numero1 *= numero2 ;
varivel1 4
+2
varivel1 6
Figura 3.4: Exemplo de operador de atribuio aritmtico. Os valor de uma varivel transfor-
mado de acordo com uma expresso matemtica.
19 cout << " Multiplicando por " ;

21 numero1 /= numero2 ;
22 cout << " Dividindo por " ;
24 numero1 %= numero2 ;
25 cout << " Resto da divis o por " ;
27 return 0;
28 }
So criadas nossas variveis nas linhas 6 e 7. Em seguida, nas linhas 8 a 11, valores so
atribudos a elas:
digite o primeiro numero 8

digite o segundo numero 3
numero1 8 numero2 3
Na linha 12, o comando (+=) equivale a dizer que numero1 recebe o prprio valor de
numero1 mais o valor de numero2. As linha 13 e 14 imprimem o resultado:

Somando 3 -> 11
numero1 11 numero2 3
Aps a impresso do resultado, vamos para a prxima operao de atribuio aritmtica.

No prximo comando na linha 15, o numero1 recebe seu prprio valor menos o numero2.
Imprimimos novamente o resultado nas linhas 17 e 18, onde o valor de numero1 volta a ser 8:

Somando 3 -> 11
Subtraindo 3 -> 8
numero1 8 numero2 3
Em seguida, na linha 18, o numero1 recebe seu prprio valor vezes o numero2, e o resultado
impresso pelo cdigo das linhas 19 e 20:

Somando 3 -> 11
Subtraindo 3 -> 8
Multiplicando por 3 -> 24
numero1 24 numero2 3
Na linha 21, numero1 recebe seu prprio valor dividido por numero2 com a operao /=,
ficando com 8 como resultado. Os valores das variveis so impressos pelas linhas 22 e 23:

Somando 3 -> 11
Subtraindo 3 -> 8
Dividindo por 3 -> 8
numero1 8 numero2 3
Por fim, na linha 24, numero1, que tem valor 8, recebe o resto da diviso de seu prprio
valor por numero2, que tem valor 3. O nosso valor de numero1 passa a ser 2. Isto impresso
pelo cdigo das linhas 25 e 26:

Somando 3 -> 11
Subtraindo 3 -> 8
Dividindo por 3 -> 8
Resto da diviso por 3 -> 2
numero1 2 numero2 3
3.5 Operadores de incremento e decremento

Assim como os operadores de atribuio aritmticos, os operadores de incremento e decre-
mento so utilizados tambm para alterar o valor de variveis. Estes operadores so usados
para adicionar ou subtrair somente uma unidade do valor de uma varivel, como apresentado na
Figura 3.6.
varivel1 4
++
varivel1 5
Figura 3.5: Exemplo de operador de atribuio aritmtico. Os valor de uma varivel transfor-
mado de acordo com uma expresso matemtica.
O operador de incremento representado por dois sinais de adio seguidos (++) e ele serve
para incrementar em uma unidade o valor de uma varivel qualquer (x++). Como esta uma
operao comum, isto tira o trabalho de dizermos que x = x + 1 ou que x += 1. Podemos
apenas dizer x++.
A posio do operador tambm altera seu modo de funcionamento. Para utilizar e depois
incrementar valores usamos x++. Chamamos este de um operador de ps-incremento. Para
incrementar e depois utilizar valores usamos ++x. Chamamos este de um operador prefixado.
De modo anlogo, no caso do decremento, podemos utilizar x ou x. Isto ficar mais claro neste
exemplo, onde mostraremos a diferena entre os vrios operadores de incremento e decremento:
2
4
5 int main (){
6 int x ;
7 x = 0;
8 cout << " x = " << x ++ << endl ;
9 cout << " x = " << x << endl ;
10 cout << " x = " << ++ x << endl ;
11 cout << " x = " << x << endl ;
12 cout << " x = " << x - - << endl ;
13 cout << " x = " << x << endl ;
14 cout << " x = " << --x << endl ;
15 cout << " x = " << x << endl ;
16 return 0;
17 }
Iniciamos nossa funo principal main com a criao de uma varivel x na linha 6. Esta
varivel inicia com valor 0 que lhe atribudo na linha 7 do cdigo. Assim temos a seguinte
condio das variveis:
x 0
Na linha 8, utilizamos um operador de incremento em uma varivel que est sendo en-
viada para um cout. Como utilizamos o operador de ps-incremento (x++), a varivel ser
primeiramente utilizada no comando cout. Isto imprime seu valor:
x = 0
Apenas aps sua utilizao, o operador da linha 8 incrementa o valor de x, que passa a ser 1.
x 1
No comando seguinte da linha 9, simplesmente imprimimos o valor da varivel x, que agora

vale 1.
x = 0
x = 1
x 1
Agora na linha 10, utilizamos um operador de incremento prefixado (++x), onde x

incrementado e depois utilizado. Primeiramente, x incrementado passando a valer 2 e em
seguida seu valor impresso:
x = 0
x = 1
x = 2
x 2
Na linha 11 imprimimos novamente o valor de x, sem alter-lo:
x = 0
x = 1
x = 2
x = 2
x 2
De modo anlogo, na linha 12 utilizamos o Operador de ps-decremento x, onde x

utilizado e apenas depois decrementado. Isso imprime o valor 2 e depois altera o valor de x para
1:
x = 0
x = 1
x = 2
x = 2
x = 2
x 1
A linha 13 do cdigo apenas imprime o valor de x, que agora 1:
x = 0
x = 1
x = 2
x = 2
x = 2
x = 1
x 1
Por fim, na linha 14 usamos o operador de decremento prefixado x, para que x seja
decrementado e depois utilizado. Assim, x passa primeiro a valer 0 e este valor impresso em
seguida:
x = 0
x = 1
x = 2
x = 2
x = 2
x = 1
x = 0
x 0
Aps isto, na linha 15, o valor final de x impresso mais uma vez e encerramos o programa:
x = 0
x = 1
x = 2
x = 2
x = 2
x = 1
x = 0
x = 0
x 0
Como vimos, o operador prefixado incrementa (++i) ou decrementa (i) o valor da varivel
antes de usa-la. Apenas aps a alterao, ela utilizada com o valor modificado na expresso
em que aparece. O operador de ps-incremento (i++) ou ps-decremento (i) altera o valor da
varivel apenas depois que a mesma utilizada na expresso em que aparece. Um quadro geral
com os operadores de incremento e decremento apresentado na Tabela 3.5.
Operador Significado Representao

Ps-incremento Utiliza e depois incrementa i++
Incremento prefixado Incrementa e depois utiliza ++i
Ps-decremento Utiliza e depois decrementa i--
Decremento prefixado Decrementa e depois utiliza --i
Tabela 3.3: Operadores de Incremento de Decremento

3.6 Dados lgicos e comparaes

muito comum em nossas vidas termos dilemas que precisamos resolver. Dilemas so
situaes onde temos apenas duas opes. Por exemplo: Esquerda ou direita? Para cima ou para
baixo? Dentro ou fora? Melhor ou pior? Sim ou no? Verdadeiro ou Falso? Zero ou um? Oito
ou oitenta?
No caso da programao, variveis lgicas so utilizadas para guardar o resultado de tais
dilemas. Estas variveis so criadas com a palavra-chave bool e podem assumir apenas dois
valores: Verdadeiro, que representado por true, e falso, que representado por false.
Neste exemplo abaixo, criaremos variveis lgicas e mostraremos seus valores:
2
4
5 int main (){
6 bool var1 ;
7 var1 = true
8 bool var2 ;
9 var2 = false ;
10 cout << " var1 = " << var1 << endl ;
11 cout << " var2 = " << var2 << endl ;
12 return 0;
13 }
criada a varivel var1 na linha 6. Logo em seguida, na linha 7, var1 recebe true, ou seja,
verdadeiro. Na linha 8 criada a varivel var2. Em seguida, na linha 9, var2 recebe false, ou
seja, falso. Assim, temos o seguinte estado das variveis:
var1 true var2 false
Nas linhas 10 e 11, imprimimos os valores destas variveis. Veja como, em vez das palavras
true e false, o cout imprime true como 1 e false como 0:
var1 = 1
var2 = 0
var1 true var2 false
3.7 Operadores relacionais

Os operadores relacionais so utilizados para comparar variveis de qualquer tipo. O
resultado dessa comparao um dado do tipo bool, que diz se a comparao verdadeira ou
falsa. Usualmente, este operadores so mais utilizados para gerar dados do tipo bool, do que
os valores true e false diretamente, como fizemos no ltimo exemplo. A Figura 3.6 mostra
um exemplo de operador relacional onde perguntamos se 3 maior que 7 e temos false (falso)
como resposta.
A Tabela 3.7 apresenta um quadro geral com os operadores relacionais que temos em C++.
Tanto o maior quequando o menor que", tanto em C++ quanto em lgebra so representados
varivel1 3 varivel2 7
>
resultado false
Figura 3.6: Exemplo de operador relacional. O valor de duas variveis so comparados e temos
um resultado lgico, que verdadeiro ou falso.
Significado C++ Em lgebra

Maior que > >
Menor que < <
Maior ou igual >=
Menor ou igual <=
Igual == =
Diferente != 6=
Tabela 3.4: Operadores de Incremento de Decremento
pelos smbolos > e <. O Maior ou igual e o menor ou igualque so representados em

matemtica por ou , em C++ so representados por >= e <=.
O igual, em C++, representado por dois sinais de igualdade juntos (==). Note como isto
diferente da igualdade em lgebra, que, naturalmente, usa apenas um sinal de igualdade (=).
Note que no podemos utilizar apenas um sinal de igualdade para representar igualdade em C++
pois este seria o operador de atribuio em C++, que aprendemos na Seo 3.1. O diferente,
em C++, representado por !=. Isto o que, em lgebra, seria representado por um smbolo da
desigualdade, que um sinal de igualdade cortado ao meio (6=).
! importante no confundir o operador relacional de igualdade (==) com o operador de

atribuio (=). O primeiro representado por dois sinais de igualdade e compara duas
variveis. O segundo representado por apenas um sinal de igualdade e serve para atribuir
valores a uma varivel. S se faz comparaes com o operador de igualdade ==.
Neste exemplo, mostraremos como a comparao de duas variveis nos retorna um valor do
tipo bool:
2
4
5 int main (){
6 bool x ;
7 x = 2 < 9;
8 cout << x << endl ;
9 cout << (2 < 3) << endl ;
10 cout << (4 > 5) << endl ;

11 cout << (1 <= 7) << endl ;
12 cout << (2 >= 2) << endl ;
13 cout << (4 == 4) << endl ;
14 cout << (4 != 4) << endl ;
15 return 0;
16 }
No exemplo, criamos uma varivel x na linha 6 para guardar dados do tipo bool. Na linha 7,
x recebe um bool que diz se dois menor que nove (2 < 9). Como dois de fato menor que
nove, esta varivel recebe true, ou verdadeiro. Em seguida, na linha 8, imprimimos x, onde seu
valor true impresso como 1:
x true
O valor de x fica ento como true. Como no precisamos armazenar o resultado de uma
expresso neste exemplo, podemos utilizar e imprimir diretamente seu resultado como fazemos
nesta prxima impresso, na linha 9. Neste comando, perguntamos se 2 menor que 3. Como o
resultado da comparao verdadeiro, true retornado e o valor 1 impresso:
1
1
Em seguida, na linha 10, testamos se 4 maior que 5, retornando falso.
1
1
0
Testamos se 1 menor ou igual a 7, na linha 11, com resultado verdadeiro:
1
1
0
1
Logo na linha 12, se 2 maior ou igual a 2, com resultado verdadeiro.
1
1
0
1
1
Na linha 13, se 4 igual a 4, com resultado verdadeiro.

1
1
0
1
1
1
E finalmente na linha 14, se 4 diferente de 4, com resultado falso:
1
1
0
1
1
1
0
3.8 Operadores lgicos

Como vimos, os operadores de relao so teis para expressar condies simples como
x < 10 (x < y), y 1000 (y >= 1000), ou x 6= y (x != y). Estes operadores geram novos
dados lgicos a partir da comparao de duas variveis quaisquer.
J os operadores lgicos so os que geram novos bools a partir de outros bools, como apre-
sentado na Figura 3.7. Eles so utilizados para testar mltiplas condies, que so representadas
pelos bools.
condio1 true condio2 false
&&
resultado false
Figura 3.7: Exemplo de operador lgico. Estes operadores criam novos dados lgicos a partir de
outros dados lgicos.
A Tabela 3.8 apresenta os operadores lgicos e o que os mesmos retornam. O E lgico,

em C++ representado por &&, retorna se dois bools so verdadeiros. O OU lgico, em C++
representado por duas barras verticais seguidas (||), retorna se pelo menos um de dois bools
true. J o NO lgico ou negao, em C++ representado por um ponto de exclamao (!),
retorna o inverso de um bool.
A Tabela 3.8 apresenta alguns exemplos de utilizao de operadores lgicos, com seus
significados. Na expresso entre parnteses temos duas expresses distintas, tambm entre
parnteses. Na primeira expresso, perguntamos se 2 > 7, o que falso. Em seguida, perguntamos
se 6 > 3, o que verdadeiro. O operador de E lgico && pergunta se as duas expresses so
verdadeiras, o que falso em nossa primeira expresso. No segundo exemplo, perguntamos se
2 < 7 e 6 > 3, o que verdadeiro.
Nome Em C++ Retorna

E lgico && se dois bools so true
OU lgico || se um dos dois bools true
No lgico ou Negao ! o inverso de um bool
Tabela 3.5: Operadores Lgicos.
No terceiro exemplo, temos uma expresso que pergunta se 2 < 6, o que verdadeiro. A
segunda expresso pergunta se 6 < 3, o que falso. O operador de OU lgico pergunta se
pelo menos uma das duas expresses verdadeira, o que torna toda a expresso verdadeira. Em
seguida, no quarto exemplo, perguntamos se 7 < 2 ou ao menos 6 < 3. O resultado da expresso
completa falso.
No ltimo exemplo, na expresso que utiliza o NO lgico, temos uma expresso que
pergunta se 2 < 3, o que verdadeiro. Porm o operador de NO lgico recebe este verdadeiro
e o transforma em falso.
Expresso Resultado Significado

((2 > 7) && (6 > 3)) false 2 > 7 e 6 > 3?
((2 < 7) && (6 > 3)) true 2 < 7 e 6 > 3?
((2 < 7) || (6 < 3)) true 2 < 7 ou 6 < 3?
((7 < 2) || (6 < 3)) false 7 < 2 e 6 < 3?
!(2 < 3) false 2 < 3? Inverta a resposta.
Tabela 3.6: Exemplos de utilizao dos Operadores Lgicos.
3.8.1 Resumo dos operadores lgicos

comum resumir o funcionamento de operadores lgicos atravs de tabelas verdade. A
Tabela 3.7 apresenta a Tabela Verdade do operador E"lgico. Neste operador, sempre que uma
das expresses utilizadas pelo operador for falsa, temos false como resultado. Mas se temos as
expresses 1 e 2 como true, temos ento true como resultado da aplicao do operador.
Expresso 1 Expresso 2 Expresso 1 && Expresso 2

false false false
false true false
true false false
true true true

! Em lgebra, podemos dizer que 3 < x < 7. Esta uma notao matematicamente correta.
Porm, em C++, devemos utilizar (3 < x) && (3 < 7). Precisamos disto pois estas so
duas operaes distintas de comparao.
A Tabela 3.8 apresenta a Tabela Verdade do operador OU lgico ||. Na tabela verdade
do operador OU lgico, temos uma situao onde temos false como resposta sempre que
as duas expresses sendo comparadas tambm sejam falsas. Para todos os outros casos, temos
true como resultado, j que uma das expresses sempre verdadeira.
Expresso 1 Expresso 2 Expresso 1 || Expresso 2

false false false
false true true
true false true
true true true
A Tabela 3.9 apresenta a Tabela Verdade do operador NO lgico !. A tabela verdade do

operador de NO lgico bem mais simples. Se temos um expresso verdadeira, logo NO
lgico retornar false e vice-versa.
Expresso !Expresso
true false
false true
3.8.2 Exemplo
Neste exemplo, usaremos operadores lgicos para unir expresses condicionais.
2
4
5 int main (){
6 bool x ;
7 x = ((2 > 7) && (6 > 3));
9 x = (( true ) || ( false ));
11 cout << ((2 < 7) && (6 > 3)) << endl ;
12 cout << ((2 < 7) || (6 < 3)) << endl ;
13 cout << ((7 < 2) || (6 < 3)) << endl ;
14 x = !x;
16 cout << !(2 < 3) << endl ;

17 return 0;
18 }
Uma varivel para dados lgicos criada logo na linha 6, primeira linha dentro da funao
main. Unimos ento duas expresses na linha 7 abaixo. Perguntamos se 2 > 7, o que falso.
Depois perguntamos se 6 > 3, o que verdadeiro. O E lgico && pergunta se as duas condies
so verdadeiras, o que falso. O resultado atribudo varivel x, que impressa como 0 na
linha 8.
x false
Em seguida, na linha 9, temos um valor booleano que representa verdadeiro e outro valor
que representa falso. O operador de OU lgico pergunta se ao menos uma das duas expresses
verdadeira, e o resultado verdadeiro. Este resultado guardado em x e impresso como 1.
0
1
x true
No prximo comando, na linha 11, imprimimos se 2 < 7 e 6 > 3, o que verdadeiro, e a

impresso ser 1.
0
1
1
Em seguida, na linha 12, se 2 < 7 ou 6 < 3, o que tambm verdadeiro, imprimimos ento 1
0
1
1
1
A prxima comparao, linha 13, pergunta se 7 < 2 ou 6 < 3. Como as duas expresses so
falsas, o resultado falso.
0
1
1
1
0
3.9 Exerccios 41
O comando que aparece na linha 14 utiliza o operao de No-lgico para inverter o valor
de x. O valor invertido de x atribudo prpria varivel x, que passa a ser falso. A linha 15
imprime o valor de x.
0
1
1
1
0
0
x false
O ltimo exemplo, na linha 16, uma impresso de um resultado da expresso invertida

diretamente no comando de impresso. Testamos se 2 < 4, que true, e invertemos o resultado
para false. O resultado impresso como 0 e encerramos o programa:
0
1
1
1
0
0
0
3.9 Exerccios
Exerccio 3.1 Faa um programa que leia uma altura e uma peso de uma pessoa e imprima
seu ndice de Massa Corporal (IMC), que calculado com a frmula:
peso
IMC =
altura2
Exemplo de sada:
Digite a altura da pessoa: 1.8

Digite o peso da pessoa: 68
O ndice de Massa Corporal desta pessoa 20.9876
Note que, por padro, no existe em C++ um operador "pr-definido para exponencia-
o. Assim, altura2 = altura altura.
Exerccio 3.2 Faa um programa que leia uma temperatura em Celsius e imprime esta
temperatura em Fahrenheit. Considere a frmula:
9C
F= + 32
5
Exemplo de sada:
Digite a temperatura em Celsius: 20.5

20.5 graus Celsius equivalem a 68.9 graus Fahrenheit
Exerccio 3.3 Faa um programa que leia o raio r de um crculo e imprima sua rea A e seu
permetro p.
A = r2 p = 2 r
Exemplo de sada:
Digite o raio do crculo: 4.12

Um crculo de raio 4.12 possui rea 53.29 e permetro 25.87
Considere que = 3.14.
Exerccio 3.4 Faa um programa que leia dois valores a e b e imprima o resultado de
(b3 + ab) 2b + a mod b. Em notao matemtica, mod representa o resto da diviso de dois
inteiros. Note que no se calcula resto da diviso de nmeros reais.
Exemplo de sada:
Digite o valor de a: 5
Digite o valor de b: 7
f(x) = 369

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 4.0Estruturas
0
1 0 condicionais
1
0 0 1
0 1
0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
A todo momento estamos tomando decises que dependem de condies. Se o carro est sujo,
ento precisamos lavar. Se no choveu, vamos regar as plantas. Se estiver escuro acenderemos
as luzes.
Cdigos com estruturas condicionais tambm funcionam assim. Estas estruturas nos do
capacidade para representar estas situaes.
Veja que nos cdigos que criamos at o momento, apenas estruturas sequenciais foram
utilizadas. Nestas estruturas, todos os comandos so executados de cima para baixo, como
representado na Figura 4.1.
Com as estruturas condicionais, podemos dizer que alguns trechos do cdigo nem sempre
sero executados. Estes trechos estaro condicionados a alguma condio, como representado na
Figura 4.2.
4.1 Condicional se
A instruo if (se, em ingls), uma instruo de uma nica seleo. Ela seleciona ou
ignora um grupo de aes de acordo com uma condio. Esta condio pode fazer com que o
programa ignore ou no certo bloco de comandos. Toda instruo de controle espera um dado do
tipo bool indicando se a condio true, verdadeira, ou false, falsa.
4.1.1 Sintaxe do se
Assim a organizao geral de uma instruo if:
1 if ( condi o ){
2 comandos ;
3 comandos ;
4 }
A condio entre parnteses deve ser um dado do tipo bool. Este bool pode ser sim-
plesmente true ou false, neste caso a condio seria sempre verdadeira ou falsa. Por isso,
normalmente, vamos usar uma expresso que retorna um bool, como x < 3.
44 Captulo 4. Estruturas condicionais
Comandos
Comandos
Comandos
Comandos
Figura 4.1: Representao de um programa com estrutura sequencial.
As chaves { e } indicam onde se inicia e termina o bloco de comandos que sero executados
apenas se a condio for verdadeira. Entre as chaves, podem ser inseridos quantos comandos
forem necessrios.
Perceba que os comandos pertencentes ao if esto alinhados mais direita do restante do
cdigo. Isto fundamental para que o cdigo seja legvel quando temos muitos comandos. Esta
organizao se chama indentao.
4.1.2 Exemplo
Neste exemplo, vamos criar um bloco do cdigo que depender de uma condio.
2
4
5 int main (){
6 double largura ;
7 cout << " Digite a largura do quadrado : " ;
8 cin >> largura ;
9 if ( largura >= 0){
10 cout << " A rea do quadrado " ;
11 cout << largura * largura << endl ;
12 }
13 return 0;
14 }
No incio da funo principal, criamos uma varivel na linha 6 e, na linha 7, pedimos ao
usurio que digite a largura de um quadrado. Este valor ser utilizado para imprimir a rea do
quadrado. Porm, apenas valores no negativos so vlidos como largura do quadrado. Caso o
nmero digitado seja menor que 0, no queremos que o valor seja impresso, pois ele invlido.
4.1 Condicional se 45
Comandos
Condio
Comandos
Comandos
Figura 4.2: Representao de um programa com estrutura condicional.
Neste exemplo, supomos que o usurio digitou 5 como largura do quadrado.
Digite a largura do quadrado: 5
largura 5
Testamos, na linha 9, a condio largura > 0, que neste caso equivale a 5>0 e verdadeira.
Isto faz com que os comandos dentro do bloco sejam executados. Veja que como os comandos
das linhas 10 e 11 pertencem ao if, eles esto indentados mais direita. Como a condio era
verdadeira, os comandos das linhas 10 e 11 so executados e a rea do quadrado, 25, impressa:
Digite a largura do quadrado: 5

A rea do quadrado 25
Vamos supor agora que o programa seja executado novamente e o usurio digitou -3 como
largura do quadrado.
Digite a largura do quadrado: -3
largura -3
A condio -3 >= 0 falsa. Assim, o bloco do if, composto pelas linhas 10 e 10, ser
ignorado e o programa ser encerrado sem a mensagem:
Digite a largura do quadrado: -3
4.2 Se-seno
Alm de fazermos tarefas que dependem de uma condio, tambm fazemos usualmente
muitas decises entre duas opes. Suponha que temos uma festa hoje. Podemos nos perguntar
se a festa ser a noite. Se sim, podemos usar um terno. Seno, podemos usar uma bermuda.
A instruo if-else (se-seno em ingls), uma instruo de seleo dupla. Ela seleciona
entre dois blocos de comandos, como representado na Figura 4.3. Diferentes aes so tomadas
em vez de apenas se ignorar um bloco. Uma condio decide qual bloco de comandos vamos
utilizar.
Comandos
Verdadeiro Falso
Condio
Comandos Comandos
Comandos Comandos
Comandos
Figura 4.3: Representao de uma instruo de seleo dupla.
4.2.1 Se-seno sintaxe

Esta a estrutura geral das instrues de se-seno.
1 if ( condi o ){
2 comandos ;
3 comandos ;
4 } else {
5 comandos ;
6 comandos ;
7 }
A condio entre parnteses deve ser representada ainda por um valor do tipo bool. As
chaves { e } agora indicam onde se iniciam e onde terminam dois blocos distintos de comandos.
Um bloco, composto pelos comandos das linhas 2 e 3, executado se a condio for true e o
outro, composto pelos comandos das linhas 5 e 6, se a condio for false. Perceba tambm a
indentao, fundamental para organizao do cdigo. Os blocos so todos indentados direita
dentro dos blocos.
4.2.2 Exemplo
Neste exemplo, vamos pedir um nmero ao usurio e imprimir uma mensagem informando se
este nmero par ou mpar:
2
4
5 int main (){
6 int numero ;
7 cout << " Digite um n mero : " ;
8 cin >> numero ;
9 if ( numero % 2 == 0){
10 cout << " O n mero par " << endl ;
11 } else {
12 cout << " O n mero mpar " << endl ;
13 }
14 return 0;
15 }
Na linha 6, criamos uma varivel numero e, na linha 7 do cdigo, pedimos ao usurio que
digite um nmero:
Digite um nmero: 7
numero 7
A expresso condicional numero % 2 == 0, que utilizamos na linha 9, testa se a diviso

de numero por 2 tem resto 0. Repare que dividir um nmero por 2 e ter resto zero significa que
este nmero par. Como o resultado false, o bloco de comandos do else, formado pelo
comando da linha 12, ento executado. Temos neste bloco um comando que imprime na tela
que o nmero digitado mpar.
Digite um nmero: 7
O nmero mpar
numero 7
4.3 Se-seno aninhados

Existem ocasies onde h vrias condies possveis que levam a diferentes escolhas. Ima-
gine que voc est de frente a um caixa eletrnico, se a sua opo for o extrato", uma tela 1 ser
exibida. Se escolher saldo", uma tela 2 ser exibida. Se a sua opo for depsito", uma tela 3
ser exibida, ou se a sua opo for saque", ento uma tela 4 ser exibida.
A instruo if-else aninhada utilizada como instruo de seleo mltipla para testar
vrios casos, como representado na Figura 4.4. Ela seleciona entre vrios grupos diferentes de
comandos. Existe agora no apenas uma condio mas um grupo de condies que escolhem
entre grupos de blocos de comandos.
Comandos
Condies
Comandos Comandos Comandos
Comandos Comandos Comandos
Comandos
Figura 4.4: Representao de uma instruo de seleo mltipla.
4.3.1 Se-seno alinhados- sintaxe

Esta a sintaxe deste tipo de estrutura condicional:
1 if ( condi o1 ){
2 comandos ;
3 comandos ;
4 } else if ( condi o2 ){
5 comandos ;
6 comandos ;
7 } else if ( condi o3 ){
8 comandos ;
9 comandos ;
10 } else {
11 comandos ;
12 comandos ;
13 }
H agora vrias condies possveis que podem ser escolhidas. Sendo assim, podem ser
criados quantos blocos forem necessrios. Para cada condio a mais, temos um bloco a mais. A
primeira condio que for true determina qual bloco ser executado. Se nenhuma for true,
ento o bloco do else executado. Perceba que a indentao se mantm.
4.3.2 Exemplo
Neste exemplo, vamos determinar qual o conceito de um aluno de acordo com sua nota.
2
4
5 int main (){
6 int nota ;
7 cout << " Digite a nota do aluno : " ;
8 cin >> nota ;
9 if ( nota >= 90){
10 cout << " O conceito do aluno A " << endl ;
11 } else if ( nota >= 80){
12 cout << " O conceito do aluno B " << endl ;
13 } else if ( nota >= 70){
14 cout << " O conceito do aluno C " << endl ;
15 } else if ( nota >= 60){
16 cout << " O conceito do aluno D " << endl ;
17 } else {
18 cout << " O conceito do aluno E " << endl ;
19 }
20 return 0;
21 }
Nas linhas 6 a 8 o usurio determina que a nota de um aluno. Neste exemplo, a nota do aluno
74, o que quer dizer que o aluno deve ter conceito C.
Digite a nota do aluno: 74
nota 74
Como a condio da linha 9, nota >= 90, falsa, o primeiro bloco de comandos, na linha
10, ignorado. Como nota >= 80, condio da linha 11, tambm falso, o segundo bloco de
comandos, da linha 12, tambm ignorado.
Na linha 13 temos a condio nota > 70, que verdadeira. O bloco de comandos corres-
pondente, na linha 14, ser executado. Este bloco de comandos imprime na tela que o conceito
do aluno C.
Digte a nota do aluno: 74

O conceito do aluno C
nota 74
Samos ento do bloco alinhado e vamos direto para a linha 20, onde a funo encerrada.
Repare que a nota tambm era maior que 60, mas apenas o primeiro bloco true considerado.
4.4 Outros operadores condicionais

Apesar das instrues apresentadas serem suficientes para representar qualquer estrutura
condicional, existem outros operadores disponveis que podem ser convenientes de se conhecer.
4.4.1 Operador ternrio

Esta a sintaxe do operador ternrio:
1 condicao ? expressao1 : expressao2 ;
Temos uma condio seguida de duas expresses, separadas por dois pontos :. Se a condio
for verdadeira, a primeira expresso ser retornada. Se a condio for falsa, a segunda expresso
ser retornada.
O operador ternrio pode ser substitudo por um if-else, onde a primeira expresso fica no
primeiro bloco e a segunda expresso no segundo bloco.
1 if ( condicao ){
2 expressao1 ;
3 } else {
4 expressao2 ;
5 }
No exemplo abaixo, utilizamos o operador ternrio para damos varivel max o valor 1 ou 0,
de acordo com a condio x>y:
1 max =( x > y )?1:0;
O mesmo cdigo pode ser representado com um if-else onde a condio x > y. No
primeiro bloco, atribumos 1 a max. No segundo, atribumos 0. Veja o exemplo:
1 if (x > y ){
2 max = 1;
3 } else {
4 max = 0;
5 }
Assim, o operador ternrio faz o mesmo que pode ser feito com um if-else. O operator
ternrio pode diminuir o nmero de linhas para se representar uma seleo dupla. Porm,
comum evitar o uso desta instruo pois ela dificulta a leitura do cdigo.
4.4.2 Switch
O switch um recurso para estruturas mltiplas de seleo. Sua sintaxe definida da
seguinte maneira:
1 switch ( vari vel ){
2 case constante1 :
3 comandos ;
4 break ;
5 case constante2 :
6 comandos ;
7 break ;
8 default :
9 comandos ;
10 }
4.5 Exerccios 51
Temos uma varivel que ser comparada com vrias constantes. Caso a varivel seja
igual a uma destas constantes, um conjunto de comandos executado.
O switch pode ser facilmente substitudo por um if-else aninhado da seguinte forma:
1 if ( vari vel == contante1 ){
2 comandos ;
3 } else if ( vari vel == constante2 ){
4 comandos ;
5 } else {
6 comandos ;
7 }
No if-else, podemos comparar a varivel a cada uma das constantes do switch.
Neste exemplo seguinte, temos um switch para definir o que fazer de acordo com uma
opo do usurio.
1 switch ( opcao ){
2 case 1:
3 cout << " Op o 1 escolhida " << endl ;
4 break ;
5 case 2:
7 break ;
8 default :
9 cout << " Op o inv lida escolhida " << endl ;
10 }
A varivel opcao enviada para o switch e comparada para cada caso. O switch um
recurso muito utilizado para apresentar um menu de opes para o usurio.
Este switch pode ser substitudo por um if-else onde comparamos opcao com cada
possibilidade de resposta:
1 if ( opcao == 1){
3 } else if ( opcao == 2){
5 } else {
6 cout << " Op o inv lida escolhida " << endl ;
7 }
4.5 Exerccios
Exerccio 4.1 Faa um programa que leia um nmero de usurio e uma senha numrica. O
programa deve dizer se os valores digitados so vlidos ou no. As senhas vlidas so:
Nmero de usurio Senha

982753 83928
263572 49582
275493 72648
Exemplo de sada:
Digite o nmero do usurio: 876342

Digite a senha do usurio: 20495
Usurio Invlido
Exerccio 4.2 Faa um programa que leia 5 nmeros e diga no final quantos nmeros eram
pares e quantos nmeros eram mpares.
Neste exerccio, apenas 2 variveis podero ser utilizadas. Uma para receber o nmero
e outra para contar quantas vezes o nmero recebido foi par ou mpar.
Exemplo de sada:
Digite o primeiro nmero: 7

Digite o segundo nmero: 15
Digite o terceiro nmero: 13
Digite o quarto nmero: 4
Digite o quinto nmero: 2
Voc digitou 2 nmeros pares e 3 nmeros mpares
Exerccio 4.3 Faa um programa que leia um valor para uma varivel x e ento calcule f (x),
sendo que:
f (x) = x + 2x2 se g(x) > 10
f (x) = 10 se g(x) 10
g(x) = 5 se h(x) 5
g(x) = h(x) se h(x) > 5
h(x) = x2 + 3x 20
Exemplo de sada:
Digite o valor de x: 15
f(x) = 465
Exerccio 4.4 Faa um programa que leia a idade de um atleta e imprima sua categoria,
sendo que:
Idade do Atleta Categoria

5 a 7 anos Infantil A
8 a 10 anos Infantil B
11 a 13 anos Juvenil A
14 a 17 anos Juvenil B
18 a 25 anos Snior
Exemplo de sada:
Digite a idade do atleta: 17

Este um atleta Juvenil B
4.5 Exerccios 53
Exerccio 4.5 Faa um programa que leia:

O salrio de um empregado por hora trabalhada
O nmero de horas trabalhadas
O nmeros de horas extras trabalhadas
O nmero de dependentes
O programa retornar o salrio final do empregado, sendo que:
H um benefcio de R$128,00 por dependente
Deve-se pagar imposto de renda de acordo com o salrio
H um benefcio de acordo com o salrio aps o imposto de renda
O imposto de renda :
Salrio Imposto
At R$1.434,59 0,00%
De R$1.434,60 at R$2.150,00 7,50%
De R$2.150,01 at R$2.866,70 15,00%
De R$2.866,71 at R$3.582,00 22,50%
Acima de R$3.582,01 27,50%
Os benefcios so:
Salrio Lquido Benefcio

At R$500,00 R$180,00
De R$500,00 at R$1.000,00 R$120
Acima de R$1.000,00 R$100,00
Exemplo de sada:
Digite o salrio do empregado por hora trabalhada: 9.5

Digite o nmero de horas trabalhadas: 160
Digite o nmero de horas extras trabalhadas: 7
Digite o nmero de dependentes: 2
O salrio final do empregado R$1804.31

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 5.0Operador
0
1 0 de endereo
1
0 0 1 e arranjos
1
0
0 0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
5.1 Operador de endereo

O endereo de variveis conceito fundamental em C++. Cada varivel declarada por ns
possui fisicamente um endereo na memria do computador. A memria dos computadores
possui vrias posies, sendo que cada posies possui um endereo. Quando criamos uma
varivel, ela guardada na memria. Cada valor precisa ficar em uma posio da memria. E
cada uma destas posies tem um endereo. Isto est representado na Tabela 5.1.
Nomes das variveis Valores das Variveis Endereos das Posies

24
25
26
27
28
largura 5 29
30
31
32
33
34
35
Tabela 5.1: Organizao dos dados na memria se d atravs de posies e endereos.
Em C++, o nome de uma varivel, como largura, retorna diretamente seu valor, que no
exemplo seria 5. O operador de endereo, representado por um e comercial"&, retorna o
endereo de uma varivel. Assim, &largura retorna o endereo 29 desta varivel que, por sua
56 Captulo 5. Operador de endereo e arranjos
vez, contm fisicamente o valor 5.

Assim, cada varivel possui um nome identificador, um valor e um endereo. O nome de
uma varivel j nos retorna seu valor. J o operador de endereo (&) usado para nos retornar o
endereo desta varivel.
Neste exemplo, criaremos uma varivel e vamos imprimir seu valor e endereo:
2
4
5 int main (){
6 int num ;
8 cin >> num ;
9 cout << " O n mero " << num << endl ;
10 cout << " O endere o do n mero " << & num << endl ;
11 return 0;
12 }
Criamos ento, na linha 6, uma varivel chamada num. A princpio, sabemos que a varivel
existe, mas no sabemos seu endereo na memria. Temos uma varivel que foi criada e que
ainda no tem um valor, mas no sabemos onde est alocada na memria:
num
Suponha ento, que nas linhas 7 e 8 de cdigo, o usurio d o valor 65 a num.
Digite um nmero: 65
num 65
Como estamos acostumados, o cout da linha 9 imprime o valor do nmero num.
Digite um nmero: 65
O nmero 65
num 65
Agora, porm, utilizamos o operador de endereo na linha 10 em num (&num) em vez de num,
e o endereo de num na memria ser exibido.
Digite um nmero: 65
O nmero 65
O endereo de nmero 0xbf8d456c
Na linha 11 finalizamos o programa. Repare que o endereo impresso da varivel no

um nmero to simples como os nmeros de nosso exemplo anterior. Isso se deve grande
capacidade de nmeros de endereos das memrias atuais.
5.2 Arranjos simples 57
5.2 Arranjos simples

Pelo o que vimos at agora, cada varivel identifica um dado da memria. Porm, sabemos
tambm que programas complexos trabalham com muitos dados, como milhares de estudantes,
milhes de produtos ou centenas de nmeros. Precisamos ento de estruturas que representem
vrios dados de uma nica vez.
Um arranjo um endereo, onde h um grupo consecutivo de posies alocadas na
memria. Todas estas posies guardam variveis do mesmo tipo. Arranjos so ento estruturas
de dados muito teis para se trabalhar com vrios itens do mesmo tipo. Por exemplo, a Figura
5.2 representa um arranjo de nmeros inteiros que tem nome identificador x.
x 5 9 3 7 2 5 8 2
Figura 5.1: Um arranjo de nmeros inteiros.
O arranjo x apresentado nada mais que o endereo do primeiro elemento deste arranjo
de nmeros inteiros. Para acessar elementos especficos precisamos de utilizar x[i], onde este
i a posio no arranjo, como apresentado na Figura ??. Formalmente, este i chamado de
ndice do arranjo.
x 5 9 3 7 2 5 8 2
x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7]
Figura 5.2: Os elementos de um arranjo podem ser acessados atravs de ndices.
Repare que o primeiro ndice i 0 e o ltimo ndice i 7, ou seja, um a menos que o nmero
de elementos no arranjo. Isso ocorre porque os ndices representam quantas posies alm do
inico do arranjo est o elemento.
Os ndices so simplesmente nmeros inteiros ou uma expresso do tipo inteiro. Suponha
variveis a e b de tipo inteiro:
a 3 b 2
Podemos acessar x na posio a+b com o comando x[a+b] para retornar o elemento que
est em x na posio 5.
Os endereos dos elementos do arranjo esto em sequncia na memria. Assim, arranjo da
Figura 5.2 ficaria guardado na memria como representado na Tabela 5.2.
Para criar um arranjo inicial em branco para dez elementos, utilizamos int x[10].
1 int x [10];
Para criar um arranjo j com seus elementos utilize, ento, int x[] e uma lista de elementos
entre chaves, como no exemplo:
1 int x [] = {5 , 9 , 3 , 7 , 2 , 5 , 8 , 2};
! fundamental lembrar que um arranjo ocupa posies contnuas na memria. Os ndices i

indicam quantas posies somamos ao endereo da varivel para encontrar um elemento.
Assim, o endereo de x[3], ou &x[3], nada mais que o endereo de x[0] + 3, ou &x[0]
+ 3.

24
x[0] 5 25
x[1] 9 26
x[2] 3 27
x[3] 7 28
x[4] 2 29
x[5] 5 30
x[6] 8 31
x[7] 2 32
33
34
35
Tabela 5.2: Um arranjo armazenado na memria. Os elementos do arranjo se encontram em

posies sequenciais na memria.
importante entender que tentar acessar uma posio inexistente no arranjo um erro grave.
No sabemos o que h na posio e quais as consequncias de tal acesso.
Suponha que temos o arranjo apresentado na Figura 5.2 e vamos tentar acessar x[9]. Neste
caso, teramos um erro, pois de acordo com a Tabela 5.2, tentaramos acessar a posio de
memria no endereo 35. No sabemos o que existe na posio 35 e nem mesmo que tipo de
dado se encontra nesta posio.
Neste prximo exemplo, criamos um arranjo com 6 elementos e somamos elementos de
posies especficas:

2
4
5 int main (){
6 int a [] = {5 ,7 ,2 ,1 ,3 ,5};
7 int soma ;
8 soma = a [0] + a [2] + a [4];
9 cout << " a [0] + a [2] + a [4] -> " << soma << endl ;
10 cout << " Endere o do arranjo -> " << a << endl ;
11 return 0;
12 }
Na linha 6, criamos um arranjo a com 6 elementos, como o apresentado abaixo:
a 5 7 2 1 3 5
a[0] a[1] a[2] a[3] a[4] a[5]
Em seguida, na linha 7, criada uma varivel soma e, na linha 8, a mesma recebe a[0] +
a[2] + a[4], que equivale a 5 + 2 + 3, nmeros das posies 0, 2 e 4 do arranjo.
a 5 7 2 1 3 5 soma 10
a[0] a[1] a[2] a[3] a[4] a[5]
Quando imprimimos soma, na linha 9, temos o resultado da operao.
a[0] + a[2] + a[4] -> 10
Na linha 10, quando imprimimos o valor de a sem especificar uma posio, temos o endereo
na memria onde comea o arranjo a.
a[0] + a[2] + a[4] -> 10

Endereo do arranjo -> 0x7fff5f6bdb70
Lembre-se assim que um arranjo um endereo onde comea uma sequncia de elementos
na memria.
5.3 Cadeias de caracteres

Como vimos, o tipo fundamental de dados do tipo char utilizado para representar letras
e caracteres. Sua relao com arranjos fundamental para formar cadeias de caracteres. Estas
cadeias representam palavras e frases, que no so um tipo fundamental de dado.
As cadeias de caracteres so arranjos simples de chars e que terminam com o caractere
especial \0, que representa o fim da cadeia. Por exemplo, a Figura 5.3 apresenta um arranjo de
chars chamado b e que carrega a palavra abacate.
b a b a c a t e \0
b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7]
Figura 5.3: Cadeias de Caracteres so arranjos com dados do tipo char.
O caractere \0 mostra que ali termina a palavra. So necessrios assim 8 elementos para
uma palavra de 7 letras. Como aprendemos na seo anterior, este arranjo poderia ter sido criado
diretamente com o seguinte comando:
1 char b [] = { a , b , a , c , a , t , e , \0 };
onde o arranjo char b recebe uma lista de chars, que so separados por vrgula (,) e aspas
simples ().
Porm, existe um atalho equivalente, que atribuir a b todos os chars entre aspas duplas (").
1 char b [] = " abacate " ;
Podemos atribuir dados s cadeias com o comando cin, como em cin >> b. Isto, porm,
muito perigoso pois a pessoa pode digitar mais que 7 letras. Neste caso, haver uma tentativa de
inserir elementos alm do arranjo.
Por exemplo, em um comando cin para atribuir um valor a b, se a pessoa digita laranjada,
por exemplo, ocorre um erro por falta de espao. Isto apresentado na Figura 5.4, onde se
tenta atribuir a palavra laranjada ao arranjo j alocado da Figura 5.3. Como isto retornaria um
erro, preciso garantir que isto no ocorra, com arranjos que tenham espao suficiente para as
palavras possveis de acordo com a aplicao.
b l a r a n j a d a \0
b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b[8] b[9]
Figura 5.4: necessrio se precaver em relao ao nmero de posies disponveis para palavras
no arranjo.
J o objeto cout, recebendo b, imprime a palavra abacate corretamente. Assim como cin,
cout no se preocupa com o tamanho do arranjo. So impressos todos os caracteres at que se
encontre o caractere especial \0, como no exemplo abaixo:
1 cout << b ;
abacate
Como em qualquer arranjo b[i] retorna o char de b na posio i aps o endereo inicial
do arranjo.
Neste exemplo, criaremos uma cadeia de caracteres e imprimimos um de seus elementos:
2
4
5 int main (){
6 char nome [10];
7 cout << " Digite seu nome : " ;
8 cin >> nome ;
9 cout << " Terceira letra de seu nome " ;
10 cout << nome [2] << endl ;
11 return 0;
12 }
Para isto, criamos um arranjo de chars com 10 elementos, na linha 6. Nas linhas 7 e 8, o
usurio insere um nome nesse arranjo.
Digite seu nome: Maria
b M a r i a \0
b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b[8] b[9]
Depois, nas linhas 9 e 10, se imprime o caractere que est na posio 2 do arranjo, ou seja, a
terceira letra do nome:
5.4 Classe string 61

A terceira letra do seu nome r
O programa ento encerrado. Mas repare que este cdigo propenso a erros. Na linha 8, o
nome digitado poderia ter mais que 9 letras, e no haveria espao no arranjo. Ou o nome poderia,
na linha 10, ter menos que 3 letras e, no caso, estaramos tentando acessar posies inexistentes,
o que configura um erro grave novamente.
5.4 Classe string

Pode ser bastante trabalhoso lidar com todos os erros possveis na representao de cadeias
de caracteres com arranjos. Por isso o C++ nos oferece a classe string, para aliviar este
problema. Esta uma classe que define um tipo de dado no fundamental e por isto no est
apresentado na Tabela 1.1 onde vimos os tipos dados. Os dados no fundamentais so compostos
com os dados fundamentais da linguagem que j conhecemos. Neste caso, uma string organiza
automaticamente as cadeias dentro de arranjos para o programador.
Vamos supor que b agora uma string e no um arranjo simples de char. Esta string pode
ser criada com o seguinte comando:
1 string b ( " abacate " );
Se tentarmos executar um comando para que b receba a cadeia de caracteres laranjada,
mais espao ser alocado para atender demanda e no teremos mais erros. Por no ser um tipo
de dado fundamental, necessrio incluir em nosso cdigo o cabealho string com o seguinte
comando:
1 # include < string >
Neste prximo exemplo, o usurio ir inserir novamente um nome que ser salvo em uma
cadeia de caracteres:
3
5
6 int main (){
7 string nome ;
8 cout << " Digite seu nome : " ;
9 cin >> nome ;
10 cout << " Terceira letra de seu nome " ;
11 cout << nome [2] << endl ;
12 return 0;
13 }
Veja que desta vez, na linha 2, ser necessrio incluir o cabealho string para nos dar o
recurso de utilizar strings, pois string no um tipo fundamental de dados.
criada, na linha 7, ento, uma string nome que ter a capacidade que for demandada.
Inicialmente, a string se encontra vazia.
nome
Imprimimos umas mensagem na linha 8 e, quando o usurio faz sua entrada, na linha 9,
alocado um arranjo com o espao para o nome digitado:
nome M a r i a \0
Na linhas 10 e 11, retornamos a terceira letra do nome digitado, ou a segunda posio do

arranjo:

Terceira letra do seu nome r
5.5 Arranjos multidimensionais

Os arranjos que vimos at agora so muito teis para representar listas de elementos. J os
arranjos multidimensionais de duas dimenses costumam ser teis para representar tabelas de
valores organizados em linhas e colunas, como apresentado na Figura 5.5.
x Coluna 0 Coluna 1 Coluna 2 Coluna 3
Linha 0 3 4 7 5
Linha 1 4 7 4 2
Linha 2 7 8 3 6
Figura 5.5: Exemplo de arranjo de duas dimenses. Estes arranjos so teis para representar
tabelas organizadas em linhas e colunas.
Sendo assim, precisamos de dois ndices para encontrar um item dentro deste tipo de arranjo,
como representado na Figura 5.6. Estes so arranjos bidimensionais, tambm conhecidos como
2D. Para acessar uma posio especfica dentro desse arranjo x da Figura precisamos de dois
ndices entre colchetes x[i][j]. Assim como em arranjos simples, os ndices comeam em
0. Por conveno, o primeiro ndice indica a linha e o segundo a coluna. Se colocamos 0 no
primeiro ndice, acessamos elementos da primeira linha. Se colocamos 0 no segundo ndice,
acessamos elementos da primeira coluna.
Este exemplo de arranjo x pode ser criado com x[3][4], onde 3 representa o nmero de
linhas e 4 representa o nmero de colunas. Este arranjo pode receber diretamente seus elementos
atravs de trs conjuntos de nmeros entre chaves, como apresentado abaixo:
1 int x [3][4] = {{3 ,4 ,7 ,5} ,{4 ,7 ,4 ,2} ,{7 ,8 ,3 ,6}};
x Coluna 0 Coluna 1 Coluna 2 Coluna 3
Linha 0 x[0][0] x[0][1] x[0][2] x[0][3]
Linha 1 x[1][0] x[1][1] x[1][2] x[1][3]
Linha 2 x[2][0] x[2][1] x[2][2] x[2][3]
Figura 5.6: Posies em um arranjo de duas dimenses. Assim como em arranjos simples, as
posies de uma dimenso comeam em 0.
Cada conjunto de nmeros entre chaves representa uma linha do arranjo. Isto acontece
porque um arranjo multidimensional , fisicamente na verdade, um arranjo de arranjos.
Assim como um arranjo simples, um arranjo multidimensional tambm ocupa posies
contnuas na memria. O arranjo da Figura 5.5, por exemplo, seria armazenado na memria
como apresentado na Tabela 5.3.
Identificadores Valores das Variveis Endereos das Posies

x[0][0] 3 24
x[0][1] 4 25
x[0][2] 7 26
x[0][3] 5 27
x[1][0] 4 28
x[1][1] 7 29
x[1][2] 4 30
x[1][3] 2 31
x[2][0] 7 32
x[2][1] 8 33
x[2][2] 3 34
x[2][3] 6 35
Tabela 5.3: Um arranjo multidimensional armazenado na memria. Assim como em arranjos

simples, os elementos do arranjo multidimensional se encontram em posies sequenciais na
memria.
Assim, cada valor do arranjo possui um identificador (representado aqui pelo identificador
do arranjo e sua posio em colchetes), um valor e uma posio.
Todos os valores esto em sequncia na memria justamente porque eles nada mais so do
que arranjos de arranjos. No arranjo multidimensional x, x[0] um arranjo de 4 elementos que
se inicia na posio 24, x[1] inicia na posio 28 e x[2] na posio 32.
A mesma estrutura sinttica de arranjos de arranjos, ou arranjos 2-D, pode ser utilizada para
criar arranjos com qualquer nmero de dimenses, seja 3-D ou 4-D, por exemplo, como nos
exemplos:
1 int x [3][2][5]; // Arranjo 3 - D para n meros inteiros
2 double y [4][8][15][26]; // Arranjo 4 - D para n meros reais

Assim como em todos os arranjos, importante lembrar que o primeiro elemento de uma
dimenso sempre tem o ndice 0 e todos os elementos estaro sempre contnuos na memria.
Neste exemplo, vamos trabalhar com arranjos de 2 dimenses:
2
4
5 int main (){
6 double x [3][2];
7 double resultado ;
8 cout << " Digite a nota do aluno 0 na prova 0: " ;
9 cin >> x [0][0];
11 cin >> x [0][1];
13 cin >> x [1][0];
15 cin >> x [1][1];
17 cin >> x [2][0];
19 cin >> x [2][1];
20 resultado = ( x [0][0] + x [1][0] + x [2][0])/3;
21 cout << " Nota m dia na prova 0 = " << resultado << endl ;
22 resultado = ( x [1][0] + x [1][1])/2;
23 cout << " Nota final do aluno 1 = " << resultado << endl ;
24 return 0;
25 }
Criamos no incio do cdigo, na linha 6, um arranjo de duas dimenses com trs linhas e
duas colunas. Assim os ndices vo de x[0][0] at x[2][1] como apresentado:
nome x[0][0] x[0][1]
x[1][0] x[1][1]
x[2][0] x[2][1]
Neste exemplo, faremos com que cada linha da matriz represente um aluno e cada coluna
uma prova feita por ele. Alm do arranjo 2D, que encontra-se ainda vazio, criamos em seguida,
na linha 7, uma varivel que guardar os resultados dos clculos.
nome
resultado
Na linha 8, Pedimos ao usurio para que digite um nota. Na linha 9, guardamos o resultado
em x[0][0].
Digite a nota do aluno 0 na prova 0: 7.3
nome 7.3
resultado
Esta posio x[0][0] se refere primeira linha e a primeira coluna. Nos referimos ento, ao
aluno 0 na prova 0 para o usurio. Apenas para observao, poderamos omitir esta informao
do usurio e mostrar esta combinao como aluno 1 e prova 1. De modo anlogo, nas linhas 10 e
11, damos valores ao elemento x[0][1]:

nome 7.3 5.6
resultado
Nas linhas 12 a 19, fazemos o mesmo para todas as combinaes de aluno e prova.

nome 7.3 5.6
6.5 9.3 resultado
2.6 3.4
Somamos agora, na linha 20, todos os elementos da coluna 0 (x[0][0] + x[1][0] +

x[2][0]) e dividimos por 3. O resultado disto, atribudo a resultado e impresso na linha 21,
ser a nota mdia dos alunos na primeira prova:

Nota media na prova 0 = 5.46667
nome 7.3 5.6
6.5 9.3 resultado 5.46667
2.6 3.4
De modo anlogo, para saber qual foi a nota final do segundo aluno, somamos todos os
elementos da linha 1 (x[1][0] + x[1][1]) e dividimos por 2, que o nmero de colunas, ou
de provas.

Nota media na prova 0 = 5.46667
Nota final do aluno 1 = 7.9
nome 7.3 5.6
6.5 9.3 resultado 7.9
2.6 3.4
5.6 Exerccios
Exerccio 5.1 Suponha um arranjo a com 5 elementos e outro arranjo b com 5 elementos.
Faa um programa que calcule o produto escalar de a por b (Isto , o primeiro elemento de a
multiplicado pelo primeiro elemento de b mais o segundo elemento de a multiplicado pelo
segundo de b mais . . . ).
Digite o primeiro elemento do arranjo a: 6

Digite o segundo elemento do arranjo a: 3
Digite o terceiro elemento do arranjo a: 4
Digite o quarto elemento do arranjo a: 8
Digite o quinto elemento do arranjo a: 3
Digite o primeiro elemento do arranjo b: 2

5.6 Exerccios 67
Digite o segundo elemento do arranjo b: 6
Digite o terceiro elemento do arranjo b: 7
Digite o quarto elemento do arranjo b: 2
Digite o quinto elemento do arranjo b: 5
O produto escalar de a[] por b[] 89
Exerccio 5.2 Fazer um algoritmo que:

1. Crie um arranjo de 5 elementos e o preencha de nmeros
2. Procure a posio do menor elemento deste arranjo
3. Troque o menor elemento com elemento da primeira posio
4. Imprima os elementos do arranjo
Digite o primeiro elemento do arranjo: 6

Digite o segundo elemento do arranjo: 3
Digite o terceiro elemento do arranjo: 4
Digite o quarto elemento do arranjo: 2
Digite o quinto elemento do arranjo: 8
O menor elemento deste arranjo est na posio a[3]
Novo arranjo: 2 3 4 6 8

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 6.0Estruturas
0
1 0 de repetio
1
0 0 1
0
01 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Um motivo pelo qual os computadores nos auxiliam muito em tarefas porque so capazes
de repetir tarefas milhes ou bilhes de vezes sem cometer erros. Este tipo de repetio poderia
demorar sculos para ns, porm, so simples para essas mquinas.
Imagine quanto tempo levaria enviar uma carta para um milho de pessoas. Compare agora
com o tempo gasto para se enviar um e-mail para um milho de pessoas.
As estruturas de repetio nos permitem realizar instrues repetidamente enquanto uma
condio for verdadeira, como apresentado na Figura 6.1. Por retornar a um comando anterior no
cdigo, estruturas de repetio tambm so chamadas de instrues de loop, ou lao. Usualmente,
os laos so repetidos um certo nmero de vezes ou at que algo acontea.
6.1 Laos com contadores

O caso mais simples de repetio aquele no qual queremos repetir exatamente a mesma
tarefa um certo nmero de vezes.
Quando queremos que um bloco de comandos se repita um certo nmero de vezes,
usamos uma varivel contadora para guardar quantas vezes o bloco j foi executado. A varivel
contadora deve ser um nmero inteiro e pode ter qualquer nome identificador. Usualmente, ela
leva tem o nome identificador de i, o que facilita o seu uso repetido. Cada repetio do lao
chamada de iterao.
6.1.1 Controle de fluxo-For

A instruo for utilizada para repeties controladas por uma varivel contadora. Ela tem
a sintaxe apresentada.
1 for ( inicializa o ; condi o ; incremento ){
2 comandos ;
3 }
A inicializao deste comando utilizada para inicializar a varivel contadora. A
condio deste comando utilizada para que a repetio continue acontecendo. Ela testa,
70 Captulo 6. Estruturas de repetio
Comandos
Comandos
Condio
Comandos
Figura 6.1: Representao de um programa com estrutura de repetio.
usualmente, se o contador atingiu um valor final. O incremento a onde dizemos como ser
incrementada a varivel contadora aps cada repetio. Normalmente, somamos 1 varivel
contadora.
Podemos colocar quantos comandos quisermos dentro do bloco de comandos de for. In-
clusive, podemos colocar ali outras estruturas condicionais e at mesmo outras estruturas de
repetio.
6.1.2 Repetio controlada por contador

Um contador utilizado em uma repetio precisa de: um nome identificador, um valor
inicial, um valor final, e um incremento a cada passo.
Veja um exemplo para um bloco de comandos que ser repetido 10 vezes.
1 for ( i = 0; i < 10; i ++){
2 comandos ;
3 }
No exemplo, a inicializao representada por uma varivel i recebendo 0 (i = 0). A
condio de repetio que i seja menor que 10. E a cada repetio feita devemos incrementar
i em 1 (i++). Essa a estrutura bsica pra repetir um bloco de comandos 10 vezes.
A instruo diz que o contador i comea em 0 e repetimos os comandos enquanto ele for
menor do que 10. A cada repetio ele incrementado em 1.
Neste exemplo, temos um programa que imprime uma mesma mensagem 10 vezes:
2
4
5 int main (){
6 int i ; // contador
7 for ( i = 0; i < 10; i ++){
6.1 Laos com contadores 71
8 cout << " Ol mundo ! " << endl ;

9 }
10 return 0;
11 }
Para imprimir a mensagem seguidas vezes, criamos uma varivel contadora i, na linha 6.
Quando entramos no lao, na linha 7, a varivel contadora inicializada com 0. A condio i
< 10 testada e o bloco de comandos ser executado porque i < 10 true. Todo o bloco da
linha 8 , ento, executado.
Ol mundo!
i 0
Ao fim da execuo do bloco, o comando de incremento i++ executado e i passa a ter

valor 1. A condio de parada i < 10 testada e o comando ser executado pois 1, valor de i
aps incremento, ainda menor que 10.
Ol mundo!
Ol mundo!
i 1
Veja que quando i 2, i < 10 tambm verdadeiro. E assim em diante.
Ol mundo!
Ol mundo!
Ol mundo!
i 2
Aps as 10 iteraes deste lao, teremos o seguinte estado, com i igual a 9 e 10 mensagens
impressas:
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
i 9
Ao fim da ltima repetio do lao, i chega a 10 atravs do incremento i++ e ento, a

condio i < 10 falsa. Assim, o bloco no ser mais executado e este o fim deste programa.
i 10
6.2 Repeties determinadas pelo usurio

Compare agora estes dois programas. Apesar do segundo no usar estruturas de repetio, os
dois imprimem o mesmo resultado na tela.
2
4
5 int main (){
6 int i ; // contador
7 for ( i = 0; i < 10; i ++){
9 }
10 return 0;
11 }
1 include < iostream >

2
4
5 int main (){
16 return 0;
17 }
No primeiro exemplo, podemos ver que o comando for nos permitiu no precisar reescrever
o comando vrias vezes. Um programa sequencial que simula o mesmo comportamento pode ser
muito extenso. Imagine um caso onde fazemos milhes de repeties.
Na maior parte dos problemas, nem mesmo possvel fazer uma verso sequencial equiva-
lente. Um exemplo disso quando no sabemos quantas vezes o comando ser repetido. Isso
ocorre, por exemplo, em problemas onde o usurio decide quantas vezes um bloco de comandos
ser repetido.
6.3 Repetio de processos similares 73
Neste prximo exemplo, temos um cdigo onde o usurio determina o nmero de repeties
do bloco:
2
4
5 int main (){
6 int i ;
7 int n ;
8 cout << " Quantas vezes voc quer a mensagem ? " ;
9 cin >> n ;
10 for ( i = 0; i < n ; i ++){
12 }
13 return 0;
14 }
Neste exemplo, aps criada a varivel contadora, na linha 6, criada uma varivel para o
nmero de repeties, na linha 7. Esta mesma varivel, na linha 9, recebe do usurio a quantidade
de vezes que ele deseja ver a mensagem. No caso, ele escolhe ver a mensagem 6 vezes:
Quantas vezes voc quer a mensagem? 6
i n 6
O lao que se inicia na linha 10 repete o bloco de comandos e incrementa o contador enquanto
a condio for verdadeira. A condio se torna falsa quando a mensagem impressa n vezes e
ento encerramos o programa.
Quantas vezes voc quer a mensagem? 6

Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
Ol mundo!
i 6 n 6
6.3 Repetio de processos similares

Nos ltimos exemplos repetimos os mesmos comandos vrias vezes. Mas nem sempre
exatamente isto o que acontece. comum, tambm, repetir tarefas que sejam similares de acordo
com a repetio do lao. Por exemplo, uma companhia pode enviar uma mensagem desejando
um feliz ano novo para todos os seus clientes. Apesar de ser uma tarefa de repetio, cada
mensagem possui algumas diferenas, como o nome do cliente.
Usualmente, uma mudana nas prprias condies das variveis pode alterar como a repetio
se comporta. Um exemplo disso, quando usamos o contador dentro do prprio bloco de
repetio.
Neste exemplo, criaremos uma estrutura de repetio onde cada iterao do bloco ter um
resultado diferente:
2
4
5 int main () {
6 int i ;
7 int n ;
8 cout << " Digite o n mero final : " ;
9 cin >> n ;
10 for ( i = 0; i <= n ; i ++){
11 cout << i << " " ;
12 }
13 return 0;
14 }
No exemplo, a varivel contadora ser utilizada dentro do prprio bloco do for para imprimir
os nmeros de 0 at n.
Assim que criada a varivel contadora, na linha 6, cria-se tambm a varivel com o nmero
final da sequncia impressa, na linha 7. O usurio, ento, nas linhas 8 e 9, escolhe um nmero
final para a sequncia. No caso, ele escolhe 5:
Digite o nmero final: 5
i n 5
Na linha 10, o contador i inicializado com 0 e a condio i <= n testada. Repare que
neste exemplo testamos se i <= n e no i < n. Isso ocorre porque queremos tambm imprimir
o nmero n. Na linha 11, o contador i impresso e seguido de um espao.

0
i 0 n 5
Logo aps a impresso, i incrementado (i++), a condio testada novamente e imprimi-

mos o valor de i.

0 1
i 1 n 5
6.4 Alterando variveis externas 75
Neste exemplo, a condio para continuar o lao que i <= 10, pois queremos imprimir o
nmero n tambm. O contador i incrementado e ainda menor ou igual a n.

0 1 2
i 6 n 5
Ao continuar executando o lao, todos os nmeros menores ou iguais a 5 sero impressos at

que i seja 6.

0 1 3 4 5
i 6 n 5
Vale lembrar que o programa pode aceitar qualquer nmero n como entrada do usurio. Caso
o nmero digitado fosse 56, teramos impresso todos os valores entre 0 e 56.

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56
i 57 n 56
6.4 Alterando variveis externas

Algumas vezes, usamos estruturas de repetio tambm para alterar o valor de variveis
externas ao bloco de repetio. Um exemplo disso quando fazemos o somatrio de vrios
valores. A estrutura de repetio faz o clculo do somatrio com uma varivel auxiliar, que ser
impressa aps todo o processo.
Neste exemplo, uma varivel soma ser usada para calcular o somatrio de todos os nmeros
de 1 at n:
2
4
5 int main () {
6 int i ;
7 int n ;
8 int soma ;
10 cin >> n ;
11 soma = 0;
12 for ( i = 1; i <= n ; i ++){

13 soma += i ;
14 }
15 cout << " Somat rio = " << soma << endl ;
16 return 0;
17 }
Como fizemos nos ltimos exemplos, aps criada a varivel contadora, na linha 6, criada
tambm a varivel para o nmero final da srie, na linha 7. Na linha 8, uma outra varivel
criada para guardar o somatrio dos nmeros. Neste exemplo, nas linhas 8 e 9, a varivel n para
o nmero final da srie recebe do usurio o nmero 4, enquanto soma inicializada com 0 na
linha 11:
i n 4 soma 0
O nosso somatrio comea em 0 e ser incrementado durante o lao. O contador i se inicia

agora, na linha 12, em 1, pois no precisamos somar 0. O lao se repetir enquanto i for menor
ou igual ao nmero digitado pelo usurio. Veja que, na linha 13, acumulamos cada valor de i
soma. Assim, o valor final de soma ser igual a 1 + 2 + 3 + 4. O resultado impresso 10.

Somatrio = 10
i 5 n 4 soma 10
Outro exemplo de nmero escolhido pelo usurio seria 100:
i n 100 soma 0
Perceba como estruturas de repetio nos permitem realizar tarefas muito mais complexas.

Somatrio = 5050
i 101 n 100 soma 5050

6.5 Aninhando estruturas de controles 77
6.5 Aninhando estruturas de controles

possvel combinar estruturas de repetio com outras estruturas de controle. Isso pode ser
feito, por exemplo, para garantir na repetio que existam determinadas condies.
Veja este exemplo onde faremos o somatrio de nmeros mltiplos de 3.
2
4
5 int main () {
6 int i ;
7 int n ;
8 int soma ;
10 cin >> n ;
11 soma = 0;
12 for ( i = 1; i <= n ; i ++){
13 if ( i % 3 == 0){
14 soma += i ;
15 }
16 }
18 return 0;
19 }
Neste exemplo, s adicionaremos um nmero ao somatrio se este for mltiplo de 3. A soma
ser ento (3 + 6 + 9 + 12 ...).
Nas linhas 6 a 11 so criadas e inicializadas as variveis. O usurio define o valor100 para a
varivel n:
i n 100 soma 0
Na repetio, definida na linha 12, o contador i inicia em 1 novamente, pois no precisamos

somar 0. Logo na linha 13, se o resto da diviso de i por 3 for igual a 0, o comando da linha 14
executado. Na primeira iterao, como i % 3 == 0 false, nada acontece.
i 1 n 100 soma 0
Continuamos nosso cdigo e, quando a condio i % 3 == 0 verdadeira, este valor de i

ser adicionado soma. Esse processo se repete at que i seja 101 e a condio de repetio
seja false. Ao final temos ento o somatrio total de todos os nmero menores que 1000 e
mltiplos de 3, que 1683:

Somatrio = 1683
i 101 n 100 soma 1683
6.6 Condies de inicializao

A condio de inicializao de um for pode ser qualquer expresso. Suponha que queremos
calcular o resultado da seguinte srie:
5 7 9 11 99
+ + + ++
3 4 5 6 50
Para isto, podemos somar elementos calculador em uma repetio onde o contador i vai de
3 a 50. Nesta srie, a cada repetio somamos o elemento:
2i 1
i
Neste exemplo, vamos utilizar um contador i inicializado em 3 para calcularmos esta srie.
2
4
5 int main () {
6 int i ;
7 int n ;
8 double soma ;
9 double numerador ;
10 double denominador ;
11 cout << " Digite o contador final : " ;
12 cin >> n ;
13 soma = 0;
14 for ( i = 3; i <= n ; i ++){
15 numerador = 2* i -1;
16 denominador = i ;
17 soma += numerador / denominador ;
18 }
20 return 0;
21 }
Nas linhas 6 a 13 inicializamos os variveis necessrias pelo programa. O usurio define um
valor final para n de 50, que o ltimo nmero da srie.
Digite o contador final: 50

numera denomi
i n 50 soma 0
dor nador
Entramos na estrutura de repetio na linha 14. Veja que a condio de inicializao que i
= 3. Fazemos isto pois 3 o primeiro valor de i em nossa srie. Nas linhas 15 a 17, a varivel
soma recebe o resultado de 5/3 na primeira iterao, quando i 3.
numera denomi
i 3 n 50 soma 1.6666 5 3
dor nador
Aps cada iterao da repetio, incrementamos o i e testamos a condio do lao. Na

segunda iterao, soma incrementado de 7/4.
numera denomi
i 4 n 50 soma 3.4166 7 4
dor nador
Esse processo se repete at que i seja n+1, ou 51. Neste ponto, o resultado do somatrio
impresso na linha 19:
Digite o contador final: 50

Somatrio = 93.0008
numera denomi
i 51 n 50 soma 93.0008 99 50
dor nador
6.7 Condies de incremento

As condies de incremento de um for tambm podem ser alteradas com qualquer outra
expresso. H vrios motivos pelos quais faramos isso:
Para alterar a condio de incremento e dar saltos mais largos na varivel contadora. Por
exemplo, i pode aumentar em 7 a cada iterao.
Podemos utilizar outra operao, por exemplo, i dobrar a cada iterao.
Podemos at mesmo decrementar a varivel contadora a cada passo, por exemplo, i
diminuir em 1 a cada iterao.
Neste exemplo, calcularemos a soma de todos os mltiplos de 7 menores que um certo
nmero limite. Temos ento 7 + 14 + 21 + 38....
2
4
5 int main () {
6 int i ;
7 int n ;
8 double soma ;
10 cin >> n ;
11 soma = 0;
12 for ( i = 7; i <= n ; i += 7){
13 soma += i ;
14 }
16 return 0;
17 }
As variveis so criadas e inicializadas nas linhas 6 a 11, onde o usurio escolhe 1000 como
um valor limite para o somatrio:
i n 1000 soma 0
Na linha 12, o contador i j inicializado com 7, o primeiro nmero da srie. Como o

contador i menor ou igual ao o nmero final n, executamos os comandos do bloco:
i 7 n 1000 soma 7
Na estrutura de repetio, j incrementamos i em 7 para a prxima iterao com i += 7. O

processo se repetir enquanto i <= 1000.

Somatrio = 71071
i 1001 n 1000 soma 71071
Veja como neste exemplo utilizamos uma expresso diferente de incremento. Com a nova
expresso no precisamos testar se i multiplo de 7 pois j sabemos que apenas mltiplos de 7
sero atribudos a i.
Neste segundo exemplo, vamos imprimir todas as potncias de 2 entre 2 e um nmero n
qualquer. Por exemplo, 2, 4, 8, 16, 32, 64, 128 e assim em diante.
2
4
5 int main () {
6 int i ;
7 int n ;
9 cin >> n ;
10 for ( i = 2; i < n ; i *=2){
11 cout << i << " " ;
12 }
13 return 0;
14 }
Nas linhas 6 e 9 so criadas e inicializadas as variveis, onde o usurio define 10000 como
um valor limite:
Digte o nmero final: 10000
i n 10000
Na linha 10, o contador i inicializado em no primeiro item da srie, que 2. O valor de i

impresso na linha 11:

2
i 2 n 10000
A operao de incremento multiplica i por 2, o transformando em 4.

2 4
i 4 n 10000
Esse processo se repete enquanto i for menor que 10000.

2 4 8 16 32 64 128 256 512 1024 2048 4096 8192
i 16384 n 10000
No terceiro exemplo, vamos imprimir uma sequncia de n at 1. Por exemplo: n, n-1, n-2,
n-3 e assim em diante.
2
4
5 int main () {
6 int i ;
7 int n ;
8 cout << " Digite o n mero inicial : " ;
9 cin >> n ;
10 for ( i = n ; i > 0; i - -){
11 cout << i << " " ;
12 }
13 return 0;
14 }
Nas linhas 6 a 9 temos as variveis criadas e inicializadas, onde o usurio d a n o primeiro

numero da srie, no caso 50.
Digite o nmero inicial: 50
i n 50
Na estrutura de repetio, na linha 10, i inicializado nesse primeiro item da srie, que n.
Seu valor impresso na linha 11:

50
i 50 n 50
O bloco de comandos se repetir enquanto i for maior que 0. Repare agora que a expresso
de incremento neste exemplo diminui o valor de i.

50 49
i 49 n 50
Assim, enquanto i > 0, todos os nmeros entre 50 e 1 so impressos.

50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28
27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
i 0 n 50
6.8 Percorrer arranjos

Os arranjos so bastante relacionados instruo for. Como arranjos tm um nmero grande
de elementos, inicializ-los um por um uma tarefa muito repetitiva. Nestes casos, a prpria
varivel contadora do for pode ser utilizada dentro do bloco de repetio como ndice para
elementos do arranjo.
Neste exemplo, vamos dar valores s posies de um arranjo com uma estrutura de repetio:
2
4
5 int main () {
6 const int n = 5;
7 double notas [ n ];
8 double soma ;
9 int i ;
10 for ( i =0; i < n ; i ++) {
11 cout << " Digite a nota do aluno " <> notas [ i ];
13 }
14 soma = 0;
15 for ( i = 0; i < n ; i ++) {
16 soma += notas [ i ];
17 }
18 cout << " M dia das notas : " << soma / n << endl ;
19 return 0;
20 }
Logo na linha 6, primeira linha da nossa funo principal main(), criamos um int que tem
valor 5. A instruo const que acompanha int indica que esta uma constante em vez de uma
varivel. O valor de uma constante no pode ser alterada ao longo do programa.
Criamos um arranjo chamado notas, na linha 7. Apenas constantes podem definir o tamanho
de arranjos em C++. A varivel soma criada na linha 8 para receber a soma de todas as notas
do arranjo. A linha 9 cria a varivel contadora i.
soma i n 5
notas
notas[0] notas[1] notas[2] notas[3] notas[4]
Na estrutura de repetio, definida na linha 10, a varivel contadora i inicializa em 0 para

trabalhar com notas[0]. Como i 0, sempre que nos referirmos a notas[i] estaremos nos
referindo a notas[0]:
soma i 0 n 5
notas
notas[i]
Na linha 11, pedimos agora para o usurio que insira a nota do aluno do primeiro aluno, o
aluno que est na posio i, ou 0, do arranjo. O resultado digitado pelo usurio guardado em
notas[i] (que no caso notas[0]).
Digite a nota do aluno 0: 6.7

soma i 0 n 5
notas 6.7
notas[i]
Na expresso de incremento i++, passamos ento para o prximo aluno i. Note que com
a alterao do valor de i, notas[i] passa a representar outra posio do arranjo. Assim, para
cada posio i do arranjo, damos um valor de nota nas linhas 11 e 12.

soma i 1 n 5
notas 6.7 7.8
notas[i]
Aps a ltima iterao da estrutura de repetio, notas[i] passa a representar notas[5],

que uma posio fora do arranjo. O programa daria um erro de tentssemos acessar notas[i].
Porm, veja que a condio de repetio no atendida e prosseguimos com o cdigo.

soma i 5 n 5
notas 6.7 7.8 4.2 9.4 8.3
notas[i]
A varivel soma, ento, na linha 14, inicializada em 0. Utilizaremos esta varivel para
fazermos um somatrio das notas no arranjo. Diferentemente dos exemplos anteriores somaremos
notas na posio i em vez de, apenas, i, o ndice.
soma 0 i 5 n 5
notas 6.7 7.8 4.2 9.4 8.3
notas[i]
Ento, i volta a ser 0 na nova estrutura de repetio da na linha 15 e, notas[i] volta a

indicar notas[0]. Veja que a soma, na linha 16, incrementado de notas[0].
soma 6.7 i 0 n 5
notas 6.7 7.8 4.2 9.4 8.3
notas[i]
Agora, na segunda iterao da estrutura de repetio, soma incrementado de notas[1].
soma 14.5 i 0 n 5
notas 6.7 7.8 4.2 9.4 8.3
notas[i]
E ao fim de todo o processo processo de repetio, soma ter o somatrio de todas as notas
no arranjo, que 36.4, e i ter valor 5, colocando notas[i] fora do arranjo novamente. Na
linha 18, a soma das notas dividida por n nos permite imprimir a nota mdia nas provas.

Mdia das notas: 7.28
soma 36.4 i 0 n 5
notas 6.7 7.8 4.2 9.4 8.3
notas[i]
6.9 Laos aninhados

Vimos na seo 6.5 a juno de estruturas de repetio com estruturas de seleo. As
estruturas de repetio podem ser combinadas tambm com outras estruturas de repetio para
uma diversidade de tarefas que envolvem repeties dentro de repeties. Inclusive, o contador
de uma estrutura de repetio pode servir de referncia para o contador da outra estrutura mais
interna.
Neste exemplo, usaremos dois contadores, i e j, que sero usados como contadores ao
mesmo tempo para imprimir vrios valores diversas vezes.
2
4
5 int main () {
6 int i ;
7 int j ;
8 int n ;
10 cin >> n ;
11 for ( i =1; i <= n ; i ++) {
12 for ( j =0; j < i ; j ++){
13 cout << i ;
14 }
15 cout << endl ;
16 }
17 return 0;
18 }
Neste cdigo, para cada valor de i do for mais externo, um for interno vai imprimir i vezes
o prprio valor i. O for mais interno utilize a varivel j como contador. Depois do for interno,
ser dada uma quebra de linha com endl.
Nas linhas 6 a 10, inicializamos as variveis e o usurio define que o valor de n ser 5.
Digite um nmero: 5
i j n 5
Veja que, no primeira lao de repetio, na linha 11, i comea em 1 e ele ir at n.
i 1 j n 5
Na linha 12, j comea em 0 no segundo lao de repetio e ele ir at i-1. Ou seja, para
cada valor de i em uma iterao no lao externo, este lao interno ocorre i vezes.
i 1 j 0 n 5
Perceba que aps o lao mais interno, na linha 15, endl passa para a prxima linha encer-
rando, assim, uma iterao do lao externo.
6.9 Laos aninhados 87
Digite um nmero: 5
1
i 1 j 1 n 5
Enfim, i incrementado para 2. Na primeira iterao do lao interno, i, ou 2, impresso

uma vez.
Digite um nmero: 5
1
2
i 2 j 0 n 5
Na segunda iterao, i impresso uma segunda vez:
Digite um nmero: 5
1
22
i 2 j 1 n 5
A fim da segunda iterao, j passa a valer 2 e o lao interno se encerra.Veja que o lao
interno imprime sempre i vezes o valor de i. E endl passa para a prxima linha.
Digite um nmero: 5
1
22
i 2 j 2 n 5
O contador i mais uma vez incrementado para 3 e seguiremos ento, para a prxima
iterao. Nesta prxima iterao, o valor de i impresso 3 vezes no lao mais interno.
Digite um nmero: 5
1
22
333
i 3 j 3 n 5
Esse processo se repete at que i seja igual a 6, interrompendo assim o lao de repetio na
linha 11.
Digite um nmero: 5
1
22
333
4444
55555
i 6 j 5 n 5
6.10 Percorrendo arranjos de arranjos

Uma das aplicaes mais comuns para laos alinhados percorrer arranjos de arranjos.
Como vimos, estes tipos de arranjos so muito utilizados para representar matrizes ou tabelas.
Enquanto o lao externo percorre linhas com contador i, o lao mais interno percorre colunas
com o contador j.
Neste prximo exemplo, criaremos um arranjo de arranjos (ou arranjo multidimensional)
para representar uma tabela de notas e alunos. Cada coluna de nossa tabela representa uma
prova e cada linha representa um aluno. Um lao externo percorre todas as linhas do arranjo
bidimensional. Um lao interno percorre todas as colunas de uma linha.
2
4
5 int main () {
6 const int n1 = 10;
7 const int n2 = 3;
8 int i ;
9 int j ;
10 double soma ;
11 double notas [ n1 ][ n2 ];
12 for ( i =0; i < n1 ; i ++) {
13 cout << " Digite as notas do aluno " <> notas [ i ][ j ];
17 }
18 }
19 for ( j =0; j < n2 ; j ++) {
20 soma = 0;
21 for ( i =0; i < n1 ; i ++){
22 soma += notas [ i ][ j ];
23 }
24 cout << " M dia na prova " << j << " : " ;
25 cout << soma / n1 << endl ;
26 }
27 return 0;
28 }
Temos um lao interno nas linhas 14 a 17 e um lao mais externo nas linhas 12 a 18. Este
lao interno percorre todas as colunas j de uma linha i. A linha i definida pelo lao mais
externo.
Nas linhas 6 a 11, criamos e inicializamos todas as variveis. As constantes n1 e n2 definem

o nmero de linhas e colunas na tabela.
notas
n1 10 n2 3
i j
soma
Veja que no lao mais externo, na linha 12, para cada linha i, que representa um aluno,
imprimimos uma mensagem, na linha 13, pedindo as notas do aluno. Ainda para este aluno i,
comeamos na linha 14 um lao mais interno com o contador j. Este lao mais interno, nas
linhas 15 e 16, pedem a nota do aluno i em cada prova j, ou seja, notas[i][j]. Na primeira
iterao, i tem valor 0. O lao mais interno utiliza j para percorrer ento as colunas 0, 1 e 2
deste aluno i.
Digite as notas do aluno 0

Prova 0: 6.8
Prova 1: 7.9
Prova 2: 7.6
notas 6.8 7.9 7.6
n1 10 n2 3
i 0 j 3
soma
Como no acabaram os alunos, vejamos a prxima iterao, quando o valor de i 1. Essa

iterao faz o mesmo para a linha seguinte da tabela.

Prova 0: 6.8
Prova 1: 7.9
Prova 2: 7.6
Prova 0: 5.4
Prova 1: 6.8
Prova 2: 9.8
notas 6.8 7.9 7.6
5.4 6.8 9.8
n1 10 n2 3
i 0 j 3
soma
J o conjunto de todas as iteraes no lao mais externo completa a tabela e nos envia para a
linha 19 do cdigo.
...
Prova 1: 6.8
Prova 2: 9.3
Prova 0: 8.3
Prova 1: 6.9
Prova 2: 7.3
Prova 0: 7.2
Prova 1: 9.5
Prova 2: 7.8
notas 6.8 7.9 7.6
5.4 6.8 9.8
n1 10 n2 3 8.6 9.5 8.2
7.6 8.7 6.8
5.8 7.2 9.5

i 10 j 3
9.5 7.3 8.8
6.7 8.8 10
6.2 6.8 9.3

soma
8.3 6.9 7.3
7.2 9.5 7.8
Na linha 19, temos um outro lao mais externo. O prximo lao externo utilizar jcom
contador para percorrer as colunas j da tabela. Para cada coluna calcularemos a sua mdia. A
soma desta coluna j comea, ento, em 0, como feito na linha 20. Nas linhas 21 a 23, para cada
linha i desta coluna j, incrementamos o valor de notas[i][j] a soma. Nas linhas 24 e 25,
imprimimos a mdia do somatrio desta coluna.
...
Prova 1: 6.8
Prova 2: 9.3
Prova 0: 8.3
Prova 1: 6.9
Prova 2: 7.3
Digite as notas do aluno
Prova 0: 7.2
Prova 1: 9.5
Prova 2: 7.8
Mdia na prova 0: 7.21
notas 6.8 7.9 7.6
5.4 6.8 9.8
n1 10 n2 3 8.6 9.5 8.2
7.6 8.7 6.8
5.8 7.2 9.5

i 10 j 0
9.5 7.3 8.8
6.7 8.8 10
6.2 6.8 9.3

soma 71.2
8.3 6.9 7.3
7.2 9.5 7.8
Na execuo de todo o lao externo, fazemos o mesmo com as outras colunas. Este o fim
deste programa.
...
Prova 1: 6.8
Prova 2: 9.3
Prova 0: 8.3
Prova 1: 6.9
Prova 2: 7.3
Digite as notas do aluno
Prova 0: 7.2
Prova 1: 9.5
Prova 2: 7.8
notas 6.8 7.9 7.6
5.4 6.8 9.8
n1 10 n2 3 8.6 9.5 8.2
7.6 8.7 6.8
5.8 7.2 9.5

i 10 j 3
9.5 7.3 8.8
6.7 8.8 10
6.2 6.8 9.3

soma 85.1
8.3 6.9 7.3
7.2 9.5 7.8
6.11 Utilizando apenas critrio de parada

muito comum repetir comandos no apenas uma certa quantidade de vezes, como tambm
at que uma condio ocorra. Por exemplo, quando esfregamos um prato at que ele esteja limpo.
No sabemos quantas vezes vamos esfregar, mas faremos isto at que esteja limpo.
s vezes, queremos que um bloco de comandos seja repetido at que uma certa condio
ocorra mas esta condio no est associada especificamente a um contador. Nestes casos, a
instruo for, por depender de um contador, pode parecer inapropriada. Usamos o comando
while (enquanto, em ingls), para definir a condio do lao.
Na sintaxe da instruo a seguinte:
1 while ( condi o ){
2 comandos ;
3 }
Enquanto a condio entre parnteses for atendida, o bloco de comandos ser executado.
Repare que, diferentemente do comando for, no h comandos para inicializao ou incremento,
pois o while no est diretamente ligado a um contador.
No exemplo seguinte, enquanto o nmero digitado for diferente de 0, o usurio digitar um
nmeros que sero elevados ao quadrado e impressos.
1 int numero = 1;
2 while ( numero != 0){
4 cin >> numero ;
5 cout << " N mero ao quadrado = " ;
6 cout << numero * numero << endl ;
7 }
No exemplo desta seo, colocaremos uma estrutura deste tipo em nosso programa.
2
4
5 int main () {
6 int numero = 1;
9 cin >> numero ;
10 cout << " N mero ao quadrado = " << numero * numero << endl ;
11 }
12 return 0;
13 }.
Na linha 6, criamos uma varivel numero que inicializada com valor 1.
numero 1
A instruo while da linha 7 diz que repetiremos o bloco de comandos enquanto o valor de
numero for diferente de 0. Como numero diferente de 0, a condio de repetio verdadeira
e executaremos os comandos das linhas 8 a 10.
Digite um nmero: 7
Nmero ao quadrado: 49
numero 7
Como o valor de numero ainda diferente de 0, a condio da linha 7 verdadeira e os

comandos das linhas 8 a 10 so executados novamente.
Digite um nmero: 7
Digite um nmero: 5
numero 5
No h um nmero definido de repeties. Este processo continua at que o usurio digite 0,

com a condio retornando false e samos do lao.
Digite um nmero: 7
Digite um nmero: 5
Digite um nmero: 0
numero 0
6.11.1 Relao entre while e for

Considere a estrutura de um while:
2 comandos ;
3 }
Para se ter o efeito de um while com um for, basta deixar em branco as condies de
inicializao e de incremento deste for, como apresentado:
1 for ( ; condi o ; ){
2 comandos ;
3 }
Quando queramos repetir um bloco enquanto o nmero fosse diferente de 0, utilizamos a
seguinte estrutura while:
3 cin >> numero ;
6 }
Poderamos ter feito o mesmo com uma instruo for. Neste caso, o for teria apenas sua
condio de repetio.
1 for (; numero != 0;){
3 cin >> numero ;
6 }
Por outro lado, considere a sintaxe de um for:
1 for ( inicializa o ; condi o ; incremento ){
2 comandos ;
3 }
Para termos o efeito de um for com um while, basta inicializar e incrementar o contador
com um comandos prprios:
1 inicializa o ;
3 comandos ;
4 incremento ;
5 }
Por exemplo, se um contador vai de 0 at 9 para imprimirmos uma sequncia, utilizariamos
o seguinte for:
1 for ( i = 0; i < 10; i ++){
2 cout << i << endl ;
3 }
O mesmo efeito pode ser obtido com um while, onde podemos fazer a inicializao antes
de iniciar a repetio. Aps os comandos originais do bloco, incrementamos com um comando
prprio o valor do contador.
1 i = 0;
2 while ( i < 10){
3 cout << i << endl ;
4 i ++;
5 }
Embora seja tecnicamente possvel converter um for em um while e vice-versa, a estrutura
mais apropriada deve ser utilizada em cada ocasio. Utilize for para repeties baseadas em
contadores. Utilize while para repeties dependentes de condies especficas de parada.
6.11.2 Laos infinitos

necessrio tomar cuidado em relao aos laos infinitos, ou seja, os laos onde a condio
de repetio sempre verdadeira e por isso nunca encerram. Isto pode ser feito propositalmente
com um while ou for que tenha true como condio de repetio:
1 while ( true ){
2 comandos ;
3 }
1 for ( inicializa ; true ; incremento ){

2 comandos ;
3 }
necessrio garantir que a condio em algum momento ser falsa.
6.12 Adiando o critrio de parada

Existe ainda uma situao onde s sabemos se a condio de repetio ser atendida aps a
primeira iterao. Este caso bem comum em menus, onde uma das opes sair. Para estes
casos, existe a a instruo do-while. No do-while, os comandos so sempre executados uma
vez antes que algum teste seja feito.
1 do {
2 comandos ;
3 } while ( condi o );
Neste exemplo, repare que um menu apresentado e cada opo faz uma tarefa:
1 int x = 5;
2 int y = 7;
3 int opcao ;
4 do {
5 cout << " [1] Somar " << endl ;
6 cout << " [2] Multiplicar " << endl ;
7 cout << " [0] Sair do programa " << endl ;
8 cout << " Digite uma opcao : " ;
9 cin >> opcao ;
10 if ( opcao == 1){
11 cout << x + y << endl ;
12 } else if ( opcao == 2){
6.13 Exerccios 97
13 cout << x * y << endl ;

14 }
15 } while ( opcao != 0);
Este menu apresentado enquanto a opo do usurio no for 0. Esta a condio perfeita
para um do-while, pois um caso onde a primeira iterao sempre deve acontecer para
determinar as prximas. S sabemos aps a primeira iterao se a opo ser sair.
6.12.1 Relao entre do-while e while

possvel obter o efeito de um do-while com um while se repetirmos o comando da
primeira iterao antes do lao. Considere a sintaxe do do-while:
1 do {
2 comandos ;
O mesmo efeito pode ser obtido com a instruo while:
1 comandos ;
2 while ( condi o ) {
3 comandos ;
4 }
Perceba que a repetio dos comandos antes do lao garante que eles sero executados pelo
menos uma vez. Isto, porm, uma soluo pouco desejvel pois estamos repetindo cdigo
desnecessariamente. Assim, apesar de ser tecnicamente possvel usar qualquer instruo,
sempre melhor utilizar a estrutura mais apropriada em cada caso.
6.13 Exerccios
Arranjos no podem ser utilizados nestes primeiros exerccios.
Exerccio 6.1 Faa um programa que apresente um menu de opes para o clculo das
seguintes operaes entre dois nmeros: adio, subtrao, multiplicao e diviso. O
programa deve solicitar dois nmeros e possibilitar ao usurio a escolha da operao desejada,
exibindo o resultado e a voltar ao menu. O programa s termina quando for escolhida a opo
de sada.
Exemplo de sada:
[1] Adio
[2] Subtrao
[3] Multiplicao
[4] Diviso
[0] Sair
Escolha uma opo: 3
Digite um nmero: 5.2
Digite outro nmero: 7.5
5.2 * 7.5 = 39.0
[1] Adio
[2] Subtrao
[3] Multiplicao
[4] Diviso
[0] Sair
Escolha uma opo: 4
Digite um nmero: 4.3
Digite outro nmero: 6.7
4.3 * 6.7 = 0.64
[1] Adio
[2] Subtrao
[3] Multiplicao
[4] Diviso
[0] Sair
Escolha uma opo: 0
Obrigado por utilizar a calculadora.
Exerccio 6.2 Escrever um algoritmo que l n valores, um de cada vez, e conta quantos
destes valores so pares, escrevendo esta informao.
Exemplo de sada:
Quantos valores deseja ler? 7

Digite um nmero: 6
Digite um nmero: 3
Digite um nmero: 5
Digite um nmero: 4
Digite um nmero: 2
Digite um nmero: 8
Digite um nmero: 5
Voc digitou 4 nmeros pares e 3 nmeros mpares
Exerccio 6.3 Escreva um programa que receba a idade de n pessoas, calcule e imprima: a
quantidade de pessoas em cada faixa etria; a porcentagem de cada faixa etria em relao ao
total de pessoas.
As faixas etrias so:
1 a 15 anos
16 a 30 anos
31 a 45 anos
46 a 60 anos
61 anos
Exemplo de sada:
Quantas idades deseja digitar? 10

Digite a idade da pessoa 1: 6
6.13 Exerccios 99
Faixa etria:
1 a 15 anos - 20.0%
16 a 30 anos - 20.0%
31 a 45 anos - 40.0%
46 a 60 anos - 0.0%
Mais de 60 anos - 20.0%
Exerccio 6.4 Escreva um programa que receba um nmero inteiro e verifique se o nmero
fornecido primo ou no. O nmero primo se ele tiver apenas 2 divisores: 1 e ele mesmo.
Exemplo de sada:
Digite um nmero limite: 7

7 um nmero primo
Exerccio 6.5 Encontre e imprima os divisores de cada nmero at um limite N (nmero

inteiro) fornecido pelo usurio.
Exemplo com N = 5:
1:1
2:1 | 2
3:1 | 3
4: 1 | 2 | 4
5: 1 | 5
Exemplo de sada:
Digite um nmero limite: 10

Os divisores at 1 so: 1
Os divisores at 2 so: 1 2
Os divisores at 4 so: 1 2 4
Os divisores at 6 so: 1 2 3 6
Os divisores at 9 so: 1 3 9

Exerccio 6.6 Construa um programa que leia vrios nmeros inteiros e mostre qual foi o
maior e o menor valor fornecido.
Exemplo de sada:
Quantos nmeros deseja digitar? 5

Digite o nmero 1: 6
Digite o nmero 2: 3
Digite o nmero 3: 5
Digite o nmero 4: 2
Digite o nmero 5: 8
O maior nmero digitado foi 8
O menor nmero digitado foi 2
Dica: Quando o usurio digita seu primeiro nmero, este sempre tanto o maior quanto o
menor nmero at ento.
Arranjos devem ser utilizados nestes prximos exerccios.
Exerccio 6.7 Dada uma tabela de 4 x 5 elementos, calcular a soma de cada linha e a soma
de todos os elementos. Uma estrutura de repetio deve ser utilizada para percorrer as linhas
e colunas.
Exemplo de sada:
Digite o elemento da linha 0 e coluna 0: 5

O soma da linha 0 igual a 24
A soma de todos os elementos 85

6.13 Exerccios 101
Exerccio 6.8 Dada uma matriz A[4x4], imprimir o nmero de linhas e o nmero de colunas
nulas (com apenas 0s) da matriz. Uma estrutura de repetio deve ser utilizada para percorrer
as linhas e colunas.
Exemplo de sada:

Esta matriz tem 2 linha(s) nula(s)
Esta matriz tem 1 coluna(s) nula(s)
Exerccio 6.9 Faa um programa que mostre os elementos diagonais A[i,i] de uma matriz.
Uma estrutura de repetio deve ser utilizada para percorrer as linhas e colunas.
Exemplo de sada:

Os elementos da diagonal so 5 4 2 3
Exerccio 6.10 Faa um programa que multiplique duas matrizes. Uma estrutura de repetio
deve ser utilizada para percorrer as linhas e colunas.
Digite o elemento da linha 0 e coluna 0 da matriz A: 5

Digite o elemento da linha 0 e coluna 0 da matriz B: 5
A matriz C = A * B igual a:
70 72 63
75 55 45
65 74 46

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 7.0Escopo
0
1 0de variveis
1
0 0 1
0
0 0
1
110 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 01 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Como vimos em nossos exemplos, um programa composto de blocos que esto sempre
entre chaves { e }. A funo principal, main, composta tambm de um bloco. Cada estrutura
de controle tambm contm ao menos um bloco.
Escopo de bloco Uma varivel tem escopo de bloco quando a declaramos em um bloco. Neste
caso, ela pode ser apenas utilizada neste bloco e nos blocos mais internos a este bloco. O
escopo de bloco comea na declarao na varivel e termina na chave que fecha o bloco.
Escopo de arquivo Uma varivel tem escopo de arquivo quando seu identificador declarado
fora de qualquer funo ou classe. Esta uma varivel global e conhecida em qualquer
ponto do programa.
Em variveis com escopo de blocos, quando h um bloco aninhado mais interno e os dois
blocos contm uma varivel com o mesmo identificador, a varivel do bloco mais externo fica
oculta at que o bloco interno termine.
Isto o que faremos neste exemplo:
2
4
5 int main () {
6 int x ;
7 x = 5;
8 cout << " x externo = " << x << endl ;
9 for ( int i = 0; i < 1; i ++){
10 int x ;
11 x = 7;
12 cout << " x interno = " << x << endl ;
13 cout << " i interno = " << i << endl ;
14 }
104 Captulo 7. Escopo de variveis
16 return 0;
17 }
Criamos e inicializamos uma varivel x, nas linhas 6 e 7, que pertence ao bloco externo, o
bloco do main. O valor desta varivel impresso na linha 8.
x externo = 5
x 5
Na linha 9, temos uma estrutura de repetio. Veja que no temos ainda uma varivel inteira
i para a estrutura de repetio. Isso ocorre porque a varivel contadora i ser agora criada no
escopo do bloco do for, atravs da instruo int na linha 9. Por isso, ela s ser existente
enquanto estivermos no bloco do for.
x 5
i 0
Na linha 10, criamos uma varivel x dentro do escopo do for. Como j temos uma varivel
x do bloco mais externo, isto faz com que a varivel x do bloco externo fique oculta. Na linha
11, quando damos valor a x, alteraes sero feitas, ento, na varivel visvel. Veja que, na linha
12, o valor impresso foi o da varivel no bloco mais interno.
x externo = 5
x interno = 7
x 5
i 0 x 7
105
Na linha 13 imprimimos apenas o valor de i, que tambm do escopo do for.
x externo = 5
x interno = 7
i interno = 0
Aps a primeira iterao o valor de i passar a ser 1 e a condio de repetio i<1 no mais
atendida. Assim, o bloco do for encerrado. As variveis do bloco interno ento deixam de
existir e o x do bloco externo no est mais oculto, sendo impresso na linha 15.
x externo = 5
x interno = 7
i interno = 0
x externo = 5
x 5
Se tentssemos inserir uma linha de cdigo que imprime o valor de i, no final do programa,
teramos um erro pois no existe a varivel i neste ponto do cdigo. Isso est representado na
linha 18 do seguinte programa:
2
4
5 int main () {
6 int x ;
7 x = 5;
8 int i ;
10 for ( i = 0; i < 1; i ++){
11 int x ;
12 x = 7;
14 cout << " i interno = " << i << endl ;
15 }
17 // O seguinte comando causaria um erro :
18 cout << " i = " << i << endl ;
19 // N o existe uma vari vel i neste ponto do c digo
20 return 0;
21 }
106 Captulo 7. Escopo de variveis
Para resolvermos este problema, portanto, precisariamos criar a varivel i no bloco externo
do programa, como feito na linha 9 do cdigo abaixo.
2
4
5 int main () {
6 int x ;
7 x = 5;
8 // criando vari vel i no bloco externo
9 int i ;
11 for ( i = 0; i < 1; i ++){
12 int x ;
13 x = 7;
15 cout << " i externo = " << i << endl ;
16 }
18 cout << " i = " << i << endl ;
19 return 0;
20 }
Agora, como a varivel i foi declarada no bloco externo, ela pode ser acessada na linha 17,
gerando o seguinte resultado para o programa:
x externo = 5
x interno = 7
i interno = 0
i = 1
Apesar do exemplo que utilizamos nesta seo, no recomendada a prtica de se utilizar

nomes identificadores de variveis que ocultam outras variveis no escopo mais externo. Neste
programa, isto pode ser corrigido simplesmente com um outro nome para o x interno:
2
4
5 int main (){
6 int x ;
7 int i ;
8 x = 5;
10 for ( i = 0; i < 1; i ++){
11 int y ;
12 y = 7;
13 cout << " y interno = " << y << endl ;
14 cout << " i externo = " << i << endl ;
15 }.
7.1 Exerccios 107

17 cout << " i = " << i << endl ;
18 return 0;
19 }.
7.1 Exerccios
Exerccio 7.1 Analise o cdigo abaixo, que est incompleto. A linha 14 precisou ser
comentada, pois causava um erro no programa. Aps o for, queramos imprimir o valor final
do contador i. Conserte o cdigo para que a linha abaixo possa ser descomentada sem causar
um erro.
2
4
5 int main (){
6 // Imprime e soma as pot ncias de 2 at 1000...
7 int somatorio = 0;
8 for ( int i = 2; i < 1000; i *=2){
9 cout << i << " + " ;
10 somatorio += i ;
11 }
12 cout << " = " << somatorio << endl ;
13 // A linha abaixo precisou ser comentada .
14 // cout << " Valor final de i = " << i << endl ;
15
16 return 0;
17 }

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 8.0Ponteiros
0
1 0
1
0
1
0
0 0
1
110 01
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 01 0 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Vimos que os dados de cada varivel contm um endereo na memria que pode ser acessado
com o operador de endereo, representado por e"comercial (&). Enquanto x retorna o valor de
uma varivel x, o operador de endereo & pode ser utilizado para retornar o endereo de x na
memria.
Ponteiros so variveis que guardam endereos da memria em seus dados. So variveis
que alm de ter seus endereos, podem guardar o endereo de outras variveis. Quando um
ponteiro guarda um endereo de um dado, dizemos que ele est apontando para aquele dado.
Suponha que criamos um nmero inteiro x de valor 5 e um ponteiro que se chamar px.
Temos o seguinte trecho de cdigo e a seguinte representao das variveis:
1 int x ;
2 x = 5;
3 int * px ;
x 5 px
O operador * utilizado na linha 3 indica que px um ponteiro para int e no apenas um

int.
A Tabela 8.1 representa estas variveis na memria de um computador. No exemplo apresen-
tado, x se encontra no endereo 25 da memria. A varivel px se encontra na posio 26 e ainda
no tem um valor atribudo.
No exemplo seguinte, guardamos tambm o endereo de x em px, na linha 4.
1 int x ;
2 x = 5;
3 int * px ;
4 px = & x ;
A Tabela 8.2 representa o estado destas variveis na memria. Como px tem o endereo de
x, dizemos que px aponta para x. Note que:
110 Captulo 8. Ponteiros

24
x 5 25
px 26
27
28
29
30
31
32
33
34
35
Tabela 8.1: Organizao de um ponteiro ainda vazio na memria. Apesar de guardar endereo,
um ponteiro uma varivel com um nome identificador, valor e endereo.
px tem endereo 26 e valor 25.

px aponta para um dado que tem endereo 25 e valor 5.

24
x 5 25
px 25 26
27
28
29
30
31
32
33
34
35
Tabela 8.2: Organizao de um ponteiro na memria.
O operador de endereo & aplicado a px (&px) nos retorna o endereo de px, que 26. E o
comando px, como usual, nos retorna o valor de px, que no caso o endereo de x, ou 25.
O operador representado por um asterisco * o operador de desreferenciao. Quando
aplicamos este operador a px (*px), desreferenciamos px e retornamos o valor apontado por px.
Nesse exemplo, este tambm o valor de x, ou 5.
Sabemos que, na memria, os ponteiros fisicamente guardam outros endereos. Porm,
quando representamos graficamente as variveis isto indicado por uma seta:
111
px
x 5
Veja a diferena entre a representao fsica na memria e a uma representao grfica. A

seta sai de dentro de px e aponta para o valor da varivel x. Sabemos, assim, que o valor de px
o endereo de x, seja este qual for.
Neste exemplo, manipularemos ponteiros que apontam para outras variveis:
2
4
5 int main () {
6 int x ;
7 int * px ;
8 int * py ;
9 x = 5;
10 px = & x ;
11 py = px ;
12 cout << " x = " << x << endl ;
13 cout << " & x = " << & x << endl ;
14 cout << " px = " << px << endl ;
15 cout << " * px = " << * px << endl ;
16 cout << " * py = " << * py << endl ;
17 cout << " & px = " << & px << endl ;
18 cout << " & py = " << & py << endl ;
19 return 0;
20 }
Criamos uma varivel x, na linha 6, que ser apontada por ponteiros. Criamos tambm, dois
ponteiros px e py para nmeros inteiros, nas linhas 7 e 8.
px py
Aps inicializar x com 5, na linha 9, px recebe em seguida o endereo de x na linha 10, o

que o faz apontar para x.
px py
x 5
Na linha 11, py recebe o valor de px, que o endereo de x. Assim, py aponta tambm para
x.
px py
x 5
Imprimimos o valor de x e o endereo de x nas linhas 12 e 13, que um endereo real na

memria.
x = 5
&x = 0x7fff571abb68
Imprimimos em seguida, na linha 14, o valor de px, que no caso, o endereo de x.
x = 5
&x = 0x7fff571abb68
&px = 0x7fff571abb68
Imprimimos, na linha 15, o valor apontado por px, que o valor de x:
x = 5
&x = 0x7fff571abb68
&px = 0x7fff571abb68
*px = 5
Na linha 16, imprimimos o valor apontado por py, que tambm o valor de x.
x = 5
&x = 0x7fff571abb68
px = 0x7fff571abb68
*px = 5
*py = 5
Apesar de apontarem para x, px e py so variveis que contm seus prprios endereos,

como mostram as impresses feitas nas linhas 17 e 18.
x = 5
&x = 0x7fff571abb68
px = 0x7fff571abb68
*px = 5
*py = 5
&px = 0x7fff5b810b40
&py = 0x7fff5b810b38
8.1 Expresses com ponteiros 113
! Apesar de guardarem apenas endereos na memria, a sintaxe dos ponteiros nos obriga
a dizer que tipo de dado ele aponta. No nosso exemplo, precisamos dizer que px um
ponteiro para um int.
Isto ocorre para que seja possvel a operao que retorna o valor apontado. Esta operao
depende do tipo de dado, para saber como interpretar os dados naquele endereo da
memria.
8.1 Expresses com ponteiros

Se px aponta para x, o valor apontado por px pode ser utilizado em qualquer expresso onde
x seria usado. Por exemplo: criamos um ponteiro que aponta para x e o valor apontado por px
pode ser incrementado no lugar de x:
1 int * px ;
2 int x ;
3 px = & x ;
4 * px = 5;
5 (* px )++;
Ao final do exemplo, o valor de x ser 6, assim como seria se nas linhas 4 e 5 tivssemos
incrementado x diretamente.
8.2 Aritmtica com ponteiros

Podemos fazer aritmtica tambm com ponteiros. Por exemplo, um incremento em um
ponteiro px com px++ faz com que ele aponte para o prximo endereo na memria para aquele
tipo de dado. De modo anlogo, px + 6 retorna o endereo seis posies a frente de px.
preciso tomar cuidado pois incrementar o valor apontado por px (*px)++ diferente de
incrementar o endereo apontado por px e utilizar este valor apontado *(px++).
Devemos evitar aritmtica com ponteiros, pois nem sempre sabemos o que est no endereo
seguinte da memria. O novo endereo pode no pertencer rea na memria reservada para o
programa. Isso seria o que chamamos de uma falha de segmentao.
Outro problema com este tipo de aritmtica que o prximo endereo da memria pode ter
um dado de outro tipo, que no o do ponteiro. Isto impede o retorno do valor apontado.
8.3 Ponteiros para ponteiros

Podemos criar ponteiros para ponteiros utilizando, mais uma vez, o operador *. No prximo
exemplo, vamos ver como podemos criar ponteiros para ponteiros. Isso feito utilizando mais
de uma vez o operador para ponteiros.
2
4
5 int main () {
6 int x ;
7 x = 5;
8 int * px ;
9 int ** ppx ;
10 px = & x ;
11 ppx = & px ;
12 cout << " x = " << x << endl ;
13 cout << " & x = " << & x << endl ;
14 cout << " px = " << px << endl ;
15 cout << " * px = " << * px << endl ;
16 cout << " & px = " << & px << endl ;
17 cout << " & ppx = " << & ppx << endl ;
18 cout << " ppx = " << ppx << endl ;
19 cout << " * ppx = " << * ppx << endl ;
20 cout << " ** ppx = " << ** ppx << endl ;
21 return 0;
22 }
Logo no incio do programa, nas linhas 6 a 11, criamos x, um ponteiro px para dados do tipo
int, e um ponteiro ppx para ponteiros para dados do tipo int. Inicializamos x com 5, px com o
endereo de x e ppx com o endereo de px.
ppx
px
x 5
Como vimos nos exemplos anteriores, px possui seu prprio endereo e guarda o endereo
de x. Assim as linhas 12 a 16 geram a seguinte sada:
x = 5
&x = 0x7fff55568b28
px = 0x7fff55568b28
*px = 5
&px = 0x7fff55568b20
Nas linhas 17 e 18, da mesma maneira, a varivel ppx possui seu prprio endereo e um
valor, que neste exemplo o endereo de px, o mesmo que foi impresso com o operador de
endereo em px (&px).
x = 5
&x = 0x7fff55568b28
px = 0x7fff55568b28
*px = 5
&px = 0x7fff55568b20
&ppx = 0x7fff55568b18
ppx = 0x7fff55568b20
Como valor apontado por ppx (*ppx), temos o valor de px, que o endereo de x. Obtendo
o valor apontado pelo valor apontado por ppx (**px), temos o valor apontado por px, que o
valor de x.
x = 5
&x = 0x7fff55568b28
px = 0x7fff55568b28
*px = 5
&px = 0x7fff55568b20
&ppx = 0x7fff55568b18
ppx = 0x7fff55568b20
*ppx = 0x7fff55568b28
**ppx = 5
8.4 Ponteiros e arranjos

Como vimos anteriormente, arranjos so endereos na memria onde comea um espao
alocado para uma sequncia de dados do mesmo tipo. Ponteiros e arranjos esto muito relaciona-
dos, pois ponteiros que apontam para arranjos podem ter seus valores manipulados para acessar
outros dados da mesma sequncia de elementos.
Vamos supor um arranjo x de tamanho 5. Criaremos tambm um ponteiro px.
1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
Sabemos que os valores de x esto em sequncia na memria. Sabemos tambm que x o
endereo na memria onde comea esta sequncia. Podemos ento atribuir este endereo a px:
1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
3 px = x ;
Com x o endereo onde comea a sequncia de elementos. O comando acima seria
equivalente a atribuir o endereo do primeiro elemento da sequncia:
1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
3 px = & x [0];
Em qualquer um dos casos, a Tabela 8.3 representa o resultado na memria destas operaes.
Os elementos do arranjo x esto nos endereos 25 a 29 da memria. O ponteiro px se encontra
no endereo 30 e tem valor 25 que o endereo do primeiro elemento do arranjo x.
Agora, se retornarmos o valor apontado por px, obteremos o valor de x[0]:
1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
3 px = x ;
4 cout << * px << endl ;
5

24
x[0] 5 25
x[1] 3 26
x[2] 6 27
x[3] 7 28
x[4] 3 29
px 25 30
31
32
33
34
35
Tabela 8.3: Um ponteiro apontando para o primeiro elemento de um arranjo.
Como x guarda elementos em posies contguas, podemos fazer aritmtica com o ponteiro
para encontrar outros elementos do arranjo. Neste exemplo, retornamos o valor no endereo que
est duas posies a frente de px.
1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
3 px = x ;
4 cout << *( px + 2) << endl ;
Podemos at retornar o valor apontado por px com o operador de subscrito [ e ].

1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
3 px = x ;
4 cout << px [0] << endl ;
Outros subscritos somam um nmero a px e procuram o que h em posies seguintes na

memria.
1 int x [] = {5 , 3 , 6 , 7 , 3};
2 int * px ;
3 px = x ;
4 cout << px [3] << endl ;
Os operaes px[3] e *(px + 3) so ento equivalentes. Elas retornam o valor no endereo

3 posies a frente de &x[0]. A utilizao do operador de subscrito (px[3]), porm, mais
comum para arranjos.
importante utilizar estes recursos com cuidado para no acessar posies onde no temos
elementos.
! Apesar da relao entre ponteiros e arranjos, um ponteiro uma varivel que guarda um
endereo na memria. J um arranjo, um endereo na memria, onde comea uma
sequncia de elementos.
Neste exemplo, vamos criar ponteiros que apontam para arranjos:

2
4
5 int main () {
6 int x [5] = {6 ,2 ,8 ,4 ,9};
7 int * px ;
8 px = x ;
9 cout << " x = " << x << endl ;
10 cout << " x [0] a x [4]: " ;
11 for ( int i =0; i <5; i ++){
12 cout << x [ i ] << " " ;
13 }
14 cout << endl ;
15 cout << " px = " << px << endl ;
16 cout << " * px = " << * px << endl ;
17 cout << " px [0] = " << px [0] << endl ;
18 cout << " px [3] = " << px [3] << endl ;
19 cout << " *( px +3) = " << *( px +3) << endl ;
20 cout << " * px ++ = " << * px ++ << endl ;
21 cout << " px [3] = " << px [3] << endl ;
22 return 0;
23 }
Criamos na linha 6 um arranjo de dados do tipo int chamado de x e um ponteiro para dados
do tipo int chamado px na linha 7.
Na linha 8, px recebe o valor de x. Como x um arranjo, e ele prprio o endereo de seu
primeiro elemento, px aponta para o primeiro elemento de x. Ou seja, px recebe &x[0].
px
x 6 2 8 4 9
x[0] x[1] x[2] x[3] x[4]

Se usarmos x diretamente, como feito na linha 9, vemos o endereo de onde comea a

sequncia de elementos do arranjo, ou seja, o endereo do primeiro elemento do arranjo
x = 0x7fff52294b10
O trecho de cdigo seguinte, nas linhas 11 a 14, imprime todos os elementos do arranjo
atravs de seus ndices de 0 a 4.
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
Na linha 15, o valor impresso de px tambm o endereo do primeiro elemento do arranjo.
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
px = 0x7fff52294b10
Como px aponta para o primeiro elemento do arranjo, o valor apontado por px retorna 6 na
linha 16.
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
px = 0x7fff52294b10
px = 6
Assim como nos arranjos, podemos retornar valores relacionados com o ponteiro com o
operador de subscrito px[i]. O operador de subscrito com um nmero i diferente de zero, pega
o elemento que estiver em i posies frente do endereo apontado por px. Isso o que ocorrre
da linha 17 a 18.
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
px = 0x7fff52294b10
*px = 6
px[0] = 6
px[3] = 4
preciso tomar cuidado com esta operao pois no podemos acessar elementos em posies
que esto fora do arranjo.
Conseguimos tambm o mesmo resultado com aritmtica de ponteiros. Na linha 19, adicio-
namos ao endereo o tamanho de 3 elementos do tipo int e chegamos a x[3].
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
px = 0x7fff52294b10
*px = 6
8.5 Exerccios 119
px[0] = 6
px[3] = 4
*(px + 3) = 4
A operao incremento em px na linha 20 (++px, faz px apontar para o prximo int na

memria. Em seguida, o operador * retorna seu valor apontado. Veja que o valor do ponteiro px
alterado para o prximo elemento do arranjo.
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
px = 0x7fff52294b10
*px = 6
px[0] = 6
px[3] = 4
*(px + 3) = 4
*px++ = 6
px
x 6 2 8 4 9
x[0] x[1] x[2] x[3] x[4]
Por fim, na linha 21, px[3] retorna o elemento 3 posies aps a posio apontada por px,
que agora x[4].
x = 0x7fff52294b10
x[0] a x[4]: 6 2 8 4 9
px = 0x7fff52294b10
*px = 6
px[0] = 6
px[3] = 4
*(px + 3) = 4
*px++ = 6
px[3] = 9
8.5 Exerccios
Exerccio 8.1 Analise o cdigo abaixo, que est incompleto. Coloque um cout antes de
cada linha explicado o que foi feito neste comando.
1 // biblioteca padr o de entrada e sa da
3
4 // espa o de nomes da biblioteca padr o ( std )
6
7 // fun o principal do programa
8 int main (){
9 int x ;
10 int * px ;
11 px = & x ;
12
13 cout << " Digite um valor para x : " ;
14 cin >> x ;
15
16 // Colocar um cout antes de cada linha
18 cout << & x << endl ;
19 cout << & px << endl ;
20 cout << px << endl ;
22
23 int v [5] = {4 , 2 , 3 , 4 , 5};
24 cout << v [0] << endl ;
25 cout << v << endl ;
26 cout << & v << endl ;
27 cout << * v << endl ;
28
29 px = v ;
30 cout << px << endl ;
31 cout << & px << endl ;
33 cout << *( px +1) << endl ;
34 cout << px [2] << endl ;
35 px ++;
36 cout << px [3] << endl ;
37 cout << (* px )++ << endl ;
38 cout << *( px ++) << endl ;
39
40 return 0;
41 }

0 1
1 0 0 0 1 1 10 0 11 1 01 1 00 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 10
1
0
1
0
0100 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 10 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
00
1
1
1 01
1
1 1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 1
00
0
1
1
1110
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 9.0Modularizao
0
1 0 1
0 0de programas
1
0
01 0
10com funes
110 1 1
0
1 0
0
110 0
1
1 0
0
000 0
0
1
1
0
0 0
00 1 00 0 0 0 01 0 01 00 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 00
0 1 01 0 1 1 1 0 01 1 11
Veja como exemplo a letra desta msica. Alguns conjuntos de estrofes so bem parecidos:
Ciranda Cirandinha
Ciranda, cirandinha Ciranda, cirandinha

Vamos todos cirandar! Vamos todos cirandar!
Vamos dar a meia volta Vamos dar a meia volta
Volta e meia vamos dar Volta e meia vamos dar
O anel que tu me destes O anel que tu me destes

Era vidro e se quebrou Era vidro e se quebrou
O amor que tu me tinhas O amor que tu me tinhas
Era pouco e se acabou Era pouco e se acabou
Por isso, dona Rosa Ciranda, cirandinha

Entre dentro desta roda Vamos todos cirandar!
Diga um verso bem bonito Vamos dar a meia volta
Diga adeus e v se embora Volta e meia vamos dar
Veja agora a mesma letra de outra maneira. Os refres que se repetem esto agrupados.
Ciranda Cirandinha
REFRO: Vamos todos cirandar!
Ciranda, cirandinha Vamos dar a meia volta

122 Captulo 9. Modularizao de programas com funes
Volta e meia vamos dar Diga adeus e v se embora
O anel que tu me destes REFRO

Era vidro e se quebrou
O anel que tu me destes
O amor que tu me tinhas
Era pouco e se acabou Era vidro e se quebrou
Por isso, dona Rosa
Era pouco e se acabou
Entre dentro desta roda
Diga um verso bem bonito REFRO
Se estamos seguindo a letra de uma msica, claro no cantamos a palavra re-

fro"quando a vemos. Quando vemos a palavra refro", voltamos onde o refro foi definido e
cantamos aquela parte.
Isto nos d um grande poder de sntese para expressar ideias. Podemos explicar a letra de
uma msica de maneira mais sucinta.
Outra possibilidade, definir todas as partes no incio da msica. Depois, podemos cantar a
msica completa usando as definies que fizemos.
Ciranda Cirandinha
Partes: Por isso, dona Rosa

REFRO: Entre dentro desta roda
Ciranda, cirandinha Diga um verso bem bonito
Vamos todos cirandar!
Diga adeus e v se embora
Vamos dar a meia volta
Volta e meia vamos dar REFRO
Msica:
O anel que tu me destes
REFRO
O anel que tu me destes O amor que tu me tinhas
Era pouco e se acabou
Era pouco e se acabou REFRO
de maneira anloga que funes de um programa podem ser definidas e depois chamadas.
Funes so unidades autnomas de cdigo, que cumprem uma tarefa particular. Os progra-
mas em C++ so formados por funes. Por enquanto, estivemos colocando todo o cdigo em
nossa funo principal main. Porm, programas que resolvem problemas maiores so usualmente
divididos em mais funes.
9.1 Funes simples

As funes so muito teis para dividir problemas em problemas menores. Tarefas que so
repetidas vrias vezes podem ser colocadas em funes para simplificar o cdigo. Para que uma
funo seja utilizada na funo main, ela precisa j ter sido declarada para que seja reconhecida.
9.1 Funes simples 123
9.1.1 Minha primeira funo

Neste exemplo, vamos criar uma funo de exemplo e a utilizaremos em nossa funo
principal. Perceba que a funo exemplo criada antes da funo main no seguinte exemplo:
2
4
5 void exemplo () {
6 cout << " Ol " ;
7 cout << " Mundo ! " ;
8 cout << endl ;
9 }
10
11 int main () {
12 cout << " Exemplo de fun o simples " << endl ;
13 exemplo ();
14 exemplo ();
15 return 0;
16 }
Na linha 5, a palavra chave void, na frente da funo exemplo, indica que esta funo no
retorna nenhum valor. Apesar disso, note que, a que a sintaxe das duas funes muito similar:
um nome de funo, parnteses e um bloco de comandos delimitado por chaves.
Assim como em qualquer programa, a sua execuo se inicia na funo principal main,
definida nas linhas 11 a 16. A linha 12 da funo main imprime a seguinte mensagem:
Exemplo de funes simples
Na linha 13, a funo exemplo chamada. Isso faz com que a funo main fique em espera
at que os comandos da funo exemplo sejam executados. Os comandos da funo exemplo,
nas linhas 5 a 9, imprimem um Ol Mundo! com trs comandos separados, nas linhas 6, 7 e 8.

Ol Mundo!
Ao fim da execuo da funo, voltamos para a funo que a chamou. Ou seja, a funo
main sai de espera na linha 13. O prximo comando do main, na linha 14, mais uma chamada
funo exemplo. Veja que a funo executada mais uma vez.

Ol Mundo!
Ol Mundo!
Retornamos funo main na linha 14. Este exemplo nos mostrou como criar novas funes
com blocos de cdigo que podem ser chamados. Isso pode nos ajudar a organizar um problema
em problemas bem menores. Mas para isso, nossas funes precisam ser declaradas antes da
funo main para que possam ser reconhecidas.
9.2 Cabealhos de funo

Por questo de organizao, usualmente melhor analisar a funo main antes de analisar
outras funes. Assim, seria bom poder definir as funes no cdigo aps a funo main. E isso
possvel atravs do uso de cabealhos.
Podemos refazer o exemplo anterior com um cabealho para nossa funo exemplo:
2
4
5 void exemplo ();
6
7 int main () {
8 cout << " Exemplo de fun o simples " << endl ;
9 exemplo ();
10 exemplo ();
11 return 0;
12 }
13
14 void exemplo () {
15 cout << " Ol " ;
16 cout << " Mundo ! " ;
17 cout << endl ;
18 }
Na linha 5, o cabealho declara a funo exemplo, de modo que a funo main a reconhea.
Aps a funo main, a partir da linha 14, definimos a funo exemplo, j declarada no cabealho.
Agora possvel usar a definio a partir da funo main mesmo antes da definio da funo
aparecer no cdigo. Por questes de organizao, este o modo mais usual de se organizar
funes.
9.3 Funes e suas variveis

Assim como a funo main, nossas funes podem ter suas prprias variveis. Devido ao
escopo de bloco, as funes no tero acesso s variveis de outras funes, nem mesmo s
variveis da funo chamadora. Por isso, no h problema algum em se repetir identificadores
usados na funo chamadora. Isso facilita o reaproveitamento de cdigo, j que no precisamos
nos preocupar com estas repeties.
Neste exemplo, vamos criar uma funo que tem suas prprias variveis.
2
4
5 void soma ();
6
7 int main () {
8 int x ;
9 int y ;
10 x = 2;
11 y = 6;
9.3 Funes e suas variveis 125
12 cout << " x + y = " << x + y << endl ;

13 soma ();
14 cout << " x + y = " << x + y << endl ;
15 return 0;
16 }
17
18 void soma () {
19 int x ;
20 int a ;
21 x = 4;
22 a = 1;
23 cout << " x + a = " << x + a << endl ;
24 }
Na funo principal main, nas linhas 8 a 11, criamos duas variveis x e y, com valores 2 e 6.
A soma dessas variveis impressa normalmente na linha 12 da funo main:
x + y = 8
main
x 2 y 6
soma
Repare que, na linha 13, a funo main chama a funo soma e fica em espera at que ela
termine. x a
A funo soma, definida nas linhas 18 a 24, tambm cria duas variveis em seu prprio
escopo, nas linhas 19 e 20. Nas linhas 21 e 22, estas variveis recebem os valores 4 e 1. Cada
uma das duas funes, main e soma, tm uma varivel chamada x. Note que no h conflito
entre os identificadores pois so escopos completamente diferentes.
main
x 2 y 6
soma
x 4 a 1
Ainda por causa do escopo separado das variveis, a funo soma no tem acesso s variveis
da funo principal main e vice-versa. Agora, na linha 23, soma imprime x + a, de acordo com
as variveis de seu escopo, resultando em 5.
x + y = 8
x + a = 5
Retornamos ento, funo main e as variveis de soma deixam de existir.
main
x 2 y 6
soma
Perceba que, na linha 14, x + y novamente impresso como 8, pois estamos nos referindo
x a
s variveis do main.
x + y = 8
x + a = 5
x + y = 8
Repare como as funes podem dividir problemas em subproblemas independentes.
9.4 Retorno de valor

Colocamos a palavra chave void antes das funes que criamos at agora. Isto indica que
estas funes no retornam nada. J a palavra chave int antes da funo main indica que ela
retorna um nmero inteiro. Este retorno acontece no comando return 0, que finaliza o programa.
O comando return 0 usado para indicar que o programa encerrou sem nenhum erro.
Podemos fazer com que funes retornem valores de qualquer tipo. E esse valor retornado
pode ser utilizado na funo chamadora como um dado daquele tipo. Isto muito til pois o
dado pode ser diretamente utilizado ou ser guardado em uma varivel daquele tipo.
Neste exemplo vamos criar uma funo que retorna um dado do tipo double.

2
4
5 double pi ();
6
7 int main () {
8 double x ;
9 x = pi ();
10 cout << " O valor de pi " << x << endl ;
11 cout << " O valor de pi " << pi () << endl ;
12 return 0;
13 }
14
15 double pi () {
16 return 3.14;
17 }
Na linha 8, criamos um double x no escopo do main.

main
Veja que, na linha 9, x recebe o que for retornado pela funo pi. Como usual, a funo
main fica em espera enquanto executada a funo pi.
Observe que no criamos nenhuma varivel na funo pi, que inicia na linha 15. O primeiro
comando de pi, na linha 16, j retorna o valor 3.14. Este valor, por sua vez capturado pela
funo main, que a chamou. Assim, a funo main volta a ser executada na linha 9, onde o valor
3.14, retornado por pi, atribudo a x.
main
x 3.14
O valor retornado pela funo pi atribudo a x na linha 9 e o comando de impresso cout

na linha 10 funciona normalmente com x.
O valor de pi 3.14
Em um segundo cout, na linha 11, o valor de 3.14 retornado direto da funo para o
comando de impresso.
O valor de pi 3.14
O valor de pi 3.14
Nesse exemplo, tivemos uma funo que retornava o valor de . Funes especficas
permitem a outras funes chamadoras tomar este subproblema como resolvido. Assim, s
precisamos utilizar a funo a onde a soluo do problema for esperada.
9.5 Parmetros de funo

Imagine agora, que voc tem a tarefa de comprar um microondas, como na Figura 9.1. Pense
nisto como uma funo comprar.
No exemplo da Figura, se voc pensa depois em comprar qualquer outro tipo de eletro-
domstico, como uma TV ou um rdio, isso muito fcil, pois como voc j comprou um
micro-ondas, j sabe como comprar qualquer outro eletrodomstico. O procedimento de compra
no diferente para outro produto. Neste caso, como se nossa funo fosse a ao de comprar
algo. Ela sempre funciona da mesma maneira. Enquanto isso, nosso parmetro o que vamos
comprar. Usamos a mesma funo para diferentes parmetros.
Perceba como o recurso de parmetros aumentou o nosso poder de sntese. As funes so
frequentemente utilizadas para resolver subproblemas. Mas assim como em nossos exemplos,
subproblemas s vezes dependem de alguma informao sobre o problema para poderem ser
resolvidos. Ou seja, na hora de comprar algo, voc precisava saber o que ir comprar.
OK
Figura 9.1: Exemplo de uma ao de comprar.
Este tipo de informao pode ser passado para as funes atravs dos parmetros. Em C++,
esses parmetros so passados para a funo entre parnteses (), aps o identificador da funo.
Neste exemplo, vamos criar uma funo que eleva um nmero qualquer ao cubo. Para isto a
funo precisa saber qual nmero elevar ao cubo.
2
4
5 double cubo ( double a );
6
7 int main () {
8 int x ;
10 cin >> x ;
11 cout << x << " ao cubo " << cubo ( x ) << endl ;
12 return 0;
13 }
14
15 double cubo ( double a ) {
16 return a * a * a ;
17 }
Esta funo depender ento de qual nmero queremos elevar ao cubo e para isso usaremos
um parmetro na funo cubo, representado por a na linha 5. Na funo principal, nas linhas 8 a
10, criamos e inicializamos uma varivel x atravs de uma entrada do usurio.
Digite um nmero: 4
main
x 4
Imprimimos agora, na linha 11, o valor de x e o valor de x ao cubo. No temos uma varivel
com o valor de x ao cubo, mas a funo cubo tem esta capacidade de fazer este clculo e retornar
o resultado.
A funo main fica em espera e a funo cubo(x) executada. A funo se inicia na linha
15, onde a varivel a uma cpia da varivel x, enviada por main ao chamar a funo.
main
x 4
cubo
a 4
Esta funo cubo retorna na linha 16 o valor de a * a * a, ou seja, 64. Com o fim da
funo cubo, main volta ser executada na linha 11, e a chamada de cubo(x) substituda pelo
valor retornado 64.
Digite um nmero: 4
4 ao cubo 64
Note que mesmo sem ter o valor de x ao cubo em nenhuma varivel, podemos dividir o
problema em subproblemas pois sabemos que h uma funo que resolve isso e retorna o que
queremos. Note tambm que para calcular o valor de x ao cubo, o valor de x precisou ser enviado
funo como parmetro.
A funo cubo, se iniciou com uma varivel a. Esta varivel um parmetro da funo. O
valor do parmetro a foi enviado pela funo chamadora, e neste caso uma cpia de x. Como
so dois escopos diferentes, note que no haveria problema algum se a tambm se chamasse x.
Repare tambm que a, nesse caso apenas uma cpia de x e qualquer alterao em a no altera
o x original.
O nico comando da funo cubo retornou a * a * a (ou a3 ). Ao trmino da funo cubo,
a funo main voltar a ser executada com o valor que foi retornado. Com o valor retornado 64,
essa foi a mensagem impressa acima.
Os parmetros aumentam muito a utilidade das funes e nos ajuda mais ainda a dividir
problemas em subproblemas.
possvel aumentar mais ainda a utilidade de funes utilizando mais de um parmetro.
Neste segundo exemplo, criaremos uma funo que eleva um nmero base a um outro nmero
que representa um expoente inteiro.
2

4
5 double eleva ( double base , int exp );
6
7 int main () {
8 double x ;
9 int y ;
10 cout << " Digite a base : " ;
11 cin >> x ;
12 cout << " Digite o expoente : " ;
13 cin >> y ;
14 cout << x << " elevado a " << y << " = " ;
15 cout << eleva (x , y ) << endl ;
16 return 0;
17 }
18
19 double eleva ( double base , int exp ) {
20 double resultado ;
21 resultado = 1;
22 for ( int i =0; i < exp ; ++ i ){
23 resultado *= base ;
24 }
25 return resultado ;
26 }
Antes da funo principal, na linha 5, declaramos a funo eleva, que elevar qualquer
nmero real base a qualquer expoente inteiro no negativo exp.
Inicializamos no main, nas linhas 8 a 13 as variveis x e y onde o usurio guardar uma base
e um expoente.
Digite a base: 4.4

Digite o expoente: 5
main
x 4.4 y 5
eleva
Na linha 14, uma mensagem impressa parcialmente:
base 4.4 exp 5
Digite a base: 4.4
4.4 elevado a 5 =
No h um endl pois o resultado da expresso ainda ser impresso nesta linha.

Na linha 15, o comando com cout precisa do resultado da funo eleva, e por isso, a funo
main fica em espera. Veja que a funo eleva se inicia com uma varivel chamada base, que
uma cpia de x, e exp, que uma cpia de y.
main
x 4.4 y 5
eleva
base 4.4 exp 5
Na linha 20, criamos para a funo tambm uma varivel, resultado, onde ser calculado
o resultado. Ela se inicia com 1 na linha 21.
main
x 4.4 y 5
eleva
base 4.4 exp 5
resul
1
tado
Nas linhas 22 a 24, temos uma estrutura de repetio. O resultado , a cada iterao,
multiplicado por base na linha 23. Com uma estrutura de repetio, fazemos com este processo
se repita exp vezes.
main
x 4.4 y 5
eleva
base 4.4 exp 5
resul
1649.16
tado
Por fim, na linha 25, o valor de resultado retornado por eleva para a funo chamadora.
Com isso, a funo eleva encerrada e a funo main volta a executar com o valor retornado,
que base elevado a exp. Isso permite que a mensagem seja impressa na linha 15.
Digite a base: 4.4

4.4 elevado a 5 = 1649.1622
9.6 Passagem de parmetros

Existem duas maneiras de se passar parmetros para uma funo. Podemos passar nossos
parmetros por valor ou por referncia.
9.6.1 Passagem de parmetros por valor

A passagem de parmetros por valor o modo que utilizamos at agora. Neste modo de
passagem de parmetros, a funo recebe uma cpia da varivel enviada pela funo chamadora.
No fim do processo as cpias so eliminadas.
Temos novamente um exemplo de funo que calcula um nmero ao cubo.

2
4
5 double cubo ( double a );
6
7 int main () {
8 double x ;
10 cin >> x ;
11 cout << x << " ao cubo " ;
12 cout << cubo ( x ) << endl ;
13 cout << " x = " << x << endl ;
14 return 0;
15 }
16
17 double cubo ( double a ) {
18 a = a * a * a;
19 return a ;
20 }
Nas linhas 8 a 10, inicializamos uma varivel chamada x e damos um valor a ela. Na linha
11, imprimimos uma mensagem parcial, sem um endl:
Digite um nmero: 4
4 ao cubo
main
x 4
soma
Como, na linha 12, cout depende de cubo, a funo main fica em espera. J dentro da
a
funo cubo, note que a , neste caso, apenas uma cpia do valor de x e alteraes em a no
alteraro x.
9.6 Passagem de parmetros 133
main
x 4
soma
a 4
Na linha 13, alteramos o valor de a pelo valor de a * a * a, ou a ao cubo. Veja como isto
no influencia o valor original de x.
main
x 4
soma
a 64
O valor de a, ou 64, ento, retornado na linha 18. A funo encerrada e main volta
execuo na linha 12 com o valor retornado.
Digite um nmero: 4
4 ao cubo 64
Na linha 13, o valor de x impresso novamente.
Digite um nmero: 4
4 ao cubo 64
x = 4
Note como o valor de x no foi alterado durante a execuo do programa.
9.6.2 Passagem de parmetros por referrencia

Na passagem de parmetros por referncia, a funo recebe apenas uma referncia para a
varivel da funo chamadora. Assim, a varivel na funo chamada apenas um apelido para a
varivel da funo chamadora. Ento, neste caso, no precisamos copiar todos os dados para
executar a funo chamadora.
Neste caso, precisamos lembrar que alteraes na varivel da funo alteram tambm a
varivel da funo chamadora. Para indicar que o parmetro ser passado por referncia, utiliza-
se um e comercial (&).
Neste exemplo, enviaremos uma varivel por referncia para uma funo que calcula um
valor ao cubo.

2
4
5 double cubo ( double & a );
6
7 int main () {
8 double x ;
10 cin >> x ;
11 cout << x << " ao cubo " ;
12 cout << cubo ( x ) << endl ;
13 cout << " x = " << x << endl ;
14 return 0;
15 }
16
17 double cubo ( double & a ) {
18 a = a * a * a;
19 return a ;
20 }
Ao declararmos a funo cubo, na linha 5, o e"comercial (&) indica que a funo recebe a
varivel a por referncia. Nas linhas 8 a 10, temos a inicializao da varivel x, de main. Na
linha 11, imprimimos uma mensagem parcial sem um endl. Como cout depende da funo
cubo, a funo main fica em espera.
Digite um nmero: 4
4 ao cubo
main
x 4
soma
J na funo cubo, na linha 17, varivel a foi passada por referncia e por isto agora apenas
um apelido para o x, que tem como valor o 4 na funo chamadora. Se alterarmos algo em a,
a
neste momento, alteraremos tambm o x.
main
x 4
soma
a x
Como a s um apelido para o x da funo main, ento na linha 18, quando a recebe a * a
* a, isto ocorre diretamente em x.
9.7 Omitindo a varivel de retorno 135
main
x 64
soma
a x
O valor de a, na linha 19, 64, ento retornado para o cout da funo main, na linha 12. A
funo cubo encerrada e main volta execuo com o valor retornado, na linha 12.
Digite um nmero: 4
4 ao cubo 64
main
x 64
O valor de x impresso na linha 13. Note como durante a execuo do programa o valor de
x foi alterado.
Digite um nmero: 4
4 ao cubo 64
x = 4
9.7 Omitindo a varivel de retorno

Como a passagem de parmetros por referncia altera diretamente as variveis da funo
chamadora, ela pode ser criada justamente para alterar algumas variveis. Essas funes podem
ter o tipo de retorno void.
Neste exemplo, usaremos uma funo apenas para alterar o valor de uma varivel. Aps a
execuo da funo, a varivel enviada para a funo ter seu valor ao cubo.
2
4
5 void cubo ( double & a );
6
7 int main () {
8 double x ;
10 cin >> x ;
11 cout << x << " ao cubo " ;
12 cubo ( x );
14 return 0;
15 }
16
17 void cubo ( double & a ) {
18 a = a * a * a;
19 }
Declaramos a funo cubo na linha 5, onde o e"comercial (&) indica que a funo recebe a
varivel a por referncia. Dessa vez, a funo no retorna nada e isto indicado com void.
feita a criao e inicializao da varivel x nas linhas 8 a 10 de main. Na linha 11,
imprimimos uma mensagem parcial:
Digite um nmero: 4
4 ao cubo
main
x 4
soma
A funo cubo chamada na linha 12, para alterar o valor de x, enquanto a funo main fica
em espera. A chamada da funo no pode estar em um comando de impresso pois a funo
a
no retorna valor algum.
Na funo cubo, a agora uma referncia para o x da funo chamadora e alteraes em a
faro com que x seja alterado, pois a apenas um apelido para x.
main
x 4
soma
a x
Por este motivo, na linha 18, a (ou x) tem seu valor alterado para 64.
main
x 64
soma
a x
9.8 Retornando vrios valores 137
Por fim, a funo cubo encerrada e, apesar de no retornar nada, o valor de x foi alterado.
A funo main retorna na linha 13 e repare que o novo valor de x impresso ainda na mesma
linha.
Digite um nnero: 4
4 ao cubo 64
main
x 64
9.8 Retornando vrios valores

Cada funo pode retornar apenas um elemento de um certo tipo. No exemplo anterior,
utilizamos a passagem de parmetros por referncia para influenciar a funo chamadora sem
precisarmos utilizar o recurso de retorno. Quando quisermos alterar mais de um elemento em
uma funo, este tambm o recurso mais utilizado para realizarmos esta tarefa.
Neste exemplo, temos uma funo maxmin retorna o mnimo e o mximo entre trs nmeros.
2
4
5 void maxmin ( int a , int b , int c , int & minimo , int & maximo );
6
7 int main () {
8 int x , y , z , menor , maior ;
9 cout << " Digite 3 n meros : " ;
10 cin >> x >> y >> z ;
11 maxmin (x , y , z , menor , maior );
12 cout << " O menor " << menor << endl ;
13 cout << " O maior " << maior << endl ;
14 return 0;
15 }
16
17 void maxmin ( int a , int b , int c , int & minimo , int & maximo ) {
18 if ( a > b ){
19 minimo = b ;
20 maximo = a ;
21 }
22 else {
23 minimo = a ;
24 maximo = b ;
25 }
26 if ( c < minimo ){
27 minimo = c ;
28 }
29 if ( c > maximo ){
30 maximo = c ;
31 }
32 }
Na linha 5, antes da funo principal main, declaramos ento a funo maxmin, que tem
dois parmetros passados por referncia. Como queremos retornar dois valores da funo, as
variveis int minimo e int maximo so passadas por referncia para guardar os resultados.
Sendo assim, na linha8, criamos 5 variveis no main. Perceba que os valores de x, y e z so
dados pelo usurio nas linha 9 e 10. As variveis menor e maior ficam sem valores definidos
por enquanto pois elas guardaro os resultados.
Digite 3 nmeros: 6 3 9
main
x 6 y 3 z 9
menor maior
Os valores de menor e maior sero dados pela funo maxmin. A funo main, na linha 11,
fica ento em espera at que maxmin seja executada.
Na funo maxmin, a, b e c so recebidos por valor de x, y e z, respectivamente. Enquanto
isso minimo e maximo so referncias para menor e maior, da funo chamadora.
main
x 6 y 3 z 9
menor maior
maxmin
minimo menor maximo maior
a 6 b 3 c 9
Exemplificamos agora o funcionamento da funo maxmin. Na linha 18, testamos entre a e

b qual a varivel de maior valor. Como a > b verdadeiro, nas linhas 19 e 20, minimo recebe o
valor de b e maximo recebe o valor de a.
9.9 Arranjos como parmetros 139
Nas linhas 26 e 29, comparamos c com o maior e menor valores j encontrados. Na linha 26,
a condio c < minimo falsa, o que quer dizer que minimo j tem o maior valor entre os trs
nmeros. Mas, como na linha 29 a condio c > maximo verdadeira, significa ento que c
ainda maior que a, que foi o valor atribudo a maximo na outra condio. Portanto, maximo,
recebe o valor de c na linha 30.
Neste ponto, a funo maxmin termina sem retornar nada, mas os valores de menor e maior
do main foram modificados corretamente pela funo.
main
x 6 y 3 z 9
menor 3 maior 9
maxmin
minimo menor maximo maior
a 6 b 3 c 9
Ao retornarmos execuo da funo main, na linha 11, os resultados so impressos nas

linhas 12 e 13.
Digite 3 nmeros: 6 3 9
O menor 3
O maior 9
! Vimos vrios exemplos onde parmetros so passados por valor e por referncia para
uma funo. Do ponto de vista de resultados, se uma varivel no ser alterada dentro da
funo, as passagens por valor ou por referncia tem, exatamente, os mesmos resultados.
Porm, do ponto de vista de eficincia, se uma varivel no alterada dentro da funo, a
passagem por referncia usualmente mais eficiente pois no necessrio o procedimento
de cpia.
9.9 Arranjos como parmetros

Como j vimos anteriormente, arranjos so endereos de memria onde se inicia uma
sequncia de valores do mesmo tipo. Por esse motivo, arranjos so sempre passados por referncia
j que, mesmo em caso de cpia, apenas o endereo do arranjo passado como parmetro, e
no seus elementos. Como eles so passados sempre por referncia, no necessrio utilizar o
e"comercial (&) para passar arranjos como referncia. Se quisermos passar uma cpia de todos
os valores no arranjo, uma cpia destes elementos deve ser feita explicitamente ainda na funo
chamadora.
Neste exemplo, criaremos uma funo que incrementa em 1 cada elemento do arranjo a.

2
4
5 void incrementa ( int a [] , int n );
6
7 int main () {
8 int x [] = {3 ,4 ,2 ,6};
9 incrementa (x ,4);
10 cout << x [0] << " " ;
11 cout << x [1] << " " ;
12 cout << x [2] << " " ;
13 cout << x [3] << " " ;
14 return 0;
15 }
16
17 void incrementa ( int a [] , int n ) {
18 for ( int i = 0; i < n ; ++ i ){
19 a [ i ]++;
20 }
21 }
Na linha 5, no cabealho da funo, o arranjo ser passado por referncia, mesmo sem ter
um e"comercial (&). O tamanho n do arranjo passado por valor.
Na funo principal main, linha 8, criamos um arranjo de tamanho 4. J na linha 9, a funo
main fica em espera para a execuo da funo incrementa. Veja que, na funo incrementa, a
recebe o endereo do arranjo x por referncia e n recebe 4 por valor.
main
x 3 4 2 6
incrementa
a x n 4
No lao definido pelas linhas 18 a 20 da funo, cada elemento do arranjo a incrementado

em 1. Assim, a funo incrementa termina sem retornar nada e o arranjo x agora tem seus
elementos incrementados.
9.10 Ponteiros como parmetros 141
main
x 4 5 3 7
incrementa
a x n 4
A funo main volta a ser executada na linha 10. Os elementos do arranjo x so impressos
no main, da linha 10 ate a 13.
4 5 3 7
Note como o arranjo foi passado por referncia sem o e comercial (&).
9.10 Ponteiros como parmetros

A passagem de variveis por referncia no a nica maneira de uma funo alterar valores da
funo chamadora. Imagine um ponteiro com o endereo de uma varivel da funo chamadora.
Se esse ponteiro passado para uma funo, ele ainda aponta na memria para a varivel da
funo chamadora.
Neste exemplo, utilizaremos ponteiros para alterar variveis da funo chamadora.
2
4
5 void cubo ( int * x );
6
7 int main () {
8 int num ;
10 cin >> num ;
11 cout << num << " ao cubo " ;
12 cubo (& num );
13 cout << num << endl ;
14 return 0;
15 }
16
17 void cubo ( int * x ) {
18 * x = (* x ) * (* x ) * (* x );
19 }
Declaramos a funo cubo na linha 5, que recebe um ponteiro para um int. A funo elevar
o valor apontado ao cubo. Inicializamos, nas linhas 8 a 10 do main, uma varivel chamada num.
Imprimimos uma mensagem parcial na linha 11:
Digite um nmero: 5
5 ao cubo
main
num 5
Logo aps, veja que a funo main, na linha 12, fica em espera at que a funo cubo seja
executada. Note que a varivel num no pode ser enviada diretamente para cubo, pois cubo
espera um ponteiro para um int e no um int. Mas, como ponteiros guardam endereos de
variveis na memria, a funo main envia para a funo cubo o endereo da varivel num. Na
funo cubo, como x tem o endereo da varivel num, isso faz com que x aponte para num. Isso
acontece mesmo com o endereo tendo sido passado por valor.
main
num 5
cubo
Quando acessamos o valor apontado por x, como na linha 18 do cdigo, trabalhamos com a
varivel num da funo chamadora, que neste caso elevada ao cubo.
main
num 125
cubo
A funo cubo encerra sem retornar nada e a funo main retoma a execuo com o valor da
varivel num alterado. Imprimimos, enfim, na linha 13, o valor alterado de num ainda na mesma
linha.
9.11 Recurso 143
Digite um nmero: 5
5 ao cubo 125
main
num 125
A passagem de ponteiros por valor era utilizada especialmente em C. Isso ocorria, pois C
no tinha o recurso de se passar parmetros por referncia com um &. Sendo assim, este era o
nico modo de se alterar valores da funo chamadora. Em C++, este um recurso que pode
menos interessante j que precisamos saber na funo chamadora se um ponteiro esperado pela
funo chamada. De qualquer maneira, h uma grande quantidade de cdigo ainda disponvel
que utiliza este recurso, que precisa ser conhecido.
9.11 Recurso
Normalmente, organizamos um programa de maneira hierrquica, onde algumas funes
chamam outras. J uma funo recursiva, uma funo que direta ou indiretamente chama a si
mesma.
Quando funes recursivas so chamadas, usualmente, elas s sabem resolver problemas
simples, chamados de caso base. Se ela chamada para um problema mais complexo, ela o
divide em partes menores, partes que sabe resolver e partes que no sabe resolver. Para que a
recurso funcione, a diviso deve levar sempre a um problema parecido, porm pelo menos um
pouco menor. Ento, a funo chama uma cpia dela para trabalhar no problema menor, o que
chamamos de um passo de recurso.
Quando uma funo chama a si mesma, a funo fica esperando que sua cpia seja executada
para ela resolver o problema menor. O prprio passo de recurso pode levar a vrias outras
cpias da funo com problemas menores. Essa sequncia de problemas menores deve convergir,
finalmente, ao caso base, que ser resolvido.
Quando no resolvemos um problema recursivamente, dizemos que estamos resolvendo o
problema iterativamente.
Por exemplo, o valor de n! (n fatorial) pode ser calculado iterativamente como:
n! = n (n 1) (n 2) . . . 3 2 1
J recursivamente, o valor de n! pode ser definido como:
n! = n (n 1)! (Passo recursivo) 1! = 1 (Caso base)
Na definio recursiva temos um um passo recursivo que depende do prprio conceito de

nmeros fatoriais ((n 1)!) para calcular n!. J no caso base da mesma definio recursiva,
sabemos que 1! igual a 1. Este caso base leva ao fim da recurso. Sem o caso base, no
conseguiramos saber o fatorial de qualquer nmero. Note que o passo recursivo usa a prpria
definio de um nmero fatorial, porm, para um problema menor.
Neste primeiro exemplo, temos uma funo iterativa que retorna n!.

2
4
5 int fatorial ( int n );
6
7 int main () {
8 int num = 5;
9 cout << num << " ! = " << fatorial ( num ) << endl ;
10 return 0;
11 }
12
13 int fatorial ( int n ) {
14 int resultado = 1;
15 for ( int i = n ; i > 1; i - -){
16 resultado *= i ;
17 }
19 }
Inicializamos, na linha 8 do main, uma varivel num que recebe o nmero 5. Logo em
seguida, a funo main aguarda o retorno da funo fatorial. O parmetro n na funo
fatorial, recebe o valor da varivel num por valor.
main
num 5
fatorial
n 5
J dentro da funo fatorial, na linha 14, a varivel resultado criada e inicializada em

1.
main
num 5
fatorial
resul
n 5 1
tado
9.11 Recurso 145
Dentro de um lao de repetio, que se inicia na linha 15, resultado receber as multi-
plicaes pelos valores de n at 1. Para isso, criado no escopo do for o contador i, que ir
percorrer os valores entre n e 1.
Na linha 16, enquanto i > 1, o resultado multiplicado por i. Quando i tem valor 5:
main
num 5
fatorial
resul
n 5 5 i 5
tado
O valor de i alterado em i para 4, e como i > 1, o resultado multiplicado por 4.
main
num 5
fatorial
resul
n 5 20 i 4
tado
main
num 5
fatorial
resul
n 5 60 i 3
tado

main
num 5
fatorial
resul
n 5 120 i 2
tado
No fim do processo, i tem valor 1 e a condio do for passa a ser falsa.

main
num 5
fatorial
resul
n 5 120 i 1
tado
O escopo do for encerrado e passamos para a linha 18 do cdigo, onde a varivel

resultado ser retornada.
main
num 5
fatorial
resul
n 5 120
tado
A funo fatorial encerrada, suas variveis so apagadas e, na linha 9, main retoma sua
execuo com o valor retornado 120.
5! = 120
main
num 5
9.11 Recurso 147
Essa foi uma verso iterativa da funo fatorial. Veja agora um segundo exemplo onde a
soluo do mesmo problema encontrada com uma funo recursiva:
2
4
5 int fatorial ( int n );
6
7 int main () {
8 int num = 5;
9 cout << num << " ! = " << fatorial ( num ) << endl ;
10 return 0;
11 }
12
13 int fatorial ( int n ) {
14 if ( n <= 1){
15 return 1;
16 } else {
17 return n * fatorial (n -1);
18 }
19 }
Declaramos uma funo recursiva fatorial na linha 5, que retorna n!. Note que no h
diferena no modo como a funo declarada para a verso iterativa. Na linha 8, criamos e
inicializamos uma varivel num no escopo da funo main.
main
num 5
Na linha 9, nossa funo principal fica em espera at que a funo fatorial seja executada.
A funo fatorial(5), que inicia na linha 13, recebe o valor de num em n.
main fatorial(5)
num 5 n 5
Na linha 14, como n no zero, a funo fatorial tenta, na linha 17, retornar n *
fatorial(4). Mas ao tentar fazer este retorno, a funo colocada em espera do retorno
de uma outra funo fatorial, que recebe 4 como parmetro.
main fatorial(5) fatorial(4)
num 5 n 5 n 4
A segunda funo fatorial(4), por sua vez, tem um problema menor do que o problema
original fatorial(5). Isto o que denominamos passo recursivo.
Um novo escopo para esta verso da funo fatorial(4) criado. Essa cpia da funo
tem 4 como parmetro num. Na linha 17, novamente, a funo fatorial(4) tenta retornar 4
* fatorial(3), mas isso faz com que ela tambm fique em espera de outra cpia da funo
fatorial.
num 5 n 5 n 4
fatorial(3)
n 3
Essa cpia recebe o valor 3 como parmetro e fica em espera ao tentar retornar 3 *
fatorial(2).
num 5 n 5 n 4
fatorial(3) fatorial(2)
n 3 n 2
Em seguida, a funo fatorial que recebe o valor 2, tambm entra em espera at o clculo
do fatorial(1).
num 5 n 5 n 4
fatorial(3) fatorial(2) fatorial(1)
n 3 n 2 n 1
Nesta ltima chamada, a funo fatorial recebe 1. Este o nosso caso base, ou seja, o
problema que nossa funo sabe resolver sem precisar enviar um problema para outra funo.
Chamamos esta pilha de cpias da funo, como as geradas at aqui, de pilha de recurso.
9.11 Recurso 149
A funo fatorial(1), na linha 15, retorna 1 para a funo que a chamou. Logo,
fatorial(2) sai de espera e pode retornar para fatorial(3) o seu resultado 2. O fatorial(3),
tambm sai de espera e pode retornar o seu resultado 6 para fatorial(4). Quando o resultado
24 de fatorial(4) retornado para fatorial(5), voltamos a nossa primeira chamada da
funo fatorial. Por fim, o fatorial(5) pode finalmente retornar seu resultado 120 para o
main, que o havia chamado na linha 9. A funo main, aps todo este processo, sai de espera e
volta a funcionar com o valor retornado, que 120.
5! = 120
A recursividade demonstra o poder de funes para dividir problemas em problemas menores.

Alguns problemas, como os nmeros fatoriais, podem ser definidos recursivamente de maneira
bem clara.
Como vimos no exemplo, as chamadas recursivas criam uma pilha de chamadas de funes,
que pode gastar muita memria. Por esse motivo nem sempre ser apropriado usar uma soluo
recursiva para um problema.
Qualquer problema resolvido recursivamente pode ser resolvido iterativamente. Porm, a
recurso pode tornar o programa mais fcil de entender ou depurar. Algumas vezes, a soluo
iterativa no to evidente. Devido a pilha de chamadas de funo, evite usar recursividade em
situaes em que precisamos de desempenho.
! preciso tomar cuidado para garantir que as funes recursivas levem a um caso base.
Caso contrrio, pode ocorrer uma recurso infinita que ser esgotada quando acabar a
memria para a pilha de funes. Esse um problema similar a um lao infinito em uma
funo iterativa e estruturas de repetio em geral.
9.11.1 Exerccios
Exerccio 9.1 Analise o cdigo abaixo, que est incompleto.
2
4
5 // cabe alhos
6 int cubo ( int a );
7 int potencia ( int a , int b );
8 int fatorial ( int a );
9
10 // fun o principal
11 int main (){
12 int x ;
13 cout << " Digite um numero : " ;
14 cin >> x ;
15
16 cout << x << " elevado ao cubo = " << cubo ( x ) << endl ;
17
18 int y ;
19 cout << " Digite um valor para o outro n mero : " << endl ;
20 cin >> y ;
21
22 cout << x << " elevado a " << y << " = " ;
23 cout << potencia (x , y ) << endl ;
24
25 cout << x << " ! = " << fatorial ( x ) << endl ;
26
27 return 0;
28 }
29
30 int cubo ( int a ){
31 return -1;
32 }
33
34 int potencia ( int a , int b ){
35 return -1;
36 }
37
38 int fatorial ( int a ){
39 return -1;
40 }

Exerccio 9.2 Edite a funo cubo (ela est definida aps o main) para que a linha 16 passe
a funcionar corretamente.
Exerccio 9.3 Editar a funo potencia para que o comando da linha 23 passe a funcionar.

Exerccio 9.4 Editar a funo fatorial para que o comando da linha 25 passe a funcionar.


2
4
5 // cabecalho da fun o com a qual vamos trabalhar
6 int potencia ( int x , int y );
7 // fun o para ordenar arranjos
8 void ordena ( int a [] , int n );
9
10 int main (){
11 // a ser elevado a b e guardaremos o resultado
12 int a , b , resultado ;
13 do {
14 cout << " Digite a base : " ;
15 cin >> a ;
9.11 Recurso 151
16 cout << " Digite o expoente : " ;

17 cin >> b ;
18 // chamando a fun o que definiremos apos o main
19 resultado = potencia (a , b );
20 cout << a << " elevado a " << b << " " ;
21 cout << resultado << endl ;
22 } while ( a != -1); // programa se repete enquanto a != -1
23 return 0;
24 }
25
26 // fun o que eleva x a y
27 int potencia ( int x , int y ){
28 int produto = x ;
29 int i ;
30 for ( i =1; i < y ; i ++){
31 produto *= x ; // equivale a produto = produto * * x
32 }
33 return produto ;
34 }
35
36 // Ordena arranjo com " m todo da bolha "
37 void ordena ( int a [] , int n )
38 {
39 int i ,j , aux ;
40 for ( j = n -1; j >0; j - -)
41 for ( i =0; i < j ; i ++)
42 {
43 if ( a [ i +1] < a [ i ])
44 {
45 // trocar a [ i ] com a [ i +1]
46 aux = a [ i ];
47 a [ i ] = a [ i +1];
48 a [ i +1] = aux ;
49 }
50 }
51 }

Exerccio 9.6 Troque a funo int potencia(int x, int y) com passagem de par-
metros por valor por uma funo int potencia(int &x, int &y) com passagem por
referncia.
O que se alterou no programa do ponto de vista de resultados? Porqu?
O que se alterou no programa do ponto de vista de sua interpretaco pelo computador?
Em quais casos a diferena de passagem por valor e por referencia se torna relevante?

Exerccio 9.7 Simule uma passagem de parmetros por referncia atravs de ponteiros
passados por valor. Para isso, crie uma nova funo potencia2 para no perder a resposta
das perguntas anteriores.
Como a passagem de parmetros por referncia pode ser simulada com ponteiros passados
por valor? Crie uma nova funo potencia2 para no perder a resposta das perguntas
anteriores.
Tendo a funo potencia2 com passagem por referncia atravs de ponteiros passados
por valor. Descreva qual a desvantagem desta abordagem do ponto de vista do programador.

Exerccio 9.8 Crie uma nova verso da funo potencia chamada potencia3. Refaa a
funo de modo que ela retorne void, a passagem de todas as variveis seja por referncia e
o resultado ser guardado diretamente em uma varivel extra passada como argumento.
Exerccio 9.9 Refaa esta funcao em uma funo potencia4 de modo que ela seja recursiva,
ou seja, a funo far uso de si mesma. Ex: x0 = 1, x1 = x x0 , x2 = x x1 , x3 = x2 x, . . . ,
xn = x(n1) x
Exerccio 9.10 Analise a funo ordena(). Veja como ela recebe um arranjo e o tamanho
deste arranjo. Crie no main um arranjo que a utilize.
Substitua os comandos da funo ordena, responsveis pela troca, por uma chamada a
uma nova funco void troca(int &a, int &b) que recebe como parmetros duas vari-
veis e troque seus contedos.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Estruturas
0
10.
1 01
0
1
0
0 0
1
110 01
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 01 0 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Estruturas, ou registros, so conjuntos de elementos agrupados de dados. Essa uma

ferramenta que nos permite criar novos tipos de dados a partir dos tipos existentes. Estas
estruturas so declaradas em C++ com a instruo struct. Os elementos de dados de uma
estrutura so chamados de membros e cada membro da estrutura pode ser de um tipo diferente
de dados.
Sintaxe
Temos aqui um exemplo de sintaxe para criao de um estrutura:
1 struct nome_do_tipo {
2 tipo_do_membro1 nome_do_membro1 ;
5 };
O nome_do_tipo o nome da estrutura que queremos criar. Entre chaves { e }, temos uma
lista de membros de dados. Cada membro tem um tipo de dados e um identificador. Essas
estruturas completas podem ser utilizadas para criar novos tipos de dados a partir dos tipos de
dados j existentes.
Por exemplo, uma estrutura como a seguinte pode ser utilizada para representar produtos:
1 struct produto {
2 double preco ;
3 double peso ;
4 string nome ;
5 };
Com esta estrutura, declaramos um novo tipo de dados chamado produto. Esse tipo de
dados contm 2 membros do tipo double e um membro do tipo string.
O novo tipo produto j pode ser utilizado para declararmos variveis desse tipo em nosso
programa. Por exemplo, uma varivel produto que represente uma ma ou um abacaxi.
154 Captulo 10. Estruturas
Os membros dessas variveis podem ser acessados diretamente com um ponto (.) entre o
identificador da varivel e o identificador do membro, como no exemplo abaixo:
1 produto pera ;
2 pera . peso = 0.3;
3 pera . nome = " P ra Williams " ;
4 cout << " Digite o pre o : " ;
5 cin >> pera . preco ;
6 cout << " Peso da p ra : " << pera . peso << endl ;
Nas linhas 1 do exemplo, criamos uma varivel do tipo produto que com nome identificador
pera. Nas linhas 2 e 3 definimos os membros peso e nome desta varivel pera atravs do
operador de atribuio. Nas linhas 4 e 5, utilizamos um cin para que usurio possa definir
o valor do membro peso da varivel pera. Na linha 6, o valor do membro peso da pera
impresso com um cout. O acesso a membros sempre feito com um ponto (.).
Exemplo
Neste exemplo, vamos criar um novo tipo de dado e utiliz-lo em nosso programa.
2
4
5 struct produto {
6 double preco ;
7 double peso ;
8 string nome ;
9 };
10
11 int main () {
12 produto x ;
13 x . peso = 0.3;
14 x . nome = " P ra " ;
16 cin >> x . preco ;
17 cout << " Peso da " << x . nome << " : " << x . peso << endl ;
18 return 0;
19 }
Antes da nossa funo principal main, declarado o novo tipo de dados produto nas linhas
5 a 9. Na linha 12, criada uma varivel x do tipo produto no escopo de main. Observe que x,
apesar de ser apenas uma varivel, tem 3 membros: preco, peso e nome.
main
x.preco x.peso x.nome
Com um ponto (.) entre o nome da varivel e o nome do membro, atualizamos o valor do
peso de x (x.peso) na linha 13. O peso deste produto recebe 0.3.
10.1 Arranjos de estruturas 155
main
x 0.3
De maneira similar, na linha 14, o nome de x recebe a string Pera.
main
x 0.3 Pra
Nas linhas 15 e 16, o usurio atribui um valor a x.preco atravs do fluxo de entrada, com o
nmero 2.3.
Digite o preo: 2.3
main
x 2.3 0.3 Pra
Ento, na linha 17, imprimimos os membros nome e peso do objeto x.
Digite o preo: 2.3

Peso da pra: 0.3
10.1 Arranjos de estruturas

Vimos ento que as estruturas servem para definir novos tipos de dados a partir dos tipos j
conhecidos. Como estruturas so novos tipos de dados, elas tambm podem ser utilizadas como
tipos de arranjos.
Neste exemplo, criaremos um arranjo da dados do tipo produto.
3
5
6 struct produto {
7 double preco ;
8 double peso ;
9 string nome ;
10 };
11
12 int main () {
13 const int n = 5;
14 produto p [ n ];
15 for ( int i =0; i < n ; ++ i ){
16 cout << " Produto " <> p [ i ]. preco ;
19 cout << " Digite o peso : " ;
20 cin >> p [ i ]. peso ;
21 cout << " Digite o nome : " ;
22 cin >> p [ i ]. nome ;
23 }
24 for ( int i =0; i < n ; ++ i ){
25 cout << p [ i ]. nome << " \ t " ;
26 cout << " R$ " << p [ i ]. preco << " \ t " ;
27 cout << p [ i ]. peso << " kg " << endl ;
28 }
29 return 0;
30 }
Antes de nossa funo principal, nas linhas 6 a 10, declaramos o novo tipo de dados produto.
J na funo principal, na linha 13, definimos a constante n com valor 5 e, na linha 14, criamos
um arranjo de produtos p, que tem capacidade para n produtos.
main
p[0] p[1] p[2] p[3] p[4]
n 5
Note como cada elemento do arranjo tem espao para os trs membros de um produto: preo,
peso e nome. Na primeira iterao do for definido nas linhas 15 a 23, o usurio atribui valores
aos membros do primeiro produto. Para isto, indicamos uma posio do arranjo e o membros
desta posio, com p[i].preco, p[i].peso ep[i].nome.
Produto 0
Digite o preco: 2.3
Digite o peso: 0.3
Digite o nome: Pra
No conjunto de todas as iteraes, passando por todos os valores de i, teremos dado valores
a todos os membros de todos os produtos.
...
Digite o nome: Lima
Produto 3
Digite o preo: 6.5
Digite o peso: 2.3
Digite o nome: Ma
Produto 4
Digite o preo: 7.2
Digite o peso: 0.56
Digite o nome: Uva
main
p 2.3 0.3 Pra 8.6 0.2 Kiwi 1.5 1.2 Lima 6.5 2.3 Ma 7.2 0.56 Uva
p[0] p[1] p[2] p[3] p[4]
n 5 i 5
J no outro conjunto de iteraes, definido nas linhas 24 a 28, imprimimos todos os produtos
do arranjo de maneira anloga.
...
Produto 4
Digite o preo: 7.2
Digite o peso: 0.56
Digite o nome: Uva
Pra R$2.3 0.3kg
Kiwi R$8.6 0.2kg
Lima R$1.5 1.2kg
Ma R$6.5 2.3kg
Uva R$7.2 0.56kg
10.2 Estruturas e ponteiros

Quando temos um ponteiro px apontando para uma estrutura x, podemos acessar os membros
de x atravs do valor apontado por px, ou seja, (*px).membro). Porm, podemos fazer o mesmo
com o operador de seta ->, como em px->membro. Este operador de seta retorna o membro do
elemento apontado por px.
Nesse exemplo, criaremos ponteiros para produtos que esto em um arranjo. Temos no
exemplo, na linha 16, um ponteiro para um produto que se chama barato. Ele ir apontar para
o produto mais barato do arranjo.
3
5
6
7 struct produto {
8 double preco ;
9 double peso ;
10 string nome ;
11 };
12
13 int main () {
14 const int n = 5;
15 produto p [ n ];
16 produto * barato ;
17 for ( int i =0; i < n ; ++ i ){
18 cout << " Produto " <> p [ i ]. preco ;
21 cout << " Digite o peso : " ;
22 cin >> p [ i ]. peso ;
23 cout << " Digite o nome : " ;
24 cin >> p [ i ]. nome ;
25 }
26 barato = & p [0];
27 for ( int i =1; i < n ; ++ i ){
28 if ( p [ i ]. preco < barato - > preco ){
29 barato = & p [ i ];
30 }
31 }
32 cout << " Produto mais barato : " << endl ;
33 cout << barato - > nome << " \ t " ;
34 cout << " R$ " << barato - > preco << " \ t " ;
35 cout << barato - > peso << " kg " << endl ;
36 return 0;
37 }
declarado no cdigo, na linha 6, o novo tipo de dados produto. Nas linhas 14 a 16,
criamos a constante n, um arranjo p de tamanho n para dados do tipo produto e um ponteiro
barato, tambm para dados do tipo produto.
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato
Exatamente como no exemplo anterior, a partir da linha 16, damos valores a todos os produtos
de nosso arranjo.
...
Dite o nome: Lima
Produto 3
Digite o preo: 6.5
Digite o peso: 2.3
Digite o nome: Ma
Produto 4
Digite o preo: 7.2
Digite o peso: 0.56
Digite o nome: Uva
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato i 5
Em seguida, na linha 26, o ponteiro barato aponta para o primeiro elemento do arranjo. O
endereo do primeiro elemento do arranjo pode ser acessada tanto com &p[0] quanto com p.
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato
Temos entre as linhas 27 e 31 um lao que procura o elemento mais barato do arranjo. O
ponteiro barato aponta para o primeiro elemento e comearamos a busca a partir do segundo
elemento p[1].
Na linha 28, na primeira iterao do lao, se o elementop[1] fosse mais barato que o
apontado por barato, barato apontaria para p[1]. Repare como o operador de seta est sendo
usado na linha 28.
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato i 1
Na prxima iterao, quando i tem valor 2, como p[2] mais barato que o elemento
apontado por barato, ento ele passa a ser o elemento apontado.
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato i 2
Ao fim do for, teremos testado isso para todos os elementos, porm nenhum foi mais barato
que p[2] neste exemplo.
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato i 5
Aps o fim do lao, utilizamos novamente o operador de seta, nas linhas 32 a 35, para
imprimir os dados sobre elemento mais barato do arranjo.
...
Digite o preo: 6.5
Digite o peso: 2.3
Digite o nome: Ma
Produto 4
Digite o preo: 7.2
Digite o peso: 0.56
Digite o nome: Uva
Produto mais barato:
Lima R$1.5 1.2kg
main
p[0] p[1] p[2] p[3] p[4]
n 5 barato
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Alocao
0
11.
1 0 1
0 de 0memria
1
0 1 0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
11.1 Alocao automtica de memria

Para cada varivel de nosso programa, h uma quantidade de memria que precisa ser alocada
para nossas variveis. Quando executamos uma funo ou bloco de cdigo, o sistema operacional
aloca a memria necessria para todas as suas variveis. Essa a memria automaticamente
alocada. Por isso, por exemplo, importante dizermos o tamanho dos arranjos em nosso
programa, diretamente ou atravs de constantes.
Neste exemplo de cdigo, criamos algumas variveis:
3
5
6 int main () {
7 int x = 4;
8 int * px = & x ;
9 int a [] = {2 ,4 ,5 ,3};
10 int b [5];
11 int i ;
12 for ( i =0; i <5; ++ i ){
13 b [ i ] = a [0] + i ;
14 }
15 const int n = 5;
16 int c [ n ];
17 for ( i =0; i < n ; ++ i ){
18 c [ i ] = a [1] + i ;
19 }
20 return 0;
21 }
162 Captulo 11. Alocao de memria
Antes de iniciar o main, o sistema operacional j aloca memria para 16 inteiros e um

ponteiro para inteiro. Essa a memria alocada de maneira automtica para o main.
x px a[0] a[1] a[2] a[3] b[0] b[1] b[2] b[3] b[4] i c[0] c[1] c[2] c[3] c[4]
Repare na linha 15 que n uma constante. Valores de constantes no podem ser alterados
durante o programa. Repare tambm que, por ele ser constante, no existe memria alocada para
ele. No necessrio alocar memria para constantes pois sabemos que seu valor nunca se altera.
simplesmente como se todas as aparies de n no cdigo fossem substitudas por seu valor.
Assim, os dois cdigos abaixo so equivalentes:
1 const int n = 5; 1 int c [5];

2 int c [ n ]; 2 for ( i =0; i <5; ++ i ){
3 for ( i =0; i < n ; ++ i ){ 3 c [ i ] = a [1] + i ;
4 c [ i ] = a [1] + i ; 4 }
5 }
De maneira anloga, esse trecho de cdigo pode levar a uma mensagem de erro:
3
5
6 int main () {
7 int n ;
8 cout << " Digite o tamanho desejado de vetor : " ;
9 cin >> n ;
10 int x [ n ];
11 for ( int i =0; i < n ; ++ i ){
12 x [ i ] = i +1;
13 }
14 return 0;
15 }
Isso acontece porque na linha 10, usamos uma varivel para definio do tamanho do arranjo.
Assim, o sistema no consegue determinar quanta memria ser necessria para a funo antes
de iniciar main.
! Apenas constantes podem definir o tamanho de arranjos alocados automaticamente.
11.2 Alocao dinmica de memria

Em vrias situaes, no sabemos a quantidade de memria necessria para fazermos tudo o
que precisamos antes de iniciar o programa. Isso comum quando a quantidade de memria
depende de uma resposta do usurio. Neste caso, necessrio pedir ao sistema para alocar dina-
micamente mais memria do que aquela inicialmente reservada para o programa. Esta memria
alocada dinamicamente pelo sistema durante a execuo dos comandos, diferentemente da

memria alocada de maneira automtica, antes do bloco de comandos se iniciar.
Os operadores new e delete (novo e deletar, em ingls), nos permitem fazer a alocao
dinmica de memria. Suponha agora, que temos uma funo com trs variveis alocadas
automaticamente. x e i so variveis do tipo int. Enquanto isso, px um ponteiro para dados
do tipo int, que at o momento no aponta para ningum:
funcao
x 5 px i 2
O operador new pede ao sistema para alocar dinamicamente memria para mais uma varivel
do tipoint. Essa varivel alocada fora do escopo da funo pois no est sendo alocada
automaticamente.
funcao
x 5 px i 2
Um problema com esse int alocado que no podemos acess-lo ainda pois no existe
um nome identificador para ele. Para resolver este problema, o operador new retorna tambm o
endereo onde foi alocada a memria para o int. Assim, este endereo pode ser atribuido a um
ponteiro, como em px = new int), onde o ponteiro px recebe ento o endereo deste novo int.
funcao
x 5 px i 2
Agora sim podemos acessar essa memria atravs desse ponteiro, como exemplo abaixo:
1 int x = 5;
2 int i = 2;
3 px = new int ;
4 * px = 3;
5 (* px )++;
funcao
x 5 px i 2
Considere agora este exemplo onde utilizamos o comando new duas vezes.
1 int x = 5;
2 int i = 2;
3 px = new int ;
4 * px = 3;
5 px = new int ;
6 * px = 4;
Temos novamente um problema, pois como px aponta ao final do cdigo para o segundo
int, no temos mais como acessar a memria alocada para o primeiro int.
funcao
x 5 px i 2
3 4
vazamento de memria
Quando uma memria fica alocada porm no temos como acess-la, dizemos que houve um
vazamento de memria. Esse um problema srio em programas, pois nossa memria um
recurso finito.
Considere agora esta funo e o estado de suas variveis:
1 void funcao (){
2 int x = 5;
3 int i = 2;
4 int * px ;
5 px = new int ;
6 * px = 4;
7 }
funcao
x 5 px i 2
Quando chegamos ao fim da funo, as variveis do escopo da funo deixam de existir.

Assim, px deixa tambm de existir e no h nenhum ponteiro para a memria alocada. Isso
causa novamente um vazamento de memria.
funcao
x 5 px i 2
muito comum que a memria alocada seja utilizada apenas durante um perodo de tempo.
Por isso, o comando delete pode ser utilizado para liberar essa memria para outros pedidos de
alocao, como no exemplo abaixo:
1 void funcao (){
2 int x = 5;
3 int i = 2;
4 int * px ;
5 px = new int ;
6 * px = 4;
7 delete px ;
8 }
funcao
x 5 px i 2
Repare que o comando delete libera a memria apontada por px e no apaga a varivel px.
Apagar a varivel px nem seria possvel, pois px foi automaticamente alocada.
Em outro exemplo da utilizao do delete, px aponta para um inteiro de valor 3, e na linha
4 ele apagado para apontar para outro inteiro de valor 4:
1 int * px ;
2 px = new int ;
3 * px = 3;
4 delete px ;
5 px = new int ;
6 * px = 4;
funcao
x 5 px i 2
3 4
Como o dado inicialmente apontado por px foi desalocado, ele pode apontar para outro
endereo na memria sem que houvesse vazamento de memria.
11.3 Alocao dinmica de arranjos

O operador new[] pede ao sistema para dinamicamente alocar memria para vrias variveis do
mesmo tipo, atravs de um arranjo:
1 int n = 4;
2 new int [ n ];
funcao
x 5 px i 2
Note que n agora no precisa mais ser uma constante, pois a memria est sendo dinamica-
mente alocada. Isso nos permite, at mesmo, associar o tamanho do arranjo a uma resposta do
usurio, como ocorre no cdigo abaixo:
1 int n ;
2 cout << " Quantos elementos deseja ter no arranjo ? " ;
3 cin >> n ;
4 new int [ n ];
Quantos elementos deseja ter no arranjo? 7

funcao
x 5 px i 2
De maneira anloga a new, new[] retorna o endereo do primeiro elemento do arranjo

alocado. Com um ponteiro para um arranjo, podemos acessar seus elementos com o operador
para retornar o valor apontado (*). Como vimos na Seo 8.4, sobre ponteiros e arranjos,
podemos tambm usar o operador de subscrito [], representado por colchetes, como em um
arranjo automaticamente alocado:
1 int n = 4;
2 px = new int [ n ];
3 * px = 4; // mesmo que px [0]
4 px [1] = 3; // mesmo que *( px +1)
5 px [2] = 5;
6 px [3] = 2;
funcao
x 5 px i 2
4 3 5 2
No cdigo acima, ao fim da utilizao dessa memria, seria importante liber-la para que
no haja vazamento de memria. Para apagar arranjos, usamos delete[] . Mas no confunda
este operador com com o delete simples. O delete simples desaloca a memria de apenas um
elemento:
1 int n = 4;
3 delete [] px ;
funcao
x 5 px i 2
fundamental desalocar toda a memria aps utiliz-la. Aps liberar a memria, para
que px pare de apontar para um endereo onde no h memria alocada, o fazemos apontar
para nullptr, que representa um ponteiro nulo. Isso faz com que o ponteiro no aponte para
nenhum endereo e previne erros futuros. Isso pode ser visto na ltima linha do cdigo abaixo:
1 int n = 4;
3 delete [] px ;
4 px = nullptr ;
funcao
x 5 px i 2
No exemplo abaixo, vamos alocar um arranjo dinamicamente com um tamanho escolhido

pelo usurio.
2
4
5 int main () {
6 int n ;
7 int * x ;
8 cout << " Digite o tamanho desejado de arranjo : " ;
9 cin >> n ;
10 x = new int [ n ];
11 for ( int i =0; i < n ; ++ i ){
12 x [ i ] = i +1;
13 }
14 delete [] x ;
15 x = nullptr ;
16 return 0;
17 }
Antes mesmo de iniciar a funo main, ainda na linha 5, o compilador sabe que ela ter
duas variveis n e x. Essas variveis no existem ainda, mas o espao para elas j foi alocado
automaticamente.
main
x n
Sendo assim, nas linhas 6 e 7, as variveis n e x passam a existir na memria j alocada

automaticamente para elas.
main
x n
Nas linhas 8 e 9, o usurio, por sua vez, atribui o valor que deseja para n, no caso, 5.
Digite o tamanho desejado de arranjo: 5
main
x n 5
Na linha 10, alocada memria para um arranjo de tamanho 5 e x aponta para ele. Repare
que a memria foi alocada no main, mas ela no pertence a seu escopo. Apenas conseguimos
acessar o arranjo atravs do ponteiro que est em main.
main
x n 5
Nas linhas 11 a 13, em um lao de repetio, o arranjo recebe os valores de 1 at n. Neste

trecho de cdigo poderamos ter qualquer outra operao sobre arranjos. Veja que x acessado
atravs de subscritos em x[i].
main
x n 5
1 2 3 4 5
Aps isto, na linha 14, chegamos em um ponto onde no precisamos mais do arranjo alocado.
Assim, o apagamos com a instruo delete[].
main
x n 5
1 2 3 4 5
Na linha 15, fazemos com que x pare de apontar para aquela posio de memria tambm, j
que no temos mais o arranjo naquele endereo.
main
1 2 3 4 5
11.4 Alocao dinmica de arranjos multidimensionais

Como vimos na Seo 5.5, sobre arranjos multidimensionais, os arranjos de vrias dimenses so
representados por arranjos de arranjos. Esta caracterstica importante ao alocar dinamicamente
arranjos multidimensionais.
Considere o cdigo abaixo que aloca dinamicamente um arranjo de 5 elementos:
1 int * x ;
2 x = new int [5];
3 // opera es com o arranjo
4 delete [] x ;
main
*int x
int x[0] x[1] x[2] x[3] x[4]
Neste programa, x um ponteiro para um arranjo de dados do tipo int e x[i] acessa a
posio i deste arranjo. Ao fim do cdigo, a memria desalocado com o comando delete[].
No exemplo abaixo alocamos dinamicamente um arranjo multidimensional como um arranjo
de arranjos:
1 // ponteiro para ponteiros de int
2 int ** x ;
3 // alocando arranjo de ponteiros para int
4 x = new * int [5];
5 // alocando arranjos
6 for ( int i =0; i <5; i ++){
7 x [ i ] = new int [105
8 }
9 // utilizar o arranjo
10 // liberando arranjos
11 for ( i =0; i <5; i ++){
12 delete [] x [ i ];
11.4 Alocao dinmica de arranjos multidimensionais 171
13 }
14 delete [] x ;
Na linha 2, criamos uma varivel x que um ponteiro para ponteiros de dados do tipo int.
Na linha 4, x aponta para um arranjo de tamanho 5. Neste exemplo, note que o comando cria um
arranjo de dados do tipo *int[5]. Ou seja, apesar da representao grfica similar, o arranjo
criado um arranjo de ponteiros para nmeros inteiros, e no um arranjo de nmeros inteiros.
Cada posio x[i] do primeiro arranjo um ponteiro que deve apontar ento para um outro
arranjo de nmero inteiros.
main
**int x
*int x[0] x[1] x[2] x[3] x[4]
Nas linhas 6 a 8, temos uma estrutura de repetio que faz com que cada x[i] aponte para
um segundo arranjo de tamanho 5, como representado a seguir:
main
**int x
*int x[0] x[1] x[2] x[3] x[4]
int x[0][0] x[0][1] x[0][2] x[0][3] x[0][4]
int x[1][0] x[1][1] x[1][2] x[1][3] x[1][4]
int x[2][0] x[2][1] x[2][2] x[2][3] x[2][4]
int x[3][0] x[3][1] x[3][2] x[3][3] x[3][4]
int x[4][0] x[4][1] x[4][2] x[4][3] x[4][4]
Assim como arranjos multidimensionais alocados automaticamente, podemos utilizar o

operador de subscrito x[i][j] para acessar os elementos da linha i e coluna j. Nas linhas 11 a
12 temos uma estrutura de repetio de libera a memria apontada pelos elementos x[i] antes
de liberarmos o arranjo apontado por x, na linha 13.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Processamento
0
12.
1 0 1
0 0 de arquivos
1
0 10 0
0
1
110
sequenciais
1
1
0
1 0
0
110 0
1
1 0
0
000 0
0
1
1
0
0 0
00 1 00 0 0 0 01 0 01 00 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Todos os dados que guardamos nas variveis em nossos programas so temporrios. Sendo
assim, todos eles deixam de existir logo aps o fim do programa. Os arquivos em unidades
externas de armazenamento so utilizados para guardar esses dados de modo permanente em
outros dispositivos.
Os objetos cin e cout, so criados quando <iostream> includo. O fluxo desses objetos
criam um canal de comunicao do programa com dispositivos de entrada e sada, como o
monitor e o teclado. Com a insero de <fstream>, podemos criar objetos que possibilitam a
comunicao do programa com arquivos. Isto representado na Figura 12.1.
fstream
iostream
Figura 12.1: Bibliotecas iostream e fstream para fluxo de entrada e sada. A biblioteca
fstream faz fluxo de entrada e sada atravs de arquivos.
Os objetos de <fstream> podem ser manipulados assim como os de <iostream>. Os

objetos dos tipos <ofstream> ou <ifstream> funcionam de maneira similar aos objetos cout
174 Captulo 12. Processamento de arquivos sequenciais
e cin: o operador de insero (<<) insere dados no arquivo; o operador de extrao (>>) l os
dados do arquivo.
Neste exemplo, faremos um programa que guarda dados em um arquivo:
2 # include < fstream >
4
6
7 int main () {
8 ofstream fout ( " pessoas . txt " );
9 string nome ;
10 int idade ;
11 int opcao ;
12 do {
13 cout << " Digite um nome : " ;
14 cin >> nome ;
15 cout << " Digite a idade de " << nome << " : " ;
16 cin >> idade ;
17 fout << nome << " " << idade << endl ;
18 cout << " Deseja continuar ? (0 = N o , 1 = Sim ): " ;
19 cin >> opcao ;
20 } while ( opcao !=0);
21 fout . close ();
22 return 0;
23 }
Como mencionado, a insero de <iostream>, na linha 1 do cdigo, cria os objetos cin e
cout. Este objetos fazem o fluxo de sada e entrada no programa. Apesar de no represent-los
graficamente, estes objetos esto constantemente disponveis ao longo de nosso programa:
cout cin
Com a insero de <fstream>, na linha 2 do programa, podemos criar outros objetos que
faam fluxo de sada e entrada com arquivos do computador.
cout cin novo

objeto
175
Veja que o fluxo de relacionamento com o arquivo pode ser nas duas direes, de acordo
com a seta.
Na linha 8 do cdigo, em main, criamos um objeto fout do tipo ofstream, para sada de
dados. Esse objeto conectado a um arquivo chamado pessoas.txt. Criamos tambm, as
variveis nome, idade e opcao nas linhas 9 a 11.
main
fout nome idade opcao
pessoas.txt
Nas linhas 12 a 20, temos uma estrutura de repetio na qual colocaremos dados no arquivo
atravs de fout. Nas linhas 13 a 16, j dentro do lao, perguntamos ao usurio um nome e uma
idade e atualizamos as variveis. Isso feito atravs dos fluxos cin e cout.
Digite um nome: Joo

Digite a idade de Joo: 27
main
fout nome Joo idade 27 opcao
pessoas.txt
Colocamos agora, na linha 17, os valores de nome e idade em nosso arquivo atravs do
objeto fout. Os dados so enviados para o arquivo de texto do mesmo modo que seriam enviados
para a tela, caso cout fosse utilizado.
main
fout nome Joo idade 27 opcao
pessoas.txt
Joo 27
O usurio, nas linhas 18 e 19, escolhe continuar com uma opo diferente de 0, que a
condio do lao.
Digite um nome: Joo

Deseja continuar? (0 = No, 1 = Sim): 1
Repetimos o processo por mais algumas vezes. Em outras iteraes do lao, o usurio insere
mais dois nomes at que decide sair.
Digite um nome: Joo

Digite um nome: Maria
Digite a idade de Maria: 25
Digite um nome: Jos
Digite a idade de Jos: 30
main
fout nome Jos idade 30 opcao 0
pessoas.txt
Joo 27
Maria 25
Jos 30
Como a opo do usurio foi 0 na ltimo iterao, samos do lao. Na linha 21, aps o lao,
fechamos o arquivo pessoas.txt e salvamos os dados. A funo close() pertence ao prprio
objeto fout. A funo open(arquivo.txt) poderia ser utilizada para associar fout a outro
177
arquivo. Em nossa memria secundria, na pasta onde foi executado o programa, temos agora
um arquivo pessoas.txt. No arquivo temos todos os nomes e idades digitados.
Em nosso segundo exemplo, criaremos um fluxo para obter informaes de um arquivo.

4
6
7 int main () {
8 ifstream fin ( " pessoas . txt " );
9 string nome ;
10 int idade ;
11 while (! fin . eof ()){
12 fin >> nome ;
13 fin >> idade ;
14 cout << nome << " " << idade << endl ;
15 }
16 fin . close ();
17 return 0;
18 }
Para ler um arquivo, na linha 8, primeira do main, criamos um objeto do tipo ifstream para
um fluxo de entrada atravs de arquivo. O arquivo j contm as informaes que sero lidas.
Criamos tambm, nas linhas 9 e 10, as variveis nome e idade para armazenar temporariamente
as informaes do arquivo.
main
fout nome idade
pessoas.txt
Joo 27
Maria 25
Jos 30
Na linha 11, A funo eof() uma abreviao para end of file (ou fim de arquivo, em
ingls). Esta funo retorna um bool indicando se j estamos no fim do arquivo. No momento
ela retornar false pois acabamos de abrir o arquivo e estamos ainda no seu incio. Na linha 11,
em outras palavras, a expresso completa do while diz que repetiremos o bloco de comandos
enquanto no estivermos no fim do arquivo.
Nas linhas 12 e 13, usamos o objeto fin para ler um nome do arquivo para a varivel nome
e depois um nmero para outra varivel idade. Apesar dos dados virem do arquivo, estes
comandos funcionam da forma muito similar a um cin. Em seguida, na linha 14, imprimimos
os valores lidos e guardados nas variveis.
Joo 27
main
fout nome Joo idade 27
pessoas.txt
Joo 27
Maria 25
Jos 30
De acordo com a condio da linha 11, como estamos dentro de um lao de repetio e ainda
no estamos no fim do arquivo, vamos ler o prximo nome e a prxima idade. Imprimimos com
cout.
Joo 27
Maria 25
Mas este ainda no o fim do arquivo. Lemos o outro nome, outra idade, e imprimimos o
resultado:
Joo 27
Maria 25
Jos 30
Chegamos ao fim do arquivo e por isso o bloco de comandos no se repetir.

Na linha 16, fechamos ento o arquivo antes de encerrar o programa. O comando open(arquivo.txt)
tambm poderia ser utilizado para associar fin a outro arquivo. O arquivo pessoas.txt conti-
nua em nossa memria secundria e no foi alterado.
12.1 Exerccios
1 // biblioteca para manipulacao de arquivos
2 // ( entrada e saida por arquivos )
5
7
8 int main (){
9 double n1 , n2 , n3 ;
10 // declara o do arquivo de entrada
11 ifstream arq_entrada ;
12 arq_entrada . open ( " teste . xyz " );
12.1 Exerccios 179
13 // enquanto n o chega ao fim do arquivo

14 while (! arq_entrada . eof ()){
15 // coloca dados em n1 , n2 e n3
16 arq_entrada >> n1 >> n2 >> n3 ;
17 // imprime n1 , n2 e n3
18 cout << n1 << " " << n2 << " " << n3 << endl ;
19 }
20 // fechamento do arquivo
21 arq_entrada . close ();
22 return 0;
23 }

Exerccio 12.2 Utilize um editor de textos para criar um arquivo teste.xyz na pasta
onde ser executado o programa. O arquivo dever conter trs nmeros reais em cada linha
separados por espao, em um formato como o apresentado abaixo:
5.2 8.5 4.6

8.3 3.2 6.9
7.8 9.8 1.2
Execute o programa.
Exerccio 12.3 Se o programa for executado corretamente, execute-o novamente, agora para
um arquivo pontos.xyz com milhares de linhas. Estes pontos sero considerados dados
de levantamento topogrfico de uma regio.
Exerccio 12.4 Defina a estrutura Ponto com os seguintes membros

1 struct Ponto {
2 double x ,y , z ;
3 };

Exerccio 12.5 Altere o programa para que os dados dos pontos sejam armazenados em um
arranjo cujos elementos sejam do tipo Ponto. O arranjo deve ter tamanho 2000. O nmero
de elementos do arranjo preenchidos com elementos vlidos deve ser contado.
Exerccio 12.6 Escreva uma funo para encontrar o ponto mais alto da regio. O prottipo
da funo deve ser:
int pontoMaisAlto(Ponto pontos[], int n);
onde n o nmero de pontos no arranjo. A funo dever retornar o ndice do ponto
encontrado no arranjo.
Exerccio 12.7 Escreva uma funo para determinar os limites, no eixos x e y, da regio
ocupada pelos pontos. O prottipo da funo deve ser:
void limites(Ponto pontos[], int n, double &minX, double &maxX, double
&minY, double &maxY);
Exerccio 12.8 Refaa o programa de maneira que a tamanho do arranjo para os pontos seja
alocado dinamicamente com a instruo new.
O arquivo deve ser lido uma vez apenas para se fazer a contagem do nmero de pontos. A
alocaco ser feita ento com o nmero exato de pontos e os dados sero ento inseridos no
arranjo.
Para se retornar a leitura para o inicio do arquivo, use os comandos:
arq_entrada.clear();
arq_entrada.seekg(0, ios::beg);

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Resumo
0
13.
1 0 de comandos
1
0 0 1
1
0
0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Nesta seo apresentamos um resumo de comandos em C++. Estes comandos podem ser
utis para recordar os conceitos deste captulo ou como referncia para leitores que j so
programadores porm no esto acostumados com a linguagem C++.
13.1 Estrutura base de programas

3 int main (){
4 // ...
5 return 0;
6 }
13.2 Tipos fundamentais de dados
1 // Dado l gico
2 bool nome ;
3 // N meros inteiros
4 short nome ;
5 int nome ;
6 long nome ;
7 // N meros reais
8 float nome ;
9 double nome ;
10 // Caracteres
11 char nome ;
13.3 Cadeias de caracteres
1 // Adicionar cabe alho para strings

182 Captulo 13. Resumo de comandos
2 # include string
3 // Cadeia ( tipo de dado n o fundamental )
4 string nome ( " texto " );
13.4 Operadores bsicos
1 int x = valor ;
2 // operadores aritm ticos
3 x = a + b ; // soma
4 x = a - b ; // subtra o
5 x = a / b ; // divis o
6 x = a * b ; // multiplica o
7 x = a % b ; // resto
8 // operadores de incremento e decremento
9 x ++; // incremento
10 x - -; // decremento
11 // operadores de atribui o aritm ticos
12 x += a ;
13 x -= a ;
14 x *= a ;
15 x /= a ;
16 x %= a ;
13.5 Operadores relacionais
1 // maior que
2 valor1 > valor2
3 // menor que
4 valor1 < valor2
5 // maior ou igual que
6 valor1 >= valor2
7 // menor ou igual que
8 valor1 <= valor2
9 // igual
10 valor1 == valor2
11 // diferente
12 valor1 != valor2
13.6 Operadores lgicos
1 // e l gico
2 dadol gico1 && dadol gico2
3 // ou l gico
4 dadol gico1 || dadol gico2
5 // nega o
6 ! dadol gico1
13.7 Estruturas condicionais
1 // sele o nica
2 if ( condi o ){
3 ...
13.8 Estruturas de Repetio 183
4 }
5 // sele o dupla
6 if ( condi o ){
7 ...
8 } else {
9 ...
10 }
11 // sele o m ltipla
12 if ( condi o ){
13 ...
14 } else if ( condi o2 ) {
15 ...
16 } else if ( condi o3 ) {
17 ...
18 } else {
19 ...
20 }
1 // operador tern rio

2 x = condi o ? express o1 : express o2 ;
1 // switch para sele o m ltipla

2 switch ( vari vel ){
3 case constante1 :
4 ...
5 break ;
6 case constante2 :
7 ...
8 break ;
9 case ...
10 ...
11 default :
12 ...;
13 }
13.8 Estruturas de Repetio
1 // for ( para repeti es baseadas em contador )

2 for ( inicializa ; condi o ; incremento ){
3 ...
4 }
1 // while ( para repeti es baseadas em crit rio de parada )

2 while ( condi o ) {
3 ...
4 }
1 // do - while ( executa o la o uma vez antes de testar a condi o )

2 do {
3 ...
184 Captulo 13. Resumo de comandos
13.9 Entrada e sada
1 // cout para sa da na tela

2 cout << " Mensagem na tela " << endl ;
3 // cout sem endl para n o fazer quebra de linha
4 cout << " Digite um valor : " ;
5 // Entrada pelo teclado
6 cin >> variavel ;
13.10 Arranjos (Alocao automtica, de tamanho fixo)
1 Tipo nome_do_vetor [ tamanho_do_vetor ];

2 nome_do_vetor [ posi o ] = valor ;
13.11 Arranjos multidimensionais (Alocao automtica, de tamanho fixo)
1 Tipo nome [ tamanho1 ][ tamanho2 ];

2 nome [ posi o1 ][ posi o2 ] = valor ;
13.12 Ponteiros
1 Tipo * px ; // ponteiro para o tipo Tipo

2 px = & x ; // ponteiro = endere o de x
3 * px ou p [0] // Valor de x
4 px // Valor de ( endere o salvo em ) px
5 & nomep // Endere o do ponteiro px
6 *( px +1) ou p [1] // Elemento salvo ap s x
7 * px +1 // Mesmo que x + 1
13.13 Funes
1 // cabe alho da fun o

2 tipo nome ( tipo parametro , tipo parametro , ...);
3 // ...
4 // fun o principal
5 int main (){
6 ...
7 }
8 // defini o da fun o
9 tipo nome ( tipo parametro , tipo parametro ,...){
10 // ... defini o
11 }
13.14 Passagem por valor e referncia
1 Tipo funcao ( tipo por_valor , tipo & por_refer ncia );

13.15 Estruturas ou Registros
1 struct Nome {
2 tipo variavel1 ;
3 tipo variavel2 ;
4 ...
5 };
6 // ...
7 Nome x ; // Cria vari vel do tipo Nome
8 x . variavel1 = valor ; // Atribui o
9 Nome * px = x ; // Ponteiro para registro
10 px - > variavel1 = valor ; // Atribui o
13.16 Alocao dinmica de arranjos
1 cin >> n ; // n o tamanho do vetor

2 tipo * v = nullptr ; // v aponta para nada
3 v = new tipo [ n ]; // v aponta arranjo alocado com tamanho n
4 // ...
5 delete [] v ; // deleta o arranjo
6 v = nullptt ; // v aponta para nada de novo
13.17 Entrada e sada de arquivos

2 // ...
3 ofstream arquivo_saida ( " saida . txt " );
4 istream arquivo_entrada ( " entrada . txt " );
5 arquivo_saida << variavel ;
6 arquivo_entrada >> variavel ;
7 arquivo_saida . close ();
8 arquivo_entrada . close ();
II
Comparando Algoritmos
14 Anlise de Algoritmos . . . . . . . . . . . . . . 189
15 Busca em arranjos . . . . . . . . . . . . . . . . . . 197
16 Ordenao de arranjos . . . . . . . . . . . . . 207

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 10
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 10
1
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 01 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
00
1
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 11
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 1
00
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Anlise
0
14.
1 0 de Algoritmos
1
0 0 1
0 10 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
10
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 00
0 1 010 1 1 1 0 01 1 11
14.1 Algoritmos
Um algoritmo um procedimento de passos para clculos e o mesmo composto de
instrues que definem uma funo. At o momento vimos apenas cdigos em C++ para
descrever ideias. Um algoritmo pode descrever ideias para pessoas programarem em outras
linguagens de programao. Abaixo temos a mesma ideia descrita com um cdigo em C++ e
com um algoritmo genrico:
1 int max ( int [] a , int n ){ Entrada: Conjunto de nmeros inteiros A

2 int i , m ; Sada: Maior elemento deste conjunto
3 m = a [0];
4 for ( i = 1; i < n ; i ++){ m primeiro elemento de A, ou A1
5 if ( m < a [ i ]){
Para todos os outros elementos Ai de A
6 m = a [ i ];
7 } se o elemento Ai for maior que m
8 } m Ai
9 return m ; retorne o valor de m
10 }
Veja que temos duas descries de uma sequncia de passos para encontrar o maior elemento
de um conjunto. No algoritmo direita, os passos so descritos de maneira geral, de modo
que possam ser utilizadas por qualquer pessoa. No cdigo direta, o conjunto de nmeros est
representado concretamente atravs de arranjos.
No cdigo em C++ a entrada o conjunto de nmeros inteiros representado pelo arranjo a e
a sada o maior elemento desse conjunto. A varivel m guarda o primeiro nmero do arranjo na
linha 3. Uma estrutura de repetio nas linhas 4 a 8 compara se h algum elemento a[i] maior
que m.
De maneira anloga, no algoritmo direita, a varivel m ento o primeiro elemento de A,
ou A1 . Comparamos todos os outros elementos Ai para i = 2, 3, 4, . . . , n com m. O valor de m
substitudo se Ai > m.
190 Captulo 14. Anlise de Algoritmos
Os algoritmos so expresses mais gerais de regras para sequncias de passos que

resolvem problemas. Apesar de ser um conjunto de regras que define uma sequncia de passos,
no existe uma definio formal e geral de algoritmo. Existem at hoje muitas dvidas sobre a
definio formal de um algoritmo:
Algoritmos que no fazem clculos so algoritmos?
Um algoritmo precisa sempre parar? Um programa que no para um algoritmo?
Programas que s param com interveno do usurio so algoritmos?
Programas que dependem do usurio so algoritmos?
Algoritmos podem ter componentes aleatrios?
Os algoritmos podem ser descritos de vrias maneiras. A prpria descrio de um cdigo
em C++ uma maneira de descrever um algoritmo. Podemos expressar um algoritmo em
uma linguagem natural (em portugus), com um pseudo-cdigo (uma listagem das operaes
matemticas), com diagramas (usando quadrados e setas) ou com as prprias linguagens de
programao (como C++, Java, Pascal, etc).
14.2 Modelos de Comparao

Estudamos algoritmos em geral em vez de cdigos em linguagens de programao porque
queremos concluses amplas sobre as anlises que fazemos dos algoritmos. Em programao,
essa anlise mais ampla permite ajudar pessoas que utilizam diferentes linguagens.
Nem sempre dois algoritmos que resolvem o mesmo problema so igualmente eficien-
tes. Podemos comparar algoritmos sob vrios critrios como velocidade, gasto de memria e
qualidade das solues.
A medida de custo real quando executamos dois algoritmos na prtica e comparamos
seus resultados lado a lado. Esta usualmente uma medida inadequada visto que depende muito
do sistema computacional que temos para os experimentos. Os computadores podem variar em
hardware ou quantidade disponvel de memria. O compilador ou a linguagem de programao
podem ter alguma caracterstica que altera o desempenho de um cdigo em relao ao outro.
Por outro lado, uma medida de custo real pode ser vantajosa quando dois algoritmos tem com-
portamento muito similar e os custos reais das operaes so ento considerados em ambientes
mais prticos.
Para contornar os problemas relacionados a medidas de custo real, utilizamos um medida
por modelos matemticos para comparar diferentes algoritmos. Nestas medidas especificamos
um conjunto de operaes e seus custos. Usualmente, apenas as operaes mais importantes do
algoritmo so consideradas, como comparaes, atribuies e chamadas de funo.
14.3 Complexidade dos algoritmos

Para mensurar o custo de um algoritmo, definimos uma funo de custo ou funo de
complexidade, denominada f (n). Esta funo f (n) pode medir o tempo ou memria necessrios
para executar um algoritmo.
Considere este algoritmo que retorna o maior elemento de um arranjo a com n elementos:
1 int max ( int a [] , int n ){
2 int i , temp ;
3 temp = a [0];
4 for ( i = 1; i < n ; i ++){
5 if ( temp < a [ i ]){
6 temp = a [ i ];
7 }
14.4 Melhor caso, pior caso e caso mdio 191
8 }
9 return temp ;
10 }
Na linha 3, ele guarda o valor do primeiro elemento do arranjo temp. A varivel temp guarda
o valor do maior elemento encontrado at ento. Na linha 5, ele compara o maior elemento
encontrado at ento temp com todos os outros elementos a[i] do arranjo. O for definido na
linha 4 varia os valores de i entre 1 e n-1.
Para um arranjo de n elementos e uma funo f (n) do nmero de comparaes, temos que o
custo deste algoritmo f (n) = n 1. Todas estas comparaes so feitas na linha 5 do algoritmo.
Repare que a operao relevante desse algoritmo o nmero de comparaes. No caso geral,
no interessante medir o nmero de operaes de atribuio pois elas s ocorrem quando a
comparao da linha 5 retorna true.
14.4 Melhor caso, pior caso e caso mdio

Suponha agora um computador no qual as operaes de atribuio so muito custosas.
Estamos ento interessados no nmero de operaes de atribuio como medida de tempo.
No algoritmo que acabamos de ver, se definirmos o nmero de atribuies em como medida
relavante de custo f (n), o melhor caso em relao a esta medida quando a comparao da
linha 5 sempre false. Assim, temos apenas uma operao de atribuio na linha 3, j que o
comando da linha 6 nunca ser executado.
Este melhor caso ocorre quando o primeiro elemento do conjunto j o maior elemento.
No melhor caso, podemos dizer que f (n) = 1, pois sempre teremos apenas uma operao de
atribuio.
Na situao contrria, se a comparao da linha 5 sempre true, temos nosso pior caso em
relao ao nmero de atribuies, pois o comando da linha 6 sempre ser executado.
Isso ocorre quando os elementos do arranjo esto em ordem crescente. Nesse pior caso,
podemos dizer que temos custo f (n) = n em relao ao nmero de atribuies, pois teremos 1
operao de atribuio na linha 3 e teremos mais n 1 operaes de atribuio para cada outro
elemento do arranjo na linha 6.
J no caso mdio, ou caso esperado, a mdia de todos os casos possveis. O caso mdio
de um algoritmo sempre muito mais difcil de ser obtido pois depende da nossa estimativa
de probabilidades de cada entrada. Para fins didticos, suponha que a probabilidade de uma
comparao ser true na linha 5 de 50%. Neste caso, podemos dizer que nosso custo no caso
mdio f (n) = 1 + (n 1)/2 = (n + 1)/2.
Porm, note que nossa suposio de que 50% das comparaes sero true pouco provvel
na prtica. Para arranjos aleatrios, a probabilidade de uma comparao true na linha 5 cai
medida que temp guarda valores maiores.
14.5 Notao O e dominao assinttica

A notao O utilizada para descrever a tendncia de uma funo. Ela muito utilizada em
computao para classificar algoritmos de acordo com a taxa de crescimento de suas funes de
custo.
Na Figura 14.1 temos a grficos representando duas funes f (n) e g(n). Veja que no grfico
da Figura 14.1(a), que quando n < 4, 5, a funo g(n) pode estar acima de f (n). Porm, para
qualquer n > 4, 5, f (n) est sempre acima de g(n). Isso pode ser visto principalmente na Figura
14.1(b), onde so apresentados os valores de 0 a 50 para n. Como f (n) domina assintoticamente
g(n), temos que, para valores grandes de n, f (n) est sempre acima de g(n). Neste caso,
qualquer valor de n acima de 4, 5 pode ser considerado um valor grande. Este valor 4, 5 a partir
do qual f (n) domina g(n) uma constante que chamaremos de m.
60 900
f(n) f(n)
g(n) 800 g(n)
50
700
40 600
500
30
400
20 300
200
10
100
0 0
0 1 2 3 4 5 6 7 8 0 5 10 15 20 25 30 35 40 45 50
n n
(a) 0 < n < 8 (b) 0 < n < 50
Figura 14.1: Uma funo f (n) que domina assintoticamente a funo g(n). Cada grfico mostra
uma faixa de valores.
Do ponto de vista de programao, suponha que f (n) e g(n) so funes de custo de
algoritmos A e B. Se para valores grandes de n, f (n) > g(n), sabemos que o algoritmo A
consome mais recursos que B.
Veja na Figura 14.2 o efeito de se multiplicar f (n) por uma constante c que pode ter diversos
valores. No grfico, f (n) foi multiplicado pelas constantes c = {1; 2; 3; 0, 5; 0, 2}. Veja como
mesmo quando multiplicamos f (n) por uma constante, f (n) ainda est acima de g(n) para
valores grandes de n. claro que ao alterar c, temos uma alterao no valor m, que define o que
um valor grande o suficiente. Contudo, f (n) continua dominando assintoticamente g(n). De
fato, se acharmos qualquer constante c para que f (n) esteja acima de g(n), podemos dizer que
f (n) domina g(n) assintoticamente.
300
f(n)
g(n)
2f(n)
250 3f(n)
0,5f(n)
0,2f(n)
200
150
100
50
0
0 1 2 3 4 5 6 7 8 9 10
n
Figura 14.2: Os valores de f (n) multiplicado por diferentes constantes. A funo f (n) domina
assintoticamente a funo g(n) mesmo quando multiplicada por uma constante.
Do ponto de vista de programao, esta informao muito relevante. Suponha novamente

que f (n) e g(n) so funes de custo dos algoritmos A e B. Sabemos agora que para valores
grandes de n, no s f (n) > g(n) mas tambm c f (n) > g(n) para alguma constante c. Como
f (n) > g(n), poderamos pensar que o algoritmo A seria mais eficiente que B se tivessemos um
14.5 Notao O e dominao assinttica 193
computador 1000 vezes mais rpido para A. Porm, se 0, 001 f (n) > g(n) para valores grandes n,
o algoritmo A ainda seria pior que B. Ainda, se c f (n) > g(n) para valores grandes n e para pelo
menos alguma constante c, o algoritmo A ou pior que B ou pode ser pior que B, caso B seja
executado em um computador mais rpido.
De modo formal, o conceito de dominao assintrica pode ser definido como abaixo:
Definio 14.5.1 Dominao Assinttica. Dizemos que uma funo f (n) domina
assintoticamente outra funo g(n) se existem duas constantes positivas c e m tais que, para
n m, temos que |g(n)| c | f (n)|. Ou seja, para nmeros grandes n > m, c f (n) ser
sempre maior que g(n), para alguma constante c.
14.5.1 Notao O
A notao O utilizada para representar dominao assinttica. Quando uma funo
g(n) = O( f (n)), dizemos que:
g(n) O de f (n)
f (n) domina g(n) assintoticamente
! Quando g(n) = O( f (n)) no correto dizer que g(n) igual a O de f (n), pois a notao
O no indica uma relao de igualdade, e sim de dominao. Dizemos apenas que g(n)
O de f (n).
importante comparar os algoritmos em notao O pois no estamos interessados em

funes exatas de custo mas sim no comportamento geral da funo, principalmente medida
que temos valores maiores de n.
Vejamos o exemplo das seguintes funes:
g(n) = (n + 1)2
f (n) = n2
Estas duas funes se dominam assintoticamente, ou seja, g(n) = O( f (n)) e f (n) = O(g(n)).
g(n) = O( f (n)) por que g(n) 4 f (n) para n > 1. Por outro lado, f (n) = O(g(n)) pois f (n)
g(n) para qualquer n > 0.
Vejamos agora um segundo exemplo:
g(n) = (n + 1)2
f (n) = n3
A funo f (n) domina a funo g(n). Temos que g(n) = O( f (n)) pois g(n) c f (n) para
um c grande o suficiente. Porm, a g(n) no domina f (n) pois dizer que f (n) cg(n) a partir
de qualquer n seria uma afirmao falsa para qualquer c. No importa qual valor escolhemos
para c, f (n) sempre ser maior que g(n) se n for grande o suficiente.
14.5.2 Limites fortes

Temos que g(n) = 3n3 + 2n2 + n = O(n3 ), pois g(n) 6n3 , para n > 0. Este considerado
um limite forte para a funo g(n). claro que tambm podemos dizer que g(n) = O(n4 ), porm
esta seria uma afirmao mais fraca. Se j sabemos que n3 domina g(n), bvido que n4 tambm
a dominar. Para analisar comportamentos de algoritmos, estamos interessados em limites fortes
pois so deles que podemos tirar melhores concluses sobre a eficincia de algoritmos.
14.5.3 Operaes com notao O

Vejamos agora algumas operaes e propriedades da representao de funes atravs de
notao O. Estas propriedades deixam claro porque a notao O til para representar de
maneira simples o comportamento de funes e, no nosso caso de interesse, de programas e

algoritmos.
Uma funo f (n) sempre se domina pois basta a multiplicar por uma constante c > 1 para
que c f (n) > f (n):
f (n) = O( f (n))
O mesmo vale para qualquer funo O( f (n)) multiplicada por uma constante c, pois basta
multiplicarmos f (n) por uma constante c2 grande o suficiente para que c2 > c( f (n)):
cO( f (n)) = O( f (n))
A soma de duas funes dominadas por f (n) ainda dominada por f (n) pois esta diferena
ainda pode ser compensada por uma constante:
O( f (n)) + O( f (n)) = O( f (n))
desta ltima propriedade que podemos facilmente calcular a ordem de complexidade de

vrios algoritmos. Por exemplo, se temos uma funo de custo g(n) = n3 + n2 + n, podemos
identificar rapidamente que g(n) = O(n3 ) j que n3 o maior termo entre os elementos somados
em g(n).
Se uma funo O(O( f (n)) (ou seja, uma funo que dominada por uma funo dominada
por f (n)), a primeira funo tambm dominada por f (n):
O(O( f (n))) = O( f (n))
A soma de duas funes, uma dominada por f (n) e outra dominada por g(n), ser dominada
pela maior funo que as domina:
O( f (n)) + O(g(n)) = O(max( f (n), g(n)))
A multiplicao de duas funes ser dominada pela multiplicao das funes que as
dominavam:
O( f (n))O(g(n)) = O( f (n)g(n)) f (n)O(g(n)) = O( f (n)g(n))
14.6 Classes de algoritmos

Com as funes de complexidade de cada algoritmo, podemos compar-los em relao a
suas funes de custo. No caso geral, se tivermos limites fortes e para valores grandes de n, se
sabemos que um programa leva o tempo O(n), ele melhor que um outro programa que leva
tempo O(n2 ).
A Tabela 14.1 apresenta algumas classes importantes de algoritmos de acordo com suas
complexidades. A Tabela mostra a ordem da funo de complexidade, como estes algoritmos
so chamados e que tipo de algoritmo usualmente tem este tipo de complexidade. Em todos os
exemplos, n considerado o tamanho do problema e c considerada uma constante qualquer.
14.7 Exerccios 195
Notao Complexidade Algoritmo Tpico

O(1) Constante Procurar e alterar uma posio de um arranjo
O(log) Logartmica Dividem o problema em dois a cada passo
O(n) Linear Fazer uma operao em cada elemento de um conjunto
O(n log n) Log-linear Dividem o problema e uma operao por elemento
O(n2 ) Quadrtica Comparaes par-a-par em conjuntos de elementos
O(n3 ) Cbica Comparaes par-a-par repetidas
O(nc ), c > 1 Polinomial Comparaes par-a-par repetidas
O(2n ) Exponencial Fora-bruta em combinaes
O(cn ), c > 1 Exponencial Fora-bruta em combinaes de c elementos
O(n!) Fatorial Fora-bruta em permutaes
Tabela 14.1: Classes Importantes de Algoritmo por Complexidade.
Os algoritmos de custo O(1), por exemplo, tm complexidade constante e eles possuem

sempre o mesmo desempenho independente do valor de n. J nos algoritmos O(n), de complexi-
dade linear, o tempo aumenta de acordo com o tamanho do problema. Os algoritmos O(n log n),
na prtica costumam ter desempenho prximo aos algoritmos O(n), a no ser para problemas
extremamente grandes.
A partir dos algoritmos O(n2 ), porm, o tamanho do problema por ser um entrave em nossos
programas. O tempo para resolver problemas comea a crescer em proporo maior do que o
tamanho do problema. Problemas que podem ser resolvidos com qualquer algoritmo que custe
menos que O(nc ), c > 1 usualmente so chamados de problemas polinomiais.
Os algoritmos de custo O(2n ), O(cn ), c > 1 e O(n!) so usualmente algoritmos que usam
fora bruta para resolver problemas testando todas as solues possveis at que se encontre a
certa. Estes algoritmos no custumam ser utilizados na prtica pois um computador poderia levar
sculos para resolver problemas pequenos.
14.7 Exerccios
Exerccio 14.1 O que significa dizer que uma funo g(n) O( f (n))?
Exerccio 14.2 Explique se h alguma diferena entre O(1) e O(2). Justifique.
Exerccio 14.3 Indique se as afirmativas so verdadeiras ou falsas:

1. 2n+1 = O(2n )
2. 22n = O(2n )
3. f (n) = O(u(n)) e g(n) = O(v(n)) f (n) + g(n) = O(u(n) + v(n))

Exerccio 14.4 Se os algoritmos A e B levam tempo a(n) = n2 n + 549 e b(n) = 49n + 49.
a(n) = O(b(n))? b(n) = O(a(n))? Para quais valores A leva menos tempo para executar do
que B?
Exerccio 14.5 Apresente o esboo de uma algoritmo para obter o maior e o segundo maior
elementos de um conjunto. Apresente uma anlise do algoritmo. Ele eficiente? Porqu?
Exerccio 14.6 Considere um algoritmo para inserir um elemento em um arranjo ordenado

de elementos. Qual o nmero mnimo de passos para resolver este problema? Qual o melhor
caso? Qual o pior caso? Qual o caso mdio?
Exerccio 14.7 Do ponto de vista assinttico, temos a seguite relao de precedncia entre
funes:
n
1 log log n log n n nc nlog n cn nn cc
Onde k 1 e 0 < < 1 < c
Indique se A O de B para os pares abaixo:
A B O
A = logk n B = n
A = nk B = cn

A= n B = nsin n
A = 2n B = 2n/2
A = nlog m B = mlog n
A = log(n!) B = log(nn )

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Busca0em arranjos
0
15.
1
1
0 0 1
0
0 0
1
110 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 01 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Como estudamos na Seo 5, arranjos so uma maneira de se armazenar muita informao

em srie. Esta informao, em aplicaes prticas, usualmente dividida em registros do C++
com o recurso struct, que estudamos na Seo 10. Quando temos os dados organizados desta
maneira, precisamos de estratgias para encontrar dados nestes arranjos.
Usualmente, cada struct do arranjo tem um membro que no se repete, que chamamos de
chave. As chaves so importantes para diferenciar os itens de um conjunto de elementos. Por
exemplo, suponha um arranjo de dados do tipo Aluno:
1 struct Aluno {
2 string nome ;
3 double nota_prova1 ;
4 double nota_prova2 ;
5 int matricula ;
6 }
Nesta estrutura, cada Aluno ter um nome, uma nota para cada prova (nota_prova1 e
nota_prova2) e um nmero de matrcula (matricula). Como os nmeros de matrcula no se
repetem, eles so bons candidatos a serem o membro chave dos alunos.
Neste caso prtico, sendo a chave de um aluno o seu nmero de matrcula, o problema da
busca em arranjo consiste em encontrar em qual posio de um arranjo a est o aluno com
nmero de matrcula x. Veja o prottipo de uma funo para busca em arranjos na Figura 15.1.
Uma funo que faz busca em arranjos deve receber um valor de chave, um arranjo de elementos
a e o tamanho n deste arranjo. O problema est em fazer com que a funo retorne em qual
posio do arranjo est o elemento com a chave pedida.
Na Figura 15.2 apresentamos o prottipo e exemplo de uso de uma funo para busca em
arranjos de dados do tipo int. Considerando que o prprio nmero representa sua chave, a
funo busca deve retornar em qual posio do arranjo a (que tem tamanho n) est o nmero x,
que 9. No caso, como o elemento 9 se encontra na posio a[4], a funo dever retornar 4.
198 Captulo 15. Busca em arranjos
x 726922 a aluno 0 aluno 1 aluno 2 aluno 3 aluno 4 aluno 5 aluno 6
int busca(int chave, Aluno a[], int n);
?
Figura 15.1: Prottipo de uma funo de busca em arranjos.
x 9 a 6 3 8 5 9 2 1
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

7
int busca(int chave, int a[], int n);
Elemento 9 est na
4 posio 4 do arranjo
Figura 15.2: Prottipo de uma funo de busca em arranjos de dados do tipo int.
15.1 Busca sequencial
O mtodo mais simples para busca , a partir do primeiro elemento, pesquisar os elementos
sequencialmente um-a-um at encontrar a chave desejada. Veja a funo que procura o elemento
chave no arranjo a, que possui tamanho n:
1 int buscaSequencial ( int chave , int a [] , int n ){

2 for ( int i =0; i < n ; i ++){
3 if ( a [ i ] == chave ){
4 return i ;
5 }
6 }
7 return -1;
8 }
A funo ir retornar um int que dir em qual posio do arranjo a est o elemento chave.
A estrutura de repetio definida nas linhas 2 a 6 ocorre com i de 0 at n-1 para percorrer da
primeira at a ltima posio a[i] do arranjo a.
Na linha 3, comparamos cada elemento do arranjo com o elemento chave. Se o elemento
chave foi encontrado, o valor de i, que tem sua posio nesta iterao da repetio, ento
retornado. J se o elemento chave no foi encontrado e a comparao retornou false, passamos
para a prxima iterao de repetio.
Na linha 7, se em nenhuma das iteraes o elemento foi encontrado, samos do for e
retornamos -1. O retorno de -1 um modo de se avisar para a funo chamadora que o elemento
no foi encontrado.
15.1.1 Anlise
Temos como operao relevante da busca em arranjo o nmero de comparaes para se
encontrar o elemento chave. Em relao ao nmero de comparaes, o melhor caso acontece
quando o elemento que procuramos o primeiro do arranjo. Neste caso, faremos apenas uma
comparao e j retornaremos a posio i. Sendo assim, teramos uma funo de custo f (n) = 1
no melhor caso. Em notao assinttica, f (n) = O(1).
J o pior caso ocorre quando o elemento que procuramos o ltimo do arranjo ou no est
no arranjo. Para um arranjo de n elementos, teramos de fazer n comparaes para encontrar o
ltimo elemento ou descobrir que o elemento no est no arranjo. Assim, temos uma funo de
custo f (n) = n no pior caso. Em notao assinttica, f (n) = O(n).
No caso mdio, precisamos de uma suposio de probabilidades. Vamos supor que o
elemento chave sempre est no arranjo e que ele tem a mesma probabilidade 1/n de estar em
qualquer uma de suas posies. Se (i) encontrar o elemento da posio i tem custo f (n) = i e (ii)
a probabilidade da chave estar em uma posio i 1/n, teremos que nosso caso mdio tem custo
definido pela seguinte equao:
1 1 1 1 1 1 n n+1
f (n) = 1 + 2 + 3 . . . (n 1) + n = i =
n n n n n n i=1 2
Assim, em notao assinttica, temos um caso mdio onde f (n) = O(n).

Na Tabela 15.1 temos um resumo do custo do algoritmo de busca sequencial em seus
principais casos. Tanto o pior caso quando o caso mdio tm custo O(n) para encontrar um
elemento.
Caso Descrio Custo

Pior caso chave o ltimo elemento ou pesquisa sem sucesso O(n)
Caso mdio Probabilidade 1/n de ter a chave em cada posio O(n)
Melhor caso chave o primeiro elemento do arranjo O(1)
Tabela 15.1: Custo do algoritmo de busca sequencial em suas situaes mais comuns
15.2 Busca binria

A busca binria um mtodo mais eficiente que a busca sequencial. Porm, a busca binria
requer que os elementos estejam mantidos em ordem dentro do arranjo. A busca binria feita
com um algoritmo onde a cada iterao de repetio, pesquisamos o elemento do meio. Se a
chave maior que este elemento, repetimos o processo na primeira metade do arranjo. Seno,
repetimos esse passo na segunda metade do arranjo. A busca binria um mtodo interessante
pois remete a como buscamos palavras em um dicionrio.
A Figura 15.3 apresenta um exemplo da aplicao deste algoritmo. Pesquisaremos o arranjo
a pela chave de valor 8. Diferentemente da busca sequencial, no iniciaremos procurando na
primeira posio i do arranjo a. O ndice i se inicia na posio que representa a metade do
arranjo (6/2, ou 3).
Quando comparamos a chave com o elemento a[i], ou a[3], percebemos que a chave
maior que este elemento. Assim, sabemos que o elemento procurado s pode estar entre as
posies 4 e 6, ao lado direito do arranjo. Assim, os elementos a[0] a a[3] so desconsiderados
e repetimos o procedimento.
chave 8
a 1 2 3 5 6 8 9 i 3
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
a 1 2 3 5 6 8 9 i 5
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
Figura 15.3: Exemplo da aplicao de um algoritmo de busca binria.
No segundo passo do algoritmo, o elemento do meio entre as posies consideradas

a[4+6/2], ou a[5]. Como o elemento igual chave o algoritmo retorna o valor de i. Veja
como utilizamos apenas dois passos para encontrar um elemento com a busca binria.
Temos abaixo o cdigo de uma busca binria:
1 int buscaBinaria ( int chave , int a [] , int n ){

2 int i ;
3 int esq = 0;
4 int dir = n -1;
5 do {
6 i = ( esq + dir )/2;
7 if ( chave > a [ i ]){
8 esq = i + 1;
9 } else {
10 dir = i - 1;
11 }
12 } while (( chave != a [ i ]) && ( esq <= dir ));
13 if ( chave == a [ i ]){
14 return i ;
15 } else {
16 return -1;
17 }
18 }
Na linha 1, similarmente busca sequencial, a funo procura o elemento chave do arranjo

a, que tem tamanho n. O ndice i, declarado na linha 2, marcar o elemento sendo comparado,
assim como no for da busca sequencial. Os ndices esq e dir, definidos nas linhas 3 e 4 por sua
vez, marcaro os limites de onde a busca est sendo feita. Inicialmente, faremos a busca entre
as posies 0 e n-1, ou seja, entre todos os elementos no arranjo a. Temos abaixo um exemplo
destes passos iniciais em um arranjo a, no qual procuramos o elemento 6:
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[esq] a[dir]
esq 0 i dir 6
Em seguida, entramos em uma estrutura de repetio definida entre as linhas 5 e 11, onde a
cada iterao o elemento i ser comparado. Na primeira iterao, com a execuo da linha 6, o
ndice i indica o elemento do meio do arranjo.
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[esq] a[i] a[dir]
esq 0 i 3 dir 6
Na linha 7, comparamos a chave com o elemento a[[i] e temos que a chave maior que
a[i]. Por este motivo, pesquisaremos agora apenas na metade direita de i e, a partir de agora,
a metade esquerda ser desconsiderada pelo algoritmo. Para isto, atualizamos o valor de esq
na linha 8. Em nosso exemplo, apesar os elementos entre a[4] e a[6] sero considerado a partir
de agora:
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[i] a[esq] a[dir]
esq 4 i 3 dir 6
Se a chave fosse menor que a a[i], o contrrio ocorreria, e a metade direita passaria a ser
desconsiderada com a atualizao de dir na linha 10.
Na linha 12, temos duas condies para continuar a estrutura de repetio. A primeira
condio que chave != a[i], ou seja, que o elemento pesquisado i ainda no seja a chave
sendo procurada. A segunda condio para continuar a repetio que esq <= dir, ou seja,
se ainda h elementos para se pesquisar. Os ndices esq e dir vo se movendo a medida que
pesquisamos mais elementos. Se o ndice esq menor ou igual a dir, a repetio deve se
continuar pois isso indica que o arranjo inteiro no foi pesquisado.
Em nosso exemplo, como as condies do lao foram atendidas, na nova iterao do lao,
na linha 6, o ndice i indica a posio o elemento do meio entre os que ainda esto sendo
considerados, ou seja, (esq + dir)/2 = 5:
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[esq] a[i] a[dir]
esq 4 i 5 dir 6
Na linha 7, como a[5], ou 8, maior que a chave 6 que procuramos, alteramos dir, na linha
10, para restringir a busca ao lado esquerdo do arranjo:
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[esq] a[i]
a[dir]
esq 4 i 5 dir 4
Nas condies de repetio do lao, na linha 12, o elemento a[i] ainda no a chave
que procuramos e os ndices esq e dir no se cruzaram indicando que todo o arranjo j foi
percorrido.
Assim, na prxima iterao, na linha 6, o elemento do meio indicado por i ((esq + dir)/2
= 4) o nico elemento ainda considerado do arranjo.
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[esq]
a[dir]
a[i]
esq 4 i 4 dir 4
No teste da linha 7, como a chave > a[i] retorna false, deslocamos o ndice dir mais
uma vez. O ndice dir estar esquerda do ndice esq indica que no que no h mais elementos
a se pesquisar.
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

chave 6
a[dir] a[esq]
a[i]
esq 4 i 4 dir 3
Nas condies de parada, na linha 12, nenhuma das duas condies so atendidas. A condio
chave != a[i] false pois o ndice i j aponta para o elemento chave e a condio esq <=
dir tambm false pois os ndices dir e esq j se cruzaram, indicando no h mais elementos
a se pesquisar.
Nas linhas 13 a 17, testamos por qual motivo o lao foi encerrado e a funo faz o retorno. O
primeiro teste da linha 13, verifica se chave == a[i], ou se a chave foi encontrada. Se a chave
foi encontrada ao fim do lao, retornamos o valor de i na linha 14. Em nosso exemplo, teramos
retornado 4.
Se o elemento a[i] no fosse igual chave, seria porque o elemento no estava no arranjo.
Neste caso, retornaramso -1 na linha 16 do cdigo.
15.2.1 Anlise
A busca sequencial um mtodo interessante de busca pois remete a como buscamos palavras
em um dicionrio. Quando pesquisamos em um dicionrio, no passamos palavra por palavra.
Procuramos uma palavra no meio do dicionrio e verificamos se a palavra que procuramos estaria
a frente ou atrs da palavra que encontramos.
Em relao ao nmero de comparaes temos um cenrio similar busca sequencial para
a descrio dos casos. O melhor caso ocorre quando o elemento que procuramos o primeiro
que testamos, ou seja, o elemento no meio do arranjo. Sendo assim, nosso melhor caso seria
f (n) = O(1).
J o pior caso acontece quando o elemento que procuramos o ltimo comparado ou quando
o elemento no est no arranjo. Vejamos o nmero mximo de comparaes que podemos fazer
em uma busca binria. Se no primeiro passo de nossa busca consideramos n elementos, temos
n/2 elementos considerados no segundo passo, n/4 = n/22 elementos considerados no terceiro
passo e assim por diante. Ou seja, no passo k do algoritmo, consideraramos n/2k elementos em
nossa busca, at que o elemento fosse encontrado. No pior caso, faramos estes passos at que
apenas 1 elemento seja considerado.
n n n n
2 3 1
1 2 2 2
Como consideramos n/2k elementos no passo k e apenas 1 elemento no ltimo passo do
pior caso, nosso ltimo passo seria aquele no qual n/2k = 1. Invertendo a equao temos que o
nmero de passos k :
k = log n
Isso nosso pior caso teria O(k) = O(log n) passos no mximo. Se considerarmos que os
elementos esto distribudos de uma forma no tendenciosa no arranjo, nosso caso mdio tambm
ser f (n) = O(log n).
Na Tabela 15.2 temos um resumo do custo do algoritmo de busca binria em seus principais
casos. Tanto o pior caso quando o caso mdio tm custo O(log n) para encontrar um elemento.
Em notao O, mesmo os piores casos so O(log n) pois, a cada passo, o algoritmo elimina
metade do problema. Veja que isto coincide com o comportamento tpico de algoritmos de
complexidade logartmica, como listado na Seo 14.6. Isto o deixa muito mais eficiente em
relao busca sequencial O(n). Veja por exemplo que se n = 1.000.000, temos apenas que
log n = 6.
Uma desvantagem do algoritmo de busca binria que precisamos manter o arranjo ordenado.
Esta operao pode ter um custo muito alto para algumas aplicaes prticas. Isso torna este
Caso Descrio Custo

Pior caso chave o ltimo elemento pesquisado ou pesquisa sem sucesso O(log n)
Caso mdio Itens distribudos de forma uniforme pelo arranjo O(log n)
Melhor caso chave o elemento do meio do arranjo O(1)
Tabela 15.2: Custo do algoritmo de busca binria em suas situaes mais comuns
mtodo mais vantajoso para aplicaes pouco dinmicas, como justamente o caso de dicionrios.
Estudaremos nas Sees seguintes mtodos para os arranjos ordenados.
A Figura 15.4 apresenta o tempo gasto pelos algoritmos de busca sequencial e busca binria
para se encontrar um elemento em um arranjo. A Figura 15.4(a) apresenta resultados para
arranjos com at 3000 elementos enquanto a Figura 15.4(b) apresenta resultados para arranjos
com at 80 mil elementos. Como a busca sequencial tem custo O(n) e a busca binria tem custo
O(log n), vemos que medida que os arranjos ficam maiores, a busca binria se torna cada vez
mais vantajosa. Porm, possvel que para arranjos pequenos, a busca sequencial seja mais
vantajosa. Nestes experimentos, isto ocorre para arranjos com menos de 350 elementos.
6 5
x 10 x 10
1.8 1.5
Busca sequencial Busca sequencial
Busca binria Busca binria
1.6
1.4
1.2 1
Tempo (segundos)
Tempo (segundos)
0.8
0.6 0.5
0.4
0.2
0 0
0 500 1000 1500 2000 2500 3000 0 1 2 3 4 5 6 7 8
Tamanho do arranjo Tamanho do arranjo 4
x 10
(a) Arranjos menores (b) Arranjos maiores
Figura 15.4: Tempo necessrio pelos algoritmos de busca para se encontrar um elemento em
arranjos de vrios tamanhos.
15.3 Exerccios
2
4
5 // busca posi o de x no arranjo a de tamanho n
6 int buscasequencial ( int a [] , int n , int x ) ;
7 // ordena o vetor a de tamanho n
8 void ordena ( int a [] , int n ) ;
9
10 int main () {
15.3 Exerccios 205
11 // Tamanho do arranjo
12 int n ;
13 cout << " Digite o tamanho do arranjo : " ;
14 cin >> n ;
15 // ponteiro para o arranjo na mem ria
16 int * v ;
17 // Alocado arranjo tamanho n
18 v = new int [ n ];
19 for ( int i = 0; i < n ; i ++) {
20 cout << " Digite o valor do elemento v [ " <> v [ i ];
22 }
23 int chave , posicao = 0;
24 do {
25 cout << " Digite o elemento que deseja buscar : " ;
26 cin >> chave ;
27 posicao = buscasequencial (v , n , chave ) ;
28 if ( posicao == -1) {
29 cout << " O elemento n o existe " << endl ;
30 } else {
31 cout << " Elemento na posic o v [ " << posicao <<
" ] " << endl ;
32 }
33 } while ( chave != -1) ;
34 // La o se repete at que a chave pesquisada seja -1
35 return 0;
36 }
37
38 // Procura a posi o de x no arranjo a de tamanho n
39 int buscasequencial ( int a [] , int n , int x )
40 {
41 for ( int i = 0; i < n ; i ++) {
42 if ( a [ i ]== x ) {
43 return i ;
44 }
45 }
46 return -1;
47 }
48
49 // Ordena o - M todo da Bolha
51 {
52 int i ,j , aux ;
53 for ( j = n -1; j >0; j - -)
54 for ( i =0; i < j ; i ++)
55 {
56 if ( a [ i +1] < a [ i ])
57 {
58 // trocar a [ i ] com a [ i +1]

59 aux = a [ i ];
60 a [ i ] = a [ i +1];
61 a [ i +1] = aux ;
62 }
63 }
64 }

Exerccio 15.2 Crie uma funo de busca binria, que busca o elemento chave em um
arranjo ordenado. Para ordenar o arranjo, use a funcao ordena(int a[], int n, int x).

Exerccio 15.3 Altere todas as funes para que elas calculem tambm o nmero de passos
necessrios para se encontrar (ou no) o elemento.
Exerccio 15.4 Altere o programa main para que sempre que um elemento chave seja
digitado, ele seja pesquisado atraves de busca sequencial e busca binaria.
Exerccio 15.5 Use a alterao para que logo em seguida seja impresso o nmero de passos
necessrios para se encontrar o elemento com cada um dos mtodos, incluindo o passo de
ordenao.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 10
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 01 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 11
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Ordenao
0
16.
1 0 1
0 de0 arranjos
1
0 1
0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
10
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
comum em programao a necessidade de se ordenar um arranjo. Um motivo razovel

para isto pode ser inclusive ordenao dos dados para facilitar sua visualizao. Veja na Tabela
16.1 como muito visualizar e analisar uma lista nomes ordenados.
Desordenado Ordenado
Pedro Alberto
Joo Barbosa
Maria Joaquim
Roberto Joo
Manuel Jos
Jos Manuel
Barbosa Maria
Joaquim Pedro
Alberto Roberto
Tabela 16.1: A visualizao e anlise de um conjunto de elementos ordenado muito mais fcil.
Alm disto, como vimos na Seo 15.2, buscas binrias em arranjos so mais eficientes que
buscas sequenciais. Porm, estas buscas s podem ser feitas em arranjos ordenados. Imagine por
exemplo fazer uma pesquisa em um catlogo telefnico onde temos os nomes das pessoas em
ordem.
As estratgias para se ordenar um arranjo so diversas. Veremos algumas dessas estratgicas
ao longo deste livro. O processo de ordenao pode ser para colocar os itens em ordem crescente
ou decrescente.
Como no caso das buscas em arranjos, os algoritmos so usualmente estendidos em situaes
prticas para ordenar structs por seus membros-chave. Porm, para fins didticos, os algoritmos
de ordenao deste captulo sero apresentados para ordenao de arranjos de tipos de dados
fundamentais.
A Figura 16.1 mostra um exemplo de um arranjo a com dados do tipo int sendo ordenado.
208 Captulo 16. Ordenao de arranjos
O prottipo da funo recebe um arranjo a e o tamanho do arranjo n. Como o arranjo a sempre

passado por referncia, os dados no prprio arranjo a estaro em ordem ao fim do processo.
a 9 3 5 3 4 4 1
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
void ordena(int a[], int n)
a 1 3 3 4 4 5 9
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
Figura 16.1: Exemplo de ordenao de arranjos. Neste caso temos um arranjo de dados do tipo
int.
16.1 Conceitos de ordenao de arranjos

16.1.1 Estabilidade de ordenao
Uma ordenao estvel aquela que mantm a ordem relativa dos elementos antes da
ordenao. Ou seja, se dois elementos so iguais, o elemento que aparece antes no arranjo
desordenado deve ainda aparecer antes no arranjo ordenado.
Suponha a ordenao j apresentada na Figura 16.1. Agora, Figura 16.2 mostra um exemplo
de ordenao estvel. Note que o resultado do processo de ordenao o mesmo. Repare a
procedncia dos elementos 3 e 4. Note atravs das setas azuis como os elementos 3 mantiveram
sua ordem relativa. Note atravs das setas verdes como os elementos 4 mantiveram sua ordem
relativa.
a 9 3 5 3 4 4 1
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
a 1 3 3 4 4 5 9
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
Figura 16.2: Exemplo de ordenao estvel.
De outro modo, a Figura 16.3 mostra um exemplo de ordenao instvel. Note que, apesar
de termos o mesmo resultado, no houve procupao para que os elementos iguais mantivessem
sua ordem relativa.
16.1 Conceitos de ordenao de arranjos 209
a 9 3 5 3 4 4 1
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
a 1 3 3 4 4 5 9
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
Figura 16.3: Exemplo de ordenao estvel.
Motivao
As vantagens de uma ordenao estvel ficam claras quandos fazemos a ordenao de elementos
atravs de seus membros-chave. Suponha que queremos ordenar um arranjo com as seguintes
cartas:
'
'
' '
''
As cartas deste arranjo podiam ser facilmente representadas pelo tipo de dados definido pela
seguinte estrutura:
1 struct Carta {
2 int valor ;
3 int naipe ;
4 }
Nesta estrutura, o valor seria representado por um nmero de 1 a 13 e o naipe seria repre-
sentado por um nmero de 1 a 4. Utilizando ento uma ordenao qualquer pelos nmeros,
podemos ter um resultado como este:
'
'
' '
''
As cartas esto ordenadas agora pelos nmeros, mas a ordem dos naipes arbitrria. Vamos
supor agora que queremos que as cartas estejam ordenadas tambm de acordo com seu naipe.
Precisamos ento ordenar mais uma vez as cartas, agora pelo naipe. Veja o que pode acontecer
se fizermos a segunda ordenao com um algoritmo instvel:
'
'
' '
''
Perdemos a ordem de valor das cartas ao ordenar pelos naipes. Claramente, isto no o
que queramos. Veja o que aconteceria se houvssemos ordenado as cartas com um algoritmo
estvel:
'
'
' '
''
Agora temos as cartas ordenadas por seus naipes mas tambm mantivemos a ordenao
anterior por seus valores dentro de capa naipe.
Forando estabilidade
Alguns mtodos mais eficientes de ordenao no so estveis. Porm, podemos forar um
mtodo no estvel a se comportar de forma estvel. Para forar essa estabilidade, adicionamos
um ndice a cada elemento do arranjo. O ndice indica a posio do elemento na posio original.
'
0 1 2 ' 3'
' 4 5
''
Agora, podemos utilizar o ndice como fator de desempate caso os elementos tenham a
mesma chave (ou o mesmo naipe, no nosso exemplo).
Apesar de ser possvel, forar um mtodo no estvel a se tornar estvel diminui a eficincia
dos algoritmos e faz com que o algoritmo gaste memria extra para armazenar todos os ndices.
Como o ndice quer dizer um membro a mais para cada elemento, este custo extra de memria
O(n).
16.1.2 Complexidade de tempo

Outro fator a se considerar a complexidade de tempo dos algoritmos de ordenao. A
medida mais relevante de tempo o nmero de comparaes C(n) feitas por um algoritmo para
ordenar o arranjo. Em geral os mtodos de ordenao simples requerem O(n2 ) comparaes
e so apropriados para arranjos pequenos. Os mtodos mais eficientes requerem O(n log n)
comparaes e so adequados para arranjos grandes.
Uma medida secundria de comparao entre estes algoritmos o nmero M(n) de mo-
vimentaes, ou operaes de atribuio. Alguns algoritmos conseguem fazer apenas O(n)
movimentaes enquanto a maioria dos algoritmo far O(n log n) movimentaes.
Porm, possvel forar um algoritmo a fazer apesar O(n) dos elementos principais do
arranjo atravs da ordenao de ndices. Ordenamos os ndices do arranjo em vez dos elementos
do arranjo propriamente ditos. Ao fim, reorganizamos os elementos, como indicado pelos ndices.
Esta estratgia implica em um custo O(n) extra de memria para armazenamento dos ndices.
16.1.3 Complexidade de memria

Mais um fator relevante a memria extra que estes algoritmos utilizam para conseguir
ordenar o arranjo. Os mtodos de ordenao que no precisam de memria extra so mtodos
O(1) por utilizarem memria constante para qualquer tamanho de arranjo. Estes mtodos so
chamados de mtodos in place, ou in situ.
H algoritmos que tm um gasto O(log n) de memria para ordenar arranjos. Este ainda
considerado um custo baixo, quase equivalente a algoritmos in place. Outros algoritmos menos
eficientes deste ponto de vista, tm um gasto de memria O(n).
16.2 Algoritmos simples de ordenao

Apresentaremos nesta seo mtodos simples de ordenao. Estes mtodos costumam ter custo
O(n2 ) em relao ao nmero de comparaes.
16.2.1 Ordenao por seleo

A ordenao por seleo (ou selection sort) um dos algoritmos mais simples de ordenao.
um algoritmo onde a cada passo de repetio se escolhe o menor elemento do arranjo e o
troca com o elemento da primeira posio. Repetimos este procedimento para os outros n 1
elementos.
Exemplo
Considere um arranjo de cartas com os seguintes elementos:
/ \ (
t
_,/
A partir do primeiro elemento, procuramos o menor elemento do arranjo, que no caso 4.
/ \ (
t
_,/
Este menor elemento trocado com o elemento 7, da primeira posio:
/ \ (
t
_,/
Sabemos agora que o arranjo est ordenado at o primeiro elemento.
/ \ (
t
_,/
A partir do segundo elemento, procuramos o menor elemento do arranjo.

/ \ (
t
_,/
Este colocado na segunda posio e sabemos que os dois primeiros elementos do arranjo j
esto ordenados.
/ \ (
t
_,/
A partir do terceiro elemento, procuramos o menor elemento e o colocamos na terceira

posio.
/ \
(
t
_,/
A partir do quarto elemento, procuramos o menor elemento e o colocamos na quarta posio.
/ \
(
t
_,/
A partir do quinto elemento, procuramos o menor elemento e o colocamos na quinta posio.
/ \
(
t
_,/
Como h apenas um elemento no subarranjo no ordenado direita, j sabemos que ele est
em sua posio correta ento podemos encerrar o mtodo.
A Figura 16.4 apresenta de forma resumida os passos deste processo de ordenao por
seleo. Temos um subarranjo ordenado esquerda, representado em amarelo, e um subarranjo
desordenado direita, representado em azul. A cada passo, trocamos o primeiro elemento do
arranjo desordenado com o menor elemento deste arranjo. Trocas esto representadas pelos
valores em vermelho. Assim, cresce a cada passo o subarranjo ordenado esquerda, representado
em amarelo.
Arranjo 7 5 4 6 9 8
Passo 1 4 5 7 6 9 8
Passo 2 4 5 7 6 9 8
Passo 3 4 5 6 7 9 8
Passo 4 4 5 6 7 9 8
Passo 5 4 5 6 7 8 9
Arranjo 4 5 6 7 8 9
Troca Desordenado Ordenado
Figura 16.4: Exemplo de ordenao por seleo.
Algoritmo
A ordenao por seleo para um arranjo de inteiros dada pelo seguinte cdigo:
1 void selecao ( int a [] , int n ){
2 int i , j , min ; // ndices
3 int x ; // elemento
4 // para cada posi o
5 for ( i = 0; i < n - 1; i ++){
6 // procuramos o menor entre i +1 e n e colocamos em i
7 min = i ; // m nimo o i
8 for ( j = i + 1; j < n ; j ++){
9 if ( a [ j ] < a [ min ]){
10 min = j ; // m nimo o j
11 }
12 }
13 // troca a [ i ] com a [ min ]
14 x = a [ min ];
15 a [ min ] = a [ i ];
16 a[i] = x;
17 }
18 }
Na linha 1 do cdigo, como sabemos que arranjos so passados por referncia em C++,
a ordenao ocorrer no arranjo a original e no precisamos retornar nada desta funo, o
que indicado com void. Os ndices i, j e min, declarados na linha 2, sero utilizados para
percorrermos o arranjo e procurar o menor elemento a cada passo do algoritmo.
A varivel x, declarada na linha 3, deve ser do mesmo tipo dos elementos do arranjos pois
ser uma varivel temporria para fazer as trocas entre elementos.
Nas linhas 5 a 17, temos um for que, para cada posio do arranjo, colocar em seu lugar o
elemento mnimo entre os elementos posteriores. Temos abaixo um exemplo de inicializao
destas variveis para um arranjo a:
a 6 3 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x
i j min
Na primeira iterao do for definido na linha 5, quando i tem valor 0 procuramos pela
posio do menor elemento nas linhas 6 a 12. Para isto supomos na linha 7 que o menor elemento
deste arranjo est na posio i. Ou seja, no nosso exemplo, supomos por enquanto que o menor
elemento entre as posies 0 e n-1 est na posio 0. Assim, a[i] e a[min] indicam o primeiro
elemento do arranjo ainda desordenado.
a 6 3 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x
a[i]
a[min]
i 0 j min 0
No for definido nas linhas 8 a 12, utilizamos j como contador para percorrer os elementos
entre i+1 e n-1 atualizando a posio do menor elemento. Na linha 9, para cada elemento a[i],
se este menor do que o menor que j conhecemos a[min], atualizamos a posio indicada por
min. No nosso exemplo, j percorrer as posies 1 a 6 finalizando com valor 7 e descobriremos
que o menor elemento est em a[6].
a 6 3 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x
a[i] a[j a[j a[j a[j a[j a[j a[j

a[min]
i 0 j 7 min 6
Nas linhas 13 a 16, trocamos ento os elementos da posio a[i] e a[min], ou a[0] e
a[6] em nosso exemplo. O x utilizado como uma varivel auxiliar para fazer esta troca. Com
isto, temos o fim do primeiro passo. Neste passo, procuramos ento o menor elemento entre a[0]
e a[n-1] e colocamos no lugar de a[0]. Ao fazer esta troca, sabemos agora que o primeiro
elemento j representa um arranjo ordenado, representado aqui em amarelo.
a 1 3 8 5 9 2 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 1
a[i] a[min] a[j]
i 0 j 7 min 6
Na prxima iterao do for mais externo, atualizamos i para 1 e fazemos mais um passo.
Sabemos que o arranjo at a[i] j est ordenado.
a 1 3 8 5 9 2 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 1
a[i] a[min] a[j]
i 1 j 7 min 6
Esta iterao, nas linhas 7 a 12, procura o menor elemento entre a[i] e a[n-1], variando o
valor de j. O valor de min, em nosso exemplo, ser 5.
a 1 3 8 5 9 2 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 1
a[i] a[j a[j a[j a[j a[j a[j]

a[min]
i 1 j 7 min 5
Este elemento a[min] trocado com a[i] nas linhas 13 a 16, e sabemos agora que o arranjo
at a[i] (ou a[1]) j est ordenado.
a 1 2 8 5 9 3 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 2
a[i] a[min] a[j]
i 1 j 7 min 5
Na prxima iterao do for mais externo, atualizamos novamente i para 2 e sabemos agora
que o arranjo at a[i] j est ordenado. Achamos o menor entre a[i] e a[n-1], nas linhas 6 a
12, e trocamos a[i] com a[min], nas linhas 13 a 16. Sabemos que o arranjo est ordenado at a
posio a[i].
a 1 2 3 5 9 8 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 3
a[i] a[min] a[j]
i 2 j 7 min 5
Na prxima iterao fazemos o mesmo, tendo i valor 3. Temos o arranjo ordenado entre as
posies a[0] e a[3].
a 1 2 3 5 9 8 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 5
a[i] a[j]
a[min]
i 3 j 7 min 3
Na iterao seguinte, colocamos o menor elemento em a[4].
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 6
a[i] a[min] a[j]
i 4 j 7 min 6
Na ltima iterao, colocamos o menor elemento em a[5].
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 8
a[i] a[j]
a[min]
i 5 j 7 min 5
Veja que no precisamos de uma iterao para o ltimo elemento. Se h apenas um elemento,
sabemos que ele o menor. Sabemos ento que mesmo encerrando o for sem alterar o valor das
variveis, todo os arranjo est ordenado.
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 8
a[i] a[j]
a[min]
i 5 j 7 min 5
Assim, terminamos a funo com todos os elementos do arranjo a ordenados.

Anlise
Analisaremos primeiro o lao interno interno do algoritmo, definido nas linhas 8 a 12. Sempre
que procuramos o menor elemento entre i e n, fazemos n i comparaes.
J no lao mais externo, o valor de i varia entre 0 e n 1. Assim, estas n i comparaes so
feitas para i = 0, 1, 2, . . . , n 2 elementos do arranjo desordenado, o que pode ser representado
com o seguinte somatrio:
n2
f (n) = n i = O(n2 )
i=0
Assim, sabemos que o nmero de comparaes feitas pelo algoritmo O(n2 ). Isto ocorre
para qualquer caso.
Em relao ao nmero de atribuies, cada troca, definida nas linhas 13 a 16, envolve
3 atribuies. Como so feitas n 1 trocas, temos f (n) = 3(n 1) = O(n) atribuies de
movimentao.
Alm das atribuies de movimentao, se considerarmos todas as atribuies, temos a
atualizao da posio menor, na linha 10. Esta ocorre em mdia O(n log n) vezes ao longo
de todo algoritmo, sendo O(log n) vezes por iterao. Se considerarmos estas atribuies, o
custo total de atribuies O(n log n). Note contudo, que as operaes de atribuio para
movimentao so muito mais custosas em situaes prticas.
A grande vantagem da ordenao por seleo que em relao ao custo de movimentao,
temos um custo linear O(n). ento um bom algoritmo onde estas movimentaes por algum
motivo custem muito. Em relao ao nmero de comparaes, que usualmente a operao mais
relevante, o algoritmo interessante apenas para arranjos pequenos, j que tem um custo O(n2 ).
Uma desvantagem do algoritmo que se o arranjo j estiver ordenado, isto no ajuda o
algoritmo, pois o custo de comparaes continua O(n2 ). Isto quer dizer que o algoritmo no tem
adaptabilidade. Outra desvantagem da ordeo por seleo que o algoritmo no estvel pois
a troca entre elementos pode destruir a ordem relativa dos mesmos.
Suponha este exemplo de passo do algoritmo de ordenao por seleo onde trocaremos
o elemento a[i] com o elemento a[min], como fazemos usualmente nas linhas 13 a 16 do
algoritmo. Neste caso, os elementos a serem trocados so 6 e 1.
a 6 3 8 6 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x
a[i] a[min] a[j]
i 0 j 7 min 6
Ao fazermos esta troca, o elemento a[i], de valor 6, perde sua ordem relativa entre qualquer
qualquer elemento entre a[i+1] e a[min-1]. Neste caso, o elemento a[i] perdeu sua ordem
relativa com o elemento a[3], que tem o mesmo valor.
a 1 3 8 6 9 2 6 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 1
a[i] a[min] a[j]
i 0 j 7 min 6
16.2.2 Ordenao por insero

A ordenao por insero o algoritmo mais utilizado por jogadores de cartas. um algoritmo
onde a cada passo de repetio temos um arranjo ordenado at um certo ponto, pegamos o
prximo elemento do arranjo desordenado e colocamos o na posio correta entre o primeiro e
ele mesmo.
Exemplo
/ \ (
t _,/
J sabemos inicialmente que o arranjo at o segundo elemento j est ordenado pois um

arranjo de apenas um elemento est sempre ordenado.
/ \ (
t _,/
Colocamos ento o prximo elemento do subarranjo desordenado na posio correta do

subarranjo ordenado.
/ \ (
t _,/
Sabemos agora ento que os dois primeiros elementos esto ordenados.
/ \ (
t
_,/
O terceiro elemento dever ser colocado em sua posio correta.
/ \ (
t
_,/
Sabemos agora que os trs primeiros elementos esto ordenados.
/ \ (
t
_,/
O quarto elemento dever ser colocado em sua posio correta.
/ \ (
t
_,/
Sabemos agora que os quatro primeiros elementos esto ordenados.
( / \
t
_,/
O quinto elemento dever ser colocado em sua posio correta.

( / \
t
_,/
Sabemos agora que os cinco primeiros elementos esto ordenados.
( / \
t
_,/
O ltimo elemento dever ser colocado em sua posio correta.
( / \
t
_,/
Sabemos agora que todos os elementos esto ordenados.
( / \
t
_,/
A Figura 16.5 apresenta de forma resumida os passos deste processo de ordenao por
insero. Logo no passo 1, sabemos que temos um subarranjo ordenado esquerda j que
um subarranjo de apenas 1 elemento um subarranjo ordenado. O subarranjo ordenado est
representado em amarelo, e um subarranjo desordenado direita, representado em azul. A cada
passo, tiramos o primeiro elemento do arranjo desordenado e o inserimos nas posio correta
do subarranjo ordenado que temos at o momento. As trocas esto representadas pelos valores
em vermelho. Veja como pode ser necessrio movimentar vrios elementos em um passo para
colocar um elemento em sua posio correta. Neste processo, cresce em um elemento a cada
passo o subarranjo ordenado esquerda, representado em amarelo.
Arranjo 7 5 4 6 9 8
Passo 1 7 5 4 6 9 8
Passo 2 5 7 4 6 9 8
Passo 3 4 5 7 6 9 8
Passo 4 4 5 6 7 9 8
Passo 5 4 5 6 7 9 8
Arranjo 4 5 6 7 8 9
Movimentao Desordenado Ordenado
Figura 16.5: Exemplo de ordenao por insercao.
Algoritmo
A ordenao por insero para um arranjo de inteiros dada pelo seguinte cdigo:
1 void insercao ( int a [] , int n ){

2 int i , j ; // ndices
3 int x ; // elemento
4 // para cada posi o a partir de i = 1
5 for ( i = 1; i < n ; i ++){
6 // coloca o elemento a [ i ] na posi o correta
7 x = a [ i ];
8 j = i - 1;
9 while (( j >= 0) && ( x < a [ j ])){
10 a [ j +1] = a [ j ];
11 j - -;
12 }
13 a [ j +1] = x ;
14 }
15 }
No prottipo da funo, definido na linha 1, a funo ordena o arranjo a, que contm n

elementos. Como sabemos que arranjos so passados por referncia em C++, no precisamos
retornar nada desta funo.
Os ndices i e j, definidos na linha 2, so utilizados para percorrermos o arranjo em um for
aninhado e colocar cada elemento a[i] em sua posio correta no arranjo ordenado. A varivel
x, definida na linha 3, deve ser do mesmo tipo dos elementos do arranjos pois ser uma varivel
temporria para fazer as trocas entre elementos.
a 6 3 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
i j
Entramos em um for na linha 5 que, para cada posio do arranjo, colocar o elementoa[i]
em seu lugar correto do arranjo ordenado de a[0] at a[n-1]. Na primeira iterao, quando
i 1, j sabemos antes de mais nada que o arranjo at a[0], de apenas um elemento, j est
ordenado.
a 6 3 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x
a[i]
i 1 j
Ao executar o bloco de repetio, a varivel x recebe um cpia do elementoa[i] na linha 7.

Esta cpia guardada para ser colocada em sua posio correta no arranjo ordenado. O ndice j,
recebe i-1 na linha 8. a partir de aa[i-1] que procuraremos a posio correta de a[i].
a 6 3 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 3
a[j] a[i]
i 1 j 0
No while aninhado, definido na linha 9, deslocaremos para a direita todos os elementos

anteriores a maiores que a[i], agora guardado em x para permitir o deslocamento. Temos duas
condies no while que garantem que faremos este deslocamento. A primeira condio j >= 0
garante simplesmente que faamos os deslocamentos enquanto j estiver apontando para uma
posio vlida do arranjo, maior ou igual a 0. A segunda condio x <= a[j] garante que
faremos o deslocamento apenas enquanto os itens forem maiores que x.
Na primeira iterao do while, o valor 6 deslocado em uma posio, na linha 10, e j
deslocado para a esquerda, na linha 11.
a 6 6 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 3
a[j] a[i]
i 1 j -1
Isso acorre at encontrarmos a posio de x ou at que todos os elementos tenham sido

deslocados. Na primeira iterao temos que a[0] deslocado e no temos mais elementos para
deslocar. Assim, encerramos o while pois j >= 0 false. O valor original de a[i], porm,
ainda est guardado em x.
Samos deste loop pois todos os elementos foram deslocados. Na linha 13, por fim, o
elemento x, que saiu de a[i] e est guardado em x, ento inserido em sua posio correta
a[j+1], posio do ltimo elemento deslocado para a direita. Com o fim desta operao sabemos
que os elementos a[0] at a[i] formam agora um subarranjo ordenado.
a 3 6 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 3
a[j] a[i]
i 1 j -1
Na prxima iterao do for, incrementamos i para 2, e sabemos agora que o arranjo at

a[1] j est ordenado. Repetindo o processo, x guarda uma cpia do elemento a[i] na linha
7. A partir de a[i-1],procuraremos no while a posio correta para o elemento x, deslocando
elementos para a direita. Para isto j definido como i-1 na linha 8.
a 3 6 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 8
a[j] a[i]
i 2 j 1
Como o elemento guardado x no menor que o elemento a[j], j achamos a posio

correta para ele sem executar nenhuma iterao do while. Na linha 13, o elemento x colocado
na posio a[j+1], que j era sua posio original. Sabemos que o subarranjo de a[0] at a[2]
agora est ordenado.
a 3 6 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 8
a[j] a[i]
i 2 j 1
Incrementamos i para 3 na iterao seguinte do for. Na linha 7, a varivel x recebe uma

cpia dea[i]. O ndice j marca que procuraremos a posio a partir de a[i-1], na linha 8.
a 3 6 8 5 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 5
a[j] a[i]
i 3 j 2
Deslocamos ento, o elemento a[j] em uma posio na linha 10 e decrementamos j na

linha 11 para testar o prximo elemento.
a 3 6 8 8 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 5
a[j] a[i]
i 3 j 1
O while ter mais uma iterao pois ainda no achamos a posio correta de x e nem
deslocamos todos os elementos. Deslocamos o elemento a[j] em uma posio na linha 10 e
decrementamos j na linha 11 para testar a prxima posio.
a 3 6 6 8 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 5
a[j] a[i]
i 3 j 0
Como o elemento x no menor que a[j], encontramos sua posio correta e saimos do
while devido segunda condio.
Na linha 13, o elemento guardado em x ento colocado em sua posio correta a[j+1].
Sabemos que o arranjo est ordenado at a[3].
a 3 5 6 8 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 5
a[j] a[i]
i 3 j 0
Na iterao seguinte do for, incrementamos i para 4. Assim como nas outras iteraes, nas
linhas 6 a 13, elementos maiores que a[i] sero deslocados no arranjo ordenado para a direita e
a[i] ser inserido em sua posio correta. Sabemos que o arranjo est ordenado at a[4].
a 3 5 6 8 9 2 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 9
a[j] a[i]
i 4 j 3
Em seguida, incrementamos i para 5 e, novamente nas linhas 6 a 13, inserimos a[i] em sua
posio correta no arranjo ordenado. Elementos maiores que a[i] sero deslocados no arranjo
ordenado e a[i] ser inserido em sua posio correta. Sabemos que o arranjo est ordenado at
a[5].
a 2 3 5 6 8 9 1 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 2
a[j] a[i]
i 5 j -1
Na ltima iterao, onde i tem valor 6. Inserimos a[i] novamente em sua posio correta
do arranjo e sabemos agora que todo o arranjo est ordenado.
a 1 2 3 5 6 8 9 n 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6]

x 1
a[j] a[i]
i 6 j -1
Atingimos assim nosso critrio de parada quando i chega a 7, encerrando assim a funo.
Anlise
Existem duas condies que terminam o lao mais interno do algoritmo, definido na linha 9:
Termos analisado todos os elementos
Termos encontrado a posio correta do elemento
Assim, em relao aos casos possveis para o lao interno temos o melhor caso quando
feita apenas uma comparao, pois o elemento j est em sua posio correta O(1). Temos o pior
caso, quando i comparaes so feitas at testarmos todas as posies, levando a custo O(i) para
comparar e deslocar i elementos. E o caso mdio, se supormos a mesma probabilidade de um
elemento estar em qualquer posio, temos um custo (1/i)(1 + 2 + 3 + i) = (i + 1)/2 = O(i).
J no lao mais externo, definido na linha 5, temos sempre n 1 iteraes que incluem uma
execuo do lao interno. Assim, no melhor caso, executaremos n 1 vezes o melhor caso do
lao interno O(1) e teremos uma lao externo com custo (n 1)O(1) = O(n). Se tivssemos
sempre o pior caso O(i) no lao interno, o algoritmo tem um custo n1 2
i=1 O(i) = O(n ). De modo
anlogo, no caso mdio, que tambm tem custo O(i) no lao interno, o algoritmo tambm teria
um custo total O(n2 ).
No algoritmo de ordenao por insero, o nmero de movimentaes proporcional ao

nmero de comparaes. Isso porque os elementos so movimentados at que uma comparao
indique que a posio correta foi enfim, encontrada. Sendo assim, em relao ao nmero de
movimentaes, temos tambm um melhor caso O(n), pior caso O(n2 ) e caso mdio O(n2 ).
O algoritmo tem um melhor caso que ocorre quando os elementos j esto ordenados.
Sendo assim, uma ordenao prvia aproveitada pelo algoritmo pois no fazemos tantos
deslocamentos. Quando isso acontece, dizemos que o mtodo adaptvel.
Assim, a ordenao por insero um bom mtodo para se adicionar alguns poucos elementos
a um arranjo ordenado, pois ter um custo baixo em um arranjo quase ordenado.
A ordenao por insero tambm um algoritmo de ordenao estvel, pois a ordem
relativa dos elementos mantida no deslocamentos feitos para se encontrar a posio de um
elemento.
Apesar de pouco provvel, na maior parte das aplicaes prticas, o custo mximo do algo-
ritmo ocorre quando os elementos esto em ordem reversa, pois sempre faremos i deslocamenos
de elemento por iterao. Neste pior caso, se o nmero de movimentaes o fator mais
relevante, ele se torna muito ineficiente em relao ordenao por seleo.
Na Tabela 16.2 temos um resumo do custo do algoritmo de ordenao por insero em seus
principais casos. Tanto o pior caso quando o caso mdio tm custo O(n2 ) para ordenar o arranjo.
Caso Descrio Custo

Pior caso Arranjo desordenado O(n2 )
Caso mdio Arranjo com elementos em ordem aleatria O(n2 )
Melhor caso Arranjo ordenado O(n)
Tabela 16.2: Custo do algoritmo de ordenao por insero em suas situaes mais comuns
16.2.3 Comparao entre algoritmos simples de ordenao

Nesta seo apresentamos dois algoritmos simples para ordenao: a ordenao por seleo
e ordenao por insero. Na Tabela 16.3 temos uma comparao do comportamento deste
algoritmos. Os dois algoritmos tm o mesmo custo mdio e custo de pior caso O(n2 ) mas existem
vantagens e desvantagens.
Para a ordenao por seleo, no existem diferenas entre os melhores e piores casos. A
medida que nos aproximamos do melhor caso da ordenao por insero, que quando o arranjo
est ordenado, temos um custo assinttico O(n) para a funo, pois ela apenas confere se o
arranjo j est ordenado.
Em relao ao nmero de movimentaes, a ordenao por seleo sempre faz apenas n
trocas de elementos, enquanto a ordenao por insero faz um nmero de movimentaes
proporcional ao nmero de comparaes no deslocamento dos elementos.
Por fim, a ordenao por insero tem duas caractersticas vantajosas. Ela um mtodo
de ordenao estvel, ou seja, que no desfaz a ordem entre elementos que tenham a mesma
chave. Ela tambm tem um custo menor para arranjos que j estejam quase ordenados, o que
chamamos de adaptabilidade.
Como os dois algoritmos tm um custo O(n2 ) no caso mdio, importante fazer uma
comparao com testes reais com estes algoritmos. Para estes testes, implementamos verses
eficientes dos dois algoritmos e medimos o tempo para ordenar arranjos de diversos tamanhos.
A Figura 16.6 apresenta o tempo necessrio por cada algoritmo para ordenar um arranjo de
elementos em ordem aleatria. No caso mdio, a ordenao por insero muito mais eficiente
que a ordenao por seleo. medida que o tamanho dos arranjos cresce, a diferena entre os
Algoritmo
Seleo Insero
Comparaes
Caso mdio O(n2 ) O(n2 )
Pior caso O(n2 ) O(n2 )
Melhor caso O(n2 ) O(n)
Movimentaes
Caso mdio O(n) O(n2 )
Pior caso O(n) O(n2 )
Melhor caso O(n) O(n)
Caractersticas
Estabilidade No Sim
Adaptabilidade No Sim
Tabela 16.3: Comparao de custo em termos de nmero de comparaes para algoritmos

simples de ordenao. Os dois algoritmos tm um custo mdio O(n2 )
dois algoritmos se torna ainda mais discrepante.

4
x 10
5
Seleo
Seleo
4.5 Insero
Insero
3.5
2
Tempo (segundos)
Tempo (segundos)
2.5
1
1.5
0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
Tamanho do arranjo Tamanho do arranjo x 10
4
Figura 16.6: Tempo necessrio para se ordenar um arranjo com ordem inicial aleatria (caso
mdio).
Na Figura 16.7 temos a proporo entre o tempo necessrio para se ordenar um arranjo com
cada um dos algoritmos. A linha verde, com valor 1, representa o tempo gasto pela ordenao por
insero. A linha azul, representa quantas vezes mais tempo levou uma ordenao por seleo.
Em proporo, para alguns tamanhos de arranjo, a ordenao por seleo chega a ser quase 18
vezes mais lenta que a ordenao por insero.
J o pior caso da ordenao por insero ocorre quando os arranjos esto em ordem descres-
cente, por temos nestes casos mais deslocamentos de elementos. A Figura 16.8 apresenta o tempo
necessrio por cada algoritmo para ordenar um arranjo de elementos em ordem decrescente.
Mesmo nestes casos especficos, a ordenao por insero consegue ser mais vantajosa que uma
ordenao por seleo, apesar da diferena de desempenho entre os algoritmos ser menor.
Na Figura 16.9 temos a proporo entre o tempo necessrio para se ordenar um arranjo em
ordem decrescente com cada um dos algoritmos. A linha verde, com valor 1, representa o tempo
gasto pela ordenao por insero. A linha azul, representa quantas vezes mais tempo levou uma
6 18
Seleo
Seleo Insero
Insero 16
5
Tempo (em proporo ordenao por seleo)

14
4 12
10
3
8
2 6
4
1
2
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.7: Proporo entre tempo necessrio para se ordenar um arranjo com ordem inicial
aleatria (caso mdio).
4
x 10
4.5
Seleo
Insero Seleo
4 Insero
3.5
2 3
Tempo (segundos)
Tempo (segundos)
2.5
1 1.5
0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.8: Tempo necessrio para se ordenar um arranjo com ordem decrescente (pior caso
para a ordenao por insero).
ordenao por seleo. Em proporo, para alguns tamanhos de arranjo, mesmo no pior caso
da ordenao por insero, a ordenao por seleo chega a ser quase 9 vezes mais lenta que a
ordenao por insero.
Por fim, o melhor caso da ordenao por insero ocorre quando os arranjos esto em
ordem crescente, pois nestes casos no temos deslocamentos de elementos. O algoritmo apenas
confere a ordenao do arranjo e encerra. A Figura 16.10 apresenta o tempo necessrio por
cada algoritmo para ordenar um arranjo de elementos em ordem decrescente. O desempenho da
ordenao por insero nestes casos muito melhor.
Na Figura 16.11 temos a proporo entre o tempo necessrio para se ordenar um arranjo em
ordem crescente com cada um dos algoritmos. A linha verde, com valor 1, representa o tempo
gasto pela ordenao por insero. A linha azul, representa quantas vezes mais tempo levou
uma ordenao por seleo. Em proporo, para alguns tamanhos de arranjo apresentados, a
ordenao por insero em seu melhor caso chega a ser quase 2.500 vezes mais rpida que a
ordenao por seleo. Esta diferena maior a medida que os arranjos sejam maiores.
8 9
Seleo Seleo
Insero Insero
7 8

7
6
6
5
5
4
4
3
3
2
2
1 1
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.9: Proporo entre tempo necessrio para se ordenar um arranjo com ordem decrescente
(pior caso para a ordenao por insero).
4
x 10
5
Seleo
Seleo
Insero
4.5 Insero
3.5
2
Tempo (segundos)
Tempo (segundos)
2.5
1
1.5
0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.10: Tempo necessrio para se ordenar um arranjo com ordem decrescente (melhor
caso para a ordenao por insero).
Vemos ento como a diferena real entre algoritmos para a mesma tarefa pode ser significativa
em aplicaes prticas. Como previmos com nossa medida por modelos matemticos que o
algoritmo por insero teria um melhor caso O(n), j era esperado que houvesse grande diferena
de desempenho em relao ordenao seleo, que tem custo O(n2 ) para todos os casos.
16.2.4 Exerccios
2 # include < stdlib .h >
3 # include < time .h >
4
6
7 void learranjo ( int a [] , int n );
30 2500
Seleo Seleo
Insero Insero
25

2000
20
1500
15
1000
10
500
5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.11: Proporo entre tempo necessrio para se ordenar um arranjo com ordem crescente
(melhor caso para a ordenao por insero).
8 void imprimearranjo ( int a [] , int n );

9 void embaralhaarranjo ( int a [] , int n );
10 // ordena o pelo m todo da bolha
11 void ordena ( int a [] , int n );
12 // ordena o pelo m todo 1
13 void ordena1 ( int a [] , int n );
14 // ordena o pelo m todo 2
15 void ordena2 ( int a [] , int n );
16
17 int main () {
18 // gerador de n meros aleat rios
19 srand ( time ( NULL ));
20
21 // tamanho do arranjo
22 int n ;
24 cin >> n ;
25 // ponteiro para arranjo que ser alocado com tamanho n
26 int * v ;
27 v = new int [ n ];
28 learranjo (v , n );
29 imprimearranjo (v , n );
30
31 cout << " Embaralhando " << endl ;
32 embaralhaarranjo (v , n );
34 cout << " Ordenando pelo m todo da bolha " << endl ;
35 ordena (v , n );
37
41 cout << " Ordenando pelo metodo ??? " << endl ;
42 ordena1 (v , n );
44
48 cout << " Ordenando pelo metodo ??? " << endl ;
49 ordena2 (v , n );
51
52 return 0;
53 }
54
55 void embaralhaarranjo ( int a [] , int n ) {
56 int pos ,i , aux ;
57 for ( i =0; i < n ; i ++){
58 pos = rand () % n + 0; // posicao entre 0 e n -1
59 aux = a [ i ];
60 a [ i ] = a [ pos ];
61 a [ pos ] = aux ;
62 }
63 }
64
65 void learranjo ( int a [] , int n )
66 {
67 for ( int i = 0; i < n ; i ++){
68 cout << " Digite o elemento v [ " <> a [ i ];
70 }
71 }
72
73
74 void imprimearranjo ( int a [] , int n )
75 {
76 cout << " v = " ;
77 for ( int i = 0; i < n ; i ++){
78 cout << a [ i ] << " " ;
79 }
80 cout << endl ;
81 }
82
84 {
85 int i ,j , aux ;
86 for ( j = n -1; j >0; j - -)
87 for ( i =0; i < j ; i ++)
88 {
89 if ( a [ i +1] < a [ i ])
90 {
91 // trocar a [ i ] com a [ i +1]
92 aux = a [ i ];
93 a [ i ] = a [ i +1];
94 a [ i +1] = aux ;
95 }
96 }
97 }
98
99 void ordena1 ( int a [] , int n )
100 {
101 int i , j , pos_min , aux ;
102 for ( i = 0; i < n - 1; i ++)
103 {
104 pos_min = i ;
105 for ( j = i + 1; j < n ; j ++)
106 {
107 if ( a [ j ] < a [ pos_min ])
108 {
109 pos_min = j ;
110 }
111 }
112 // troca a [ i ] com a [ min ]
113 aux = a [ pos_min ];
114 a [ pos_min ] = a [ i ];
115 a [ i ] = aux ;
116 }
117 }
118
119 void ordena2 ( int a [] , int n )
120 {
121 int i , j , aux ;
122 for ( i = 1; i < n ; i ++)
123 {
124 aux = a [ i ];
125 j = i - 1;
126 while ( aux < a [ j ] && j >= 0)
127 {
128 a [ j +1] = a [ j ];
129 j - -;
130 }
131 a [ j +1] = aux ;
132 }
133 }

Exerccio 16.2 Renomeie as funcoes ordena1 e ordena2 para o nome correto dos mtodos
de ordenao.
Exerccio 16.3 Crie um struct do tipo Aluno com nome e numero de matricula de cada
aluno.
Exerccio 16.4 Faa com que as funes de ordenao ordenem agora arranjos de elementos
do tipo Aluno de acordo com seus nmeros de matrcula.
Exerccio 16.5 Faa com que as funes de ordenao retornem o nmero de comparaes
realizadas em vez de void.
Exerccio 16.6 Compare o nmero de comparaes realizadas por cada mtodo de ordenao
para diferentes tamanhos de arranjo. Para que isto seja possvel em arranjo grandes, faa
com que os elementos sejam atribudos automaticamente ao arranjo. Utilize a funo rand(),
apresentada na funo embaralhaarranjo.
16.3 Algoritmos eficientes de ordenao

Apresentaremos nesta seo mtodos simples de ordenao. Estes mtodos costumam ter custo
O(n log n) em relao ao nmero de comparaes.
16.3.1 Merge sort

O merge sort (ordenao por intercalao), um mtodo que utiliza uma tcnica de dividir
para conquistar. um algoritmo onde a cada passo, se divide o arranjo em dois subarranjos
menores at que tenhamos vrios arranjos de tamanho 1. Ento, iniciamos uma repetio onde,
dois subarranjos so fundidos em um subarranjo maior ordenado at que tenhamos o arranjo
original ordenado.
Exemplo
/ \ (
t
_,/
Inicialmente, consideramos que temos um subarranjo desordenado de 8 elementos. Vamos

iniciar assim a etapa de diviso. Vamos dividir cada subarranjo na metade. Esse processo
continua at que tenhamos subarranjos de um elemento cada.
/ \ (
t
_,/
/ \ (
t
_,/
/ \ (
t
_,/
/ \ (
t
_,/
Por definio, sabemos que cada um destes arranjos de 1 elemento um arranjo ordenado.
Iniciaremos agora a fase de intercalao destes arranjos ordenados. Os dois primeiros arranjos
ordenados so intercalados em um novo arranjo ordenado.
/ \ (
t
_,/
Fazemos isto com todos os arranjos menores.
/ \ (
t
_,/
/ \ (
t
_,/
/ \ (
t
_,/
O interessante que o custo de se intercalar dois arranjos ordenados de tamanho n = O(n)

em um arranjo ordenado de tamanho 2n = O(n) apenas O(n), um custo menor do que seria o
custo de se colocar dois arranjos desordenados em um arranjo ordenado (o que teria o mesmo
custo de uma ordenao). Fazemos a intercalao para os arranjos de tamanho 2:
/ \ (
t
_,/
/ \ (
t
_,/
Na ltima etapa de intercalao, temos todo o arranjo original ordenado.
( / \
t
_,/
A Figura 16.12 apresenta de forma resumida os passos deste processo de ordenao com o
merge sort. Na etapa de diviso, os arranjos desordenados so divididos at que formem arranjos
ordenados de apenas 1 elemento. Estes arranjos ordenados so representados em amarelo. A
cada passo de intercalao, ou conquista, intercalamos arranjos ordenados em novos arranjos
ordenados maiores.
Diviso 7 5 3 4 6 2 9 8
7 5 3 4 6 2 9 8
7 5 3 4 6 2 9 8
7 5 3 4 6 2 9 8
Intercalao
5 7 3 4 2 6 8 9
3 4 5 7 2 6 8 9
2 3 4 5 6 7 8 9
Desordenado Ordenado
Figura 16.12: Exemplo de ordenao com o merge sort.
Algoritmo de intercalao
Em sua implementao mais usual, a etapa de intercalao de dois arranjos requer um arranjo
auxiliar, onde sero colocados os itens. Os elementos so intercalados em um arranjo auxiliar e
ento so transferidos de volta para o arranjo de onde vieram: o arranjo sendo ordenado. Isto
apresentado na Figura 16.13
Assim, para se intercalar n elementos, precisamos de uma memria extra O(n) para o arranjo
auxiliar.
Temos abaixo o algoritmo de intercalao:
1 void intercala ( int a [] , int n ) {
2 // arranjo tempor rio para intercala o
3 int * temp = new int [ n ];
4 // ndice que marca o meio do arranjo
5 int meio = n / 2;
6 // ndices para a estrutura de repeti o
7 int i , j , k ;
8 // ndice i para itens do primeiro arranjo
9 i = 0;
10 // ndice j para itens do segundo arranjo
11 j = meio ;
12 // ndice k para itens no arranjo tempor rio
13 k = 0;
14 // enquanto i e j n o chegam ao fim dos arranjos
15 while (( i < meio ) && ( j < n )){
5 7 3 4
3 4 5 7
3 4 5 7
Figura 16.13: Etapa de intercalao de um merge sort.
16 // o menor entre a [ i ] e a [ j ] vai temp

17 if ( a [ i ] < a [ j ]){
18 temp [ k ] = a [ i ];
19 i ++;
20 } else {
21 temp [ k ] = a [ j ];
22 j ++;
23 }
24 k ++;
25 }
26 // se o ndice i chegou ao fim de seu arranjo
27 if ( i == meio ){
28 // copiamos o restante do segundo arranjo para temp
29 while ( j < n ){
30 temp [ k ] = a [ j ];
31 j ++;
32 k ++;
33 }
34 }
35 // se foi j quem chegou ao fim de seu arranjo
36 else {
37 // copiamos o restante do primeiro arranjo para temp
38 while ( i < meio ){
39 temp [ k ] = a [ i ];
40 i ++;
41 k ++;
42 }
43 }
44 // temp agora tem todos os elementos intercalados
45 // copiamos os elementos de volta para a []
46 for ( i = 0; i < n ; i ++){
47 a [ i ] = temp [ i ];
48 }
49 // o arranjo tempor rio pode ser ent o apagado
50 delete [] temp ;
51 }
O algoritmo de intercalao intercala a primeira metade ordenada do arranjo a, que a[0] a
a[(n/2)-1], com sua segunda metade ordenada a[n/2] a a[n-1]. O algoritmo organizado
em 3 etapas principais. Entre as linhas 2 e 13, criamos um arranjo temporrio e inicializamos os

ndices. Entre as linhas 14 e 43, os elementos de a so intercalados nesse arranjo temporrio
temp. Na linhas 44 a 50, os elementos intercalados no arranjo temporrio so transferidos de
volta para o arranjo a.
Temos aqui um exemplo de intercalao. Na linha 3, criamos um ponteiro temp que aponta
para um arranjo de dados do tipo int. Note que o arranjo alocado dinamicamente e, por isto,
est fora do escopo da funo. O ndice meio, declarado na linha 5, marca onde est o meio do
arranjo e no se alterar ao longo da funo. Elementos entre a[0] e a[meio-1] representam
representam o primeiro subarranjo ordenado. Elementos entre a[meio] e a[n-1] representam
representam o segundo subarranjo ordenado. Por fim, nas linhas 8 a 13, o ndice i marcar
o incio do primeiro subarranjo ordenado, o ndice j marcar o incio do segundo subarranjo
ordenado e o ndice k marcar o incio do arranjo temporrio.
a 3 4 5 7 2 6 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[i] a[j] a[n]

a[meio]
temp i 0 j 4 k 0
temp[0] temp[1] temp[2] temp[3] temp[4] temp[5] temp[6] temp[7]
temp[k]
Na funo os elementos de a[0] at a[3] (ou a[meio-1]) sero intercalados com os elementos
de a[4] (ou a[meio]) a a[7] (ou a[n-1]). Por isto a condio de repetio na linha 15 que i
ainda no tenha chegado a meio e j no tenha chegado a n.
Na linha 17, sempre escolhemos o menor elemento entre a[i] e a[j] para guardarmos
em temp[k]. Nas linhas 18 e 19, guardamos o valor do primeiro subarranjo em temp e
incrementamos i para marcar qual o prximo elemento a ser copiado deste arranjo. Nas linhas
21 e 22, guardamos o valor do segundo subarranjo em temp e incrementamos j. O ndice k
sempre incrementado para marcar a prxima posio do arranjo temporrio. Na primeira iterao,
por exemplo, como a[j] menor que a[i], copiaremos a[j] para temp[k] e incrementaremos
os ndices j e k.
a 3 4 5 7 2 6 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[i] a[meio] a[j] a[n]
temp i 0 j 5 k 1
temp[k]
Este processo das linhas 16 a 24 continua se repetindo at que i atinja meio ou j atinja n. O
valor 3, por ser menor que 6, inserido no arranjo temporrio temp.
a 3 4 5 7 2 6 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[meio] a[j] a[n]

a[i]
temp i 4 j 6 k 6
2 3 4 5 6 7
temp[k]
O valor 4, por ser menor que 6, inserido no arranjo temporrio temp.
a 3 4 5 7 2 6 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[i] a[meio] a[j] a[n]
temp i 2 j 5 k 3
2 3 4
temp[k]
Em nosso exemplo, a repetio se encerrar quando i atinjir o valor de meio, indicando que
todos os elementos do primeiro subarranjo ordenado j esto em temp.
a 3 4 5 7 2 6 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[meio] a[j] a[n]

a[i]
temp i 4 j 6 k 6
2 3 4 5 6 7
temp[k]
Ao sair do lao de repetio, temos um teste i == meio na linha 27. Este teste nos diz se a
condio de repetio encerrou porque o primeiro subarranjo foi todo percorrido por i (i ==
meio) ou porque o segundo subarranjo foi todo percorrido por j (j == n). Em nosso exemplo,
a primeira condio verdadeira, o que nos leva para o bloco de comandos entre as linhas 28 e
33. Isso quer dizer que os outros elementos do segundo arranjo ainda precisam ser copiados.
Para copiar os elementos restantes do outro subarranjo, temos uma estrutura de repetio
while que percorrer todas as posies a[j] guardando estes elementos em temp[k]. Ao fim
do processo, i sempre ser meio e j sempre ser n.
a 3 4 5 7 2 6 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[meio] a[j]
a[i] a[n]
temp i 4 j 8 k 8
2 3 4 5 6 7 8 9
temp[k]
Note que se o segundo subarranjo tivesse sido todo copiado primeiro, os comandos entre as
linhas 36 e 43 seriam executados para copiar os elementos restantes do primeiro subarranjo de
maneira anloga.
Ao chegar neste ponto, o vetor temp tem todos os elementos intercalados. Ao fim do cdigo,
nas linhas 44 a 50, copiamos os elementos de temp de volta para a e desalocamos o arranjo
apontado por temp.
a 2 3 4 5 6 7 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]

a[7]
meio 4
a[i] a[n]
a[meio] a[j]
temp i 4 j 8 k 8
2 3 4 5 6 7 8 9
temp[k]
Note que importante desalocar o arranjo apontado por temp. Se o arranjo no for desalo-
cado, temos um erro de vazamento de memria, pois o arranjo foi alocado dinamicamente e no
pertence ao escopo da funo.
Nos nossos exemplos de alocao dinmica de arranjos, na Seo 11.3, fizemos com que
os ponteiros apontassem para nullptr aps desalocar a memria apontada por eles. Neste
caso, no precisamos fazer com que temp receba nullptr pois temp deixar de existir logo na
prxima linha, ao fim da funo.
Algoritmo de ordenao
A utilidade de funes justamente quebrar problemas em problemas menores. Usando
a funo apresentada de intercalao como uma funo auxiliar, podemos definir de maneira
simples a funo de ordenao com o merge sort. Essa funo de ordenao pode ser facilmente
expressa em termos recursivos.
Utilizando a funo de intercalao como uma funo auxiliar, esta funo recursiva ordena
um arranjo com o mtodo Merge Sort.
1 void mergeSort ( int a [] , int n ) {
2 int meio ;
3 if ( n > 1) {
4 meio = n / 2;
5 mergeSort (a , meio );
6 mergeSort ( a + meio , n - meio );
7 intercala (a , n );
8 }
9 }
Na linha 4, dividimos o arranjo ao meio. Na linha 5, usamos o prprio mtodo recursivamente
para ordenar o arranjo at a metade. Na linha 6, agora usamos o prprio mtodo recursivamente
para ordenar o arranjo da metade at o final. Na linha 7, intercalamos os dois subarranjos
ordenados em a com a funo de intercalao que j deve estar declarada.
Como vimos na Seo 9.11, sobre recurso, as funes recursivas precisam de um passo
recursivo e um caso base. O caso base garante que no entraremos em uma recurso infinita.
Veja que o passo recursivo acontece sempre que chamamos a prpria funo mergeSort para
um arranjo menor que o original. J a condio da linha 3 garante que o caso base ocorra. Esta
condio garante que o passo recursivo s ser executado para arranjos maiores que 1. Para
arranjos de tamanho 0 ou 1, temos nosso caso base, pois o arranjo j est ordenado e basta no
executar instruo alguma.
Em nosso exemplo, a funo ser executada ento nas primeira metade do arranjo a[0] a
a[3] e na segunda metade a[4] a a[8].
mergeSort(&a[0], 8)
a 7 5 3 4 6 2 9 8 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 4
a[0] a[meio] a[n]
Na linha 5 da funo mergeSort(&a[0],8), chamada uma cpia da funo para ordenar

o arranjo nas posies a[0] a a[3]. Lembre-se que um arranjo nada mais que um endereo
onde se inicia uma srie de elementos alocados na memria. Assim, a funo chamada ordenar
o arranjo de elementos que comea no endereo de a e vai at 4 posies a frente. A funo
original mergeSort(&a[0],8) fica na pilha de funes e fica em espera.
mergeSort(&a[0], 4)
a 7 5 3 4 6 2 9 8 n 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 2
a[0] a[meio] a[n]

Na linha 5 da funo mergeSort(&a[0],4), chamada uma cpia da funo para ordenar

o arranjo nas posies a[0] a a[1]. A funo mergeSort(&a[0],4) fica na pilha de funes e
fica em espera.
mergeSort(&a[0], 2)
a 5 7 3 4 6 2 9 8 n 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 1
a[0] a[meio] a[n]
Na funo mergeSort(&a[0],2) as duas chamadas de funo das linhas 5 e 6 no executa-

ro nenhum comando, pois elas tero arranjo de tamanho 1, que o caso base da funo. Assim,
iremos para a linha 7 da funo mergeSort(&a[0],2). A linha 7 utiliza a funo intercala,
que temos definida anteriormente. Assim, os elementos 7 e 5 so intercalados de maneira correta.
A funo mergeSort(&a[0],4), que havia chamado mergeSort(&a[0],2) volta a ser
executada.
mergeSort(&a[0], 4)
a 5 7 3 4 6 2 9 8 n 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 2
a[0] a[meio] a[n]
Na linha 6, esta funo chama mergeSort para o arranjo que se inicia no endereo a + meio
e tem tamanho n-meio.
mergeSort(&a[2], 2)
a 5 7 3 4 6 2 9 8 n 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 1
a[0] a[meio] a[n]
Na funo mergeSort(&a[2],2), as duas operaes de ordenao das linhas 6 e 7 cairo

no caso base, pois h apenas um elemento. A operao de intercalao manter os elementos
como esto j que eles j esto em ordem. Assim retornaremos funo mergeSort(&a[0],4),
que a chamou.
mergeSort(&a[0], 4)
a 5 7 3 4 6 2 9 8 n 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 2
a[0] a[meio] a[n]
A chamada mergeSort(&a[0],4) da funo j executou recursivamente assim as linhas

5 e 6, que ordenam os elementos nas duas metades do arranjo. Na linha 7, os elementos a[0]
e a[1], da primeira metade do arranjo, sero intercalados com os elementos a[2] e a[3], do
segundo subarranjo ordenado.
mergeSort(&a[0], 4)
a 3 4 5 7 6 2 9 8 n 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 2
a[0] a[meio] a[n]
Com o fim da intercalao, a funo mergeSort(&a[0],4) retorna e voltamos a executar

sua funo chamadora mergeSort(&a[0],8).
mergeSort(&a[0], 8)
a 3 4 5 7 6 2 9 8 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 4
a[0] a[meio] a[n]
A execuo da linha 5 j ordenou recursivamente a primeira metade do arranjo. Como j

vimos ser possvel, na linha 6, a funo mergeSort(&a[4],4) ordenar a segunda metade do
arranjo, que comea no endereo &a[4] e tem 4 elementos.
mergeSort(&a[0], 8)
a 3 4 5 7 2 6 7 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 4
a[0] a[meio] a[n]
Basta agora intercalar as duas metades ordenadas do arranjo, o que feito na linha 7.
mergeSort(&a[0], 8)
a 2 3 4 5 6 7 8 9 n 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
meio 4
a[0] a[meio] a[n]
Temos assim o arranjo original ordenado e finalizamos a funo.
Anlise
Uma pea fundamental do algoritmo a intercalao de dois arranjos. Esta intercalao tem
um custo O(n) pois passamos 1 vez por cada elemento o colocando-o no arranjo temporrio.
Como cada etapa de intercalao custa O(n), o custo total do algoritmo merge sort depende
ento do nmero de intercalaes feitas. Para isto, analisemos todos os passos de intercalao
apresentados na Figura 16.14.
No exemplo note que houve k = 3 passos de intercalao para n = 8 elementos sendo
ordenados. Em cada passo de intercalao, temos um custo O(n). Assim, o custo total do
algoritmo O(nk). Nos resta saber o nmero k de passos.
7 5 3 4 6 2 9 8
5 7 3 4 2 6 8 9
3 4 5 7 2 6 8 9
2 3 4 5 6 7 8 9
Figura 16.14: Representao de todas as etapas de intercalao de um merge sort.
Como a cada passo dobramos o tamanho do arranjo intercalado, em k passos de intercalao

conseguiremos ordenar k2 elementos. Se quisermos saber o nmero de passos para ordenao de
n elementos, podemos inverter a equao e termos:
2k = n k = lg n
Sendo assim, precisamos de k = lg n passos para encerrar o algoritmo com n elementos.
Assim, o custo total do algoritmo merge sort O(nk) = O(n log n) para qualquer caso.
Como vimos na Seo 14.6, sobre classes de algoritmo, o algoritmo merge sort um
algoritmo tpico da classe loglinear, pois um algoritmo que quebra o problema em problemas
menores, faz uma operao para cada um dos elementos e depois combina os resultados.
Sendo assim, a complexidade do mtodo O(n log n). Uma vantagem do mtodo sua
complexidade constante para o pior caso e melhor caso. Sua maior desvantagem a necessidade
de memria extra O(n) na fase de intercalao e nas chamadas recursivas da funo. Dessa
forma, esse o algoritmo a ser usado quando queremos uma ordem de complexidade baixa,
constante, mas que a memria no seja um problema. Ele tambm um algoritmo estvel, pois a
fase de intercalao no desfaz a ordem relativa entre elementos de mesma chave.
16.3.2 Quicksort
Para uma ampla variedade de situaes, o quicksort o mtodo mais rpido que se conhece.
Assim como o merge sort, o quicksort tambm definido de maneira recursiva. A cada passo do
Quicksort, o problema de ordenao dividido em dois problemas menores que so ordenados
de maneira independente.
A parte mais complexa do mtodo a partio do problema em problemas menores. Esse
processo de partio feito a partir da escolha de um piv x. Assim que escolhido o piv, um
arranjo dividido em duas partes: (i) o subarranjo da esquerda, com elementos menores ou
iguais a x, e (ii) o subarranjo da direita com elementos maiores ou iguais a x.
Exemplo
/ \ (
t
_,/
Escolheremos um piv x, que neste exemplo ser o elemento do meio do arranjo, 4.
/ \ (
t
_,/
Particionamos o arranjo de modo que elementos menores que o piv fiquem esquerda e
elementos maiores fiquem direita.
( / \
t
_,/
Pelo mesmo princpio recursivo, selecionamos um piv para cada subarranjo.
( / \
t
_,/
Particionamos novamente os subarranjos com os maiores direita e menores esquerda
( / \
t
_,/
Repetiremos o processo para cada subproblema. Porm, os arranjos de tamanho 1 j so

considerados como ordenados. Este o caso base.
( / \
t
_,/
Este o resultado do novo processo de partio.
( / \
t
_,/
Todos os subarranjos gerados de tamanho 1 podem ser ento considerados ordenados.
( / \
t
_,/
Com todos os subarranjos ordenados, sabemos que o arranjo original est ordenado.
( / \
t
_,/
Particionamento
Para fazer o particionamento de um arranjo no quicksort:
1. Escolhemos um piv x
2. Percorremos o arranjo a partir da esquerda at que a[i] >= x
3. Percorremos o arranjo a partir da direita at que a[j] >= x
4. Se i e j no tiverem cruzado, trocamos os elementos de a[i] com a[j]
5. Incrementamos i, decrementamos j e continuamos do passo 2 at que i e j se cruzem
Como exemplo, considere novamente o arranjo de cartas com os seguintes elementos:
/ \ (
t
_,/
Escolhemos um elemento como piv.
/ \ (
t
_,/
Definimos ndices i e j que marcam o nicio e o fim do arranjo
/ \ (
t
_,/
a[i] a[j]
Movimentamos i para a direita at encontrar um elemento maior ou igual a x. Neste caso, o
elemento o prprio 7.
/ \ (
t
_,/
a[i] a[j]
Movimentamos j para a esquerda at encontrar um elemento menor ou igual a x. O primeiro

elemento nesta condio o 2.
/ \ (
t
_,/
a[i] a[j]
Trocamos a[i] com a[j].
( / \
t
_,/
a[i] a[j]
Deslocamos i e j e continuaremos o processo.
( / \
t
_,/
a[i] a[j]
Deslocamos i at encontrar um elemento a[i] maior ou igual a x. Este elemento j o 5.

( / \
t
_,/
a[i] a[j]
Deslocamos j at encontrar um elemento a[j] menor ou igual a x. Este elemento o 4.
( / \
t
_,/
a[i] a[j]
Trocamos a[i] com a[j].
( / \
t
_,/
a[i] a[j]
Deslocamos i e j e continuaremos o processo.

( / \
t
_,/
a[i]
a[j]
Deslocamos i at encontrar um elemento a[i] maior ou igual a x. Este elemento o 5.
( / \
t
_,/
a[j] a[i]
Deslocamos j at encontrar um elemento a[j] menor ou igual a x. Este elemento j o 3.
( / \
t
_,/
a[j] a[i]
Desta vez, porm, os valores de i e j se cruzaram e por isto no faremos a troca e encerramos
a funo. Os itens da esquerda at o elemento a[j] formam um subarranjo com elementos
menores ou iguais ao piv. Os itens da direita a partir do elemento a[i] formam um subarranjo
com elementos maiores ou iguais ao piv.
subarranjo 1 subarranjo 2
( / \
t _,/
a[j] a[i]
Em todos os exemplos at o momento, o piv foi escolhido como o elemento na posio
(i+j)/2.
A Figura 16.15 apresenta de forma resumida os passos deste processo de partio, que coloca
os elementos menores esquerda e elementos maiores direita. A cada passo percorremos da
esquerda para a direita e da direita para a esquerda procurando elementos que so maiores e
menores que o piv. Trocamos estes elementos at que os ndices se cruzem. Veja que os dois
subarranjos formados no so sempre do mesmo tamanho.
Passo 7 5 3 4 6 2 9 8
1 2 5 3 4 6 7 9 8
2 2 4 3 5 6 7 9 8
3 2 4 3 5 6 7 9 8
Movimentao Piv
Figura 16.15: Exemplo de partio para ordenao com o mtodo quicksort.
A Figura 16.16 apresenta de forma resumida os passos de um processo de ordenao com o

quicksort. A cada passo, os arranjos desordenados so divididos em dois outros subarranjos, com
elementos menores e maiores que o piv. O processo se repete at que se formem arranjos de
apenas 1 elemento, que so, por definio, ordenados. Estes arranjos ordenados so representados
em amarelo.
Algoritmo de partio
Este o algoritmo que particiona o arranjo a[esq]...a[dir] nos subarranjos a[esq]...a[j]
e a[i]...a[dir].
1 void particionar ( int esq , int dir , int &i , int &j , int a []) {
2 int x , temp ;
3 i = esq ;
Passo 7 5 3 4 6 2 9 8
1 2 4 3 5 6 7 9 8
2 2 3 4 5 6 7 9 8
3 2 3 4 5 6 7 8 9
Subarranjo Ordenado
Desordenado Piv
Figura 16.16: Exemplo de ordenao com o quicksort.
4 j = dir ;
5 x = a [( i + j ) / 2];
6 do {
7 while ( x > a [ i ]){
8 ++ i ;
9 }
10 while ( x < a [ j ]){
11 --j ;
12 }
13 if ( i <= j ){
14 temp = a [ i ];
15 a [ i ] = a [ j ];
16 a [ j ] = temp ;
17 ++ i ; --j ;
18 }
19 } while ( i <= j );
20 }
O prottipo da funo recebe o arranjo a e as posies esq e dir entre as quais o arranjo
deve ser particionado. Os ndices i e j so passados por referncia pois ao final da funo
devero marcar onde comeam e terminam os subarranjos criados.
O lao interno do algoritmo de partio, definido entre as linhas 7 e 18, muito simples. Por
isto, o algoritmo quicksort to rpido.
Na linha 1, a funo de partio recebe vrios parmetros. Os parmetros esq e dir indicam
qual subarranjo de a[] queremos particionar. Os parmetros i e j so passados por referncia.
Eles pertencem originalmente funo chamadora do quicksort. Ao fim do algoritmo, estas
referncias i e j diro funo chamadora quais so os sub-arranjos particionados. Todo o
arranjo a[] tambm enviado funo. Como sabemos, arranjos so endereos na memria e
por isto so apenas enviados por referncia.
Na linha 2, criamos ento a varivel x, para guardar o elemento piv, e uma varivel
temporria temp para fazer trocas. Nas linhas 3 e 4, os ndices i e j so inicializados nos
extremos do arranjo a ser particionado. O elemento do meio ento escolhido como piv na
linha 5. De acordo com a estratgia, outro piv poderia ter sido escolhido.
Neste exemplo, particionaremos todo um arranjo de a[0] a a[7].
particionar(0, 7, &i, &j, a)
a 7 5 3 4 6 2 9 8 i 0 j 7
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[i] a[(i+j)/2] a[j]
x 4 temp
Neste grande lao entre as linhas 6 e 19, vamos fazer as trocas enquanto os ndices i e j no
tenham se cruzado. Nas linha 7 a 9, deslocamos o ndice i at encontrar o primeiro elemento
a[i] maior ou igual ao x. Nas linhas 10 a 12, deslocamos o ndice j at encontrar o primeiro
elemento a[j] menor ou igual a x.
a 7 5 3 4 6 2 9 8 i 0 j 5
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[i] a[j]
x 4 temp
Na linha 13, como nesse deslocamento os ndices no se cruzaram, as linhas 14 a 16, trocam
a[i] com a[j]. Na linha 17, deslocamos i e j em mais uma posio.
a 2 5 3 4 6 7 9 8 i 1 j 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[i] a[j]
x 4 temp 7
Todo o lao externo se repete enquanto os ndices no se cruzarem, encontramos os elementos

trocados (linhas 7 a 12), trocamos os elementos (linhas 14 a 16) e deslocamos ento, os ndices i
e j (linhas 17).
a 2 5 3 4 6 7 9 8 i 2 j 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[j]
a[i]
x 4 temp 5
Os ndices i e j esto na mesma posio mas ainda no se cruzaram. Nas linhas 7 a 9, o

primeiro a[i] maior ou igual a x a[3]. Nas linhas 10 a 12, o elemento a[j] j menor ou
igual a x. Como os ndices j se cruzaram, a condio da linha 13 no atendida e a troca no
feita.
a 2 5 3 4 6 7 9 8 i 3 j 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[j] a[i]
x 4 temp 5
Na linha 19, a segunda constatao de que os ndices j se cruzaram encerra a funo. Como
resultado, temos dois subarranjos. Um de a[0] at a[2] (ou a[esq] a a[j]) e outro de a[3] at
a[7] (a[i] a a[dir]).
Como i e j foram passados por referncia, a funo chamadora tem acesso aos valores
calculados de i e j.
Algoritmo de ordenao
Tendo pronta a funo para o processo de partio, o algoritmo de ordenao do quicksort se

torna conceitualmente muito simples.
1 void ordenar ( int esq , int dir , int a []) {

2 int i , j ;
3 particionar ( esq , dir , i , j , a );
4 if ( esq < j )
5 ordenar ( esq , j , a );
6 if ( i < dir )
7 ordenar (i , dir , a );
8 }
No prottipo da funo, da linha 1, esta funo ordena o arranjo a[] entre as posies esq
e dir. Para ordenar todo arranjo, chamamos: ordenar(0, 7, a). Na linha 2, criamos ento
os ndices i e j, que indicaro quais so os sub-arranjos aps a partio.
ordenar(0, 7, a)
a 7 5 3 4 6 2 9 8 i j
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[8]
esq 0 dir 7
Na linha 3 particionamos o arranjo entre as posies a[esq] e a[dir]. Os ndices i e j

indicam onde termina o primeiro sub-arranjo e onde comea o segundo.
ordenar(0, 7, a)
a 2 4 3 5 6 7 9 8 i 3 j 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[j] a[i]
Se o valor de j atingir o valor de esq, como testado na linha 4, o sub-arranjo tem apenas
um elemento e no precisa ser ordenado. Como o sub-arranjo de a[0] a a[2] tem mais de 1
elemento, usamos a prpria funo quicksort(0, 2, a) para orden-lo. A funo chamadora
vai para a pilha de funes e executamos a funo que ordenar a[] das posies 0 a 2. Os
ndices so criados e o sub-arranjo particionado.
ordenar(0, 2, a)
a 2 3 4 5 6 7 9 8 i 2 j 1
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 2
a[j] a[i]
Na linha 5, esta funo jogada na pilha e chamamos a funo de ordenao para o subarranjo
de a[esq] at a[j]. Os ndices so criados e o sub-arranjo particionado. Como o subarranjo
da esquerda no tem nenhum elemento, no executamos esta ordenao. E como o subarranjo da
direita tem tambm apenas 1 elemento, damos este sub-arranjo como ordenado. Ao fim desta
funo, temos o sub-arranjo de 0 at 1 ordenado e voltaremos a com a funo do topo da pilha.
ordenar(0, 1, a)
a 2 3 4 5 6 7 9 8 i 1 j -1
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 1
a[j] a[i]
O prximo comando desta funo ordena(0, 2, a) seria ordenar o sub-arranjo da direita,

mas isto no necessrio pois este sub-arranjo tem apenas 1 elemento. Assim, encerramos a
funo pois sabemos que os elementos entre a[0] e a[2] esto ordenados.
ordenar(0, 2, a)
a 2 3 4 5 6 7 9 8 i 2 j 1
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 2
a[j] a[i]
Voltamos para a funo ordena(0, 7, a) do topo da pilha. Esta funo, na linha 7, chama
ento a ordenao dos elementos de a[3] at a[7].
ordenar(0, 7, a)
a 2 3 4 5 6 7 9 8 i 3 j 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[j] a[i]
Criamos os ndices e particionamos este subarranjo na linha 3 da funo ordena(3, 7, a).

Entre os subarranjos de a[3] at a[4] e de a[6] at a[7] a funo de partio deixou isolado o
elemento a[5], que por estar sozinho, est tambm, por definio, ordenado.
ordenar(3, 7, a)
a 2 3 4 5 6 7 9 8 i 6 j 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[j] a[i]
Com uma chamada recursiva, ordenamos a[3] e a[4]. Criamos os ndices e particionamos.
Como nenhum dos subarranjos tm mais de um elemento, damos todos os elementos esto
ordenados. A funo que sai da pilha ainda precisa ordenar os elementos de a[6] at a[7]. Esta
funo tambm leva a dois subarranjos de tamanho 1, que por isto j esto ordenados, que por
isso j esto ordenados. Sendo assim, a funo corrente sai da pilha.
ordenar(3, 7, a)
a 2 3 4 5 6 7 8 9 i 6 j 4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 3 dir 7
a[j] a[i]
A funo original tambm sai da pilha, finalizando o mtodo com o arranjo original ordenado.
ordenar(0, 7, a)
a 2 3 4 5 6 7 8 9 i 3 j 2
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esq 0 dir 7
a[j] a[i]
Um inconveniente deste mtodo que precisamos passar para a funo trs parmetros
quando queremos ordenar todo o arranjo. Para no precisamos fazer isto, criamos um mtodo
auxiliar que chamado para ordenar todo o arranjo, iniciando de a[0].
1 void quicksort ( int a [] , int n ) {
2 ordenar (0 , n -1 , a );
3 }
Deste modo, mantemos o padro com os outros mtodos de ordenao.
Anlise
O quicksort tambm um tpico exemplo de algoritmo O(n log n), ou loglinear. Algoritmos
tpicos desta classe so os que dividem um problema em dois problemas menores e depois os
juntam fazendo uma operao em cada um dos elementos.
Anlise do piv
A escolha do piv um fator determinante no desempenho do algoritmo pois dependemos dele
para realmente dividir o arranjo em dois subarranjos de tamanho similar. Imagine um algoritmo
onde o piv escolhido sempre o menor elemento do conjunto de n elementos.
a 7 5 3 4 6 2 9 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
Ao dividir o arranjo em dois arranjos, teremos apenas 1 elemento no subarranjo da esquerda

e teremos que ordenar o subarranjo da direita que ainda tem n 1 elementos.
a 2 5 3 4 6 7 9 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
Se em todos os passos escolhermos o pior piv, no conseguiremos dividir o problema pela

metade a cada passo.
a 2 3 5 4 6 7 9 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
Em 2 dois passos de partio ordenamos apenas 2 elementos.
a 2 3 4 5 6 7 9 8
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
Apesar de ser uma situao muito rara, com a pior escolha de piv a cada passo, precisaramos
de n passos de partio para ordenar todo o arranjo. Como a cada passo estamos achando o
menor elemento do arranjo e o colocando em sua posio correta, este pior caso do quicksort
equivale exatamente ordenao por seleo, que tem custo O(n2 ).
Algumas estratgias podem ser utilizadas para se escolher um melhor piv, melhorando a
eficincia do algoritmo e deixando o pior caso ainda menos provvel.
O piv timo para um passo de repartio seria a mediana dos valores no arranjo. Um
piv igual mediana dividiria sempre o arranjo em dois subarranjos de tamanho idntico. Porm,
obter a mediana de um arranjo desordenado seria um processo caro (mais especificamente O(n)).
Escolher a cada passo um elemento aleatrio do arranjo ou escolher trs elementos aleatrios
do arranjo e usar a mediana dos trs como piv so exemplos de estratgias comuns para se obter
melhores pivs.
Anlise geral
O quicksort um mtodo muito eficiente para ordenar dados. Devido pilha de funes
precisa de apenas um espao extra muito pequeno, que O(log n). Em termos prticos, este
custo de memria usualmente considerado muito prximo de O(1).
O algoritmo requer apenas O(n log n) comparaes em seu caso mdio. Apesar da mesma
ordem de complexidade mdia, usualmente mais rpido que o Merge sort no caso mdio.
O quicksort tem um pior caso O(n2 ) quando o pior piv possvel sempre selecionado. A
probabilidade de ocorrncia deste pior caso extremamente baixa e no chega a alterar o caso
mdio. Contudo, considerar este pior caso pode ser um fator importante em aplicaes crticas,
mesmo que com uma baixa probabilidade.
O quicksort tambm no um algoritmo estvel pois as trocas na fase de partio no
consideram a ordem relativa dos elementos.
Na Tabela 16.4 temos um resumo do custo do quicksort em seus principais casos. Apesar de
ter um pior caso O(n log n), o algoritmo tem custo O(n log n) no caso mdio e no melhor caso.
Caso Descrio Custo

Pior caso piv sempre maior ou menor elemento O(n2 )
Caso mdio piv aleatrio O(n log n)
Melhor caso piv sempre elemento mediano O(n log n)
Tabela 16.4: Custo do algoritmo quicksort em suas situaes mais comuns
16.3.3 Exerccios
Veja que inclumos as bibliotecas stdlib.h e time.h neste cdigo. Elas permitem
gerao de nmeros aleatrios e medir tempo.
Veja que criamos um arranjo dinamicamente com o tamanho pedido. (new int[n])
Veja que a funo rand() gera nmeros aleatrios que so inseridos no arranjo.
Veja que temos algumas funes que no so utilizadas ainda.
2 // Gera o de n meros aleat rios
3 # include < stdlib .h >
4 // Fun es relacionadas a tempo
5 # include < time .h >
6 # include < chrono >
7
8 void intercala ( int a [] , int n ) ;
9 void particionar ( int esq , int dir , int &i , int &j , int a [])
;
10
12
13 int main () {
14 // gerador de n meros aleat rios
15 srand ( time ( NULL ) ) ;
16 // tamanho do arranjo
17 int n ;
19 cin >> n ;
20 // ponteiro para o arranjo na mem ria
21 int * v ;
22 v = new int [ n ];
23
24 for ( int i =0; i < n ; ++ i ) {
25 // numero entre 1 e n *3
26 v [ i ] = rand () % ( n *3) + 1;
27 }
28
29 for ( int k =0; k < n ; ++ k ) {
30 cout << v [ k ] << " \ t " ;
31 }
32 cout << " <- Desordenado " << endl ;
33
34 // Come a a medir tempo
35 chrono :: high_resolution_clock :: time_point inicio ;
36 inicio = chrono :: high_resolution_clock :: now () ;
37
38 // Chame a sua fun o de ordena o aqui
39 // ordena (v , n ) ;
40
41 // Termina de medir tempo
42 chrono :: duration < double > duracao ;
43 duracao = chrono :: duration_cast < chrono :: duration < double
> >( chrono :: high_resolution_clock :: now () - inicio ) ;
44
45 cout << " Ordenar o arranjo demorou " << duracao . count ()
<< " segundos " << endl ;
46
47 for ( int k =0; k < n ; ++ k ) {
48 cout << v [ k ] << " \ t " ;
49 }
50 cout << " <- Ordenado " << endl ;
51
52 return 0;
53 }
54
55 void intercala ( int a [] , int n )
56 {
57 int * tmp = new int [ n ];
58 int meio = n / 2;
59 int i , j , k ;
60 i = 0;
61 j = meio ;
62 k = 0;
63 // Enquanto os ndices i e j n o tenham chegado ao
fim de seus arranjos
64 while ( i < meio && j < n ) {
65 // colocamos o menor item entre a [ i ] e a [ j ]
no arranjo tempor rio
66 if ( a [ i ] < a [ j ]) {
67 tmp [ k ] = a [ i ];
68 ++ i ;
69 } else {
70 tmp [ k ] = a [ j ];
71 ++ j ;
72 }
73 ++ k ;
74 }
75 // se o ndice i chegou ao fim de seu arranjo
primeiro
76 if ( i == meio ) {
77 // os outros elementos do segundo arranjo v
o para o arranjo tempor rio
78 while ( j < n ) {
79 tmp [ k ] = a [ j ];
80 ++ j ;
81 ++ k ;
82 }
83 // se foi o ndice j que chegou ao fim de
seu arranjo primeiro
84 } else {
85 // os outros elementos do primeiro arranjo
v o para o arranjo tempor rio
86 while ( i < meio ) {
87 tmp [ k ] = a [ i ];
88 ++ i ;
89 ++ k ;
90 }
91 }
92 // neste ponto , o arranjo tempor rio tem todos os
elementos intercalados
93 // estes elementos s o copiados de volta para o
arranjo int a []
94 for ( i = 0; i < n ; ++ i ) {
95 a [ i ] = tmp [ i ];
96 }
97 // o arranjo tempor rio pode ent o ser desalocado
da mem ria
98 delete [] tmp ;
99 }
100
101 void particionar ( int esq , int dir , int &i , int &j , int a [])
{
102 int x , temp ;
103 i = esq ;
104 j = dir ;
105 x = a [( i + j ) / 2];
106 do
107 {
108 while ( x > a [ i ]) {
109 ++ i ;
110 }
111 while ( x < a [ j ]) {
112 --j ;
113 }
114 if ( i <= j ) {
115 temp = a [ i ];
116 a [ i ] = a [ j ];
117 a [ j ] = temp ;
118 ++ i ;
119 --j ;
120 }
121 } while ( i <= j ) ;
122 }

Exerccio 16.8 Veja a funo intercala:

Ela recebe um arranjo que comea no endereo a e tem tamanho n
Se a primeira metade do arranjo (de a[0] at a[n/2]) e a segunda metade (de
a[n/2+1] at a[n-1]) estiverem ordenadas, a funo faz a intercalao dos dois
e deixa o arranjo inteiro ordenado.
Utilize a funo para fazer uma funo que ordene um arranjo com o merge sort.
Exerccio 16.9 Veja a funo particionar:

Ela recebe um arranjo e particiona os elementos entre a[esq] e a[dir]
Aps fazer o particionamento ela guarda as posies finais nos elementos i e j, que
so passados por referncia
O particionamento faz com que os elementos menores fiquem entre a[esq] e a[j].
Os elementos maiores ficam entre a[i] e a[dir].
Utilize esta funo para fazer uma funo que ordena um arranjo com o quicksort.
Exerccio 16.10 Altere o cdigo de modo que as duas ordenaes sejam usadas e compare o
tempo entre as duas.
Exerccio 16.11 Coloque o cdigo dentro de um for.

Faa com que neste for, a varivel contadora seja utilizada para testar os algoritmos em
arranjos de vrios tamanhos
Altere o cdigo de modo que ele imprima apenas o tamanho do arranjo, o tempo com
uma ordenao, e o tempo com a outra
Qual a relao entre os algoritmos e o tamanho do arranjo?
No geral, qual a relao entre os dois mtodos de ordenao?

16.4 Comparando algoritmos de ordenao

Neste captulo apresentamos dois algoritmos simples e dois algoritmos eficientes para orde-
nao de arranjos. Na Tabela 16.5 temos uma comparao do comportamento deste algoritmos.
Algoritmos simples tm um custo mdio O(n2 ) enquanto algoritmos eficientes tm um custo
O(n log n). Existem, porm, vantagens e desvantagens em relao a estes algoritmos.
Algoritmo
Simples Eficiente
Seleo Insero Merge sort Quicksort
Comparaes
Caso mdio O(n2 ) O(n2 ) O(n log n) O(n log n)
Pior caso O(n2 ) O(n2 ) O(n log n) O(n2 )
Melhor caso O(n2 ) O(n) O(n log n) O(n log n)
Movimentaes
Caso mdio O(n) O(n2 ) O(n log n) O(n log n)
Pior caso O(n) O(n2 ) O(n log n) O(n log n)
Melhor caso O(n) O(n) O(n log n) O(n log n)
Memria
Caso mdio O(1) O(1) O(n) O(log n)
Pior caso O(1) O(1) O(n) O(n)
Melhor caso O(1) O(1) O(n) O(log n)
Caractersticas
Estabilidade No Sim Sim No
Adaptabilidade No Sim No Sim
Tabela 16.5: Comparao de custo em termos de nmero de comparaes para algoritmos

de ordenao. Os algoritmos simples tm um custo mdio O(n2 ) enquanto algoritmos mais
eficientes tm custo mdio O(n log n).
Entre os mtodos eficientes, veremos que o quicksort ainda mais rpido na mdia do que o
mergesort, apesar de terem mesma ordem de grandeza O(n log n).
Se os elementos j estiverem ordenados, a ordenao por insero sempre o mtodo mais
rpido. Este melhor caso da insero, porm, pouco provvel na maioria das aplicaes.
Contudo, a ordenao por insero interessante para se adicionar alguns elementos a um
arranjo j ordenado. Assim, estaremos prximos de seu melhor caso.
Apesar de ter a mesma ordem de grandeza O(n2 ) da ordenao por seleo, a ordenao
por insero a mais lenta para arranjos em ordem decrescente. Mesmo assim, pode continuar
melhor que a ordenao por seleo. Ainda apesar da mesma ordem de grandeza O(n2 ) no caso
16.4 Comparando algoritmos de ordenao 263
mdio, a ordenao por insero tende a ser melhor que a ordenao por seleo no caso mdio
com arranjos aleatrios.
Nos casos gerais, a insero um mtodo interessante apenas para arranjos bastante pequenos,
com menos de 20 elementos.
Se os registros so grandes, as movimentaes se tornam caras e a ordenao por seleo se
torna interessante por fazer apenas O(n) movimentaes, caso no haja tantos elementos. Porm,
outra maneira de se evitar movimentos usar ordenao indireta, ou seja, ordenamos ponteiros
para elementos e s fazemos O(n) movimentaes no final. Esta estratgia, porm, utiliza uma
memria extra O(n) para armazenar estes ponteiros.
No caso mdio, quicksort a melhor opo para a maioria da situaes. Apesar de no
geral ser o melhor mtodo entre os apresentados, ele no garante estabilidade. Suas chamadas
recursivas tambm demandam um pouco de memria extra.
Apesar de haver um pior caso no quicksort, sua ocorrncia quase impossvel para qualquer
estratgia razovel de seleo de pivs. Quando os arranjos j esto quase ordenados, usar o
elemento do meio como piv melhora muito o desempenho do algoritmo. Porm, nem sempre
usar o piv do meio uma boa estratgia.
Os mtodos de insero e quicksort podem ser combinados. A insero pode ordenar
subarranjos pequenos do quicksort, o que costuma melhorar muito seu desempenho mdio.
A Figura 16.17 apresenta o tempo gasto por cada um dos quatro algoritmos apresentados
para ordenar arranjos de diferentes tamanhos.
4
x 10
5
Seleo Seleo
Insero 4.5 Insero
Merge sort Merge sort
Quicksort Quicksort
4
3.5
2
Tempo (segundos)
Tempo (segundos)
2.5
1
1.5
0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.17: Tempo necessrio pelos algoritmos simples e eficientes para se ordenar um arranjo
com ordem inicial aleatria (caso mdio).
O tempo gasto pela ordenao por seleo to maior que difcil distinguir a diferena
de tempo entre os outros algoritmos para arranjos grandes. Assim, a Figura 16.18 apresenta
o tempo gasto pelos mtodos eficientes de ordenao em relao ao mtodo de ordenao por
insero. Mesmo que no consideremos a ordenao por seleo, h uma grande diferena entre
a ordenao por insero e os mtodos eficientes de ordenao. Para arranjos onde n < 800,
porm, a ordenao por insero pode ser mais eficiente que o merge sort. Para arranjos onde
n < 20, o custo da ordenao por insero pode at se confundir com o custo de um quicksort.
Como esperado, os mtodos simples de ordenao so muito mais lentos. A Figura 16.22
apresenta a proporo de custo entre todos os algoritmos. O algoritmo de ordenao por seleo
chega a ser at 700 vezes mais lento que algoritmos eficientes em arranjos grandes. Esta diferena
se tornaria ainda maior a medida que aumentamos o tamanho dos arranjos.
5
x 10
7 0.4
Insero Insero
0.35
6 Quicksort Quicksort
0.3
5
0.25
Tempo (segundos)
Tempo (segundos)
4
0.2
3
0.15
2
0.1
1
0.05
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.18: Tempo necessrio pelos algoritmos eficientes e pela ordenao por insero para
se ordenar um arranjo com ordem inicial aleatria (caso mdio).
9 800
Seleo Seleo
Insero Insero
8 700
Quicksort Quicksort
7
600
Tempo (em proporo ao Quicksort)
6
500
5
400
4
300
3
200
2
1 100
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.19: Proporo do tempo necessrio para se ordenar um arranjo com ordem inicial
aleatria (caso mdio).
A Figura 16.20 apresenta a proporo de custo entre os algoritmos eficientes e a ordenao por
insero. Mesmo o algoritmo de ordenao por insero chega a ser at 55 vezes mais lento que
algoritmos eficientes em arranjos grandes. Quanto maior o valor de n, piores sero os mtodos
O(n2 ) (de complexidade quadrtica) em relao aos mtodos O(n log n) (de complexidade
loglinear).
Como sabemos logicamente que os algoritmos O(n2 ) tero pior desempenho que os algorit-
mos O(n log n), a Figura 16.21 apresenta uma comparao de tempo entre os algoritmos merge
sort e quicksort. Em comparao direta entre os mtodos, o quicksort usualmente mais eficiente
que o merge sort para arranjos aleatrios.
A Figura 16.22 apresenta a proporo de tempo gasto entre os mtodos eficientes de ordena-
o. Vemos como a proporo de eficincia entre os dois mtodos se mantm constante para
diferentes tamanhos arranjo, j que os dois mtodos so O(n log n) e tm uma funo de custo
que cresce na mesma ordem.
16.5 Concluso 265
4 60
Insero
Merge sort Insero
Quicksort Merge sort
3.5
Quicksort
50

40
2.5
2 30
1.5
20
10
0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 16.20: Proporo de tempo necessrio pelos algoritmos eficientes e pela ordenao por
insero para se ordenar um arranjo com ordem inicial aleatria (caso mdio).
5
x 10
7 0.012

Quicksort Quicksort
6
0.01
5
0.008
Tempo (segundos)
Tempo (segundos)
0.006
0.004
2
0.002
1
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
mdio).
16.5 Concluso
Os mtodos de ordenao mostram como possvel obter variados tipos de vantagens e

desvantagens entre algoritmos para a mesma classe de problemas, mesmo que este problema seja
simples. Mesmo com o limite inferior de O(n log n), h vrios fatores a se considerar em cada
algoritmo como pior caso, caso mdio, estabilidade, adaptabilidade, memria extra e operaes
de atribuio.
Apesar dessa introduo ao tpico de ordenao ter sido limitada, as comparaes entre
algoritmos mostram a importncia de conceitos como: notao O, diviso e conquista, estruturas
de dados, anlise de melhor caso, pior caso e caso mdio, e, por fim, conflito entre tempo e
memria. Todas estas lies so fundamentais para quaisquer outros algoritmos.
4 4
Quicksort Quicksort
3.5 3.5
3 3

2.5 2.5
2 2
1.5 1.5
1 1
0.5 0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
mdio).
16.6 Outros algoritmos de ordenao

Alm dos mtodos apresentados aqui, existem vrios outros mtodos de ordenao, cada um com
suas vantagens e desvantagens. Listamos aqui alguns dos algoritmos mais famosos de ordenao:
Heapsort Melhora sobre ordenao por seleo com estruturas de dados mais eficientes. No
algoritmo de ordenao por seleo, o menor elemento do arranjo selecionado a cada
passo. No heapsort, uma estrutura chamada heap utilizada para que este menor elemento
seja encontrado de maneira mais eficiente a cada passo.
Introsort Hbrido entre quicksort e Heapsort. O quicksort utilizado at que o certo nvel seja
atingido na pilha de funes chamadas recursivamente. A partir deste ponto, o heapsort
ordena os subarranjos. A combinao faz com que no exista mais o pior caso O(n2 )
do quicksort quando um piv ruim escolhido repetidas vezes. Este pior caso, quando
se comparam os algoritmos, uma das poucas desvantagens do quicksort. Por isto, tem
sido um dos algoritmos mais utilizados atualmente para funes gerais de ordenao de
arranjos.
In-place merge sort Variao do merge sort onde no h o gasto extra de memria O(n). Isto
feito atravs de um processo mais complexo de intercalao de elementos. Isso, porm,
leva o algoritmo a ter um custo computacional ainda mais alto. Um motivo para utilizar o
merge sort mesmo com seu custo mais alto em relao a outros algoritmos eficientes que
ele tem a capacidade de fazer uma ordenao estvel.
Bubble sort Famosos mtodo de implementao simples. O bubble sort, ou ordenao por
bolha, muito apresentado em livros didticos junto aos mtodos de ordenao por seleo
e insero como mtodos simples, porm pouco eficientes, de ordenao. O mtodo
simplesmente percorre os elementos vrias vezes fazendo com que elementos subjacentes
sejam trocados caso estejam em posio relativa incorreta. Assim como a ordenao por
insero, este mtodo tem custo O(n2 ) no caso mdio e pior caso e, no melhor caso, o
mtodo tem custo O(n).
Shellsort Generalizao da ordenao por insero muito apresentada em livros didticos.
Subarranjos com elementos a uma distncia grande entre si so ordenados primeiro.
A distncia entre os elementos ordenados reduzida a cada passo at que estejamos
ordenando os elementos com distncia 1 entre si. A ordenao por insero ento um
shellsort onde elementos com distncia 1 entre si j esto sendo ordenados no primeiro
16.6 Outros algoritmos de ordenao 267
passo. A complexidade mdia do shellsort depende da sequncia de distncias consideradas

mas, para todas as sequncias possveis, ele tem um pior caso O(n2 ) e um melhor caso
O(n log2 n).
Todos os mtodos apresentados neste captulo so chamados mtodos de ordenao por
comparao. Isto porque os elementos so comparados e movimentados at que terminem em
suas posies corretas. Os mtodos mais eficientes por comparao tm custo O(n log n).
Alm dos mtodos por comparao, existem os mtodos de ordenao por contagem. Nestes
mtodos contamos o nmero de ocorrncias de cada elemento em um arranjo secundrio e reco-
locamos os elementos no arranjo original. A ordenao por contagem simples nos possibilita
ordenar um arranjo com custo O(n + r), onde r a faixa de valores possvel para os elementos
do arranjo.
Entre os mtodos de ordenao de contagem, o radix sort utiliza a ordenao por contagem
para cada casa dgito de um elemento. Com uma ordenao estvel, cada dgito pode ser
ordenado separadamente com um custo O(n). Assim, esta um estratgia de ordenao com
custo O(nk) no caso mdio, onde k o nmero de dgitos dos elementos. medida que k < log n,
o radix sort se torna mais eficiente que os mtodos de ordenao por comparao.
III
Estruturas de Dados
17 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . 271
18 Containers Sequenciais . . . . . . . . . . . . . 273
19 Percorrendo containers . . . . . . . . . . . . . 285
20 Anlise dos Containers Sequenciais . 297
21 Containers Associativos e Conjuntos 305
22 Adaptadores de Container . . . . . . . . . 333
23 Algoritmos da STL . . . . . . . . . . . . . . . . . . . 345

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Templates
0
17.
1 0 1
0
1
0
0 0
1
110 01
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 01 0 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
So comuns situaes em que operaes muito parecidas podem ser executadas em diferentes
tipos de dados. Isto especialmente verdade entre os tipos de dados aritmticos. Por exemplo, o
algoritmo para encontrar o mximo ou mnimo em um conjunto de dados do tipo int muito
similar ao algoritmo para os tipos de dado double, short, float ou long. Considere o cdigo
abaixo que encontra o maior elemento entre 3 nmeros inteiros:
1 int maximo ( int a , int b , int c ){

2 int max = a ;
3 if ( b > max ){
4 max = b ;
5 }
6 if ( c > max ){
7 max = c ;
8 }
9 return max ;
10 }
Veja agora o cdigo que faz o mesmo para dados do tipo double.
1 double maximo ( double a , double b , double c ){

2 double max = a ;
3 if ( b > max ){
4 max = b ;
5 }
6 if ( c > max ){
7 max = c ;
8 }
9 return max ;
10 }
272 Captulo 17. Templates
Com exceo do tipo de dado, os cdigos so idnticos. No difcil perceber que o

mesmo cdigo funcionaria para qualquer outro tipo de dado, como float ou at mesmo char.
Precisaramos apenas alterar o tipo. J vimos neste curso vrios algoritmos que poderiam ser
generalizados para qualquer tipo de dado. Os algoritmos de ordenao, por exemplo, so os
mesmos para qualquer tipo de dado.
Em C++, os templates nos permitem definir uma funo que funciona para mais de um tipo
de dado como no exemplo abaixo:
1 template < class T >
2 T maximo ( T a , T b , T c ){
3 T max = a ;
4 if ( b > max ){
5 max = b ;
6 }
7 if ( c > max ){
8 max = c ;
9 }
10 return max ;
11 }
Definir um template equivale a ter definido a funo para qualquer tipo de dado possvel.
Por exemplo, se a funo chamadora tem um comando maximo(4,2,6), o compilador gera
uma verso da funo maximo que aceita dados do tipo int. Se a funo chamadora tem um
comando maximo(4.4,2.4,6.2), o compilador gera uma verso da funo maximo que aceita
dados do tipo double. Isso feito substituindo-se o tipo de dado do template chamado de T com
um tipo de dado compatvel com a funo que precisamos.
Os templates, assim, representam uma coleo de definies para qualquer tipo de dados.
Essas definies so geradas sob demanda pelo compilador de acordo com as chamadas de
funo que aparecem no cdigo. Deste modo, eles so um recurso poderoso de reutilizao de
cdigo em C++ pois, com eles, conseguimos fazer o que chamamos de programao genrica.
Retornaremos a este tpico mais vezes neste livro.
17.1 Standard Template Library

A contribuio mais relevante e mais representativa de programao genrica em C++ a
Standard Template Library (STL) ou Biblioteca Padro de Templates, em portugus. A STL
uma parte do padro C++ aprovada em 1997/1998 e estende o ncleo do C++ fornecendo
componentes gerais.
Como alguns exemplos, a STL fornece o tipo de dado string, diferentes estruturas para
armazenamento de dados, classes para entrada/sada e algoritmos utilizados frequentemente por
programadores. A Tabela 17.1 apresenta as trs partes lgicas que compem a STL.
Parte lgica Descrio

Containers Gerenciam colees de objetos
Iteradores Percorrem elementos das colees de objetos
Algoritmos Processam elementos da coleo
Tabela 17.1: Partes Lgicas da Standard Template Library
Para que os recursos sejam teis a programadores de maneira genrica, todos os recursos da
STL so baseados em templates. Neste Captulo, estudaremos todas as partes lgicas da STL.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 10
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 01 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 11
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Containers
0
18.
1 0 1
0 0 11
Sequenciais
0
0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
10
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
18.1 Containers
As estruturas de dados se referem a como armazenamos e organizamos dados de uma
aplicao. Elas so representadas com a STL atravs de containers. Como a analogia sugere,
dentro de um container, podemos guardar vrias variveis de qualquer tipo. Isto est representado
na Figura 18.1.
varivel3
varivel2
varivel4
varivel1
Container
varivel5
Figura 18.1: Os containers guardam dados utilizando diferentes estruturas de dados.
Porm, cada container tem suas prprias caractersticas pois utiliza internamente diferentes
estruturas de dados para guardar estas variveis. Ou seja, cada tipo de container possui uma
estratgia diferente para organizao interna de seus dados. Esta estratgia controlada pela
STL, de acordo com o tipo de containers.
Por isso, cada container possui vantagens e desvantagens em diferentes situaes. A Tabela
18.1 apresenta os dois tipos bsicos de containers.
Os containers so representados atravs de objetos que utilizam templates. Os templates, por
sua vez, permitem que o container seja utilizado em qualquer tipo de dado. Estudaremos objetos
274 Captulo 18. Containers Sequenciais
Containers Representa Caracterstica

Sequenciais Listas Cada elemento tem uma posio especfica
Associativos Conjuntos A posio interna de um elemento depende de seu valor
Tabela 18.1: Tipos Bsicos de Container
em um captulo futuro deste livro. A grosso modo, por ora, objetos so recursos similares aos
tipos de dados definidos com struct, que aprendemos na Seo 10. Porm, alm de ter suas
prprias variveis, os objetos possuem suas prprias funes.
Supondo um container chamado c, a Tabela 18.2 apresenta funes importantes que esto
disponveis em todos os containers. Algumas funes retornam dados lgicos, nmeros inteiros
ou iteradores. Os iteradores sero utilizados para acessar os elementos de um container, como
veremos mais adiante. Outras funes apenas alteram a estrutura do container, sem fazer retorno
algum.
Funo Retorna
c.empty() Se o container est vazio
c.size() Tamanho ou nmero de elementos
c.begin() Iterador para primeiro elemento
c.end() Iterador para fim do container
<, >, >=, <=, ==, != Operadores de comparao
c.rbegin() Iterador reverso para incio
c.rend() Iterador reverso para o fim
Funo Efeito
c.erase(i) Apaga o elemento i
c.clear() Limpa o container
c.swap(c2) Troca elementos com c2
Tabela 18.2: Funes-membro comuns aos containers. Algumas funes retornam valores e
outras alteram o container.
18.2 Containers sequenciais

Os containers sequenciais so aqueles utilizados para representar sequncias de elementos. Em
uma sequncia de elementos, cada elemento deve ter uma posio especfica. Estudaremos os
containers sequenciais vector, deque e list.
18.3 Vector
O vector talvez o container de sequncia mais utilizado. Esse container tem funes para
acessar, remover ou inserir elementos no fim da sequncia de elementos de maneira eficiente.
Para utilizarmos este container, necessria a incluso do cabealho <vector> no incio de
nosso programa.
18.3.1 Utilizao
Imagine a sequncia de elementos abaixo.
18.3 Vector 275
4 6 2 7
Imagine que o vector com esta sequncia se chama c. Novos elementos podem ser inseridos
ao final de c com a funo push_back.
1 c . push_back (5);
4 6 2 7 5 1 9
Elementos podem ser removidos do final de c com a funo pop_back.

1 c . pop_back ();
2 c . pop_back ();
4 6 2 7 5
O primeiro e ltimo elementos de c podem ser acessados com as funes front e back.
1 cout << c . front () << " " << c . back () << endl ;
4 6 2 7 5
4 5
18.3.2 Como funciona

Apesar de todas as simplificaes oferecidas pelos templates, os containers so complexos
internamente. Todo container precisa ser representado internamente atravs de recursos que
j conhecemos, como ponteiros e arranjos. Este recursos so organizados para formarem uma
estrutura de dados que organiza os elementos.
A estrutura exata para representar um container depende do compilador mas, de acordo com
o container, sabemos que h algumas estruturas bsicas utilizadas por todos os compiladores.
esta estrutura comum que precisamos conhecer para entender as vantagens e desvantagens de
cada container.
Com este comando, podemos criar um vector vazio.
1 vector < int > c ;
Internamente, o vector ter usualmente um ponteiro um dois nmeros inteiros, chamados
aqui de n, p e pn. Um nmero inteiro n guarda o nmero de elementos no container enquanto o
ponteiro pn aponta para um arranjo de elementos na memria. Note como o arranjo no est no
escopo do vector, pois ele alocado dinamicamente. O segundo nmero inteiro pn guarda o
tamanho deste arranjo.
vector<int> c;
n 0 p pn 4
Quando inserimos um elemento no fim do container, este inserido na posio n do arranjo

e n incrementado.
vector<int> c;
n 1 p pn 4
Como o arranjo j tem espao para mais que n elementos, mais elementos podem ser
inseridos sem necessidade de se alocar mais memria. Sempre que no precisarmos de mais
espao para um elemento, este pode ser inserido no arranjo com custo constante O(1). As
posies representadas em cinza no esto sendo utilizadas at o momento.
vector<int> c;
n 2 p pn 4
4 6
Eventualmente, o nmero de elementos ser igual ao tamanho do arranjo. Neste caso, no

podemos colocar mais elementos sem alocar mais memria.
18.3 Vector 277
vector<int> c;
n 4 p pn 4
4 6 2 7
Queremos agora inserir o elemento 5 ao container.

Como no h mais espao para elementos no arranjo, este procedimento ocorre em quatro
passos.
1) Alocamos espao para um arranjo com o dobro de elementos e fazemos um ponteiro
temporrio apontar para ele.
vector<int> c; c.push_back(5);
n 4 p pn 4 temp
4 6 2 7
2) Copiamos todos os elementos do arranjo apontado por p para o arranjo apontado por temp.
Naturalmente, para n elementos, este passo tem um custo O(n).
n 4 p pn 4 temp
4 6 2 7
4 6 2 7
3) Desalocamos a memria apontada por p e fazemos com que p aponte para o mesmo
arranjo de temp.
n 4 p pn 4 temp
4 6 2 7
4) Atualizamos o valor de pn, inserimos o valor 5 normalmente, com custo O(1), e incre-
mentamos n. O ponteiro temp deixa de existir por ter apenas escopo de funo.
vector<int> c;
n 5 p pn 8
4 6 2 7 5
Se considerarmos todos os passos, toda a operao de insero teve custo O(n) quando houve
necessidade de se alocar mais memria. Este custo, porm, se amortizado entre vrias inseres
tem um custo mdio de O(1). O custo mdio ocorre pois s fazemos uma alocao de custo O(n)
a cada n inseres de custo O(1). Por isto a alocao prvia de memria to importante.
Existe inclusive a funo capacity() que retorna quantos elementos ainda podem ser
colocados em um vector sem se alocar mais memria.
De maneira similar, a remoo de um elemento no fim da sequncia feita com um custo
constante O(1).
1 c . pop_back ();
vector<int> c;
n 4 p pn 8
4 6 2 7 5
Com custo O(1), a funo para remover o ltimo elemento do container realizada apenas
pela atualizao do valor de n, o fazendo indicar que apenas os 4 primeiros elementos devem ser
considerados.
18.4 Deque 279
18.4 Deque
O container deque uma abreviao para double ended queue (fila com duas pontas). um
container indicado para sequncias que crescem nas duas direes pois tem a capacidade de
insero rpida de elementos no incio e no final da sequncia. Para utilizarmos um deque,
necessrio incluir o cabealho <deque> no incio de nosso programa.
18.4.1 Utilizao
Imagine a sequncia de elementos abaixo.
4 6 2 7
Imagine que o deque que contm esta sequncia se chama c. Da mesma maneira que fizemos
com um vector, novos elementos podem ser inseridos ao final de um deque c com a funo
push_back.
4 6 2 7 5 1 9
Diferentemente de um vector, elementos podem ser removidos do incio de c com a funo

pop_front.
1 c . pop_front ();
2 c . pop_front ();
3 c . pop_front ();
7 5 1 9
Novos elementos podem ser inseridos eficientemente em deque no incio de c com a funo
push_front.
1 c . push_front (4);
1 6 4 7 5 1 9
Assim como em um vector, elementos podem ser removidos no fim do deque c com a
funo pop_back.
1 c . pop_back ();
2 c . pop_back ();
3 c . pop_back ();
1 6 4 7
O primeiro e ltimo elementos de c podem ser acessados com as funes front e back.
1 cout << c . front () << " " << c . back () << endl ;
1 6 4 7
1 7

Um deque utiliza uma estrutura de dados um pouco mais complexa que um vector. Para que
elementos do incio sejam removidos eficientemente, um deque utiliza uma estrutura de arranjo
diferente para no precisar deslocar os elementos.
Com este comando, podemos criar um deque vazio.
1 deque < int > c ;
Internamente, o deque tem um ponteiro um trs nmeros inteiros. Diferentemente de

vector, no temos mais o nmero n de elementos no container e sim dois elementos frente e
tras, que indicam onde comea e termina o deque.
deque<int> c;
frente 0 tras 0 p pn 4
p[frente]
p[tras]
Assim, como no vector, a insero de vrios elementos causa o aumento de memria

alocada no arranjo.
18.4 Deque 281
deque<int> c;
4 6 2 7 5
p[frente] p[tras]
Quando um elemento do incio removido, isto feito incrementando o valor de frente.

Os valores de frente e tras indicam que devemos considerar apenas valores entre p[frente] e
p[tras-1] como pertencentes ao container.
1 c . pop_front ();
deque<int> c;
4 6 2 7 5
p[frente] p[tras]
Quando muitos elementos so inseridos no incio do arranjo, uma estrutura toroidal utilizada
para representar os elementos do container.
deque<int> c;
3 6 2 7 5 9 8
p[tras] p[frente]
Pode parecer estranho que frente > tras, mas isto indica que os elementos do container
vo de p[6] at p[7] e depois continuam entre p[0] e p[4], formando uma estrutura circular.
18.5 List
O container list representa listas duplamente encadeadas. Assim como o deque, ele consegue
eficientemente inserir e remover elementos das primeiras posies com os mesmos comandos
(push_front, push_back, pop_front, pop_back). Assim, do ponto de vista de utilizao
destas funes, ele equivalente ao deque. Porm, sua estrutura de dados muito diferente, pois
no baseada em arranjos. Para utilizamos o list, precisamos incluir o cabealho <list> no
incio de nossos programas.

As listas so compostas de clulas que contm ponteiros e valores. Estas clulas so representadas
com definies do tipo struct. Cada clula aponta para uma clula similar, de modo que se
forme uma lista. Assim, quando um novo elemento inserido, alocado mais espao na memria
apenas para uma clula com este elemento.
Com este comando, podemos criar um list vazio chamado c.
1 list < int > c ;
Internamente, o list tem usualmente dois ponteiros (chamados aqui de frente e tras) e
um nmero inteiro para guardar o nmero de elementos no container (chamado aqui de n).
list<int> c;
frente tras n 0
Quando inserimos um elemento no container, uma estrutura chamada clula criada para
este elemento. Cada clula contm 2 ponteiros e um elemento.
int
*celula *celula
Os ponteiros apontam para outras clulas de modo que possamos formar uma lista de clulas.
Quando utilizamos o comando para inserir um elemento, o elemento inserido em uma
clula cujos ponteiros no so utilizados por enquanto. Esta clula criada em uma posio
qualquer disponvel na memria. Como esta a nica clula da lista, os ponteiros frente e
tras apontam para ela.
18.5 List 283
list<int> c;
frente tras n 1
Ao se inserir mais um elemento, criada para ele mais uma clula que entra na lista
encadeada.
list<int> c;
frente tras n 2
4 5
A memria alocada para esta clula est em um local qualquer da memria. Um ponteiro da
clula aponta para o ltimo elemento da lista e o ltimo elemento da lista aponta para a nova
clula. O ponteiro tras passa a apontar para a nova clula, n incrementado e o novo elemento
est inserido.
Podemos assim inserir vrios elementos com tempo O(1). Para cada nova insero alocada
uma clula em uma posio qualquer da memria.
list<int> c;
frente tras n 3
4 5 3
Para remover um elemento do incio ou do fim da sequncia, um processo muito similar

feito.
1 c . pop_front ();
list<int> c;
frente tras n 2
5 3
O ponteiro frente aponta para o prximo elemento e o anterior removido, com seus
ponteiros.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Percorrendo
0
19.
1 0 1
0 0 1
1
0
containers
0
0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
19.1 Subscritos
Assim como utilizamos os subscritos [ e ] para acessar posies de arranjos, podemos utilizar
subscritos para acessar elementos dos containers de sequncia. Porm, apenas os containers de
sequncia chamados de containers de acesso aleatrio tem este recurso. Da mesma maneira
que fazemos em arranjos, o subscrito [i] utilizado para acessar o (i + 1)-simo elemento do
container.
19.1.1 Vector
Neste exemplo utilizaremos subscritos para acessar elementos de um vector. Este cdigo utiliza
subscritos para imprimir os valores do container c.
2 # include < vector >
3
5
6 int main (){
8 for ( int i =1; i <6; i ++) {
9 c . push_back ( i );
10 }
11 for ( int i =0; i < c . size (); i ++) {
12 cout << c [ i ] << " " ;
13 }
14 cout << endl ;
15 }
Note na linha 2 que incluimos o cabealho vector. Nas linhas 7 a 10, criamos um vector
chamado c e inserimos em seu final os elementos 1, 2, 3, 4 e 5. Nas linhas 11 a 14, o subscrito
286 Captulo 19. Percorrendo containers
c[i] utilizado para imprimir os elementos de c.
1 2 3 4 5
Como funciona
Internamente, o i-simo elemento do vector pode ser acessado ao se acessar o i-simo elemento
do arranjo p que guarda seus elementos.
vector<int> c;
n 4 p pn 4
4 6 2 7
p[0] p[1] p[2] p[3]

c[0] c[1] c[2] c[3]
Assim, as posies de subscrito do arranjo apontado por p so as mesmas que devem ser
retornadas pelos subscritos do container c.
19.1.2 Deque
Este cdigo utiliza subscritos tambm para imprimir os valores no deque chamado c.
2 # include < deque >
3
5
6 int main ()
7 {
8 deque < float > c ;
9 for ( int i =1; i <6; i ++) {
10 c . push_front ( i *1.1);
11 }
12 for ( int i =0; i < c . size (); i ++) {
13 cout << c [ i ] << " " ;
14 }
15 cout << endl ;
16 }
Note na linha 2 como inclumos o cabealho <deque>. O bloco de cdigo nas linhas 8 a 11
cria um deque chamado c e insere em seu incio os elementos 1.1, 2.2, 3.3, 4.4 e 5.5. No
trecho de cdigo das linhas 12 a 15, o subscrito c[i] utilizado para imprimir os elementos de
c.
5.5 4.4 3.3 2.2 1.1

19.1 Subscritos 287
Como funciona
Internamente o i-simo elemento do deque pode ser acessado ao se acessar o i-simo elemento
do arranjo p aps o elemento p[frente]. Suponha o seguinte deque:
deque<int> c;
4 6 2 7 5
p[frente] p[tras]
Podemos converter assim a localizao dos elementos:
deque<int> c;
4 6 2 7 5
p[0] p[1] p[2] p[3] p[4] p[5] p[6] [7]

c[0] c[1] c[2] c[3]
Deste modo, a localizao das posies frente e tras devem ser consideradas ao se procurar
o i-simo elemento do deque c. Neste caso, a posio do i-simo elemento do container pode
ser encontrado na posio p[frente+i] do arranjo.
Quando ciclos ocorrem, uma operao de mdulo no valor encontrado necessria para
achar a posio correta. Considere o exemplo abaixo onde ocorrem um ciclo:
deque<int> c;
3 6 2 7 5 9 8
p[tras] p[frente]
Neste exemplo, veja os subscritos do arranjo e os subscritos do container neste caso.
deque<int> c;
3 6 2 7 5 9 8
p[0] p[1] p[2] p[3] p[4] p[5] p[6] [7]

c[2] c[3] c[4] c[5] c[6] c[0] c[1]
A posio do i-simo elemento do container pode ser encontrada na posio p[(frente+i)%pn]

do arranjo apontado por p.
19.1.3 List
J para o container list, no possvel encontrar diretamente o i-simo elemento da sequncia,
j que os elementos no so organizados em arranjos nesta estrutura. Apenas os containers
vector e deque so de acesso aleatrio, por serem baseadas em arranjos.
Vejamos um exemplo onde queremos acessar o terceiro elemento de um list.
list<int> c;
frente tras n 5
4 5 3 7 1
Em um arranjo, sabemos que o i-simo elemento est i posies de memria a frente do

primeiro elemento. Como os elementos do list c esto espalhados na memria com uma
estrutura baseada em ponteiros, no existe uma operao que calcule diretamente a posio do
i-simo elemento do container na memria. Com uma estrutura baseada em ponteiros, a nica
maneira de se encontrar o i-simo elemento de c analisando no primeiro elemento onde est o
segundo, no segundo onde est o terceiro, ..., no (i-1)-simo onde est o i-simo.
Ou seja, precisamos seguir os ponteiros i vezes para encontrar o elemento da posio i.
Assim, achar o i-simo elemento a partir do primeiro tem um custo O(i). Isto significa O(n)
no pior caso e caso mdio e O(1) no melhor caso, quando procuramos o primeiro ou o ltimo
elemento.
19.1.4 Anlise
Como vimos, os subscritos so utilizados para acessar diretamente o i-simo elemento do
container. Este na verdade um recurso que encontra o i-simo elemento do container no arranjo
19.2 Iteradores 289
alocado para guardar os elementos. Isto possvel apenas para os containers vector e deque,
que usam arranjos e por isso alocam os elementos em sequncia na memria. Estes containers
so chamados de containers de acesso aleatrio.
Cabe aqui uma comparao entre conteiners sequenciais e arranjos. Em C++, a utilizao de
subscritos muito til pois permite at que utilizemos um container de sequncia para substituir
arranjos. Esta uma prtica comum, especialmente com containers do tipo vector. Com esta
prtica ganhamos vrias vantagens em relao a arranjos:
Containers j controlam seus prprios tamanhos
Containers contm em si mesmos algoritmos eficientes para vrias tarefas
19.2 Iteradores
Como vimos, a opo de se acessar elementos de um container atravs do operador de subscrito
restrita apenas a containers de acesso aleatrio. Para conseguirmos acessar elementos de todos
os tipos de container, precisamos de iteradores.
Os iteradores so objetos que caminham (iteram) sobre elementos de containers. Eles
funcionam como um ponteiro especial para elementos de containers: enquanto um ponteiro
representa uma posio na memria, um iterador representa uma posio em um container. So
muito importantes pois permitem criar funes genricas para qualquer tipo de container.
Supondo um iterador chamado i, a Tabela 19.1 apresenta funes comuns a iteradores.
Funo Retorna
*i Retorna o elemento na posio do iterador
++i Avana o iterador para o prximo elemento
== Confere se dois iteradores apontam para mesma posio
!= Confere se dois iteradores apontam para posies diferentes
Tabela 19.1: Funes-membro comuns aos iteradores.
Os iteradores podem ser gerados atravs de funes de um container, como apresentado na

Figura 19.1. Suponha um container chamado c. O comando c.begin() retorna um iterador
para o primeiro elemento deste container c. O comando c.end() retorna um iterador para uma
posio aps o ltimo elemento do container c.
5 3 3 6 2 3 8 5 7
begin() end()
Figura 19.1: As funes begin() e end() geram iteradores a partir de containers.
19.2.1 Exemplo
Neste exemplo usamos um iterador para percorrer os elementos de um list.
2 # include < list >
3

5
6 int main (){
7 list < char > c ;
8 for ( char letra = a ; letra <= z ; letra ++) {
9 c . push_back ( letra );
10 }
11 list < char >:: iterator pos ;
12 for ( pos = c . begin (); pos != c . end (); ++ pos ){
13 cout << * pos << " " ;
14 }
15 cout << endl ;
16 }
Na linha 7, criamos um list que se chama c e guardar elementos do tipo char. Nas linhas 8
a 10, colocamos no container c todos os dados possveis do tipo char entre a e z.
c a b c d e f g h i j k l m n o p q r s t u v w x y z
Criamos agora, na linha 11, um iterador chamado pos. Repare que quando declaramos o tipo
de dado deste iterador, utilizamos list<char>::iterator para indicar que pos um iterador
para um list de dados do tipo char.
Na linha 12, quando dizemos que pos = c.begin(), inicializamos o for fazendo com que
pos seja um iterador apontando para o primeiro elemento de c. A condio de parada pos !=
c.end() que o iterador pos tenha chegado na posio c.end(), que uma posio aps o
ltimo elemento de c.
pos c.end()
Retornamos ento, na linha 13, o elemento na posio do iterador com *pos.
Independente do tipo de container, a condio de incremento ++pos faz com que pos aponte
para o prximo elemento do container.
pos c.end()
O elemento na posio do iterador impresso de novo na linha 13.

19.2 Iteradores 291
a b
O trecho completo de cdigo das linhas 12 a 14 faz com que consigamos imprimir todos os
elementos de c. Ao fim, pos finalmente chega posio c.end().
c.end()
pos
a b c d e f g h i j k l m n o p q r s t u v w x y z
Repare que, com os iteradores, conseguimos acessar os elementos de um list, que no

um container de acesso aleatrio.
19.2.2 Categorias de Iteradores

Cada container pode gerar um iterador de certa categoria. O container list contm iteradores
bidirecionais pois a partir de um elemento s temos acesso ao prximo elemento ou o elemento
anterior. Para o containers vector e deque, temos iteradores de acesso aleatrio pois a partir de
uma posio qualquer, basta uma operao aritmtica para encontrar qualquer outro elemento.
A Tabela 19.2 apresenta funes disponveis para iteradores de acordo com sua categoria.
19.2.3 Funes com iteradores

Insert - List
H ainda funes que pertencem aos containers porm dependem de iteradores como parmetro.
Uma funo dos containers de sequncia que precisa de um iterador a funo insert. Esta
funo insere um elemento em uma posio qualquer da sequncia. Para tal, a funo precisa de
um elemento e de um iterador para a posio onde queremos coloc-lo.
Considere a estrutura interna de um container do tipo list chamado c.
1 list < int > c ;
list<int> c;
frente tras n 2
4 3 7 2 5 7
Funo Retorna
Todos iteradores
*i Desreferencia
i = i2 Atribuio
i == i2 Compara igualdade de posio
i != i2 Compara desigualdade de posio
Iteradores unidirecionais
++i Pr-incrementa
i++ Ps-incrementa
Iteradores bidirecionais
-i Pr-decrementa
i- Ps-decrementa
Iteradores de acesso aleatrio
i += n Incrementa n posies
i -= n Decrementa n posies
i + n Aritmtica (soma) com iteradores
i - n Aritmtica (subtrao) com iteradores
i[i2] Desreferencia i2 posies aps *p
i < i2 Compara posio no container
i > i2 Compara posio no container
i <= i2 Compara posio no container
i >= i2 Compara posio no container
Tabela 19.2: Funes-membro de iteradores de acordo com suas categorias.
Considere tambm que geramos um iterador i apontando para a segunda posio de c.

1 list < int >:: iterator i ;
2 i = c . begin ();
3 ++ i ;
list<int> c;
frente tras n 2
4 3 7 2 5 7
Podemos chamar deste modo uma funo para inserir um elemento 11 na posio i do
container.
1 c . insert (i ,11);
19.2 Iteradores 293
list<int> c;
frente tras n 2
4 3 7 2 5 7
i
11
Ser alocada na memria uma nova clula para este elemento 11. A nova clula aponta
para a clula anterior da posio i e para a prpria clula da posio i. Alteramos ento os
ponteiros do elemento i e do elemento anterior a i.
Supondo que j temos um iterador para a posio que queremos, o nmero de operaes para
esta insero constante O(1). Esta exatamente a maior vantagem do container list. Fazer
com que o iterador chegue posio i, porm, pode ter custo O(n) pois um container do tipo
list no tem acesso aleatrio.
Insert - Vector
Vejamos agora a utilizao da funo insert em um vector. Considere agora a estrutura
interna da mesma sequncia sendo representada por um vector.
vector<int> c;
n 6 p pn 8
4 3 7 2 5 7
Considere tambm que geraremos um iterador i apontando para o segundo elemento da

sequncia.
1 vector < int >:: iterator i ;
2 i = c . begin ();
3 ++ i ;
vector<int> c;
n 6 p pn 8
4 3 7 2 5 7
A funo que insere o elemento 11 na posio i mais complicada para um vector. Temos
uma sequncia de passos:
1) A varivel n incrementada, abrindo espao para mais um elemento. Este processo tem
um custo constante O(1). Em algumas situaes, pode ser que um novo arranjo precise ser
alocado, levando a um custo O(n), como vimos na Seo 18.3.2.
vector<int> c;
n 7 p pn 8
4 3 7 2 5 7
2) Todos os elementos entre i e o penltimo elemento precisam ser deslocados para a

prxima posio do arranjo. Esta operao tem um custo O(n i). Se i for o ltimo elemento,
temos um melhor caso O(1). Se i for o primeiro elemento, temos um pior caso O(n). Se
consideramos que, no caso mdio, i tem a mesma probabilidade de estar em qualquer posio,
temos tambm um custo O(n) no caso mdio.
vector<int> c;
n 7 p pn 8
4 3 3 7 2 5 7
3) O elemento 11 pode ser inserido na posio i. Este passo tem apenas um custo O(1).
19.2 Iteradores 295
vector<int> c;
n 7 p pn 8
4 11 3 7 2 5 7
Devido a todas as movimentaes, esta operao completa de insero no meio da sequncia

tem um custo O(n).
Como vimos, a grande vantagem dos containers vector e deque vm do fato de eles
serem baseados em arranjos. Isso permite que os elementos fiquem em sequncia na memria
possibilitando assim acesso aleatrio aos elementos.
Curiosamente, a grande desvantagem destas estruturas tambm se deve ao fato de utilizarem
arranjos, pois todos os elementos precisam ser movidos para que um elemento seja inserido no
meio da sequncia.
Insert e Erase
De modo anlogo funo insert(i, elem), existe a funo erase(i), que remove do
container o elemento da posio i.
A funo insert pode tambm receber 2 iteradores em vez de um elemento para inserir
vrios elementos de uma vez. Neste caso, os elementos entre os dois iteradores em um segundo
container so inseridos no container.
A funo erase pode tambm receber 2 iteradores em vez de um para remover vrios
elementos de uma vez.
Funo construtura
Com iteradores, um container pode at mesmo j ser construdo com elementos de outro container
de outro tipo. No exemplo abaixo, j criamos o container c2 com uma cpia dos elementos do
container c1. Dizemos que esta a funo que constri c2.
1 vector < int > c2 ( c . begin () , c . end ());
Um container tambm pode ser construdo com os elementos de um arranjo, atravs de seus
endereos.
1 vector < int > c (a , a + n );
Funes genricas
Vimos no exemplo anterior a funo insert, que depende de iteradores para definir em qual
posio de um container ser inserido o elemento. Outra utilidade de iteradores possibilitar
funes genricas, que funcionem para qualquer tipo de container.
A funo abaixo imprime todos os elementos de um container:
1 template < typename T >
2 void imprime ( T const & x )
3 {
4 typename T :: const_iterator pos ;
5 typename T :: const_iterator end ( x . end ());

6 for ( pos = x . begin (); pos != end ; ++ pos ) {
7 cout << (* pos ) << " " ;
8 }
9 cout << endl ;
10 }
Como ela utiliza templates, ela pode ser utilizada com qualquer container.
Nesta funo, na linha 1, temos no template que o tipo de container ser referido como T.
Nas linhas 4 e 5, criamos um iterador pos que caminhar sobre os itens do container e um
iterador end que inicializado com a posio final do container chamado aqui de x.
Utilizamos entoo iterador, nas linhas 6 a 8, como em qualquer outro cdigo.
importante lembrar que algumas operaes no esto disponveis para todos os tipos de
iteradores. Apresentamos as categorias de iteradores na Seo 19.2.2. preciso tomar cuidado ao
tentar criar um cdigo genrico para qualquer tipo de container. O cdigo abaixo, por exemplo,
tem capacidade de percorrer os elementos de qualquer tipo de container.
2 cout << * pos << " " ;
3 }
J o cdigo abaixo no conseguir percorrer elementos de qualquer tipo de container pois o
operador < s est disponvel para iteradores de acesso aleatrio.
1 for ( pos = c . begin (); pos < c . end (); ++ pos ){
2 cout << * pos << " " ;
3 }
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Anlise
0
20.
1
00 1
0dos 011
1 Sequenciais
Containers
0
1 0
0
1
1101 1
0
0
0
110 0
1
0
0
000 0
0
1
1
0
0 0
00 1 00 0 0 0 01 0 01 00 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Vimos nas ltimas Sees trs tipos de containers sequenciais e como eles podem ser acessados
com iteradores. Podemos agora fazer uma breve comparao entre estas diferentes maneiras de
representar estruturas de dados.
20.1 Vector
Quando acaba a memria, um vector cria um novo arranjo dinamicamente e copia os elementos.
Isto tem custo O(n).
Em geral, tanto a insero quanto a remoo de elementos no fim da sequncia tem custo
O(1) em um vector. preciso saber que h um custo maior O(n) quando for necessrio alocar
memria para um novo arranjo. Porm, como esta alocao no frequente, no caso mdio, o
custo de se inserir um elemento continua O(1).
Por ter seus elementos organizados em uma arranjo (com elementos em sequncia na
memria), uma insero ou remoo no meio da sequncia tem custo O(n) pois elementos
precisam ser deslocados.
Por outro lado, uma consulta em qualquer posio de um vector tem custo O(1) pois eles
so containers de acesso aleatrio. Esta uma grande vantagem do vector.
Uma outra grande vantagem de um vector o baixo gasto de memria auxiliar para
gerenciar sua estrutura. Em um arranjo, no temos gasto extra algum com ponteiros.
Sua maior desvantagem o custo O(n) de se inserir um elemento no incio ou no meio da
sequncia.
20.2 Deque
A estrutura do deque permite que elementos sejam inseridos com baixo custo O(1) tanto no
incio quanto no fim do arranjo.
Alm desta nica diferena para o vector, por ser tambm baseado em arranjos, um deque
tem os mesmos resultados assintticos do vector para (i) insero e remoo no meio da sequncia
O(n), (ii) realocao de memria O(n) e (iii) acesso aleatrio a elementos O(1).
298 Captulo 20. Anlise dos Containers Sequenciais
Em relao ao list, o deque possui as mesmas vantagens e desvantagens do vector: (i)

baixo custo de memria extra O(1), (ii) acesso aleatrio aos elementos O(1) e (iii) alto custo
para insero ou remoo no meio da sequncia O(n).
Em relao ao vector, em termos assintticos, ele oferece a possibilidade de insero de
elementos no incio da sequncia em tempo O(1).
Em suma, alm das vantagens assintticas do vector relacionadas capacidade de acesso
aleatrio, um deque apresenta a possibilidade de insero ou remoo no incio da sequncia
em tempo O(1), o que levaria tempo O(n) para um vector. Deste modo, do ponto de vista
assinttico, pode parecer que no vantagem utilizar um vector em situao alguma.
Porm, nas operaes de acesso a elementos onde deque e vector gastam tempo constante
O(1), o tempo total gasto pelo deque sempre maior do que um vector. Isto ocorre porque um
deque precisa de operaes aritmticas de soma e resto para encontrar seus elementos enquanto
o vector pode procurar a posio diretamente no arranjo. Vimos isto na Seo 19.1, quando
analisamos a utilizao de subscritos em containers. Deste modo, a utilizao do deque s
recomendada se o recurso de insero e remoo eficientes no incio da sequncia for realmente
muito utilizado e importante.
20.3 List
A maior vantagem dos containers do tipo list a insero ou remoo de elementos em
qualquer posio com custo constante O(1), desde que tenhamos um iterador para esta posio.
No existe realocao de arranjos nestas estruturas.
Um grande desvantagem o alto gasto de memria extra O(n) nestas estruturas pois para
cada elemento so guardados dois ponteiros. Outra desvantagem que este container no oferece
acesso aleatrio a seus elementos e gerar um iterador para um elemento pode ter custo O(n).
20.4 Comparao
A Tabela 20.1 apresenta o custo das principais operaes utilizadas nas estruturas de dados
representadas pelos containers sequenciais.
Container Sequencial
vector deque list
Insero/Remoo
Incio O(n) O(1) O(1)
Meio O(n) O(n) O(1)
Fim O(1) O(1) O(1)
Acesso
Incio O(1) O(1) O(1)
Meio O(1) O(1) O(n)
Fim O(1) O(1) O(1)
Caractersticas
Acesso Aleatrio Sim Sim No
Tabela 20.1: Comparao de custo em termos de nmero de atribuies para estruturas de dados
sequenciais. As estruturas de acesso aleatrio tem mais facilidade de acesso a elementos no meio
da sequncia. As estruturas baseadas em ponteiro tem mais facilidade de insero e remoo de
elementos no meio da sequncia.
20.4 Comparao 299
Qualquer container tem a capacidade inserir, remover, ou acessar elementos no fim da

sequncia em tempo O(1). Dado um iterador, apenas um list pode colocar elementos no meio
de uma sequncia em tempo O(1). Apenas um vector no pode colocar elementos no incio de
uma sequncia em tempo O(1).
O vector possui ento apenas capacidade de inserir e remover elementos no fim da sequncia
em tempo O(1). Um deque, apesar de ser baseado em arranjos tambm, pode inserir ou remover
de elementos no incio de uma sequncia em tempo O(1). A grande vantagem do list ter a
capacidade de inserir ou remover elementos em qualquer posio de uma sequncia em tempo
O(1).
Do ponto de vista de acesso, por outro lado, o vector uma estrutura muito vantajosa.
Em relao a custo de acesso, um vector ou um deque podem acessar qualquer posio da
sequncia em tempo O(1). Apesar de ambos terem um custo constante de acesso, o custo de
acesso em um vector ser menor que em um deque pois ele precisa de operaes aritmticas
mais simples. J um list, tem um gasto O(n) para acessar elementos no meio da lista pois ele
no tem acesso aleatrio.
Assim, uma questo fundamental ao se escolher um container saber se precisamos do
recurso de acesso aleatrio para elementos no meio da sequncia. Isto faz com que os containers
de acesso aleatrio sejam ideais para aplicaes pouco dinmicas. Se vamos usar um deque
ou um vector, precisamos lembrar que apesar de ser O(1), o custo de acesso em um vector
menor que em um deque.
A Figura 20.1 apresenta o custo de insero de um elemento em um container sequencial.
Em experimentos reais, apesar da insero no fim de um container ter sempre custo assinttico
O(1), podemos ver que os containers vector e deque apresentam alguns picos de custos bem
maiores que a mdia para alguns tamanho de arranjo. Isso se deve realocao de arranjos. Alm
disso, a insero no fim de um deque costuma ser 23% mais lenta que um vector, enquanto a
insero no fim de um list costuma ser 416% mais lenta do que um vector.
Para insero no incio da sequncia podemos ver como esta operao em um vector
maior para arranjos maiores, j o custo desta operao O(n) neste container. Porm, a insero
no incio da sequncia ainda vantajosa em um vector do que em um list se temos arranjos
com menos que 250 elementos. Apesar da complexidade costante para os outros containers, um
list costuma ser 23% mais lento que um deque.
6 6
x 10 x 10
3.5 2
vector vector
deque deque
list 1.8 list
3
1.6
2.5 1.4
Tempo (segundos)
Tempo (segundos)
1.2
2
1.5
0.8
1 0.6
0.4
0.5
0.2
0 0
0 200 400 600 800 1000 1200 1400 1600 1800 2000 0 200 400 600 800 1000 1200 1400 1600 1800 2000
Tamanho do arranjo Tamanho do arranjo
(a) Fim da sequncia (b) Incio da sequncia
Figura 20.1: Custo de insero em um container sequencial.

20.5 Exerccios
2 // bibliotecas com os containeres
4 # include < deque >
5 # include < list >
6
8
10 void imprimeContainer ( T const & coll ) ;
11
12 int main ()
13 {
14 // cria um vector de int chamado dados
15 vector < int > vetor ;
16
17 // inserindo dados no fim do vector , um a um
18 vetor . push_back (2) ;
26 cout << " Elementos no vector inicial ( " << vetor . size ()
<< " ) : " << endl ;
27 imprimeContainer ( vetor ) ;
28
29 // Fa a aqui um algoritmo de inser o
30 vetor . resize ( vetor . size () +1) ;
31
32 // Imprimindo o vector novamente com o elemento
inserido
33 cout << " Elementos no vector com elemento na posicao
inicial ( " << vetor . size () << " ) : " << endl ;
35
36 // Conseguindo um iterador para o meio do vetor
37 vector < int >:: iterator i_vector = vetor . begin () ;
38 i_vector += vetor . size () /2;
39
40 // Imprimindo o elemento do meio do vector
41 cout << " O elemento que esta no meio do vetor o " <<
* i_vector << endl ;
42
20.5 Exerccios 301
43 // Fun o insert coloca um elemento na posi o indicada

pelo iterador
44 vetor . insert ( i_vector , 90) ;
45 cout << " Elementos no vector com 90 inserido no meio ( "
<< vetor . size () << " ) : " << endl ;
47
48 // A fun o resize aumenta o tamanho do vector
49 vetor . resize ( vetor . size () +1) ;
50 cout << " Elementos no vector aumentado em 1 ( " << vetor
. size () << " ) : " << endl ;
52
53 // Fa a aqui uma inser o no meio do vector
54
55 // Imprimindo o vector mais uma vez
56 cout << " Elementos no vector com elemento inserido ( "
<< vetor . size () << " ) : " << endl ;
58
59 // Opera es similares ser o feitas com um deque .
60 deque < int > fila ;
61 // Copiando os elementos do vector para a fila
duplamente encadeada
62 while (! vetor . empty () ) {
63 fila . push_front ( vetor . back () ) ;
64 vetor . pop_back () ;
65 }
66
67 // Imprime a fila
68 cout << " Elementos na fila com duas pontas inicial ( "
<< fila . size () << " ) : " << endl ;
69 imprimeContainer ( fila ) ;
70
71 // Inserir elementos com push_front
72
73 // Imprimindo a nova fila
74 cout << " Elementos na fila com duas pontas com
elementos no in cio ( " << fila . size () << " ) : " <<
endl ;
76
77 // Conseguindo um iterador para o meio do deque
78 deque < int >:: iterator i_fila = fila . begin () ;
79 i_fila += fila . size () /2;
80
81 // Imprimindo o elemento do meio do deque
82 cout << " O elemento que esta no meio da fila com duas
pontas eh o " << * i_fila << endl ;
83
84 // Fun o insert coloca um elemento ap s a posi o
indicada
85 fila . insert ( i_fila , 91) ;
86 cout << " Elementos na fila com duas pontas com 91
inserido ( " << fila . size () << " ) : " << endl ;
88
89 fila . resize ( fila . size () +1) ;
90 cout << " Elementos na fila com duas pontas aumentada ( "
<< fila . size () << " ) : " << endl ;
92
93 // Fazer inser o no meio do deque
94
95 // Imprimindo a fila mais uma vez
96 cout << " Elementos na fila com duas pontas com elemento
inserido ( " << fila . size () << " ) : " << endl ;
98
99 // Opera es similares ser o feitas com uma lista
100 list < int > lista ;
101
102 // Copiando os elementos da fila para a lista
103 while (! fila . empty () ) {
104 lista . push_back ( fila . front () ) ;
105 fila . pop_front () ;
106 }
107
108 // Imprime a fila
109 cout << " Elementos na lista duplamente encadeada
inicial ( " << lista . size () << " ) : " << endl ;
110 imprimeContainer ( lista ) ;
111
112 // Fazer inser o no inicio da lista
113
114 // Imprimindo a nova lista
115 cout << " Elementos na lista duplamente encadeada ( " <<
lista . size () << " ) : " << endl ;
117
118 // Obter iterador para o meio da lista
119 list < int >:: iterator i_lista = lista . begin () ; // pegando
a posi o inicial
120
121 // Imprimindo o elemento do meio da lista
20.5 Exerccios 303
122 cout << " O elemento que esta no meio da lista

duplamente encadeada eh o " << * i_lista << endl ;
123
124 // Fun o insert coloca um elemento ap s a posi o
indicada
125 lista . insert ( i_lista , 92) ;
126 cout << " Elementos na lista duplamente encadeada com o
92 ( " << lista . size () << " ) : " << endl ;
128
129 // Limpa a lista
130 lista . clear () ;
131 cout << " Lista duplamente encadeada limpa ( " << lista .
size () << " ) : " << endl ;
133
134 return 0;
135 }
136
138 void imprimeContainer ( T const & coll )
139 {
140 if ( coll . empty () ) {
141 std :: cout << " ( Vazio ) " << endl ;
142 return ;
143 }
144 typename T :: const_iterator pos ; // iterator que vai
percorrer coll
145 typename T :: const_iterator end ( coll . end () ) ; //
iterador que aponta para a posi o final
146
147 for ( pos = coll . begin () ; pos != end ; ++ pos ) {
148 std :: cout << * pos << ;
149 }
150 std :: cout << std :: endl ;
151 }

Exerccio 20.2 O container vector no tem uma funo push_front que insere um ele-
mento na primeira posio do vector. Faa na linha 29 um cdigo para inserir um elemento
qualquer na primeira posio do vector (sem usar a funo insert).
Na linha 29, a funo resize j est sendo utilizada para aumentar o tamanho do vetor em
1. A funo resize aumenta o tamanho do vector (completando com elementos de valor 0)
para caber mais elementos. Voc precisar mover todos os elementos existentes para frente e
abrir espao para o novo elemento.
Qual a dificuldade de se inserir um elemento em um vector?
Observao: A funo resize no necessariamente realoca o arranjo no vector. A
capacidade dele se mantm constante, se possvel.
Exerccio 20.3 Faa na linha 53 um cdigo para inserir um elemento no meio do vector
sem utilizar a funo insert. Para isto, voc precisar mover elementos aps o meio em
uma posio.
Exerccio 20.4 Na linha 71, insira mais alguns elementos no incio do deque com a funo
push_front. Esta funo no estava disponvel para um vector. Porqu? Como ela feita
em um deque?
Exerccio 20.5 Na linha 93, faa um cdigo para inserir um elemento no meio do deque.
Porm, desta vez, a funo insert no dever ser utilizada.
Exerccio 20.6 O deque faz todas as operaes que o vector capaz de fazer com a mesma
complexidade em notao O e ainda tem a capacidade de inserir elementos na primeira
posio em tempo O(1). Sendo assim, qual a vantagem da utilizao de um vector em
relao a um deque?
Exerccio 20.7 Na linha 112, insira mais alguns elementos no incio da lista com a funo
push_front. Esta funo no estava disponvel para um vector mas estava disponvel para
um deque. Como ela ocorre em um list?
Exerccio 20.8 Na linha 118, voc deve conseguir um iterador para o elemento do meio da
lista duplamente encadeada. Porm diferentemente deste trecho de cdigo para vector e
deque, a operao +=list.size()/2 no pode ser utilizada. Isso ocorre pois o container
list no um container de acesso aleatrio. Faa o cdigo de maneira que funcione para
list, utilizando o operador ++ repetidamente em um for. Qual sua dificuldade? Por que
isso acontece?
Exerccio 20.9 A funo de insert deve ser utilizada para se inserir elementos no meio de
listas. No possvel fazer isto de maneira manual como fizemos para vector e deque
pois no existe a operao [] em filas. Conhecendo como implementada na verdade
a operao insert de um vector e um deque (exerccios anteriores), qual a vantagem da
operao insert para listas?
Exerccio 20.10 Em todo o cdigo, sempre que criamos um container novo, copiamos os
elementos do container antigo atravs de um loop. Altere estes trechos de cdigo de modo
os contrutores dos novos containers sejam utilizados com os elementos do container antigo.
Exemplo: vector<int> c(c2.begin(), c2.end());.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0 0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 10
1
0
1
0
010 0 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 1 0 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
00
1
1
1 01
1
1 1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 1
00
0
1
1
111 0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Containers
0
21.
1
00 1
0 01 1
1 e 1Conjuntos
Associativos
0 0 0
1 1 110 1
0
0
0
110 0
1
0
0
000 0
0
1
1
0
0 0
00 1 00 0 0 0 010 01 00 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 00
0 1 01 0 1 1 1 0 01 1 11
Os containers associativos so utilizados para representar conjuntos. Em conjuntos, importante

saber se um elemento pertence ou no ao conjunto. Porm, no queremos saber da posio de
um elemento no conjunto. Alterar a posio dos elementos internamente, no altera o conjunto
sendo representado. Esta falta de controle na relao de ordem difere estes dos containers de
sequncia, como apresentado na Figura 21.1.
2 4 7
=
8 5
conjunto conjunto 2
5 7 4 8
Figura 21.1: Os containers associativos so utilizados para representar conjuntos. No existe

uma relao de ordem entre os elementos. Se dois conjuntos tm os mesmos elementos, eles so
o mesmo conjunto, independentemente da posio de cada elemento.
Como a posio dos elementos no relevante, eles ficam organizados automaticamente. O

critrio de organizao dos elementos especificado em uma funo de comparao utilizada
pelo container.
Nestes containers, elementos so encontrados rapidamente pois a estrutura de dados sabe
encontr-los de acordo com sua chave. Busca-se elementos pela prpria chave e no h uma
posio especfica de sequncia para o elemento.
21.1 Containers Associativos Ordenados

21.1.1 Set
O container set o container utilizado para representar conjuntos. Ao acessar os elementos
de um set um a um, eles so ordenados de acordo com seu valor. Cada elemento pode ocorrer
apenas uma vez em um conjunto representado por um set.
306 Captulo 21. Containers Associativos e Conjuntos
Considere que o conjunto de nmeros inteiros abaixo est representado por um set chamado
c.
1 set < int > c ;
O conjunto criado est inicialmente vazio.

Elementos podem ser inseridos em um conjunto com a funo insert.
3 1
6
c
2 5 4
Note que a funo insert no precisou de um iterador indicando em qual posio do

conjunto ser inserido o elemento.
Como em qualquer container, podemos usar iteradores para acessar os elementos do container
um a um.
1 set < int >:: iterator i ;
2 for ( i = c . begin (); i != c . end (); ++ i ){
3 std :: cout << * i << " " ;
4 }
5 cout << endl ;
Ao fazer isto, os elementos so impressos em ordem crescente. Isto no depende da ordem
em que foram inseridos.
1 2 3 4 5 6
J a funo erase pode ser utilizada para apagar elementos de acordo com suas chaves.
1 c . erase (5);
2 c . erase (6);
3 1
c
2 4
A funo find procura um elemento e retorna um iterador para ele caso este seja encontrado.
1 set < int >:: iterator pos ;
2 pos = c . find (2);
3 1
c
2 4
pos
O operador ++ leva o iterador para o prximo elemento do conjunto, considerando os

elementos em ordem.
1 ++ pos ;
3 1
c
2 4
pos
21.1.2 Multiset
O multiset um container muito similar ao set. A diferena que ele representa multiconjun-
tos, ou seja, conjuntos onde um elemento pode ocorrer mais de uma vez.
Suponha o seguinte multiset abaixo chamado c.
1 multiset < int > c ;
Podemos agora inserir elementos replicados no conjunto.

1 c . insert (3);
2 c . insert (3);
3 c . insert (6);
4 c . insert (4);
5 c . insert (2);
6 c . insert (2);
7 c . insert (5);
5 2
3
c 3 4
6
2
Ao iterar pelos elementos, estes ainda esto ordenados. As repeties de elementos ocorrem
em sequncia.
1 multiset < int >:: iterator i ;
2 for ( i = c . begin (); i != c . end (); ++ i ){
3 cout << * i << " " ;
4 }
5 cout << endl ;
2 2 3 3 4 5 6
A funo find procura a primeira ocorrncia de um elemento e retorna um iterador para ele,
caso este seja encontrado.
1 set < int >:: iterator pos ;
2 pos = c . find (2);
5 2
3
c 3 4
6
2
pos
O operador ++ leva o iterador para o prximo elemento do conjunto ou para a prxima

repetio do elemento, considerando os elementos em ordem.
1 ++ pos ;
5 2
3
c 3 4
6
2
pos
A funo erase pode receber um iterador para retirar apenas o elemento apontado do
conjunto.
1 c . erase ( pos );
5 2
3
c 3 4
6
2
pos
Alm das funes usuais, a funo count pode ser utilizada em um multiset para determi-
nar quantas ocorrncias de um elemento existe em um conjunto.
1 c . insert (3);
2 c . insert (3);
3 c . insert (2);
4 c . insert (4);
5 cout << c . count (3);
3 5 2
3
c 3 3 4
6 4
2
H outras duas funes importantes em multiconjuntos. A funo lower_bound retorna

um iterador para a primeira ocorrncia de um elemento no conjunto. A funo upper_bound
procura a ltima ocorrncia de um elemento no conjunto e retorna um iterador para a prxima
posio.
1 set < int >:: iterator primeiro = c . lower_bound (3);
2 set < int >:: iterator ultimo = c . upper_bound (3);
3 5 2
3
c 3 3 4
6 4
2
primeiro ultimo
21.1.3 Map
O conteiner map utilizado para representar um tipo de dados chamado arranjos associativos.
Em um conjunto, temos vrias chaves. Em um arranjo associativo, temos vrias chaves e para
cada chave temos um registro associado. A chave e o registro no precisam ser do mesmo tipo.
Considere o arranjo associativo abaixo representado por um map chamado c.
1 map < string , double > c ;
c
O container ter chaves do tipo string e registros do tipo double.

Podemos inserir elementos facilmente neste conjunto de dados atravs do operador de
subscrito. Colocamos a chave no subscrito e o registro direita.
1 c [ " PI " ] = 3.14;
2 c [ " ZERO " ] = 0.0;
3 c [ " IRPF " ] = 0.15;
ZERO 0.0
c PI 3.14
IRPF 0.15
Esta estrutura frequentemente chamada de arranjo associativo pois quando a utilizamos

com o operador de subscrito como se estivssemos acessando um arranjo onde as posies so
as chaves. Podemos, assim, de maneira simples retornar um valor.
1 cout << c [ " PI " ] << endl ;
3.14
Assim como em outros containers, a funo find utilizada para encontrar um elemento pela
chave. retornado um iterador para este elemento.
1 map < string , double >:: iterator pos ;
2 pos = c . find ( " ZERO " );
ZERO 0.0
c PI 3.14
IRPF 0.15
pos
Ao desreferenciar um iterador de um map, retornada uma estrutura com duas variveis:

first e second.
first second
ZERO 0.0
c PI 3.14
IRPF 0.15
pos
Podemos guardar toda a estrutura ou utilizar diretamente os campos first e second.

1 cout << pos - > first << " : " << pos - > second << endl ;
2 // comando equivalente
3 cout << (* pos ). first << " : " << (* pos ). second << endl ;
ZERO: 0
ZERO: 0
Assim como em outros containers, ao se iterar pelos elementos, estes ocorrem no conjunto
ordenados pela chave.
2 cout << pos - > first << " : " << pos - > second << endl ;
3 }
IRPF: 0.15
PI: 3.14
ZERO: 0
21.1.4 Multimap
Assim como os containers set e multiset, o container map tambm contm um equivalente
que aceita entradas repetidas de um elemento: o multimap.
Todas as funes especficas para multiset, como lower_bound, upper_bound e count
podem ser utilizadas tambm no multimap.
Um recurso especificamente interessante em um multimap que rplicas de uma chave
podem ter registros diferentes, o que diferencia os elementos com chaves replicadas.
21.1.5 Como funcionam

Apesar dos tipos distintos de containers associativos, todos eles se baseiam usualmente em uma
estratgia similar: rvores Binrias de Pesquisa ou BST (Binary Search Tree).
As rvores binrias so estruturas eficientes para armazenar informao. Elas permitem o
acesso direto a elementos de forma eficiente. As operaes de insero e remoo so tambm
feitas com um baixo custo nestas estruturas.
Assim como as listas encadeadas, as rvores so baseadas em clulas que guardam elementos
e ponteiros para outras clulas. Clulas esquerda da rvore contm elementos menores e clulas
direita contm elementos maiores.
A Figura 21.2 apresenta um exemplo de rvore binria de pesquisa com nmeros inteiros.
Veha que para qualquer clula da rvore, a clula esquerda contm um elemento menor, como
ocorre com os elementos 350 e 300. Veja que para qualquer clula da rvore, a clula direita
contm um elemento maior, como ocorre com os elementos 350 e 500.
O mesmo ocorre para subrvores esquerda e direita de uma clula, como apresentado na
Figura 21.3. Podemos ver na Figura 21.3(a) que toda clula R tem uma subrvore E esquerda e
outra subrvore D direita. Todos os elementos em E so menores que R. Todos os elementos
em D so menores que R. Isto vale para qualquer clula, como podemos ver na Figura 21.3(b).
Em um container do C++, a rvore representada atravs da alocao de memria para
vrias clulas representadas com struct. De modo similar s clulas utilizadas nos containers
list, cada clula de uma rvore contm um elemento e dois ponteiros para outras clulas.
200
150 350
100 170 300 500
400 600
Figura 21.2: Exemplo de rvore Binria de Pesquisa
200 R 200
E
D R
150 350 150 350
E D
100 170 300 500 100 170 300 500
400 600 400 600
(a) Subvores 1 (b) Subvores 2
Figura 21.3: Toda clula R tem elementos menores em uma subrvore esquerda E e elementos
maiores em uma subrvore direita D.
10
Um objeto do tipo set contm um ponteiro para a clula alocada como raiz da rvore
(variavl chamada aqui de raiz) e uma varivel chamada aqui de n para contar o nmero de
elementos na estrutura.
1 set < int > c ;
set<int> c;
raiz n 0
Quando os elementos so inseridos, os ponteiros das clulas apontam para os elementos raiz
das rvores esquerda e direita.
1 c . insert (200);
2 c . insert (150);
3 c . insert (350);
4 c . insert (100);
5 c . insert (170);
6 c . insert (300);
7 c . insert (500);
8 c . insert (400);
9 c . insert (600);
set<int> c;
raiz n 9
200
150 350
100 170 300 500
400 600
Para procurar um elemento, basta ir raiz da rvore e fazer uma comparao para saber em
qual subrvore est o elemento. Ao descobrirmos em qual subrvore est o elemento, vamos
a esta subrvore e repetimos o processo em sua raz. Se a raz da rvore o elemento que
procuramos, terminamos a busca. Se tal raz no encontrada, o elemento no est no conjunto.
1 pos = c . find (500);
set<int> c;
raiz n 9
200
150 350
100 170 300 500
400 600
Ao procurar o elemento 500, vamos raiz da rvore, que 200. Assim, sabemos que o
elemento, se existente, estar na subrvore direita. O mesmo ocorre repetidamente at que
encontramos o elemento 500.
Para inserir um elemento, um processo similar utilizado. Suponha que queremos inserir o
elemento 180.
1 c . insert (180);
set<int> c;
raiz n 10
200
150 350
100 170 300 500
180 400 600
Percorremos as clulas da rvore como fazemos em uma pesquisa, at encontrar onde o

elemento 180 est ou deveria estar. Basta criar uma clula para o elemento e inser-lo nesta
posio.
Para remover um elemento da rvore, temos um problema um pouco mais complicado, que
pode ocorrer em 3 casos.
Caso 1) Para remover um n folha, apenas procuramos por ele e o removemos.
1 c . erase (180);
set<int> c;
raiz n 9
200
150 350
100 170 300 500
180 400 600
Caso 2) Para remover um n que tem apenas um filho, temos um processo de dois passos.
Caso 2 - Passo 1 - Removemos o n.
set<int> c;
raiz n 9
200
150 350
100 170 300 500
180 400 600
Caso 2 - Passo 2 - Substitumos o n por seu filho.
set<int> c;
raiz n 9
200
150 350
100 180 300 500
400 600
Caso 3) Para remover um n com 2 filhos temos 3 passos. Caso 3 - Passo 1 - Em vez de
remover o n, procuramos seu sucessor ou predecessor de acordo com seu valor.
set<int> c;
raiz n 9
200
150 350
100 180 300 500
400 600
Neste caso, vamos utilizar o sucessor de 350, que sempre o elemento mais esquerda da
rvore direita. O predecessor, de modo anlogo, seria o elemento mais direita da rvore
esquerda.
Caso 3 - Passo 2 - O sucessor toma a posio do item que queremos remover.
set<int> c;
raiz n 9
200
150 400
100 180 300 500
400 600
Caso 3 - Passo 3 - Removemos ento o sucessor marcado. Esta operao de remoo

recursiva e pode cair em qualquer um dos 3 casos novamente. A remoo do sucessor, neste
caso, caiu no caso 1. O processo assim encerrado.
set<int> c;
raiz n 9
200
150 400
100 180 300 500
400 600
Balenceamento
Apesar da eficincia mdia das rvores apresentadas, a ordem de insero dos elementos pode
afetar o desempenho das rvores. Os elementos podem ser inseridos em uma ordem tal que a
rvore final tenha muitos nveis e seja pouco eficiente.
Suponha a rvore gerada internamente pela insero dos elementos na ordem apresentada:
1 c . insert (200);
2 c . insert (150);
3 c . insert (350);
4 c . insert (100);
5 c . insert (170);
6 c . insert (300);
7 c . insert (500);
8 c . insert (180);
9 c . insert (400);
10 c . insert (600);
set<int> c;
raiz n 10
1 200
2 150 350
3 100 170 300 500
4 180 400 600
As linhas pontilhadas representam os nveis da rvore. Para encontrar um elemento nesta

rvore, no mximo 4 comparaes so feitas. Uma em cada nvel. Esta uma rvore com-
pletamente balenceada, onde o nmero de nveis o mnimo possvel para a quantidade de

elementos.
O nmero de nveis em uma rvore balanceada com n elementos O(log n) (1 = lg 2, 2 =
lg 4, 3 = lg 8, 4 = lg 16, . . . ). Sendo o custo de se encontrar um elemento igual ao nmero de
nveis, este custo tambm O(log n).
Agora suponha esta rvore gerada pela insero dos mesmo elementos em ordem crescente:
1 c . insert (100);
2 c . insert (150);
3 c . insert (170);
4 c . insert (180);
5 c . insert (200);
6 c . insert (300);
7 c . insert (350);
8 c . insert (400);
9 c . insert (500);
10 c . insert (600);
100
150
170
180
200
300
350
400
500
600
Encontrar um elemento na rvore pode custar at n = 10 comparaes. O nmero de nveis

em uma rvore totalmente desbalanceada com n elementos O(n). Sendo o custo de se encontrar
um elemento igual ao nmero de nveis, este custo tambm O(n). Perceba como em uma
rvore desbalanda a estrutura de dados se parece com uma lista encadeada.
Para que este problema de desbalanceamento no ocorra, a STL prev estratgias de balance-
amento para que o custo das operaes sobre conjunto seja sempre O(log n). Esta estratgias
so sempre aplicadas quando inserimos um elemento a mais no conjunto. Estas estratgias
usualmente envolvem rotaes nos elementos inseridos.
400
500
500
400 600
600
Em C++, porm, estas estratgias variam muito de acordo com o compilador. No faz parte
do escopo deste livro discutir todas estas estratgias, que podem ser encontradas em qualquer
bom livro didtico sobre estruturas de dados.
21.1.6 Anlise
Em uma rvore binria, cada comparao feita pelo algoritmo que busca um elemento divide o
nmero de solues possveis pela metade, de modo similar a uma busca binria. Assim, o custo
mdio de insero, remoo e pesquisa em todos os casos O(log n).
Como a STL contm estratgias de balanceamento, o custo das operaes continua O(log n)
mesmo no pior caso. Na verdade, mesmo para rvores que no tem estratgias de balanceamento,
o custo mdio ainda O(log n) para inseres feitas aleatoriamente. Seu pior caso, porm,
O(n).
21.2 Containers Associativos Desordenados

Os containers ordenados que apresentamos at o momento foram set, multiset, map e
multimap. Do ponto de vista de comandos, podemos criar os containers desordenados com
os tipos de dados equivalentes unordered_set, unordered_multiset, unordered_map e
unordered_multimap.
Tambm do ponto de vista de comandos, a utilizao dos containers desordenados se d de
forma idntica a seus pares ordenados. Porm, ao percorrer estes containers com um iterador,
se perceber que internamente os elementos no ficam estruturados em ordem. A quebra desta
restrio de ordenao leva a um ganho em velocidade de busca.
Veja o seguinte exemplo:
3 // < unordered_map > em vez <map >
4 # include < unordered_map >
5
7
8 int main (){
9 // unordered_map < string , int > em vez de map < string , int >
10 unordered_map < string , int > meses ;
11 meses [ " janeiro " ] = 31;
12 meses [ " fevereiro " ] = 28;
13 meses [ " marco " ] = 31;
14 meses [ " abril " ] = 30;
15 meses [ " maio " ] = 31;
16 meses [ " junho " ] = 30;
17 meses [ " julho " ] = 31;
18 meses [ " agosto " ] = 31;

19 meses [ " setembro " ] = 30;
20 meses [ " outubro " ] = 31;
21 meses [ " novembro " ] = 30;
22 meses [ " dezembro " ] = 31;
23 cout << " Setembro -> " ;
24 cout << meses [ " setembro " ] << endl ;
25 cout << " Abril -> " ;
26 cout << meses [ " abril " ] << endl ;
27 cout << " Dezembro -> " ;
28 cout << meses [ " dezembro " ] << endl ;
29 cout << " Fevereiro -> " ;
30 cout << meses [ " fevereiro " ] << endl ;
31 return 0;
32 }
A nica diferena entre este programa e um programa no qual utilizamos um map, a
declarao do tipo de dados na linha 9 e o cabealho correspondente na linha 11. Nos dois casos
criamos um arranjo associativo que tem como chave o nome dos meses e como registro o nmero
de dias neste ms.
Do ponto de vista de resultados, os dois programas (map e unordered_map) seriam equiva-
lentes e mostrariam o nmero de dias nos meses indicados.
Setembro -> 30
Abril -> 30
Dezembro -> 31
Fevereiro -> 28
Internamente, porm, sabemos que os dados do unordered_map no esto ordenados.

Veja agora este exemplo onde os elementos do container so percorridos nas linhas 22 a 25.
Veja como os elementos do unordered_map no esto em ordem quando percorridos.
4
6
7 int main (){
8 unordered_map < string , int > meses ;
9 meses [ " janeiro " ] = 31;
10 meses [ " fevereiro " ] = 28;
11 meses [ " marco " ] = 31;
12 meses [ " abril " ] = 30;
13 meses [ " maio " ] = 31;
14 meses [ " junho " ] = 30;
15 meses [ " julho " ] = 31;
16 meses [ " agosto " ] = 31;
17 meses [ " setembro " ] = 30;
18 meses [ " outubro " ] = 31;
19 meses [ " novembro " ] = 30;

20 meses [ " dezembro " ] = 31;
21 unordered_map < string , int >:: iterator i ;
22 for ( i = meses . begin (); i != meses . end (); ++ i ){
23 cout < first << " : " ;
24 cout < second << endl ;
25 }
26 return 0;
27 }
Temos a seguinte sada para o programa.
dezembro: 31
novembro: 30
setembro: 30
outubro: 31
agosto: 31
junho: 30
maio: 31
fevereiro: 28
abril: 30
julho: 31
marco: 31
janeiro: 31
Se utilizarmos um container map no mesmo exemplos, os elementos do exemplo estariam em

ordem em relao chaves. Como a chave do tipo string, eles estariam em ordem alfabtica.
abril: 30
agosto: 31
dezembro: 31
fevereiro: 28
janeiro: 31
julho: 31
junho: 30
maio: 31
marco: 31
novembro: 30
outubro: 31
setembro: 30
Os elementos do unordered_map esto em ordem arbitrria quando percorremos o container,

mas claramente isto no um problema para o tipo de dado que estamos guardando. Ter os meses
do ano em ordem alfabtica de pouca utilidade na maioria das aplicaes. Por isto, podemos
abrir mo da ordenao interna dos dados caso isto gere um ganho de tempo nas consultas.
21.2.1 Como funcionam

Assim como os containers ordenados, todos os containers desordenados so tambm baseados
em estruturas de dados similares. Estes containers desordenados so baseados estruturas de
dados chamadas tabelas hash. Estas se baseiam em estratgias de transformao de chave, o

que chamado usualmente de hashing.
As estruturas baseadas em transformao de chave utilizam um arranjo para guardar os
elementos do conjunto. Quando uma chave pesquisada, esta chave transformada em um
nmero atravs de uma operao de transformao de chave. O nmero retornado representa
uma posio em um arranjo, onde o elemento est guardado.
Considere um unordered_set que representa um conjunto desordenado.
1 unordered_set < int > c ;
Temos neste objeto uma varivel n que guarda o nmero de elementos no container, um
ponteiro chamado aqui de p para um arranjo alocado na memria, e o tamanho deste arranjo
chamado aqui de m.
unordered_set<int> c;
n 0 p m 7
p[0] p[1] p[2] p[3] p[4] p[5] p[6]
Este arranjo alocado na memria e apontado por p chamado de Tabela Hash. nele que os
elementos sero inseridos. O tamanho inicial desta tabela depende da implementao existente
no compilador. Vamos supor aqui que a tabela hash tenha espao alocado m para 7 elementos.
Suponha agora que queremos inserir na tabela o elemento 32.
1 c . insert (32);
A funo de transformao h(x) dever transformar esta chave 32 em uma posio do arranjo.
A funo de transformao h(x) mais comum para nmeros inteiros h(x) = x%m, onde m
o tamanho da tabela hash e x o valor da chave. Em nosso exemplo, teramos ento que
h(32) = 32%7 = 4. Assim, a funo de transformao indica que o elemento 32 deve ser inserido
na posio p[4] da Tabela Hash.
n 1 p m 7
32
p[0] p[1] p[2] p[3] p[4] p[5] p[6]
21.2.2 Tratamento de Colises

Um problema bvio com tabelas hash que a transformao de chave pode querer colocar um
outro elemento na mesma posio da tabela. Por exemplo, se tentssemos inserir a chave 46,
teramos que h(46) = 46%7 = 4. A posio p[4], porm, j est tomada pelo elemento 36.
A estratgia mais comum para tratamento de colises transformar este arranjo de elementos
apontado por p em um arranjo de ponteiros para clulas de listas encadeadas de elementos.
Por exemplo, ao se inserir o elemento 32, ele vai para a posio h(32) = 4 da tabela hash
como um elemento em uma clula de uma lista encadeada.
1 c . insert (32);
n 1 p m 7
p[0]
p[1]
p[2]
p[3]
p[4] 32
p[5]
p[6]
Cada elemento fica em uma clula que composta de um elemento e um ponteiro para uma
possvel prxima clula. Por exemplo, ao se inserir o elemento 27, temos que h(27) = 27%7 = 6.
1 c . insert (27);
n 2 p m 7
p[0]
p[1]
p[2]
p[3]
p[4] 32
p[5]
p[6] 27
Em caso de coliso, o elemento simplesmente colocado como ltimo da lista.

1 c . insert (46);
n 3 p m 7
p[0]
p[1]
p[2]
p[3]
p[4] 32 46
p[5]
p[6] 27
1 c . insert (31);
2 c . insert (22);
3 c . insert (15);
n 6 p m 7
p[0]
p[1] 22 15
p[2]
p[3] 31
p[4] 32 46
p[5]
p[6] 27
21.2.3 Anlise
A maior vantagem de tabelas hash a sua eficincia em relao a custo mdio para pesquisa,
insero e remoo. Para uma tabela onde os dados esto bem distribudos o custo de qualquer
operao na tabela O(1).
O STL j inclui estratgias para que os dados fiquem sempre bem distribudos na tabela.
Estas estratgias incluem funes de hashing que garantam uma boa distribuio dos dados e
alocao de maiores tabelas caso a carga de elementos esteja muito alta.
Para a estratgia de tratamento coliso apresentada, no pior caso, se todos os elementos
forem para a mesma posio, o custo de cada operao seria O(n). Porm, alm da probabilidade
deste caso ser desprezvel, um tratamento de coliso atravs de rvores em vez de listas pode
levar este pior caso a O(log n), fazendo com que a tabela hash seja, na pior das hipteses, to
eficiente quanto uma rvore.
Mais ainda, possvel garantir de vrias formas uma boa distribuio dos dados na tabela.
Todas as tabelas hash alocam espao para tabelas maiores quando o nmero de elementos cresce.
Usualmente uma nova tabela maior criada quando o nmero de elementos maior que 70% do
tamanho da tabela. Esta proporo chamada de fator de carga.
Quando o tamanho da tabela aumenta uma operao O(n) copia os elementos para a nova
tabela, causando um custo de realocao de memria. Para evitar isto, comum manter duas
tabelas hash para representar um conjunto de dados. Sempre que um elemento novo inserido
na tabela nova, um elemento da tabela antiga transferido para a tabela nova com custo O(1).
Porm, nesta estratgia, a busca de um elemento, apesar de ser ainda O(1), sempre precisar ser
feita em duas tabelas.
A maior desvantagem das tabelas hash que os dados ficam desordenados na tabela. Assim,
para retornar todos os itens em ordem seria necessrio colocar tudo para uma outra estrutura
ordenada ou orden-los em uma estrutura de sequncia. Qualquer uma destas opes ter um
custo O(n log n). Por isto, esta uma estrutura a ser utilizada apenas quando os dados em ordem
realmente no so necessrios.
21.3 Anlise dos Containers Associativos

O diagrama apresentado na Tabela 21.1 apresenta os principais fatores a se considerar ao escolher
um container para armazenamento de dados.
A posio dos elementos em uma sequncia importante?

Sim No
Containers Sequenciais Containers Associativos
Onde sero feitas as inseres? Precisa manter os itens ordenados?
Fim Meio Incio Sim No
vector list deque Associativo ordenado Associativo desordenado
Tabela 21.1: Fatores a se considerar ao escolher uma categoria de container para representar uma
estrutura de dados.
Discutimos na Seo 20 a diferena de desempenho entre os containers sequenciais. Se

ignorarmos a ordem dos elementos em um container sequencial, claro que poderamos utilizar
um container sequencial qualquer para representar conjuntos. Para inserir um elemento no
conjunto, colocaramos o elemento fim da sequncia, em tempo O(1). Para remover um elemento
ou fazer um pesquisa no conjunto, percorramos todo o arranjo em busca do elemento, com custo
O(n). Veja que qualquer container teria o mesmo custo para estas operaes (inserir ao fim da
sequncia e percorrer os elementos). Por isto, usual utilizamos um container vector para este
fim.
Para retornar os dados em ordem, um algoritmo de ordenao deve ser aplicado sequncia.
possvel tambm representar conjuntos com um container sequencial que seja mantido ordenado,
o que garantiria uma busca O(log n) com uma busca binria. O custo de se inserir e posicionar
um elemento na posio correta, porm, seria O(n). Esta seria uma melhor soluo em aplicaes
menos dinmicas.
A Tabela 21.2 apresenta o custo assinttico destas operaes de representao de conjuntos
para diferentes containers, incluindo os sequenciais. Vemos como a representao de conjuntos
com containers sequenciais desvantajosa do ponto de vista assinttico. Entre os containers
associativos, se no precisamos ter os elementos em ordem, o container desordenado sempre
mais vantajoso. Se precisamos percorrer os elementos em ordem, teramos um custo O(n log n)
para ordenar os elementos. O custo desta ordenao pode ser ou no compensado pela operao
que faremos nos elementos ao percorr-los.
Container Sequencial Container Associativo

Desordenado Ordenado Ordenado Desordenado
Insero O(1) O(n) O(log n) O(1)
Remoo O(n) O(n) O(log n) O(1)
Pesquisa O(n) O(log n) O(log n) O(1)
Percorrer em ordem O(n log n) O(n) O(n) O(n log n)
Tabela 21.2: Custo para representao de conjuntos atravs das estruturas de dados e containers
mais comuns.
A Figura 21.4 apresenta o custo de insero de um elemento em um container que representa

conjuntos. Foram utilizados os containers vector, set e unordered_set para armazenar dados
do tipo int neste experimento. O custo de uma insero em um container sequencial ordenado
cresce em proporo com o nmero de elementos, j que precisamos posicionar o elemento
em sua posio correta da sequncia. Mesmo com seu custo assinttico maior, para conjuntos
com menos de 200 elementos o container sequencial ordenado mais vantajoso que todos os
containers associativos. Para conjuntos com menos de 5000 elementos o container sequencial
ordenado mais vantajoso que um container associativo ordenado.
Os containers desordenados sempre tm custo contante de insero, sendo que um contaner
sequencial desordenado tem sempre um custo mais baixo, j que precisa apenas inserir um
elemento ao fim de um arranjo. Os containers associativos ordenados, baseados em rvores, tem
um custo O(log n), que passa a ser discernvel de um custo constante medida conjuntos se
tornam muito grandes. Se e apenas se a operao dominante da aplicao for inseres, pode
ser vantajoso utilizar um container sequencial desordenado para representar conjuntos. No caso
geral, como containers desordenados tambm tm custo constante de insero, provvel que
containers associativos continuem mais interessantes, devido ao custo de suas outras operaes.
6 6
x 10 x 10
3 1.2
Sequencial Desordenado
Associativo Ordenado
Sequencial Ordenado Associativo Desordenado
2.5 1
Associativo Desordenado
2 0.8
Tempo (segundos)
Tempo (segundos)
1.5 0.6
1 0.4
0.5 0.2
0 0
0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8
Tamanho do conjunto 4
x 10 Tamanho do conjunto x 10
4
(a) Todos os containers (b) Seleo de containers
Figura 21.4: Custo de insero em um container que representa conjuntos.
A Figura 21.5 apresenta o custo de remoo de um elemento em um container que representa

conjuntos. O custo de uma remoo em um container sequencial cresce em proporo com
o nmero de elementos, j que precisamos reposicionar os elementos na sequncia. Nestes
containers, para toda operao de remoo, h uma operao de pesquisa. O container sequencial
desordenado especialmente mais lento pois o custo de pesquisa do elemento a ser removido
O(n). Em nossos experimentos, para conjunto pequenos, um container sequencial desordenado
mais vantajoso que um sequencial ordenado para menos de 250 elementos, que um associativo
desordenado para menos de 320 elementos e que um associativo ordenado para menos de 600
elementos. Um container sequencial ordenado tem uma remoo mais rpida que um associativo
desordenado para menos de 7000 elementos e que um associativo ordenado para menos de 7200
elementos.
J os containers associativos tm um custo baixo de remoo muito mais baixo, sendo que a
diferena entre containers associativos ordenados O(log n) e desordenados O(1) se torna maior
medida que os conjuntos se tornam muito grandes. Containers associativos ordenados tm
sempre uma eficincia menor que associativos desordenados para insero de elementos.
5 6
x 10 x 10
3 6
Sequencial Desordenado Sequencial Ordenado
Sequencial Ordenado Associativo Ordenado
Associativo Ordenado Associativo Desordenado
2.5 5
2 4
Tempo (segundos)
Tempo (segundos)
1.5 3
1 2
0.5 1
0 0
0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8
x 10 Tamanho do conjunto 4
x 10
Figura 21.5: Custo de remoo em um container que representa conjuntos.
A Figura 21.6 apresenta o custo de pesquisa de um elemento em um container que representa

conjuntos. Os containers sequenciais desordenados tm um custo alto O(n) para este tipo de
operao. Porm, em nossos experimentos, containers sequenciais desordenados podem ter
consultas mais eficientes do que containers associativos desordenados para menos de 50 elemen-
tos, que containers associativos desordenados para menos de 200 elementos e que containers
sequenciais ordenados para menos de 225 elementos. Para outros casos, containers associativos
desordenados so sempre vantajosos para pesquisa. Nos casos onde h necessidade de ordenao,
containers sequenciais ordenados so cerca de 50% mais rpidos do que containers associativos
ordenados.
Entre os tipos de containers associativos ordenados e desordenados, como cada um destes dois
utiliza a mesma estrutura com a mesma eficincia, nossa escolha depende de nossas necessidades
em relao a caractersticas do conjunto a ser representado. A Tabela 21.3 apresenta as principais
caractersticas dos containers associativos.
Em geral, os containers desordenados (os do tipo unordered) tm operaes menos
custosas de insero, remoo e pesquisa. Estas operaes tm apenas custo O(1). Mesmo assim,
as operaes dos containers ordenados, apesar de no to eficientes quanto as dos containers
desordenados, tem ainda um custo baixo: O(lg n).
Os containers desordenados, por outro lado, no tm os seus elementos estruturados inter-
namente em ordem. No caso geral, seria necessria uma operao O(n log n) de ordenao dos
elementos para que estes sejam acessados em ordem. Em um arranjo ordenado, os dados podem
ser normalmente acessados em ordem com apenas um custo O(n).
Em relao a outras caractersticas que podem influciar a deciso, os containers do tipo map
5 7
x 10 x 10
1.6 3.5
Sequencial Ordenado
Sequencial Ordenado Associativo Desordenado
1.4
Associativo Ordenado 3
1.2
2.5
1
Tempo (segundos)
Tempo (segundos)
2
0.8
1.5
0.6
1
0.4
0.5
0.2
0 0
0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8
x 10 Tamanho do conjunto x 10
4
Figura 21.6: Custo de pesquisa em um container que representa conjuntos.
Container Custo operaes Itens em ordem Registros Itens repetidos

set O(log n) Sim No No
multiset O(log n) Sim No Sim
map O(log n) Sim Sim No
multimap O(log n) Sim Sim Sim
unordered_set O(1) No No No
unordered_multiset O(1) No No Sim
unordered_map O(1) No Sim No
unordered_multimap O(1) No Sim Sim
Tabela 21.3: Custo para representao de conjuntos atravs das estruturas de dados e containers
mais comuns.
so os que tm registros associados s chaves e os do tipo multi so os que permitem registros

duplicados.
21.3.1 Dicas de utilizao de containers

muito importante entender como os dados so organizador em um container. Mais ainda,
importante saber como alocado espao para elementos em um container. Os containers
vector, deque e associativos desordenados precisam realocar arranjos sempre que o nmero
de elementos cresce. Quando sabemos que j teremos vrios elementos sero colocados nestes
containers, ele contm a funo c.reserve(n) que permite j alocar espao para um certo
nmero n de elementos. Isto evita o custo de vrias realocaes de arranjo.
tambm importante entender como os elementos so organizados dentro de um container.
Entender como os dados so organizados no container garante que se entenda o nmero de
operaes envolvidas em cada funo disponvel para o container. Assim, entendendo a estrutura,
no precisamos decorar o custo de cada operao
Use a funo c.empty() para saber se um container est vazio. Esta funo utiliza dados
pr-processados para retornar uma resposta. No use c.size()==0 para saber se um container
est vazio. Fazer isto envolve 2 operaes: clculo do nmero de elementos e comparao.
21.4 Exerccios
21.4 Exerccios 329
Exerccio 21.1 Analise o cdigo abaixo, que est incompleto. O cdigo abaixo utiliza um
container do tipo set para guardar um conjunto de siglas, que so do tipo string.
Veja como o conjunto criado com set<string>.
Veja como siglas podem ser adicionadas ao conjunto com a funo insert.
Veja como a funo imprimeContainer imprime todas as siglas de um set.
Veja como a funo pesquisaSigla utiliza a funo find para pesquisar uma sigla.
Veja como temos um lao com um menu dentro. As funes para o menu precisam ser
implementadas.
Veja que inclumos as bibliotecas stdlib.h e time.h neste cdigo. Elas permitem
gerao de nmeros aleatrios e medir tempo.
Veja que criamos um arranjo dinamicamente com o tamanho pedido. (new int[n])
Veja que a funo rand() gera nmeros aleatrios que so inseridos no arranjo.
Veja que temos algumas funes que no so utilizadas ainda.
1 # include < iostream > // biblioteca de entrada e saida
2 # include < string > // biblioteca para usar strings
4 # include <set >
5 # include <map >
7 # include < algorithm >
8
10
11 template < typename T > // fun o similar do exerc cio
anterior
12 void imprimeContainer ( T const & x ) ;
13
14 template < typename T > // Pesquisa uma sigla no container
15 void pesquisaSigla ( T const & x ) ;
16
17
18 int main ()
19 {
20 // cria um set de strings chamado x
21 set < string > x ;
22
23 // inserindo siglas no conjunto , um a um
24 x . insert ( " INSS " ) ; // Instituto Nacional de Seguran a
Social
25 x . insert ( " CEP " ) ; // C digo de Endere amento Postal
26 x . insert ( " FUNAI " ) ; // Funda o Nacional do ndio
27 x . insert ( " IOF " ) ; // Imposto sobre Opera es de Cr dito
28 x . insert ( " IR " ) ; // Imposto de Renda
29 x . insert ( " EMBRATEL " ) ; // Empresa Brasileira de
Telecomunica es
30 x . insert ( " ONU " ) ; // Organiza o das Na es Unidas
31 x . insert ( " SPC " ) ; // Servi o de Prote o ao Cr dito
32 x . insert ( " IBGE " ) ; // Instituto Brasileiro de Geografia

e Estat stica
33
34 cout << " Elementos no conjunto inicial ( " << x . size ()
<< " ) : " << endl ;
35 imprimeContainer ( x ) ;
36
37 // Menu com op es
38 string opcao ;
39 do {
40 // Mostra o menu
41 cout << endl ;
42 cout << " [1] Listar todas as siglas " << endl ;
43 cout << " [2] Pesquisar uma sigla " << endl ;
44 cout << " [3] Adicionar uma sigla " << endl ;
45 cout << " [4] Remover uma sigla " << endl ;
46 cout << " [5] Retornar o numero de siglas
cadastradas " << endl ;
49
50 // l uma op o
51 cin >> opcao ;
52
53 // executa uma fun o de acordo com a op o
54 if ( opcao == " 1 " ) {
55 cout << " Listando todas as siglas " << endl ;
56 imprimeContainer ( x ) ;
57 } else if ( opcao == " 2 " ) {
58 cout << " Pesquisando uma sigla " << endl ;
59 pesquisaSigla ( x ) ;
60 } else if ( opcao == " 3 " ) {
61 cout << " Adicionando uma sigla " << endl ;
62 cout << " Esta funcao ainda nao foi implementada
" << endl ;
63 } else if ( opcao == " 4 " ) {
64 cout << " Removendo uma sigla " << endl ;
" << endl ;
66 } else if ( opcao == " 5 " ) {
67 cout << " Retornando o n mero de siglas " << endl
;
" << endl ;
69 } else if ( opcao == " 0 " ) {
70 cout << " Saindo do programa " << endl ;
71 } else {
72 cout << " Opcao invalida " << endl ;
73 }
21.4 Exerccios 331
74 } while ( opcao != " 0 " ) ;

75
76 return 0;
77 }
78
80 void imprimeContainer ( T const & x )
81 {
82 if ( x . empty () ) {
84 return ;
85 }
86 typename T :: const_iterator pos ; // iterator que vai
percorrer x
87 typename T :: const_iterator end ( x . end () ) ; // iterador
que aponta para a posi o final
88 int i = 1;
89 for ( pos = x . begin () ; pos != end ; ++ pos , ++ i ) {
90 std :: cout < // Pesquisa uma sigla no container
96 void pesquisaSigla ( T const & x )
97 {
98 cout << " Digite o nome da sigla que deseja pesquisar : "
<< endl ;
99 string pesquisa ;
100 // Guarda o que o usu rio digitou
101 cin >> pesquisa ;
102 // Esta linha converte todas as letras para mai sculas
103 std :: transform ( pesquisa . begin () , pesquisa . end () ,
pesquisa . begin () , :: toupper ) ;
104 // cria - se um iterador
105 typename T :: const_iterator i ;
106 // procura o elemento e faz o iterador apontar para ele
107 i = x . find ( pesquisa ) ;
108 if ( i != x . end () ) {
109 cout << " A sigla " << pesquisa << " esta no
conjunto de siglas " << endl ;
110 } else {
111 cout << " A sigla nao foi encontrada " << endl ;
112 }
113 return ;
114 }

Exerccio 21.2 Implemente as funes que ainda no foram implementadas. Use a funo j
implementada como referencia.
Exerccio 21.3 Vamos agora transformar este programa em um dicionario de siglas, ou seja,
para cada sigla pesquisada, teremos retornada sua definio.
Para isto, troque a estrutura set por uma estrutura map. Os registros e as chaves desse
map devero ser do tipo string.
A insero de siglas no map feita de maneira mais conveniente com o operador de
subscrito [].

Exerccio 21.4 Com o dicionrio de siglas implementado, troque a estrutura map por
unordered_map.
necessrio fazer mais alguma alterao para que o cdigo funcione?
Qual a desvantagem e qual a vantagem de se utilizar um unordered_map?

Exerccio 21.5 A estrutura unordered_map no consegue retornar os itens em ordem cres-

cente como o map. Porm, a estrutura unordered_map tem um ganho em eficincia para
pesquisa e insero. Se quisermos utilizar o unordered_map e mesmo assim quisermos
retornar os itens ordenados, como podemos fazer isto manualmente?
Exerccio 21.6 Neste cenrio, onde tanto as funes de pesquisa em unordered_map e map
retornam os itens ordenados, em quais casos seria vantagem utilizar map ou unordered_map?

Exerccio 21.7 Implemente a alterao na funo imprimeContainer para que ela imprima
os itens de um unordered_map de maneira ordenada. Os elementos podem ser transferidos
temporariamente para um map simples.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Adaptadores
0
22.
1 0 1
0 0de Container
1
0 10 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Os containers que vimos at agora so chamados de containers de primeira classe. Os adapta-

dores de container no so containers de primeira classe pois so apenas verses limitadas do
containers de primeira classe para aplicaes especficas.
Estas verses limitadas dos containers de sequncia contm apenas funes push e pop.
As outras opes dos containers de sequncia no esto disponveis no adaptador de container.
Estes containers tambm no podem ser percorridos com iteradores. Assim, a utilizao de
adaptadores de container bem simples.
22.1 Stack
O container stack utilizado para representar pilhas de elementos. Ele permite apenas a
insero ou remoo em uma extremidade do container de sequncia. Este adaptador de container
tem apenas as funes de push e pop para insero e remoo. Estas funes, na verdade, apenas
chamam as funes push_back e pop_back de um container de sequncia original, que est
sendo utilizado internamente para representar a pilha.
Um stack pode ser usado para implementar uma pilha com um vector, list, ou deque.
Nos casos de omisso, um deque ser utilizado por padro. Neste adaptador de container, a
funo top obtm o elemento no topo da pilha, equivalente funo back dos containers de
sequncia.
22.1.1 Utilizao
Para utilizar um stack, o cabealho #include <stack> precisa ser includo em nosso pro-
grama. O tipo de dados stack<int> cria uma pilha de nmeros inteiros. Para especificar que
queremos a pilha representada com um list, utilizamos stack<int, list<int> >.
Considere a pilha de elementos abaixo.
1 stack < int > c ;
2 c . push (7);
3 c . push (7);
334 Captulo 22. Adaptadores de Container
4 c . push (2);
5 c . push (6);
Em uma pilha, s temos acesso ao elemento do topo de uma sequncia. Neste caso, o
elemento no topo da pilha o 6.
A funo push coloca um elemento no topo da pilha.
1 c . push (4);
A funo pop retira um elemento do topo da pilha.

1 c . pop ();
A funo top retorna o valor do elemento no topo da pilha.

1 cout << c . top () << endl ;
6
22.1 Stack 335

Internamente, um stack pode ser representado com um vector, deque ou list. Para um
vector ou deque, seu funcionamento muito similar.
Vimos como vector e deque so baseados em arranjos. Considere agora apenas o arranjo
de um vector ou um deque representando uma pilha com um elemento.
1 stack < int > c ;
2 c . push (2);
Quando inserimos mais um elemento no stack, os elementos so copiados para um arranjo

com o dobro do tamanho para colocar o novo elemento.
1 c . push (3);
2 3
Para inserir mais um elemento, um arranjo com o dobro do tamanho precisa novamente ser
alocado.
1 c . push (7);
2 3 7
Agora possvel inserir mais um elemento no topo da pilha sem aumentar o tamanho do
arranjo.
1 c . push (1);
2 3 7 1
Para inserir o elemento 4, um arranjo maior precisa ser novamente alocado.

1 c . push (4);
2 3 7 1 4
Ao remover elementos do topo do stack, um arranjo menor no necessariamente criado.

1 c . pop ();
2 3 7 1
1 c . pop ();
2 3 7
1 c . pop ();
2 c . pop ();
3 c . pop ();
Como estudamos na Seo 18.2, ao se remover um elemento de um arranjo de um vector ou

deque, os elementos no so fisicamente removidos do arranjo. No vector, apenas decrementa-
mos a varivel n que controla o nmero de elementos no container e no deque, decrementamos
a varivel tras que indica onde est o ltimo elemento do container no arranjo. Isto representa
um elemento sendo apagado do arranjo.
J quando colocamos elementos em um stack representado por um list, apenas uma clula
para este elemento alocada.
1 stack < int , list < int > > c ;
2 c . push (2);
Sempre que um elemento novo inserido, o espao exato para este elemento alocado.
1 c . push (3);
2 3
1 c . push (7);
2 3 7
Para cada elemento, porm, so alocados dois ponteiros, que acabam gastando memria
extra O(n).
22.2 Queue 337
1 c . push (1);
2 c . push (4);
2 3 7 1 4
Quando um elemento removido, a memria gasta com este elemento tambm desalocada.
Assim, no temos o processo de realocao de memria O(n) necessrio para um vector ou
deque. Todas as operaes de insero tm custo constante O(1).
1 c . pop ();
2 3 7 1
1 c . pop ();
2 c . pop ();
3 c . pop ();
No fim do processo, se no h elementos, nenhuma memria est sendo gasta.
22.2 Queue
O adaptador queue utilizado para representar filas de elementos. O que caracterizam filas
que elas permitem inseres (push) no fim da lista e retiradas do incio (pop). Como faremos
remoes no incio da sequncia, melhor implementar filas com um list ou deque. Por
padro, o C++ utiliza um deque. Em um queue, as funes front e back do acesso aos
primeiro e ltimo elementos.
22.2.1 Utilizao
Para utilizar um queue, o cabealho #include <queue> precisa ser includo. O tipo de dado
queue<int> utilizado para criar uma pilha de nmeros inteiros. Para especificar que queremos
a fila representada com um list, usamos queue<int, list<int> >.
A Figura 22.1 representa uma fila sendo representada por um queue. As funes para
insero e remoo de elementos tm a mesma sintaxe de um container stack. Porm, com
a funo push, novos elementos so sempre inseridos no fim da fila. Com a funo pop, os
elementos no incio da fila so removidos primeiro.
Diferentemente de um stack, onde a funo top acessava o elemento no topo da pilha,
temos as funes front e back em uma fila representada por um queue. A funo back retorna
o elemento do fim da fila. A funo front retorna o elemento do incio da fila.
back front
push
pop
Figura 22.1: Exemplo de uma fila sendo representada por um queue e suas principais funes.
Novos elementos so sempre inseridos no fim da fila. Os elementos no incio da fila so
removidos primeiro.

Como mencionamos, no se representa um queue com um vector pois este no tem uma funo
eficiente para remoo de seu primeiro elemento. Por exemplo, suponha o arranjo de um vector
ou um deque representando uma pilha com um elemento.
1 c . push (2);
Todas as etapas iniciais de insero funcionariam exatamente como em um stack. Quando

inserimos mais um elemento no stack, os elementos so copiados para um arranjo com o dobro
do tamanho para colocar o novo elemento.
1 c . push (3);
2 3
Para inserir mais um elemento, um arranjo com o dobro do tamanho precisa novamente ser
alocado.
1 c . push (7);
2 3 7
22.2 Queue 339
Agora possvel inserir mais um elemento no topo da pilha sem aumentar o tamanho do
arranjo.
1 c . push (1);
2 3 7 1
Para inserir o elemento 4, um arranjo maior precisa ser novamente alocado.

1 c . push (4);
2 3 7 1 4
Agora, ao se remover um elemento, aquele elemento que est na frente da fila removido.
Como o vector no tem uma operao O(1) para remover o primeiro elemento do container,
todos os elementos do container precisam ser deslocados.
1 c . pop ();
2 3 7 1 4
Este deslocamento resulta no primeiro elemento da fila removido. Porm, isto ocorre com
um alto custo O(n), o que torna o vector uma estrutura pouco apropriada para um queue.
1 c . pop ();
3 7 1 4
Na remoo do prximo elemento, todos os elementos so deslocados novamente, com um

custo O(n).
1 c . pop ();
7 1 4
A cada operao de remoo, um deslocamento O(n) executado.

1 c . pop ();
1 4
Deste modo, o vector uma estrutura muito ineficiente para queue.

1 c . pop ();
Assim, utilizando um vector para representar o queue, sempre que inserssemos um

elemento no container teramos um custo constante O(1) e cada remoo teria um custo O(n).
Para evitar este custo, mais comum se representar um queue com um deque. Considere
agora o arranjo de um deque que est representando um queue. Ao fim dos passos de insero,
teramos um arranjo igual ao do vector.
1 queue < int > c ;
2 c . push (2);
3 c . push (3);
4 c . push (7);
5 c . push (7);
6 c . push (1);
7 c . push (4);
2 3 7 1 4
Porm, em um deque, quando um elemento removido da frente da fila, os elementos no

so deslocados pois no deque apenas indicamos a posio na qual comea a fila.
1 c . pop ();
3 7 1 4
Isto se repete para as outras remoes.

1 c . pop ();
7 1 4
1 c . pop ();
1 4
1 c . pop ();
22.2 Queue 341
Assim, com um deque representando um queue, todas as operaes so O(1).

De outro modo, ao colocar elementos em um stack representado por um list, apenas uma
clula para este elemento alocada.
1 queue < int , list < int > > c ;
2 c . push (2);
1 c . push (3);
2 3
Para cada elemento, porm, so alocados dois ponteiros, que gastam memria extra O(n).
1 c . push (7);
2 c . push (1);
3 c . push (4);
2 3 7 1 4
Quando um elemento removido, ele removido diretamente do incio do list e a memria

gasta com este elemento desalocada.
1 c . pop ();
3 7 1 4
1 c . pop ();
2 c . pop ();
3 c . pop ();
Assim como em um deque, todas as operao so tambm O(1).

22.3 Priority queue

Os adaptadores de container priority_queue so utilizados para representar filas de priorida-
des. Estes tipos de fila permitem inserir elementos de maneira que o maior elemento do container
removido a cada chamada de pop. Ele pode ser implementado com um deque ou vector
(padro).
22.3.1 Utilizao
Assim como em outros adaptadores temos as funes push e pop para insero e remoo. A
funo push insere um elemento na fila de prioridade. A funo pop retira o maior elemento
(chamado de elemento de maior prioridade). A funo top consulta o elemento de maior
prioridade.
Para utilizar um priority_queue, o cabealho #include <queue> precisa ser includo.
O tipo de dados priority_queue<int> cria uma fila de prioridade com nmeros inteiros.

As filas de prioridade ficam sempre organizadas em forma de arranjo. Assim fica organizado o
arranjo de um vector que representa um queue.
11 10 7 9 5 6 4 8 2 3 1
Apesar de no estar ordenado, o primeiro elemento deste arranjo sempre o maior elemento
do container, no caso, o 11.
Este arranjo, na verdade, representa uma rvore chamada heap. O heap representado pelo
arranjo de modo que os filhos de um elemento na posio i estejam nas posies 2i+1 e 2i+2.
Ou seja, apesar dos elementos estarem no arranjo, eles representam a rvore abaixo.
11
10 7
9 5 6 4
8 2 3 1
Por exemplo, os filhos do elemento 11 da posio 0 do arranjo so 10 e 7, das posies 1 e 2

do arranjo. Os filhos do elemento 7, da posio 2, so 6 e 4, das posies 5 e 6.
Uma propriedade importante destas rvores heap que, apesar dos elementos no estarem
ordenados, os filhos de um elemento sempre so menores que o pai. Esta propriedade permite
que, caso o elemento de maior prioridade seja removido, o segundo maior elemento consegue
tomar seu lugar em tempo O(log n). Vejamos este processo.
1 c . pop ();
Para rearranjar o heap aps remover o elemento do topo, o ltimo elemento do heap toma o
lugar do elemento removido. Veja este processo no heap e no arranjo que o representa.
22.3 Priority queue 343
10 7
9 5 6 4
8 2 3
1 10 7 9 5 6 4 8 2 3
O elemento que tomou o lugar do maior elemento comparado com seus filhos e troca de
posio com maior deles.
10
1 7
9 5 6 4
8 2 3
10 1 7 9 5 6 4 8 2 3
Novamente, o elemento comparado com seus filhos e troca de posio com maior deles.
10
9 7
1 5 6 4
8 2 3
10 9 7 1 5 6 4 8 2 3
O processo se repete at que o elemento esteja em uma posio que respeita a condio de
ser maior que seus filhos.
10
9 7
8 5 6 4
1
8 2 3
10 9 7 8 5 6 4 1 2 3
Como o elemento pode trocar de posio uma vez para cada nvel da rvore e uma rvore
balanceada tem O(log n) nveis, o processo de remoo em uma fila de prioridade tem custo
O(log n).
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Algoritmos
0
23.
1 0 1
0 da 0STL
1
0
0 0
1
110 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 01 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Parte fundamental da STL so os seus algoritmos. Estes algoritmos podem ser utilizados para
executar operaes comuns a dados guardados em containers da STL como ordenao, busca,
cpia, somatrio, ou contagem.
Alm de nos poupar tempo de programao, estes algoritmos so usualmente implemen-
taes muito eficientes dos algoritmos que conhecemos. Assim, antes de implementar uma
operao bsica, sempre bom conferir se a STL j disponibiliza este algoritmo. O cabea-
lho <algorithm> inclui algoritmos comuns para containers. O cabealho <numeric> inclui
algoritmos comuns para dados numricos.
23.1 Algoritmos modificadores da STL

A Tabela 23.1 apresenta uma lista de alguns algoritmos modificadores e algoritmos para tarefas
importantes da STL. importante consultar a lista completa de funes na verso mais recente da
linguagem para consultar se h funes que implementam algum algoritmo que seja necessrio.
Um exemplo de funo muito utilizada no STL o sort. A funo sort ordena uma
sequncia de elementos, como no exemplo abaixo:
2 // ...
3 int nums [] = {32 ,71 ,12 ,45 ,26 ,80 ,53 ,33};
4 vector < int > v ( nums , nums +8);
5 // 32 71 12 45 26 80 53 33
6 // Ordenar elementos nas posi es entre begin () e begin ()+4
7 sort ( v . begin () , v . begin ()+4);
8 // (12 32 45 71) 26 80 53 33
9 // Ordenar elementos nas posi es entre begin () e end ()
10 sort ( v . begin () , v . end ());
11 // 12 26 32 33 45 53 71 80
12 // ...
346 Captulo 23. Algoritmos da STL
Funo Descrio
Modificadores de sequncia
copy Copia elementos
fill Preenche elementos com um valor
iter_swap Troca valores de objetos de dois iteradores
random_shuffle Embaralha os elementos
remove Remove valor da sequncia
replace Substitui valor na sequncia
reverse Reverte sequncia
rotate Rotaciona elementos da sequncia para esquerda
swap Troca o valor de dois objetos
transform Transforma sequncia com uma funo
unique Remove duplicatas em sequncia
Parties
partition Particiona sequncia em duas
Ordenao
sort Ordena elementos
stable_sort Ordena elementos com algoritmo estvel
partial_sort Ordena primeiros elementos
is_sorted Confere se elementos esto ordenados
Intercalao
merge Intercala duas sequncias ordenadas
Heap
make_heap Cria um heap da sequncia
push_heap Coloca elemento em um heap
pop_heap Retira elemento de um heap
is_heap Testa se sequncia um heap
Permutaes
next_permutation Transforma sequncia em sua prxima permutao
next_permutation Transforma sequncia em sua permutao anterior
Tabela 23.1: Lista de algoritmos modificadores e algoritmos para tarefas importantes da STL.
Neste exemplo, as sequncias nos comentrios representam o efeito da aplicao da funo.

Nas linhas 3 e 4, criamos uma sequncia em um arranjo e a copiamos para um vector chamado
v. A funo recebe sempre dois iteradores que representam a sequncia. Na linha 7, ordenamos a
sequncia formada pelos 4 primeiros elementos, entre os iteradores v.begin() e v.begin() +
4. Na linha 10, ordenamos a sequncia com todos os elementos, entre os iteradores v.begin()
e v.end().
Apesar de ter o mesmo comportamento assinttico O(n log n), o sort do STL faz uma
ordenao que ainda mais eficiente do que um quicksort. A Figura 23.1 compara o tempo gasto
por estes algoritmos.
J a Figura 23.2 apresenta a proporo de tempo entre os dois algoritmos. O quicksort
quase 4 vezes mais lento em arranjos pequenos e quase 50% mais lento em arranjos maiores.
O algoritmo fill coloca o valor passado como parmetro em toda uma sequncia de
elementos.
23.1 Algoritmos modificadores da STL 347
5 3
x 10 x 10
3.5 7
Quicksort Quicksort
STL Sort STL Sort
3 6
2.5 5
Tempo (segundos)
Tempo (segundos)
2 4
1.5 3
1 2
0.5 1
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 23.1: Tempo necessrio pelos algoritmos do STL e por uma implementao eficiente do
quicksort para se ordenar um arranjo com ordem inicial aleatria.
4 4
Quicksort Quicksort
STL Sort STL Sort
3.5 3.5
3 3
Tempo (em proporo ao STL Sort)
Tempo (em proporo ao STL Sort)
2.5 2.5
2 2
1.5 1.5
1 1
0.5 0.5
0 0
0 100 200 300 400 500 600 700 0 1 2 3 4 5 6 7 8 9 10
4
Figura 23.2: Proporo de tempo necessrio pelos algoritmos do STL e por uma implementao
eficiente do quicksort para se ordenar um arranjo com ordem inicial aleatria.

2 // ...
3 vector < char > letras (10);
4 fill ( letras . begin () , letras . end () , B );
5 // B B B B B B B B B B
6 imprimeContainer ( letras );
7 // Colocar A nos 5 elementos a partir de begin ()
8 fill_n ( letras . begin () ,5 , A );
9 // A A A A A B B B B B
10 imprimeContainer ( letras );
11 // ...
Na linha 4 do exemplo, a letra B colocada em todas as posies da sequncia, entre os

elementos apontados pelos iteradores letras.begin() e letras.end(). Na linha 8, a funo
fill_n coloca a letra A nas 5 posies a partir do primeiro elemento letras.begin().
O algoritmo remove remove elementos que tenham o valor passado como parmetro em
toda uma sequncia de elementos.
2 // ...
3 int nums [] = {32 ,71 ,33 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 33 45 33 80 53 33
6 // Remover as ocorr ncias de 33 entre begin () e end ()
7 remove ( v . begin () , v . end () , 33);
8 // 32 71 45 80 53
9 imprimeContainer ( v );
10 // ...
Na linha 7 do exemplo, todos os elementos com valor 33 so removidos da sequncia.
Considera-se toda a sequncia, entre os iteradores v.begin() e v.end().
O algoritmo replace substitui o valor de todos os elementos que tenham o valor passado
como parmetro em toda uma sequncia de elementos.
2 // ...
3 int nums [] = {32 ,71 ,33 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 33 45 33 80 53 33
6 // Substitui ocorr ncias de 33 por 100
7 replace ( v . begin () , v . end () , 33 , 100);
8 // 32 71 100 45 100 80 53 100
10 // ...
Na linha 7 do exemplo, todos os elementos com valor 33 so substitudos por elementos de
valor 100. Considera-se toda a sequncia, entre os iteradores v.begin() e v.end().
O algoritmo random_shuffle embaralha uma sequncia de elementos.
2 // ...
3 int nums [] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8};
5 // 1 2 3 4 5 6 7 8
6 // Embaralha elementos entre begin () e end ()
7 random_shuffle ( v . begin () , v . end ());
8 // 6 4 8 2 3 5 1 7
10 // ...
Na linha 7 do exemplo, todos os elementos da sequncia so embaralhados, entre os iteradores
v.begin() e v.end().
23.2 Algoritmos no modificadores da STL

A Tabela 23.2 apresenta uma lista de alguns algoritmos no modificadores da STL. importante
consultar a lista completa de funes na verso mais recente da linguagem para consultar se h
funes que implementam algum algoritmo que seja necessrio.
O algoritmo equal testa se duas sequncias de elementos so iguais.
23.2 Algoritmos no modificadores da STL 349
Funo Descrio
No modificadores de sequncia
count Conta elementos com certo valor
count_if Conta elementos com certa condio
equal Testa se duas sequncias so iguais
find Procura elemento com busca sequencial
find_if Procura elemento que respeita condio
search Procura subsequncia
Min / Max
min Retorna o menor de 2 elementos
max Retorna o maior de 2 elementos
minmax Retorna o menor e o maior entre 2 elementos
min_element Retorna o menor de uma sequncia
max_element Retorna o maior de uma sequncia
minmax_element Retorna o menor e o maior de uma sequncia
Busca binria
lower_bound Busca primeira ocorrncia de elemento
upper_bound Busca ltima ocorrncia de elemento
binary_search Testa se elemento existe
Tabela 23.2: Lista de algoritmos no modificadores para tarefas importantes da STL.

2 // ...
3 vector < int > v1 (5 ,10); // 10 10 10 10 10
4 vector < int > v2 (5 ,10); // 10 10 10 10 10
5 // compara duas sequ ncias de valores
6 bool resultado = equal ( v1 . begin () , v1 . end () , v2 . begin ());
7 if ( resultado ){
8 cout << " Os vetores t m os mesmos valores " << endl ;
9 } else {
10 cout << " Os vetores s o diferentes " << endl ;
11 }
12 // ...
Na linha 6 do exemplo, a sequncia entre os iteradores v1.begin() e v2.end() comparada
com a sequncia que inicia no iterador v2.begin(). O resultado testado na linha 7 e se imprime
uma mensagem.
O algoritmo find procura um elemento em uma sequncia.
2 // ...
3 int nums [] = {32 ,71 ,12 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 12 45 33 80 53 33
6 vector < int >:: iterator r ;
7 // Procura elemento 12 e retorna iterador para ele
8 r = find ( v . begin () , v . end () , 12);
9 // Se o elemento foi encontrado
10 if ( r != v . end ()){
11 // Elemento : 12
12 cout << " Elemento : " << * r << endl ;
13 // Posi o : 2
14 cout << " Posi o : " << r - v . begin () << endl ;
15 }
16 // ...
Na linha 8 do exemplo, procuramos o elemento 12 na sequncia formada entre os iteradores
v.begin() e v.end(). O resultado um iterador que aponta para o elemento procurado. Se o
elemento no for encontrado, um iterador para v.end() retornado. Na linha 10 testamos se o
elemento foi realmente encontrado. Caso sim, o elemento impresso nas linhas 12 e 14.
O algoritmo binary_search retorna se um elemento est presente em uma sequncia.
2 // ...
3 int nums [] = {32 ,71 ,12 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 12 45 33 80 53 33
6 vector < int >:: iterator r ;
7 // Ordena os elementos entre begin () e end ()
8 sort ( v . begin () , v . end ());
9 // 12 32 33 33 45 53 71 80
10 // Se o elemento foi encontrado
11 if ( binary_search ( v . begin () , v . end () , 12)){
12 cout << " Elemento encontrado " << endl ;
13 }
14 // ...
Na linha 8 do exemplo, os elementos da sequncia so ordenados para permitir uma busca
binria. Na linha 11, procuramos o elemento 12 na sequncia formada entre os iteradores
v.begin() e v.end(). O valor retornado pela funo um bool que j utilizado para imprimir
uma mensagem. Para se encontrar um iterador para o elemento, as funes lower_bound e
upper_bound devem ser utilizadas.
O algoritmo count retorna quantos elementos com um dados valor existem na sequncia.
2 // ...
3 int nums [] = {32 ,71 ,33 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 33 45 33 80 53 33
6 // Conta quantas ocorr ncias de 33 entre begin () e end ()
7 int r = count ( v . begin () , v . end () , 33);
8 cout << r << " n meros 33 " << endl ;
9 // 3 n meros 33
10 // ...
Na linha 7 do exemplo, contamos quantos elementos da sequncia formada entre os iteradores
v.begin() e v.end() so iguais a 33.
O algoritmo min_element retorna um iterador para o menor elemento de uma sequncia.
2 // ...
23.3 Algoritmos numricos da STL 351
3 int nums [] = {32 ,71 ,12 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 12 45 33 80 53 33
6 // Procura o menor elemento entre begin () e end ()
7 int r = * min_element ( v . begin () , v . end ());
8 cout << " Menor elemento : " << r << endl ;
9 // Menor elemento : 12
10 // ...
Na linha 7 do exemplo, a funo retorna um iterador para o menor elemento da sequncia.
Utilizamos o operador * para atribuirmos o valor apontado por este iterador na varivel r.
De modo anlogo, o algoritmo max_element retorna um iterador para o maior elemento de
uma sequncia.
2 // ...
3 int nums [] = {32 ,71 ,12 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 12 45 33 80 53 33
6 // Procura o maior elemento entre begin () e end ()
7 int r = * max_element ( v . begin () , v . end ());
8 cout << " Maior elemento : " << r << endl ;
9 // Maior elemento : 80
10 // ...
23.3 Algoritmos numricos da STL

A Tabela 23.3 apresenta uma lista de alguns algoritmos numricos da STL. Estes algoritmos so
utilizados para dados aritmticos.
Funo Descrio
Numricas
accumulate Somatrio de elementos
inner_product Produto interno
partial_sum Somas parciais
adjacent_difference Diferena adjacente
iota Atribui sequncia crescente de nmeros
Tabela 23.3: Lista de algoritmos no modificadores para tarefas importantes da STL.
Como exemplo de algoritmo numrico, a funo accumulate faz um somatrio de toda uma
sequncia de valores.
1 # include < numeric >
2 // ...
3 int nums [] = {32 ,71 ,12 ,45 ,33 ,80 ,53 ,33};
5 // 32 71 12 45 33 80 53 33
6 // Soma todos os elementos do vector iniciando somat rio com 0
7 int r = accumulate ( v . begin () , v . end () , 0);
8 cout << " Somat rio : " << r << endl ;
9 // Somat rio : 359

10 // ...
Na linha 7 do exemplo, fazemos um somatrio com todos os elementos da sequncia entre
os iteradores v1.begin() e v2.end(). Este somatrio e iniciado em 0. O resultado, atribudo a
r, impresso na linha 8.
23.4 Exerccios
Exerccio 23.1 Veja o cdigo abaixo. Ao complet-lo codigo abaixo, vamos implementar o
jogo de cartas 21. Neste jogo, h uma pilha com todas as cartas do baralho (stack). Cada
carta sera representada com um numero de 1 a 13 (1 = A, 11=J, 12=Q, 13=K). O naipe no
ser representado pois no relevante.
A cada passo, o jogador pode tirar uma carta da pilha e colocar em seu conjunto de cartas
(em outro container) ou parar de jogar. O somatrio dos valores das cartas em sua mo sua
pontuao mas o jogador perde o jogo se o somatrio ultrapassar 21.
Analise o cdigo abaixo, que est incompleto.
5 # include < stack >
7
9
10 void imprimeCarta ( int const & x );
11
12 template < typename T > // fun o que imprime container
13 void imprimeBaralho ( T const & x );
14
15 int main ()
16 {
17 // cria um container vetor com as cartas
18 vector < int > x ;
19 // Aloca espa o para 13*4 elementos
20 x . reserve (13*4);
21 int i ;
22
23 // Coloca 4 vezes cada numero de 1 a 13 no baralho
24 for ( i =1; i <13; i ++){
25 x . push_back ( i );
29 }
30
31 cout << " Cartas do baralho : " << endl ;
32 imprimeBaralho ( x );
23.4 Exerccios 353
33
34 // Embaralha e imprime
35 cout << " Embaralhando : " << endl ;
36 random_shuffle ( x . begin () , x . end () );
37 imprimeBaralho ( x );
38
39 // Cria uma pilha vazia
40 stack < int > pilha ;
41
42 // Fa a a pilha receber as cartas do baralho aqui
43 // Use a funcao push para colocar algo na pilha
44
45 vector < int > cartas ;
46
47 // Menu com op es
48 string opcao ;
49 do {
50 cout << " Suas cartas s o : " << endl ;
51 imprimeBaralho ( cartas );
52
53 // Mostra o menu
54 cout << endl ;
55 cout << " [1] Puxar mais uma carta da pilha " << endl ;
56 cout << " [0] Sair do jogo " << endl ;
57 cout << " Digite uma op o : " ;
58
59 // L uma op o
60 cin >> opcao ;
61
62 // executa uma fun o de acordo com a op o
63 if ( opcao == " 1 " ){
64 cout << " Puxando mais uma carta " << endl ;
65 // Implemente este trecho
66 cout << " C digo n o implementado " << endl ;
67 } else if ( opcao == " 0 " ){
68 cout << " Saindo do programa " << endl ;
69 } else {
70 cout << " Opcao invalida " << endl ;
71 }
72 } while ( opcao != " 0 " );
73
74 cout << " Fim de jogo " << endl ;
75 // Implemente este trecho
76 cout << " C digo n o implementado " << endl ;
77
78 return 0;
79 }
80
81 void imprimeCarta ( int const & x ){
82 if ( x ==1){
83 cout << " A " ;
84 } else if (x <11){
85 cout << x << " " ;
86 } else if ( x ==11) {
87 cout << " J " ;
88 } else if ( x ==12) {
89 cout << " Q " ;
90 } else if ( x == 13) {
91 cout << " K " ;
92 }
93
94 }
95
97 void imprimeBaralho ( T const & x )
98 {
99 if ( x . empty ()){
101 return ;
102 }
103 // iterator que vai percorrer x
104 typename T :: const_iterator pos ;
105 // iterador que aponta para a posi o final
106 typename T :: const_iterator end ( x . end ());
107 for ( pos = x . begin (); pos != end ; ++ pos ) {
108 imprimeCarta (* pos );
109 }
110 cout << endl ;
111 }

Exerccio 23.2 Logo aps a criao de uma pilha vazia, faa com que ela receba todas as
cartas do baralho em x.
Exerccio 23.3 O vector cartas receber os elementos que o jogador retirar da pilha.
Implemente a retirada de uma carta da pilha e sua insercao no vector cartas quando o jogador
pedir.
Exerccio 23.4 Quando o jogador no quiser mais retirar cartas, ele utilizar a opcao == 0
e sair do for. Quando isto ocorrer, implemente o trecho de cdigo que mostrar a pontuao
final do jogador. Se a soma ultrapassar 21, dever ser emitida uma mensagem que ele perdeu
o jogo. Utilize a funo accummulate.
Exerccio 23.5 Qual a vantagem da utilizao de uma pilha stack em vez de se representar
a pilha de cartas com um container de sequncia?
23.4 Exerccios 355
Exerccio 23.6 Qual a vantagem da utilizacao do header <algorithm>?
Exerccio 23.7 No jogo real de 21, as cartas K, J, Q e 10 (representadas por 10, 11, 12, 13)
valem 10. As cartas A (representadas aqui por 1) podem valer 1 ou 11. Faa esta alterao no
programa na hora do resultado final. O jogador receber a maior pontuao possvel para seu
conjunto de cartas. Dica: Utilize a funo replace para alterar as cartas K, J e Q, que devem
valer 10. Considere que um A vale 1 e conte o nmero de As (funo count). Troque estes
As que valem 1 por As iguais a 10 enquanto tenhamos menos que 21.
IV
Programao Orientada a
Objetos
24 Classes e Instncias de Objetos . . . . . 359
25 Definindo classes . . . . . . . . . . . . . . . . . . . 367
26 Relaes entre objetos . . . . . . . . . . . . . 377
27 Recursos de Objetos . . . . . . . . . . . . . . . . 385

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Classes
0
24.
1 0 e Instncias
1
0 0 1
0 1 Objetos
0
de 00
1
110 1
0
1 0
0
110 0
1
1 0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
24.1 Introduo
Temos estudado at o momento o que chamamos de programao estruturada. Em programa-
o estruturada, o fluxo no qual ocorrem os comandos tem a maior importncia. O foco est na
ordem das aes. assim que temos trabalhado at agora.
A Figura 24.1 apresenta uma representao em diagrama de programas baseados em pro-
gramao estruturada. Nestes programas, seguimos um fluxo de aes, que pode ser totalmente
sequencial ou alterado por desvios e laos.
J na programao orientada a objetos (POO), a nossa preocupao com os objetos
que tm atributos e aes. Dados os objetos, nos preocupamos em determinar como eles se
comportam e no em um fluxo geral de aes. Queremos saber como cada objeto e o que faz
cada objeto.
A Figura 24.2 apresenta uma representao em diagrama de objetos utilizados em um
programa para representar animais. Nestes programas, as caractersticas dos objetos e relaes
entre objetos so mais importantes do que um fluxo de comandos.
No exemplo apresentado, temos 3 objetos: Animal, Cachorro e Ovelha. Os objetos Cachorro
e Ovelha so apenas tipos de objeto do tipo Animal. Cachorro e Ovelha tm suas caractersticas
e comportamentos especficos.
24.2 Classes e Instncias de Objetos

Para criar objetos em um programa, devemos definir primeiro novas classes de objetos. As
classes so utilizadas para definir como so objetos de um certo tipo.
A relao entre classes (que tm a palavra-chave class) e um struct (como os que
estudamos na Seo 10) bem direta. Assim podemos criar um struct que representa um
retngulo.
1 struct Retangulo {
2 int largura , altura ;
3 };
360 Captulo 24. Classes e Instncias de Objetos
Comandos
Comandos
Comandos
Comandos
Comandos Comandos
Comandos
Comandos
Comandos
Comandos
Comandos
Figura 24.1: Representao em diagrama de programao estruturada.
Cada retngulo tem dois atributos: largura e altura. Com a definio deste struct
poderamos criar dados do tipo Retangulo. Atravs da instruo class, poderamos definir o
mesmo tipo de dado da seguinte maneira:
1 class Retangulo {
2 public :
4 };
Para criar um novo tipo de dados definindo uma class, devemos dizer que os membros da
classe so pblicos para que eles sejam acessveis. Isto foi feito na linha 2 com a palavra-chave
public. Sem a palavra chave public, os membros da classe seriam considerados privados e no
seriam acessveis. Isto um conceito importante em POO. Em um struct, todos os membros
so considerados pblicos por padro.
Nos objetos, alm de variveis, podemos ter funes como membros de uma classe. As
funes representam comportamentos de uma classe de objetos. Podemos ter alguns comporta-
mentos comuns a retngulos:
1 class Retangulo {
3 public :
4 void set_valores ( int , int );
5 int area () { return largura * altura ;}
6 };
Nas linhas 4 e 5, definimos 2 funes pblicas relativas a retngulos. Definimos compor-
tamentos relativos a retngulos. Na linha 2, definimos atributos de um retngulo. Note que os
atributos na linha 2 no so pblicos pois so definidos antes da palavra-chave public. Podemos
ter em um objeto membros pblicos e privados ao mesmo tempo. Neste exemplo, temos membros
pblicos e privados: comportamentos pblicos e atributos privados.
24.2 Classes e Instncias de Objetos 361
Animal
branco
e marrom
branca
Cachorro Ovelha e preta
Consegue
latir
Consegue correr Consegue correr
(mais devagar) (mais rpido)
Na verdade, comum deixar explcito quais so os membros privados. Para isto usamos a
palavra-chave private.
1 class Retangulo {
2 public :
4 int area () { return largura * altura ;}
5 private :
7 };
Com isto, deixamos os membros privados no fim da definio, o que interessante pois
as pessoas esto normalmente mais interessadas nos membros que elas podem acessar em um
objeto.
As funes do prprio objeto, claro, so as nicas que tm acesso aos membros privados
deste objeto. Como os atributos do retngulo no esto acessveis, podemos utilizar a funo
pblica set_valores para determinar os valores de largura e altura. Isto uma prtica
muito comum pois podemos usar a funo para validar os valores inseridos para largura e
altura. Podemos, por exemplo, verificar se so valores maiores que zero.
Note tambm que, na linha 3, apenas o cabealho da funo est definido no objeto. A
implementao da funo deve vir depois.
Na linha 4, temos a definio da funo area. Esta funo utiliza os atributos conhecidos
para retornar a rea do retngulo. Como esta uma funo simples, sua implementao j consta
no objeto.
Note com a funo area, como a orientao a objetos pode ser til para agregar nos
retngulos as funes que so associadas apenas a retngulos.
Inclumos no cdigo em seguida tambm a definio da funo set_valores. A sintaxe
Retangulo::set_valores utilizada para especificar fora da definio da classe que a funo
sendo implementada pertence classe Retangulo.
1 class Retangulo {
2 public :
4 int area () { return ( largura * altura );}

5 private :
7 };
8
9 void Retangulo :: set_valores ( int x , int y ) {
10 largura = x ;
11 altura = y ;
12 }
24.3 Instanciando objetos

Neste exemplo completo, definimos e criamos um objeto Retangulo e imprimimos sua rea.
2
4
5 class Retangulo {
6 public :
9 private :
11 };
12
14 largura = x ;
15 altura = y ;
16 }
17
18 int main (){
19 Retangulo r ;
20 r . set_valores (3 ,4);
21 cout << " A rea de r " << r . area () << endl ;
22 return 0;
23 }
Entre as linhas 5 e 16 temos a definio completa da classe Retangulo. Como podem existir
vrios retngulos diferentes, definimos aqui uma classe de objetos.
Na linha 19, criamos um retngulo r que ainda no tem seus atributos inicializados. Dizemos
que o objeto r uma instncia da classe de objetos Retangulo.
Na linha 20, a funo set_valores do retngulo utilizada para inicializar sua largura
com 3 e altura com 4.
Na linha 21, a prpria funo area do retngulo utilizada para imprimir a rea.
A rea de r 12
Note que funo area no recebe parmetros pois tudo que ela precisa dos prprios
atributos internos do retngulo r.
24.4 Ponteiros para objetos 363
Vejamos agora um exemplo com dois retngulos a e b.

2
4
5 class Retangulo {
6 public :
9 private :
11 };
12
14 largura = x ;
15 altura = y ;
16 }
17
18 int main (){
19 Retangulo a , b ;
20 a . set_valores (3 ,4);
21 b . set_valores (4 ,5);
22 cout << " A rea de a " << a . area () << endl ;
23 cout << " A rea de b " << b . area () << endl ;
24 return 0;
25 }
Os retngulos so definidos na linha 19 e recebem valores nas linhas 20 e 21. Nas linhas 22
e 23, as respectivas reas so impressas.
A rea de a 12
A rea de b 20
24.4 Ponteiros para objetos

Assim como fizemos em um struct, podemos tambm criar ponteiros e alocar memria para
um objeto.
2
4
5 class Retangulo {
6 public :
9 private :
11 };
12
14 largura = x ;
15 altura = y ;
16 }
17
18 int main (){
19 Retangulo a ;
20 Retangulo * b = new Retangulo ();
21 a . set_valores (3 ,4);
22 b - > set_valores (4 ,5); // ou (* b ). set_valores (4 ,5);
23 cout << " A rea de a " << a . area () << endl ;
24 cout << " A rea de * b " < area () << endl ;
25 delete b ;
26 b = nullptr ;
27 return 0;
28 }
Na linha 20, criamos um ponteiro para Retangulo chamado b. Alocamos dinamicamente
um Retangulo na memria e fazemos com que b aponte para ele.
Assim como se pode fazer em um struct, podemos utilizar o operador de seta -> em objetos
para acessar um membro de um objeto apontado. Isto feito na linha 22. Veja como o operador
de seta da linha 22 equivale a retornar o valor apontado por b com o operador * e depois acessar
um membro.
Na linha 24, utilizamos novamente o operador de seta para imprimir a rea do Retangulo
apontado por b.
A rea de a 12
A rea de *b 20
24.5 Arranjos de objetos

Como qualquer outro tipo de dado, podemos tambm criar arranjos de objetos.
2
4
5 class Retangulo {
6 public :
9 private :
11 };
12
14 largura = x ;
15 altura = y ;
16 }
24.5 Arranjos de objetos 365
17
18 int main (){
19 Retangulo a [2];
20 a [0]. set_valores (3 ,4);
21 a [1]. set_valores (4 ,5);
22 cout << " A rea de a [0] " << a [0]. area () << endl ;
24 return 0;
25 }
Na funo deste exemplo, trabalhamos com a[0] e a[1], que guardam dois retngulos
diferentes.
A rea de a[0] 12
A rea de a[1] 20
Podemos tambm alocar arranjos de objetos dinamicamente.

2
4
5 class Retangulo {
6 public :
9 private :
11 };
12
14 largura = x ;
15 altura = y ;
16 }
17
18 int main (){
19 Retangulo * a = new Retangulo [2];
20 a [0]. set_valores (3 ,4);
21 a [1]. set_valores (4 ,5);
24 return 0;
25 }
Neste exemplo, temos o ponteiro a que apontando para o endereo onde comea um arranjo
de dois retngulos na memria. Para todos os outros efeitos, o operador de subscrito []
utilizado para acessar os elementos do arranjo.
A rea de a[0] 12
A rea de a[1] 20
24.6 POO em sistemas complexos

Como vimos, a POO serve para modelar sistemas mais complexos. J que o mundo rodeado de
objetos, o conceito de objeto til para modelagem de coisas reais. Na POO, devemos modelar
quais so os atributos (variveis) e quais so os comportamentos (funes) de um objeto.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Definindo
0
25.
1 01
0 0 1
classes
0
0 0
1
110 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 01 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
H vrias prticas comuns e recursos para definio de objetos. Nesta seo veremos algumas
delas.
25.1 Contrutores
Quando um objeto criado, uma funo construtora chamada. Chamamos esta funo de
construtor. Esta funo constri o objeto dando valores iniciais a seus atributos. Para definir o
construtor, criamos uma funo com o mesmo nome da classe.
2
4
5 class Retangulo {
6 public :
7 Retangulo ( int , int );
9 private :
11 };
12
13 Retangulo :: Retangulo ( int a , int b ) {
14 largura = a ;
15 altura = b ;
16 }
17
18 int main () {
19 Retangulo ra (3 ,4);
20 Retangulo rb (5 ,6);
368 Captulo 25. Definindo classes
21 cout << " A rea de ra " << ra . area () << endl ;

22 cout << " A rea de rb " << rb . area () << endl ;
23 return 0;
24 }
Ne linha 7 do exemplo, nosso objeto tem agora uma funo construtora que recebe dois
nmeros inteiros. Na implementao da funo construtora, nas linhas 13 a 16, guardamos o
primeiro parmetro recebido como largura e o segundo como altura.
Na funo principal, nas linhas 19 e 20, ao criar um objetos do tipo Retangulo, os parmetros
para o construtor j devem ser passados.
Nas linhas 21 e 22, como os objetos ra e rb j foram construdos com os valores de altura
e largura, j podemos imprimir a rea sem utilizao de uma funo como set_valores.
A rea de ra 12
A rea de rb 30
25.2 Sobrecarga de construtores

Podemos tambm sobrecarregar construtores. Assim temos diferentes verses que dependem
dos parmetros.
2
4
5 class Retangulo {
6 public :
7 Retangulo ();
10 private :
12 };
13
14 Retangulo :: Retangulo () {
15 largura = 5;
16 altura = 5;
17 }
18
20 largura = a ;
21 altura = b ;
22 }
23
24 int main () {
26 Retangulo rb ;
27 cout << " rea de ra : " << ra . area () << endl ;
28 cout << " rea de rb : " << rb . area () << endl ;
29 return 0;
25.2 Sobrecarga de construtores 369
30 }
No primeiro construtor, implementado nas linhas 14 a 17, se nenhum parmetro passado, o
Retangulo criado com altura e largura iguais a 5. No segundo construtor, implementado
nas linhas 19 a 22, se os parmetros so passados, eles so atribudos aos membros.
Criamos ento neste exemplo um retngulo com cada construtor. Na linha 25, utilizamos
o construtor que recebe dois parmetros e, na linha 26, utilizamos o construtor que no recebe
parmetros.
A rea de ra: 12
A rea de rb: 25
Podemos criar quantas sobrecargas quisermos. Precisamos apenas que cada sobrecarga
dependa de uma combinao diferente de parmetros.
2
4
5 class Retangulo {
6 public :
7 Retangulo ();
8 Retangulo ( int );
11 private :
13 };
14
15 Retangulo :: Retangulo () {
16 largura = 5;
17 altura = 5;
18 }
19
20 Retangulo :: Retangulo ( int a ) {
21 largura = a ;
22 altura = a ;
23 }
24
26 largura = a ;
27 altura = b ;
28 }
29
30 int main () {
31 Retangulo ra (3);
32 Retangulo rb = 4;
35 return 0;
36 }
Neste exemplo, se apenas um parmetro passado, ele atribudo tanto altura quanto
largura, como definido nas linhas 20 a 23. Nas linhas 31 e 32 utilizamos apenas este construtor
para definir novos retngulos. Como vimos, o parmetros ou os parmetros devem ser passados
para o objeto em sua criao, como fizemos na linha 31.
Construtores com apenas um parmetro so interessantes pois podem ser utilizados para
atribuir um tipo de dado a outro. Neste exemplo, atribumos um int em Retangulo na linha 32.
A converso feita pelo construtor de apenas um parmetro.
A rea de ra: 9
A rea de rb: 16
25.2.1 Construtor de Cpia

Outro tipo comum de construtor o construtor de cpia.

2
4
5 class Retangulo {
6 public :
8 Retangulo ( const Retangulo &);
10 private :
12 };
13
15 largura = a ;
16 altura = b ;
17 }
18
19 Retangulo :: Retangulo ( const Retangulo & direita ) {
20 largura = direita . largura ;
21 altura = direita . altura ;
22 }
23
24 int main () {
26 Retangulo rb = ra ;
29 return 0;
30 }
Este construtor recebe outro elemento do mesmo tipo e faz uma cpia, como definido nas
linhas 19 a 22 e utilizado na linha 26.
25.3 Sobrecarga de operadores 371
A rea de ra: 12
A rea de rb: 12
25.3 Sobrecarga de operadores

Existe a possibilidade de se somar, dividir ou comparar dois objetos. A sobrecarga de operadores
define o que fazer quando so chamados os operadores para uma classe sendo definida.
Neste exemplo, criamos uma funo nos permitir somar dois retngulos.
2
4
5 class Retangulo {
6 public :
8 Retangulo operator + ( const Retangulo &);
10 private :
12 };
13
15 largura = a ;
16 altura = b ;
17 }
18
19 Retangulo Retangulo :: operator + ( const Retangulo & direita ) {
20 Retangulo temp ( largura + direita . largura , altura + direita . altura );
21 return temp ;
22 }
23
24 int main () {
27 Retangulo rc = ra + rb ;
28 cout << " rea de rc : " << rc . area () << endl ;
29 return 0;
30 }
Dado um retngulo, o operador de soma deve receber um segundo retngulo e retornar um
terceiro. Para definir a funo de soma, utilizaremos operator+ como nome da funo. Esta
definio est na linha 8 do exemplo.
Esta operao de soma receber como parmetro um outro Retangulo ao qual a instncia da
classe ser somada. O tipo de dado de retorno tambm Retangulo, pois o resultado da soma
ser um outro retngulo.
Na linha 19 iniciamos a implementao da funo. Na linha 20, um novo Retangulo
chamado temp construdo com a soma das larguras e alturas do prpria retngulo e do retngulo
recebido como parmetro. Na linha 21, este retngulo temp retornado como resultado da soma
de dois retngulos.
Na funo principal, nas linnhas 25 a 27, usamos estes recursos para criar um retngulo rc
como a soma de ra e rb.
rea de rc: 63
Neste segundo exemplo, usamos o recurso de sobrecarga de operadores para podermos

comparar dois retngulos de acordo com suas reas.
2
4
5 class Retangulo {
6 public :
8 bool operator < ( Retangulo & dir ) { return area () < dir . area ();}
10 private :
12 };
13
15 largura = a ;
16 altura = b ;
17 }
18
19 int main () {
22 if ( ra < rb ){
23 cout << " A rea de ra menor que a de rb " << endl ;
24 } else {
25 cout << " A rea de rb menor que a de ra " << endl ;
26 }
27 return 0;
28 }
O operador< definido na linha 8 do exemplo e retorna um bool indicando se a rea do
retngulo maior que a rea do retngulo recebido como parmetro.
Na linha 22 da funo principal, o operador< retorna um bool de acordo com a rea dos
retngulos ra e rb. O resultado impresso em um cout nas linhas 23 ou 25.
A rea de ra menor que a de rb
25.4 Setters e Getters

Os setters e getters so as funes que atribuem ou retornam atributos de um objeto. Os atributos
do objeto usualmente ficam privados enquanto as funes fazem o papel de acesso. Esta prtica
deixa o objeto menos propenso a erros do que se deixssemos os atributos como pblicos. No
exemplo seguinte, temos vrias funes deste tipo.
25.4 Setters e Getters 373
1 class Retangulo {
2 public :
4 void setAltura ( int x );
5 void setLargura ( int x );
6 int getAltura () { return altura ;}
7 int getLargura () { return largura ;}
9 private :
11 };
12
14 setAltura ( a );
15 setLargura ( b );
16 }
17
18 void Retangulo :: setAltura ( int x ) {
19 if ( x >=0){
20 altura = x ;
21 } else {
22 altura = 0;
23 }
24 }
25
26 void Retangulo :: setLargura ( int x ) {
27 if ( x >=0){
28 largura = x ;
29 } else {
30 largura = 0;
31 }
32 }
Na nova classe temos 2 setters e 2 getters que servem para enviar e receber valores relativos
s variveis. Estas funes esto definidas nas linhas 4 a 7. Os getters, definidos nas linhas 6 e 7,
simplesmente retornam os valores de altura e largura.
As funes setters que do valores aos atributos so definidas nas linhas 18 a 32, conferem
se os valores so maiores do que zero pois a altura e largura de um retngulo no podem ser
valores negativos.
J a funo construtora, definida nas linhas 13 a 16, que define os valores iniciais de altura
e largura, utiliza os prprios setters para garantir que os valores sero vlidos.
Considere agora uma funo main que utiliza este Retangulo:
1 int main () {
4 ra . setAltura (4);
5 ra . setLargura (7);
7 ra . setAltura (3);
8 ra . setLargura ( -5); // tentando passar um valor inv lido

10 return 0;
11 }
Na funo principal, nas linha 8, tentamos atribuir valores invlidos para um retngulo mas a
funo no nos permite. Apenas os valores vlidos so atribudos.
A utilizao de getters e setters tem vrias vantagens:
Se for necessrio alterar vrias variveis no objeto, o usurio da classe no precisa fazer
isto diretamente.
Os dados enviados pelo usurio podem ser sempre validados.
O cdigo do usurio continua vlido se for alterado como o setter funcionar. Isso por
envolver uma troca de estrutura de dados interna, por exemplo.
O modo como o objeto est sendo representado fica oculto.
25.5 Destrutores
Alm dos construtores, podemos definir quais comandos sero executados quando um objeto
for destrudo. Pode parecer estranho alterar valores do objetos ou fazer aes quando no
precisaremos mais dos objetos, mas isto especialmente importante para evitar vazamento de
memria quando destrumos objetos que haviam alocado espao na memria.
Suponha uma classe utilizada para representar listas de nmeros inteiros em um arranjo.
Como no sabemos qual ser o tamanho da lista, utilizaremos alocao dinmica de memria.
1 class Lista {
2 public :
3 Lista ( int );
4 void setElemento ( int pos , int x ) { px [ pos -1] = x ;}
5 int getElemento ( int pos ) { return px [ pos -1];}
6 private :
7 int * px ;
8 int tamanho ;
9 };
10
11 Lista :: Lista ( int n ){
12 tamanho = n ;
14 for ( int i = 0; i < n ; i ++){
15 px [ i ] = i +1;
16 }
17 }
Entre os atributos da lista, definidos nas linhas 7 e 8, um ponteiro px apontar para o arranjo
alocado na memria e um outro membro guardar o tamanho do arranjo alocado, que tambm
o tamanho da lista.
O construtor declarado na linha 3 recebe o tamanho da lista de elementos. Em sua imple-
mentao, nas linhas 11 a 17, o construtor aloca um arranjo do tamanho pedido nas linhas 12 e
13, e d valores de 1 a n para os elementos da lista, nas linhas 14 a 16.
Os setters e getters das linhas 4 e 5 retornam o elemento em uma posio da lista. A funo
considera que as posies na lista so de 1 at n.
Veja agora o que acontece em relao aos atributos do objeto quando ele construdo. Apenas
o ponteiro px e tamanho so atributos da lista. O arranjo, apesar de ser usado para representar a
lista, est alocado na memria, fora do escopo do objeto.
25.5 Destrutores 375
Lista(10)
tamanho 10 px
1 2 3 4 5 6 7 8 9 10
Quando esta lista destruda, apenas o ponteiro px e tamanho so destrudos. O arranjo

continua existindo, o que causa um vazamento de memria.
Lista(10)
tamanho 10 px
1 2 3 4 5 6 7 8 9 10
Para que isto no ocorra, precisamos definir na funo destrutora que o arranjo ser desa-
locado tambm sempre que o objeto for destrudo. Nesta nova definio da classe, temos uma
funo destrutura na linha 4.
1 class Lista {
2 public :
3 Lista ( int );
4 ~ Lista ();
5 void setElemento ( int pos , int x ) { px [ pos -1] = x ;}
6 int getElemento ( int pos ) { return px [ pos -1];}
7 private :
8 int * px ;
9 int tamanho ;
10 };
11
12 Lista :: Lista ( int n ){
13 tamanho = n ;
15 for ( int i = 0; i < n ; i ++){
16 px [ i ] = i +1;
17 }
18 }
19
20 Lista ::~ Lista (){
21 delete [] px ;
22 }
A funo destrutura tem o mesmo nome da classe precedido de um . A funo destrutora
no recebe parmetros e executada sempre que um objeto ser destrudo.
Na implementao do destrutor, feita nas linhas 20 a 22, podemos dizer ao objeto para
desalocar a memria apontada por px antes de excluir os atributos da lista.
Lista(10)
tamanho 10 px
1 2 3 4 5 6 7 8 9 10
Apenas aps a execuo do destrutor os atributos da lista so desalocados.
Lista(10)
tamanho 10 px
1 2 3 4 5 6 7 8 9 10
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Relaes
0
26.
1 0 entre
1
0 0 objetos
1
0 1 0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Estudaremos nas prximas sees vrias maneiras como objetos podem se relacionar.
26.1 Composio de objetos

muito til em sistemas complexos a relao na qual objetos podem conter outros objetos como
membros. Por exemplo:
Um computador que tem um teclado
Um carro que tem 4 rodas
Uma universidade contm vrios departamentos
Um departamento contm vrios professores
Com este tipo de definio, podemos criar objetos mais complexos que os objetos originais
atravs de composio.
Considere uma classe que define objetos do tipo Professor.
1 class Professor {
2 public :
3 Professor ( string s , int x ) { nome = s ; cpf = x ;};
4 void setNome ( string s ) { nome = s ;}
5 void setCpf ( int x ) { cpf = x ;}
6 string getNome () { return nome ;}
7 int getCpf () { return cpf ;}
8 private :
9 string nome ;
10 int cpf ;
11 };
Nos membros privados da classe, como definidos nas linhas 9 e 10, cada Professor tem
como atributos seu nome e cpf. Os setters e getters definidos nas linhas 4 a 7 podem alterar estes
dados.
Podemos agora criar uma classe Departamento que tem vrios professores.
378 Captulo 26. Relaes entre objetos
1 class Departamento {
2 public :
3 Departamento ( string s ) { nome = s ;};
4 void contrataProfessor ( Professor x ) { docentes . push_back ( x );}
5 int getTamanho () { return docentes . size ();};
6 void imprime ();
7 private :
8 vector < Professor > docentes ;
9 string nome ;
10 };
11
12 void Departamento :: imprime (){
13 cout << nome << " \ tProfessores " << endl ;
14 vector < Professor >:: iterator i ;
15 for ( i = docentes . begin (); i != docentes . end (); ++ i ){
16 cout < getCpf () << " \ t " < getNome () << endl ;
17 }
18
19 }
O departamento tem um conjunto de professores. O vector da linha 8 guardar o conjunto

de professores neste departamento. Atravs da funo da linha 4, contratamos mais professores
com um push_back neste vector. Na linha 5, o tamanho do departamento pode ser obtido
pelo prprio tamanho do conjunto de professores.
Criamos tambm uma funo que mostra todos os professores de um departamento. A funo
imprime est definida nas linhas 12 a 19 e percorre todo o conjunto de professores com um
iterador.
Com as definies destas classes, podemos criar na funo principal um departamento,
contratar professores e imprimir os dados deste departamento.
1 int main () {
2 Professor x ( " Joao " , 123);
3 Departamento dept ( " DECOM " );
4 dept . contrataProfessor ( x );
5 Professor y ( " Jose " , 345);
6 dept . contrataProfessor ( y );
7 dept . imprime ();
8 return 0;
9 }
Assim como criamos um Departamento com vrios professores, poderamos ter criado
tambm uma classe Universidade, com vrios departamentos, e assim por diante. Podemos
perceber como composio de objetos uma ferramenta til para modelar sistemas complexos.
26.1.1 Destrutores de objetos membros
Quando um objeto destrudo, todos os seus itens membros so destrudos automaticamente.

Alm disso, quando o objeto destrudo, todos os objetos de sua propriedade tambm so
destrudos. Assim, no necessrio se preocupar com a funo destrutora de objetos membros.
26.1 Composio de objetos 379
26.1.2 Construtores de objetos membros

Os objetos membros de outro objetos tambm precisam ser construdos. A construo de todos
os membros de uma classe ocorre antes da execuo do prprio construtor desta classe. Porm,
possvel definir como qualquer atributo ser construdo.
Considere a seguinte classe utilizada para representar uma roda.
1 class Roda {
2 public :
3 Roda ();
4 Roda ( double );
5 void setRaio ( double x ) { raio = x ;}
6 double getRaio () { return raio ;}
7 private :
8 double raio ;
9 };
10
11 Roda :: Roda (){
12 raio = 5;
13 }
14
15 Roda :: Roda ( double x ){
16 raio = x ;
17 }
Cada roda ter um atributo raio que guarda o valor de seu raio, como definido na linha .
Temos para a classe dois contrutores. O primeiro construtor, declarado na linha 3, o
construtor padro, que em sua definio, nas linhas 11 a 13, d valor 5 ao raio. O segundo
construtor, declarado na linha 4 e definido nas linhas 15 a 17, guarda o valor do raio que
recebido como parmetro.
Temos ainda os getters e setters para um raio nas linhas 5 e 6.
Considere agora uma segunda classe que representa motocicletas.
1 class Motocicleta {
2 public :
3 Motocicleta ( double , double );
4 void setDianteira ( Roda x ) { dianteira = x ;}
5 void setTraseira ( Roda x ) { traseira = x ;}
6 Roda getDianteira () { return dianteira ;}
7 Roda getTraseira () { return traseira ;}
8 private :
9 Roda dianteira ;
10 Roda traseira ;
11 };
12
13 Motocicleta :: Motocicleta ( double r1 , double r2 ){
14 dianteira . setRaio ( r1 );
15 traseira . setRaio ( r2 );
16 }
Cada motocicleta tem duas rodas, representadas pelos atributos das linhas 9 e 10. No
temos um construtor padro para a Motocicleta. Temos apenas um construtor que recebe 2
parmetros, declarado na linha 3.
Nas linhas 13 a 16, na definio do construtor da motocicleta, associa-se os valores passados

como parmetro s rodas da motocicleta. Para isto, a funo setRaio utilizada.
Note que antes mesmo do primeiro comando do construtor ser executado na linha 14, os
objetos que representam as rodas j foram construdos. S por isto podemos utilizar a funo
setRaio. Os objetos j esto construdos com seus construtores padro, que do valor 5 ao raio
de qualquer roda. Assim, precisamos apenas utilizar a funo de setRaio para definir o raio das
rodas que j existem na linha 14.
Deste modo, o construtor da motocicleta realiza 2 passos:
1. Antes mesmo do bloco de comandos se iniciar, cada Roda construda com o construtor
padro (raio recebe 5)
2. O raio de cada roda alterado
Veja como uma Roda, alm do construtor padro, tem um construtor que recebe um valor
double. Seria muito bom se pudssemos j definir como uma roda da motocicleta deve ser
construda. Assim, poderamos utilizar o construtor que j recebe o raio da roda e economizar
operaes.
Podemos fazer isto entre a passagem dos parmetros para o construtor e incio do bloco de
comandos.
1 Motocicleta :: Motocicleta ( double r1 , double r2 ):
2 dianteira ( r1 ) , traseira ( r2 ){
3 // N o precisamos de comando algum aqui
4 }
Deste modo, o segundo construtor para a Roda j chamado e no precisamos alterar o raio
da roda aps sua criao pois elas j so criadas com os valores corretos.
De maneira similar, o double que guarda o raio de uma roda j pode ser criado com seu
valor correto.
1 Roda :: Roda ():
2 raio (5){
4 }
5
6 Roda :: Roda ( double x ):
7 raio ( x ){
9 }
Esta, porm, no uma operao que economizaria tantos recursos.
Note que outra vantagem de se definir como os objetos membros sero criados que no
precisamos de um construtor padro. A Motocicleta, por exemplo, no precisa mais do
construtor padro definido pela funo Raio() para funcionar.
Inicializar os membros de um objeto antes de comear a funo chama os construtores dos
membros. Esta uma boa prtica pois evita utilizar de maneira desnecessria o construtor padro
para estes itens, o que pode ser um desperdcio grande de recursos. Alm disto, alguns objetos
podem no ter construtores padro e esta a nica maneira de inicializ-los.
26.2 Herana
Quando uma classe herda de outra classe, ele pega para si todas as funes e membros desta
classe. Chamamos esta classe superior de superclasse.
26.2 Herana 381
A Figura 26.1 apresenta um exemplo de relao de herana. Os retngulos e tringulos so

todos polgonos. Por isto, eles devem necessariamente ter todas os atributos e comportamentos
de polgonos.
Poligono
Retangulo Triangulo
! Note que tringulos e retngulos no contm polgonos. Eles so polgonos. No podemos

confudir relaes de composio com relaes de herana. As motocicletas contm rodas.
As motocicletas no so rodas. Os retngulos so polgonos. Os tringulos so polgonos.
Na relao de herana apresentada, retngulos e tringulos tm os mesmos comportamentos

e atributos de polgonos. Polgonos, porm, no necesserariamente tm todos os comportamentos
e atributos de retngulos e tringulos.
Dizemos que o Poligono uma superclasse e que o as classes Retangulo e Triangulo
herdam da classe Poligono.
Suponha de modo mais concreto uma classe utilizada para representar polgonos.
1 class Poligono {
2 public :
3 void set_valores ( int a , int b ){
4 largura = a ;
5 altura = b ;
6 }
7 protected :
9 };
Nesta classe, vamos poder representar polgonos que tenham largura e altura. Veja que
temos uma nova palavra-chave: protected. Os membros protegidos de uma classe no so
acessveis por quem cria objetos desta classe, assim como os membros privados. Porm, membros
protegidos so acessveis por objetos que herdam desta classe.
Nas linhas 3 a 6, temos tambm uma funo pblica que define os valores de largura e
altura. Qualquer objeto que herdar de Poligono, ter tambm este recurso.
Veja agora esta classe utilizada para representar retngulos.
1 class Retangulo : public Poligono {
2 public :
3 int area (){
4 return largura * altura ;
5 }
6 };
Na linha 1, o trecho : public Poligono faz com que a classe Retangulo herde de
Poligono.
Alm das funes definidas em Poligono, a classe Retangulo tem uma funo que utiliza
seus valores de altura e largura para clculo de sua rea. Assim, apesar de todo Retangulo
ser um Poligono, ele tambm pode ter seus atributos e comportamentos especficos.
Deste modo, a definio acima de Retangulo equivalente seguinte definio:
1 class Retangulo {
2 public :
3 void set_valores ( int a , int b ){
4 largura = a ;
5 altura = b ;
6 }
7 int area (){
8 return largura * altura ;
9 }
10 private :
12 };
Pela diferena entre as definies equivalentes, note como a herana facilita o reaproveita-
mento de cdigo.
De volta a nosso exemplo, podemos definir outras classes de polgonos que tenham altura
e largura. Definimos ento uma nova classe Triangulo que tambm herda os atributos e
comportamentos de Poligono.
1 class Triangulo : public Poligono {
2 public :
3 int area (){
4 return ( largura * altura )/2;
5 }
6 };
Note que cada classe que herda de Poligono pode ter tambm seus atributos e comporta-
mentos especficos. Neste caso, o clculo da rea diferente para um tringulo. Note mais uma
vez como isto facilita o reaproveitamento de cdigo.
Atravs da herana, conseguimos definir apenas com uma implementao de set_valores
os valores de qualquer objeto que herde de Poligono.
1 int main () {
2 Retangulo rect ;
3 Triangulo trgl ;
4 rect . set_valores (4 ,5);
5 trgl . set_valores (4 ,5);
6 cout << rect . area () << endl ;
7 cout << trgl . area () << endl ;
8 return 0;
9 }
Alm da atribuio de valores feita nas linhas 4 e 5, conseguimos tambm utilizar diretamente
as funes especficas destes objetos, como fizemos nas linhas 6 e 7.
26.2 Herana 383
20
10
26.2.1 Polimorfismo
Outra possibilidade interessante relacionada herana entre objetos polimorfismo. Um retn-
gulo, por exemplo, por ser tambm um polgono, pode ser tratado ento simplesmente como
Retangulo ou como Poligono. Em outras palavras, um objeto pode assumir mais de uma
forma, dependendo de sua relao de herana.
Veja este exemplo de como um retngulo ou um tringulo podem ser tratados simplesmente
como polgonos.
1 int main () {
2 Retangulo rect ;
3 Triangulo trgl ;
4 Poligono * ppoli1 = & rect ; // Retangulo um Poligono
5 Poligono * ppoli2 = & trgl ; // Triangulo um Poligono
6 ppoli1 - > set_valores (4 ,5);
8 cout << rect . area () << endl ;
9 cout << trgl . area () << endl ;
10 return 0;
11 }
O exemplo cria um Retangulo e um Triangulo nas linhas 2 e 3. Em seguida, nas linhas
4 e 5, so criados dois ponteiros para polgonos. Um aponta para o retngulo e outro para o
tringulo. No h problema nisto pois um retngulo e um tringulo tambm so polgonos! Eles
podem assumir esta forma.
Utilizamos nas linhas 6 e 7 os ponteiros ento para dar valores aos polgonos. Isto tambm
possvel pois set_valores uma funo comum a polgonos.
Em seguida, nas linhas 8 e 9, acessamos as funes de rea que pertencem aos objetos.
20
10
Note que o seguinte cdigo geraria erro.

1 int main () {
2 Retangulo rect ;
3 Triangulo trgl ;
4 Poligono * ppoli1 = & rect ;
5 Poligono * ppoli2 = & trgl ;
8 cout << ppoli1 - > area () << endl ;
9 cout << ppoli1 - > area () << endl ;
10 return 0;
11 }
Nas linhas 8 e 9, a funo area no uma funo comum aos polgonos definida em
Poligono e sim funes especficas das classes Retangulo e Triangulo.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Recursos
0
27.
1 0 de Objetos
1
0 0 1
01 0 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 0 01 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
27.1 Templates de Objetos

Como j vimos na Seo 17, templates so recursos poderosos de programao genrica pois
generalizam conceitos para quaisquer tipos de dados. Templates so muito teis para criar
funes que funcionam com vrios tipos variveis. Usamos tambm no Captulo III vrios
objetos que representam containers. Atravs de templates, estes containers conseguem guardar
qualquer tipo de dado.
Veja esta classe para representar um par de nmeros inteiros.
1 class par {
2 public :
3 par ( int a , int b ){
4 primeiro = a ;
5 segundo = b ;
6 }
7 int getPrimeiro () { return primeiro ;}
8 int getSegundo () { return segundo ;}
9 int getMaior ();
10 int getMenor ();
11 private :
12 int primeiro ;
13 int segundo ;
14 };
15
16 int par :: getMaior (){
17 if ( primeiro > segundo ){
18 return primeiro ;
19 } else {
20 return segundo ;
21 }
386 Captulo 27. Recursos de Objetos
22 }
23
24 int par :: getMenor (){
25 if ( primeiro < segundo ){
27 } else {
28 return segundo ;
29 }
30 }
Os nicos atributos desta classe so os dois nmeros inteiros, declarados nas linhas 12 e
13. Entre os recursos da classe podemos no s retornar o primeiro e segundo elementos mas
tambm o maior e o menor elementos, pelas funes declaradas nas linhas 7 a 10. Por serem
maiores, as funes getMaior e getMenor esto definidas fora da classe, nas linhas 16 a 30.
Veja o resultado da execuo deste programa.
1 int main () {
2 par objeto (6 , 12);
3 cout << " Par de objetos " << endl ;
4 cout << " Primeiro = " << objeto . getPrimeiro () << endl ;
5 cout << " Segundo = " << objeto . getSegundo () << endl ;
6 cout << " Maior = " << objeto . getMaior () << endl ;
7 cout << " Menor = " << objeto . getMenor () << endl ;
8 return 0;
9 }
Par de objetos
Primeiro = 6
Segundo = 12
Maior = 12
Menor = 6
Parece claro que um objeto que guarda um par de qualquer tipo de dados no muito
diferente de um objeto que guarda um par de dados do tipo int. Para isto, com a seguinte
converso, conseguimos representar a mesma classe com templates.
2 class par {
3 public :
4 par ( T a , T b ){
5 primeiro = a ;
6 segundo = b ;
7 }
8 T getPrimeiro () { return primeiro ;}
9 T getSegundo () { return segundo ;}
10 T getMaior ();
11 T getMenor ();
12 private :
13 T primeiro ;
14 T segundo ;
27.1 Templates de Objetos 387
15 };
16
18 T par <T >:: getMaior (){
21 } else {
22 return segundo ;
23 }
24 }
25
27 T par <T >:: getMenor (){
30 } else {
31 return segundo ;
32 }
33 }
Na linha 1, iniciamos a definio da classe avisando que T representar um template. Em
toda a definio da classe, at a linha 15, substitumos ento todas as ocorrncias de int pelo
tipo de dado T, representando um template.
As implementaes das funes do objeto tambm precisam ser feitas com templates. Por
isto os templates T so definidos novamente nas linhas 17 e 26, antes do incio da implementao.
Pelas definies das linhas 18 e 27, vamos que estas funes agora retornam dados do tipo T e
pertencem ao objeto par<T>.
Veja agora o resultado da execuo deste programa.
1 int main () {
2 par < int > objeto (6 , 12);
8 return 0;
9 }
Par de objetos
Primeiro = 6
Segundo = 12
Maior = 12
Menor = 6
Obtivemos o mesmo resultado utilizando templates. A nica alterao necessria na funo

principal foi definir com qual tipo de dado queremos utilizar o objeto. Isto foi feito com
Par<int>. Indicamos assim qual tipo de dado ser utilizado no lugar do template. Isto
feito da mesma maneira que utilizamos containers, que so objetos que utilizam templates para
representar estruturas de dados.
Agora, claro, podemos utilizar nosso objeto com qualquer tipo de dado ou objeto.
1 int main () {
2 par < char > objeto ( g , t );
8 return 0;
9 }
Par de objetos
Primeiro = g
Segundo = t
Maior = t
Menor = g
1 int main () {
2 par < double > objeto (6.7 , 3.2);
8 return 0;
9 }
Par de objetos
Primeiro = 6.7
Segundo = 3.2
Maior = 6.7
Menor = 3.2
27.2 Operador de Converso

Um problema que pode ocorrer com os novos objetos que criamos que podem no existir
funes que funcionem com ele, afinal, estamos criando um novo tipo de dado. Em alguns casos,
o operador de converso pode ser til para transformar um objeto em um outro tipo de dado j
conhecido.
Veja este exemplo onde temos uma classe Roda.
2
4
5 class Roda {
6 public :
27.2 Operador de Converso 389
7 Roda ( double x ) { raio = x ;}

8 void setRaio ( double x ) { raio = x ;};
10 private :
11 double raio ;
12 };
13
14 int main () {
15 Roda x (7.2);
16 cout << " Roda de raio " << x . getRaio () << endl ;
17 return 0;
18 }
Utilizamos esta classe na funo principal para criarmos uma Roda e imprimirmos seu raio.
Roda de raio 7.2
Para imprimir o raio, utilizamos a funo getRaio, que retorna um double. A impresso
s possvel porque o objeto cout reconhece variveis do tipo double. J o seguinte comando
levaria a um erro:
1 cout << " Roda de raio " << x << endl ;
Isto porque o objeto cout no sabe trabalhar com variveis do tipo Roda. Assim, neste
prximo exemplo, criamos um operador de converso.
2
4
5 class Roda {
6 public :
7 Roda ( double x ) { raio = x ;}
8 void setRaio ( double x ) { raio = x ;};
10 operator double (){ return raio ;}
11 private :
12 double raio ;
13 };
14
15 int main () {
16 Roda x (7.2);
17 cout << " Roda de raio " << x . getRaio () << endl ;
18 cout << " Roda de raio " << x << endl ;
19 return 0;
20 }
Este operador double(), na linha 10, define como converter uma Roda em um double,
retornando o valor de seu raio.
Na linha 18, o objeto cout agora funciona com uma Roda, j que existe um operador que
converte uma roda para um tipo de dados conhecido por ele.
Roda de raio 7.2

Roda de raio 7.2
27.3 Interface e Implementao

Em projeto grandes, ao definir uma classe, comum termos dois componentes:
Uma interface, que inclui o cabealho das funes, a definio dos atributos e uma
implementao das funes simples
Uma implementao, onde temos a definio das funes declaradas nos cabealhos
uma prtica vantajosa separar estes dois componentes. Para isto, usualmente os objetos
so separados em arquivos .h e .cpp.
Vejamos novamente um exemplo de classe de objetos.
1 // Cabe alho / Interface
2 class Par {
3 public :
4 Par ( int a , int b ){
5 primeiro = a ;
6 segundo = b ;
7 }
10 int getMaior ();
11 int getMenor ();
12 private :
13 int primeiro ;
14 int segundo ;
15 };
16
17 // C digo - Fonte / Implementa o
18 int Par :: getMaior (){
21 } else {
22 return segundo ;
23 }
24 }
25
26 int Par :: getMenor (){
29 } else {
30 return segundo ;
31 }
32 }
Nas linhas 1 a 16, temos a definio dos cabealhos, onde chamamos de interface. Nas linhas
17 a 32, temos o cdigo-fonte que implementa as funes. comum separar estas duas coisas
em dois arquivos separados com o nome da funo. Neste caso, a interface ficaria em um arquivo
Par.h e a implementao ficaria em um arquivo Par.cpp.
27.3 Interface e Implementao 391
No arquivo Par.h temos os recursos da classe. Este o arquivo que ser consultado por um
usurio da classe.
1 // Arquivo Par . h
2 # ifndef PAR_H
3 # define PAR_H
4
5 class Par
6 {
7 public :
8 Par ( int , int );
11 int getMaior ();
12 int getMenor ();
13 private :
14 int primeiro ;
15 int segundo ;
16 };
17
18 # endif
Note que todos os recursos esto nas linhas 5 a 16. Note que acrescentamos os comandos
#ifndef PAR_H na linha 2, #define PAR_H na linha 3 e #endif na linha 18. Estes comandos
garantem que a classe Par s seja definida se no estiver definida ainda. Isso acontece se
tentarmos incluir a classe mais de uma vez no cdigo.
O arquivo Par.cpp com o cdigo-fonte pode ser visto abaixo:
1 // Arquivo Par . cpp
2 # include " Par . h "
3
4 Par :: Par ( int a , int b ){
5 primeiro = a ;
6 segundo = b ;
7 }
8
9 int Par :: getMaior (){
12 } else {
13 return segundo ;
14 }
15 }
16
17 int Par :: getMenor (){
20 } else {
21 return segundo ;
22 }
23 }
Inclumos o arquivo Par.h na linha 2. Isto equivale a replicar todo o cdigo de Par.h no
incio de Par.cpp. Note que as incluses de nossos arquivos so feitas com aspas ("Par.h") e
no com chaves (<Par.h>).
Para utilizar nossa classe, o usurio precisa somente do arquivo Par.h para conhecer seus
recursos.
Note como o arquivo Par.h deve ser includo em nosso arquivo main.cpp e como isto torna
nosso cdigo mais organizado.
1 // Arquivo main . cpp
3 # include " Par . h "
4
6
7 int main (){
8 Par x (2 ,3);
9 cout << " Maior : " << x . getMaior () << endl ;
10 cout << " Menor : " << x . getMenor () << endl ;
11 return 0;
12 }
Temos agora todos os recursos da classe Par em nosso arquivo principal.
Maior: 3
Menor: 2
A separao da interface e implementao muito til por vrios motivos. Pessoas diferentes
podem trabalhar em arquivos diferentes. A implementao pode ficar escondida do usurio da
classe. Se os cabealhos forem mantidos, as implementaes podem ser alteradas sem causar
problemas ao usurio da classe. Por fim, o cdigo fica mais organizado e modularizado.
27.4 Exerccios
Exerccio 27.1 Analise o cdigo abaixo, que est incompleto. Ela define o objeto Aluno
para ser usado em um sistema de cadastro de uma academia.
A classe j define como imprimir um aluno, atribuir dados, retornar dados e comparar
alunos.
A funo apresentaMenu entra em um lao que permite trabalhar com um conjunto
de alunos.
Utilizando a classe de alunos, o menu apresenta funes para cadastrar e remover
alunos.
A inteno deste exerccio fazer um sistema de matrcula de alunos.
Os alunos so cadastrados em um map que usa o nmero de matrcula como chave para
organizar os dados.
3 # include <map >
4
6
27.4 Exerccios 393
7 class Aluno {
8 public :
9 void imprime () {
10 cout << matricula << " - " << nome << endl ;
11 return ;
12 }
13
14 // Fun es modificadoras
15 void setValores ( string x , int y ) {
16 nome = x ;
17 matricula = y ;
18 }
19
20 void setNome ( string x ) {
21 nome = x ;
22 return ;
23 }
24
25 void setMatricula ( int x ) {
26 matricula = x ;
27 return ;
28 }
29
30 // Fun es n o - modificadoras
31 string getNome () {
32 return nome ;
33 }
34
35 int getMatricula () {
36 return matricula ;
37 }
38
39 bool operator <( const Aluno x ) const {
40 return ( this - > matricula < x . matricula ) ;
41 }
42
43 private :
44 int matricula ;
45 string nome ;
46 };
47
48 void apresentaMenu ( map < int , Aluno > & cadastro ) ;
49 void imprimeCadastro ( map < int , Aluno > & x ) ;
50 void insereAluno ( map < int , Aluno > & x ) ;
51 void pesquisaAluno ( map < int , Aluno > & x ) ;
52
53 int main () {
54 map < int , Aluno > cadastro ; // chave a matricula ( int ) e
registro o pr prio aluno
55 cout << " Bem vindo ao sistema de cadastro de alunos da

academia " << endl ;
56 string opcao ;
57 apresentaMenu ( cadastro ) ;
58 cout << " \ nObrigado por utilizar nosso sistema de
cadastro BCC702 " << endl ;
59 return 0;
60 }
61
62 void apresentaMenu ( map < int , Aluno > & cadastro ) {
63 string opcao ;
64 do {
65 cout << " \ n **** Sistema de cadastro de alunos **** "
<< endl ;
66 cout << " [1] Imprimir lista com todos os alunos " <<
endl ;
67 cout << " [2] Inserir um novo aluno " << endl ;
68 cout << " [3] Consultar um aluno " << endl ;
71 cin >> opcao ;
72 if ( opcao == " 1 " ) {
73 imprimeCadastro ( cadastro ) ;
74 } else if ( opcao == " 2 " ) {
75 insereAluno ( cadastro ) ;
76 } else if ( opcao == " 3 " ) {
77 pesquisaAluno ( cadastro ) ;
78 }
79 } while ( opcao != " 0 " ) ;
80 return ;
81 }
82
83 void imprimeCadastro ( map < int , Aluno > & x ) {
84 map < int , Aluno >:: iterator i ;
85 for ( i = x . begin () ; i != x . end () ; ++ i ) {
86 i - > second . imprime () ;
87 }
88 return ;
89 }
90
91 void insereAluno ( map < int , Aluno > & x ) {
92 Aluno temp ;
93 string tempnome ;
94 int tempmatricula ;
95 cout << " Digite o nome do aluno : " ;
96 cin . ignore (100 , \ n ) ; // getline difere de cin pois l
toda a linha
97 getline ( cin , tempnome ) ;
98 temp . setNome ( tempnome ) ;
27.4 Exerccios 395
99 cout << " Digite o numero de matricula : " ;

100 cin >> tempmatricula ;
101 temp . setMatricula ( tempmatricula ) ;
102 x [ tempmatricula ] = temp ;
103 return ;
104 }
105
106 void pesquisaAluno ( map < int , Aluno > & x ) {
107 cout << " Digite o numero de matricula : " ;
108 int numero ;
109 cin >> numero ;
110 map < int , Aluno >:: iterator i ;
111 i = x . find ( numero ) ;
112 if ( i == x . end () ) {
113 cout << " Nao existe aluno com o numero de matricula
" << numero << endl ;
114 } else {
115 i - > second . imprime () ;
116 }
117 }

Exerccio 27.2 Imagine que cada aluno pode agora ser cadastrado em vrios cursos da
academia. O conjunto (set) de atividades (musculacao, danca, spinning, etc...) no qual um
aluno pode estar cadastrado pode ento ser representado com um set<int>, onde o inteiro
representa o cdigo da atividade (por exemplo,1 para musculacao, 2 para danca, etc...).
Crie esta varivel privada set<int> para cada aluno.
Crie funes na classe Aluno que matriculem ou desmatriculem o aluno de uma
atividade
Crie uma funo na classe Aluno para imprimir as atividades em quais atividades ele
est matriculado
Crie uma funo na classe Aluno que retorne em quantas atividades ele est matriculado
Insira uma opo no menu para matricular o Aluno em uma atividade
Insira uma opo no menu para desmatricular o Aluno de uma atividade
Altere a funo de listar todos os alunos para que ela mostre em quantas atividades
cada Aluno est matriculado
Altere a funo de pesquisa do menu para que ela mostre tambm em quais atividades
um Aluno est matriculado

Exerccio 27.3 Os construtores so funes que so chamadas sempre que um Aluno

criado.
Suponha que todo Aluno cadastrado ganha uma inscrio grtis na aula musculao,
que tem o cdigo 1. Faa um construtor que insira automaticamente esta aula de
musculao para todo aluno que criado no cadastro.
possvel criar um contrutor que tambm j receba valores iniciais. Crie um cons-
trutor que j receba o nome e nmero de matrcula do aluno para no precisarmos de
setNome() e setMatricula() na funo insereAluno().
Exerccio 27.4 As funes que se iniciam com set e get so utilizadas por padro para que
o usurio utilize a classe de maneira segura sem ter acesso a variaveis privadas diretamente.
Altere a funo que imprime as atividades de um aluno para que em vez dos cdigos
das atividades sejam exibidos os nomes das atividades. Crie nomes de atividades e para
cada nmero deve ser impresso um nome.
Altere as funes que inscrevem os alunos em atividades para que apenas nmeros de
atividades vlidas sejam cadastradas. Caso no seja escolhida uma atividade vlida,
uma mensagem de erro deve ser exibida.
Suponha agora que o nmero de matricula deve ter no minimo 4 digitos (numero >
999). Altere as funes que definem nmeros de matrcula para que apenas numeros
vlidos sejam cadastrados. Caso no seja escolhido um nmero vlido, uma mensagem
de erro deve ser exibida.

V
Prticas de Programao em
C++
28 Prticas Comuns de Programao em

C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
29 Algoritmos Eficientes . . . . . . . . . . . . . . . 411
ndice Remissivo . . . . . . . . . . . . . . . . . . . 417

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Prticas
0
28.
1
001
0 0 1 de Programao
Comuns
1
0 1 1 0
0
1
1101 C++ 0
em
1
0
0
0
110 0
1
0
0
000 0
0
1
1
0
0
00 1 00 0 0 0 01 0 1 01 00 11
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Neste captulo discutiremos brevemente prticas importantes de programao que no podem ser
discutidas em uma introduo didtica aos tpicos de programao. Discutiremos recursos do
C++ que formam prticas de programao distintas para programadores especializados em C++.
28.1 Ponteiros inteligentes

Ponteiros inteligentes so uma classe baseada em templates que imita o comportamento de
ponteiros, chamados aqui de ponteiros crus. Esta imitao ocorre atravs da sobrecarga de
operadores.
Ponteiros que apontam para alguma memria alocada dinamicamente com a instruo new
precisam podem gerar vazamento de memria caso o programador no desaloque a memria ao
fim com a instruo delete.
Os ponteiros inteligentes, em C++, desalocam automaticamente a memria apontada aos
destruir o objeto que simula um ponteiro, facilitando assim a prtica de programao. O seguinte
comando cria um ponteiro inteligente para nmeros inteiros:
1 shared_ptr < int > p ;
O tipo de dado shared_ptr utilizado para ponteiros inteligentes compartilhados: o tipo
mais comum de ponteiros inteligentes. Seu construtor pode receber como parmetro um objeto
sendo alocado na memria ou mesmo o endereo.
1 # include < memory >
2 // ...
3 shared_ptr < int > p ( new int );
4 * p = 10;
5 shared_ptr < int > p2 ;
6 p2 = p1 ;
7 p1 = make_shared < int > (20);
400 Captulo 28. Prticas Comuns de Programao em C++
A funo unique() retorna se um ponteiro o nico que aponta para aquele endereo. Os
dados apontados por um ponteiro s so desalocados quando mais nenhum ponteiro aponta para
o endereo.
Alm do ponteiro inteligente shared_ptr, existem os ponteiros inteligentes unique_ptr,
que no permitem que mais de um ponteiro aponte para o mesmo endereo, e weak_ptr, que
so utilizados para guardar ponteiros crus.
28.2 Deduo do tipo de dado

Em vrias situaes, o C++ pode deduzir pelo o cdigo o tipo de dado necessrio para uma
varivel. Sempre que possvel inferir o tipo de dado, a instruo auto pode ser utilizada em
vez se escrever o tipo da varivel. As duas linhas de cdigo abaixo tm o mesmo efeito para criar
variveis do tipo int.
1 int x = 10;
2 auto y = 10;
claro que este um caso onde no existe um ganho no uso deste recurso. O comando auto
especialmente til quando trabalhamos com templates e iteradores:
1 vector < int > vec ;
2 auto itr = vec . iterator ();
No exemplo, utilizamos auto para definir o tipo de dado do iterador. Sem a funo auto,
teramos que definir o tipo correto do iterador vector<int>::iterator.
A funo decltype complementar a auto. Ela consegue determinar o tipo de uma varivel
em relao ao tipo de outra. No exemplo seguinte, conseguimos criar uma varivel y que tem o
mesmo tipo de dados de x, mesmo sem precisarmos saber o tipo de x neste ponto do cdigo.
1 decltype ( x ) y = x ;
28.3 Objetos de funo

Um objeto de funo um objeto que criamos apenas para guardar uma funo til como
parmetro para outra funo. Estes objetos podem ser tratados como se fossem funes.
No exemplo abaixo, chamamos a funo sort para ordenar uma sequncia de elementos.
1 int main ()
2 {
3 vector < int > items v { 4 , 3 , 1 , 2 };
4 sort ( v . begin () , v . end ());
5 return 0;
6 }
Perceba que na chamada da funo sort, est implicito que o critrio de comparao que
define a ordem entre dois elementos o operador <. De modo explcito, se quisermos utilizar
qualquer outra critrio de comparao, a funo sort precisa receber um terceiro parmetro que
uma funo indicando este critrio.
1 bool comparaInt ( int a , int b )
2 {
3 return a < b ;
4 }
5
28.4 Funes annimas 401
6 int main ()
7 {
9 sort ( v . begin () , v . end () , comparaInt );
10 return 0;
11 }
Neste exemplo, a funo comparaInt diz se um elemento maior que o outro e este critrio
utilizado para ordenar a sequncia. Assim, se quisermos ordenar a sequncia em ordem
decrescente podemos utilizar uma funo que retorna o contrrio de a < b.
1 bool comparaInt ( int a , int b )
2 {
3 return a > b ;
4 }
5
6 int main ()
7 {
10 return 0;
11 }
Em C++, um objeto com uma funo definida pelo operador () pode ser utilizada no lugar
da funo passada como argumento. Este um objeto de funo:
1 class comparaInt {
2 public :
3 bool operator ()( const int &a , const int & b ) const {
4 return a < b ;
5 }
6 };
7
8 int main ()
9 {
12 return 0;
13 }
O objeto de funo tem uma funo operator() que determina como se comparar dois
nmeros inteiros. A funo sort pode utilizar ento este objeto para ordenar a sequncia de
elementos. Os objetos de funo podem ter seus prprios atributos e comportamentos, estendendo
a utilidade de funes auxiliares.
28.4 Funes annimas

Alm destes recursos para passagem de funes como parmetros, o C++ permite a utilizao de
funes annimas, ou funes lambda. Uma funo lambda uma funo que pode ser escrita
no meio do prprio cdigo para ser passada para outra funo ou at mesmo guardada em uma
varivel. Com as funes annimas, as criao de funes pequenas se torna muito mais fcil. O
cdigo abaixo apresenta um exemplo de funo lambda:

2
4
5 int main ()
6 {
7 auto funcao = [] () { cout << " Ol Mundo ! " ; };
8 funcao (); // chamando a fun o guardada na vari vel
9 }
No exemplo acima, o [] indica o incio de uma funo lambda. Em seguida temos a lista
vazia de argumentos (). No necessrio definir o tipo de valor retornado por funes lambda
pois isto pode ser deduzido pelo compilador. A funo guardada em uma varivel chamada
funcao e no executada na linha 7. Na linha 8, a funo guardada na varivel funcao
executada.
Assim, lambdas so abordagens muito mais fceis para enviar funes auxiliares em algorit-
mos da STL, como no exemplo abaixo:
1 int main ()
2 {
4 sort ( v . begin () , v . end () , [] ( int a , int b ){ return a < b ;});
5 return 0;
6 }
Neste exemplo, uma funo lambda passada para sort determina como devem ser compara-
dos dois nmeros inteiros. Para ordenar os elementos em ordem decrescente poderamos apenas
utilizar:
1 sort ( v . begin () , v . end () , [] ( int a , int b ){ return a > b ;});
Alm da praticidade, as funes lambda tambm podem capturar elementos no passados
como parmetro. A Tabela 28.1 apresenta estas formas de se capturar elementos.
Captura Descrio
[] No captura variveis externas
[&] Captura qualquer varivel externa por referncia
[=] Captura qualquer varivel externa fazendo uma cpia
[=,&v1] Captura tudo por valor e a varivel v1 por referncia
[v1] Captura v1 fazendo uma cpia
[&v1] Captura v1 por referncia
Tabela 28.1: Opes para captura de variveis em funes lambda.
Este recurso permite o acesso a dados externos s funes auxiliares. No exemplo a seguir,
utilizaremos capturas para remover elementos menores que um certo valor na sequncia.
1 int main ()
2 {
3 vector < int > c { 1 ,2 ,3 ,4 ,5 ,6 ,7 };
4 int x = 5;
5 remove_if ( c . begin () , c . end () , [ x ]( int n ) { return n < x ; } );
6 }
28.5 For baseado em intervalo 403
A funo remove_if, neste exemplo remove todos os elementos que so menores que x. A
funo recebe o critrio de remoo de elementos atravs de uma funo lambda que recebe
nmeros inteiros como parmetro mas definida em termos de um valor x, que externo.
Por fim, uma funo lambda pode ser guardada em uma varivel do tipo function.
1 function < int ( int ) > funcao = []( int i ) { return i +10; };
2 cout << " Resultado : " << funcao (6) << \ n ;
28.5 For baseado em intervalo

O for baseado em intervalos uma sintaxe para escrever laos sobre elementos de maneira
conveniente. O cdigo seguinte imprime todos os elementos de uma sequncia.
1 vector < int > c { 1 ,2 ,3 ,4 ,5 ,6 ,7 };
2 for ( int i : c )
3 {
4 cout << i ;
5 }
Este cdigo imprime o contedo de um vector, com a varivel i tendo a cada passo o valor
de cada elemento.
Para tipos de dados mais complicados, a instruo auto pode ser utilizada para facilitar o
uso da estrutura.
1 map < int , string > calendario ;
2 for ( auto entrada : calendario ) {
3 cout << entrada . first << " - " << entrada . second << endl ;
4 }
Para modificar os dados na sequncia ou evitar copiar dados por valor, a sintaxe permite
acessar os dados por referncia. O cdigo abaixo incrementa todos os valores da sequncia.
1 vector < int > c { 1 ,2 ,3 ,4 ,5 ,6 ,7 };
2 for ( int & i : c ) {
3 i ++;
4 }
28.6 Tuplas
Tuplas so objetos utilizados para guardar uma combinao de elementos de diferentes tipos.
Uma maneira de se retornar mais de um tipo de dado de uma funo em C++ atravs da
utilizao de tuplas.
Neste exemplo criaremos tuplas e acessaremos seus elementos.
2 # include < tuple >
3
4 int main ()
5 {
6 // criamos tupla com letra c e n mero 15
7 tuple < int , char > t ( c ,15);
8 // criamos tupla com fun o make_tuple
9 auto t2 = make_tuple (6.3 , " texto " , 2 , o );
10
11 // acessamos elemento na posi o 2 da tupla t2
12 get <2 >( t2 ) = 125;
13
14 // desempacotamos elementos da tupla em vari veis
15 int x ;
16 char y ;
17 tie (y , x ) = t ;
18 // ignorando algumas das vari veis
19 tie ( ignore , ignore , x , y ) = t2 ;
20 // com a fun o get
21 y = std :: get <3 >( bar );
22
23 return 0;
24 }
A tupla pode ser definida explicitamente ou com o comando auto, que infere o tipo de dados
pelo retorna da funo make_tuple, que cria tuplas.
A funo tie serve para desempacotar os elementos da tupla enquanto a funo get
retorna um dos elementos da tupla.
28.7 Programao com iteradores

Vimos que os algoritmos da STL so todos baseados em iteradores, pois isso torna os cdigos
generalizveis. Quando fazemos cdigos genricos em C++, uma boa prtica fazer estes
cdigos tambm baseados em iteradores. Estes cdigos so muito mais genricos pois podem ser
utilizados com qualquer tipo de container ou arranjo. Eles podem retornar dados para qualquer
tipo de container. Alm disso, eles podem ser utilizados em qualquer subsequncia dentro de um
container ou arranjo. Eles tambm so usualmente mais eficientes.
So duas as regras para fazer um cdigo baseado em containers que seja generalizvel e
eficiente: 1) nunca passar containers para uma funo (passar iteradores) e 2) nunca retornar
containers de uma funo (utilizar iteradores). Em vez de passar um container para uma funo,
passe iteradores para o primeiro e ltimo elementos. Em vez de retornar um container, passe um
iterador onde os resultados possam ser guardados.
Veja uma funo que recebe um container e calcula o produto de seus valores.
1 template < class Container >
2 double produto ( const Container & c )
3 {
4 Container :: iterator i = c . begin ();
5 double p = 1;
6 while ( i != c . end () ) {
7 p *= * i ++;
8 }
9 return p ;
10 }
Apesar desta funo utilizar templates e servir para qualquer container, ela no uma funo
genrica o suficiente. Ela no funcionaria para arranjos e para subsequncias em um container.
A definio seguinte, que utiliza iteradores, mais clara e geral:
1 template < class Iterador >
28.8 Operador de cpia e movimento 405
2 double product ( Iterador inicio , Iterador fim )

3 {
4 double p = 1;
5 while ( inicio != fim ){
6 p *= * inicio ++;
7 }
8 return p ;
9 }
Esta funo agora funciona bem com arranjos, containers e subsequncias.
Vamos supor agora uma funo que precise retornar vrios resultados. Isso comum em
funes que copiam elementos de um container para outro, por exemplo. Neste caso, no uma
boa soluo utilizar iteradores como parmetros e retornar um container. Uma abordagem mais
geral receber um iterador onde os resultados sero guardados. Veja por exemplo como pode ser
definida uma funo que copia elementos de um container para outro.
1 template < class Entrada , class Saida >
2 Saida copia ( Entrada inicio , Entrada fim , Saida resultado ) {
3 while ( inicio != fim ) {
4 * resultado = * inicio ;
5 ++ resultado ; ++ inicio ;
6 }
8 }
A funo define dois templates: para iteradores de entrada e sada. So necessrio dois
templates para garantir que o tipo de iterador onde possam ser guardados os resultados possa
ser diferente do tipo de iterador com os dados de entrada. A funo guarda os elementos da
sequncia de entrada na sada, representada por resultado. A funo ainda retorna um iterador
que aponta para uma posio aps a posio onde foi copiado o ltimo elemento.
Supondo dois containers c1 e c2, os elementos de c1 poderiam ser copiados para c2 com a
seguinte chamada:
1 auto iter = copia ( c1 . begin () , c1 . end () , c2 . begin ());
Um problema possvel no haver espao para os elementos de c1 em c2. Uma maneira
simples de resolver este problema utilizando o recurso back_inserter.
1 auto iter = copia ( c1 . begin () , c1 . end () , back_inserter ( c2 ));
O back_inserter retorna um iterador especial para um container, chamado iterador de
insero. Este iterador sempre aloca espao ao fim do container quando necessrio pela funo.
Com a utilizao de iteradores com templates, fizemos nossas funes muito mais teis e
generalizveis do que antes. A Tabela 28.2 apresenta algumas funes teis para programao
com iteradores.
28.8 Operador de cpia e movimento

Sempre que vamos trocar valores entre duas variveis, precisamos de uma varivel temporria,
como no exemplo seguinte, onde trocamos os valores das variveis x e y.
1 // Criando as vari veis
2 int x = 4;
3 int y = 3;
Funo Descrio
advance Avana o iterador um certo nmero de posies
distance Distncia entre 2 iteradores
prev Retorna iterador para elemento anterior
next Retorna iterador para o prximo elemento
back_inserter Constri iterador de insero no fim da sequncia
front_inserter Constri iterador de insero no incio da sequncia
inserter Constri iterador de insero em um posio determinada
make_move_iterator Constri iterador para movimentar elementos
Tabela 28.2: Funes importantes para programao com iteradores.
4 // Trocando os valores
5 int temp ;
6 temp = x ;
7 x = y;
8 y = temp ;
Isto ocorre pois sempre que atribumos um valor a uma varivel, seu valor antigo perdido.
Com alguns objetos, porm, isto pode gerar um alto custo em termos de desempenho. Suponha
estarmos fazendo uma troca de contedo entre dois objetos vector<int>.
2 vector < int > temp ;
3 temp = x ;
4 x = y;
5 y = temp ;
Neste exemplo, se h n elementos no container x, teremos que fazer uma cpia de todos os
elementos de x em temp, o que teria custo O(n), tanto em relao a tempo quanto a memria.
Ao fim do processo, temp descartada.
Neste caso, sabemos que tivemos um desperdcio de recurso pois um vector no um
tipo fundamental de dados. Ele depende de ponteiro que, internamente, aponta para um arranjo
alocado na memria com os elementos. Poderiamos mover todo o contedo de x para temp
apenas fazendo com que o ponteiro de temp aponte para o arranjo que apontado por x. Isso
faz com que temp represente a sequncia x em tempo O(1). Mover os elementos para temp em
vez de fazer uma cpia no gera tambm problema algum lgica do programa, j que temp
apenas uma varivel temporria.
A semntica de movimento permite que no precisemos fazer cpias desnecessrias para
trabalhar com objetos temporrios.
1 # include < utility >
2 // ...
4 vector < int > temp = move ( x );
5 x = move ( y );
6 y = move ( temp );
Um construtor de movimento pode ser criado de maneira similar a como criado um
construtor de cpia para um objeto. Supondo um objeto A, este seria o prottipo de seu construtor
de movimento.
28.9 Threads 407
1 // Construtor de c pia
2 A :: A ( const A & outro );
3 // Construtor de movimento
4 A :: A ( A && outro );
Note que para containers, existe tambm a funo swap, que troca os elementos entre os
containers.
2 x . swap ( y );
28.9 Threads
Atualmente, so comuns programas que executam vrias tarefas ao mesmo tempo. Para isto,
precisamos do recurso de threads. Uma thread de execuo define instrues que podem ser
executadas ao mesmo tempo pelo computador. Uma thread pode ser criada em C++ com o
objeto do tipo thread.
1 // biblioteca de threads
2 # include < thread >
3 // ...
4 void funcao ( int x )
5 {
6 cout << x * x << endl ;
7 }
8 // ...
9 int main ()
10 {
11 // come a a executar uma fun o
12 thread t1 ( funcao ,4);
13 // coma a a executar outra fun o
14 thread t2 ( funcao ,10);
15
16 // sincroniza as threads
17 // pausa at que primeira thread termine
18 t1 . join ();
19 // pausa at que segunda thread termine
20 t2 . join ();
21
22 return 0;
23 }
No exemplo, temos uma funcao que imprime um valor elevado ao quadrado. Nas linhas 11
a 14, criamos as threads t1 e t2, que executaro esta funo com diferentes parmetros (4 e 10).
Cada thread executa a funo paralelamente. Nas linhas 16 a 20, pedimos ao programa para que
espere que as funes sejam executadas nas threads.
Para problemas maiores, possvel criar arranjos ou containers com threads de maneira
anloga. Porm, preciso prestar ateno pois o tempo de criao de uma thread pode no
compensar o ganho com a execuo de problemas muito pequenos em paralelo.
28.10 Medindo tempo

O cabealho chrono utilizado para trabalhar com trs tipos de conceitos: duraes, pontos no
tempo e relgios. comum utilizar duraes para medir quanto tempo foi necessrio para a
execuo de um programa.
1 // ...
2 # include < chrono >
3 // ...
4 using namespace std :: chrono ;
5 steady_clock :: time_point t1 = steady_clock :: now () ;
6 execut a_funcao_qu alquer () ;
7 steady_clock :: time_point t2 = steady_clock :: now () ;
8 duration < double > d = duration_cast < duration < double > >( t2 - t1 ) ;
9 std :: cout << d . count () << " segundos " << std :: endl ;
10 // ...
Na linha 2 deste exemplo, inclumos a biblioteca chrono, necessria para se medir tempo.
Na linha 4, indicamos que vamos utilizar recursos do espao de nomes chrono, que por sua vez
est dentro do espao de nomes std.
Na biblioteca chrono, temos 3 tipos de relgios, como os apresentados na Tabela 28.3. Todos
os relgios do acesso a pontos no tempo. Na linha 5 do cdigo, utilizamos o steady_clock
para calcular intervalos. Os recursos do relgio steady_clock esto no espao de nomes
steady_clock, que est dentro do espao de nomes chrono.
Relgio Descrio
steady_clock Utilizado para calcular intervalos
system_clock Acessa o relgio geral do sistema
high_resolution_clock Relgio de maior preciso possvel
Tabela 28.3: Relgios da biblioteca chrono.
Criamos nesta linha 4 uma varivel t1 do tipo time_point. O tipo de dado time_point
est definido no espao de nomes do relgio e utilizado para guardar pontos no tempo. A
funo now(), tambm pertencente ao espao de nomes do relgio, retorna um ponto no tempo
representando o momento atual.
Na linha 6, executamos uma funo qualquer, e na linha 7 fazemos um procedimento similar
ao da linha 5 para guardar o ponto no tempo t2 aps a execuo da funo.
Na linha 8, calculamos a durao entre os dois pontos no tempo. Dados do tipo duration
guardam a durao entre dois pontos no tempo. Estes dados guardam a diferena entre dois
pontos no tempo e a proporo entre estes pontos no tempo e uma unidade de medida de tempo,
como segundos, minutos ou horas.
O duration<double> indica que dados do tipo double so utilizados internamente para
guardar a durao. A classe duration pode receber um segundo parmetro no template indi-
cando a proporo entre pontos no tempo e unidades de tempo. Por exemplo, duration<double,
seconds> faria com que os valores da durao fossem retornados em segundos. Outras opes
esto na Tabela 28.4. Por padro, a durao ser retornada em segundos.
Ao lado direito da expresso da linha 8, a funo duration_cast transforma um tipo
de durao em outro. A operao t2 - t1 retorna uma durao que representada por
um tipo de dados correspondente ao relgio. A funo duration_cast utiliza o template
28.11 Nmeros aleatrios 409
Tipo Descrio
hours Horas
minutes Minutos
seconds Segundos
milliseconds Milisegundos
microseconds Microsegundos
nanoseconds Nanosegundos
Tabela 28.4: Tipos de proporo entre pontos no tempo e unidades de medida de tempo.
duration<double> para transformar a durao recebida como parmetro para uma durao do
tipo duration<double>.
Por fim, na linha 9, a funo d.count() retorna a durao guardada em d expressa em
segundos, como definida no segundo parmetro de seu template.
28.11 Nmeros aleatrios

Para gerao de nmeros aleatrio, utilizamos a biblioteca random. A biblioteca contm gerado-
res de nmeros aleatrios e distribuies.
1 // ...
2 # include < random >
3 // ...
4 default_random_engine gerador ;
5 uniform_real_distribution < double > distribuicao (0.0 ,1.0) ;
6 cout << distribuicao ( gerador ) << endl ;
7 // ...
Na linha 4 do exemplo de cdigo, criamos um gerador de nmeros aleatrios do tipo
default_random_engine. Este tipo de dado representa o gerador padro de nmeros aleatrio.
Na linha 5 criamos uma distribuio de nmeros reais entre 0.0 e 1.0. As distribuies
utilizam os geradores para gerar nmeros naquela distribuio. Para a gerao de nmeros reais
com distribuio uniforme utilizamos a distribuio uniform_real_distribution. O double
no template indica que os nmeros gerados sero representados com dados do tipo double.
Na linha 6, a distribuio criada utiliza o gerador para imprimir um nmero aleatrio entre
0.0 e 1.0.
Na linha 5, vrios tipos de distribuio poderiam ser utilizados. A Tabela 28.5 apresenta as
distribuies disponveis.
Distribuio Descrio
Uniforme
uniform_int_distribution Distribuio inteira uniforme
uniform_real_distribution Distribuio real uniforme
Tentativas de Bernoulli
bernoulli_distribution Distribuio de Bernoulli
binomial_distribution Distribuio binomial
geometric_distribution Distribuio geomtrica
negative_binomial_distribution Distribuio negativa binomial
Baseada em taxa de acerto
poisson_distribution Distribuio de Poisson
exponential_distribution Distribuio exponencial
gamma_distribution Distribuio gamma
weibull_distribution Distribuio de Weibull
extreme_value_distribution Distribuio de valores extremos
Normal
normal_distribution Distribuio normal
lognormal_distribution Distribuio lognormal
chi_squared_distribution Distribuio chi-quadrado
cauchy_distribution Distribuio de Cauchy
fisher_f_distribution Distribuio de Fisher
student_t_distribution Distribuio t de Student
Por partes
discrete_distribution Distribuio discreta
piecewise_constant_distribution Distribuio contante
piecewise_linear_distribution Distribuio linear
Tabela 28.5: Distribuies disponveis para nmeros aleatrios.

0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 1 0
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 101
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 0 1 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
10
1 1 0 0
00
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
001
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 1 1
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 00
1
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1 0 Algoritmos
0
29.
1 0 1
0 0 1 0
Eficientes
0 1 0
1
110 1
0
1 0
0
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 00 0 0 001 01 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
1 0
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 000 1 010 1 1 1 0 01 1 11
Nos captulos anteriores deste livro, apresentamos verses didticas de algoritmos importantes
para busca e ordenao. As verses apresentadas destes algoritmos, naturalmente, no so
as verses mais eficientes por ser tratarem de verses escolhidas principalmente por serem
mais didticas. Este captulo apresenta uma lista de algoritmos importantes em C++ com suas
implementaes eficientes. Estes so implementaes que podem ser utilizadas em aplicaes
prticas dos mtodos descritos neste livro. So tambm os mtodos utilizados para gerao dos
grficos de comparao dos algoritmos ao longo deste livro.
29.1 Busca em arranjo

O STL oferece implementaes para os algoritmos de busca em arranjo. Em aplicaes prticas,
estes so utilizados por programadores em C++.
29.1.1 Busca sequencial

Uma busca sequencial pode ser feita com a funo find.
1 // a fun o recebe 2 iteradores ( ou endere os ) e o elemento procurado
2 p = find ( v . begin () , v . end () , 30);
3 // se p n o aponta para v . end () o elemento foi encontrado
4 if ( p != v . end ())
5 std :: cout << " Elemento encontrado : " << * p << endl ;
6 else
7 std :: cout << " Elemento n o encontrado " << endl ;
29.1.2 Busca binria

Uma busca binria pode ser feita com as funes binary_search, upper_bound e lower_bound.
2 resultado = binary_search ( v . begin () , v . end () , 30);
412 Captulo 29. Algoritmos Eficientes
3 // resultado diz se o elemento estava na sequ ncia

4 if ( resultado )
5 std :: cout << " Elemento encontrado " << endl ;
6 else
7 std :: cout << " Elemento n o encontrado " << endl ;
A funo binary_search no retorna iteradores. Para iteradores, precisamos das funes
upper_bound e lower_bound.
2 p1 = lower_bound ( v . begin () , v . end () , 20);
3 p2 = upper_bound ( v . begin () , v . end () , 20);
4 cout << " primeiro elemento 20 na posi o " << ( p1 - v . begin ()) << endl ;
5 cout << " ltimo elemento 20 ap s posi o " << ( p2 - v . begin ()) << endl ;
29.2 Ordenao
A ordenao de elementos pode ser feita com a funo sort. No caso geral, sempre mais
conveniente utilizar a funo sort do STL. Esta usualmente uma implementao do algoritmo
introsort, que eficiente e tem custo O(n log n) para todos os casos.
1 // a fun o ordena a sequ ncia entre 2 iteradores ( ou endere os )
2 sort ( v . begin () , v . end ());
3 for ( int i = 0; i < v . size (); ++ i ){
4 std :: cout << v [ i ] << ;
5 }
6 cout << endl ;
Note que a funo sort aceita o envio de um predicado para a funo, caso seja necessrio
utilizar um critrio de ordenao diferente do operador <.
1 // a fun o ordena a sequ ncia entre 2 iteradores ( ou endere os )
2 sort ( v . begin () , v . end () , []( int a , int b ){ return b < a ;});
3 for ( int i = 0; i < v . size (); ++ i ){
4 std :: cout << v [ i ] << ;
5 }
6 cout << endl ;
Nas prximas sees temos implementaes de outros algoritmos importantes de ordenao,
apresentados neste livro. Todas as funes tem a mesma sintaxe da funo sort, recebendo
apenas dois iteradores genricos.
29.2.1 Ordenao por seleo

A ordenao por seleo pode ser implementada eficientemente da seguinte maneira.
1 template < typename Iterador , typename Predicado >
2 void selection_sort ( Iterador inicio , Iterador fim , Predicado comp ) {
3 for ( auto i = inicio ; i != fim ; ++ i ) {
4 iter_swap (i , min_element (i , fim , comp ));
5 }
6 }
A funo depende de um template que define o iterador e outro template que define o
predicado. O template do iterador garante que a funo funcionar para qualquer tipo de iterador
29.2 Ordenao 413
ou mesmo endereo na memria. A funo recebe um iterador que marca o incio da sequncia
e outro que marca uma posio aps o fim da sequncia. O template do predicado para uma
funo genrica que ser usada para indicar quando um elemento maior que outro. Caso seja
necessrio utilizar a funo com o predicado padrom que o operador <, a seguinte funo
pode ser chamada:
1 template < typename Iterador >
2 void selection_sort ( Iterador inicio , Iterador fim ) {
3 typedef typename iterator_traits < Iterador >:: value_type Tipo ;
4 insertion_sort ( inicio , fim , less < Tipo >());
5 }
Na linha 3 descobrimos o tipo do iterador e o chamamos de Tipo. Na linha 4, chamamos a
verso original da funo com o operador < para este tipo de dados.
O for do algoritmo percorre todos os elementos com o iterador i. Para cada elemento
fazemos uma troca com a funo iter_swap. A troca feita entre o elemento i e o menor
elemento entre i e fim. A funo min_element do STL utilizada para encontrar este menor
elemento.
29.2.2 Ordenao por insero

A ordenao por insero pode ser implementada eficientemente da seguinte maneira.
2 void insertion_sort ( Iterador inicio , Iterador fim , Predicado comp ) {
3 for ( auto i = inicio ; i != fim ; ++ i ) {
4 rotate ( upper_bound ( inicio , i , *i , comp ) , i , i + 1);
5 }
6 }
7
9 void insertion_sort ( Iterador inicio , Iterador fim ) {
11 insertion_sort ( inicio , fim , less < Tipo >());
12 }
O templates e sobrecargas da funo so novamente definidos para considerar um predicado
qualquer na funo.
Na primeira definio, um iterador i percorre todos os elementos. Para cada elemento,
achamos sua posio correta no subarranjo ordenado entre inicio e i. Para isto, utilizamos uma
busca binria com a funo upper_bound. Isto faz com que a busca pela posio correta ocorre
muito mais rapidamente. O elemento i colocado em sua posio correta com a funo rotate.
29.2.3 Merge sort

O merge sort pode ser implementado eficientemente da seguinte maneira.
2 void mergesort ( Iterador inicio , Iterador fim , Predicado comp ) {
3 if ( fim - inicio > 1)
4 {
5 Iterador meio = inicio + ( fim - inicio ) / 2;
6 mergesort ( inicio , meio , comp );
7 mergesort ( meio , fim , comp );
414 Captulo 29. Algoritmos Eficientes
8 inplace_merge ( inicio , meio , fim , comp );

9 }
10 }
11
13 void mergesort ( Iterador inicio , Iterador fim ) {
15 mergesort ( inicio , fim , less < Tipo >());
16 }
Nesta funo, sempre que a sequncia for maior que 1, temos um arranjo (ou sequncia
qualquer) potencialmente desordenado e entramos em um bloco de comandos que ordena
recursivamente 2 subarranjo. Ordenamos o subarranjo que vai do incio ao meio do arranjo e
depois ordenamos o subarranjo que vai do meio ao fim do arranjo. A funo inplace_merge
intercala os dois subarranjos e um arranjo completo ordenado.
29.2.4 Quicksort
Para uma implementao eficiente do quicksort, precisamos de uma funo auxiliar. Primeira-
mente, a seguinte funo retorna o item mediano entre 3 elementos. Esta uma funo auxiliar
importante para se encontrar um piv eficiente.
2 T median ( T t1 , T t2 , T t3 )
3 {
4 if ( t1 < t2 )
5 {
6 if ( t2 < t3 )
7 return t2 ;
8 else if ( t1 < t3 )
9 return t3 ;
10 else
11 return t1 ;
12 }
13 else
14 {
15 if ( t1 < t3 )
16 return t1 ;
17 else if ( t2 < t3 )
18 return t3 ;
19 else
20 return t2 ;
21 }
22 }
A funo retorna o elemento mediano entre os elementos t1, t2 e t3. Podemos ento definir
a funo de ordenao como a seguir:
2 void quicksort ( Iterador inicio , Iterador fim , Predicado comp ) {
3 if ( fim - inicio > 1) {
5 Iterador meio = inicio + ( fim - inicio )/2;
29.2 Ordenao 415
6 Tipo pivo = mediana (* inicio , * meio , *( fim -1));

7 Iterador divisao = partition ( inicio , fim ,
8 [& pivo ,& comp ]( Tipo x ){ return comp (x , pivo );});
9 quicksort ( inicio , divisao -1 , comp );
10 quicksort ( divisao , fim , comp );
11 }
12 }
13
15 void quicksort ( Iterador inicio , Iterador fim )
16 {
18 quicksort ( inicio , fim , less < Tipo >());
19 }
Funo quicksort executada recursivamente sempre que a sequncia tiver mais de 1
elemento. O iterador meio aponta para o elemento do meio da sequncia. A mediana entre o
primeiro elemento, o ltimo elemento e o elemento do meio utilizada como piv no processo
de partio.
A partio feita pela funo partition, que recebe como terceiro parmetro o critrio
para elementos que deve estar esquerda da partio. No caso, este critrio ser menor que o
piv (utilizando o critrio de comparao definido). Para isto, pivo e comp so enviados para a
funo lambda.
A partio divide a sequncia em duas subsequncias, divididas pelo iterador divisao.
Assim, precisamos apenas chamar a funo quicksort recursivamente para cada subsequncia.
0 1
1 0 0 0 1 1 10 0 11 1 01 1 0
0 1 1 1 0 1 0
10 1 0 1 10 1 1 1 00 1 0 0 11 0 0 0 11 0 0 1 10 1 0
0
1
1 1
1
0
1
0 1
1
1
0
0 0
0 1
1
0
1
11
1 1
1 1 10
1 00
0 0
0
10 1
1 11
0 1 1
0
1
1
0 0
0
100 10
0
0
1
1
000 0 1
1
0 0
1
0 111 0
0
00 1
0
011 10
1
0
1
0
0
010 1
0
1 0
1
0 111 1
0
10
0
1 0 1
1 0 1
1 1 0 0 11
0 1 1 01 01 1
10 1 11 1 1 0
0 1
010 1
1 0
111 0
1 0
001 1
0 0
111 0
0 0
111 1
0 1
001 0
0
1 0
1
0
1
1 1 1 1
0
1
1 11 1 01
1
1 0
1 1 0 000
0 1
1 1 0
1 10
0 0
0 1 0
1
0 0
1 0 1 1 0 0 1 0 1 0 1 0 0 1 1 1 1
11
0
0 0
1
1 0
1
0 10
1
1
0
10 0
0
00
1
0 0 1 0 1
01 1 0 1 0 11 0 1
1 0 11 0 1 1
1 100 1
0 0
001 0
1 0
000 1 0 1
11
1
10
1
0
1
1 10
1
1 0
0 0
1
0
1 01
0
0 0
1 1
0 10
1
00
1
1
1 01
1
1
1 0
1
1
0 10
1 0
0
0
1
0
0 1 0
0
0
0 1 0
0
1
0 1 0
0 1
1
0 0
01
0 1
0 0 11
0 11
1 0
0 11 1
1 10
1
0 1
0
1
1 0 1
1
001 1
10
0
0
1
001 0
0
1
0 0
1 1 101 0
0
00 0
0
101 1
00
0
1
1
111
0
0
1
1 0
0 1 101 0
1
00
0 1 1 1 0 1 1 0 10 1 1 0 00 0 1 0 10 0 1 1
01
1 1 0
1 0
1
0
1 01
1 1
1 01
1
1 01
0 1 0
0 0
0
0
1
01
1 0
0 1
0
1
0 00
0 1
0
0
0
1
1 11
0 1 0
1 0
1
0 0
1
1
1
1
0
1 0 1
0
1
0
00 0
1
110 0 1
0
1 0
0 1
110 0
1
1 0
0
0
000 0
0 1 1
1
0
0 0
00 1 ndice
00 0 01 0 01 0 00 0 11 1
1 1 1
1
1
0 0 0
1
0 1 1
0
0 1 1 0
000
1
1
0
10
0
101
1
0 11 0
0
100
1 1
0 0 0 1
1
0 0 0 0 1 0 1 1 0 1 1 0 0 0
10 00
1 1 10 0 0 1 0 0 11 1 10 1 10 00
0 1 010 1 1 1 0 01 1 11
Anlise da busca sequencial . . . . . . . . . . . . 199

Anlise da ordenao por insero . . . . . . 225
A Anlise da ordenao por seleo . . . . . . . 217
Anlise de Algoritmos . . . . . . . . . . . . . . . . 189
Acesso aleatrio . . . . . . . . . . . . . . . . . . . . . . 285 Anlise do algoritmo quicksort . . . . . . . . . 257
Adaptabilidade em ordenao . . . . . . . . . . 217 Anlise do mtodo merge sort . . . . . . . . . . 243
Adaptadores de container . . . . . . . . . . . . . . 333 Anlise do piv para o quicksort . . . . . . . . 257
Adiando o critrio de parada . . . . . . . . . . . . 96 Aninhando estruturas de controles . . . . . . . 77
Algoritmo de ordenao do merge sort . . 241 Aritmtica com ponteiros . . . . . . . . . . . . . . 113
Algoritmo de ordenao do quicksort . . . 254 Arranjos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Algoritmo de ordenao por insero . . . 221 Arranjos associativos . . . . . . . . . . . . . . . . . . 309
Algoritmo de ordenao por seleo . . . . 213 Arranjos como parmetros . . . . . . . . . . . . . 139
Algoritmo de partio . . . . . . . . . . . . . . . . . 251 Arranjos de objetos . . . . . . . . . . . . . . . . . . . 364
Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Arranjos Multidimensionais . . . . . . . . . . . . . 62
Algoritmos da STL . . . . . . . . . . . . . . . . . . . 345 Arranjos Unidimensionais . . . . . . . . . . . . . . 57
Algoritmos Eficientes . . . . . . . . . . . . . . . . . 411 rvores Binrias de Pesquisa . . . . . . . . . . . 311
Algoritmos eficientes de ordenao . . . . . 233 Balanceamento . . . . . . . . . . . . . . . . . . . 317
Algoritmos modificadores da STL . . . . . . 345
Algoritmos no modificadores da STL . . 348
Algoritmos numricos da STL . . . . . . . . . . 351
Algoritmos simples de ordenao . . . . . . . 211 B
Alocao automtica de memria . . . . . . . 161
Alocao de memria . . . . . . . . . . . . . . . . . 161 Balanceamento de rvores Binrias . . . . 317
Alocao dinmica de arranjos . . . . . . . . . 166 Biblioteca Padro de Templates . . . . . . . . 272
Alocao dinmica de arranjos multidimensi- Binary Search Tree . . . . . . . . . . . . . . . . . . . . 311
onais . . . . . . . . . . . . . . . . . . . . . . . . 170 Busca binria . . . . . . . . . . . . . . . . . . . . 199, 411
Alocao dinmica de memria . . . . . . . . 162 Busca em arranjo . . . . . . . . . . . . . . . . . . . . . 411
Alterando variveis externas . . . . . . . . . . . . 75 Busca em arranjos . . . . . . . . . . . . . . . . . . . . 197
Anlise da busca binria . . . . . . . . . . . . . . . 203 Busca sequencial . . . . . . . . . . . . . . . . . 198, 411
418 NDICE
Containers associativos ordenados . . . . . . 305

Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 319
C Como funcionam . . . . . . . . . . . . . . . . . 311
Containers de primeira classe . . . . . . . . . . 333
C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Containers de segunda classe . . . . . . . . . . 333
Cabealhos de funo . . . . . . . . . . . . . . . . . 124 Containers Sequenciais
Cadeias de caracteres . . . . . . . . . . . . . . . . . . . 59 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 297
Caso base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Comparao . . . . . . . . . . . . . . . . . . . . . 298
Caso mdio . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Containers sequenciais . . . . . . . . . . . . . . . . 274
Chave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 Contrutores . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 Critrio de parada . . . . . . . . . . . . . . . . . . . . . . 93
Classes de algoritmos . . . . . . . . . . . . . . . . . 194
Comentrios. . . . . . . . . . . . . . . . . . . . . . . . . . .18
Comparao entre algoritmos de ordenao
262 D
Comparao entre containers e arranjos . 289
Dados lgicos e comparaes . . . . . . . . . . . 34
Comparando algoritmos . . . . . . . . . . . . . . . 189
Declarao de funes . . . . . . . . . . . . . . . . 124
Compilador . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Deduo do tipo de dado . . . . . . . . . . . . . . 400
Complexidade cbica . . . . . . . . . . . . . . . . . 195
Definio de funes . . . . . . . . . . . . . . . . . . 124
Complexidade constante . . . . . . . . . . . . . . . 194
deque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Complexidade de memria em algoritmos de
Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 297
ordenao . . . . . . . . . . . . . . . . . . . 210
Como funciona . . . . . . . . . . . . . . . . . . . 280
Complexidade de tempo em algoritmos de
Utilizao . . . . . . . . . . . . . . . . . . . . . . . 279
ordenao . . . . . . . . . . . . . . . . . . . 210
Destrutores. . . . . . . . . . . . . . . . . . . . . . . . . . .374
Complexidade dos algoritmos . . . . . . . . . . 190
Destrutores de objetos membros . . . . . . . . 378
Complexidade exponencial . . . . . . . . . . . . 195
Diviso e conquista . . . . . . . . . . . . . . . . . . . 233
Complexidade fatorial . . . . . . . . . . . . . . . . . 195
Dominao assinttica. . . . . . . . . . . . . . . . .191
Complexidade linear . . . . . . . . . . . . . . . . . . 194
Complexidade logaritmica . . . . . . . . . . . . . 194
Complexidade loglinear . . . . . . . . . . . . . . . 195
Complexidade quadrtica . . . . . . . . . . . . . . 195 E
Complexidade quasilinear . . . . . . . . . . . . . 195
Composio de objetos . . . . . . . . . . . . . . . . 377 erase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Conceitos de ordenao de arranjos . . . . . 208 Escopo de arquivo . . . . . . . . . . . . . . . . . . . . 103
Concluso sobre algoritmos de ordenao265 Escopo de bloco . . . . . . . . . . . . . . . . . . . . . . 103
Condies de inicializao de estruturas de Escopo de variveis . . . . . . . . . . . . . . . . . . . 103
repetio . . . . . . . . . . . . . . . . . . . . . 78 Espaos de Nomes Padro . . . . . . . . . . . . . . 18
Condicional se . . . . . . . . . . . . . . . . . . . . . . . . . 43 Estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Estruturas condicionais . . . . . . . . . . . . . . . . . 43
Construtor de cpia . . . . . . . . . . . . . . . . . . . 370 Estruturas de dados . . . . . . . . . . . . . . . . . . . 271
Construtores de objetos membros . . . . . . 379 Estruturas de repetio . . . . . . . . . . . . . . . . . 69
Contador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Estruturas sequenciais . . . . . . . . . . . . . . . . . . 17
Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 Exemplo de aplicao da ordenao por inser-
Funo construtura . . . . . . . . . . . . . . . 295 o . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Containers associativos desordenados . . . 319 Exemplo de aplicao da ordenao por sele-
Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 324 o . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Como funcionam . . . . . . . . . . . . . . . . . 321 Exemplo de aplicao do merge sort . . . . 233
Containers associativos e conjuntos . . . . . 305 Exemplo de aplicao do quicksort . . . . . 244
Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 325 Expresses com ponteiros . . . . . . . . . . . . . 113
NDICE 419
Funes genricas . . . . . . . . . . . . . . . . 295

Programao com... . . . . . . . . . . . . . . . 404
F
Falha de segmentao . . . . . . . . . . . . . . . . . 113 L

Fator de carga . . . . . . . . . . . . . . . . . . . . . . . . 324
Fila de prioridade . . . . . . . . . . . . . . . . . . . . . 342 Laos aninhados . . . . . . . . . . . . . . . . . . . . . . . 86
Filas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 Laos apenas com critrio de parada . . . . . 93
Fluxo de Entrada . . . . . . . . . . . . . . . . . . . . . . 22 Laos com contadores . . . . . . . . . . . . . . . . . . 69
for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Laos infinitos . . . . . . . . . . . . . . . . . . . . . . . . . 96
for baseado em intervalo . . . . . . . . . . . . . . 403 Limites fortes . . . . . . . . . . . . . . . . . . . . . . . . 193
Funo de complexidade . . . . . . . . . . . . . . 190 list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Funo de custo . . . . . . . . . . . . . . . . . . . . . . 190 Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Funes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Como funciona . . . . . . . . . . . . . . . . . . . 282
Funes annimas . . . . . . . . . . . . . . . . . . . . 401
Funes com iteradores . . . . . . . . . . . . . . . . 291
Funes e o escopo de suas variveis . . . 124 M
Funes e suas variveis . . . . . . . . . . . . . . . 124
Funes lambda . . . . . . . . . . . . . . . . . . . . . . 401 map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Funes simples . . . . . . . . . . . . . . . . . . . . . . 122 Medida de custo real . . . . . . . . . . . . . . . . . . 190
Medida por modelos matemticos . . . . . . 190
Medindo tempo . . . . . . . . . . . . . . . . . . . . . . . 408
G Melhor caso . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Melhor caso, pior caso e caso mdio . . . . 191
Getters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 Membro chave . . . . . . . . . . . . . . . . . . . . . . . 197
Merge sort . . . . . . . . . . . . . . . . . . . . . . . 233, 413
Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . 233
H Implementao Eficiente . . . . . . . . . . 413
Minha primeira funo . . . . . . . . . . . . . . . 123
Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Modelos de comparao . . . . . . . . . . . . . . . 190
Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 Custo real . . . . . . . . . . . . . . . . . . . . . . . . 190
Herana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380 Modelos matemticos . . . . . . . . . . . . . 190
Modularizao de programas . . . . . . . . . . . 121
multimap . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
I multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . 20
if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 N
if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
if-else aninhados . . . . . . . . . . . . . . . . . . . . . . . 47 Nmeros aleatrios . . . . . . . . . . . . . . . . . . . 409
Implementao . . . . . . . . . . . . . . . . . . . . . . . 390 Notao O . . . . . . . . . . . . . . . . . . . . . . . 191, 193
Indentao . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
insert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Instncia de objetos . . . . . . . . . . . . . . . . . . . 362 O
Intercalao . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 Objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
Interface e Implementao . . . . . . . . . . . . . 390 Objetos de funo . . . . . . . . . . . . . . . . . . . . 400
Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 Omitindo a varivel de retorno . . . . . . . . . 135
Categorias . . . . . . . . . . . . . . . . . . . . . . . 291 Operaes com notao O . . . . . . . . . . . . . 193
Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . 289 Operador de cpia e movimento . . . . . . . . 405
420 NDICE
Operador de Converso . . . . . . . . . . . . . . . . 388 Ponteiros inteligentes . . . . . . . . . . . . . . . . . 399

Operador de desreferenciao . . . . . . . . . . 110 Ponteiros para objetos . . . . . . . . . . . . . . . . . 363
Operador de endereo . . . . . . . . . . . . . . . . . . 55 Porqu programar . . . . . . . . . . . . . . . . . . . . . . 13
Operador ternrio . . . . . . . . . . . . . . . . . . . . . . 50 Prticas de programao em C++ . . . . . . . 399
Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Primeiros programas . . . . . . . . . . . . . . . . . . . 17
Operadores aritmticos . . . . . . . . . . . . . . . . . 25 Priority queue . . . . . . . . . . . . . . . . . . . . . . . . 342
Operadores de atribuio . . . . . . . . . . . . . . . 21 priority_queue . . . . . . . . . . . . . . . . . . . . . 342
Operadores de atribuio aritmticos . . . . . 27 Processamento de arquivos sequenciais . 173
Operadores de incremento e decremento . 30 Programao com iteradores . . . . . . . . . . . 404
Operadores lgicos . . . . . . . . . . . . . . . . . . . . . 37 Programao estruturada . . . . . . . . . . . . . . . 13
Operadores relacionais . . . . . . . . . . . . . . . . . 34 Programao genrica . . . . . . . . . . . . . . . . . 272
Ordenao . . . . . . . . . . . . . . . . . . . . . . . . . . . 412 Programao Orientada a Objetos . . . . . . 359
Algoritmos eficientes . . . . . . . . . . . . . 233 Programas iterativos . . . . . . . . . . . . . . . . . . 143
Algoritmos simples . . . . . . . . . . . . . . . 211 Programas recursivos . . . . . . . . . . . . . . . . . 143
Conceitos . . . . . . . . . . . . . . . . . . . . . . . . 208 Programas sequenciais . . . . . . . . . . . . . . . . . 17
Ordenao de arranjos . . . . . . . . . . . . . . . . . 207
Ordenao estvel . . . . . . . . . . . . . . . . . . . . 208
Ordenao instvel . . . . . . . . . . . . . . . . . . . . 208 Q
Ordenao por insero . . . . . . . . . . . 218, 413
Desvantagens . . . . . . . . . . . . . . . . . . . . 226 Queue
Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . 218 queue . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Implementao Eficiente . . . . . . . . . . 413 Quicksort . . . . . . . . . . . . . . . . . . . . . . . 244, 414
Vantagens . . . . . . . . . . . . . . . . . . . . . . . 226 Desvantagens . . . . . . . . . . . . . . . . . . . . 258
Ordenao por seleo . . . . . . . . . . . . 211, 412 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . 244
Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . 211 Implementao Eficiente . . . . . . . . . . 414
Implementao Eficiente . . . . . . . . . . 412 Particionamento . . . . . . . . . . . . . . . . . . 246
Outros algoritmos de ordenao . . . . . . . . 266 Piv timo . . . . . . . . . . . . . . . . . . . . . . . 257
Vantagens . . . . . . . . . . . . . . . . . . . . . . . 258
P
R
Parmetros de funo . . . . . . . . . . . . . . . . . 127
Parmetros mltiplos em funes . . . . . . . 129 Recurso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Particionamento no algoritmo quicksort . 246 Recurso infinita. . . . . . . . . . . . . . . . . . . . . .149
Passagem de parmetros . . . . . . . . . . . . . . . 132 Recursos de objetos . . . . . . . . . . . . . . . . . . . 385
Passagem de parmetros por referncia . 133 Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Passagem de parmetros por valor . . . . . . 132 Relao entre do-while e while . . . . . . . . 97
Passo recursivo . . . . . . . . . . . . . . . . . . . . . . . 143 Relao entre while e for . . . . . . . . . . . . . . 95
Percorrendo arranjos de arranjos . . . . . . . . . 88 Relaes entre objetos . . . . . . . . . . . . . . . . . 377
Percorrendo containers . . . . . . . . . . . . . . . . 285 Repetio de processos similares . . . . . . . . 73
Percorrer arranjos . . . . . . . . . . . . . . . . . . . . . . 82 Repeties determinadas pelo usurio . . . . 72
Pilhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 Resumo de comandos . . . . . . . . . . . . . . . . . 181
Pior caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Retornando vrios valores . . . . . . . . . . . . . 137
Piv timo no quicksort . . . . . . . . . . . . . . . 257 Retorno de valor . . . . . . . . . . . . . . . . . . . . . . 126
Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . 383
Ponteiro nulo . . . . . . . . . . . . . . . . . . . . . . . . . 168
Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 S
Ponteiros como parmetros . . . . . . . . . . . . 141
Ponteiros e arranjos . . . . . . . . . . . . . . . . . . . 115 Se . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Ponteiros e estruturas . . . . . . . . . . . . . . . . . . 157 Se-seno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
NDICE 421
Se-seno aninhados . . . . . . . . . . . . . . . . . . . . 47 Como funciona . . . . . . . . . . . . . . . . . . . 275

Setters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 Utilizao . . . . . . . . . . . . . . . . . . . . . . . 274
Setters e Getters . . . . . . . . . . . . . . . . . . . . . . 372
Sobrecarga de construtores . . . . . . . . . . . . 368
Sobrecarga de operadores . . . . . . . . . . . . . . 371
sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Standard Template Library . . . . . . . . . . . . 272
STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
struct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Subscritos. . . . . . . . . . . . . . . . . . . . . . . . . . . .285
Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Deque . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
deque
Como funciona, 287
list . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
vector
Como funciona, 286
Superclasse . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Switch
switch . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Tabela verdade . . . . . . . . . . . . . . . . . . . . . . . . 38
Tabelas Hash . . . . . . . . . . . . . . . . . . . . . . . . . 321
Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Fator de carga . . . . . . . . . . . . . . . . . . . . 324
Tratamento de Colises . . . . . . . . . . . 322
Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
Templates de Objetos . . . . . . . . . . . . . . . . . 385
Tempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Tipos Fundamentais de Dados . . . . . . . . . . . 14
Tratamento de Colises . . . . . . . . . . . . . . . . 322
Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Vriaveis no alteradas em funes . . . . . 139

Variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Varivel contadora . . . . . . . . . . . . . . . . . . . . . 69
Varivel global . . . . . . . . . . . . . . . . . . . . . . . 103
Vazamento de memria . . . . . . . . . . . . . . . . 164
vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Anlise . . . . . . . . . . . . . . . . . . . . . . . . . . 297

Livrocpp PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Livrocpp PDF

Încărcat de

Drepturi de autor:

Formate disponibile

10 0 0

11 00 1 001 100 1 000 1

Edio: 19 de Maro de 2015

5 Operador de endereo e arranjos . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

7 Escopo de variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

9 Modularizao de programas com funes . . . . . . . . . . . . . . . . 121

11 Alocao de memria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

12 Processamento de arquivos sequenciais . . . . . . . . . . . . . . . . . . . . 173

14 Anlise de Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

15 Busca em arranjos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

III Estruturas de Dados

18 Containers Sequenciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

19 Percorrendo containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

21 Containers Associativos e Conjuntos . . . . . . . . . . . . . . . . . . . . . . . 305

22 Adaptadores de Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

23 Algoritmos da STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

IV Programao Orientada a Objetos

24 Classes e Instncias de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

25 Definindo classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

26 Relaes entre objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

27 Recursos de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

V Prticas de Programao em C++

28 Prticas Comuns de Programao em C++ . . . . . . . . . . . . . . . . . 399

ndice Remissivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

5 Operador de endereo e arranjos . . . . 55

7 Escopo de variveis . . . . . . . . . . . . . . . . 103

9 Modularizao de programas com fun-

11 Alocao de memria . . . . . . . . . . . . . 161

12 Processamento de arquivos sequenciais

13 Resumo de comandos . . . . . . . . . . . . . . 181

1.1 Porqu Programar

1.2 Linguagem C++

! Como referncia para leitores que j so programadores porm no esto acostumados

1.4 Tipos Fundamentais de Dados

Tipos de dados Palavra-Chave Exemplos

Tabela 1.1: Tipos Fundamentais de Dados em C++

2.1 Primeiros programas

1 # include < iostream >

O comando apresentado na primeira linha, #include <iostream>, inclui a biblioteca

2.2 Segundo programa em C++ e espao de nomes padro

1 # include < iostream >

Ol, Mundo! Ol! Mais uma vez!

2.4 Criando variveis

numero letra num_real teste

Figura 2.2: Quatro variveis criadas que ainda no tm valores especificados.

Este programa criou 4 variveis!

variavel1 8 variavel1 4 variavel2 6

3.1 Operador de atribuio

A varivel numero do tipo int tem valor 4

3.2 Fluxo de entrada

1 # include < iostream >

numero1 numero2 soma

digite o primeiro numero:

digite o primeiro numero: 3.14

numero1 3.14 numero2 soma

digite o primeiro numero: 3.14

numero1 3.14 numero2 2.7 soma

numero1 3.14 numero2 2.7 soma 5.84

O programa finaliza com uma ltima mensagem.

digite o primeiro numero: 3.14

3.2.1 Alteraes possveis

3.3 Operadores aritmticos

A Tabela 3.1 apresenta os operadores aritmticos.