Treinamento Em Linguagem C - Módulo 1z

(1)

(2)

,

SUMARIO

Prefácio ... . XVII Uma Visão Geral ... . XIX Classes e objetos . . . XIX Encapsular e esconder . .. .. . .. . .. .. . .. .. . . .. . .. . .. .. .. . .. . .. . .. . .. . .. . .. . XX Herança ... XX Polimorfismo e sobrecarga . .. .. .. .. . .. .. . .. . .. .. . .. .. . .. .. . . .. . .. .. .. . .. XXII C é um subconjunto de C++ . . .. . .. . ... . .. . .. . .. . .. . .. .. .. . .. . .. . .. . ... . XXITI

Capítulo 1 Conceitos Básicos ... ... ... .. ... 1

A estmtura básica de um programa em C++ . . .. .. . . . ... . .. . .. . .. . .. . .. .. .. . . 1

Forma geral das fnnções C++ ... 1

O primeiro programa .. . .. . .. . .. .. . .. .. . .. . .. . .. .. . .. .. . .. . .. . .. . ... . .. . . 2

Nome das funções . . . .. .. . .. .. . .. . . .. .. . .. . .. . .. .. . .. .. . .. . .. . . .. .. . .. . .. 2

O tipo void . .. .. . .. .. . .. . .. . .. .. . .. .. . .. .. . .. . .. . ... . . .. .. . .. . .. .. . . . 2

Chaves . . .. .. . .. . .. .. . .. . .. .. . .. . .. .. . .. . .. .. . .. . .. . .. . .. . .. . .. . ... . .. . . 3

Espaços em branco ... . ... .. ... . ... 3

Instruções de programa ... 4

Imprimindo usando cout ... . ... .. ... .. ... . ... . ... 4

O pré-processador C++ ... 5

A diretiva #include ... 5

(3)

X Treinamento em Linguagem C++

Arquivos de inclusão ... 6

O arquivo iostream.h . ... .. .. . .. . ... . ... . .. . .. .. .... . .. .. .. . ... . .. 6

Executando o primeiro programa ... 6

Códigos especiais ... 7

Imprimindo numa nova linha ... 8

Constantes numéricas .... . ... . .. . ... . ... . .. . ... . ... 8

Cadeia de caracteres constante . .. .. . .. .. .. . .. .... .. . .. .. .. . . .. . .. .. .. . .. .. . . 9

Aspas simples ou aspas duplas ... 9

Imprimindo outros tipos de dados ... 9

Variáveis .... . ... . ... . ... . ... . . 10

Declarações de variáveis ... . .. . ... . ... . ... 11

Tipos de variáveis ... . ... . ... 12 Inicializando variáveis . ... . ... . ... . ... . ... . .. . ... . .. . . 14

Variáveis ponto flutuante (float) ... 14

O modificador unsigned: inteiros com e sem sinal ... . .. . .. . .. . .. .. .. . .. . . 16

Nomes de variáveis ... . ... . ... . ... 17

Palavras-chave de C++ ... . .. . ... . .. . ... . .. . .. . ... 18

Manipuladores de tamanho de campos na impressão .. . .. ... . . .. . .. .. . .. .. . . 19

Tamanho de campos com números inteiros ... 19

Tamanho de campos com pontos flutuantes ... 21

Tamanho de campos com cadeias de caracteres ... . .. . .. . .. . ... 22

Manipuladores de bases numéricas . . ... . ... . .. . ... 23

Imprimindo caracteres gráficos . .. .. . .. .. . .. . .. .. . .. . ... . .. . . .. .. . .. . .. . .. . 23

Re\risão . .. . .. . .. . o • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • 26 Exercícios ... o • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • 28 Capítulo 2 Operadores .... ... ... .. .. ... ... .... .. ... .. ... .. .... . ... . 34

Operador de atribuição: = . ... . .. . .. . ... . ... . .. . ... . .. . . 34

Operadores aritméticos: + - * I % . .. . .. .. .. . ... .. . .. . ... . .. . . .. .. . .. . .. .. .. 35

Precedência .. . .. . .. . .. .. . .. .. . .. . .. . .. .. . .. .. . .. . ... . .. . . .. .. . .. . ... 36

O operador menos unário: - ... 37

Lendo com cin e o operador de extração >> . ... .. . .. . .. .. .. . . .. .. . .. . .. . ... 37

Múltiplas entradas com cin . .. .. .. . .. .. .... . . .. .. . .. .. .. . .. . . .. .. . .. .. .. 38

(4)

Sumário XT

Manipuladores de bases numéricas: dec hex oct .. . .. . .. .. . . ... .. .. . .. . .40

O qualificador const .. .. . .. . .. . .. ... .. . .. . .. . .. .. .. . .. . ... . .. ... .. . . 40

Conversões de tipos e o operador de molde . ... . .. . ... 41

As funções getche() e getch() ... . ... . ... 42

Comentários .. . .. . ... . .. . ... . ... .. ... ... .. 43

Sintaxe ... 44

Operadores de incremento ( ++) e de decremento (--) . . ... . .. . .. . .. . ... . .. 44

Precedência ... . ... .. ... 46

Cout enganando você ... 47

Operadores aritméticos de atribuição: += -= *= I= %= ... .. ... 49

Operadores relacionais: > >= < <= == != ... 51

Precedência .. . .. . ... . .. .. ... . .. .. .. . ... .. . . ... 52

Operadores lógicos: && I I ! . .. .. .. . .. . .. . .... .. .. .. . .. .. . .. . .. . .. . .. ... . 53

O operador condicional temário: ?: ... . ... . ... 54

Tabela de precedência dos operadores . . .. . .. . .. .. . .. .. . .. . .. .. . .. . .. . . .. .. . 55

Operadores: avaliação lógica ou numérica ... .... ... . ... 56

Revisão ... . .. .. . . ... .. .. . .. .. .. . ... . .. .. . .. .. . ... . .. .. . .. .. 56

Exercícios ... 57

Capítulo 3 Laços .. ... ... .. .... .. ... ... . .... .. ... ... .. ... .. .. 63

O laço for . . ... . ... ... .... . .. . .. . .. .. . o o • • • • • • • • • • • • • • o • • • • • 63 Sintaxe do laço for ... . . ... . . o • • • • • o • • • • • o • o • • • • • • • • • • • • • • • • • • • o 64 Variáveis declaradas na instrução for ... 66

Flexibilidade do laço for . .. . . .. .. . .. .. .. . . .. ... .. . .. .. . . .. ... . .. .. .. 67

O operador vírgula ... o • • • • • o • • • • • • • • • • o • • • • • • • o • • • • • • • • • • • • • • • • • • • • 67 Usando caracteres ... 67

Usando chamadas a funções ... .... ... . ... . ... 68

Omitindo expressões do laço for . .. . .. ... . .. .. . .. .. . ... . .. .. . .. .. 68

Um laço infirlito . o • • • o o • • o • • • • o • • o • • • • o • • o • • • • • • • • • • • o • • • • • o • • o • • o • • • o o • 69 Omitindo o corpo do laço for . .. . ... . .. . . . .. . .. . ... . .. . .. .. . . .. .. .. . .. . . 69

Múltiplas instruções no corpo de um laço for ... 69

Visibilidade de variáveis de bloco .. . .. . .. . .. . .. . ... . .. . .. . .. . .. .. .. . . .. . 71

Laços for aninhados .. ... .. .. .. . .. . .. .... .. .. .. .. . ... . . .. . ... . .. .. 72

(5)

Xll T1'einnmento em Linguagem C++

O laço while .. . .. . ... . .. . ... . .. .. . ... . . ... . .. .. .. . .. . ... ... .. ... . 76

Sintaxe do laço while .. . .. . . .. .. .... .. .. . .. . . .. .. .. . .. . .. .... .. .. .. . .. . . 77

Laços while aninhados . ... . ... . .... . ... .. .. . ... ... . ... 78

O laço do-while .. . . ... 79

