apstila c++ rev

Prévia do material em texto

3 
SUMÁRIO 
 
Unidade I 
 
1.0 Itens fundamentais......................................................................pg-
8 
1.1 Dados Numéricos.........................................................................pg-
8 
1.2 Dado literal...................................................................................pg-
8 
2.0 Variável.........................................................................................pg-
8 
2.1 Formação de 
Identificadores........................................................pg-9 
2.2 Declaração de 
variáveis.................................................................pg-9 
2.3 Modificadores de tipos oferecidos por 
c++...................................pg-9 
3.0 
Operadores.....................................................................................pg-10 
3.1 Operadores de 
atribuição...............................................................pg-10 
3.2 Operadores 
aritméticos...................................................................pg-10 
4.0 Funções de entrada e 
saída..............................................................pg-11 
 
 4 
4.1 
Entrada.............................................................................................pg-11 
4.2 
Saída..................................................................................................pg-11 
5.0 Manipuladores de tamanho de campos na 
impressão.....................pg-12 
6.0 Funções 
aritméticas..........................................................................pg-14 
7.0 Operadores 
relacionais.....................................................................pg-14 
8.0 manipuladores de bases 
numéricas..................................................pg-17 
9.0 Imprimindo caracteres 
gráficos.......................................................pg-17 
10.0 Códigos 
Especiais............................................................................pg-18 
11.0Comentários.....................................................................................
pg-18 12 Estruturas 
condicionais.....................................................................pg-19 
13.0 Estruturas de 
repetições.................................................................pg-22 
13.1 Estrutura 
For..................................................................................pg-22 
13.2 Estrutura 
While..............................................................................pg-23 
 
 5 
 13.3 Estrutura Do-
While.......................................................................pg-25 
14.0 
Commandos:......................................................................................pg-28 
14.1 
Break..............................................................................................pg-28 
14.2 
Continue..........................................................................................pg-29 
14.3 
Switch..............................................................................................pg-29 
 
Unidade II 
 
1.0 
Matrizes...........................................................................................pg-31 
1.1 Matriz 
Unidimensional....................................................................pg-31 
1.2 Matriz 
Multidimensional.................................................................pg-33 
 
Unidade III 
 
1.0 
Funções.............................................................................................pg-34 
 
 
 6 
1.1Chamando um 
função........................................................................pg-35 
1.2 Funções 
simples................................................................................pg-35 
1.3 Protótipo de 
funções..........................................................................pg-35 
1.4 Tipos de 
funções................................................................................pg-36 
1.5 O comando 
Return............................................................................pg-36 
1.6 Definição da 
função...........................................................................pg-36 
1.7 Parâmetros da 
função.......................................................................pg-36 
1.8 Passagem por 
valor...........................................................................pg-37 
1.9 Passagem vários 
argumentos............................................................pg-38 
1.10 O operador unário de 
referência:&...............................................pg-39 
1.11 Passagem por 
referência.................................................................pg-40 
1.12 Referência 
constantes.....................................................................pg-41 
1.13 Classes de 
argumentos....................................................................pg-41 
 
 7 
1.14 O operador de 
escopo.....................................................................pg-42 
1.15 Funções 
recursivas.........................................................................pg-43 
 
Unidade IV 
 
 
1.0 
Estruturas.......................................................................................pg-45 
1.1 Definindo a 
estrutura......................................................................pg-45 
1.2 Acessando os membros da 
estrutura...............................................pg-46 
1.3 Combinando 
declarações..................................................................pg-46 
1.4 Inicializando 
estruturas....................................................................pg-46 
1.5 Operações entre 
estruturas..............................................................pg-46 
1.6 Estruturas 
aninhadas........................................................................pg-47 
1.7 Passando estruturas para 
funções....................................................pg-47 
1.8 Matrizes de 
estruturas......................................................................pg-48 
 
 8 
1.8.1declarando a matriz de 
estruturas..................................................pg-49 
1.9.0 
Arquivos.........................................................................................pg-53 
1.9.1 Classes 
iostream.............................................................................pg-53 
1.9.2 Detectando o fim de 
arquivo..........................................................pg-54 
1.9.3- Lendo e gravando um caracter por vez no arquivo. 
 
1.9.4 A função 
Open().............................................................................pg-55 
1.9.5 Gravando 
Objetos..........................................................................pg-55 
1.9.6 Lendo 
Objetos................................................................................pg-57 
1.9.7 Gravando e lendo objetos de um mesmo 
arquivo.........................pg-57 
1.9.8 As funções seekg(), tellg(0, seekp() e 
tellp()...................................pg-59 
1.9.9 Calculando o número de registros do 
arquivo..............................pg-59 
1.10 Exemplos adicionais de 
arquivos...................................................pg-62 
Unidade V 
 
 
 9 
1.0 
Ponteiros............................................................................................pg-69 
1.1 Por que os ponteiros são 
usados.......................................................pg-69 
1.2 Ponteiros 
variáveis............................................................................pg-70 
1.3 Endereços de 
memória......................................................................pg-701.4 Operador de 
endereços.....................................................................pg-70 
1.5 Passando argumentos por referência com 
ponteiros.......................pg-71 
1.6 variáveis que armazena 
endereços...................................................pg-72 
1.7 O operador 
indireto..........................................................................pg-72 
1.8 Passando endereços para a 
função...................................................pg-72 
1.9 Ponteiros sem 
funções.......................................................................pg-72 
1.10 Ponteiros e variáveis 
apontadas.....................................................pg-73 
1.11 
atribuição.........................................................................................pg-73 
1.12 Operação 
indireta...........................................................................pg-73 
 
 10 
1.13 Trazendo o endereço do 
ponteiro...................................................pg-74 
1.14 Incremento em 
ponteiro..................................................................pg-74 
1.15 Ponteiro no lugar de 
matrizes.........................................................pg-74 
1.16 Ponteiros constantes e ponteiros 
variáveis.....................................pg-74 
1.17 Passando matrizes como argumento para 
funções........................pg-75 
1.18 
Precedência.....................................................................................pg-76 
1.19 Ponteiros e 
strings...........................................................................pg-76 
1.20 Matrizes de 
ponteiros......................................................................pg-77 
1.21 Área de alocação dinâmica: 
Heap.................................................pg-77 
1.22 Retornado o ponteiro 
This..............................................................pg-79 
1.23 dimensionando matrizes em tempo de 
execução...........................pg-79 
 
 11 
 
 
LINGUAGEM C++ 
 
UNIDADE - I 
 
1.0 - Itens Fundamentais 
 
 1.1 - Dados Numéricos 
 
 É representado pelo sistema decimal inglês. 
 Obs.: A separação da parte inteira da fracionária é feita pelo ponto decimal. 
 
 Ex.: 0.19 
 0.298 
 
 I . FF E n 
 
 expoente 
 potência de dez 
 parte fracionária 
 ponto decimal 
 parte inteira 
 
Ex.: a) 2.98E3 = 2,98 X 103 
 b) 0.45E-4 = 0,45 X 10-4 
 
 1.2 - Dado Literal 
 
 
 12 
 É formado por qualquer seqüência de caracteres e vem entre aspas duplas. 
 
 Ex. a) " 2040" 
 b) " " 
 c) " Não Fume" 
 
2.0 - Variável 
 
 É o endereço de memória (RAM) reservado para armazenar certo tipo de 
dado. 
 Obs.: RAM - Memória dinâmica de acesso aleatório a leitura e escrita e é 
volátil. 
 
 13 
 
 Ex.: 
 
d 1
0 
n
ota 
1
00 
s
exo 
f 
 
 2.1 - Formação de identificadores é formada por apenas uma letra ou então 
uma letra seguido de letras e dígitos nunca símbolos especiais. 
 Obs.: A letra maiúscula é diferente de letra minúscula. 
 
 Ex.: 1) funcao 3) media 
 2) d 4) m200 
 
 Cuidado - MEDIA  media 
 
 2.2 - Declaração de variáveis 
 
 Tipo da variável <nome-do-identificador>; 
 
 O ponto-e-vírgula manda o computador executar a próxima instrução. 
 Nome-do-identificador são os nomes das variáveis separadas por vírgula. 
 
 Tipo da variável pode ser do tipo int, float, double, char, etc. 
 
 Ex.: int x,y; 
 
 14 
 float med; 
 
 Tabela de tipos 
Tipo Bytes Escala 
int 2 -32768 a 32767 
char 1 -128 a 127 
float 4 3.4E-38 a 3.4E38 
double 8 1.7E-308 a 
1.7E308 
void 0 Nenhum valor 
 
 2.3 - Modificadores de tipos oferecidos por C++ são: 
 
 1 - long 
 2 - short 
 3 - unsigned 
 
 Obs.: O modificador de tipo pode ser utilizado sem que seja especificado o 
tipo da variável, por default assume o tipo INT. 
 
 A tabela de tipo utilizando os modificadores. 
Tipo Bytes Escala 
unsigned char 1 0 a 255 
unsigned 2 0 a 65535 
short 2 -32768 a 32767 
long 4 -2147483648 a 
2147483647 
unsigned long 4 0 a 42949667295 
long double 10 3.4E-4932 a 
1.1E+4932 
 
 15 
 
 
 
 Obs.: 
 int tem sempre o tamanho da palavra da máquina, isto é, em computadores de 
16 bits ele terá 16 bits de tamanho. 
 Short tem tamanho diferente do tipo int, geralmente à metade do tamanho de 
um int. 
 
 STRINGS são declaradas da seguinte maneira 
 
 char nome[n]; 
 Onde: n é o numero de caracteres da string. 
 
 Ex.: 
 int id,nm; 
 float alt,peso; 
 char nome[25]; 
 char sexo; 
 
3.0 - Operadores 
 
 3.1 - Operador de atribuição: = 
 Representa a atribuição da expressão a sua direita a variável a sua 
esquerda. 
 
 Ex.: 1) x = 200; 
 2) y = 5; 
 
 3.2 - Operadores aritméticos 
 
 16 
 
 + soma 
 - subtração 
 * multiplicação 
 / divisão 
 % resto da divisão de 2 números inteiros 
 
 Prioridade 
 
Prioridade operadores 
1ª. *, /, % 
2ª. +, - 
 
