C C A Biblia_BlocoFontes

Prévia do material em texto

http://blocofontes.blogspot.com.br/
Convertido para PDF por: Daniel dos Santos
Kris J a m s a , Ph .D. 
La r s Kl a n d e r
Tradução e Revisão Técnica
Jeremias René D. Pereira dos Santos 
Analista de Software
MAKRON Books do Brasil Editora Ltda. 
Rua Tabapuã, 1.348, Itaim-Bibi 
CEP 04533-004 — São Paulo — SP 
(011) 829-8604 e (011) 820-6622 
makron@book.com.br
São Paulo • Rio de Janeiro • Ribeirão Preto • Belém • Belo Horizonte • Brasília • Campo Grande • Cuiabá • Curitiba • Florianópolis • Fortaleza
• Goiânia • Manaus • N atal • Porto Alegre • Recife • Salvador
Barcelona • Bogotá • Buenos Aires • Caracas • Ciudad dei México • Frankfurt • Guadalajara • Lisboa • Londres • Madrid • Montevideo
• New York • Paris • Porto • Santiago
Daniel dos Santos Pinheiro
http://blocofontes.blogspot.com.br/
Tamanho: 34,21MB
Tipo: PDF
Do Original Jamsa’s C/C++ Programmer's Bible
Copyright © 1998 by Jamsa Press
Copyright © 1999 MAKRON Books do Brasil Editora Ltda.
Todos os direitos para a língua portuguesa reservados pela MAKRON Books do 
Brasil Editora Ltda. Nenhuma parte desta publicação poderá ser reproduzida, 
guardada pelo sistema “retrieval” ou transmitida de qualquer modo ou por 
qualquer outro meio, seja este eletrônico, mecânico, de fotocópia, de gravação, ou 
outros, sem prévia autorização, por escrito, da Editora.
EDITOR: MILTON MIRA DE ASSUMPÇÀO FILHO
Gerente de Produção 
Silas Camargo
Editora Assistente 
Eugênia Pessotti
Produtora Editorial 
Salete Del Guerra
Design de Capa 
Marianne Helm 
James Rehrauer
Editoração Eletrônica: ERJ Informática Ltda.
Dados de Catalogação na Publicação
Programando em C/C+ + — A Bíblia; Kris Jamsa e Lars Klander 
traduçáo: e revisão técnica: Jeremias René D. Pereira dos Santos 
São Paulo: MAKRON Books, 1999.
Título original: Jamsa’s C/C+ + Programmer’s Bible
ISBN: 85.346.1025-8
S u m á r io
In t r o d u ç ã o à L in g u a g e m C
Uma Introdução à Program ação............................................................... 1
Criando um Arquivo-Fonte em A S C II......................................................2
Compilando Seu P rogram a.......................................................................... 3
Compreendendo os Erros de Sintaxe ........................................................4
Estrutura de um Típico Programa em C ................................................. 5
Acrescentando Comandos aos Seus Program as........................................6
Exibindo Saída em uma Nova L in h a ........................................................7
Considera as Letras Maiúsculas e Minúsculas D iferen tes......................8
Compreendendo os Erros Lógicos ............................................................ 9
Compreendendo o Processo de Desenvolvimento de um
Program a.....................................................................................................10
Compreendendo os Tipos de Arquivo ................................................ 11
Compreendendo Melhor o L in k ed ito r................................................ 12
Compreendendo os Arquivos de C abeçalho ....................................... 13
Ajudando o Compilador a Localizar os Arquivos de Cabeçalho . . . 14
Agilizando as C om pilações.....................................................................15
Comentando Seus P rogram as................................................................ 16
Melhorando a Legibilidade do Seu Program a.....................................17
Prestando Atenção às Mensagens de Advertência do Compilador . 18
Controlando as Advertências do C om pilador.....................................19
Usando Comentários para Excluir Comandos do Programa ......... 20
Compreendendo a Importância dos N o m e s ....................................... 21
Compreendendo o Ponto-e-V írgula.....................................................22
Apresentando as Variáveis.......................................................................23
Atribuindo um Valor a uma V ariável...................................................24
Compreendendo os Tipos de Variáveis................................................ 25
Declarando Múltiplas Variáveis do Mesmo T ip o ..............................26
Comentando Suas Variáveis na Declaração ....................................... 27
Atribuindo Valores às Variáveis na D eclaração.................................. 28
Inicializando Múltiplas Variáveis durante a Declaração .................. 29
Usando Nomes Representativos para as Variáveis..............................30
Compreendendo as Palavras-chave de C ..............................................31
Compreendendo as Variáveis do Tipo int ......................................... 32
Compreendendo as Variáveis do Tipo c h a r ....................................... 33
Compreendendo as Variáveis do Tipo f lo a t ....................................... 34
Compreendendo as Variáveis do Tipo double .................................. 35
Atribuindo Valores aos Valores em Ponto F lu tu a n te .......................36
Compreendendo os Modificadores de T i p o ....................................... 37
Compreendendo o Modificador de Tipo unsigned ......................... 38
Compreendendo o Modificador de Tipo lo n g .................................. 39
Combinando os Modificadores de Tipo unsigned e lo n g ................ 40
Trabalhando com os Valores Grandes ................................................ 41
Compreendendo o Modificador de Tipo register............. . ............... 42
Compreendendo o Modificador de Tipo sh o rt.................................. 43
Om itindo int das Declarações Modificadas ....................................... 44
Compreendendo o Modificador de Tipo signed................................ 45
Múltiplas Operações de A tribuição ....................................................... 46
Atribuindo o Valor de um Tipo de Variável a um Tipo
D iferente .....................................................................................................47
Criando Seus Próprios T ip o s ................................................................ 48
Atribuindo um Valor Hexadecimal ou O c ta l .....................................49
Compreendendo o Extravasamento....................................................... 50
Compreendendo a Precisão.....................................................................51
Atribuindo Apóstrofos e Outros Caracteres ....................................... 52
Introdução ao Comando p r in tf ..............................................................53
Exibindo Valores do Tipo int Usando p r in tf .....................................54
Imprimindo um Valor Inteiro Octal ou H exadecim al.....................55
Exibindo Valores do Tipo unsigned int Usando p r i n t f .................56
Exibindo Valores do Tipo long int Usando p r in tf .......................... 57
Exibindo Valores do Tipo float Usando p r in tf .................................58
Exibindo Valores do Tipo char Usando p r in tf .................................59
Exibindo Valores de Ponto Flutuante em um Formato
E xponencial..................................................................................................60
Exibindo Valores em Ponto F lu tuante .....................................................61
Exibindo uma String de Caracteres Usando p r i n t f ............................. 62
Exibindo um Endereço de Ponteiro Usando p rin tf ........................... 63
Precedendo um Valor com um Sinal de Adição ou de
Sub tração ...................................................................................................... 64
Formatando um Valor Inteiro Usando p r in t f ....................................... 65
Saída de Inteiros Preenchida com Zeros ................................................66
Exibindo um Prefixo Antes dos Valores Octais ou
H exadecim ais............................................................................................... 67
Formatando umValor em Ponto Flutuante Usando p r in tf ................ 68
Formatando a Saída Exponencial............................................................. 69
Justificando à Esquerda a Saída de p r i n t f ............................................. 70
Combinando os Especificadores de Formato de p r i n t f ....................... 71
Quebrando uma String de Caracteres em Duas L inhas.......................72
Exibindo Strings do Tipo near e far .......................................................73
Trabalhando com os Caracteres Escape de p r i n t f ................................74
Determinando o Número de Caracteres Que p rin tf Exibiu ..............75
Usando o Valor de Retorno de p r in t f .................................................... 76
Usando o Controlador de Dispositivo A N S I................................ 77
Usando o Controlador ANSI para Limpar Sua T e la .......................... 78
Usando o Controlador ANSI para Exibir as Cores da T e la ................ 79
Usando o Controlador ANSI para Posicionar o Cursor ....................80
Executando Operações Matemáticas Básicas em C .............................. 81
Compreendendo a Aritmética do M ó d u lo ..............................................82
Compreendendo a Precedência e a Associatividade dos
O peradores.................................................................................................... 83
Forçando a Ordem de Avaliação dos Operadores ................................84
Compreendendo o Operador de Incremento de C ..............................85
Compreendendo o Operador de Decremento de C ........................... 86
Compreendendo uma Operação O U Bit a B i t .................................... 87
Compreendendo uma Operação E Bit a B i t ......................................... 88
Compreendendo uma Operação O U Exclusivo Bit a B i t .................. 89
Compreendendo a Operação Inverso Bit a B i t .................................... 90
Aplicando uma Operação ao Valor de uma V ariável............................91
Compreendendo o Operador Condicional de C .................................. 92
Compreendendo o Operador sizeof de C ............................................. 93
Efetuando um Deslocamento Bit a Bit .................................................. 94
Efetuando uma Rotação Bit a B i t ........................................................... 95
Compreendendo os Operadores Condicionais.......................................96
Compreendendo o Processamento Iterativo........................................... 97
Compreendendo Como C Representa Verdadeiro e Falso ................98
Testando uma Condição com i f ............................................................. 99
Compreendendo os Comandos Simples e Com postos.......................100
Testando a Igualdade................................................................................ 101
Efetuando Testes Relacionais.................................................................. 102
Executando uma Operação Lógica E para Testar Duas
Condições ...................................................................................................103
Executando uma Operação Lógica O U para Testar Duas
Condições .................................................................................................. 104
Executando uma Operação Lógica NÃO ( N O T ) ........................... 105
Atribuindo o Resultado de uma Condição ...................................... 106
Declarando Variáveis Dentro de Comandos Com postos................107
Usando Recuos para Melhorar a Legibilidade..................................108
Usando a Verificação Estendida de Ctrl+Break ................................ 109
Testando Valores de Ponto F lu tu a n te .................................................. 110
Laço de Repetição Infinito ........................................................................111
Testando uma A tribuição......................................................................... 112
Cuidado com os Comandos if-if-else..................................................... 113
Executando Comandos um Número Específico de V eze s ................ 114
Partes do Comando for São O p c io n a is ................................................ 115
Decrementando os Valores em um Comando f o r ..............................116
Controlando o Incremento do Laço fo r ................ ............................... 117
Usando Laços for com Valores char e f lo a t ......................................... 118
V
VI Programando em C/C++ — A B íbl ia
Compreendendo um Laço Null ......................................................... 119
Compreendendo o Laço Infinito .......................................................120
Usando o Operador Vírgula de C Dentro de um
Laço f o r .................................................................................................... 121
Evite Modificar o Valor de uma Variável de Controle em um Laço
f o r ........................... ' ................................................................................122
Repetindo um ou Mais Comandos Usando um Laço w h ile ......... 123
Compreendendo as Partes de um Laço w h ile .................................. 124
Repetindo um ou Mais Comandos Usando do ..............................125
Compreendendo o Comando continue de C .................................. 126
Finalizando um Laço Usando o Comando break de C ................ 127
Desvios com o Comando g o to ............................................................128
Testando Múltiplas C ond içõ es............................................................129
Compreendendo break Dentro de sw itc h ......................................... 130
Usando o Case default do Comando sw itch .....................................131
Definindo Constantes no Seu Program a........................................... 132
Compreendendo a Expansão de Macros e de C onstantes..............133
Nomeando as Constantes e as M a c ro s ..............................................134
Usando a Constante de Pré-processador _ F IL E _ ............................135
Usando a Constante de Pré-processador__LINE.... .........................136
Alterando a Contagem de Linha do Pré-processador.....................137
Gerando um Erro Incondicional do Pré-processador.....................138
Outras Constantes do Pré-processador..............................................139
Registrando a Data e a Hora do Pré-processador............................140
Testando a Adesão ao Padrão A N S I.................................................. 141
Testando C++ versus C .......................................................................142
Anulando a Definição de uma Macro ou C o n s ta n te .....................143
Comparando Macros e F u n çõ es......................................................... 144
Compreendendo Pragmas do C o m p ilad o r....................................... 145
Aprendendo sobre os Valores e Macros Predefinidos.....................146
Criando Seus Próprios Arquivos de Cabeçalho................................ 147
Usando #include <nomearq.h> ou #include "nom earq .h"........... 148
Testando Se um Símbolo Está D efinido........................................... 149
Efetuando o Processamento if-else .....................................................150
Efetuando um Teste de Condição de Pré-processador Mais
P oderoso .................................................................................................. 151
Realizando Processamento if-else e e lse-if ......................................... 152
Definindo Macros e Constantes Q ue Requerem Múltiplas
L in h a s ....................................................................................................... 153
Criando Suas Próprias M a c ro s ............................................................154
Não Coloque Ponto-e-Vírgula nas Definições de Macros ........... 155
Criando Macros M in e M a x ................................................................156
Criando Macros QUADRADO e CUBO .......................................157
Cuidado com os Espaços nas Definições das M acro s.....................158
Compreendendo Como Usar os Parênteses .....................................159
As Macros Não Têm T ip o .................................................................. 160
Co m p r e e n d e n d o a s S t r i n g s
Visualizando uma String de C ............................................................161
Como o Compilador Representa uma String de Caracteres......... 162
Como C Armazena as Strings de Caracteres.....................................163
Aprendendo Como ‘A’ Difere de “A” ................................................ 164
Representando um Apóstrofo Dentro de uma Constante
de S tr in g .................................................................................................. 165
Determinando o Tamanho de uma S tr in g ....................................... 166
Usando a Função strlen ....................................................................... 167
Copiando os Caracteres de uma String em O utra S trin g ..............168
Anexando o Conteúdo de uma String em O u t r a ............................169
Anexando n Caracteres em uma S tring ..............................................170
Transformando uma String em O u t r a ..............................................171
Não Ultrapasse o Tamanho de uma String .....................................172
Determinando Se Duas Strings São ou Não Iguais .....................173
Ignorando a Caixa ao Determinar Se as Strings São I g u a is ......... 174
Convertendo uma String de Caracteres para Maiúsculas ou
Minúsculas .............................................................................................. 175
O btendo a Primeira Ocorrência de um Caractere em uma
String .......................................................................................................176
Retornando um índice à Primeira Ocorrência de uma String . . . 177 
Encontrando a Ultima Ocorrência de um Caractere em uma 
String ....................................................................................................... 178
Retornando um índice à Última Ocorrência de uma S trin g ......... 179
Trabalhando com Strings do Tipo f a r ................................................180
Escrevendo Funções String para as Strings f a r .................................. 181
Contando o Número de Ocorrências de um Caractere em uma
S trin g ........................................................................................................ 182
Invertendo o Conteúdo de uma S tr in g ............................................. 183
Atribuindo um Caractere Específico a uma String In te ira ..............184
Comparando Duas Strings de Caracteres .........................................185
Comparando os Primeiros n Caracteres de Duas Strings ..............186
Comparando Strings sem Considerar a C a ix a ..................................187
Convertendo a Representação em String de Caracteres de um
N ú m e ro ....................................................................................................188
Duplicando o Conteúdo de uma String ...........................................189
Encontrando um Caractere da Primeira Ocorrência de um
Determinado C o n ju n to ........................................................................... 190
Localizando uma Substring Dentro de uma S tr in g ............................191
Contando o Número de Ocorrências da Substring ............................192
Obtendo um índice para uma Substring ..............................................193
Obtendo a Ocorrência Mais à Direita de uma S u b strin g ................ 194
Exibindo uma String sem o Específicador de Formato % s .............195
Removendo uma Substring de Dentro de uma String ................... 196
Substituindo uma Substring por O u tr a ................................................ 197
Convertendo uma Representação Numérica A S C II............................198
Determinando Se um Caractere É Alfanumérico .............................. 199
Determinando Se um Caractere É uma L e tra .................................... 200
Determinando Se um Caractere Contém um Valor A S C II.............. 201
Determinando Se um Caractere É um Caractere de Controle . . . 202
Determinando Se um Caractere É um D íg ito .................................... 203
Determinando Se um Caractere É um Caractere G rá fic o ................ 204
Determinando Se um Caractere É Maiúsculo ou Minúsculo . . . . 205
Determinando Se um Caractere É Imprimível ..................................206
Determinando Se um Caractere É um Sinal de Pontuação..............207
Determinando Se um Caractere Contém Espaço em Branco . . . . 208
Determinando Se um Caractere É um Valor Hexadecimal..............209
Convertendo um Caractere para M aiúscula...................................... 210
Convertendo um Caractere para Minúsculo ....................................211
Trabalhando com Caracteres ASCII ..................................................212
Escrevendo Saída Formatada em uma Variável S tring .................... 213
Lendo a Entrada de uma String de Caracteres ..................................214
"Tokenizando" as Strings para Poupar Espaço ............................... 215
Inicializando uma S t r in g ...................................................................... 216
F u n ç õ e s
Compreendendo as Funções ............................................................... 217
Usando Variáveis Dentro das Funções ............................................. 218
Compreendendo main Como uma F u n ção ...................................... 219
Introdução aos Parâm etros.................................................................... 220
Usando Parâmetros M ú ltip lo s ................................................................221
Compreendendo as Declarações de Parâmetros em Programas
C Mais A n tig o s .........................................................................................222
Retornando um Valor de uma Função ................................................223
Compreendendo o Comando re tu rn .....................................................224
Compreendendo os Protótipos de Função ............................................225
Compreendendo a Biblioteca de Execução ......................................... 226
Compreendendo os Parâmetros Formais e R ea is................................ 227
Solucionando os Conflitos nos N o m e s ................................................ 228
Funções Que Não Retornam i n t ........................................................... 229
Compreendendo as Variáveis Locais .....................................................230
Como as Funções Usam a Pilha ............................................................231
Compreendendo a Sobrecarga da F u n ç ã o ............................................232
Compreendendo Onde C Coloca as Variáveis L o ca is ....................... 233
Declarando Variáveis Globais ................................................................ 234
Evite Usar Variáveis G lo b a is ...................................................................235
Solucionando os Conflitos de Nomes de Variáveis Locais e
G lobais......................................................................................................... 236
Definindo Melhor o Escopo de uma Variável G lo b a l .......................237
Compreendendo a Chamada por V a lo r ................................................ 238
Evitando a Alteração no Valor do Parâmetro com a Chamada
por V a lo r ..................................................................................................239
Compreendendo a Chamada por Referência.................................... 240
Sumário VII
O btendo um E ndereço ......................................................................... 241
Usando um Endereço de M em ória .....................................................242Alterando o Valor de um Parâm etro.................................................. 243
Alterando Somente Parâmetros Específicos.......................................244
A Chamada por Referência Ainda Usa a P ilh a ................................ 245
Introduzindo as Variáveis de Funções que L em bram .....................246
Compreendendo Como C Inicializa Variáveis E státicas................ 247
Usando a Seqüência de Chamada Pascal ......................................... 248
Compreendendo o Efeito da Palavra-Chave Pascal......................... 249
Escrevendo um Exemplo de Linguagem M is ta ................................ 250
Compreendendo a Palavra-Chave cdecl ............................................251
Compreendendo a R ecursão ................................................................ 252
Compreendendo a Função Recursiva Fatorial.................................. 253
Programando O utro Exemplo Recursivo ......................................... 254
Exibindo Valores para Compreender Melhor a R ecursão..............255
Compreendendo a Recursão Direta e In d ire ta ................................ 256
Decidindo Usar ou Não a R ecursão .............................................. ' . . 257
Compreendendo Por Q ue as Funções Recursivas São Lentas . . . . 258
Compreendendo Como Remover a R ecursão.................................. 259
Passando Strings para as F u n çõ es....................................................... 260
Passando Elementos Específicos da M a tr iz .......................................261
Compreendendo const em Parâmetros F o rm a is ..............................262
Usar const Não Impede a Modificação do Parâmetro .................. 263
Compreendendo as Declarações de Strings Não-Limitadas ......... 264
Usando Ponteiros versus Declarações de S trin g ................................ 265
Como C Usa a Pilha para os Parâmetros S tring ..............................266
Compreendendo as Variáveis E x te rn as..............................................267
Colocando extern em Uso .................................................................. 268
Compreendendo a Variável Estática Externa .................................. 269
Compreendendo a Palavra-chave volatile ......................................... 270
Compreendendo a Estrutura de Chamada e o Ponteiro de
B ase............................................................................................................271
Chamando uma Função em Linguagem Assem bly......................... 272
Retornando um Valor a partir de uma Função em Linguagem
Assem bly.................................................................................................. 273
Introduzindo Funções Que Não Retornam V alo res....................... 274
Compreendendo as Funções Que Não Usam Parâmetros ............275
Compreendendo a Palavra-chave auto ..............................................276
Compreendendo o E sc o p o .................................................................. 277
Compreendendo as Categorias de Escopo de C ..............................278
Compreendendo o Espaço do Nome e os Identificadores ........... 279
Compreendendo a Visibilidade do Identificador ........................... 280
Compreendendo a Duração ................................................................ 281
Funções Que Suportam um Número Variável de Parâmetros . . . 282
Suportando um Número Variável de Parâm etros........................... 283
Como va_start, va_arg e va_end Funcionam .................................. 284
Criando Funções Q ue Suportam Muitos Parâmetros e Tipos . . . 285
O p e r a ç õ e s d e T e c l a d o
Lendo um Caractere do Teclado .......................................................286
Exibindo um Caractere de Saída......................................................... 287
Compreendendo a Entrada Bufferizada ........................................... 288
Atribuindo Entrada do Teclado a uma String ................................ 289
Combinando getchar e putchar ......................................................... 290
Lembre-se, getchar e putchar São M acros......................................... 291
Lendo um Caractere Usando E/S Direta ......................................... 292
Entrada Direta no Teclado sem a Exibição do C aractere..............293
Sabendo Quando Usar ‘\r* e ‘\n ’ .......................................................294
Executando Saída D ire ta .......................................................................295
Colando uma Tecla Digitada de Volta no Buffer do Teclado . . . 296
Saída Formatada Rápida Usando c p r in t f ......................................... 297
Entrada Rápida Formatada a partir do T e c la d o ..............................298
Escrevendo uma String de C aracteres................................................299
Escrita Mais Rápida de String Usando E/S D ire ta ......................... 300
Lendo uma String de Caracteres do T e c la d o .................................. 301
Executando Entrada de String Mais Rápida peJo T e c la d o ......... .. 302
Exibindo Saída em C o r e s .................................................................... 303
Limpando a Tela do V ídeo .................................................................. 304
Apagando até o Final da Linha A tu a l................................................ 305
Apagando a Linha Atual da Tela .......................................................306
Posicionando o Cursor para Saída na Tela ........................................ 307
Determinando a Posição de Linha e de Coluna ...............................308
Inserindo uma Linha em Branco na T e l a ...........................................309
Copiando Texto da Tela para um Buffer ...........................................310
Escrevendo um Buffer de Texto em uma Posição Específica
da T e la ........................................................................................................ 311
Determinando as Definições do Modo T e x to ....................................312
Controlando as Cores da T e la ...............................................................313
Atribuindo Cores de F u n d o ................................................................... 314
Definindo a Cor de Frente Usando T ex tC olor..................................315
Definindo a Cor de Fundo Usando textbackground........................ 316
Controlando a Intensidade do T e x to ...................................................317
Determinando o M odo Atual do Texto ............................................ 318
Movendo Texto da Tela de um Local para Outro ...........................319
Definindo uma Janela de T ex to ............................................................ 320
Usando o Valor Absoluto de uma Expressão In te ira .......................... 321
Usando o Arco C o-seno.......................................................................... 322
Usando o Arco Seno ...............................................................................323
Usando o Arco T angen te ........................................................................324
Obtendo o Valor Absoluto de um Número C om plexo...................325
Arredondando para Cima um Valor em Ponto F lu tuan te ............... 326
Usando o Co-seno de um  n g u lo ........................................................327
Usando o Co-seno Hiperbólico de um  n g u lo ................................. 328
Usando o Seno de um Ângulo ............................................................ 329
Usando o Seno Hiperbólico de um Ângulo .................................. 330
Usando a Tangente de um  n g u lo ...................................................... 331
Usando a Tangente Hiperbólica de um Ângulo ............................... 332
Realizando a Divisão Inteira ................................................................. 333
Trabalhando com Exponencial ............................................................ 334
Usandoo Valor Absoluto de uma Expressão em Ponto
F lu tu a n te ................................................................................................... 335
Usando o Resto em Ponto F lutuante................................................... 336
Usando a Mantissa e o Expoente de um Valor em Ponto
F lu tu a n te ................................................................................................... 337
Calculando o Resultado de x * 2 e ........................................................338
Calculando o Logaritmo N a tu ra l.......................................................... 339
Calculando o Resultado de loglO x........................................................340
Determinando os Valores Máximo e M ín im o ....................................341
Quebrando um Double em Seus Componentes Inteiro e Real . . . 342
Calculando o Resultado de xn ...............................................................343
Calculando o Resultado de 10 * ............................................................ 344
Gerando um Número A leatório.............................................................345
Mapeando Valores Aleatórios para um Intervalo Específico ......... 346
Inicializando o Gerador de Números Aleatórios ...............................347
Calculando a Raiz Quadrada de um Valor ..........................................348
Criando uma Rotina de Tratamento de Erro Matemático .............349
Arquivos, Diretórios e Discos
Determinando a Unidade de Disco A tu a l ...........................................350
Selecionando a Unidade A tu a l............................................................... 351
Determinando o Espaço Disponível no D isco ....................................352
Cuidado com o d b lsp ace ........................................................................353
Lendo as Informações de uma Tabela de Alocação de
A rquivos....................................... ............................................................354
Compreendendo a Identificação do D isco ........................................355
Efetuando uma Leitura ou Gravação Absoluta de Setor ..................356
Efetuando E/S no Disco Baseada no B IO S ........................................357
Testando a Prontidão de uma Unidade de D isquete.........................358
Abrindo um Arquivo Usando fopen ................................................... 359
Compreendendo a Estrutura FIL E ........................................................360
Fechando um Arquivo A b e r to ............................................................... 361
Lendo e Gravando Informações no Arquivo um Caractere de
Cada V e z ................................................................................................... 362
Compreendendo o Ponteiro de Posição do Ponteiro de
Arquivo ..................................................................................................... 363
Determinando a Posição Atual no A rquivo ........................................ 364
Compreendendo os Canais de Arquivos ............................................. 365
Compreendendo as Traduções de Arquivos........................................ 366
Compreendendo a Linha FILES=valor no Config.Sys......................367
Usando E/S em Arquivos de Baixo Nível e de Alto Nível .............368
VIII Programando em C/C++ — A B íbl ia
Compreendendo os Indicativos de Arquivos.....................................369
Compreendendo a Tabela de Arquivos do Processo....................... 370
Visualizando as Entradas da Tabela de Arquivos do Processo . . . 371
Compreendendo a Tabela de Arquivos do Sistema ....................... 372
Exibindo a Tabela do Sistema de Arquivos .....................................373
Derivando Indicativos de Arquivos a partir de Ponteiros
Stream (de Canais) ................................................................................ 374
Executando Saída Formatada em Arquivo .......................................375
Renomeando um A rquivo.....................................................................376
Excluindo um A rq u iv o ......................................................................... 377
Determinando Como um Programa Pode Acessar um
A rquivo.....................................................................................................378
Definindo o Modo de Acesso de um A rq u iv o ................................ 379
Ganhando Melhor Controle dos Atributos do A rq u iv o ................ 380
Testando o Erro no Canal de um A rquivo.......................................381
Determinando o Tam anho de um A rq u iv o .....................................382
Esvaziando um Canal de E/S ..............................................................383
Fechando Todos os Arquivos Abertos de uma Só V e z .................. 384
O btendo o Indicativo de Arquivo de um Canal de Arquivo . . . . 385 
Criando um Nome de Arquivo Temporário Usando P_tmpdir . . 386 
Criando um Nome de Arquivo Temporário Usando TM P ou
T E M P ...................................................................................................... 387
Criando um Arquivo Verdadeiramente T em porário....................... 388
Removendo Arquivos Tem porários.....................................................389
Pesquisando o Caminho de Comandos para um Arquivo ........... 390
Pesquisando um Arquivo na Lista de Subdiretório de um
Item do A m biente.................................................................................. 391
Abrindo Arquivos no Diretório TEM P ............................................392
Minimizando as Operações de E/S em A rquivo..............................393
Escrevendo Código Que Usa Barras Invertidas nos Nomes de
D ire tó rio .................................................................................................. 394
Modificando o Diretório A tu a l............................................................395
Criando um D iretório ........................................................................... 396
Removendo um D iretório .....................................................................397
Removendo uma Árvore de Diretório ..............................................398
Construindo o Nome de Caminho C o m p le to ................................ 399
Subdividindo um Caminho de D ire tó rio ......................................... 400
Construindo um Nome de C a m in h o ................................................ 401
Abrindo e Fechando um Arquivo Usando Funções de Baixo
N ív e l......................................................................................................... 402
Criando um Arquivo ............................................................................403
Efetuando Operações de Leitura e Gravação de Baixo Nível . . . . 404
Testando o Final de um A rq u iv o ...........................................................405
Colocando as Rotinas de Arquivo de Baixo Nível para
T rabalhar.................................................................................................. 406
Especificando o Modo para uma Tradução Arquivo-Indicativo . . 407
Posicionando o Ponteiro de Arquivo Usando lseek ...........................408
Abrindo Mais de 20 Arquivos .................. ................................... .... 409
Usando serviços de arquivo baseados no D O S..................................... 410
O btendo a Data e a H ora de Criação de um A rq u iv o ...................... 411
O btendo a Data e a Hora de um Arquivo Usando Campos de
B i t .................................................................................................................412
Definindo a Data e a Hora de um A rq u iv o ........................................ 413
Definindo a Data e a Hora de um Arquivo com a Data e a
Hora A tuais................................................................................................. 414
Lendo e Gravando Dados uma Palavra de Cada V e z ........................ 415Alterando o Tamanho de um A rq u iv o ................................................. 416
Controlando as Operações de Leitura e Gravação em
Arquivos A bertos........................................................................................417
Atribuindo um Buffer de Arquivo ........................................................ 418
Alocando um Buffer de A rquivo.............................................................419
Criando um Nome de Arquivo Exclusivo Usando m k tem p......... 420
Lendo e Gravando E stru tu ras..................................................................421
Lendo Dados de uma Estrutura a partir de um Canal de
A rqu ivo ........................................................................................................422
Duplicando o Indicativo de um A rq u iv o ............................................ 423
Forçando a Definição de um Indicativo de Arquivo ........................424
Associando o Indicativo de um Arquivo com um Canal ................. 425
Compreendendo o Compartilhamento de Arquivo .......................... 426
Abrindo um Arquivo para o Acesso C om partilhado.......................... 427
Bloqueando o Conteúdo de um Arquivo .........................................428
Ganhando Controle Mais Refinado do Bloqueio de Arquivo . . . . 429
Trabalhando com Diretórios do D O S ................................................430
Abrindo um D ire tó rio ...........................................................................431
Lendo uma Entrada do Diretório .......................................................432
Usando Serviços de Diretório para Ler C:\W indows .................... 433
Voltando para o Início de um D ire tó rio ...........................................434
Lendo Recursivamente os Arquivos de um Disco .........................435
Determinando a Posição Atual no A rquivo.......................................436
Abrindo um Canal de Arquivo Com partilhado................................437
Criando um Arquivo Exclusivo em um Diretório Específico . . . . 438
Criando um Novo A rqu ivo ..................................................................439
Usando os Serviços do DOS para Acessar um Arquivo ................440
Forçando a Abertura de um Arquivo no Modo Binário ou
T e x to .........................................................................................................441
Lendo Linhas de T e x to .........................................................................442
Gravando Linhas de Texto ..................................................................443
Colocando fgets e fputs em Uso .........................................................444
Forçando a Tradução de Arquivo B inário .........................................445
Compreendendo Por Que o Programa copiatxt Não Pode
Copiar Arquivos Binários...................................................................... 446
Testando o Final do Arquivo .............................................................447
Devolvendo um C arac tere ....................................................................448
Lendo Dados Formatados de A rquivo................................................449
Posicionamento do Ponteiro de Arquivo com Base em Sua Posição
Atual ........................................................................................................ 450
Obtendo Informações do Indicativo de A rqu ivo............................. 451
Reabrindo um Canal de A rquivo.........................................................452
Ma t r iz e s , P o n t e ir o s e Es t r u t u r a s
Compreendendo as M a trizes................................................................453
Declarando uma M a triz .........................................................................454
Visualizando uma M atriz ...................................................................... 455
Compreendendo os Requisitos de Armazenamento de uma
Matriz ......................................................................................................456
Inicializando uma M atriz ...................................................................... 457
Acessando Elementos da Matriz ........................................................ 458
Percorrendo em um Laço os Elementos da M a tr iz ........................ 459
Usando Constantes para Definir as M atrizes....................................460
Passando uma Matriz a uma F u n ção ................................................. 461
Revisitando as Matrizes Como Funções ...........................................462
Compreendendo Como as Matrizes de String D iferem ..................463
Passando Matrizes para a Pilha ...........................................................464
Determinando Quantos Elementos uma Matriz Pode
A rm azenar............................................................................................... 465
Usando o Modelo de Memória Huge para as Matrizes
G ran d es ....................................................................................................466
A Barganha entre Matrizes e Memória D in âm ica ...........................467
Compreendendo as Matrizes M ultidim ensionais.............................468
Compreendendo as Linhas e C o lu n a s ...............................................469
Acessando Elementos em uma Matriz B idim ensional....................470
Inicializando Elementos em uma Matriz B idim ensional............... 471
Determinando o Consumo de Memória de uma Matriz
M ultidim ensional................................................................................... 472
Percorrendo em um Laço uma Matriz Bidim ensional....................473
Percorrendo uma Matriz Tridim ensional.......................................... 474
Inicializando Matrizes M ultidim ensionais........................................ 475
Passando uma Matriz Bidimensional para uma Função ............... 476
Tratando as Matrizes Multidimensionais Como uma Dimensão . 477 
Compreendendo Como C Armazena Matrizes
M ultidim ensionais................................................................................. 478
Compreendendo a Ordem Linha por Linha versus Coluna por
C o lu n a ................................................................................ ..................... 479
Matrizes de Estruturas de Matrizes ................................................... 480
Compreendendo as Uniões .................................................................481
Economizando Memória com as U n iõ e s .......................................... 482
Usando REGS - Uma União C lássica...............................................483
Colocando a União REGS em U s o ................................................... 484
Compreendendo as Estruturas de Campos de B i t .......................... 485
Visualizando uma Estrutura de Campos de B i t ...............................486
Sumário IX
Compreendendo o Intervalo de Valores de uma Estrutura
Bit a Bit .................................................................................................. 487
Procurando um Valor Específico em uma Matriz ......................... 488
Compreendendo uma Pesquisa B inária..............................................489
Usando uma Pesquisa B inária..............................................................490
Classificando uma M a tr iz .....................................................................491
Compreendendo o Método da B o lh a ................................................ 492
Colocando o Algoritmo da Bolha em U s o .......................................493
Compreendendo o Algoritmo da S eleção ......................................... 494
Colocando em Uso o Método da Seleção......................................... 495
Compreendendo o Algoritmo Shell .................................................. 496
Colocando em Uso o Algoritmo Shell ..............................................497
Compreendendo o Q uick S o r t ............................................................498Colocando o Quick Sort em U s o ....................................................... 499
Problemas com as Soluções de Classificação A n terio res ................ 500
Classificando uma Matriz de Strings de Caracteres ....................... 501
Pesquisando uma Matriz com lfind .................................................. 502
Procurando Valores com lsearch ......................................................... 503
Pesquisando uma Matriz Classificada com bsearch......................... 504
Classificando Matrizes com q s o r t .......................................................505
Determinando o Número de Elementos na Matriz .......................506
Compreendendo Ponteiros como Endereços .................................. 507
Determinando o Endereço de uma V ariável.....................................508
Compreendendo como C Trata Matrizes como P on te iro s............509
Aplicando o Operador de Endereço (&) a uma M a tr iz ................ 510
Declarando Variáveis Ponteiro ............................................................511
Desreferenciando um P o n te iro ............................................................512
Usando Valores de P o n te iro ................................................................ 513
Usando Ponteiros com Parâmetros de F u n ç ã o ................................ 514
Compreendendo a Aritmética de Ponteiros .....................................515
Incrementando e Decrementando um P o n te iro ..............................516
Combinando uma Referência e Incremento de P o n te iro ..............517
Percorrendo uma String Usando um P o n te iro ................................ 518
Usando Funções Q ue Retornam Ponteiros....................................... 519
Criando uma Função Que Retorna um P on te iro ............................520
Compreendendo uma Matriz de Ponteiros.......................................521
Visualizando uma Matriz de Strings de Caracteres......................... 522
Percorrendo em um Laço uma Matriz de Strings de
C aracteres................................................................................................ 523
Tratando uma Matriz de String de Caracteres Como um
Ponteiro .................................................................................................. 524
Usando um Ponteiro para um Ponteiro para Strings de
C aracteres................................................................................................ 525
Declarando uma Constante String Usando um P o n te iro ..............526
Compreendendo o Ponteiro do Tipo v o id .......................................527
Criando Ponteiros para as Funções.....................................................528
Usando um Ponteiro para uma F u n ç ã o ........................................... 529
Usando um Ponteiro para um Ponteiro para um Ponteiro ......... 530
Compreendendo as Estruturas ............................................................531
Uma Estrutura É um Gabarito para a Declaração de Variáveis . . 532
O Descritor de uma Estrutura È o Nome da E stru tu ra ................533
Declarando uma Variável Estrutura de Modos D iferen tes........... 534
Compreendendo os Membros da Estrutura .....................................535
Visualizando uma Estrutura ................................................................ 536
Pondo uma Estrutura em Uso ............................................................... 537
Passando uma Estrutura a uma Função ............................................538
Alterando uma Estrutura Dentro de uma Função ......................... 539
Compreendendo a Indireção (*ponteiro).m em bro......................... 540
Usando o Formato ponteiro->membro ........................................... 541
Usando uma Estrutura sem N o m e .....................................................542
Compreendendo o Escopo de Definição de uma E s tru tu ra ......... 543
Inicializando uma Estrutura ....................................................................544
Efetuando E/S em E stru tu ras ..............................................................545
Usando uma Estrutura Dentro de O u t r a .............................................546
Estruturas Que Contêm M atrizes.......................................................... 547
Criando uma Matriz de E stru tu ras.....................................................548
S e r v iç o s D O S e B IO S
Compreendendo os Serviços do Sistema do D O S ......................... 549
Compreendendo os Serviços da BIOS ..............................................550
Compreendendo os Registradores ..........................................................551
Compreendendo o Registrador de Flags ..............................................552
Compreendendo as Interrupções de S o ftw a re .....................................553
Usando a BIOS para Acessar a Impressora ......................................... 554
Informação de C trl+B reak.......................................................................555
Compreendendo Possíveis Efeitos Colaterais do D O S .................... 556
Suspendendo um Programa T em porariam ente.................................. 557
Divertindo-se com S o m ...........................................................................558
Obtendo Informações Específicas do P a ís ............................................559
Compreendendo o Endereço de Transferência do Disco ................ 560
Acessando e Controlando a Área de Transferência do Disco . . . . 561
Usando os Serviços de Teclado da B IO S .......................................... 562
Obtendo a Lista de Equipamentos da B IO S ....................................563
Controlando a E/S da Porta Serial......................................................564
Acessando os Serviços do DOS Usando b d o s ................................. 565
O btendo Informações Estendidas de Erro do DOS ...................... 566
Determinando a Quantidade de Memória Convencional da
B I O S ...........................................................................................................567
Construindo um Ponteiro far ................................................................568
Dividindo um Endereço far em um Segmento e Deslocamento . . 569
Determinando a Memória do Núcleo Livre .......................................570
Lendo as Configurações do Registrador de Segm ento ....................... 571
G e r e n c ia m e n t o d e M e m ó r ia
Compreendendo os Tipos de M em ória ................................................572
Compreendendo a Memória C onvencional......................................... 573
Compreendendo o Layout da Memória C onvencional.....................574
Acessando a Memória Convencional.................................................... 575
Compreendendo Por Que o PC e o DOS Estão Restritos a
1 M b .............................................................................................................576
Produzindo um Endereço a partir de Segmentos e
Deslocam entos...........................................................................................577
Compreendendo a Memória Expandida ............................................. 578
Usando a Memória Expandida ............................................................. 579
Compreendendo a Memória E stend ida ................................................580
Compreendendo os Modos Real e Protegido.......................................581
Acessando a Memória E sten d id a ...........................................................582
Compreendendo a Área de Memória A lta ........................................... 583
Compreendendo a Pilha ........................................................................ 584
Compreendendo Diferentes Configurações da P i lh a .........................585
Determinando o Tamanho da Pilha Atual do Seu Programa . . . . 586
Controlando o Espaço na Pilha com _stk len .......................................587
Atribuindo um Valor a umIntervalo de Memória ........................... 588
Copiando um Intervalo de Memória para O utro ..............................589
Copiando um Intervalo de Memória até um Byte Específico . . . . 590
Comparando Duas Matrizes de unsigned char .................................. 591
Permutando Bytes de Strings de Caracteres A djacentes.................... 592
Alocando Memória D in â m ic a ................................................................593
Revisitando a Conversão .........................................................................594
Liberando a Memória Quando Ela Não É Mais N ecessária .........595
Alocando Memória Usando a Função c a llo c ...................................... 596
Compreendendo o H e a p ........................................................................ 597
Contornando o Limite de 64Kb para o H e a p .................................... 598
Alocando Memória a partir da P i lh a ....................................................599
Alocando Dados H u g e .............................................................................600
Alterando o Tamanho de um Bloco Alocado .................................... 601
Compreendendo b r k ...............................................................................602
Validando o H e a p ................................................................................... 603
Efetuando uma Verificação Rápida do H e a p ...................................... 604
Preenchendo o Espaço Livre do H e a p ..................................................605
Verificando uma Entrada Específica no H e a p ....................................606
Percorrendo as Entradas do H e a p ........................................................ 607
Examinando o Conteúdo de uma Posição de Memória
Específica.................................................................................. .................608
Colocando Valores na Memória ...........................................................609
Compreendendo as Portas do P C ........................................................ 610
Acessando os Valores das Portas ........................................................... 611
Compreendendo a C M O S ...................................................................... 612
Compreendendo os Modelos de M em ória...........................................613
Compreendendo o Modelo de Memória Tiny ................................. 614
X Programando em C/C++ — A B íbl ia
Compreendendo o Modelo de Memória Small ..............................615
Compreendendo o Modelo de Memória M e d iu m ......................... 616
Compreendendo o Modelo de Memória C om pac t......................... 617
Compreendendo o Modelo de Memória Large................................ 618
Compreendendo o Modelo de Memória Huge ..............................619
Determinando o Modelo de Memória Atual .................................. 620
Da t a e h o r a
Obtendo a Data e a Hora Atuais Como Segundos desde 1/1/1970 . . 621 
Convertendo uma Data e uma Hora de Segundos
para ASCII ..............................................................................................622
Ajuste do Horário de Verão ..............................................................623
Retardando durante um Determinado Número de
M ilissegundos......................................................................................... 624
Determinando o Tempo de Processamento do Seu Programa . . . 625
Comparando Dois H o rá rio s ................................................................ 626
Obtendo uma String de D a ta ..............................................................627
Obtendo uma String com o H o rá r io ................................................ 628
Lendo o Temporizador da BIOS .......................................................629
Trabalhando com o Horário L o ca l.....................................................630
Trabalhando com o Horário de G reenw ich .....................................631
Obtendo o Horário do Sistema D O S ................................................ 632
Obtendo a Data do Sistema do D O S ................................................ 633
Definindo o Horário do Sistema D O S ..............................................634
Definindo a Data do Sistema do DOS ........................................... 635
Convertendo uma Data do DOS para o Formato do UNIX . . . . 636 
Usando timezone para Calcular a Diferença entre a Zona
H o rá r ia .....................................................................................................637
Determinando a Zona Horária A tu a l ................................................ 638
Definindo Campos de Zona Horária com tz s e t ..............................639
Usando a Variável de Ambiente T Z .............................................. . 640
Definindo a Entrada de Ambiente T Z a partir de Dentro de
Seu P ro g ram a......................................................................................... 641
Obtendo as Informações de Zona H o rá ria .......................................642
Definindo a Hora do Sistema em Segundos desde a Meia-noite
de 1/1/1970 ............................................................................................ 643
Convertendo uma Data para Segundos desde a Meia-noite de
1/1/1970 .................................................................................................. 644
Determinando a Data Juliana de uma D a ta .....................................645
Criando uma String Formatada de Data e H o r a ............................646
Compreendendo os Tipos de Relógio do P C .................................. 647
R e d i r e c io n a n d o a E /S e P r o c e s s a n d o U n h a s d e Co m a n d o
Aguardando a Digitação de uma T e c la ..............................................648
Pedindo uma Senha ao U su á rio ......................................................... 649
Escrevendo Sua Própria Função de Senha .......................................650
Compreendendo o Redirecionamento da Saída ..............................651
Compreendendo o Redirecionamento da E n tr a d a ......................... 652
Combinando o Redirecionamento da Entrada e da Saída ........... 653
Usando stdout e s td in ........................................................................... 654
Compreendendo o Operador de Canalização.................................. 655
Compreendendo getchar e p u tch a r.....................................................656
Numerando a Entrada Redirecionada................................................657
Garantindo Q ue uma Mensagem Apareça na T e la ......................... 658
Escrevendo Seu Próprio Comando more ......................................... 659
Exibindo um Contador de Linhas Redirecionadas......................... 660
Exibindo um Contador de Caracteres Redirecionados.................. 661
Criando um Comando More com Controle de T e m p o ................662
Impedindo o Redirecionamento da E / S ........................................... 663
Usando o Indicativo de Arquivo s td p rn ........................................... 664
Desviando a Saída Redirecionada para um A rqu ivo ....................... 665
Usando o Indicativo de Arquivo s td a u x ........................................... 666
Encontrando Ocorrências de Substring Dentro da Entrada
Redirecionada......................................................................................... 667
Exibindo as Primeiras n Linhas da Entrada Redirecionada ......... 668
Compreendendo os Argumentos da Linha de C o m a n d o ..............669
Exibindo um Contador de Argumentos da Linha de Comandos . 670
Exibindo a Linha de Comando ......................................................... 671
Trabalhando com Argumentos da Linha de Comando entre
A s p a s .......................................................................................................... 672
Exibindo o Conteúdo de um Arquivo a partirda Linha de
C o m ando ................................................................................................... 673
Tratando argv Como um Ponteiro ...................................................... 674
Compreendendo Como C Sabe sobre a Linha de Comando . . . . 675
Compreendendo o A m biente................................................................. 676
Tratando env Como um Ponteiro ......................................................677
Use void para os Parâmetros de m a in ..................................................678
Trabalhando com Números da Linha de C o m a n d o .........................679
Compreendendo os Valores de Status da S aída ..................................680
Usando return para o Processamento do Status da S a íd a ................ 681
Determinando Se main Deve ou Não Ser Declarada Como
void .............................................................................................................682
Pesquisando o Item Específico no A m biente...................................... 683
Como o DOS Trata o Ambiente ........................................................ 684
Usando a Variável Global env iron ........................................................ 685
Acrescentando um Item ao Ambiente Atual ...................................... 686
Acrescentando Elementos no Ambiente D O S ....................................687
Abortando o Programa A tu a l..................................................................688
Definindo Funções Que Executam ao Término do Programa . . . 689
Compreendendo as Bibliotecas .............................................................690
Reutilizando o Código-Objeto ................................................................ 691
Problemas com a Compilação de Arquivos C e OBJ .......................692
Criando um Arquivo de B ib lio teca...................................................... 693
Compreendendo as Operações da Biblioteca C o m u m ...................... 694
Listando as Rotinas em um Arquivo de B ib lio teca ........................... 695
Use Bibliotecas para Reduzir Seu Tempo de Com pilação................696
Aprendendo Mais sobre as Capacidades da Sua B iblio teca..............697
Compreendendo o L in k ed ito r ............................................................... 698
Vendo as Capacidades do Linkeditor ..................................................699
Usando um Mapa do L inkeditor...........................................................700
Usando Arquivos de Resposta do Linkeditor.......................................701
Simplificando a Criação de Aplicativos com o M A K E .....................702
Criando um Arquivo Simples do MAKE ........................................... 703
Usando Múltiplos Arquivos de Dependência com o MAKE . . . . 704
Comentando Seus Arquivos do M A K E ................................................705
Linhas de Comando e M A K E ............................................................... 706
Colocando Múltiplas Dependências em um Arquivo do
M A K E ........................................................................................................ 707
Regras Implícitas e Explícitas do M A K E ............................................. 708
Usando Macros do MAKE ....................................................................709
Macros Predefinidas do M A K E ............................................................. 710
Executando Processamento Condicional com o MAKE ...................711
Testando um Nome de Macro ............................................................. 712
Incluindo um Segundo Arquivo do MAKE ...................................... 713
Usando os Modificadores de Macro do MAKE ............................... 714
Finalizando, um Arquivo do MAKE com um E r r o ........................... 715
Desabilitando a Exibição do Nom e do C o m an d o ............................. 716
Usando o Arquivo BUILTINS.MAK ..................................................717
Executando Processamento de Status de Saída no MAKE ..............718
Chamando e Alterando uma Macro ao Mesmo T e m p o .................. 719
Executando um Comando MAKE para Múltiplos Arquivos 
Dependentes ............................................................................................. 720
C A v a n ç a d o
Determinando Se o Co-Processador Matemático Está Presente . . 721
Compreendendo as Macros ctype.h e is ty p e ...................................... 722
Controlando o Vídeo D ire to ..................................................................723
Detectando Erros Matemáticos e do Sistema .................................... 724
Exibindo Mensagens de Erro Predefinidas........................................... 725
Determinando o Número de Versão do Sistema Operacional . . . 726
Compreendendo a P ortab ilidade...........................................................727
Efetuando um Goto Não-local ............................................................. 728
Obtendo a Identificação do Processo.................................................... 729
Chamando um Comando Interno do DOS .......................................730
Usando a Variável Global _ p s p ..............................................................731
Usando o Modificador const nas Declarações de Variáveis..............732
Usando Tipos E num erados.................................................................... 733
Colocando um Tipo Enumerado em U s o ........................................... 734
Sumário XI
Compreendendo um Valor E n u m e rad o ............................................735
Atribuindo um Valor Específico a um Tipo E num erad o ..............736
Salvando e Restaurando os R egistradores......................................... 737
Introdução às Listas Dinâmicas ......................................................... 738
Declarando uma Estrutura de Lista L igada.......................................739
Criando uma Lista Ligada.....................................................................740
Exemplo de uma Lista Ligada S im ples..............................................741
Compreendendo como Percorrer uma Lista L ig a d a .......................742
Criando uma Lista Mais Ú t i l ..............................................................743
Anexando um Elemento na L is ta .......................................................744
Inserindo um Elemento na L ista......................................................... 745
Exibindo um Diretório C lassificado...................................................746
Excluindo um Elemento de uma L is ta ..............................................747
Usando uma Lista Duplamente Ligada..............................................748
Criando uma Lista Duplamente Ligada Simples ............................749
Compreendendo nodo->anterior->próxim o.....................................750
Removendo um Elemento de uma Lista Duplamente Ligada . . . 751
Inserindo um Elemento em uma Lista Duplamente L igada......... 752
Compreendendo os Processos-Filho...................................................753
Gerando um Processo-Filho................................................................ 754
Usando Outras Funções spawnlxx .....................................................755
Usando as Funções spaw nvxx..............................................................756
Executando um Processo-Filho....................... ....................................757
Usando Outras Funções execlxx......................................................... 758
Usando as Funções execvxx ................................................................ 759
Compreendendo os Overlays ..............................................................760
Compreendendo as Interrupções......................................................... 761
As Interrupções do P C ......................................................................... 762
Usando a Palavra-Chave interrupt .....................................................763Determinando o Vetor de uma In terrupção.....................................764
Definindo um Vetor de Interrupção...................................................765
Habilitando e Desabilitando as Interrupções .................................. 766
Criando uma Rotina Simples de Tratam ento de Interrupção . . . . 767
Encadeando uma Segunda In terrupção..............................................768
Gerando uma Interrupção.....................................................................769
Interceptando o Temporizador do P C ..............................................770
Compreendendo os Erros Críticos .....................................................771
Tratamento de Erro Crítico em C .....................................................772
Uma Rotina de Tratamento de Erro Crítico C o m p le ta ................ 773
Restaurando as Interrupções A lte rad as..............................................774
Criando uma Rotina de Tratamento de C trl+Break.......................775
Usando os Serviços do DOS na Sua Rotina de Tratamento
de Erro C r í t ic o ....................................................................................... 776
Aumentando o Desempenho com o Uso da Seleção do
Conjunto de Instruções......................................................................... 777
Funções Intrínsecas In - lin e .................................................................. 778
Habilitando e Desabilitando as Funções Intrínsecas.......................779
Compreendendo as Chamadas Rápidas de F u n çõ es......... .............780
Regras para a Passagem de Parâmetros _ fa stca ll..............................781
Compreendendo o Código Invariante ..............................................782
Compreendendo a Supressão de Carga R edundante.......................783
Compreendendo a Compactação do Código .................................. 784
Compreendendo a Compactação do Laço ....................................... 785
Compreendendo a Indução do Laço e a Redução da F o rç a ......... 786
Compreendendo a Eliminação de Subexpressão C o m u m ..............787
Compreendendo as Conversões Comuns de C P adrão .................. 788
Compreendendo os Quatro Tipos Básicos de C ..............................789
Compreendendo os Tipos Fundamentais versus os Derivados . . . 790
Compreendendo os Inicializadores.....................................................791
Compreendendo o Sistema de Ligação (L inkage)............................792
Compreendendo as Declarações Experimentais ..............................793
Contrastando Declarações e Definições ............................................794
Compreendendo lvalues .......................................................................795
Compreendendo rv a lu es.......................................................................796
Usando Palavras-chave de Registradores de Segmento ......................797
Use os Ponteiros far com C u id ad o .....................................................798
Compreendendo os Ponteiros Normalizados ......................................799
Comandos do Co-Processador Matemático ........................................ 800
Compreendendo cdecl e pascal nas V ariáveis...................................... 801
Impedindo as Inclusões C ircu la res........................................................ 802
In t r o d u ç ã o à C + +
Introduzindo C++ ................................................................................ .. 803
Como os Arquivos-Fonte de C++ São D ife re n te s ..............................804
Iniciando com um Programa Simples em C + + ...................................805
Compreendendo o Canal de Enrrada/Sa/da c o u r ................................ 806
Escrevendo Valores e Variáveis com cout ............................................807
Combinando Diferentes Tipos de Valores com c o u t ..........................808
Exibindo Valores Hexadecimais e O cta is.............................................. 809
Redirecionando cout ................................................................................810
Se Você Gosta de printf, Use p r i n t f ..................................................... 811
Escrevendo Saída em cerr ...................................................................... 812
Recebendo Entrada com cin .................................................................. 813
cin Não Usa Ponteiros............................................................................. 814
Compreendendo Como cin Seleciona os Campos de D ados.............815
Compreendendo Como os Canais de E/S Conhecem os Tipos
dos Valores..................................................................................................816
Efetuando Saída Usando clog ................................................................817
cin, cout, cerr e clog São Ocorrências de C lasse ................................ 818
Descarregando a Saída com flush .........................................................819
Compreendendo o Q ue iostream.h C o n té m .......................................820
C++ Requer Protótipos de F u nções.......................................................821
C++ Acrescenta Novas Palavras-Chave ................................................822
C++ Suporta as Uniões A nôninias.........................................................823
Resolvendo o Escopo G lo b a l.................................................................. 824
Fornecendo Valores Padrão de Parâmetros ......................................... 825
Controlando a Largura da Saída de c o u t ..............................................826
Usando setw para Definir a Largura para c o u t .................................. 827
Especificando um Caractere de Preenchimento em c o u t ...................828
Justificando à Direita e à Esquerda a Saída de cout ......................... 829
Controlando o Número de Dígitos em Ponto Flutuante
Exibidos por c o u t .......................................................................................830
Exibindo Valores nos Formatos Fixo ou C ientífico ............................831
Restaurando cout para o Padrão ........................................................... 832
Definindo a Base da E / S .........................................................................833
Declarando Variáveis Onde Você Precisa Delas ................................834
Colocando Valores de Parâmetro Padrão em Protótipos de
F u n ção .........................................................................................................835
Usando Operadores Bit a Bit e c o u t .................................................... 836
Compreendendo a Avaliação Preguiçosa (ou Curto- Circuito) . . . 837
Usando a Palavra-Chave const em C + + ................................................838
Usando a Palavra-Chave enum em C++ ............................................. 839
Compreendendo o Espaço Livre ........................................................... 840
Alocando Memória com n ew ...................................................................841
Alocando Múltiplas M atrizes.................................................................. 842
Testando a Falta de Espaço Livre .........................................................843
Considerações sobre o Espaço no H e a p ................................................844
Usando Ponteiros far e o Operador n e w ..............................................845
Liberando Memória de Volta ao Espaço Livre .................................. 846
Compreendendo as Referências de C + + ................................................847
Passando uma Referência a uma F u n ç ã o ..............................................848
Atentando para os Objetos O cu lto s .......................................................849
Usando Três Modos de Passar Parâmetros ......................................... 850
Regras para Trabalhar com Referências................................................