Sintaxe do laço do-while ... . ... . ... .. . ... 80

Re,risão ... . .. .. . .. ... .. .. ... .. . ... . .. .. .. . .. . ... . .. . .. .. .. 81

Exercícios ... 82

Capítulo 4 Comandos de Decisão .. ... .. ... ... ... .. ... .. ... ... ... .. .... .. 87

O comando if . .. .. . ... .. . .. .. . ... . . .. ... . ... . .. . . .. ... . ... . .. 87

Sintaxe do comando if ... .. . . .. . ... . .. ... .. . ... . .. . ... . .. 88

O programa que conta zeros .. . .. . .. ... ... . .. . ... . .. . .. ... . 88

Implementando um algoritmo . .. .. . .... .. .. . . .. .. . ... .... . .. .. . .. .. .. 89

O comando if-else ... . ... 90

Sintaxe do comando if-else ... 91

O programa que conta zeros modificados ... . .. . ... . .. . ... 92

Um tabuleiro de xadrez .. . .. . .. .. . .. .. . .. . .. . ... . .. .. .... .. .. . . . .. .. . 92

O jogo de cara ou coroa ... 94

Desenhando linhas ... ... ... . ... .. .... 96

Comandos if aninhados ... . ... .. ... 97

Usando operadores lógicos ... 101

Os comandos break e continue .. . .. . ... . ... . ... .. .. . .. .. . . .. . .. . .. . 102 O comando continue .. .. .... . .. . ... . ... .... ... . ... .. .. . .. . 104 O comando goto . . .. .. .. . .. . .. . .. . ... . .. . .. . ... . .. . .. .. . .. . .. .. . .. . 105

O comando switch ... . ... " ... 106

Sintaxe do comando switch ... . . ... . ... . .. .. .. . . 106

O programa DIASEMAN.CPP .... ... . ... . ... . .. . 107

O programa CALC.CPP modificado .. .. . .. . .. .. . .. . .. .. . .. . . .. . .. . .. .. . 109 Casos sem break em comandos switch .. . .. . .. . .. .. . .. . . .. . .. . ... . .. . 110

Revisão . .. . .. .. . .. . .. . .. .. . .. .. . .. . .. . ... . .. . .. . .. . ... . .. . .. . .. . .. . .. . . . 111

Exercícios . . ... o • o • • o • • • • • • • • • • o • o o • • • • • • • o • o o • o • o • • • • • • • • o • o • • o • o o o o • 112 Capítulo 5 Funções ... 117

Chamando uma função .. .. ... . . . . .. . . ... . . .... . . . ... ... . . .... 118

(6)

Sumário Xlll

O protótipo de funções ... 120

Protótipo externo e local ... 121

Eliminando o protótipo de funções ... 122

Tipos de funções ... 123

O comando return . . ... . ... .... 123 Limitações do comando return . .. ... . . ... . .. .. ... . ... .. . . 124 Definição da fw1ção ... . ... . .. . ... .... .. . ... . .. . .. . ... . .. . 124

Parâmetros da função ... 125

Passagem por valor ... 126

Funções que não retornam nada: tipo void .. . ... .. ... 127

Funções que não recebem nada e não retornam nada .... . ... . ... . .. . ... 128

Passando vários argumentos ... . .. . ... . .. .. ... . ... 129 Escrevendo várias funções num mesmo programa . .. .. .. . .. ... ... 130

Chamadas a funções usadas como argumento de outras funções ... 132

O operador unário de referência: & ... 133

Passagem por referência ... . ... 134

Ordenando uma lista de números ... 136 Referências constantes .. . .. . .. . .. . ... . . . ... . .. . .. . ... . .. . .. . 137

Considerações sobre referências ... 138

Valores default para os argumentos de uma função ... 139

Sobrecarga de funções . .... . .. . ... .. ... . .. . .. ... 140

O programa LINHAl.CPP modificado .. . ... . ... . .. . ... . .. . .. . 142 Funções inline . .. . .. .. .. . .. . .. . .. . ... . .. . .. . .. . ... . .. . .. . ... . .. . 143 Quando usar inline .. . ... . . ... .. ... ... .. . ... . . .. .. .... . . .. .. . . . ... 144

Funções recursivas ... 145

Como trabalha uma função recursiva? . . .. . .. .. . .. .. . . .. . .. . .. . .. .. .. . . . 146

Jogo da torre de hanoi ... . ... . ... 148

Classes de armazenamento ... 150 A classe auto . .. . .. . .. . .. . .. . .. . ... . .. . .. . .. . .. . ... . .. .. . . .. .. .. . .. . 151

A classe extern . . .. .. .. . . .. .. . .. . ... . .. . .. . .. . .. . .. . .. . .. . .. . .. .. .. . .. . 152

O operador de escopo: :: . ... . .. . ... . .. . .. . .. .. .. . . .. .. . .... .. .. . .. . 153

A palavra-chave extern . .. . .. . .. .. .. . .. . .. . .. . .. .. .. . .. . . . .. . .. .. .. . .. . 154

Retornando de uma função por referência ... 154

(7)

XIV Treinamento em Linguagem C++

Uma função que gera números aleatórios ... 156

A classe static extem .. . .. . . .. .. .. . .. .. .. . . .. .. . .. . .. . . .. ... . .. .. . ... 158

Classe de armazenamento de fw1ções ... 160

A classe register ... 160

Observações técnicas ... . .. . ... . ... . ... . ... .... 162 O pré-proce.ssador . . .. .. ... . .. .. . .. .. . . . .. . .. .. . .. .. . ... . .. .. . .. .. 162

A diretiva #define ... . .. ... ... . ... .... .. . ... . .. . . . ... .. .. . .. . 163

Macros ... . ... .. ... 165

O uso de parênteses em macros ... . ... 167

Definindo macros usando outras macros .. . ... . . .. ... 168 Macros em várias linhas ... 169 Macros versus funções inline ... . .. . .. . ... . .. .. .. . .. .. .... . .. . .. . .. . 169 A diretiva #undef ... 172

A diretiva #include ... 172

Arquivos de inclusão . . .. . .. . .. .. . .. .. . .. . .. .. . .. . ... . . .. . .. . .. .. .. . .. . 173

Compilação condicional ... . .. . ... . ... . ... .. . . 174 As diretivas #if, #ifdef, #ifndef, #elif, #else e #endif ... 175 O operador defined .. .. . .. . .... . ... . .. . .. . ... . ... . .. . .... . .. .. .. . .. . 177 A diretiva #error ... . .. . ... 177 Re,,isão ... 177 Exercícios . . .. . ... . ... . .. . ... . .. . .. ... . . .. . .. . .. . ... 180 Capítulo 6 Matrizes ... 188 Declaração da matriz .. .. . .. . .. . .. . .. .. .. . .. . ... . ... . .... .. .. . .. . 190

Referendando os elementos da matriz ... 191

Matrizes de outros tipos de elementos ... 191

Um número desconhecido de elementos ... . .. . .. . .. . 193 Checando limites . . .. .. .. . ... . .. .. . .. .. . .. . .. .. . .. . .. .. . .. . .. . .. .. . .. .. 194

Inicializando matrizes .. .... .. .. . . . ... . .. . .. . .. . ... .. .. . .. . . . ... . .. . 195 Ma trizes de mais de uma dimensão . . .. . ... . . .. .. . . . ... . .. . .. . .... .. .. . .. . 197

Inicializando matrizes de duas dimensões ... . ... 202

Inicializando matrizes de três dimensões .. . .. . .. . .. .. .. . .. . .. . .... .. .. . .. . 205

Ma trizes como argumentos de funções .. .. . .. .... .. .. . ... . .. .... .. . .. .. . 206

(8)

Sumário XV

Ordenando os valores de uma matriz . ... . . ... . . ... ... . .. .. .. . .. . 208

A ordenação bolha .. .. . .. . . .. .. .. . .. .. .. . . .... .. . .. .. . .. .... .. .. .. . ... 210