Ex: 1. x+y; 
 2. x-y; 
 3. 2*nota + 10; 
 4. tot/k - 40; 
 5. y=9 % 4; 
 
4.0 - Funções de entrada e saída 
 
 Funções: 
 i) cin >> nome-da-variável >> nome-da variável >> . . . 
 
 Transfere os dados externos via teclado para as variáveis especificadas. 
 
 Obs.: >> significa OPERADOR DE EXTRAÇÃO 
 Ex.: cin >> anos; 
 Cuidado os dados são separados de uma variável para outra através do espaço 
em branco. 
 
 17 
 Ex.: cin >> anos >> altura 
 
 Tela 
 
 26 1.70 anos 26 
 altura 1.70 
 
 
 ii) gets (nome-da-variável); 
 
 Ler uma cadeia de caracteres do teclado enquanto não for pressionada a tecla 
ENTER. 
 
 Ex.: gets(nome); 
 
 Tela 
 nome 
 
 
 
 iii) getche( ) e getch( ) 
 
 Transferem um caracter para a variável sem esperar pressionar <ENTER>. 
 
 Ex.: ch = getche( ); 
 ch = getch( ); 
 
 Tela 
 
 A ch A 
a
A 
n
n 
a
a 
 p
P 
a
a 
u
u 
l
l 
a
a 
 
 18 
 
 4.2 - Saída 
 
 cout << identificador << . . . 
 Onde: Identificadores são os nomes das variáveis e/ou mensagem. 
 
 << operador de inserção. 
 
 Exibe na tela o conteúdo de variáveis e/ou mensagens. 
 Obs: A mensagem vem entre aspas duplas. 
 
 Ex.: cout <<"A sua idade é : " << id; 
 
 Tela 
id 18 A sua idade é : 18 
 
 
5 - Manipuladores de tamanho de campos na impressão. 
 
 O tamanho do campo é definido pelo arquivo iomanip.h e são os seguintes: 
 
 1 - setw - seleciona o tamanho do próximo campo a ser impresso. 
 
 2 - setprecision - define o numero de casas decimais a serem impressas para 
o número ponto flutuante (float). 
 
 3 - setfill - seleciona o caractere que deverá preencher as colunas em branco 
de um campo. 
 
Exemplos: 
 
 19 
 
1) com números inteiros 
 
#include <iostream.h> 
main( ) 
{ 
 int lap,bor,can,cad,fit; 
 lap=45; bor=2345; can=420; cad=8; fit=13050; 
 cout << "\n\n\n" // insere linhas 
 cout << '\n' << "Borracha" <<bor; 
 cout << '\n' << "Lapis" << lap; 
 cout << '\n' << "Canetas" << can; 
 cout << '\n' << "Cadernos" << cad; 
 cout << '\n' << "fitas" << fit; 
} 
 
#include <iostream.h> 
#include <iomanip.h> 
main( ) 
{ 
 int lap=45,bor=2345, can=420, cad=8, fit=13050; 
 cout << "\n\n\n" // insere linhas 
 cout << '\n' << "Borracha" << setw(12) << bor; 
 cout << '\n' << "Lapis" <<setw(12) << lap; 
 cout << '\n' << "Canetas" <<setw(12) << can; 
 cout << '\n' << "Cadernos" <<setw(12) << cad; 
 cout << '\n' << "fitas" <<setw(12) << fit; 
{} 
 2) Preencher as colunas em branco com o caracter (.). 
 
 
 20 
 - acrescentar: 
 
 cout << setfill(' . '); 
 cout << '\n'<<"lapis"<<setw(12)<<lap; 
 . 
 . 
 . 
 . 
 
Ex.: Tamanho de campos com pontos flutuantes. 
 
#include <iostream.h> 
#include <iomanip.h> 
main( ) 
{ 
 float lap=4.875,bor=234.542,can=42.036,cad=8.0,fit=13.05; 
 cout << "\n\n\n"; 
 cout << setprecision(2); 
 cout <<'\n'<<"lapis"<<setw(12) << lap; 
 . 
 . 
 . 
 . 
} 
 
Ex.: Tamanho de campos com cadeias de caracteres 
 
 . 
 . 
 . 
 
 21 
{ 
 cout << "\n\n\n"; 
 cout << "objeto"<<setw(12)<<"codigo"<<'\n'; 
 cout <<'\n'<< "lapis"<<setw(12)<<"WQR"; 
 cout << '\n'<< "borracha"<<setw(12)<<"ASO"; 
 . 
 . 
 . 
} 
 
 
#include <iostream.h> 
#include <iomanip.h> 
#include <conio.h> 
void main(void) 
{ 
 float lap=4.875, bor = 234.542; 
 cout<<"\n\n\n"; 
 cout<<setprecision(2)<<setfill('.'); 
 cout<<"\nlapis "<<setw(12)<<lap; 
 cout<<"\nborracha "<<setw(12)<<bor; 
 cout<<"\nAperte enter "; 
 getch( ); 
 return; 
} 
 
6.0 - Funções Aritméticas 
 1) sin(x) 
 2) cos(x) 
 
 22 
 3) atan(x) - arco-tangente de x 
 4) sqrt(x) - raiz quadrada de x 
 5) exp(x) - Nº. e elevado a x 
 6) abs(x) - valor absoluto inteiro 
 7) fabs(x) - valor absoluto real 
 8) log(x) logaritmo 
 9) log10 - logaritmo na base 10 
 10) pow(x,y) - elevar x a y 
 
7.0 - Operadores relacionais 
 
 1) = = 3) > 5) > = 
 2) ! = 4) < 6) < = 
 
 7.1 - O resultado de uma operação de dois valores pode ser: 
 - 0 (falso) ou 1 (verdadeiro) 
 
 7.2 - O resultado de uma operação lógica é um valor cujos bits são operados 
um a um de acordo com a álgebra de proposições. 
 
 7.3 - Operadores lógicos 
 
 ! (negação) 
 && (conjunção) 
 || (disjunção) 
OBS: 1º. PORTA LÓGICA AND(&&) 
 
 TABELA VERDADE: 
 
 23 
 
X Y Z 
0 0 0 
0 1 0 
1 0 0 
1 1 1 
 
Analogia De Um Circuito Em Série, Basta Uma Chave Desligada Para A Lâmpada 
Desligar. 
 
2ª. PORTA OR ( | | ) 
 
TABELA VERDADE: 
 
X Y Z 
0 0 0 
0 1 1 
1 0 1 
1 1 1 
 
Analogia De Um Circuito Em Paralelo, Basta Uma Chave Ligada Para A Lâmpada 
Acender. 
 
 
 7.4 - Operadores aritméticos de atribuição 
 
 1) + = 4) / = 
 2) - = 5) % = 
 3) * = 
 
 
 24 
 Ex.: 1) t + = 2; ------> t=t+2; 
 2) x * = y+1; -- > x = x * (y + 1) 
 3) t / = 25; -- > t = t / 25 
 4) p % = 5; -- > p = p % 5 
 
 7.5 - Operadores de incremento (+ +) e de decremento (- -) 
 
 - O Operador de incremento pode ser usado de 2 formas: 
 
 a) Prefixado quando aparece antes do nome da variável 
 b) Pós-fixado aparece em seguida ao nome da variável 
 
Ex.: 1) x = x + 1; // adiciona 1 a x 
 2) + + x; // adiciona 1 a x 
 3) x + +; // adiciona 1 a x 
 
 Obs.: A diferença entre as operações executadas pelo operador prefixado e o 
pós-fixado aparece em instruções que fazem mais do que somente incrementar a variável 
operando. 
 
 1) O operador de incremento prefixado incrementa a variável operando antes 
de executar a instrução em que ele aparece. 
 
Ex.: n = 5; 
 x = + + n; 
 cout << "\n N= " << n <<" X = "<< x; 
 
 A saída será 
 N = 6; X = 6 
 
 
 25 
 2) O operador de incremento pós-fixado incrementa a variável operando logo 
após a execução da instrução em que ele aparece. 
 
Ex.: n = 5; x = n++; 
 cout << "\n N = "<< n <<" X = "<< x; 
 
 A saída será 
 N = 6; X = 5 
 
 3) A sintaxe do operador de decremento é idêntica a do operador de 
incremento. 
 
 7.6 - Operador condicional ternário: ? : 
 
 Sintaxe: 
 
 exp1 ? exp2 : exp3; 
 
 A exp1 é avaliada, se for verdadeira a exp2 é executada; caso contrário, se a 
exp1 for falsa a exp3 é executada. 
 
 Ex1.: max = (a > b) ? a: b; 
 
 A variável max receberá o maior valor. 
 
 Ex2.: abs = (x > 0) ? x : -x; 
 
 Ex3.: cout << ( (x % 2) ? "Impar " : "Par"); 
 
// Calcula a média aritmética de 4 notas 
 
 26 
 
#include <iostream.h> 
main( ) 
{ 
 float nota,media; 
 media = 0; 
 cout<<"\nDigite a primeira nota : "; 
 cin >> nota; 
 media + = nota; 
 cout<<"\nDigite a segunda nota : "; 
 cin >> nota ; 
 media + = nota; 
 cout<<"\nDigite a terceira nota : "; 
 cin >> nota; 
 media + = nota; 
 cout<<"\nDigite a quarta nota : "; 
 cin >> nota; 
 media + = nota; 
 media / = 4; 
 cout << "\n Media = "<<media; 
} 
 
 
#include <iostream.h> 
main() 
{ 
 int verdadeiro,falso 
 verdadeiro = (15<20); 
 falso = (15 = = 20); 
 cout << "\n Verdadeiro "<<verdadeiro; 
 
 27 
 cout << "\n Falso "<<falso; 
} 
 
 
#include <iostream.h> 
main( ) 
{ 
 cout << "\n"<<(4+1<3); 
 cout << "\n"<<(2<1+3); 
} 
 
 
8 - Manipuladores de bases Numéricas 
 
 Os manipuladores de bases numéricas estão definidos no arquivo iostream.h e 
são os seguintes: 
 dec - decimal (default) 
 hex - hexadecimal 
 oct - octal 
 
Ex.: 
#include <iostream.h> 
main( ) 
{ 
 int n=65 
 cout<<'\n'<<"Hexadecimal"<<hex<<n; 
 cout<<'\n'<<"Octal"<<oct<<n; 
 cout<<'\n'<<"Hexadecimal"<<dec<<n; 
} 
 
 
 28 
 Saída: 41 
 101 
 65 
 
