Programando Em C/C++ "A Bíblia" (Preto e Branco e Com OCR)

1030 Pages·1999·40.75 MB·Portuguese

by  Kris Jamsa Ph.D, Lars Klander

O Melhor Guia Para a
Programação em C/C++
*
MAKRON
Books
PROqRAttwk) EM (X++
A Bíblia
Kris Jamsa, Ph.D.
Lars Klander
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, Itaím-Bibi
CEP 04533-004 — São Paulo — SP
[phone] e [phone]
[email protected], b r
São Paulo • Rio ãe Janeiro • Ribeirão Preto • Belém • Belo Horizonte * Brasilia • Campo Grande • Cuiabá • Curitiba * Florianópolis • Fortaleza
• Goiânia • Manaus • Natal • Porto Alegre • Recife * Salvador
Barcelona • Bogptá ■ Buenos Aires • Caracas • Ciudad del Médco • Frankfurt • Guadalajara • Lisboa • Londres • Madrid • Montevideo
• New York • Paris • Porto • Santiago
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
Sumário
Exibindo Valores de Ponto Flutuante em um Formato
Exponential.....................................................................................60
Introdução à Linguagem C
Exibindo Valores em Ponto Flutuante.............................................61
Uma Introdução à Programação.................................................... . 1 Exibindo uma String de Caracteres Usando printf.........................62
Criando um Arquivo-Fonte em ASCII.......................................... . 2 Exibindo um Endereço de Ponteiro Usando printf .......................63
Compilando Seu Programa............................................................ . 3 Precedendo um Valor com um Sinal de Adição ou de
Compreendendo os Erros de Sintaxe ............................................ . 4 Subtração.........................................................................................64
Estrutura de um Típico Programa em C ...................................... . 5 Formatando um Valor Inteiro Usando printf.................................65
Acrescentando Comandos aos Seus Programas.............................. . 6 Saída de Inteiros Preenchida com Zeros .........................................66
Exibindo Saída em uma Nova Linha............................................ . 7 Exibindo um Prefixo Antes dos Valores Octais ou
Considera as Letras Maiusculas e Minúsculas Diferentes.............. . 8 Hexadecimais..................................................................................67
Compreendendo os Erros Lógicos ................................................ . 9 Formatando um Valor em Ponto Flutuante Usando printf............68
Compreendendo o Processo de Desenvolvimento de um Formatando a Saída Exponential....................................................69
Programa........................................................................................ 10 Justificando à Esquerda a Saída de printf......................................70
Compreendendo os Tipos de Arquivo .......................................... 11 Combinando os Especificadores de Formato de printf.................71
Compreendendo Melhor o Linkeditor.......................................... 12 Quebrando uma String de Caracteres em Duas Linhas...................72
Compreendendo os Arquivos de Cabeçalho.................................. 13 Exibindo Strings do Tipo near e far ...............................................73
Ajudando o Compilador a Localizar os Arquivos de Cabeçalho . . . 14 Trabalhando com os Caracteres Escape de printf...........................74
Agilizando as Compilações............................................................ 15 Determinando o Número de Caracteres Que printf Exibiu ...........75
Comentando Seus Programas........................................................ 16 Usando o Valor de Retorno de printf.............................................76
Melhorando a Legibilidade do Seu Programa................................ 17 Usando o Controlador de Dispositivo ANSI........................... 77
Prestando Atenção às Mensagens de Advertência do Compilador . 18 Usando o Controlador ANSI para Limpar Sua Tela.......................78
Controlando as Advertências do Compilador................................ 19 Usando o Controlador ANSI para Exibir as Cores da Tela.............79
Usando Comentários para Excluir Comandos do Programa ........ 20 Usando o Controlador ANSI para Posicionar o Cursor ................80
Compreendendo a Importância dos Nomes.................................. 21 Executando Operações Matemáticas Básicas em C .........................81
Compreendendo o Ponto-e-Vírgula.............................................. 22 Compreendendo a Aritmética do Módulo.......................................82
Apresentando as Variáveis.............................................................. 23 Compreendendo a Precedência e a Associatividade dos
Atribuindo um Valor a uma Variável............................................ 24 Operadores.......................................................................................83
Compreendendo os Tipos de Variáveis.......................................... 25 Forçando a Ordem de Avaliação dos Operadores ...........................84
Declarando Múltiplas Variáveis do Mesmo Tipo.......................... 26 Compreendendo o Operador de Incremento de C.........................85
Comentando Suas Variáveis na Declaração .................................. 27 Compreendendo o Operador de Decremento de C .......................86
Atribuindo Valores às Variáveis na Declaração.............................. 28 Compreendendo uma Operação OU Bit a Bit..............................87
Inicializando Múltiplas Variáveis durante a Declaração ................ 29 Compreendendo uma Operação E Bit a Bit..................................88
Usando Nomes Representativos para as Variáveis.......................... 30 Compreendendo uma Operação OU Exclusivo Bit a Bit..............89
Compreendendo as Palavras-chave de C........................................ 31 Compreendendo a Operação Inverso Bit a Bit...............................90
Compreendendo as Variáveis do Tipo int .................................... 32 Aplicando uma Operação ao Valor de uma Variável.......................91
Compreendendo as Variáveis do Tipo char.................................. 33 Compreendendo o Operador Condicional de C.............................92
Compreendendo as Variáveis do Tipo float.................................. 34 Compreendendo o Operador sizeof de C .......................................93
Compreendendo as Variáveis do Tipo double .............................. 35 Efetuando um Deslocamento Bit a Bit ...........................................94
Atribuindo Valores aos Valores em Ponto Flutuante.................... 36 Efetuando uma Rotação Bit a Bit...................................................95
Compreendendo os Modificadores de Tipo.................................. 37 Compreendendo os Operadores Condicionais.................................96
Compreendendo o Modificador de Tipo unsigned ...................... 38 Compreendendo o Processamento Iterative.....................................97
Compreendendo o Modificador de Tipo long.............................. 39 Compreendendo Como C Representa Verdadeiro e Falso .............98
Combinando os Modificadores de Tipo unsigned e long.............. 40 Testando uma Condição com if.....................................................99
Trabalhando com os Valores Grandes .......................................... 41 Compreendendo os Comandos Simples e Compostos...................100
Compreendendo o Modificador de Tipo register..........-............. 42 Testando a Igualdade.....................................................................101
Compreendendo o Modificador de Tipo short.............................. 43 Efetuando Testes Relacionais.........................................................102
Omitindo int das Declarações Modificadas .................................. 44 Executando uma Operação Lógica E para Testar Duas
Compreendendo o Modificador de Tipo signed............................ 45 Condições .....................................................................................103
Múltiplas Operações de Atribuição................................................ 46 Executando uma Operação Lógica OU para Testar Duas
Atribuindo o Valor de um Tipo de Variável a um Tipo Condições .....................................................................................104
Diferente........................................................................................ 47 Executando uma Operação Lógica NÃO (NOT).........................105
Criando Seus Próprios Tipos........................................................ 48 Atribuindo o Resultado de uma Condição ...................................106
Atribuindo um Valor Hexadecimal ou Octal................................ 49 Declarando Variáveis Dentro de Comandos Compostos..............107
Compreendendo o Extravasamento................................................ 50 Usando Recuos para Melhorar a Legibilidade...............................108
Compreendendo a Precisão............................................................ 51 Usando a Verificação Estendida de Ctrl+Break ...........................109
Atribuindo Apóstrofos e Outros Caracteres .................................. 52 Testando Valores de Ponto Flutuante...........................................110
Introdução ao Comando printf...................................................... 53 Laço de Repetição Infinito ..............................................................111
Exibindo Valores do Tipo int Usando printf................................ 54 Testando uma Atribuição...............................................................112
Imprimindo um Valor Inteiro Octal ou Hexadecimal.................. 55 Cuidado com os Comandos if-if-else.............................................113
Exibindo Valores do Tipo unsigned int Usando printf................ 56 Executando Comandos um Número Específico de Vezes............114
Exibindo Valores do Tipo long int Usando printf........................ 57 Partes do Comando for São Opcionais.........................................115
Exibindo Valores do Tipo float Usando printf.............................. 58 Decrementando os Valores em um Comando for.........................116
Exibindo Valores do Tipo char Usando printf.............................. 59 Controlando o Incremento do Laço for........................... 117
Usando Laços for com Valores char e float...................................118
V
VI Programando em C/C++ — A Bíblia
Compreendendo um Laço Null .................................................. 119 Retornando um índice à Última Ocorrência de uma String........179
Compreendendo o Laço Infinito ..................................................120 Trabalhando com Strings do Tipo for...........................................180
Usando o Operador Vírgula de C Dentro de um Escrevendo Funções String para as Strings far...............................181
Laço for..........................................................................................121 Contando o Número de Ocorrências de um Caractere em uma
Evite Modificar o Valor de uma Variável de Controle em um Laço String...........................................................................................182
for........................'........................................................................122 Invertendo o Conteúdo de uma String.........................................183
Repetindo um ou Mais Comandos Usando um Laço while........123 Atribuindo um Caractere Específico a uma String Inteira............184
Compreendendo as Partes de um Laço while.............................. 124 Comparando Duas Strings de Caracteres .....................................185
Repetindo um ou Mais Comandos Usando do .............................125 Comparando os Primeiros n Caracteres de Duas Strings .............186
Compreendendo o Comando continue de C.................................126 Comparando Strings sem Considerar a Caixa...............................187
Finalizando um Laço Usando o Comando break de C ................127 Convertendo a Representação em String de Caracteres de um
Desvios com o Comando goto.......................................................128 Número.........................................................................................188
Testando Múltiplas Condições.......................................................129 Duplicando o Conteúdo de uma String .......................................189
Compreendendo break Dentro de switch.....................................130 Encontrando um Caractere da Primeira Ocorrência de um
Usando o Case default do Comando switch...................................131 Determinado Conjunto.................................................................190
Definindo Constantes no Seu Programa...................................... 132 Localizando uma Substring Dentro de uma String.......................191
Compreendendo a Expansão de Macros e de Constantes............133 Contando o Número de Ócorrências da Substring.......................192
Nomeando as Constantes e as Macros...........................................134 Obtendo um índice para uma Substring.......................................193
Usando a Constante de Pré-processador _FILE_...........................135 Obtendo a Ocorrência Mais à Direita de uma Substring............194
Usando a Constante de Pré-processador LINE ......................136 Exibindo uma String sem o Especificador de Formato %s..........195
Alterando a Contagem de Linha do Pré-processador.....................137 Removendo uma Substring de Dentro de uma String .................196
Gerando um Erro Incondicional do Pré-processador.....................138 Substituindo uma Substring por Outra.........................................197
Outras Constantes do Pré-processador...........................................139 Convertendo uma Representação Numérica ASCII.......................198
Registrando a Data e a Hora do Pré-processador...........................140 Determinando Se um Caractere Ê Alfanumérico .........................199
Testando a Adesão ao Padrão ANSI...............................................141 Determinando Se um Caractere É uma Letra...............................200
Testando C++ versus C .................................................................142 Determinando Se um Caractere Contém um Valor ASCII..........201
Anulando a Definição de uma Macro ou Constante....................143 Determinando Se um Caractere É um Caractere de Controle ... 202
Comparando Macros e Funções.....................................................144 Determinando Se um Caractere É um Dígito............................203
Compreendendo Pragmas do Compilador.....................................145 Determinando Se um Caractere É um Caractere Gráfico...........204
Aprendendo sobre os Valores e Macros Predefinidos.....................146 Determinando Se um Caractere É Maiúsculo ou Minúsculo .... 205
Criando Seus Próprios Arquivos de Cabeçalho..............................147 Determinando Se um Caractere É Imprimível .............................206
Usando #include <nomearq.h> ou #include "nomearq.h"..........148 Determinando Se um Caractere É um Sinal de Pontuação.........207
Testando Se um Símbolo Está Definido........................................149 Determinando Se um Caractere Contém Espaço em Branco .... 208
Efetuando o Processamento if-else ................................................150 Determinando Se um Caractere É um Valor Hexadecimal..........209
Efetuando um Teste de Condição de Pré-processador Mais Convertendo um Caractere para Maiúscula.................................210
Poderoso........................................................................................151 Convertendo um Caractere para Minúsculo ...............................211
Realizando Processamento if-else e else-if.......................................152 Trabalhando com Caracteres ASCII .............................................212
Definindo Macros e Constantes Que Requerem Múltiplas Escrevendo Saída Formatada em uma Variável String...................213
Linhas.......................................................................................... 153 Lendo a Entrada de uma String de Caracteres .............................214
Criando Suas Próprias Macros.......................................................154 "Tokenizando" as Strings para Poupar Espaço .............................215
Não Coloque Ponto-e-Vírgula nas Definições de Macros ............155 Inicializando uma String...............................................................216
Criando Macros Min e Max..........................................................156
Criando Macros QUADRADO e CUBO ....................................157 Funções
Cuidado com os Espaços nas Definições das Macros.....................158 Compreendendo as Funções ........................................................217
Compreendendo Como Usar os Parênteses ..................................159 Usando Variáveis Dentro das Funções .........................................218
As Macros Não Têm Tipo.......................................................... 160 Compreendendo main Como uma Função..................................219
Introdução aos Parâmetros.............................................................220
Compreendendo as Strings
Usando Parâmetros Múltiplos.......................................................221
Visualizando uma String de C ......................................................161 Compreendendo as Declarações de Parâmetros em Programas
Como o Compilador Representa uma String de Caracteres........162 C Mais Antigos.............................................................................222
Como C Armazena as Strings de Caracteres..................................163 Retornando um Valor de uma Função .........................................223
Aprendendo Como ‘A’ Difere de “A”............................................164 Compreendendo o Comando return.............................................224
Representando um Apóstrofo Dentro de uma Constante Compreendendo os Protótipos de Função.....................................225
de String...................................................................................... 165 Compreendendo a Biblioteca de Execução ...................................226
Determinando o Tamanho de uma String.................................. 166 Compreendendo os Parâmetros Formais e Reais...........................227
Usando a Função strlen .............................................................. 167 Solucionando os Conflitos nos Nomes.........................................228
Copiando os Caracteres de uma String em Outra String............168 Funções Que Não Retornam int...................................................229
Anexando o Conteúdo de uma String em Outra..........................169 Compreendendo as Variáveis Locais .............................................230
Anexando n Caracteres em uma String..........................................170 Como as Funções Usam a Pilha ...................................................231
Transformando uma String em Outra..........................................171 Compreendendo a Sobrecarga da Função.....................................232
Não Ultrapasse o Tamanho de uma String ...................................172 Compreendendo Onde C Coloca as Variáveis Locais...................233
Determinando Se Duas Strings São ou Não Iguais .....................173 Declarando Variáveis Globais .......................................................234
Ignorando a Caixa ao Determinar Se as Strings São Iguais........174 Evite Usar Variáveis Globais.........................................................235
Convertendo uma String de Caracteres para Maiúsculas ou Solucionando os Conflitos de Nomes de Variáveis Locais e
Minúsculas .................................................................................. 175 Globais...........................................................................................236
Obtendo a Primeira Ocorrência de um Caractere em uma Definindo Melhor o Escopo de uma Variável Global...................237
String ............................................................................................176 Compreendendo a Chamada por Valor.........................................238
Retornando um índice à Primeira Ocorrência de uma String ... 177 Evitando a Alteração no Valor do Parâmetro com a Chamada
Encontrando a Ultima Ocorrência de um Caractere em uma por Valor.......................................................................................239
String .......................................................................................... 178 Compreendendo a Chamada por Referência.................................240
Sumário VII
Obtendo um Endereço..................................................................241 Posicionando o Cursor para Saída na Tela ...................................307
Usando um Endereço de Memória................................................242 Determinando a Posição de Linha e de Coluna ..........................308
Alterando o Valor de um Parâmetro..............................................243 Inserindo uma Linha em Branco na Tela....................................309
Alterando Somente Parâmetros Específicos....................................244 Copiando Texto da Tela para um Buffer .....................................310
A Chamada por Referência Ainda Usa a Pilha..............................245 Escrevendo um Buffer de Texto em uma Posição Específica
Introduzindo as Variáveis de Funções que Lembram....................246 da Tela..........................................................................................311
Compreendendo Como C Inicializa Variáveis Estáticas..............247 Determinando as Definições do Modo Texto...............................312
Usando a Sequência de Chamada Pascal ......................................248 Controlando as Cores da Tela.......................................................313
Compreendendo o Efeito da Palavra-Chave Pascal........................249 Atribuindo Cores de Fundo..........................................................314
Escrevendo um Exemplo de Linguagem Mista..............................250 Definindo a Cor de Frente Usando TextColor............................315
Compreendendo a Palavra-Chave cdecl ........................................251 Definindo a Cor de Fundo Usando textbackground....................316
Compreendendo a Recursão..........................................................252 Controlando a Intensidade do Texto............................................317
Compreendendo a Função Recursiva Fatorial................................253 Determinando o Modo Atual do Texto ......................................318
Programando Outro Exemplo Recursive ......................................254 Movendo Texto da Tela de um Local para Outro ......................319
Exibindo Valores para Compreender Melhor a Recursão............255 Definindo uma Janela de Texto....................................................320
Compreendendo a Recursão Direta e Indireta..............................256 Usando o Valor Absoluto de uma Expressão Inteira....................321
Decidindo Usar ou Não a Recursão........................................'.. 257 Usando o Arco Co-seno...............................................................322
Compreendendo Por Que as Funções Recursivas São Lentas .... 258 Usando o Arco Seno ...................................................................323
Compreendendo Como Remover a Recursão................................259 Usando o Arco Tangente.............................................................324
Passando Strings para as Funções..................................................260 Obtendo o Valor Absoluto de um Número Complexo.................325
Passando Elementos Específicos da Matriz....................................261 Arredondando para Cima um Valor em Ponto Flutuante............326
Compreendendo const em Parâmetros Formais............................262 Usando o Co-seno de um Ângulo................................................327
Usar const Não Impede a Modificação do Parâmetro ..................263 Usando o Co-seno Hiperbólico de um Ângulo............................328
Compreendendo as Declarações de Strings Não-Limitadas ..........264 Usando o Seno de um Ângulo ....................................................329
Usando Ponteiros versus Declarações de String..............................265 Usando o Seno Hiperbólico de um Ângulo ................................330
Como C Usa a Pilha para os Parâmetros String............................266 Usando a Tangente de um Ângulo.............................................331
Compreendendo as Variáveis Externas..........................................267 Usando a Tangente Hiperbólica de um Ângulo .........................332
Colocando extern em Uso ............................................................268 Realizando a Divisão Inteira ........................................................333
Compreendendo a Variável Estática Externa ................................269 Trabalhando com Exponential ....................................................334
Compreendendo a Palavra-chave volatile ......................................270 Usando o Valor Absoluto de uma Expressão em Ponto
Compreendendo a Estrutura de Chamada e o Ponteiro de Flutuante.......................................................................................335
Base................................................................................................271 Usando o Resto em Ponto Flutuante.............................................336
Chamando uma Função em Linguagem Assembly........................272 Usando a Mantissa e o Expoente de um Valor em Ponto
Retornando um Valor a partir de uma Função em Linguagem Flutuante.......................................................................................337
Assembly........................................................................................273 Calculando o Resultado de x * 2e.................................................338
Introduzindo Funções Que Não Retornam Valores......................274 Calculando o Logaritmo Natural...................................................339
Compreendendo as Funções Que Não Usam Parâmetros ............275 Calculando o Resultado de loglOx.................................................340
Compreendendo a Palavra-chave auto ..........................................276 Determinando os Valores Máximo e Mínimo...............................341
Compreendendo o Escopo............................................................277 Quebrando um Double em Seus Componentes Inteiro e Real ... 342
Compreendendo as Categorias de Escopo de C............................278 Calculando o Resultado de xn.......................................................343
Compreendendo o Espaço do Nome e os Identificadores ............279 Calculando o Resultado de 10x.....................................................344
Compreendendo a Visibilidade do Identificador ..........................280 Gerando um Número Aleatório.....................................................345
Compreendendo a Duração ..........................................................281 Mapeando Valores Aleatórios para um Intervalo Específico .........346
Funções Que Suportam um Número Variável de Parâmetros . .. 282 Inicializando o Gerador de Números Aleatórios ...........................347
Suportando um Número Variável de Parâmetros..........................283 Calculando a Raiz Quadrada de um Valor ...................................348
Como va_start, va_arg e va_end Funcionam ................................284 Criando uma Rotina de Tratamento de Erro Matemático ...........349
Criando Funções Que Suportam Muitos Parâmetros e Tipos . .. 285
Arquivos, Diretórios e Discos
Operações de Teclado
Determinando a Unidade de Disco Atual....................................350
Lendo um Caractere do Teclado ..................................................286 Selecionando a Unidade Atual.....................................................351
Exibindo um Caractere de Saída....................................................287 Determinando o Espaço Disponível no Disco..............................352
Compreendendo a Entrada Bufferizada ........................................288 Cuidado com o dblspace.............................................................353
Atribuindo Entrada do Teclado a uma String ..............................289 Lendo as Informações de uma Tabela de Alocação de
Combinando getchar e putchar ....................................................290 Arquivos.................................... 354
Lembre-se, getchar e putchar São Macros......................................291 Compreendendo a Identificação do Disco....................................355
Lendo um Caractere Usando E/S Direta ......................................292 Efetuando uma Leitura ou Gravação Absoluta de Setor ...............356
Entrada Direta no Teclado sem a Exibição do Caractere............293 Efetuando E/S no Disco Baseada no BIOS..................................357
Sabendo Quando Usar ‘\f e ‘\n’ ..................................................294 Testando a Prontidão de uma Unidade de Disquete.....................358
Executando Saída Direta................................................................295 Abrindo um Arquivo Usando fopen ............................................359
Colando uma Tecla Digitada de Volta no Buffer do Teclado . .. 296 Compreendendo a Estrutura FILE................................................360
Saída Formatada Rápida Usando cprintf......................................297 Fechando um Arquivo Aberto......................................................361
Entrada Rápida Formatada a partir do Teclado............................298 Lendo e Gravando Informações no Arquivo um Caractere de
Escrevendo uma String de Caracteres............................................299 Cada Vez.......................................................................................362
Escrita Mais Rápida de String Usando E/S Direta........................300 Compreendendo o Ponteiro de Posição do Ponteiro de
Lendo uma String de Caracteres do Teclado................................301 Arquivo .........................................................................................363
Executando Entrada de String Mais Rápida pelo Teclado......... 302 Determinando a Posição Atual no Arquivo...................................364
Exibindo Saída em Cores..............................................................303 Compreendendo os Canais de Arquivos .......................................365
Limpando a Tela do Vídeo............................................................304 Compreendendo as Traduções de Arquivos...................................366
Apagando até o Final da Linha Atual............................................305 Compreendendo a Linha FILES=valor no Config.Sys...................367
Apagando a Linha Atual da Tela ..................................................306 Usando E/S em Arquivos de Baixo Nível e de Alto Nível ...........368
VIII Programando em C/C++ — A Bíblia
Compreendendo os Indicativos de Arquivos..................................369 Bloqueando o Conteúdo de um Arquivo .....................................428
Compreendendo a Tabela de Arquivos do Processo......................370 Ganhando Controle Mais Refinado do Bloqueio de Arquivo .... 429
Visualizando as Entradas da Tabela de Arquivos do Processo ... 371 Trabalhando com Diretórios do DOS...........................................430
Compreendendo a Tabela de Arquivos do Sistema ......................372 Abrindo um Diretório...................................................................431
Exibindo a Tabela do Sistema de Arquivos ..................................373 Lendo uma Entrada do Diretório .................................................432
Derivando Indicativos de Arquivos a partir de Ponteiros Usando Serviços de Diretório para Ler C:\Windows ...................433
Stream (de Canais) ........................................................................374 Voltando para o Início de um Diretório.......................................434
Executando Saída Formatada em Arquivo ....................................375 Lendo Recursivamente os Arquivos de um Disco .......................435
Renomeando um Arquivo..............................................................376 Determinando a Posição Atual no Arquivo...................................436
Excluindo um Arquivo..................................................................377 Abrindo um Canal de Arquivo Compartilhado.............................437
Determinando Como um Programa Pode Acessar um Criando um Arquivo Exclusivo em um Diretório Específico .... 438
Arquivo..........................................................................................378 Criando um Novo Arquivo...........................................................439
Definindo o Modo de Acesso de um Arquivo..............................379 Usando os Serviços do DOS para Acessar um Arquivo ...............440
Ganhando Melhor Controle dos Atributos do Arquivo..............380 Forçando a Abertura de um Arquivo no Modo Binário ou
Testando o Erro no Canal de um Arquivo....................................381 Texto . ...........................................................................................441
Determinando o Tamanho de um Arquivo..................................382 Lendo Linhas de Texto.................................................................442
Esvaziando um Canal de E/S ........................................................383 Gravando Linhas de Texto ...........................................................443
Fechando Todos os Arquivos Abertos de uma Só Vez..................384 Colocando fgets e fputs em Uso ...................................................444
Obtendo o Indicativo de Arquivo de um Canal de Arquivo .... 385 Forçando a Tradução de Arquivo Binário.....................................445
Criando um Nome de Arquivo Temporário Usando P_tmpdir .. 386 Compreendendo Por Que o Programa copíatxt Não Pode
Criando um Nome de Arquivo Temporário Usando TMP ou Copiar Arquivos Binários...............................................................446
TEMP............................................................................................387 Testando o Final do Arquivo .......................................................447
Criando um Arquivo Verdadeiramente Temporário......................388 Devolvendo um Caractere.............................................................448
Removendo Arquivos Temporários................................................389 Lendo Dados Formatados de Arquivo...........................................449
Pesquisando o Caminho de Comandos para um Arquivo ............390 Posicionamento do Ponteiro de Arquivo com Base em Sua Posição
Pesquisando um Arquivo na Lista de Subdiretório de um Atual .............................................................................................450
Item do Ambiente..........................................................................391 Obtendo Informações do Indicativo de Arquivo...........................451
Abrindo Arquivos no Diretório TEMP ........................................392 Reabrindo um Canal de Arquivo...................................................452
Minimizando as Operações de E/S em Arquivo............................393
Matrizes, Ponteiros e Estruturas
Escrevendo Código Que Usa Barras Invertidas nos Nomes de
Diretório........................................................................................394 Compreendendo as Matrizes.........................................................453
Modificando o Diretório Atual......................................................395 Declarando uma Matriz.................................................................454
Criando um Diretório....................................................................396 Visualizando uma Matriz...............................................................455
Removendo um Diretório..............................................................397 Compreendendo os Requisitos de Armazenamento de uma
Removendo uma Árvore de Diretório ..........................................398 Matriz ...........................................................................................456
Construindo o Nome de Caminho Completo..............................399 Inicializando uma Matriz...............................................................457
Subdividindo um Caminho de Diretório......................................400 Acessando Elementos da Matriz ...................................................458
Construindo um Nome de Caminho............................................401 Percorrendo em um Laço os Elementos da Matriz.......................459
Abrindo e Fechando um Arquivo Usando Funções de Baixo Usando Constantes para Definir as Matrizes.................................460
Nível..............................................................................................402 Passando uma Matriz a uma Função.............................................461
Criando um Arquivo ....................................................................403 Revisicando as Matrizes Como Funções .......................................462
Efetuando Operações de Leitura e Gravação de Baixo Nível .... 404 Compreendendo Como as Matrizes de String Diferem.................463
Testando o Final de um Arquivo..................................................405 Passando Matrizes para a Pilha .....................................................464
Colocando as Rotinas de Arquivo de Baixo Nível para Determinando Quantos Elementos uma Matriz Pode
Trabalhar........................................................................................406 Armazenar.....................................................................................465
Especificando o Modo para uma Tradução Arquivo-Indicativo .. 407 Usando o Modelo de Memória Huge para as Matrizes
Posicionando o Ponteiro de Arquivo Usando Iseek ......................408 Grandes.........................................................................................466
Abrindo Mais de 20 Arquivos ................. 409 A Barganha entre Matrizes e Memória Dinâmica.........................467
Usando serviços de arquivo baseados no DOS................................410 Compreendendo as Matrizes Multidimensionais...........................468
Obtendo a Data e a Hora de Criação de um Arquivo..................411 Compreendendo as Linhas e Colunas...........................................469
Obtendo a Data e a Hora de um Arquivo Usando Campos de Acessando Elementos em uma Matriz Bidimensional...................470
Bit..................................................................................................412 Inicializando Elementos em uma Matriz Bidimensional...............471
Definindo a Data e a Hora de um Arquivo..................................413 Determinando o Consumo de Memória de uma Matriz
Definindo a Data e a Hora de um Arquivo com a Data e a Multidimensional...........................................................................472
Hora Atuais....................................................................................414 Percorrendo em um Laço uma Matriz Bidimensional...................473
Lendo e Gravando Dados uma Palavra de Cada Vez....................415 Percorrendo uma Matriz Tridimensional.......................................474
Alterando o Tamanho de um Arquivo..........................................416 Inicializando Matrizes Multidimensionais.....................................475
Controlando as Operações de Leitura e Gravação em Passando uma Matriz Bidimensional para uma Função ...............476
Arquivos Abertos............................................................................417 Tratando as Matrizes Multidimensionais Como uma Dimensão . 477
Atribuindo um Buffer de Arquivo ................................................418 Compreendendo Como C Armazena Matrizes
Alocando um Buffer de Arquivo....................................................419 Multidimensionais.........................................................................478
Criando um Nome de Arquivo Exclusivo Usando mktemp........420 Compreendendo a Ordem Linha por Linha versus Coluna por
Lendo e Gravando Estruturas........................................................421 Coluna....................................................................... 479
Lendo Dados de uma Estrutura a partir de um Canal de Matrizes de Estruturas de Matrizes ...............................................480
Arquivo..........................................................................................422 Compreendendo as Uniões ...........................................................481
Duplicando o Indicativo de um Arquivo......................................423 Economizando Memória com as Uniões.......................................482
Forçando a Definição de um Indicativo de Arquivo ....................424 Usando REGS - Uma União Clássica...........................................483
Associando o Indicativo de um Arquivo com um Canal ..............425 Colocando a União REGS em Uso...............................................484
Compreendendo o Compartilhamento de Arquivo ......................426 Compreendendo as Estruturas de Campos de Bit.........................485
Abrindo um Arquivo para o Acesso Compartilhado......................427 Visualizando uma Estrutura de Campos de Bit.............................486
Sumário IX
Compreendendo o Intervalo de Valores de uma Estrutura Compreendendo os Registradores .................................................551
Bit a Bit ...................................................................................... 487 Compreendendo o Registrador de Flags .......................................552
Procurando um Valor Específico em uma Matriz ...................... 488 Compreendendo as Interrupções de Software...............................553
Compreendendo uma Pesquisa Binária........................................ 489 Usando a BIOS para Acessar a Impressora ...................................554
Usando uma Pesquisa Binária...................................................... 490 Informação de Ctrl+Break.............................................................555
Classificando uma Matriz............................................................ 491 Compreendendo Possíveis Efeitos Colaterais do DOS .................556
Compreendendo o Método da Bolha.......................................... 492 Suspendendo um Programa Temporariamente..............................557
Colocando o Algoritmo da Bolha em Uso.................................. 493 Divertindo-se com Som.................................................................558
Compreendendo o Algoritmo da Seleção.................................... 494 Obtendo Informações Específicas do País.....................................559
Colocando em Uso o Método da Seleção.................................... 495 Compreendendo o Endereço de Transferência do Disco .............560
Compreendendo o Algoritmo Shell ............................................ 496 Acessando e Controlando a Área de Transferência do Disco .... 561
Colocando em Uso o Algoritmo Shell ........................................ 497 Usando os Serviços de Teclado da BIOS.....................................562
Compreendendo o Quick Sort.................................................... 498 Obtendo a Lista de Equipamentos da BIOS................................563
Colocando o Quick Sort em Uso................................................ 499 Controlando a E/S da Porta Serial................................................564
Problemas com as Soluções de Classificação Anteriores.............. 500 Acessando os Serviços do DOS Usando bdos..............................565
Classificando uma Matriz de Strings de Caracteres .................... 501 Obtendo Informações Estendidas de Erro do DOS .....................566
Pesquisando uma Matriz com Ifind ............................................ 502 Determinando a Quantidade de Memória Convencional da
Procurando Valores com Isearch.................................................. 503 BIOS............................................................................................567
Pesquisando uma Matriz Classificada com bsearch...................... 504 Construindo um Ponteiro far .......................................................568
Classificando Matrizes com qsort................................................ 505 Dividindo um Endereço far em um Segmento e Deslocamento .. 569
Determinando o Número de Elementos na Matriz .................... 506 Determinando a Memória do Núcleo Livre .................................570
Compreendendo Ponteiros como Endereços .............................. 507 Lendo as Configurações do Registrador de Segmento...................571
Determinando o Endereço de uma Variável................................ 508
Gerenciamento de Memória
Compreendendo como C Trata Matrizes como Ponteiros.......... 509
Aplicando o Operador de Endereço (&) a uma Matriz.............. 510 Compreendendo os Tipos de Memória.........................................572
Declarando Variáveis Ponteiro .................................................... 511 Compreendendo a Memória Convencional...................................573
Desreferenciando um Ponteiro.................................................... 512 Compreendendo o Layout da Memória Convencional.................574
Usando Valores de Ponteiro........................................................ 513 Acessando a Memória Convencional.............................................575
Usando Ponteiros com Parâmetros de Função............................ 514 Compreendendo Por Que o PC e o DOS Estão Restritos a
Compreendendo a Aritmética de Ponteiros ................................ 515 1Mb..............................................................................................576
Incrementando e Decrementando um Ponteiro.......................... 516 Produzindo um Endereço a partir de Segmentos e
Combinando uma Referência e Incremento de Ponteiro............ 517 Deslocamentos...............................................................................577
Percorrendo uma String Usando um Ponteiro............................ 518 Compreendendo a Memória Expandida .......................................578
Usando Funções Que Retornam Ponteiros.................................. 519 Usando a Memória Expandida .....................................................579
Criando uma Função Que Retorna um Ponteiro........................ 520 Compreendendo a Memória Estendida.........................................580
Compreendendo uma Matriz de Ponteiros.................................. 521 Compreendendo os Modos Real e Protegido.................................581
Visualizando uma Matriz de Strings de Caracteres...................... 522 Acessando a Memória Estendida...................................................582
Percorrendo em um Laço uma Matriz de Strings de Compreendendo a Área de Memória Alta.....................................583
Caracteres.................................................................................... 523 Compreendendo a Pilha ...............................................................584
Tratando uma Matriz de String de Caracteres Como um Compreendendo Diferentes Configurações da Pilha.....................585
Ponteiro ...................................................................................... 524 Determinando o Tamanho da Pilha Atual do Seu Programa .... 586
Usando um Ponteiro para um Ponteiro para Strings de Controlando o Espaço na Pilha com _stklen.................................587
Caracteres.................................................................................... 525 Atribuindo um Valor a um Intervalo de Memória .......................588
Declarando uma Constante String Usando um Ponteiro............ 526 Copiando um Intervalo de Memória para Outro .........................589
Compreendendo o Ponteiro do Tipo void.................................. 527 Copiando um Intervalo de Memória até um Byte Específico .... 590
Criando Ponteiros para as Funções.............................................. 528 Comparando Duas Matrizes de unsigned char .............................591
Usando um Ponteiro para uma Função...................................... 529 Permutando Bytes de Strings de Caracteres Adjacentes.................592
Usando um Ponteiro para um Ponteiro para um Ponteiro ........ 530 Alocando Memória Dinâmica......................................................593
Compreendendo as Estruturas .................................................... 531 Revisitando a Conversão ..............................................................594
Uma Estrutura É um Gabarito para a Declaração de Variáveis . . 532 Liberando a Memória Quando Ela Não É Mais Necessária........595
O Descritor de uma Estrutura É o Nome da Estrutura.............. 533 Alocando Memória Usando a Função calloc................................596
Declarando uma Variável Estrutura de Modos Diferentes.......... 534 Compreendendo o Heap..............................................................597
Compreendendo os Membros da Estrutura ................................ 535 Contornando o Limite de 64Kb para o Heap..............................598
Visualizando uma Estrutura ........................................................ 536 Alocando Memória a partir da Pilha............................................599
Pondo uma Estrutura em Uso .................................................... 537 Alocando Dados Huge..................................................................600
Passando uma Estrutura a uma Função ...................................... 538 Alterando o Tamanho de um Bloco Alocado ..............................601
Alterando uma Estrutura Dentro de uma Função ...................... 539 Compreendendo brk....................................................................602
Compreendendo a Indireção (*ponteiro).membro...................... 540 Validando o Heap........................................................................603
Usando o Formato ponteiro->membro ...................................... 541 Efetuando uma Verificação Rápida do Heap.................................604
Usando uma Estrutura sem Nome.............................................. 542 Preenchendo o Espaço Livre do Heap...........................................605
Compreendendo o Escopo de Definição de uma Estrutura........ 543 Verificando uma Entrada Específica no Heap...............................606
Inicializando uma Estrutura ........................................................ 544 Percorrendo as Entradas do Heap.................................................607
Efetuando E/S em Estruturas...................................................... 545 Examinando o Conteúdo de uma Posição de Memória
Usando uma Estrutura Dentro de Outra.................................... 546 Específica......................................................................... 608
Estruturas Que Contêm Matrizes................................................ 547 Colocando Valores na Memória ...................................................609
Criando uma Matriz de Estruturas.............................................. 548 Compreendendo as Portas do PC.................................................610
Acessando os Valores das Portas ...................................................611
Serviços DOS e BIOS
Compreendendo a CMOS.............................................................612
Compreendendo os Serviços do Sistema do DOS...................... 549 Compreendendo os Modelos de Memória.....................................613
Compreendendo os Serviços da BIOS ........................................ 550 Compreendendo o Modelo de Memória Tiny .............................614
X Programando em C/C+ + — A Bíblia
Compreendendo o Modelo de Memória Small ............................615 Aspas............................................................................................672
Compreendendo o Modelo de Memória Medium........................616 Exibindo o Conteúdo de um Arquivo a partir da Linha de
Compreendendo o Modelo de Memória Compact........................617 Comando......................................................................................673
Compreendendo o Modelo de Memória Large..............................618 Tratando argv Como um Ponteiro ...............................................674
Compreendendo o Modelo de Memória Huge ............................619 Compreendendo Como C Sabe sobre a Linha de Comando .... 675
Determinando o Modelo de Memória Atual ................................620 Compreendendo o Ambiente........................................................676
Tratando env Como um Ponteiro ..............................................677
Data e Hora
Use void para os Parâmetros de main..........................................678
Obtendo a Data e a Hora Atuais Como Segundos desde 1/1/1970 . . 621 Trabalhando com Números da Linha de Comando....................679
Convertendo uma Data e uma Hora de Segundos Compreendendo os Valores de Status da Saída.............................680
para ASCII ....................................................................................622 Usando return para o Processamento do Status da Saída............681
Ajuste do Horário de Verão ........................................................623 Determinando Se main Deve ou Não Ser Declarada Como
Retardando durante um Determinado Número de void ..............................................................................................682
Milissegundos................................................................................624 Pesquisando o Item Específico no Ambiente.................................683
Determinando o Tempo de Processamento do Seu Programa . . . 625 Como o DOS Trata o Ambiente ................................................684
Comparando Dois Horários..........................................................626 Usando a Variável Global environ................................................685
Obtendo uma String de Data........................................................627 Acrescentando um Item ao Ambiente Atual .................................686
Obtendo uma String com o Horário............................................628 Acrescentando Elementos no Ambiente DOS..............................687
Lendo o Temporizador da BIOS ..................................................629 Abortando o Programa Atual........................................................688
Trabalhando com o Horário Local................................................630 Definindo Funções Que Executam ao Término do Programa ... 689
Trabalhando com o Horário de Greenwich..................................631 Compreendendo as Bibliotecas ....................................................690
Obtendo o Horário do Sistema DOS............................................632 Reutilizando o Código-Objeto .......................................................691
Obtendo a Data do Sistema do DOS............................................633 Problemas com a Compilação de Arquivos C e OBJ ...................692
Definindo o Horário do Sistema DOS..........................................634 Criando um Arquivo de Biblioteca..............................................693
Definindo a Data do Sistema do DOS ........................................635 Compreendendo as Operações da Biblioteca Comum...................694
Convertendo uma Data do DOS para o Formato do UNIX .... 636 Listando as Rotinas em um Arquivo de Biblioteca.......................695
Usando timezone para Calcular a Diferença entre a Zona Use Bibliotecas para Reduzir Seu Tempo de Compilação............696
Horária..........................................................................................637 Aprendendo Mais sobre as Capacidades da Sua Biblioteca..........697
Determinando a Zona Horária Atual............................................638 Compreendendo o Linkeditor......................................................698
Definindo Campos de Zona Horária com tzset............................639 Vendo as Capacidades do Linkeditor ..........................................699
Usando a Variável de Ambiente TZ........................................ . 640 Usando um Mapa do Linkeditor..................................................700
Definindo a Entrada de Ambiente TZ a partir de Dentro de Usando Arquivos de Resposta do Linkeditor.................................701
Seu Programa................................................................................641 Simplificando a Criação de Aplicativos com o MAKE.................702
Obtendo as Informações de Zona Horária....................................642 Criando um Arquivo Simples do MAKE ....................................703
Definindo a Hora do Sistema em Segundos desde a Meia-noite Usando Múltiplos Arquivos de Dependência com o MAKE .... 704
de 1/1/1970 ................................................................................ 643 Comentando Seus Arquivos do MAKE........................................705
Convertendo uma Data para Segundos desde a Meia-noite de Linhas de Comando e MAKE......................................................706
1/1/1970 ...................................................................................... 644 Colocando Múltiplas Dependências em um Arquivo do
Determinando a Data Juliana de uma Data..................................645 MAKE..........................................................................................707
Criando uma String Formatada de Data e Hora..........................646 Regras Implícitas e Explícitas do MAKE......................................708
Compreendendo os Tipos de Relógio do PC................................647 Usando Macros do MAKE ..........................................................709
Macros Predefinidas do MAKE....................................................710
Redirecionando a E/S e Processando Linhas de Comando Executando Processamento Condicional com o MAKE ...............711
Aguardando a Digitação de uma Tecla..........................................648 Testando um Nome de Macro ....................................................712
Pedindo uma Senha ao Usuário....................................................649 Incluindo um Segundo Arquivo do MAKE .................................713
Escrevendo Sua Própria Função de Senha ....................................650 Usando os Modificadores de Macro do MAKE ...........................714
Compreendendo o Redirecionamento da Saída ............................651 Finalizando, um Arquivo do MAKE com um Erro.......................715
Compreendendo o Redirecionamento da Entrada........................652 Desabilitando a Exibição do Nome do Comando.........................716
Combinando o Redirecionamento da Entrada e da Saída ............653 Usando o Arquivo BUILTINS.MAK ..........................................717
Usando stdout e stdin....................................................................654 Executando Processamento de Status de Saída no MAKE ...........718
Compreendendo o Operador de Canalização................................655 Chamando e Alterando uma Macro ao Mesmo Tempo..............719
Compreendendo getchar e putchar................................................656 Executando um Comando MAKE para Múltiplos Arquivos
Numerando a Entrada Redirecionada............................................657 Dependentes ................................................................................720
Garantindo Que uma Mensagem Apareça na Tela........................658 C Avançado
Escrevendo Seu Próprio Comando more ......................................659
Exibindo um Contador de Linhas Redirecionadas........................660 Determinando Se o Co-Processador Matemático Está Presente . . 721
Exibindo um Contador de Caracteres Redirecionados..................661 Compreendendo as Macros ctype.h e istype.................................722
Criando um Comando More com Controle de Tempo..............662 Controlando o Vídeo Direto.........................................................723
Impedindo o Redirecionamento da E/S........................................663 Detectando Erros Matemáticos e do Sistema ...............................724
Usando o Indicativo de Arquivo stdprn........................................664 Exibindo Mensagens de Erro Predefinidas.....................................725
Desviando a Saída Redirecionada para um Arquivo......................665 Determinando o Número de Versão do Sistema Operacional ... 726
Usando o Indicativo de Arquivo stdaux........................................666 Compreendendo a Portabilidade...................................................727
Encontrando Ocorrências de Substring Dentro da Entrada Efetuando um Goto Não-local .....................................................728
Redirecionada................................................................................667 Obtendo a Identificação do Processo.............................................729
Exibindo as Primeiras n Linhas da Entrada Redirecionada ..........668 Chamando um Comando Interno do DOS .................................730
Compreendendo os Argumentos da Linha de Comando............669 Usando a Variável Global _psp.....................................................731
Exibindo um Contador de Argumentos da Linha de Comandos . 670 Usando o Modificador const nas Declarações de Variáveis..........732
Exibindo a Linha de Comando ....................................................671 Usando Tipos Enumerados...........................................................733
Trabalhando com Argumentos da Linha de Comando entre Colocando um Tipo Enumerado em Uso.....................................734
Sumário XI
Compreendendo um Valor Enumerado...................................... 735 Introdução à C+ +
Atribuindo um Valor Específico a um Tipo Enumerado............ 736
Salvando e Restaurando os Registradores.................................... 737 Introduzindo C++ ....................................................................... 803
Introdução às Listas Dinâmicas .................................................. 738 Como os Arquivos-Fonte de C++ São Diferentes.........................804
Declarando uma Estrutura de Lista Ligada.................................. 739 Iniciando com um Programa Simples em C++.............................805
Criando uma Lista Ligada............................................................ 740 Compreendendo o Canal de Enrrada/Saída cout...........................806
Exemplo de uma Lista Ligada Simples........................................ 741 Escrevendo Valores e Variáveis com cout .....................................807
Compreendendo como Percorrer uma Lista Ligada.................... 742 Combinando Diferentes Tipos de Valores com cout.....................808
Criando uma Lista Mais Útil...................................................... 743 Exibindo Valores Hexadecimais e Octais........................................809
Anexando um Elemento na Lista................................................ 744 Redirecionando cout .....................................................................810
Inserindo um Elemento na Lista.................................................. 745 Se Você Gosta de printf, Use printf.............................................811
Exibindo um Diretório Classificado............................................ 746 Escrevendo Saída em cerr ............................................................812
Excluindo um Elemento de uma Lista........................................ 747 Recebendo Entrada com cin ........................................................813
Usando uma Lista Duplamente Ligada........................................ 748 cin Não Usa Ponteiros..................................................................814
Criando uma Lista Duplamente Ligada Simples ........................ 749 Compreendendo Como cin Seleciona os Campos de Dados........815
Compreendendo nodo->anterior->próximo................................ 750 Compreendendo Como os Canais de E/S Conhecem os Tipos
Removendo um Elemento de uma Lista Duplamente Ligada . .. 751 dos Valores....................................................................................816
Inserindo um Elemento em uma Lista Duplamente Ligada........ 752 Efetuando Saída Usando clog ......................................................817
Compreendendo os Processos-Filho............................................ 753 cin, cout, cerr e clog São Ocorrências de Classe...........................818
Gerando um Processo-Filho........................................................ 754 Descarregando a Saída com flush ................................................819
Usando Outras Funções spawnlxx .............................................. 755 Compreendendo o Que iostream.h Contém................................820
Usando as Funções spawnvxx...................................................... 756 C++ Requer Protótipos de Funções..............................................821
Executando um Processo-Filho................................................... 757 C++ Acrescenta Novas Palavras-Chave ........................................822
Usando Outras Funções execlxx.................................................. 758 C++ Suporta as Uniões Anônimas................................................823
Usando as Funções execvxx ........................................................ 759 Resolvendo o Escopo Global........................................................824
Compreendendo os Overlays ...................................................... 760 Fornecendo Valores Padrão de Parâmetros ..................................825
Compreendendo as Interrupções.................................................. 761 Controlando a Largura da Saída de cout......................................826
As Interrupções do PC................................................................ 762 Usando setw para Definir a Largura para cout............................827
Usando a Palavra-Chave interrupt .............................................. 763 Especificando um Caractere de Preenchimento em cout..............828
Determinando o Vetor de uma Interrupção................................ 764 Justificando à Direita e à Esquerda a Saída de cout .....................829
Definindo um Vetor de Interrupção............................................ 765 Controlando o Número de Dígitos em Ponto Flutuante
Habilitando e Desabilitando as Interrupções .............................. 766 Exibidos por cout...........................................................................830
Criando uma Rotina Simples de Tratamento de Interrupção .... 767 Exibindo Valores nos Formatos Fixo ou Científico.......................831
Encadeando uma Segunda Interrupção........................................ 768 Restaurando cout para o Padrão ...................................................832
Gerando uma Interrupção............................................................ 769 Definindo a Base da E/S...............................................................833
Interceptando o Temporizador do PC........................................ 770 Declarando Variáveis Onde Você Precisa Delas ...........................834
Compreendendo os Erros Críticos .............................................. 771 Colocando Valores de Parâmetro Padrão em Protótipos de
Tratamento de Erro Crítico em C.............................................. 772 Função...........................................................................................835
Uma Rotina de Tratamento de Erro Crítico Completa.............. 773 Usando Operadores Bit a Bit e cout.............................................836
Restaurando as Interrupções Alteradas........................................ 774 Compreendendo a Avaliação Preguiçosa (ou Curto- Circuito) . .. 837
Criando uma Rotina de Tratamento de Ctrl+Break.................... 775 Usando a Palavra-Chave const em C++........................................838
Usando os Serviços do DOS na Sua Rotina de Tratamento Usando a Palavra-Chave enum em C++ ......................................839
de Erro Crítico............................................................................ 776 Compreendendo o Espaço Livre ...................................................840
Aumentando o Desempenho com o Uso da Seleção do Alocando Memória com new.........................................................841
Conjunto de Instruções................................................................ 777 Alocando Múltiplas Matrizes.........................................................842
Funções Intrínsecas In-line.......................................................... 778 Testando a Falta de Espaço Livre .................................................843
Habilitando e Desabilitando as Funções Intrínsecas.................... 779 Considerações sobre o Espaço no Heap.........................................844
Compreendendo as Chamadas Rápidas de Funções................... 780 Usando Ponteiros far e o Operador new.......................................845
Regras para a Passagem de Parâmetros _fastcall.......................... 781 Liberando Memória de Volta ao Espaço Livre .............................846
Compreendendo o Código Invariante ........................................ 782 Compreendendo as Referências de C++.........................................847
Compreendendo a Supressão de Carga Redundante.................... 783 Passando uma Referência a uma Função.......................................848
Compreendendo a Compactação do Código .............................. 784 Atentando para os Objetos Ocultos...............................................849
Compreendendo a Compactação do Laço .................................. 785 Usando Três Modos de Passar Parâmetros ...................................850
Compreendendo a Indução do Laço e a Redução da Força........ 786 Regras para Trabalhar com Referências.........................................851
Compreendendo a Eliminação de Subexpressão Comum............ 787 As Funções Podem Retornar Referências......................................852
Compreendendo as Conversões Comuns de C Padrão................ 788 Usando a Palavra-Chave inline de C++........................................853
Compreendendo os Quatro Tipos Básicos de C.......................... 789 Usando a Palavra-chave asm de C++............................................854
Compreendendo os Tipos Fundamentais versus os Derivados ... 790 Lèndo um Caractere Usando cin...................................................855
Compreendendo os Inicializadores.............................................. 791 Escrevendo um Caractere com cout...............................................856
Compreendendo o Sistema de Ligação (Linkage)........................ 792 Escrevendo um Programa Simples de Filtro .................................857
Compreendendo as Declarações Experimentais .......................... 793 Escrevendo um Comando Tee Simples.........................................858
Contrastando Declarações e Definições ...................................... 794 Escrevendo um Comando First Simples ......................................859
Compreendendo lvalues .............................................................. 795 Escrevendo um Comando First Melhor........................................860
Compreendendo rvalues.............................................................. 796 Testando o Final do Arquivo.........................................................861
Usando Palavras-chave de Registradores de Segmento ................ 797 Gerando uma Nova Linha com endl.............................................862
Use os Ponteiros far com Cuidado.............................................. 798 Compreendendo as Especificações de Ligação...............................863
Compreendendo os Ponteiros Normalizados .............................. 799 Compreendendo a Sobrecarga.......................................................864
Comandos do Co-Processador Matemático ................................ 800 Sobrecarregando as Funções...........................................................865
Compreendendo cdecl e pascal nas Variáveis.............................. 801 Sobrecarregando Funções: um Segundo Exemplo.........................866
Impedindo as Inclusões Circulares.............................................. 802 Evitando a Ambigüidade da Sobrecarga.........................................867
Lendo uma Linha de Cada Vez com cin .......................................868