Matrizes de duas dimensões como argumento de fw1ções .... . .... . ... . 211

Strings ... .. ... .. ... 214

Strings constantes ... . ... . ... . ... .. ... ... 215

Strings variáveis ... . . .. . .. .. . .. . . ... . .. .. . ... . . 216

A função getsO ... . . . .. . ... . ... .... .. . ... . .... . ... .. .. . .. . 217

Inicializando strings ... 218

Aritmética com endereços ... . ... 219

Outras funções de manipulação de strings . . ... . . ... . . ... 220

A função strlen() .. .. .. . ... . .. .. . .. .. . .. . .. . .. .. . . .. . ... . .. .. .. . .. . 221 A função strcat() ... . ... .. . . .. .. .. . ... . .. .. . .. . . ... . .. . 222

A função strcmp() ... .. . . .. . ... . .. . . .. . .. . .. ... 223

A função strcpy() ... . .. . ... . .. .. ... . ... . 226

As funções strncat(), strncmp(), strncpy() . . .. .... .. . .. .. . .. . .. . .. . .. . .. . 227

Uma matriz de strings ... . . . ... . ... . ... .. . . 227

Revisão ... . .. .. . . ... .. .. . .. .. .. . ... . .. .. . .. .. . ... . .. .... . . 229

Exercícios ... 230

Capítulo 7 Estruturas . .. ... .. .... ... ... .... .. . .... ... .. ... ... .. .. . 237

Criando novos tipos de dados com struct . ... . .. . .. . ... . . 238

Definindo a estrutura ... . . ... . .. . ... . . .. ... . ... . . .. .. . .. .. . . .. .. .. . .. 239

Declarando uma variável do tipo definido ... . .. . . .. . . ... . .... ... 240

Acessando os membros da estrutura .. .. .. . .. . ... . .. . .. . .. .. .... .. .. . .. . 241

Combinando declarações ... ... ... ... 241

Inicializando estruturas ... ... . ... . ... . ... . . 242

Atribuições entre estruturas ... . ... . ... . .. .... ... . .. . 243

Operações entre estruturas . ... . .. . . .. .. . .. . .. .. . .. . .. .. . .. . .... .. . .. .. . 243

Estruturas aninhadas .... . .. . .. . .. . ... . .. . .. . ... . .. . .. . .. . ... . .. . 244

Inicializando estruturas aninhadas . . ... . .. . .. . .. . .. . ... . .. . .... . .. .. .. . .. . 245

Passando estruturas para funções ... ... ... .... ... . .... 246

Passando estruturas para funções por referência .... .. .. . .. . .. . .. . ... . .. . 248

Funções que retornam uma estrutura . . .. .. . .. .... . .. .. . .. .. . .. .... .. . .. .. . 249

(9)

XVI Treinamento em Linguagem C++

Declarando a matriz de estruturas ... .... . .. .. .. . ... . .. . 255

Acessando membros da matriz de estruturas ... .. . .. .. .. . . .. . . .. .. . .. .. . 256

As funções atoi() e atof() ... . ... . ... . ... 256

A função exit() ... 257

Estruturas e classes ... . .. . ... . ... . ... .. . 257

Tipos de dados enumerados: enum . .. . .. . . .. . .. . .. .. .. . .. . . ... 258

Uniões .. .. .. . ... . ... . .. . .. . ... . ... .... .. . ... . .. . .. . ... . . . 259

O operador sizeof ... 262

U11iões anôrlimas ... .. . .. ... . ... 263

O operador de endereços: & ... . . . ... . . . ... . . ... ... 265

Uniões de estruturas .. . ... . .. .. . .. .. . .. . .. . .. .. . . .. . ... . .. . ... 267

A ROM BIOS .. . .. . ... . .. .. . . ... . .. .. .. . .. .. . . ... .. ... 268

Conhecendo a biblioteca da ROM BIOS . .... . .. .. .. . .. .. ... ... . .... 269

Acessando a ROM BIOS ... ... 269

Os principais registradores do 8086 . . .. . . .. . .. . .. .. . .. .. . .. . .. . . .. . ... . . 270

Número de interrupções ... . .. . ... .. .. 271

A função C++ int86() e o arquivo dos.h ... . . ... .. ... 272

Descobrindo o tamanho da memória principal .. . .. .... .. . . .. .. . .. . .. . .. . 273

Limpando a tela ... . ... . . . ... 27 4 Montando o tamanho do cursor ... 276

Fazendo o cursor desaparecer ... . ... . .. . ... . ... .... .. 279

Revisão ... . .. .. . . ... . .. . .. . ... . ... .. .. . .. .. ... . ... .. . . 281

Exercícios . . .. ... . ... .. . .. .. . .. . ... . . .. .. . .. . .. . ... . .. . .. . .. . .. . .. . . . 283

(10)

,

PREFACIO

O curso completo está dividido em dois volumes. O Módulo 1 abrange os Capítulos 1 a 7 e o Módulo 2, os Capítulos 8 a 13. Este livro foi planejado para um curso completo de programação em linguagem C++. O estudante deve ter conhecimentos básicos de sistema operacional nos equipamentos da família IBM-PC, XT, ATou PS/2.

O objetivo principal é o de apresentar a linguagem C++ de maneira simples e clara e mostrar como C++ pode ser usada para a criação de programas sérios. Os exemplos expostos não estão relacionados a nenhum assunto

especí-fico e podem ser facilmente adaptados a qualquer área de aplicação.

O livro apresenta uma organização didática dos temas abordados e pode ser adotado em cursos de computação de escolas técnicas ou universida-des. Ao aluno interessado é dada a oportunidade de criar novos programas e desenvolver novas idéias a partir das apresentadas.

É certamente possível aprender C++ sem conhecer a linguagem C. Esse livro foi planejado para o ensino da linguagem C++ como linguagem indepen-dente. Você pode aprender C++ mesmo como primeira linguagem de progra-mação. Entretanto seus conceitos e sua sintaxe não são tão fáceis como os de uma linguagem como BASIC ou PASCAL, e os programadores iniciantes podem sentir alguma dificuldade.

Os exemplos deste livro foram processados utilizando o compilador TURBO C++ da Borland ou o compilador C++ 7.0 da Microsoft para computa-dores IBM-PC e sistema operacional MS-DOS versão 6.0.

(11)

(12)

,.,

UMA VISAO GERAL

CLASSES E OBJETOS

A idéia fundamental de linguagens orientadas ao objeto é a possibilidade de combinar num único registro campos que conterão dados e campos que são funções para operar os campos de dados do registro. Uma unidade assim definida é chamada classe.

Uma classe é considerada um tipo de dado como os tipos que existem predefinidos em compiladores de diversas linguagens de programação.

Como exemplo, considere o tipo int que é predefinido em C e C++. Podemos declarar quantas variáveis do tipo int forem necessárias ao programa. De modo similar, podemos declarar quantas variáveis quisermos de uma classe já definida.

Uma variável de uma classe é chamada objeto e conterá campos de dados e funções.

Definir uma classe não cria nenhum objeto, do mesmo modo que a existência do tipo int não cria nenhuma variável.

(13)

XX Treinamento em Linguagem C++

As funções de um objeto são chamadas funções-membro ou métodos

e, de modo geral, são o único meio de acesso aos campos de dados também

chamados variáveis de instância.

ENCAPSULAR E ESCONDER

Se o programa necessita atribuir um valor a alguma variável de instância, deve

chamar uma função-membro que recebe o valor como argumento e faz a

alteração. Não podemos acessar variáveis de instância diretamente.

Desta forma, os campos de dados estarão escondidos para nós, o que previne alterações acidentais. Dizemos então que os campos de dados e suas

funções estão encapsulados (de cápsula) numa única entidade.

As palavras encapsular e esconder são termos técnicos da definição de

linguagens orientadas ao objeto.

Se alguma modificação ocorrer em variáveis de instância de um certo

objeto, sabemos exatamente quais funções interagiram com elas: são as