9 - Imprimindo caracteres gráficos 
 
 O código ASCII dispõe de números de 0 a 127 (decimal) abrangendo letras, 
dígitos, caracteres de pontuação, etc. 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 
 A forma de representar um caractere de código acima de 127 é : \xdd; 
 onde: \xdd é um caractere e pode ser contido por uma cadeia de caracteres 
entre aspas duplas. 
 
 
 
Ex.: 
#include <iostream.h> 
main( ) 
{ 
 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\xDFO\xDF"; 
 cout<<"\n\n"; 
} 
 
10 - Códigos especiais 
 
 29 
 
Códigos Especiais Significado 
\n Nova linha 
\t Tab 
\b Retrocesso 
\f Salta página de formulário 
\a Beep - toca o alto falante 
\r CR - Cursor para o inicio da linha 
\\ \ - Barra invertida 
\0 Null - zero 
\' ' - Aspa simples 
\" " - Aspa dupla 
\xdd Representação hexadecimal 
 
11 - Comentários 
 
 Podem ser colocadas em qualquer lugar do programa e são tratados pelo 
compilador como espaços em branco e vem entre /* ............................. */ ou então // 
.................. 
 
 obs.: // só uma linha 
 
Ex.: 
#include <iostream.h> // diretiva do pré-processador 
#include <conio.h> // necessário p/ o getche( ) 
// início do programa 
 
main( ) 
{ 
 charch; /* declaração de variável */ 
 
 30 
 cout<<"\nPressione uma tecla "; 
 ch=getche( ); // solicita uma tecla 
 cout<<"\nA tecla sucessora ASCII é "<<char(chr+1); 
} 
 
12 -Estruturas Condicionais 
 
 12.1 - Estrutura condicional simples: 
 
 1) Só uma instrução 
 
 if (expressão de teste) 
 instrução; 
 
Ex1.: 
 if (a = = b) 
 x = x + 1; 
 
Ex2.: 
 if (a>b+c | | a>20) 
 y = y + 2; 
 
 2) Mais de uma instrução 
 
 if (expressão de teste) 
 { 
 instrução; 
 instrução; 
 } 
 
 
 31 
Ex1.: 
 if (ch = = '0') 
 { 
 cout<<"\n Zero detectado"; 
 cont = cont+1; 
 } 
 
 12.2 - Estrutura condicional composta 
 
 1) Só uma instrução: 
 
 if (expressão de teste) 
 instrução a; 
 else instrução b; 
 
Ex1.: 
 if (a > 10) 
 k = k+2; 
 else y = y+3; 
 
 
 2) Mais de uma instrução 
 
 if (expressão de teste) 
 { 
 instrução1a; 
 . . . 
 instrução na; 
 } 
 else { 
 
 32 
 instrução1b; 
 . . . 
 instrução nb; 
 } 
 
 
 
 
Ex2.: 
 if (sexo = ='f') 
 { 
 nm = nm + 1; 
 k = k+i; 
 } 
 else { 
 nh = nh +1; 
 y = y+i; 
 } 
 
Ex: 
 1) Fazer um programa em C+ + que leia valores distintos. Determine e 
escreva o menor deles. 
 
#include <conio.h> 
#include <iostream.h> 
void main(void) 
{ 
 float a,b,c,men; 
 clrscr(); 
 cout <<"\nDigite três valores distintos "; 
 
 33 
 cin >> a >> b >> c; 
 if (a<b && a<c) 
 men=a; 
 else if (b<c) 
 men=b; 
 else men = c; 
 cout<<“\n menor = “<<men; 
 cout <<"\n Aperte quqlquer tecla "; 
 getch( ); 
 return; 
} 
 
 2) Fazer um programa em C+ + que leia os coeficientes de uma equação do 
2º. Grau. Calcule escreva as raízes reais se houver. 
 
 
#include <conio.h> 
#include <math.h> 
#include <iostream.h 
void main(void) 
{ 
 float x1,x2,a,b,c,d; 
 cout<<"\nDigite os coeficientes da equação do 2º. Grau"; 
 cin>>a>>b>>c; 
 d = pow(b,2)-4*a*c; 
 if (d>=0) 
 { 
 x1=(-b+sqrt(d))/2*a; 
 x2=(-b-sqrt(d))/2*a; 
 cout<<'\n x1= "<<x1<<" x2= "<<x2; 
 
 34 
 } 
 else cout<<"\n Não existem raízes reais "; 
 cout<<"\n Aperte qualquer tecla "; 
 getch( ); 
 return; 
} 
 
3 - fazer um prog. em c++ que leia os lados de um triângulo. Determine se os lados 
formam um triângulo se houver indique através de uma mensagem o tipo (eqüilátero, 
isósceles ou escalenos); caso contrário informe que não existe triângulo. 
 
 
#include <conio.h> 
#include <iostream.h> 
#include <math.h> 
void main(void) 
{ 
 int x,y,z; 
 cout<<"\nDigite os lados do triângulo "; 
 cin >> x >> y >> z; 
 if (x<y+z && y<x+z && z<x+y) 
 if (x = = y && x = = z) 
 cout<<"\n Triângulo eqüilátero "; 
 else if (x = = y | | x = = z | | y = = z) 
 cout<<"\n Triângulo isósceles "; 
 else cout <<"\n Triângulo escaleno"; 
 else cout<<“\n não existe triângulo”; 
 cout << "\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
 
 35 
} 
 
13 - Estruturas de repetições 
 
 13.1 - A estrutura for: 
 
 1. só uma instrução: 
 
 for (inicialização; teste; incremento) 
 instrução; 
 
 2. Mais de uma instrução: 
 
 for (inicialização; teste; incremento) 
 { 
 instrução; 
 instrução; 
 } 
 
Obs.: i) for é usado quando sabemos o número de vezes a repetir. 
 ii) Só pode usar for se a variável de controle for do tipo inteira e variando de 
um em um. 
 iii) Todas as variáveis que estiverem dentro da estrutura de repetição tem que 
atribuir valores iniciais, exceto as lidas. 
 
Ex.: 1) Fazer um programa em C+ + que leia a altura e o sexo de 10 pessoas. 
Calcule e escreva a maior e a menor altura com os respectivos sexos. 
 
 
 
 36 
 Dados: alt 
 sexo 
 10 pessoas (np) 
 
#include <stdio.h> 
#include <conio.h> // diretiva limpa tela 
#include <iostream.h> 
void main(void) 
{ 
 char sexo,aux1,aux2; 
 float alt,ma,me; 
 int np; 
 ma = 0; me =4; 
 for (np=1; np<=10; np++) 
 { 
 cout<<"\nDigite o sexo : "<<np<<” ? “; 
 cin >>sexo; 
 cout<<"\nDigite a altura : "<<np<<” ? “; 
 cin >> alt; 
 if (alt > ma) 
 { 
 ma = alt; 
 aux1 = sexo; 
 } 
 if (alt < me) 
 { 
 me = alt; 
 aux2 = sexo; 
 } 
 clrscr( ); 
 
 
 37 
 } 
 cout<<"\n ma = "<<ma<<" aux1 = "<<aux1; 
 cout<<"\n me = "<<me<<" aux2 = "<<aux2; 
 cout<<"\nAperte qualquer tecla "; 
 getch( ); 
 return; 
} 
 
 13.2 - Estrutura while 
 
 Sintaxe: 
 1- uma instrução: 
 
 i) while (expressão de teste) 
 instrução; 
 
 2- mais de uma instrução: 
 
 ii) while (expressão de teste) 
 { 
 instrução; 
 instrução; 
 } 
 
 Obs.: 
 i) O laço while é apropriado em situações em que o laço pode ser terminado 
inesperadamente, por condições desenvolvidas dentro do laço. 
 ii) while executa as instruções enquanto a expressão de teste for verdadeira. 
 
 
 38 
 Ex. 1) Fazer um programa em C+ + que leia a idade de um grupo de pessoas. 
O último dado que não entrará nos cálculos tem idade igual a 0 (zero). Calcule e escreva: 
- a idade média do grupo 
- 
 Dado: id 
 
 idm = sid/np 
 
#include <iostream.h> 
#include <stdio.h> 
#include <conio.h> 
void main(void) 
{ 
 int id; 
 unsigned long np,sid; 
 float idm; 
 np = 0; sid = 0; 
 cout<<"\nDigite a idade ; "; 
 cin>>id; 
 while (id!=0) 
 { 
 sid=sid + id; 
 np = np + 1; 
 cout<<"\nDigite a idade e idade = 0 para "; 
 
 cin >> id; 
 clrscr( ); 
 } 
 if (np!=0) 
 { 
 
 39 
 idm = sid/np; 
 cout<<"\nA média é : "<<idm; 
 } 
 else cout<<"\nNão existe "; 
 cout<<"\n Aperte qualquer tecla "; 
 getch( ); 
 return ; 
} 
 
Ex: 2 Fazer um prog. em c++ que leia o nome,idade e o sexo.O último dado que não 
entrará tem nome igual a fim. Calcule e escreva: 
- o número de mulheres de idade entre 18 e 30 anos e nome igual à Luciane; 
- a idade média dos homens. 
 
#inclcude <stdio.h> // Para a função gets() 
#include <string.h> // Para a função strcmpi(s1,s2) 
#include <iostream.h> 
#include <conio.h> 
void main(void) 
 { 
 char no[25],sexo; 
 int id,nh,nm,sid; 
clrscr(); 
sid=0;nm=0;nh=0; 
cout<<“\n digite o nome”; 
gets(no); 
while(strcmpi(no,”fim”)) //executa enquanto o nome diferente de fim 
 { 
 cout<<“\n digite a idade e o sexo”; 
 cin>>id>>sexo; 
 
 40 
 if(sexo==‘m’) 
 { 
 nh=nh+1; 
 sid=sid+id; 
 } 
 
 if(sexo==‘f’ && id>18 && id<30 && strcmpi(no,”luciane”)=0) 
 nm++; 
 cout<<“\n digite o nome e nome igual a fim interrompe o laço”; 
 gets(no); 
 clrscr(); 
 } 
if(nh!=0) 
 cout<<“\n A media e: “<<(sid/nh); 
cout<<“\n nm= “<<nm; 
cout<<“\n aperte qualquer tecla”; 
getch(); 
return; 
}Obs: A função strcmpi(s1,s2) compara duas strings, se forem diferentes é 
verdadeiro(1); caso contrário é falso(0). 
 
 
 13.3 - A estrutura do-while 
 Sintaxe do laço do-while 
 do 
 { 
 instrução; 
 instrução; 
 
 41 
 } while (expressão de teste); 
 
 Obs.: i) do-while é utilizado em situações em que é necessário executar o 