funções-membro do objeto. Nenhuma outra função pode acessar esses dados. Isso

simplifica a escrita, manutenção e alteração de programas.

Um programa em C++ consiste em um conjunto de objetos que se

comunicam por meio de chamadas às funções-membro.

A frase "chamar uma função-membro de um objeto" pode ser dita como "enviar uma mensagem a um objeto".

HERANÇA

A programação orientada ao objeto oferece uma maneira de relacionar classes

umas com as outras por meio de hierarquias.

No nosso dia-a-dia, esse processo está presente quando dividimos classes em subclasses, mantendo-se o princípio de que cada subclasse herda as

(14)

Umn visão geral XXT

características da classe da qual foi derivada. Por exemplo: a classe de animais é dividida nas subclasses mamíferos, aves, peixes etc. Uma das características da classe animais é a reprodução. Todas as suas subclasses têm essa característica.

Além das características herdadas, cada subclasse tem suas caracterí

s-ticas particulares.

CLASSE BASE ~

características

A B

características características características

A A B A B

c

B _E F

c

D F _G

CLASSES DERIVADAS

Em programação orientada ao objeto, o conceito de subclasse ou processo de classes derivadas é chamado HERANÇA.

Em C++, a classe de origem é chamada classe-base e as classes que

compartilham as características de uma classe-base e têm outras características

adicionais são chamadas classes derivadas.

Uma classe-base representa os elementos comuns a um grupo de classes derivadas.

Você poderia pensar em herança como algo semelhante ao uso de funções para simplificar tarefas tradicionais. Você escreve uma função quando identifica que várias secções diferentes de um programa, em parte, executam a

•

mesma coisa.

Em C++, você define uma classe-base quando identifica características comuns em um grupo de classes derivadas.

(15)

XXJJ Treinamento em Linguagem C++

Da mesma forma que você pode criar uma biblioteca de funções úteis a diversos programas, pode formar uma biblioteca de classes que poderão vir a ser o núcleo de muitos programas.

O uso de uma biblioteca de classes oferece uma grande vantagem sobre o uso de uma biblioteca de funções: o programador pode criar classes derivadas de classes-base de biblioteca. Isto significa que, sem alterar a classe-base, é possível adicionar a ela características diferentes que a tornarão capaz de executar exatamente o que desejarmos.

Uma classe que é derivada de uma classe-base pode, por sua vez, ser a classe-base de outra classe.

O uso de classes derivadas aumenta a eficiência da programação pela não-necessidade da criação de códigos repetitivos. A uma função de biblioteca não podemos adicionar outras implementações a não ser que ela seja reescrita ou que tenhamos seu código-fonte para alterá-la e recompilá-la.

A facilidade com que classes existentes podem ser reutilizadas sem serem alteradas é um dos maiores benefícios oferecidos por linguagens orien-tadas ao objeto.

POLIMORFISMO E SOBRECARGA

O sentido da palavra polimorfismo é o do uso de um único nome para definir várias formas distintas.

Em C++, chamamos de polimorfismo a criação de uma família de funções que compartilham do mesmo nome, mas cada uma tem código inde-pendente.

O resultado da ação de cada uma das funções da família é o mesmo. A maneira de atingir esse resultado é distinta. Como exemplo, suponhamos que desejemos calcular o salário líquido de todos os funcionários de uma empresa.

Nessa empresa há horistas, mensalistas, os que ganham por comissão etc.

Criamos um conjunto de funções em que cada uma tem um método diferente de calcular o salário. Quando a função é chamada, C++ saberá

(16)

Uma visão geral XXlll

A sobrecarga é um tipo particular de polimorfismo. Como exemplo, tomemos o operador aritmético+. Em C++, usamos esse operador para somar números inteiros ou para somar números reais:

5 + 2

3.4 + 5.8

O computador executa operações completamente diferentes para somar números inteiros e números reais. A utilização de um mesmo símbolo para a

execução de operações distintas é chamada sobrecarga. Em C++, além das

sobrecargas embutidas na linguagem, podemos definir outras com capacidades

novas.

Por exemplo, podemos definir a seguinte operação nova para o símbolo +: "ABC" + "DEF" "ABCDEF "

O polimorfismo e a sobrecarga são habilidades únicas em linguagens orientadas ao objeto.

,

C

E UM SUBCONJUNTO DE

C+

+

C++ é uma linguagem derivada da linguagem C. O conjunto de instruções que

fazem parte da linguagem C também é parte de C++.

Os elementos principais que foram adicionados à linguagem C para dar origem a C++ consistem nas classes, nos objetos e na idéia de programação orientada ao objeto.

Se você já sabe programar em C, conhece a maior parte da sintaxe de C++ e tem pouco a aprender.

C++ é rica em recursos que atendem às limitações impostas pelas linguagens procedurais.

(17)

(18)

Capítulo 1

,

CONCEITOS BASICOS

,

A ESTRUTURA BASICA DE UM PROGRAMA EM

C+

+

A unidade fundamental de programas C++ são as funções. Um programa C++

consiste em uma ou várias funções.

~

FORMA GERAL DAS FUNÇOES

C+

+

Os elementos básicos de toda função C++ são os seguintes:

t ipo nome () { } i nstrução_ l i i nstrução_2 i • instrução_n i 1

(19)

2 Treinamento em Li11guagem C++ Cap. 1

O

PRIMEIRO PROGRAMA

Vamos começar com um programa muito simples: #include

void ma in () ( cout << 11 Prime ir o Programa 11 ; }

Você pode digitar este programa e gravá-lo em disco com o nome PrimP.CPP. O sufixo .CPP indica programa-fonte em C plus plus.

~

NOME DAS FUNÇOES

Este programa compõe-se de uma única função chamada main. O nome de uma função pode ser qualquer um, com exceção de main, reservado para a função que inicia a execução do programa.

Em todo programa C++, deve existir uma única função chamada main. A função main marca o ponto de partida do programa. Se um programa for

constituído de uma única função, esta será main. O programa termina quando

for encerrada a execução da função main.

O

TIPO void

A função main particular de nosso programa é do tipo void. O tipo void indica

que a função não tem valor de retorno, ou seja, não retoma nada. Os tipos de funções serão abordados em detalhes no capítulo de funções.

(20)

Cap. 1 Conceitos básicos 3

CHAVES

Toda função C++ deve começar com uma chave de abertura de bloco

I

e deve

terminar com uma chave de fechamento de bloco } . As chaves delimitam o corpo

da função.

ESPAÇOS EM BRANCO

Você pode inserir espaços em branco e tabulações e pular linhas à vontade em

seus programas. O compilador ignora esses caracteres. Você pode escrever várias instruções em uma única linha, separadas por qualquer número de

espaços ou tabulações, ou pode escrever uma instrução em várias linhas. Não

existe um estilo obrigatório para a escrita de programas C++.

O nosso primeiro programa poderia ser escrito da seguinte forma:

#include <iostream.h>

v o i d main() {

cout <<

"Primeiro Programa "

• '

}

A sintaxe anterior não é recomendada, pois esse estilo causa sérios

problemas de legibilidade.

Algumas exceções no uso de espaços, tabulações e linhas em branco devem ser consideradas: cadeias de caracteres constantes como "Primeiro Programa" não podem ser separadas em diversas linhas; nomes de funções, operadores e comandos da linguagem não podem ser separados. Diretivas do pré-processador como #include não podem ser escritas em diversas linhas.

(21)

4 Treinamento em Li11guagem C++ Cap. 1

H

INSTRUÇOES DE PROGRAMA

O nosso primeiro programa contém uma única instrução: cout << '' Primeiro Programa'' ;

Essa instrução imprime a frase entre aspas duplas na tela.

Toda instrução C++ termina em um ponto-e-vírgula(;). O ponto-e-vír-gula é parte crucial da sintaxe da linguagem e facilmente pode ser esquecido por programadores distraídos, o que acarretaria a apresentação de um erro de compilação.