corpo do laço uma primeira vez e depois avaliar a expressão de teste e criar um ciclo 
repetido. 
 ii) Este ciclo de execução do bloco e teste é repetido até que a expressão 
de teste se torne falsa (igual à zero), então o laço termina e o controle do programa passa para 
a linha seguinte ao laço. 
 
 Ex.1) Fazer um programa em C+ + que leia a nota e o código. O último dado 
que entrará tem código igual a 3020. Calcule e escreva: 
 - As duas maiores notas, com os respectivos códigos. 
 
#include <stdio.h> 
#include <conio.h> 
#include <iostream.h> 
void main(void) 
{ 
 float no,m1,m2,cod,aux1,aux2; 
 m1=0;m2=0;aux1=0;aux2=0; 
 do 
 { 
 cout<<"\nDigite a nota e o código : "; 
 cin>>no>>cod; 
 if (no>m1) 
 { 
 m2=m1; 
 aux2=aux1; 
 m1=no; 
 aux1=cod; 
 
 42 
 } 
 else if (no>m2 && no!=m1) 
 { 
 m2=no; 
 aux2=cod; 
 } 
 clrscr( ); 
 } while (cod!=3020); 
 cout<<"\nm1 = "<<m1<<"aux1 = "<<aux1; 
 cout<<"\nm2 = "<<m2<<"aux2 = "<<aux2; 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
} 
 
ex.2 Fazer um prog. em c++ que calcule e escreva o número de anos necessários para 
que a população de A seja maior ou igual à de B. Sabendo que a população de A é 90000000 
milhões de habitantes com uma taxa de crescimento constante de 3% ao ano e que B tem 
200000000 de habitantes com uma taxa constante de 1.5% ao ano. 
 
 
#include <conio.h> 
#include <stdio.h> 
#include <iostream.h> 
void main(void) 
{ 
 long popa,popb; 
 int na; 
 popa=9E7; popb=2E8; na=0; 
 do 
 
 43 
 { 
 na = na+1; 
 popa=popa+0.03*popa; 
 popb=popb+0.015*popb; 
 } 
 while (popa<popb); 
 cout<<"\nO numero de anos : "<<na; 
 cout<<"\n Aperte qualquer tecla "; 
 getch( ); 
 return; 
} 
Ex.3 Fazer um prog. em c++ que leia o salário e o nome. O último dado que entrará 
tem o nome igual a João. Calcule e escreva: 
- o maior salário com o respectivo nome. 
#include <conio.h> 
#include <iostream.h> 
#include <string.h> 
#include <stdio.h> 
void main(void) 
 { 
 char no[25],aux[25]; 
 float sal,mas; 
 clrscr(); 
 mas=0; 
 do 
 { 
 cout<<“\n digite o nome e nome igual a joão para”; 
 gets(no); 
 cout<<“\n digite o salário: “; 
 cin>>sal; 
 
 44 
 if(sal>mas) 
 { 
 mas=sal; 
 strcpy(aux,no); // copia o conteúdo da string no na string aux. 
 } 
 clrscr(); 
 } 
 while(strcmpi(no,”joao”)); 
cout<<“\n mas = “<<mas<<“ nome e : “<<aux; 
cout<<“\n aperte qualquer tecla ”; 
getch(); 
return; 
} 
 
Obs: A função strcpy(s1,s2) copia o conteúdo da string s2 na string s1. 
 
 
14 - Comandos: 
 
 14.1 - break 
 
 O comando break causa a saída imediata do laço; o controle passa para a 
próxima instrução após o laço. Se a instrução break pertencer a uma estrutura de laços 
aninhados afetará somente os laços internos a ele. 
 
 Ex1) Fazer um programa em C+ + para calcular a soma dos 20 primeiros 
termos da série: 
 S = x - x2/3! + x4/5! - x6 /7! + . . . 
 onde: x é lido. 
Resolução: 
 
 45 
 
i = i + 2 
d = d * (i-1) * i 
e = e +2 
sinal = (-1)*sinal 
s = s + pow(x,e)*sinal/d 
 
#include <conio.h> 
#include <math.h > 
#include <iostream.h> 
void main (void) 
{ 
 int sinal,e,cont,i; 
 long d; 
 float s,x; 
 cont << "\ndigite X "; 
 cin >> x; 
 s=0; i=3; d=6; e=2; sinal = -1; 
 for (cont=1;cont<=19;cont++) 
 { 
 if (x<0) 
 break; 
 s = s + pow(x,e)*sinal/d; 
 i = i+2; 
 d = d*(i-1)*i; 
 sinal = (-1)*sinal; 
 e = e + 2; 
 } 
 cout << "\nO valor de X é = "<<(s+x); 
 cout <<"\n Aperte qualquer tecla "; 
 
 46 
 getch( ); 
 return; 
} 
 
 14.2 - Continue 
 
 Continue faz com que o controle do programa avalie imediatamente a 
expressão de teste e depois continua o processo do laço. 
 
exemplo: imprima os caracteres diferentes dos dígitos. 
#include <iostream.h> 
#include <conio.h> 
void main( ) 
{ 
 char ch; 
 while ((ch=getch( ))!='x') 
 { 
 if (ch>='0' && ch <='9') 
 continue; 
 cout << ch; 
 } 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
} 
 
 14.3 - switch 
 
 switch permite selecionar uma entre várias ações alternativas. 
 
 
 47 
 
 
 
 Sintaxe: 
 
 switch (variável seletora) 
 { 
 case constante1 : instrução; 
 instrução; 
 break; 
 case constante2 : instrução; 
 instrução; 
 break; 
 default : instrução; 
 instrução; 
 } 
 
 onde: variável seletora é do tipo enumerável (inteira ou char). 
 
 Ex1) Fazer um programa que leia o canal e o número de pessoas que estão 
assistindo. O último dado que não entrará tem canal igual a 0 (zero). Calcule e escreva: 
 
 - As porcentagens de audiência dos principais canais de televisão. 
 
 dados: { canal, npas } 
 p4 = n4*100/tot 
 . 
 . 
 . 
 p12 = n12*100/tot 
 
 48 
 
 
#include <conio.h> 
#include <iostream.h> 
 
void main(void) 
{ 
 long tot,n4,n5,n6,n7,n12; 
 int canal,npas; 
 float p4,p5,p6,p7,p12; 
 
 n4=0; n5=0; n6=0; n7=0; n12=0; 
 cout<<"\n Digite o canal "; 
 cin>>canal; 
 
 while (canal!=0) 
 { 
 cout<<"\nDigite o numero de pessoas"; 
 cin >> npas; 
 switch(canal) 
 { 
 case 4 : n4=n4+npas; 
 break; 
 case 5 : n5=n5+npas; 
 break; 
 case 6 : n6=n6+npas; 
 break; 
 case 7 : n7=n7+npas; 
 break; 
 case 12 : n12=n12+npas; 
 
 49 
 break; 
 default : cout<<"\nDigitou o canal errado "; 
 } 
 clrscr(); 
 cout<<"\nDigite outro canal e canal = 0 para "; 
 cin>>canal; 
 } 
 tot=n4+n5+n6+n7+n12; 
 if (tot!=0) 
 { 
 p4 = n4*100/tot; 
 . 
 . 
 . 
 p12 = n12*100/tot; 
 cout<<"\np4 = "<<p4<< . . . <<"p12 = "<<p12; 
 } 
 cout<<"\n Aperte qualquer tecla "; 
 getch( ); 
 return; 
} 
 
 
 50 
 
 
UNIDADE - II 
 
 1.0 - Matrizes 
 
 Matriz é um tipo de dado em C+ + usado para representar uma coleção de 
variáveis de mesmo tipo. 
 
 1.1 - Matriz Unidimensional 
 
 É um conjunto de dados do mesmo tipo, referenciados por um único nome, 
onde cada elemento é referenciado por um único índice. 
 
 1.1.1 - Declaração de variável 
 
 tipo nome-da-variável[n]; 
 onde: n é o número de elementos. 
 
 Ex1) Fazer um programa que leia 10 notas. Calcule e escreva: 
 - A média das notas; 
 
#include <conio.h> 
#include <iostream.h> 
void main(void) 
{ 
 int nota[10],i; 
 float media; 
 media = 0; 
 for(i=0;i<10;i++) 
 
 51{ 
 cout<<"\nDigite a nota "<<(i+1)<<": "; 
 cin>>nota[i]; 
 media=media+nota[i]; 
 clrscr( ); 
 } 
 cout<<"\nA media é = "<<(media/10); 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
} 
 
 Ex2) Fazer um programa em C+ + que leia uma variável composta contendo n 
(n<=100) elementos inteiro, onde n é lido. 
 
 Calcule e escreva: 
 - O maior elemento par e indique a posição; 
 - Uma 2ª. variável composta contendo os elementos divisíveis por 3. 
 
 
#include <iostream.h> 
#include <conio.h> 
#include <math.h> 
void main(void) 
{ 
 int a[100],i,b[100],map,p,j,n; 
 map = 0; p=0; j =0; 
 cout<<"\nDigite o numero de elementos n<=100"; 
 cin>>n; 
 for (i=0;i<n;i++) 
 
 52 
 { 
 cout<<"\nDigite um numero inteiro "<<(i+1)<<" : "; 
 cin>>a[i]; 
 if (a[i]>map && a[i]%2= =0) 
 { 
 map=a[i]; 
 p=i; 
 } 
 if (a[i]%3= =0) 
 { 
 b[j]=a[i]; 
 j++; 
 } 
 clrscr( ); 
 } 
 for(i=0;i<j;i++) 
 cout<<"\nOs elementos de B são :"<<b[i]; 
 cout<<"\nO maior elemento par = "<<map <<"p = "<<p; 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
 
} 
 
 1.2 - Matrizes multidimensionais 
 
 São as que necessitam de mais de um índice para individualizar um elemento 