Uma função pode ter qualquer número de instruções. As instruções devem ser escritas entre as chaves que delimitam o corpo da função e são executadas na ordem em que as escrevemos.

IMPRIMINDO USANDO

cout

cout (pronuncia-se "C out") é um objeto de uma classe de I/0 (leitura e impressão) predefinida em C++. A descrição completa do uso de cout requer um entendimento maior sobre classes, objetos e sobrecarga de operadores. Esses assuntos serão discutidos detalhadamente mais adiante.

Neste ponto, daremos apenas uma idéia breve do seu funcionamento. C++ fornece uma biblioteca de funções e classes conhecida como "streams". Elas contêm os elementos necessários para a execução de operações de leitura e impressão (I/0). O objeto cout está associado à saída padrão (geralmente o vídeo).

O operador<<, chamado "operador de inserção", conecta a mensagem a ser impressa à cout.

As definições e declarações necessárias para o uso de "streams" estão contidas no arquivo "iostream.h" instalado no diretório INCLUDE pelo seu compilador.

(22)

,

O

PRE-PROCESSADOR

C+

+

A primeira linha de nosso programa

#include

não é uma instrução C++ e sim uma diretiva do pré-processador C++.

O pré-processador C++ é um programa que examina o programa-fonte

em C++ e executa nele certas modificações com base em instruções chamadas

diretivas. Toda diretiva é iniciada pelo símbolo # e seu texto deve ser escrito

em uma única linha. Se o texto for muito grande, pode-se terminar a linha com

a barra invertida "\" e continuar em outra linha.

Diretivas do pré-processador não fazem parte da linguagem C++; elas

servem para auxiliar no desenvolvimento do programa-fonte.

A DIRETIVA #include

A diretiva #indude provoca a inclusão de outro arquivo em nosso

programa-fonte. Na verdade, o compilador substitui a diretiva #include de nosso

progra-ma pelo conteúdo do arquivo indicado antes de o programa ser compilado.

Usar a diretiva #indude é similar a usar o comando de um processador

de textos que inclui um texto gravado em disco no texto que estamos editando.

A primeira linha do nosso programa

#include

solicita que o compilador inclua o arquivo iostream.h em nosso programa antes

de compilá-lo.

Além do uso dos sinais de< e>, a diretiva #include aceita uma segunda sintaxe:

#inc lude "iostream . h ''

Quando usamos os sinais de< e>, o arquivo é procurado somente no

diretório INCLUDE. Quando usamos aspas duplas, o arquivo é procurado

(23)

6 Treinamento em Li11guagem C++ Cap. 1

,.,

ARQUIVOS DE INCLUSAO

Os arquivos de inclusão (também chamados arquivos de cabeçalho) são textos

escritos em caracteres ASCII normais. Em geral, eles contêm definições e

declarações necessárias para que o compilador reconheça vários identificadores da linguagem C++.

Você pode verificar o conteúdo desses arquivos utilizando o comando

type do DOS.

Geralmente, os arquivos de inclusão têm um nome terminado com o

sufixo ".H" (de header ou cabeçalho) e estão gravados no diretório INCLUDE.

O

ARQUIVO iostream.h

O arquivo iostream.h é um exemplo de arquivo de inclusão. Ele contém declarações necessárias ao uso do objeto cout e do operador de inserção <<.

Sem essas declarações/ o compilador não reconhece cout e <<.

O arquivo iostream.h inclui ainda um objeto para recuperar dados

digitados no teclado e também outras definições básicas de

I/0

(impressão e

leitura) necessárias a todos os programas que fizerem uso da saída padrão

(vídeo) e da entrada padrão (teclado).

EXECUTANDO

O

PRIMEIRO PROGRAMA

O nosso primeiro programa, quando executado, irá imprimir na tela: Primei ro Programa

Se você executar o nosso primeiro programa três vezes seguidas, obterá

a seguinte saída:

(24)

Note que o objeto cout não imprime numa nova linha automaticamente. A impressão é colocada na posição atual do cursor. Se desejar, você deve inserir um caractere de nova linha explicitamente.

O caractere de nova linha não pode ser inserido diretamente pelo teclado.

Por que não usar a tecla [ENTER]?

Porque, se você pressionar a tecla [ENTER] em alguma posição na frase que deve ser impressa, o processador de textos que edita o seu programa-fonte abandonará a linha atual e passará para uma nova linha, deixando a linha anterior inacabada, e o objeto cout não o tomará como parte da impressão.

,

CODIGOS ESPECIAIS

Além da tecla [ENTER], vários outros caracteres não podem ser digitados do

teclado para dentro do nosso programa. Esses caracteres que não podem ser obtidos diretamente do teclado são codificados em C++ por meio da combinação do sinal \ (barra invertida) com outros caracteres.

A tabela a seguir mostra esses códigos.

CÓDIGOS ESPECIAIS \n \t \b \f \a \r \\ \0 \' \" \xdd SIGNIFICADO Nova linha (CR+LF) Tab Retrocesso

Salta página de formulário Beep- Toca o alto-falante

CR - Cursor para o início da linha

\ - Barra invertida Null-Zero

' - Aspa simples " - Aspa dupla

(25)

8 Treinamento em Li11guagem C++ Cap. 1

IMPRIMINDO NUMA NOVA LINHA

Vamos alterar o nosso exemplo para que a frase seja impressa numa nova linha toda vez que o programa for executado. Para isso, é necessário inserir um código de nova linha no início da frase a ser impressa. Códigos especiais podem ser colocados em qualquer lugar dentro de uma cadeia de caracteres.

#include <iostream .h>

ma in (}

{

cout << "\ nPrime i r o pr ograma";

}

,

CONSTANTES NUMERICAS

Uma constante tem valor fixo e inalterável. Números constantes em C++ podem ser escritos nas seguintes bases numéricas:

DECIMAL Escrevemos um número em decimal de forma pura e

simples, como a que estamos acostumados. Exemplos: 2345, 501 88.

Observe que números em decimal não podem estar entre aspas.

HEXADECIMAL Os números escritos na base 16 devem ser precedidos de Ox. Exemplo: Ox41, Oxlafb1 Ox54c2.

OCTAL Os números escritos na base 8 devem ser precedidos de um zero na frente.

(26)

CARACTERE

Observação:

Cap. 1 Conceitos básicos 9

A numeração caractere só está definida para números entre O e 255. Isto significa que a forma caractere é definida para números que caibam em um único byte. Caracteres constantes são escritos entre aspas simples.

Exemplo: O número decimal 65 pode ser escrito como' A'. Outros exemplos: '5', 'a', 'w', '\n', '\t'.

Note que um zero na frente de um número é avaliado como representação octal. Ou seja, escrever 10 não é a mesma coisa

que escrever 010. O número 010 é o número 8 em decimal.

CADEIA DE CARACTERES CONSTANTE

A expressão "Primeiro programa" é um exemplo de cadeia de caracteres

constante. A linguagem C++ reconhece uma cadeia de caracteres constante

quando delimitada por aspas duplas, como mostrado na expressão anterior.

ASPAS SIMPLES OU ASPAS DUPLAS

Algumas linguagens de programação permitem o uso de aspas simples ou

duplas indistintamente. Em C++, as aspas simples servem para representar um único caractere ASCII com um valor numérico entre O e 255 e as aspas duplas, para representar cadeias de caracteres.

IMPRIMINDO OUTROS TIPOS DE DADOS

O próximo exemplo mostra como imprimir diferentes tipos de dados utilizando

(27)

10 Treinamento em Linguagem C++ Cap. 1

#include <iost ream.h>

void ma in ()

{

cout << ''Venus esta a '' << 67 << "milhoes de milhas'' << 1 \n 1 << ''do sol'';

}

Note que utilizamos o operador << repetidamente na instrução. Este uso é perfeitamente correto. O programa envia primeiramente a cadeia "Venus esta a " para cout, então envia o número 67, e em seguida a cadeia "milhoes de milhas", o caractere de nova linha '\n' e finalmente a cadeia "do sol".