no conjunto de dados. 
 
 1.2.1 - Declaração de variáveis 
 
 53 
 
 tipo nome-da-variável [nl] [nc]; 
 
 onde: 
 - nl : é o número de linhas 
 - nc : é o número de colunas 
 
 
 Ex1) Fazer um programa que leia uma matriz A3 x 3 de elementos numéricos. 
Calcule e escreva: 
 - A média dos elementos 
 
#include <iostream.h> 
#include <conio.h> 
 
void main(void) 
{ 
 float a[3][3], med; 
 int i,j; 
 med=0; 
 for(i=0;i<3;i++) 
 for(j=0;j<3;j++) 
 { 
 cout<<"\nDigite um valor "<<i<<" "<<j; 
 cin>>a[i][j]; 
 med=med+a[i][j]; 
 clrscr( ); 
 } 
 cout<<"\nA média é = "<<(med/9); 
 cout<<"\n Aperte qualquer tecla"; 
 
 54 
 getch( ); 
 return; 
} 
 
 Ex2) Fazer um programa que leia uma matriz Am x n (m<=20, n<=25) onde m 
e n são lidos. Calcule e escreva: 
 - a matriz transposta de A 
 
#include <iostream.h> 
#include <conio.h> 
 
void main(void) 
{ 
 float a[20][25], b[25][20]; 
 int i,j,m,n; 
 cout<<"\nDigite a ordem (m<=20, n<=25) "; 
 cin>>m >>n; 
 for (i=0;i<m;i++) 
 for (j=0;j<n;j++) 
 { 
 cout<<"\nDigite um valor : "<<i<<" "<<j; 
 cin>>a[i][j]; 
 b[j][i]=a[i][j]; 
 clrscr( ); 
 } 
 
 for (i=0;i<n;i++) 
 for(j=0;j<m;j++) 
 cout<<"\nA matriz é : "<<b[i][j]; 
 cout<<"\nAperte enter "; 
 
 55 
 getch( ); 
 return; 
} 
 
 
 56 
 
 
UNIDADE - III 
 
 1.0 - Funções 
 
 Uma função é um conjunto de instruções desenhadas para cumprir uma tarefa 
particular e agrupadas numa unidade com um nome para referenciá-la. 
 
 1.1 - Chamando uma função 
 
 É o meio pelo qual solicitamos que o programa desvie o controle e passe para 
a função, executar suas instruções e depois volte à instrução seguinte a da chamada da 
função. 
 
 1.2 - Funções simples 
 
 Exemplo: converter a temperatura de graus Fahrenheit para Celsius 
 
 #include <conio.h> 
 #include <iostream.h> 
 #include <iomanip.h> 
 
 int Celsius (int f) 
 { 
 int c; 
 c=(f-32)*5/9; 
 return c; 
 } 
 
 
 57 
 void main(void) 
 { 
 int c,f; 
 cout<<"\nDigite a temperatura em graus Fahrenheit "; 
 cin>>f; 
 c=Celsius(f); 
 cout<<"\n Celsius = "<<c; 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
 } 
 
 58 
 
 1.3 - Protótipo de funções 
 
 A declaração de uma função é chamada protótipo e é uma instrução, geralmente 
colocada no início do programa, que estabelece o tipo da função e os argumentos que ela 
recebe. 
 
 O protótipo de uma função deve preceder a sua definição e a sua chamada. 
 
 
 Ex.: 1 - int Celsius (int fa); // protótipo 
 2 - int Celsius (int); // protótipo 
 
 1.4 - Tipos de funções 
 
 O tipo de uma função é determinado pelo valor que ela retorna via comando 
return e não pelo tipo de argumentos que ela recebe. 
 
 
 
 1.5 - O comando return 
 
 Termina a execução da função e retorna o controle para a instrução seguinte 
do código de chamada. Se após a palavra return houver uma expressão, o valor da expressão 
é retornado à função que chama. 
 
 A sintaxe de uma instrução return tem uma das 3 formas: 
 return; 
 return expressão; 
 return (expressão); 
 
 59 
 
 Ex.: int Celsius (int f) 
 { 
 return (f-32)*5/9; 
 } 
 
 Obs.: Não é permitido o retorno de mais de um valor por meio do comando 
return. 
 
 1.6 - Definição da função 
 
 Tipo nome (declaração dos parâmetros) 
 { 
 instruções; 
 } 
 
 1.7 - Parâmetros da função 
 
 São as informações transmitidas para a função. 
 A função deve declarar essas informações entre parênteses, no cabeçalho de 
sua definição. 
 Ex: int Celsius (int f) 
 { 
 int c; // c é uma variável local 
 c=(f-32)*5/9; 
 return c; 
 } 
 
 
 
 
 60 
 
 1.8 - Passagem por valor 
 
 Sua declaração indica que o valor enviado será armazenado na variável 
indicada e é criada quando a função inicia a sua execução e destruída quando a função 
termina. 
 
 Exemplo1: Fazer um programa que leia uma matriz AM*N 
(M<=20,N<=10). Onde M e N são lidos. Calcule e escreva: a matriz transposta de A. 
 
#include <conio.h> 
#include <iostream.h> 
void matriz(int m, int n) 
 { 
 float a[20][10], at[10][20]; 
 int i,j; 
 for (i=0;i<m;i++) 
 for (j=0;j<n;j++) 
 { 
 cout<<"\n Digite um elemento "<<i<<" "<<j; 
 cin>>a[i][j]; 
 at[j][i]=a[i][j]; 
 clrscr( ); 
 } 
 for (i=0;i<n;i++) 
 for(j=0;j<m;j++) 
 cout<<"\n at["<<i<<" "<<j<<"] = "<<at[i][j]; 
 return: 
 } 
void main(void) 
 
 61 
 { 
 int m,n; 
 cout<<"\nDigite a ordem, M<=20 e N<=10 "; 
 cin>>m>>n; 
 matriz(m,n); 
 cout<<"\nAperte enter "; 
 getch( ); 
 return; 
 } 
 
Exemplo2: 1. Fazer uma função que calcule a soma da série abaixo: 
 2 7 8 13 14 19 . . . 
 2. Fazer um programa que leia o número de termos da série. Calcule e 
escreva a soma dos n primeiros termos da série. 
 
#include <conio.h> 
#include <iostream.h> 
long soma(int n) 
 { 
long so,cont,nu; 
so=0; nu=2; 
for (cont=1;cont<=n;cont++) 
 if (nu % 2 = =0) 
 { 
 so=so+nu; 
 nu=nu+5; 
 } 
 else { 
 so=so+nu; 
 nu=nu+1; 
 
 62 
 } 
return so; 
} 
void main(void) 
 { 
 int n; 
 long so; 
 cout<<“\n digite o número de termos da série”; 
 cin>>n; 
 so=soma(n); 
 cout<<“\n a soma da série é : “<<so; 
 cout<<“\n aperte qualquer tecla”; 
 getch(); 
 return; 
 } 
 
 
 63 
1.9 - Passando vários argumentos 
 
 Ex: Função que desenha retângulos 
 
 #include <iostream.h> 
 #include <conio.h> 
 
 void retangulo(int l, int alt) 
 { 
 int i,j;l=l/2; 
 alt=alt/4; 
 for(i=1;i<=alt;i++) 
 { 
 cout<<"\t\t"; 
 for(j=1;j<=l;j++) 
 cout<<'\XDB'; 
 cout<<'\n'; 
 } 
 } 
 
 void main(void) 
 { 
 cout<<"\nSala\n"; 
 retangulo(22,12); 
 cout<<'\nCozinha\n"; 
 retangulo(16,16); 
 cout<<"\nBanheiro\n"; 
 retangulo(6,8); 
 cout<<"\nQuarto\n"; 
 
 64 
 retangulo(12,12); 
 cout<<"\nAperte enter"; 
 getch( ); 
 return; 
 } 
 
 
 
 
 
 
 1.10 - O operador unário de referência: & 
 
 O operador de referência cria outro nome para uma variável já criada. 
 
 Ex.: int n; 
 int& n1 = n; 
 
 onde: n1 é o outro nome para n. A operação em qualquer dos nomes tem 
o mesmo resultado. 
 Uma referência não é uma cópia da variável a que se refere. É a mesma 
variável sob nomes diferentes. 
 
 Ex.: int n; 
 int& n1=n; 
 n=5; 
 cout<<n1; 
 n1=8; 
 cout<<n; 
 
 
 65 
  saídas: 5 e 8 
 
Obs: O operador unário &, quando usado na criação de referência, faz parte do tipo: 
 
 int& é um tipo de dado. 
 
 Toda referência deve obrigatoriamente ser inicializada. 
 
 int n; 
 int& n1; //errado 
 int& n1=n; // certo 
 
 
 1.11 - Passagem por referência 
 
 A principal vantagem da passagem por referência é a de que a função pode 
acessar as variáveis da função que chamou. Este mecanismo, possibilita que uma função 
retorne mais de um valor para a função que chama. 
 
 Exemplo: Mostra passagem de argumentos por referência 
 
#include <conio.h> 
#include <iostream.h> 
void reajusta (float& p, float& r ) // reajusta o preço em 20% 
 { 
 r=p*0.2; 
 p=p*1.2; 
 } 
 
 void main(void) 
 
 66 
 { 
 float preco,valreaj; 
 do 
 { 
 cout<<"\n Entre com o preço "; 
 cin>preco; 
 reajusta(preco,valreaj); 
 cout<<"\n Preco novo = "<<preco; 
 cout<<"\n Valreaj = "<<valreaj; 
 } 
 while (preco !=0); 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 } 
 
 Ex.2 
 // ordena uma lista de 3 números 
 #include <conio.h> 
 #include <iostream.h> 
 void troca(float& n, float& m) 
 { 
 float aux; 
 aux=n; 
 n=m; 
 m=aux; 
 } 
 void main(void) 
 { 
 float n1,n2,n3; 
 cout<<"\nDigite 3 números "; 
 
 67 
 cin>>n1>>n2>>n3; 
 if(n1>n2) 
 troca(n1,n2); 
 if(n1>n3) 
 troca(n1,n3); 
 if(n2>n3) 
 troca(n2,n3); 
 cout<<"\nn1 = "<<n1<<" n2 = "<<n2<<" n3 = "<<n3; 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 } 
 
 1.12 - Referências Constantes 
 
 Você pode combinar a palavra chave const com a declaração de uma 
referência para uma variável. 
 
 Ex.: int n = 456; 
 const int &n1 = n; 
 
 Estas declarações fazem de n1 um nome "read-only" para n. Você não poderá 
fazer nenhuma modificação em n1, somente em n. 
 
 1.13 - Classes de armazenamento 
 
 São quatro as classes de armazenamento em C ++: 
 
 1 - auto - automáticas (default) 
 2 - extern - externas 
 3 - static - estáticas 
 
 68 
 4 - register - em registradores 
 
 1) Classe auto 
 Podem ser acessadas somente pelas instruções do mesmo bloco e 
escritas após a sua declaração. 
 Quando uma variável automática é criada, o programa não a inicializa 
com nenhum valor específico. Variáveis automáticas conterão um valor inicial aleatório, 
chamado " lixo ". 
 
 2) Classe extern 
 São declaradas fora de qualquer função. O acesso a elas é permitido a 
todas as funções definidas após a sua declaração, e elas existirão enquanto o programa 
estiver sendo executado. 
 
 Ex.: 
 #include <conio.h> 
 #include <iostream.h> 
 int i; // externa 
 int j=234; // externa 
 
 void func( ) 
 { 
 i=25; j=48; 
 } 
 
 void main(void) 
 { 
 cout<<"\n i = "<<i<<"j = "<<j; 
 func( ); 
 cout<<"\n i = "<<i<<"j = "<<j; 
 
 69 
 cout<<"\nAperte enter "; 
 getch( ); 
 return; 
 } 
 
  saída: i = 0 j = 234 
 i = 25 j = 48 
 
 1.14 - O Operador de escopo : : 
 
 Em C ++, as variáveis automáticas têm precedência sobre variáveis externas. 
Você pode solicitar ao compilador que utilize a variável externa em vez da automática 
colocando o operador : : antes do nome da variável. 
 
 Ex.: 
 #include <iostream.h> 
 #include <conio.h> 
 
 int i; // inicializa com zero 
 int j=234; // inicializa com 234 
 
 void main( ) 
 { 
 int i=5, j=10; // variáveis automáticas 
 cout<<: : i<<: : j<<"\n"; // externas 
 cout<<i<<j<<"\n"; 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 } 
 
 
 70 
 1.15 - Funções recursivas 
 
 Uma função é dita recursiva se for definida em termos dela mesma. Isto é, 
uma função é recursiva quando dentro dela está presente uma instrução de chamada a ela 
própria. 
 
 Ex: 1 - Escrever uma função que calcula o fatorial de um número. 
 
 #include <conio.h> 
 #include <iostream.h> 
 long fatorial (int n) 
 { 
 if (n<=1) 
 return (1); 
 else return (n*fatorial(n-1)); 
 } 
 void main(void) 
 { 
 int n; 
 cout<<"\nDigite um numero inteiro"; 
 cin>>n; 
 cout<<"\nFat = "<<fatorrial(n); 
 cout<<"\nAperte enter"; 
 getch( ); 
 return; 
 } 
 Quando o programa for executado a função fatorial será acessada 
repetidamente, uma vem em main e (n-1) vezes dentro dela mesma apesar do usuário não se 
preocupar com isso. Quando um programa recursivo é executado, as chamadas das funções 
recursivas não são executadas imediatamente. Elas são colocadas em uma pilha (stack) até 
 
 71 
que a condição de término da recursão seja encontrada. As chamadas da função são 
executadas, então, em ordem inversa, à medida que forem retiradas (popped off) da pilha. 
Quando uma expressão fatorial for avaliada recursivamente, as chamadas de função serão 
executadas da seguinte ordem: 
 
 n! = n*(n-1)! 
 (n-1)! = (n-1)*(n-2)! 
 (n-2)! = (n-2)*(n-3)! 
 
 2! = 2*1! 
 
 Os valores serão então devolvidos na seguinte ordem: 
 
 1! = 1 
 2! = 2*1! = 2*1 = 2 
 3! = 3*2! = 3*2 = 6 
 4! = 4*3! = 4*6 = 24 
 
 Ex.2 - Imprime uma frase de ordem inversa a que foi lida. 
 
 #include <iostream.h> 
 #include <conio.h> 
 void invert( ) 
 { 
 char ch; 
 if ((ch=getche( ) )!= '\r') 
 invert( ); 
 cout<<ch; 
 } 
 
 
 72 
 void main(void) 
 { 
 cout<<"\n"; 
 inverte( ); 
 cout<<"\n Aperte qualquer tecla"; 
 getch( ); 
 return; 
 } 
 
1.16 - O conjunto das diretivas mais comuns reconhecidas pelo pré-processador é o 
seguinte: 
 
 1 - #define 
 2 - #undef 
 3 - #include 
 4 - #if 
 5 - #ifdef 
 6 - #ifndef 
 7 - #else 
 8 - #elif 
 9 - #endif 
 10 - #error 
 
 1.16.1 - #define é usada para definir constantes simbólicas com nomes 
apropriados 
 
 Ex.: #define PI 3.14 
 
 1.16.2 - #undef remove a mais recente definição criada com #define 
 
 
 73 
 1.16.3 - #include causa a inclusão de outro arquivo em nosso programa 
fonte. 
 
 1.16.4 - #error provocauma mensagem de erro do compilador em tempo de 
compilação. 
 
 
 
 
 
 
UNIDADE - IV 
 
1.0 - Estruturas 
 
 Há cinco tipos de dados simples que estão pré-definidos no compilador e que 
nos já conhecemos e já utilizamos. São eles: char, int, float, double e void. 
 Estruturas são tipos de variáveis que agrupam dados geralmente desiguais. Os 
itens de dados de uma estrutura são chamados membros. 
 
 1.1 - definindo a estrutura 
 
 struct nome-do-tipo 
 { 
 membros 
 }; 
 
 onde: struct indica que um novo tipo de dado está sendo definido. 
 
 Ex.: struct aluno 
 
 74 
 { 
 int idade; 
 float altura; 
 char sexo, nome[25]; 
 }; 
 
 1.2 - Acessando os membros da estrutura. Seus membros podem ser 
acessados por meio do operador ponto. 
 
 nome-da-estrutura.membro 
 
 Ex.: aluno.idade 
 
 1.3 - Combinando declarações 
 
 struct 
 { 
 membros; 
 } nome-das-variáveis; 
 
 75 
 
 Ex.: struct 
 { 
 int nmat; 
 float nota[3]; 
 float media; 
 } Ana, Jose, joão; // declaração de diversas variáveis 
 
 
 1.4 - Inicializando estruturas 
 
 É semelhante à inicialização de uma matriz 
 
 Ex.: struct data 
 { 
 int dia; 
 char mes[10]; 
 int ano; 
 }; 
 
 data natal = {25,”dezembro”,1.994}, 
 aniversario={30,”julho”,1.978}; 
 
 Obs.: As variáveis estão sendo inicializada na mesma instrução de suas 
declarações. 
 
 1.5 - Operações entre estruturas 
 
 struct venda 
 { 
 
 76 
 int pecas; 
 float preco; 
 }; 
 
 venda a={20,110.0}, b= {3,16.5}, total; 
 
 Operações simples como a soma não está definida para tipos criados 
com a palavra struct. A soma deve ser efetuada membro a membro: 
 
 total.pecas=a.pecas+b.pecas; 
 total.preco=a.preco+b.preco; 
 
 1.6 - Estruturas aninhadas 
 
 exemplo: 
 
 //mostra estruturas aninhadas 
 #include <conio.h> 
 #include <iostream.h> 
 
 struct data 
 { 
 int dia; 
 char mes[10]; 
 int ano; 
 }; 
 
 struct venda 
 { 
 int pecas; 
 
 77 
 float preco; 
 data diavenda; 
 }; 
 
 void main( ) 
 { 
 venda a={20,110.0,{7,”novembro”,1.993}}; 
 cout<<“\npecas: “<<a.pecas; 
 cout<<“\npreco: “<<a.preco; 
 cout<<“\ndata: “<<a.diavenda.dia<<“de”<<a.diavenda.ano; 
 getch( ); 
 return; 
 } 
 
 Eis a saída: 
 
 pecas: 20 
 preco: 110 
 data: 7 de novembro de 1.993. 
 
 1.7 - Passando estruturas para funções. 
 
 As estruturas podem ser passadas como argumentos de funções de 
mesma forma que variáveis simples. 
 
 Exemplo: 
 // mostra passagem de estruturas para funções por valor. 
 
 #include <iostream.h> 
 #include <conio.h> 
 
 78 
 
 struct venda 
 { 
 int pecas; 
 float preco; 
 }; 
 
 void listavenda (venda c, venda d) 
 { 
 cout<<“\nVenda total = “; 
 cout<<“\nTotal de peças: “<<(c.pecas+d.pecas); 
 cout<<“\nPreco total: “<<(c.preço+d.preco); 
 getch( ); 
 } 
 struct data 
 { 
 int dia; 
 char mes[10]; 
 int ano; 
 }; 
 
 struct venda 
 { 
 int pecas; 
 float preco; 
 data diavenda; 
 }; 
 
 void main( ) 
 { 
 
 79 
 venda a={20,110.0,{7,”novembro”,1,993}}; 
 cout<<“\npecas: “<<a.pecas; 
 cout<<“\nprecos: “<<a.preco; 
 cout<<“\ndata: “<<a.diavenda.dia<<“de”<<a.diavenda.ano; 
 getch( ); 
 return; 
 } 
 
 1.8 - Matrizes de Estruturas 
 
 É um conjunto de registros referenciáveis por um mesmo nome e 
individualizados por índices. 
 
 1.8.1 - Declarando a matriz de estruturas 
 
 O processo de declaração de uma matriz de estruturas é perfeitamente 
análogo à declaração de qualquer outro tipo de matriz. 
 A instrução: vendas[50]; 
 Declara vendas como sendo uma matriz de 50 elementos, cada 
elemento da matriz é uma estrutura do tipo venda. Então venda[0] é a primeira estrutura do 
tipo venda, veda[1] é a segunda estrutura do tipo venda e assim por diante. 
 