Vamos agora escrever um programa com mais de uma instrução: #include <iostream.h>

void ma in ()

{

cout << ''A letra '' << 1

j 1

;

cout << '' pronuncia-se '' << '' jota" <<

}

I I ,

.

'

Observe que 'j' é delimitado por aspas simples, enquanto "jota" é delimitado por aspas duplas. Isto indica ao compilador como diferenciar um caractere de uma cadeia de caracteres.

Note também que a saída é escrita em duas linhas de programa, o que não constitui duas linhas impressas de texto. Se você desejar imprimir um caractere de nova linha, deve inseri-lo explicitamente.

,

V

AR lAVEIS

As variáveis são o aspecto fundamental de qualquer linguagem de computador. Uma variável em C++ é um espaço de memória reservado para arma-zenar um certo tipo de dado e tendo um nome para referenciar o seu conteúdo.

(28)

O espaço de memória ocupado por uma variável pode ser compartilhado por diferentes valores segundo certas circunstâncias. Em outras palavras, uma variável é um espaço de memória que pode conter, a cada tempo, valores diferentes.

Para explicar o uso de variáveis, vamos escrever um programa que cria duas variáveis:

#inc l ude <iostream.h>

void ma in ()

{

)

int numl;

num1=44;

cout << '' \nO prime iro nómero é '' << numl ;

int num2;

num2 =88;

cout << "\nO segundo nómero é " << num2 ;

Se você executar este programa, obterá a seguinte saída:

O pri meiro número é 44 O segundo númer o é 88

Este programa cria primeiramente a variável numl, imprime o valor atribuído a ela como parte de uma frase, para depois criar a variável num2, atribuir 88 a ela e imprimir seu conteúdo.

DECLARAÇÕES DE VARIÁVEIS

As instruções

int numl;

(29)

são exemplos de declaração de variáveis, isto é, apresentam um tipo int e um

nome para acessar seu conteúdo.

Uma declaração de variável é uma instrução para reservar uma

quan-tidade de memória apropriada a fim de armazenar o tipo especificado, nesse

caso int, e indicar que seu conteúdo será referenciado pelo nome dado a ela.

Uma declaração de variável consiste no nome de um tipo, seguido do nome da variável, seguido de ponto-e-vírgula.

Em C++, todas as variáveis devem ser declaradas. As variáveis devem

ser declaradas antes de serem usadas no programa. Uma variável pode ser

declarada em qualquer lugar do programa.

C++ não funciona se você não declarar suas variáveis. As variáveis podem ser declaradas em qualquer lugar do programa.

Se você tiver mais de uma variável do mesmo tipo, poderá declará-las

de uma única vez, separando seus nomes por vírgulas. int aviao, foguete , helicoptero;

,

TIPOS DE VARIAVEIS

O tipo de uma variável informa a quantidade de memória, em bytes, que a

variável ocupará e a forma como um valor deverá ser armazenado e interpretado.

Tipo de variável diz respeito ao tamanho de memória e à forma de armazenamento.

Em C++, existem cinco tipos básicos de variáveis. Nos computadores de ambiente MS-DOS, a tabela seguinte é válida:

(30)

TIPO c h ar int float double void BIT 8 16 32 64

o

BYTES 1 2 4 8

o

Cap. 1 Conceítos básicos 13

ESCALA -128 a 127 -32768 a 32767 3.4E-38 a 3.4E+38 1.7E-308 a 1.7E+308 nenhum valor

Com exceção de void, os tipos de dados básicos podem ser acompa-nhados por modificadores na declaração de variáveis. Os modificadores de tipo oferecidos por C++ são:

l ong

short

uns i gned

Um modificador de tipo pode ser utilizado sem que seja especificado o tipo da variável. Quando isso é feito, o compilador assume, por default, que o tipo é int.

Os modificadores podem ser utilizados com os tipos e as escalas descritos pela tabela a seguir:

TIPO BIT BYTES ESCALA

unsigned char 8 1 O a 255

unsigned 16 2 O a 65535

short 16 2 -32768 a 32767

long 32 4 -2147483648 a 2147483647

unsigned long 32 4 O a 4294967295

long double 80 10 3.4E-4932 a 1.1E+4932

O tipo int tem sempre o tamanho da palavra da máquina, isto é, em computadores de 16 bits ele terá 16 bits de tamanho.

O tipo short tem tamanho diferente do tipo int em outros computado-res, geralmente a metade do tamanho de um int. Em MS-DOS, o tipo short é

(31)

,

INICIALIZANDO VARIAVEIS

'

E possível combinar uma declaração de variável com o operador de atribuição

para que a variável tenha um valor inicial ao mesmo tempo de sua declaração; é o que chamaremos de inicialização de variável. Como exemplo, escreveremos

um programa que cria três variáveis e as inicializa. #include <iostream.h>

ma in (} { } int evento - 5; char corrida - 'C'; f l oat tempo - 27. 25 ;

cout << "\nO tempo vitorioso na eliminatoria "

<< corrida << "\nda competição " << evento << " foi " << tempo << I I •

• 1

A saída será:

O tempo vitorioso na eliminatoria C

da competição 5 foi 27 . 25 .

Este programa utiliza os três tipos de variáveis mais comuns: int, char e float.

Inicializar uma variável significa atribuir um valor a ela na mesma

instrução de sua declaração.

VARIÁVEIS PONTO FLUTUANTE (lloat)

Números em ponto flutuante correspondem ao que os matemáticos chamam de

(32)

Existem várias maneiras de escrever números em ponto flutuante. A notação "3.16E7" é um meio de indicar que 3.16 será multiplicado por 10 elevado à potência 7, isto é, 31600000. Esta indicação chama-se notação científica e é usada para armazenar números em ponto flutuante na memória do computador. Assim, valores armazenados em variáveis float são guardados na memória em duas partes. Estas duas partes são chamadas de mantissa e expoente. A mantissa é o valor do número e o expoente é a potência que irá aumentá-lo.

Por exemplo, 12345 é representado por 0.12345E5, onde o número que segue o (E) é o expoente, e 0.12345 é o valor do número.

Variáveis do tipo float são guardadas em 4 bytes: um para o expoente e 3 para a mantissa.

3 bytes 1 byte

+ 0.12345 ₅

sinal fração expoente

Observe que uma variável do tipo long int ocupa o mesmo espaço que uma variável do tipo float, mas são tipos diferentes, já que a forma de armazenamento é distinta. Lembre-se: um tipo de variável define um tamanho

(33)

O

MODIFICADOR unsigned: INTEIROS COM E SEM SINAL

O computador interpreta o bit mais significativo de uma variável como bit de

sinal. O modificador unsigned indica que o tipo associado deve ter seu bit

superior interpretado como outro bit qualquer e não como bit de sinal.

O modificador unsigned é utilizado quando a quantidade representada

é sempre positiva, como, por exemplo, quando indicamos uma quantidade de

alguma coisa (copos, lápis, laranjas etc.). Observe o programa a seguir:

#inc l ude <iost ream. h>

ma i n {}

{

unsigned j=65000 i

cout << "\ nVar unsigned - n << ] i .

int i = ]. i cout << "\nVar i nt - 11 << ~i . } A saída será: Var unsigned - 65 000 Var int - - 536

A razão disto está na maneira pela qual o computador interpreta o bit

15 de uma variável int. Na forma binária, o bit 15 de uma variável do tipo int

positiva é sempre O, e o de uma negativa é sempre 1.

O computador ignora o bit de sinal de uma variável unsigned, tratan-do-o como um bit a mais para números positivos.

Os números negativos são conhecidos como complementos de dois dos números positivos, pois a conversão de um número positivo para o seu negativo

(34)

é feita por um processo de duas etapas. No momento, você não precisa entender

como é feita essa conversão. No segundo volume deste livro, voltaremos a este

assunto.

Essa explicação vale também para o bit de ordem superior de outros tipos de variáveis. Por exemplo, o tipo unsigned char tem um tamanho de um byte e pode armazenar números entre O e 255, enquanto o tipo char armazena números entre -128 a 127.