Exs.: 1 - Declara a seguinte estrutura de dados. 
 
 contas cliente 
0 
1 nome 
2 r
ua 
n
úmero 
c
pf 
3 saldo 
 
 80 
4 
5 
struct cliente 
 { 
 char nome[25]; 
 char rua[40]; 
 int numero; 
 char cpf[14]; 
 float saldo; 
 }; 
cliente contas[6]; 
 
2.0 - Dada à tabela abaixo 
 
 C
ódigo 
Nome 
0 10
00 
Alfaiate 
1 10
20 
Analista 
2 10
30 
Vended
or 
. 
. 
. 
 
9
9 
10
99 
Médico 
 
 
 
 81 
 Fazer um programa que, dados 500 códigos de profissão, emita o nome das 
profissões correspondentes. A tabela acima também deve ser lida do dispositivo de entrada. 
 
 Estrutura de dados 
 
0 
1 
2 c
ódigo 
n
ome 
3 
. 
. 
. 
 
9
9 
 
 
#include <conio.h> 
#include <iostream.h> 
#include <string.h> 
#include <stdio.h> 
void main(void) 
 { 
 struct tabela 
 { 
 char no[25]; 
 long codigo; 
 }; 
 
 tabela tab[100]; 
 int i,k; 
 
 82 
 long codigodesejado; 
 clrscr( ); 
 for (i=0;i<=99;i++) 
 { 
 cout<<“\ndigite o nome”<<i; 
 gets(tab[i].no); 
 cout<<“\ndigite o código”<<i; 
 cin>>tab[i].codigo; 
 clrscr( ); 
 } 
 
 for (k=1;k<=500;k++) 
 { 
 cout<<“\nDigite o codigo desejado”; 
 cin>>codigodesejado; 
 i=0; 
 while (tab[i].codigo != codigodesejado && i<99) 
 i++; 
 if (tab[i].codigo = = codigodesejado) 
 cout<<“\nCodigo”<<codigodesejado<<tab[i].no; 
 else cout<<“\nInvalido”<<codigodesejado; 
 } 
 cout<<‘\nAperte qualquer tecla”; 
 getch( ); 
 return; 
 } 
 
3 - Em certo município vários proprietários de imóveis estão em atraso com o 
pagamento do imposto predial. Escrever um programa que calcule e escreva o valor da multa 
a ser paga por estes proprietários considerando que: 
 
 83 
 - Os dados de cada imóvel: identificação (literal), valor do imposto e número de 
meses em atraso, estão à disposição numa unidade de entrada; 
 - As multas devem ser calculadas a partir do valor do imposto e de acordo com a 
seguinte tabela. 
 
Valor do 
imposto 
% por mês em 
atraso 
até R$ 5000 1 
de 5000 a 
18000 
2 
de 180001 a 
50000 
4 
de 50001 a 
120000 
7 
acima de 
120000 
10 
 
 - O último registro lido, que não deve ser considerado, contém identificação do 
imóvel igual a vazio. 
 
 - Na saída deverão ser impressos: identificação do imóvel, valor do imposto, 
meses em atraso e a multa a ser paga. 
 
 As estruturas de dados a serem adotadas para a solução do problema são: 
 
Limites 
de até perce
ntual 
0 5.000 1 
 
 84 
5.001 18.00
0 
2 
18.001 50.00
0 
4 
50.001 120.0
00 
7 
120.001 10 
 
 Para os dados de cada imóvel, será adotado o seguinte registro (variável 
composta heterogênea) 
 
 
identifi
c 
impo
sto 
mese
sat 
 
 literal numérico numérico 
 
#include <conio.h> 
#include <string.h> 
#include <stdio.h> 
#include <iostream.h>void main(void) 
{ 
 float tab[5][3]; 
 struct imóvel 
 { 
 char ident[8]; 
 float imposto; 
 int meseat; 
 
 85 
 }; 
 
 int i,j; 
 float multa; 
 clrscr( ); 
 cout<<“\nLeitura da tabela”; 
 for (i=0;i<=4;i++) 
 for (j=0;j<=2;j++) 
 { 
 cout<<“\nDigite um valor “<<i<<“ “<<j; 
 cin>>tab[i][j]; 
 clrscr( ): 
 } 
 cout<<‘\nDigite a identificação”; 
 gets(imovel.ident); 
 while(strscmpi(imovel.ident, “ “)) 
 { 
 cout<<“\nDigite o imposto”; 
 cin>>imovel.imposto; 
 cout<<“\nDigite o mes”; 
 cin>>imovel.meseat; 
 i=4; 
 while (imovel.imposto<tabe[i][0] && i>=0) 
 i=i-1; 
 if(imovel.imposto>=tab[i,][1] 
 { 
 multa=tab[i][2]*(imovel*imposto)*(imovel*meseat/100); 
 cout<<“\nIdent = “<<imovel.ident; 
 cout<<“\nImposto”<<imovel.imposto; 
 cout<<“\nMulta”<<multa; 
 
 86 
 } 
 cout<<“\nDigite a identificação”; 
 gets(imovel.ident); 
 } 
 cout<<‘\nAperte qualquer tecla”; 
 getch( ); 
 return; 
} 
1.9 Arquivos 
 
1.9.1- As classes iostream: 
 
 As classes istream e ostream são derivadas de ios e são dedicadas a leitura e 
impressão, respectivamente. 
 A classe istream contém funções como get(), getline(), read(), além de outras. 
Contém ainda a sobrecarga do operador de extração >>. 
 A classe ostream contém funções como put(), write(), além de outras. Contém a 
sobrecarga do operador de inserção <<. 
 
Ex: 
 
Gravando linha a linha em arquivos em discos. 
 
// Cria um arquivo e grava nele uma string por vez. 
#include <fstream.h> // diretiva para as funções de arquivos. 
#include<iostream.h> 
void main() 
 { 
 ofstream fout(“teste.txt”); //cria arquivo para gravação em modo texto 
 fout<<“\n Um grande antídoto contra o egoismo e a generosidade”; 
 
 87 
 fout<<“\n Dê mesmo que isso requeira de você um esforço.”; 
 } 
 
Obs: inicializamos este objeto com o nome do arquivo teste.txt. Esta inicialização 
associa o objeto fout ao arquivo em disco teste.txt para gravação. 
 
Ex2: Lendo uma linha por vez em arquivos em disco. 
 
Este exemplo pelo programa teste.txt criado pelo programa anterior lê uma string por 
vez. 
 
// Lê strings de arquivo 
#include <fstream.h> 
#include <conio.h> 
#include <iostream.h> 
void main() 
 { 
 const int max=80; 
char buff[max]; 
ifstream fin(“teste.txt”); //cria arquivo p/leitura em modo texto 
while(fin) // enquanto nao termina o arquivo 
 { 
 fin.getline(buff,max); // Lê linha de texto 
 cout<<buff<<‘\n’; 
 } 
cout<<“\n aperte enter p/continuar”; 
getch(); 
return; 
} 
 
 
 88 
No exemplo, getline() lê caracteres enquanto não encontrar o caracter ‘\n’ e coloca os 
caracteres lidos no buffer especificado como argumento. O tamanho máximo do buffer é 
informado no segundo argumento. O conteúdo do buffer é impresso após cada leitura. 
 
1.9.2- Detectando o Fim-de-Arquivo. 
 
 O objeto fin terá o valor zero se o sistema operacional enviar ao programa o sinal 
de fim-de-arquivo e um valor não- zero caso contrário. 
 
 Exemplo: Podemos verificar o fim de arquivo ao mesmo tempo em que lemos uma 
linha.Esta é uma forma mais composta. 
 
#include <fstream.h> 
#include <conio.h> 
#include <iostream.h> 
void main() 
 { 
const int max=80; 
char buff[max]; 
ifstream fin(“teste.txt”); // cria arquivo para leitura em modo texto. 
while(fin.getline(buff,max)) // enquanto nao eof 
 cout<<buff<<‘\n’; 
cout<<“\n aperte enter”; 
getch(); 
return; 
} 
 
1.9.3- Lendo e gravando um caracter por vez no arquivo. 
 
 
 89 
 Para trabalhar com um único caracter por vez, usamos as funções put() e get(), 
membros das classes ostream e istream respectivamente. 
 
Ex: 
// Grava um caracter por vez num arquivo 
#include <fstream.h> 
#include <iostream.h> 
void main() 
 { 
 ofstream fout(“teste1.txt”); 
 char ch; 
 while(cin.get(ch)) // Lê um caracter do teclado 
 fout.put(ch); 
 } 
 
Obs:1. O laço while verifica se o caractere que indica fim-de-arquivo foi digitado no 
teclado. Este caractere tem código ´\x1a’ e é inserido pressionando-se tecla ctrl-z. 
 2. A instrução fout.put(ch) grava o caractere contido em ch no arquivo associado 
à fout. 
 
 Ex: Lê um caractere por vez de um arquivo. 
#include <conio.h> 
#include <iostream.h> 
#include <fstream.h> 
void main() 
 { 
 ifstream fin(“teste1.txt”); 
 char ch; 
 while (fin.get(ch)) // Lê um caractere do arquivo 
 cout<<ch; 
 
 90 
 cout<<“\n aperte enter”; 
 getch(); 
return; 
} 
 
1.9.4- A função open() 
 
 Tanto o construtor como a função open() aceitam a inclusão de um segundo 
argumento indicando o modo de abertura do arquivo. Este modo é definido por bits de um 
byte, onde cada um especifica certo aspecto de abertura do arquivo. 
 
 A lista de modos é definida na classe ios por meio do tipo enum open-mode. 
Modos Descrição 
ios::ou abre para gravação 
ios::ate abre e posiciona no fim do 
arquivo.Este modo trabalha com leitura e 
gravação. 
ios::in abre para leitura 
ios::app grava a partir do fim do arquivo 
ios::trunc abre e apaga todo o conteúdo do 
arquivo 
ios::nocreate erro de abertura se o arquivo não 
existir. 
ios::noreplace erro de abertura se o arquivo existir 
ios::binary abre em binário(default é texto). 
 
1.9.5-Gravando Objetos. 
 
 As funções apropriadas para o processo de gravação e leitura de objetos são as 
funções write() e read(). 
 
 91 
 
Exemplo: Para mostrar o seu uso, primeiramente criaremos um programa para gravar 
registros de livros de uma biblioteca. 
 
// Grava objetos em disco. 
#include <fstream.h> 
#include<iostream.h> 
#include <stdio.h> 
#include <conio.h> 
class livro 
 { 
 private : 
 char titulo[50]; 
 char autor[50]; 
 int numreg; 
 double preco; 
 public : 
 void novonome(); 
 }; 
void livro::novonome() 
 { 
 cout<<“\n digite titulo”; 
 gets(titulo); 
 cout<<“\n digite o autor”; 
 gets(autor); 
 cout<<“\n digite o numero do registro”; 
 cin>>numreg; 
 cout<<“\n digite o preco”; 
 cin>>preco; 
 clrscr(); 
 
 92 
 } 
void main() 
 { 
 ofstream fout(“lista.dat”); 
 livro li; 
 do 
 { 
 li.novonome(); 
 fout.write((char * )&li,sizeof(livro)); 
 cout<<“\n mais um livro (s/n)?”; 
 } 
 while(getche()!=‘n’); 
} 
 
onde: - A função membro novonome() é chamada das informações dos registros. É 
gravado no arquivo lista.dat por meio da função write(). 
 
 - A função write() recebe 2 argumentos:- o primeiro é o endereço do objeto a 
ser gravado; 
 - o segundo o tamanho do objeto deve ser convertido para um ponteiro char. 
 
1.9.6- Lendo Objetos 
 
 Para ler os objetos gravados pelo programa anterior, usaremos a função read(). 
 
Ex: Lê objetos do disco. 
 
#include <fstream.h> 
#include <stdio.h> 
#include <conio.h> 
 
 93 
#include<iostream.h> 
class livro 
 { 
 private : 
 char titulo[50]; 
char autor[50]; 
int numreg; 
double preco; 
public : void print(); 
}; 
void livro::print() 
 {cout<<“\n titulo: “<<titulo; 
 cout<<“\n autor: “<<autor; 
 cout<<“\n no. reg :”<<numreg; 
 cout<<“\n preco: “<<preco; 
 } 
void main() 
 { 
 ifstream fin(“lista.dat”); 
 livro li; 
 clrscr(); 
 while(fin.read((char *)&li,sizeof(livro))) 
 li.print(); 
 cout<<“\n aperte qualquer tecla”; 
 getch(); 
 return; 
} 
 
 
 94 
onde: - A função read() é membro da classe istream e recebe 2 argumentos:- o 
primeiro é o endereço do objeto para onde irão os dados lidos; 
 - o segundo, tamanho do objeto deve ser convertido para um ponteiro char. 
 
1.9.7- Gravando e Lendo Objetos de um mesmo arquivo. 
 
 Ex: grava e lê objetos de disco. 
 
#include <fstream.h> 
#include <stdio.h> 
#include <conio.h> 
#include<iostream.h> 
class livro 
 { 
 private : 
 char titulo[50]; 
 char autor[50]; 
 int numreg; 
 double preco; 
 public : void novonome(); 
 void print(); 
 }; 
void livro::novonome() 
 { 
 cout<<“\n digite titulo”; 
 gets(titulo); 
 cout<<“\n digite o autor”; 
 gets(autor); 
 cout<<“\n digite o número do registro”; 
 cin>>numreg; 
 
 95 
 cout<<“\n digite o preco”; 
 cin>>preco; 
 clrscr(); 
 } 
void livro::print() 
 { 
cout<<“\n titulo: “<<titulo; 
cout<<“\ autor : “<<autor; 
cout<<“\nno. reg. : “<<numreg; 
cout<<“\n preco : “<<preco; 
} 
void main() 
{ 
fstream fio; // Cria objeto de leitura e gravação. 
livro li; // Cria objeto livro 
fio.open(“lista.dat”,ios::ate || ios::out || ios::in); 
do 
{ 
li.novonome(); 
fio.write((char *)&li,sizeof(livro)); 
cout<<“\n Mais um livro (s/n) ? “; 
 } 
while(getche()!=‘n’); 
fio.seekg(0); // Coloca o ponteiro no início do arquivo. 
cout<<“\n lista de livros do arquivo”; 
cout<<“\n ===================================“; 
while(fio.read((char * )&li,sizeof(livro))) 
 li.print(); 
cout<<“\n aperte enter”; 
getch(); 
 
 96 
return; 
} 
 
onde: - A instrução fstream fio cria um objeto para leitura e gravação. 
 - Na instrução fio.open(“lista.dat”,ios::ata | ios::out | ios::in) 
vários modos podem ser aplicados simultaneamente por meio do operador OR (||). 
 - Usamos “ate” para preservar os objetos que já existem no arquivo e 
acrescentar novos objetos ao final dele. Usamos “out” e “in” pois queremos executar as duas 
operações de gravação e de leitura. 
 - A instrução fio.seekg(0) modifica a posição corrente do arquivo para o seu 
início. 
 
1.9.8- As funções seekg(),tellg(),seekp() e tellp(). 
 
 Cada objeto stream está associado a dois valores inteiros chamados ponteiro de 
posição corrente de leitura e ponteiro de posição corrente de gravação. 
 A fonação seekg() permite movimentar a posição corrente de leitura do arquivo 
para uma posição escolhida. 
 A função seekp() executa a mesma tarefa para a posição corrente de gravação. 
 A função seekg() tem o seguinte protótipo: 
istream&seeg(long pos,sek-dir posição=ios::beg); 
 O primeiro argumento indica o deslocamento em bytes a partir da posição 
escolhida. Quando a função é chamada com um único argumento, a posição é assumida como 
sendo o início do arquivo (ios::beg). 
 O segundo argumento quando usado, deve ser um dos modos seguintes: 
ios::beg A partir do início do arquivo 
ios::cur A partir da posição corrente 
ios::end A partir do fim do arquivo. 
Como a leitura do nosso arquivo deve começar no seu início, queremos deslocar o 
byte a partir do início do arquivo. 
 
 97 
 A função tellg() tem o seguinte protótipo: 
 long tellg(); 
 Esta função retorna a posição corrente de leitura(em bytes), sempre a partir do 
início do arquivo. 
 
1.9.9- Calculando o número de registros do arquivo. 
 
Exemplo: O exemplo mostra o uso das funções seekg() e tellg(). 
#include <fstream.h> 
#include <iostream.h> 
#include <stdio.h> // para exit() 
#include <conio.h> 
class livro 
 { 
 private : 
 char titulo[50]; 
 char autor[50]; 
 int numreg; 
 double preco; 
 public : void novonome(); 
 void print(); 
 }; 
void livro::novonome() 
 { 
 cout<<“\n digite titulo”; 
 gets(titulo); 
 cout<<“\n digite autor”; 
 gets(autor); 
 cout<<“\n digite o número de registros”; 
 cin>>numreg; 
 
 98 
 cout<<“\n digite o preco”; 
 cin>>preco; 
 clrscr(); 
 } 
void livro::print() 
 { 
 cout<<“\n titulo: “<<titulo; 
 cout<<“\n autor: “<<autor; 
 cout<<”\n No. reg. :”<<numreg; 
 cout<<“\n preco : “<<preco; 
 } 
void main() 
 { 
ifstream fin; 
livro li; 
fin.seekg(0,ios::end); //aponta para fim do arquivo, deslocamento zero 
long nrec=(fin.tellg())/sizeof(livro); 
cout<<“\n numero de registros=“<<nrec; 
cout<<“\n insira o numero do registro:”; 
cin>>nrec; 
int posicao=(nrec-1)*sizeof(livro); 
fin.seekg(posicao); 
fin.red(char *)&li,sizeof(livro)); 
fin.seekg(posicao); 
fin.read((char *)&li,sizeof(livro)); 
li.print(); 
cout<<“\n aperte enter”; 
getch(); 
return; 
} 
 
 99 
 
A saída será : 
Numero de registros=3 
insira o número de registro: 1 
Titulo : Helena 
Autor : Machado de Assis 
No. Reg. : 102 
Preco : 70.50 
 
Observe que o usuário escolheu o registro 1 indicando o primeiro registro do arquivo, 
entretanto para o programa o primeiro registro é o de numero 0. Assim, na instrução: 
int posicao=(nrec-1)*sizeof(livro); 
usamos nrec-1 para corrigir o número do registro. 
 
 
 
 
 
 
 100 
1.10 Exemplos extras de arquivos. 
 
// ------------------------------ Programa inicial para uma agenda 
// 
// PUC - Minas - Departamento de Ciência da Computação - 02/96 
// 
// Programa para exercitar conceitos básicos sobre arquivos. 
// 
// 
// ------------------------------ Bibliotecas necessárias 
 
#include <conio.h> 
#include <ctype.h> 
#include <stdio.h> 
#include <string.h> 
#include <fstream.h> 
#include <iostream.h> 
 
// ------------------------------ Definicoes globais 
 
#define BOOLEAN int 
#define TRUE 1 
#define FALSE 0 
 
#define nl '\n' 
#define FDA '.' 
 
// ------------------------------ Biblioteca basica 
 
char GetOption(int X, int Y, char * Valida) // GetOption() 
{ 
 // objetivo : 
 // colher uma resposta do teclado, posicionando-a na tela 
 // nas coordenadas (X,Y) e verificando sua validade 
 // 
 // parâmetros : 
 
 101 
 // X - coluna (ate' 80) 
 // Y - linha (ate' 24) 
 // Valida - cadeia de caracteres com as opções validas 
 // 
 // definições locais 
 char C; // opção que será' lida do teclado 
 
 do 
 { 
 gotoxy(X,Y); clreol(); // posicionar e limpar ate' o fim da linha 
 gotoxy(X,Y); C=getche(); // posicionar, ler e ecoar o caractere 
 } 
 while(! memchr(Valida,C,strlen(Valida))); 
 return(toupper(C)); // voltar à maiúscula correspondente 
} 
 
void PutStr(int X, int Y, char * Str) // PutStr() 
{ 
 // objetivo : 
 // colocar uma mensagem na tela nas coordenadas (X,Y) 
 // 
 // parâmetros : 
 // X - coluna (ate' 80) 
 // Y - linha (ate' 24)