,

NOMES DE VARIAVEIS

A escolha de nomes significativos para suas variáveis pode ajudá-lo a entender

o que o programa faz e a prevenir erros.

Você pode usar quantos caracteres quiser para um nome de variável,

com o primeiro sendo obrigatoriamente uma letra ou o caractere de sublinhado.

O nome de uma variável pode conter letras maiúsculas ou minúsculas, dígitos de O a 9 e o caractere de sublinhado.

Em C++, letras maiúsculas e minúsculas são diferentes.

Os seguintes nomes são distintos: PESO

Peso

peso peSo

Em C++, somente os 32 primeiros caracteres são significativos, isto é:

Orcamento_de_Contabilidade_de_1992 Orcamento_de_Conta bil idade_de_ 1993

são considerados o mesmo nome.

Uma variável não pode ter o mesmo nome de uma palavra-chave de C++. A tabela a seguir mostra as palavras-chave.

(35)

PALAVRAS-CHAVE DE

C++

asm

_-

f ar public

auto f ar register

break float return

case for _saveregs

catch friend _seg

cdecl

- goto short

cdecl huge signed

char if sizeof

class inline _ss

const int static

continue interrupt struct

cs

- - loadds switch

default long template

do _- near this

double near typedef

_ds new umon .

else operator unsigned

enum _pascal virtual

es

- pascal void

_export priva te volatile

(36)

..

MANIPULADORES DE TAMANHO DE CAMPOS NA IMPRESSAO

O objeto cout permite estabelecer o tamanho de um campo para a impressão. Isto significa que podemos definir o número de colunas que serão ocupadas por um valor ou texto a ser impresso. Geralmente, a definição de tamanho de

campos é usada para alinhamento e estética de um relatório.

Os manipuladores de tamanho de campos estão definidos no arquivo

"iomanip.h" e são os seguintes:

setw Seleciona o tamanho do próximo campo a ser impresso.

setprecision Define o número de casas decimais a serem impressas para

números em ponto flutuante (float).

setfill Seleciona o caractere que deverá preencher as colunas em

branco de um campo.

,

TAMANHO DE CAMPOS

COM

NUMEROS INTEIROS

A seguir, mostraremos um programa que não utiliza tamanho de campos e o

mesmo programa com definições de tamanho de campos. Compare a apresen-tação da saída dos dois programas.

#include <iostream .h> voi d ma in ()

{

i nt l ap=45 , bor=2345,can=42 0,cad=8, fit=1 3050; cout << "\ n \ n\n";

cout << ' \n ' << "Lapis "<< lap;

cout << ' \ n I << "Borracha "<< bor; cout << I \ n I << "Canetas "<< can ;

cout << 1\ n l _{<< "Cader}_no_s _"<< _cad;

c out << I \n ' << "Fi tas "<< f it;

(37)

20 Treinamento em Linguagem C++ Cap. 1 Eis a saída: Lap is 45 Borracha 2345 Canetas 420 Cader nos 8 Fi t as 13 050 #include <iostream. h>

#include void ma in () { int lap=4 5 1 bor=234 5 1 can=420~cad=8 ~ fi t= 13050 ; cout << "\n\n\ n "; cout << 1\ n l _<< _"_L_ap_i _s _"_<< _setw ₍₁₂ ₎ _<< _lap_; cout << 1\n l _<< _"Borra_ch_{a "<< s}_e_t _w₍₁₂₎ _{<< bo}_r; cout << I \n I << "Canetas "<< set w(12) << can ;

cout << 1\n l << "Cadernos H<< _setw ₍₁₂₎ _{<< cad}_;

cout << I \n I << "Fitas ₁₁<< se tw(12) << fit ; } Eis a saída: Lapi s 45 Borracha 2345 Canetas 420 Cadernos 8 Fitas 13050

O próximo exemplo preenche as colunas em branco com o caractere'.'.

#include #include <iomani p .h> void ma i n () { int lap=45 , bor=234 5 , can=42 0 ~ cad=8 ~ fit=13050 ; cout << '' \n\n\n'' ;

(38)

cout << set f i ll ( 1 . 1 ) ;

c out << I \n I << "Lapis ti<< se tw(12) << lap;

cout << 1\n l << "Borracha 11 << _{setw(12) << bor}_;

cout << I \n I << "Canetas "<< setw(12) << can;

cout << I \n I << "Cader nos "<< s e tw (12) << cad;

cout << I \n I << "Fitas _1t<< setw(12) << fit;

) Eis a saída: Lapi s ... .. . . 45 Borracha . . . 2345 Canetas . . . 420 Cadernos . . . 8 Fitas . . . 13050

TAMANHO DE CAMPOS COM PONTOS FLUTUANTES

Além do tamanho em colunas a ser ocupado por um número ponto flutuante, pode-se definir o número de casas decimais a serem impressas para obter precisão e arredondamento. Veja um exemplo:

#incl ude <ios t ream.h> #inc l ude <iomanip .h>

void ma in ()

{

float lap=4 . 875 ~ bor=234 . 54 2 1 can=42 . 036 ~ cad=8 .01 fit=13 .05 ;

c out << "\n\n\n";

cout << se tprecision( 2) ;

c out << I \n I << "Lapis "<< s e tw (12) << l ap;

cout << I \n I << "Borracha 11 << se tw( 12 ) << bor;

cout << I \n I << "Canetas "<< setw(12) << can;

cout << I \n I << "Cadernos ₁₁<< setw (12) << cad;

cout << I \n I << "Fitas _lt<< setw (12) << fi t;

(39)

22 Treinamento em Linguagem C++ Cap. 1 Eis a saída: Lapis 4 . 88 Borracha 234 . 54 Canetas 42 . 04 Cadernos 8 . 00 Fitas 13 . 05

TAMANHO DE CAMPOS COM CADEIAS DE CARACTERES

O manipulador setw justifica campos numéricos e cadeias de caracteres à direita no campo de impressão definido.

#include <iostream .h>

#include <iomanip .h>

void ma in ()

{

c out << '' \n\n\n '';

cout << "OBJETO ''<< setw{ 12) << "CODIGO'' << 1

\n1 ;

cout << I \n I << "Lapis "<< setw(12) << "WQR " ;

cout << I \n I << "Borracha "<< setw(12) << "ASO" ; cout << I \n I << "Canetas "<< set w{12) << "KPX";

cout << I \n I << "Cadernos "<< setw(12) << "FJ I";

cout << I \n I << "Fitas "<< setw{12) << "TYE" ; } Eis a saída: OBJETO CO DIGO Lapis WQR Borracha ASO Canetas KPX Cadernos FJI Fitas TYE

Observação: Se o tamanho do campo especificado em setw for menor que o tamanho mínimo necessário para impriinir o valor associado, a impressão utilizará o número necessário de colunas, ignorando o tamanho do campo.

(40)

,

MANIPULADORES DE BASES NUMERICAS

O objeto cout permite-nos estabelecer a base numérica na qual desejamos ver

.

'

1mpresso um numero.

Os manipuladores de bases numéricas estão definidos no arquivo

"iostream.h" e são os seguintes:

dec A impressão do próximo campo é apresentada em decimal (modo default).

hex A impressão do próximo campo é apresentada em hexadecimal. oct A impressão do próximo campo é apresentada em octal.

#include <iostream .h> void ma in ()

{

int n =65 ;

cout << ' \n ' << ''Hexadecimal '' << hex << n ;

cout << , \n , << "Oc tal

cout << ' \n ' << "Decimal } Eis a saída: Hexadecimal 41 Octal 101 Decimal 65

,

" << oct << n ; " << dec << n ;

IMPRIMINDO CARACTERES GRAFICOS

Como você provavelmente sabe, todo caractere (letra, dígito, caractere de pontua-ção etc.) é representado no computador por um número. O código ASCII dispõe de números de O a 127 (decimal) abrangendo letras, dígitos de O a 9, caracteres de pontuação e caracteres de controle como salto de linha, tabulação etc.

(41)

Os computadores IBM-PC usam 128 caracteres adicionais, com códigos

de 128 a 255, que consistem em símbolos de línguas estrangeiras e caracteres

gráficos.

Já

mostramos como imprimir caracteres ASCII usando o objeto cout.

Os caracteres gráficos e outros não-padrões requerem outra maneira de escrita

para serem impressos. A forma de representar um caractere de código acima

de 127 é:

\ xdd

onde dd representa o código do caractere na base hexadecimal. Observe que

\xdd é um caractere e pode ser contido por uma cadeia de caracteres entre aspas

duplas.

Neste livro, usaremos esse formato para impressão de qualquer carac

-tere gráfico.

O programa a seguir imprime um carro e uma caminhonete. Observe

a listagem:

#include

ma in {}

{

)

cout << "\n\n";

cout << "\n \xDC\xDC\xDB\xDB\xDB\xDB\xDC\xDC" ;

cout << "\n \xDFO\ xDF\xDF\xDF \ xDFO\xDF '';

cout << • \n \n" ;

cout << '' \n \xDC\ xDC\xDB \xDB\xDB\xDB\xDB\xDB\xDB '';

cout << '' \n \xDFO\xDF\xDF\xDF\xDF\xDFOO\xDF '';

(42)

A saída será:

Carro

Cami nhão

O próximo exemplo desenha uma moldura na tela:

#include

rnain (} { } cout << H\n\n"; c out << '' \n\xC9\xCD\xBB''; cout << "\n\xBA \ xBA ''; cout << '' \n\xCB\xCD\xBC'' ; cout << H \n\n H ; A saída será:

(43)

Os códigos dos caracteres são os seguintes:

C9 CD BB

fF

-C8 CD BC ""

REVISA

O

1. Todo programa em C++ deve ter uma função chamada main(), que é a

primeira função a ser executada. O programa termina sua execução quando

é encontrada a chave que fecha o corpo da função main().

2. O pré-processador é uma linguagem para o compilador C++. Suas

instru-ções são chamadas diretivas.

3. A diretiva #include causa a inclusão de outro arquivo em nosso

programa-fonte.

4. Arquivos de inclusão são textos escritos em caracteres ASCII normais.

S. O arquivo iostream.h contém as definições básicas de impressão em vídeo

(44)

6. O identificador cout é um objeto predefinido em C++ e corresponde à saída padrão (vídeo).

7. O operador<< conecta a frase que queremos imprimir à cout.

8. Os caracteres que não podem ser obtidos diretamente do teclado para dentro do programa são codificados em C++ por meio da combinação do sinal \ (barra invertida) com outros caracteres, conforme a tabela de códigos

.

especiaiS.

9. Números em C++ podem ser escritos em C++ em decimal, hexadecimal, octal ou formato caractere.

10. Uma declaração de variável consiste no nome de um tipo, seguido do nome da variável seguido de ponto-e-vírgula.

11. Todas as variáveis devem ser declaradas antes de ser usadas. C++ não funciona se você não declarar suas variáveis.

12. As variáveis podem ser declaradas em qualquer lugar do programa.

13. O tipo de uma variável define seu tamanho de memória em bytes e a forma como um valor deve ser armazenado e recuperado.

14. Os cinco tipos básicos de variáveis em C++ são: char, int, float, double e void.

15. Os modificadores de tipo são utilizados para alterar o tamanho de um tipo de variável ou para alterar a interpretação do seu bit mais significativo.

16. Os três modificadores de tipo em C++ são: long, short e unsigned.

17. Nomes de variáveis devem começar com uma letra ou o caractere de sublinhado. O nome de uma variável pode conter letras maiúsculas ou minúsculas, dígitos de O a 9 e o caractere de sublinhado.

18. Em C++, somente os 32 primeiros caracteres de um nome de variável são significativos.

(45)

,

EXERCICIOS

1. Um dos alunos preparou o seguinte programa e apresentou-o para ser avaliado. Ajude-o.

#inc l ude <iostrea m.h>

void lYia i n ()

{

cout << Existem 56 semanas no ano; }

2. Qual será a impressão obtida por cada uma das seguintes instruções?

Assuma que elas fazem parte de um programa completo.

a) cout << "\n\tBom Dia ! Shirley."; b) cout << "Você já tomou café ?\n";

c) cout << "\n\nA solução não existe ! \nNão i nsista";

d) cout << "Duas\tli nhas\tde\tsaída\nou\tuma?";

e) cout << "um" << 1

\n 1

<< "dois" << 1

\n 1

<< "tres";

3. Qual é a saída do seguinte programa?

#inc l ude <iost r ea m.h> void ma in ()

{

cout << '' \n\t\ '' Primeiro programa\ '' '';

}

4. Qual é a saída do programa a seguir?

#include <iostream.h> voi d ma in () { } cout << ' \n ' << ' \t ' << '\''' << "Prime i r o progr ama"; cou t << ' \ " ' ;

(46)

5. Identifique o tipo das seguintes constantes: a) '\r' b) 2130 c) -123 d) 33.28 e) Ox42 f) 0101 g) 2.0e30 h) '\xdc' i) '\"' j) '\ \' k) 'F' 1)

o

m) '\0' n)

"F"

o) -4567.89

6. O que é uma variável em C++?

7. Um tipo de variável em C++ define:

a) uma variável armazenada em hexadecimal;

b) o tamanho de memória que a variável ocupará; c) uma variável em binário;

d) a base a ser usada para armazenar uma variável;

(47)

8. Em que partes do programa é possível declarar variáveis em C++?

9. Quais dos seguintes nomes são válidos para variáveis em C++?

a) 3ab b) _sim c) n

_{- -}

a o d) _OOFIM e) _int f) _A123 g) x**x h)- -A i) _y_-2 j) OOFIM

k)

\meu 1) *y2

10. Quais das seguintes instruções são corretas?

a) int a; b) float b; c) double float c; d) unsigned char d; e) unsigned e; f) long float f; g) long g;

(48)

12. Verdadeiro ou Falso: tipos de variáveis long podem conceber números não

maiores que o dobro da maior variável do tipo int.

13. Qual o trecho de programa que inicializa a variável x?

a) int Xi x=5i

b) int x=5 i c) int x,y=5i

d) X=Y i

14. Arquivos de inclusão são:

a) bibliotecas; b) compiladores;

c) arquivos em ASCII;

d) linkeditores.

15. Arquivos de inclusão servem para:

a) auxiliar o compilador a compilar;

b) auxiliar o programador a elaborar o fonte;

c) executar instruções;

d) incluir programas.

16. A diretiva #include é:

a) uma instrução C++;

b) uma instrução de linguagens orientadas ao objeto;

c) uma instrução do pré-processador;

d) um objeto.

17. Diretivas do pré-processador são executadas pelo:

a) compilador;

(49)

32 Treinamento em Linguagem C++ Cap. 1

c) linkeditor; d) programa.

18. Códigos especiais servem para:

a) codificar senhas;

b) nomear arquivos escondidos;

c) substituir caracteres que não podem ser digitados no teclado;

d) desenvolver programas codificados.

19. Qual é a diferença no uso de aspas simples e aspas duplas em C++?

20. Quais instruções são corretas?

a) _cout

<< "Primeiro Programa " i

b) _cout _<

< "Prime iro Programa" i

c) _cout _<< _"_Primeiro Programa " i d) _cout << "Primeiro Programa" • I

21. Reescreva o programa que desenha uma moldura na tela para que ele desenhe uma moldura similar, mas com quatro caracteres de largura e quatro caracteres de altura. Use o caractere 11, de código BA hexa, para complementar a moldura.

(50)

22. Escreva um programa que contenha uma única instrução e imprima na tela:

um

dois

tres

23. Escreva um programa que imprima na tela:

Programação orientada ao objeto .

Linguagem C plus plus .

a) com uma única instrução; b) com três instruções;