Apostila c++

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-70
1.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 << "nnn" // insere linhas
cout << 'n' << "Borracha" << bor;
cout << 'n' << "Lapis" << lap;
cout << 'n' << "Canetas" << can;
cout << 'n' << "Cadernos" << cad;
cout << 'n' << "fitas" << fit;
}
#include <iomanip.h>
main( )
{
int lap=45,bor=2345, can=420, cad=8, fit=13050;
cout << "nnn" // 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.
main( )
{
float lap=4.875,bor=234.542,can=42.036,cad=8.0,fit=13.05;
cout << "nnn";
cout << setprecision(2);
cout <<'n'<<"lapis"<<setw(12) << lap;
.
.
.
.
}
Ex.: Tamanho de campos com cadeias de caracteres
.
.
.

21
{
cout << "nnn";
cout << "objeto"<<setw(12)<<"codigo"<<'n';
cout <<'n'<< "lapis"<<setw(12)<<"WQR";
cout << 'n'<< "borracha"<<setw(12)<<"ASO";
.
.
.
}
#include <conio.h>
void main(void)
{
float lap=4.875, bor = 234.542;
cout<<"nnn";
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
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;
}
main()
{
int verdadeiro,falso
verdadeiro = (15<20);
falso = (15 = = 20);
cout << "n Verdadeiro "<<verdadeiro;

27
cout << "n Falso "<<falso;
}
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.:
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.:
main( )
{
cout<<"nn";
cout<<"nxDCxDCxDBxDBxDBxDBxDCxDC";
cout<<"nxDFOxDFxDFxDFxDFOxDF";
cout<<"nn";
cout<<"nxDCxDCxDBxDBxDBxDBxDBxDBxDB";
cout<<"nxDFOxDFxDFxDFxDFxDFOxDF";
cout<<"nn";
}
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( )
{
char ch; /* 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
{
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:
instrução a;
else instrução b;
Ex1.:
if (a > 10)
k = k+2;
else y = y+3;
2) Mais de uma instrução
{
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>
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 <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
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 <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 ";
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 <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>
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>
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;
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 <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 >
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 <conio.h>
void main( )
{
char ch;
while ((ch=getch( ))!='x')
{
if (ch>='0' && ch <='9')
continue;
cout << ch;
}
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>
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;
break;
break;
break;

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;
}
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>
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);
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 <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;
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 <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);

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 <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];

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>
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;
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>
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);
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>
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;
getch();
return;
}

63
1.9 - Passando vários argumentos
Ex: Função que desenha retângulos
#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<<"tt";
for(j=1;j<=l;j++)
cout<<'XDB';
cout<<'n';
}
}
void main(void)
{
cout<<"nSalan";
retangulo(22,12);
cout<<'nCozinhan";
retangulo(16,16);
cout<<"nBanheiron";
retangulo(6,8);
cout<<"nQuarton";

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>
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);
getch( );
}
Ex.2
// ordena uma lista de 3 números
#include <conio.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;
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>
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
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 <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";
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>
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 <conio.h>
void invert( )
{
char ch;
if ((ch=getche( ) )!= 'r')
invert( );
cout<<ch;
}

72
void main(void)
{
cout<<"n";
inverte( );
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 provoca uma 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>
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 <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 <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>
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>
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 <conio.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
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>
void main()
{
ifstream fin(“teste1.txt”);
char ch;
while (fin.get(ch)) // Lê um caractere do arquivo
cout<<ch;

90
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 <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 <stdio.h>
#include <conio.h>

93
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();
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 <stdio.h>
#include <conio.h>
class livro
{
private :
char titulo[50];
char autor[50];
int numreg;
double preco;
public : void novonome();
void print();
};
{
gets(titulo);
cout<<“n digite o autor”;
gets(autor);
cout<<“n digite o número do registro”;
cin>>numreg;

95
cin>>preco;
clrscr();
}
void livro::print()
{
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();
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 <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();
};
{
gets(titulo);
cout<<“n digite autor”;
gets(autor);
cout<<“n digite o número de registros”;
cin>>numreg;

98
cin>>preco;
clrscr();
}
void livro::print()
{
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();
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>
// ------------------------------ 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)
// Str - cadeia de caracteres com a mensagem a ser mostrada
//
gotoxy(X,Y); cout << Str;
return;
}
void Pausa() // Pausa()
{
// objetivo :
// fazer uma pausa, esperando pela digitação de uma tecla

102
PutStr(1,24,"Digite <Enter> para continuar.");
getch();
return;
}
void Terminar() // Terminar()
{
// objetivo :
// informar o termino do processamento
clrscr();
cout << "Terminar ...";
Pausa();
return;
}
BOOLEAN Existir (const char * Nome) // Existir()
{
// objetivo
// verificar a existência de um arquivo,
// cujo nome será' passado como parâmetro
//
// parâmetros :
// Nome - nome externo do arquivo que se quer testar a existência
//
return ((int) (fopen(Nome,"r")));
}
// ------------------------------ Definições de tipos globais
class Agendas
{
public:
typedef struct SData // data completa

103
{
int Dia, Mes, Ano;
}
Datas;
// descrição do registro básico
char Agenda[30]; // nome externo da agenda
char Pessoa[30];
char Endereço[60];
char Telefone[13];
char Aniversario[10];
Agendas(const char * Nome); // construtor padrão
void Ler(void);
void Mostrar(void);
void Criar();
void Listar();
void Procurar();
void Acrescentar();
};
// ------------------------------ Biblioteca especifica
void Agendas::Agendas(const char * Nome) // construtor padrão
{
// objetivo :
// designar um nome externo `a agenda
//
strcpy(Agenda, Nome);
return;
}
void Agendas::Ler(void) // GetReg()
{
// objetivo :
// ler do teclado os campos do registro de uma pessoa

104
//
clrscr();
PutStr(1, 2, "Ler os dados de uma pessoa : ");
PutStr(1, 4, "Nome : "); gets(Pessoa);
if(Pessoa[0] != '.')
{
PutStr(1, 5, "Endereco : "); gets(Endereco);
PutStr(1, 6, "Telefone : "); gets(Telefone);
PutStr(1, 7, "Aniversario : "); gets(Aniversario);
}
else
{
strcpy(Endereco , "");
strcpy(Telefone , "");
strcpy(Aniversario, "");
}
Pausa();
return;
}
void Agendas::Mostrar(void) // PutReg()
{
// objetivo :
// mostrar na tela os campos do registro de uma pessoa
//
if(Pessoa[0] != '.')
{
clrscr();
PutStr(1, 2, "Mostrar os dados de uma pessoa : ");
PutStr(1, 4, "Nome : "); cout << Pessoa;
PutStr(1, 5, "Endereco : "); cout << Endereco;
PutStr(1, 6, "Telefone : "); cout << Telefone;
PutStr(1, 7, "Aniversario : "); cout << Aniversario;
}

105
Pausa();
return;
}
FILE *Agenda; // definição global da variável arquivo
// pois nao pode ser passada como parâmetro
void Agendas::Criar(void) // Criar()
{
// objetivo :
// criar um arquivo em disco,
// com o nome externo que receber como parâmetro
//
// parâmetros :
// Nome - nome externo do arquivo que se quer criar
//
// condições especiais :
// - se um arquivo de mesmo nome já' existir,
// será' dada à opção de nao altera'-lo;
// - se o arquivo nao existir, nao haverá' problemas
char Opção = 'S';
long N=-1;
ofstream Txt(Agenda);
clrscr();
if(Existir(Agenda))
{
PutStr(1,3, "Agenda já' existenn");
PutStr(1,5, "Quer apagar e começar outra [S,N] ? ");
Opcao = GetOption(36,5,"SNsn");
if(Opcao == 'S')
{
cout << "Os dados atuais serão apagados.";
}

106
else
{
cout << "Os dados atuais serão mantidos.";
}
}
if(Opcao == 'S')
{
cout << "Criar ...";
do
{
Ler();
Txt << Pessoa << nl; // writing
Txt << Endereco << nl;
Txt << Telefone << nl;
Txt << Aniversario << nl;
N++; // register counter
}
while(Pessoa[0] != FDA);
clrscr();
PutStr(1, 2, "Agenda criada.n");
cout << N << " registros gravados.n";
}
Pausa();
return;
}
void Agendas::Listar(void) // Listar()
{
// objetivo :
// mostrar os conteúdos de cada registro um arquivo,
// cujo nome será' passado como parâmetro
//
// parâmetros :
// Nome - nome externo do arquivo que se quer mostrar o conteúdo
//

107
long N=-1;
ifstream Txt(Agenda);
clrscr();
cout << "Listar ...";
if(Existir(Agenda))
{
cout << "Listando ...";
do
{
Txt.getline(Pessoa ,30); // lendo
Txt.getline(Endereco ,60);
Txt.getline(Telefone ,13);
Txt.getline(Aniversario,10);
N++; // contando
Mostrar(); // mostrando
}
clrscr();
PutStr(1, 2, "Termino da leitura.");
cout << nl << N << " registros lidos.n";
getch();
}
else
{
PutStr(1,3, "Erro : Agenda nao existe. nn");
}
Pausa();
return;
}
void Agendas::Procurar(void) // Procurar()
{
// objetivo :
// procurar no arquivo,
// cujo nome será' passado como parâmetro,

108
// pelo registro que contenha um determinado nome de pessoa
//
// parâmetros :
// Nome - nome externo do arquivo onde se quer procurar um registro
//
long N=1,P;
char Opção;
char Procurado[30];
fstream Txt;
BOOLEAN Achar=FALSE;
clrscr();
cout << "Procurar ...nn";
cout << "Digite o nome a ser procurado : ";
gets (Procurado);
strcpy(Pessoa, Empty);
Txt.open(Agenda, ios::in | ios::out);
while(Pessoa[0] != FDA && ! Achar)
{
Txt.getline(Pessoa ,30); // lendo
Txt.getline(Endereco ,60);
Txt.getline(Telefone ,13);
Txt.getline(Aniversario,10);
if(strcmp(Pessoa, Procurado) == 0)
Achar = TRUE;
else
{
N++; // contando
P = Txt.tellg(); // guardando onde estava
}
}
if(Achar)
{
Mostrar(); // mostrando
PutStr(1, 10, "Quer alterar (S/N) ?");

109
Opcao = GetOption(22,10,"SsNn");
if(Opcao == 'S')
{
Ler(); // ler os dados novos
Txt.seekg(P, ios::beg); // determinar a posição
Txt << Pessoa << nl; // gravar um novo
}
}
else
{
cout << "Registro nao encontrado. n";
}
clrscr();
PutStr(1, 2, "Termino da procura.");
cout << nl << N << " registros lidos.n";
// realizada a procura
Pausa();
return;
}
void Agendas::Acrescentar(void) // Acrescentar()
{
// objetivo :
// acrescentar registros ao arquivo,
// cujo nome externo será' passado como parâmetro
//
// parâmetros :
// Nome - nome externo do arquivo no qual se quer acrescentar registros
//
long N=-1;
char S[80];
fstream Txt;

110
clrscr();
cout << "Acrescentar ...nn";
Txt.open(Agenda, ios::ate | ios::out);
Txt.seekg(-3, ios::end); // retirar a marca FDA
do
{
Ler();
Txt << Pessoa << nl; // gravar um novo
N++; // contar mais um gravado
}
clrscr();
PutStr(1, 2, "Agenda alterada.n");
cout << N << " registros novos gravados.n";
Pausa();
return;
}
void Menu() // Menu()
{
// objetivo :
// mostrar as opções básicas do programa,
// e receber a escolha da função desejada pelo usuário
char Opção;
Agendas Minha ("Agenda.DAT");
do
{
clrscr();
PutStr(25, 5, "PROGRAMA PARA TRATAR UMA AGENDA");

111
PutStr(35, 7, "OPCOES :");
PutStr(35, 9, "0 - Terminar");
PutStr(35,10, "1 - Criar");
PutStr(35,11, "2 - Listar");
PutStr(35,12, "3 - Procurar");
PutStr(35,13, "4 - Acrescentar");
PutStr(30,16, "Digite sua opção : ");
Opcao = GetOption(50,16,"01234");
switch(Opcao)
{
case '0' : Terminar();
break;
case '1' : Minha.Criar();
break;
case '2' : Minha.Listar();
break;
case '3' : Minha.Procurar();
break;
case '4' : Minha.Acrescentar();
break;
default:
PutStr(1,22, "Opção invalidan");
Pausa();
}
}
while (Opcao != '0');
return;
}
// ------------------------------ Programa principal
void main(void)
{

112
Menu();
return;
}
5 - UNIDADE V
1- Ponteiros
É um endereço de memória. Seu valor indica onde uma variável está armazenada. Um ponteiro
proporciona um modo de acesso a uma variável sem referenciá-la diretamente.
1-1 Por que os ponteiros são usados?
Os ponteiros são usados em situações em que o uso de uma variável é difícil ou indesejável.
Algumas razões para o uso de ponteiros são:
 manipular elementos de matrizes;
 receber argumentos em funções que necessitam modificar o argumento original;
 passar strings de uma função para outra; usá-los no lugar de matrizes;
 criar estruturas de dados complexos, como listas encadeadas e árvore binárias, onde um item
deve referências a outro;
 alocar e deslocar memória do sistema.
1-2 Ponteiros variáveis
Um ponteiro variável armazena um endereço de memória. Este endereço é a
localização de uma outra variável. Dizemos que uma variável aponta para outra variável
quando a primeira contém o endereço da segunda.
1-3 Endereços de memória

113
A memória de seu computador é dividida em bytes, e estes bytes são numerados
de o até o limite de memória de sua máquina. Estes números são chamados endereços de
bytes. Um endereço é a referência que o computador usa para localizar variáveis. Toda
variável ocupa certa localização na memória, e seu endereço é o do primeiro byte ocupado
por ela.
1-4 Operador de endereços &
Este operador é um operador unário e seu operando deve ser o nome de uma
variável, e o resultado é o seu endereço.
Exemplo: Mostra o uso do operador de endereços.
#include <conio.h>
void main()
{
int i,k,j;
clrscr();
cout<<“n “”<<&i;
cout<<“n”<<&j;
cout<<“n”<<k;
getch();
return;
}
Eis a saída:
0xfff4 ----------endereço de i

114
0xfff2 ----------endereço de j
0xfff0 ----------endereço de k
Obs.: 1.O operador << imprime endereços hexadecimal, precedidos pelo prefixo 0x.
2. O operador de endereço(&) só pode ser usado com nomes de variáveis.
Exs: .1- &(i+1) ; // errado
2- &5 ; // errado
1-5 Passando argumentos por referência com ponteiros.
Há três maneiras de passar argumentos para uma função:
- por valor
- por referência
- por ponteiro.
Se uma função deseja alterar variáveis da função chama dora estas variáveis não
podem ser passadas por valor.
Em situações como esta, podem usar referências ou ponteiros. Para usar ponteiros
como argumentos devemos seguir dois passos:
 Primeiro, a função chama dora,em vez de passar valores para a função
chamada, passa endereços usando o operador de endereços. Estes endereços são de
variáveis de função chamadora onde queremos que a função coloque novos valores.
 Segundo lugar, a função chamada deve criar variáveis para armazenar os
endereços enviados pela função chamadora. Estas variáveis são ponteiros.
Exemplo:
#include <conio.h>

115
void reajusta(float *p, float *r)
{
*r=*p*0.2;
*p=p*1.2;
}
void main()
{
float preco,valoreaj;
do
{
cin>>preco;
reajusta(&preco, &valoreaj);
cout<<”n preco novo “<<preco;
cout<<“n aumento =“<<valoreaj;
}
while(preco!=0.0);
getch();
return;
}
1-6 Variáveis que armazena endereços.
Os endereços são armazenados de modo semelhante as variáveis. Semelhante as
variáveis. Uma variável que armazena um endereço é chamado de ponteiro. Observe que um
ponteiro para um float não é do tipo float, mas sim do tipo float *. O asterisco faz parte do
nome do tipo e indica ponteiro para.

116
A declaração dos argumentos da função reajusta() são float *p,float *r indica
que *p e *r sãp do tipo float e que p e r são ponteiros para variáveis float. Na verdade, usar a
*p é uma maneira indireta de usar a variável preco de main(). Toda alteração feita em *p
afetará diretamente preco.
1-7 O operador indireto(*)
É um operador unário que tem como operando um endereço ou ponteiro e resulta no
conteúdo da variável localizada no endereço(ponteiro) operando. Em outras palavras, resulta
da variável apontada.
1-8 Passando endereços para a função.
A função main() chama a função reajusta() por meio da seguinte instrução:
reajust(&preco,&valoreaj);
Os endereços das variáveis preco e valoreaj são enviados como argumentos. O
operador de endereços (&) é usado para obter estes endereços.
A função reajusta() recebe estes valores em ponteiros. Para que esta função possa
acessar as variáveis apontadas, deve não somente conhecer o endereço da variável como
também o seu tipo, o qual indica o tamanho em bytes e a forma de armazenamento. O tipo da
variável apontada é dado na declaração do ponteiro.
1-9 Ponteiros sem funções.
Exemplo: Mostra o uso de ponteiros automáticos.
#include <conio.h>
void main()
{

117
int x,y;
x=4; y=7;
cout<<“n &x=“<<&x<<“x=“<<x;
cout<<“n&y=“<<&y<<“y=“<<y;
int *px,*py;
px=&x;
py=&y;
cout<<“px=“<<px<<“*px=“<<*px;
cout<<“<<py=“<<py<<“*py=“<<*py;
cout<<“naperte enter”:
getch();
return;
}
Eis a saída:
&x= 0xfff4 x=4
&y= 0xfff2 x=7
px= 0xfff4 *px=4
py= 0xfff2 *py=7
Obs.: Quando um ponteiro não é inicializada na instrução de sua declaração, o
compilador inicializa-o com o endereço zero(null). C++ garante que null não é um endereço
válido, então antes de usá-los devemos atribuir a eles algum endereço válido.
1-10 Ponteiros e variáveis apontadas.
Exemplo: Mostra o uso de ponteiro automáticos.

118
#include <conio.h>
void main()
{
int x,y;
int *px=&x; // inicializa p com o endereço de x
*p=14; // o mesmo que x=14
y=*p; // o mesmo que y=x
cout<<“n y=“<<y ;
getch();
return;
}
Observação: A instrução y=*p; indica o valor da variável apontada.
1-11 Atribuição
Um endereço pode ser atribuído a um ponteiro.
Exemplo:
px=&x; //Atribuímos o endereço de x a px
py=&y;
1-12 Operação Indireta
O operador indireto (*) precedendo o nome do ponteiro resulta no valor da
variável apontada.
1-13 Trazendo o endereço do ponteiro.

119
Como as variáveis, os ponteiros tem um endereço e um valor. O ponteiro (&)
precedendo o nome do ponteiro resulta na posição de memória onde o ponteiro está
localizado.
O nome do ponteiro indica o valor contido nele, isto é, o endereço para o
qual ele aponta( o endereço da variável apontada).
Exemplo: Ordenar quatro valores numéricos usando ponteiros.
#include<conio.h>
using namespace std;
void troca(float* a, float* b)
{
float aux;
aux=*a;
*a=*b;
*b=aux;
}
int main()
{
float n1,n2,n3,n4;
cout<<"n digite 4 valores ";
cin>>n1>>n2>>n3>>n4;
if(n1>n2)
troca(&n1,&n2);
if(n1>n3)
troca(&n1,&n3);
if(n1>n4)
troca(&n1,&n4);

120
if(n2>n3)
troca(&n2,&n3);
if(n2>n4)
troca(&n2,&n4);
if(n3>n4)
troca(&n3,&n4);
cout<<"nn1= "<<n1<<" n2 = "<<n2<<" n3= "<<n3<<" n4= "<<n4;
cout<<"n";
system("pause");
}
1-14 Incremento em ponteiro.
Incrementar um ponteiro acarreta sua movimentação para o próximo tipo
apontado; isto é, se px for um ponteiro para uma variável int, depois de executar a instrução
px++ o valor de px será incrementado de um int(dois bytes). Cada vez que px é
incrementado, apontará para o próximo int da memória. A mesma idéia é verdadeira para
decrementar.
1-15 Ponteiro no lugar de matrizes.
Exemplo: Imprimir os valores dos elementos de uma matriz.
#include <conio.h>
void main()
{
int m[5]={92,81,70,69,58};
int i;
for(i=0;i<5:i++)

121
cout<<“n “<<*(m+i);
getch();
return;
}
Onde: *(m+i) tem o mesmo valor de m[i]. Você já sabe que m é um ponteiro int e
aponta para m[0], conhecendo também a aritmética com ponteiros. se somarmos 1 a m,
obtemos o endereço de m[1], m+2 é o endereço de m[2] e assim por diante.Em regra geral,
temos que: m+i é equivalente a &m[i], portanto *(m+i) é equivalente a m[i].
1-16 Ponteiros constantes e ponteiros variáveis.
Na instrução cout<<“n”<<*(m+i); não pode ser substituída pela instrução
cout”n”<<*(m++); pois não podemos incrementar uma constante.
O nome de uma matriz é um ponteiro constante e não pode ser alterado.
Um ponteiro variável é um lugar na memória que armazena um endereço. Um ponteiro
constante é um endereço, uma simples referência.
Exemplo: Imprimir os elementos de uma matriz.
#include <conio.h>
void main()
{
int m[5]={92,81,70,69,58};
int *p=m;
int i;
for (i=0;i<5;i++)
cout<<“n”<<*(p++);

122
cout<<“aperte enter”;
getch();
return;
}
Onde: - A instrução int *p=m inicializa o ponteiro com o nome da matriz m. Agora
podemos usar p em todo lugar do programa que sua m e, como p é um ponteiro variável e
não uma constante, podemos usar a expressão como: *(p++); onde p contém inicialmente o
endereço do primeiro elemento da matriz.
1-17 - Passando matrizes como argumento para funções.
Exemplo:
#include <conio.h>
int media(int *lista,int tamanho)
{
int i,m;
m=0;
for(i=0;i<tamanho;i++)
m=m+*lista++;
return (m/tamanho);
}
void main(void)
{
const maxi=20;
int i,notas[maxi],m;
for(i=0;i<maxi;i++)
{

123
cout<<“n digite a nota :”<<i;
cin>>*(notas+i);
if(*(notas+i)<0)
break;
clrscr();
}
m=media(notas,i);
cout<<“n media : “<<media;
getch();
return;
}
Obs: 1. Na instrução int *lista é equivalente a original int lista[]
2. visto que o nome da matriz é um endereço, não há necessidade de usar o
operador(&0 na instrução int m=media(notas,i).
1-18 Precedência
O operador ponteiro e o de incremento tem a mesma precedência> Os operadores
da mesma precedência são resolvidos por associação.
1-19 Ponteiros e strings.
Exemplo: Procurar um caracter numa mesma cadeia de caracteres.
#include <conio.h>
#include <stdio.h>
char *procura(char *s,char ch)

124
{
while(*s!=ch && *!=‘o’)
s=s+1;
if(*s!=‘o’)
return s;
else return(char *)0;
void main(void)
{
char ch, str[81],*ptr;
cout<<‘n digite uma frase : “;
gets(sr);
ptr=procura(str,’h’);
cout<<“n a frase começa no endereço “<< unsigned(ptr);
if(ptr)
{
cout<<“n primeira ocorrência do caracter h é :”<<unsigned(ptr);
cout<<“n A sua posição é : “<<unsigned(ptr-str);
}
else cout<<“n Não existe o caracter h”;
getch();
return;
}
1-20 Matrizes de ponteiros.
Exemplo: Imprime o dia da semana a partir de uma data.
#include <conio.h>

125
int dsemana(int dia, int mes, int ano)
{
int f = ano+dia+3*(mes-1) - 1;
if(mes<3)
ano=ano-1;
else f=f-int(0.4*mes+2.3);
f=f+int(ano/4) - int((ano/100 +1)*0.75);
f=f%7;
return (f);
}const char esc=27;
void main()
{
char
*diasemana[7]={“domingo”,”segunda”,”terça”,”quarta”,”quinta”,”sexta”,”sabado”};
int dia,mes,ano,i;
do
{
cout<<“n digite a data dd mm aaaa : “;
cin>>dia>>mes>>ano;
i=(dsemana(dia,mes,ano);
cout<<‘n “<<diasemana[i];
}
while(getch()!=esc);
getch();
return;
}
1-21 Área de alocação dinâmica: HEAP.

126
Á area de alocação dinâmica também chamada HEAP. Consiste em toda
memória disponível que não foi usada para outro propósito. Em outras palavras, o HEAP é
simplesmente o resto da memória.
C++ oferece dois operadores que permitem a alocação ou a liberação dinâmica
de memória de HEAP, new e delete.
O operador new obtém memória do sistema operacional e retorna um
ponteiro para o primeiro byte do novo bloco de memória que foi alocado.Uma vez alocada,
esta memória continua ocupada até que seja deslocada explicitamente pelo operador delete.
Uma variável criada pelo operador new existirá e poderá ser acessada por qualquer parte do
programa enquanto não for destruída pelo operador delete e seu retorno ao banco de memória
disponível.
Exemplo: Mostra a classe string modificada.
#include <conio.h>
#include <string.h>
class string
{
private : char *str;
public : string()
{
str=new char;
*str=‘0’;
}
string(char *s)
{
str=new(char[strlen(s) + 1];
strcpy(str,s);

127
}
~string()
{
if(str)
delete str;
}
void print()
{
cout<<str;
}
};
void main()
{
string s=“ A vida é uma longa estrada na qual”
“ corremos contra o tempo”;
strins s1;
cout<<“n”;
s. print();
cout<<“n”;
s1. print();
}
saída:
A vida é uma longa estrada na qual corremos contra o tempo.
Onde: A instrução str = new char[ strlen(s) +1 ];
retorna um ponteiro p/ um bloco de memória do tamanho exato p/ armazenar a cadeia
s mais o ‘a’. strcpy() copia a cadeia s p/ a nova memória reservada, apontada por str.
 st = new char reserva um único byte de memória.
 se não houver memória suficiente o operador new devolverá um ponteiro com o
valor zero (NULL).

128
~ string ()
{
if (str)
delete str;
}
Verifica se a memória foi alocada por new antes de liberar; caso contrário aponte para
endereço zero.
A função testa se o endereço do objeto é o mesmo do contido no ponteiro this.
1-22 Retornando o ponteiro this
Retorna um valor de uma função membro ou de uma função que sobrecarrega um
operador.
Exemplo:
string & operator = (const string & s )
{
if (&s = = this)
return * this;
int tamanho = strlen ( s.str );
delete str;
str = new char [ tamanho +1 ];
strcpy (str, s.str);
return;
}
1-23 Dimensionando matrizes em tempo de execução
Exemplo:
# include <iostream.h>
# include <conio.h>
int media (int *lista, int tamanho)

129
{
int m, i;
for(i = 0;i < tamanho; i++)
m=m + *lista++;
return( m/ tamanho);
}
void main()
{
int tamanho, *notas, i, m;
cout<<“n Digite o nº de notas” ;
cin>>tamanho;
notas = new int [tamanho];
notas = new int [tamanho][3];
.
.
.
.
delete[] notas;
Obs.: Você pode alocar uma matriz multidimensional com new, mas somente a
primeira dimensão pode ser definida em tempo de execução; as outras de um ser constantes.
int (*notas)[3];

130
EXERCÍCIOS PROPOSTOS
1 - Faça um programa que some os números pares de 0 (zero) até 100 e imprima o
resultado.
2 - Fazer um programa que leia um número indeterminado de cartões contendo cada
um a idade de um indivíduo. O último cartão, que não entrará nos cálculos, contém o valor de
idade igual à zero. Calcule e imprima a idade média deste grupo de indivíduos.
3 - Tem-se um conjunto de dados contendo a altura e o sexo (masculino ou
feminino) de 50 pessoas. Fazer um programa que calcule e imprima:
- A maior e a menor altura do grupo;
- A média de altura das mulheres;
- O número de homens
4 - Um comerciante deseja fazer o levantamento do lucro das mercadorias que ele
comercializa. Para isto, mandou perfurar em carões (um para cada mercadoria) o nome,
preço de compra e preço de venda das mesmas. Fazer um programa que:
- Determine e escreva quantas mercadorias proporcionam:
lucro < 10%
10% < = lucro < = 20%
lucro > 20%
- Determine e escreva o valor total de compra e de venda de todas as
mercadorias assim como o lucro total.

131
obs.: O aluno deve adotar um flag.
5 - Uma firma fez uma pesquisa de mercado para saber se as pessoas gostaram ou
não de um novo produto lançado no mercado. Para isto, perfurou-se em cartões o sexo do
entrevistado e sua resposta (sim ou não). Sabendo-se que foram entrevistadas 200 pessoas,
fazer um programa que calcule e imprima;
- O número de pessoas que responderam sim;
- O número de pessoas que responderam não;
- A porcentagem de homens que responderam não;
- A porcentagem de mulheres que responderam sim;
6 - Deseja-se fazer um levantamento a respeito da ausência de alunos à primeira
prova de programação de computadores para cada uma das 14 turmas existentes. Para cada
turma foi perfurado um conjunto de cartões, sendo que o primeiro cartão do conjunto contém
a identificação da turma (a,b,c) e o numero de alunos matriculados, e os demais cartões
contêm o número de matrícula do aluno e a letra A ou P para o caso do aluno estar ausente
ou presente, respectivamente. Fazer um programa que:
- Para cada turma, calcule a porcentagem de ausência e escreva a identificação
da turma e a porcentagem calcula;
- Determine e escreva qtas turmas tiveram porcentagem de ausência superior
a 5%.
7 - Fazer um programa que calcule e escreva o seguinte somatório
S = 1 + 3/2 + 5/3 + 7/4 + . . . +99/50;
8 - Fazer um programa que calcule e escreva o seguinte somatório:
S = 1 + 3 + 5 + 7 + 9 + 11 + . . . + 199
9 - Uma companhia de teatro planeja dar um série de espetáculos. A direção calcula
que, a R$50,00 o ingresso, serão vendidos 120 ingressos, e as despesas montarão em
R$200,00. A diminuição de R$5,00 no preço do ingresso, espera-se que haja um aumento de

132
26 ingressos vendidos. Fazer um programa que escreva uma tabela de valores do lucro
esperado em função do preço do ingresso, fazendo variar este preco de R$5,00 a R$1,00 de
R$0,50 em R$0,50. Escreva ainda, o lucro máximo esperado, o preço e o número de
ingressos correspondentes.
10 - Uma determinada fábrica de rádios possui duas linhas de montagem distintas:
Standard e luxo. A linha de montagem Standard comporta no máximo 32 operários; cada
rádio luxo dá um lucro de Y reais e gasta dois homens por dia para sua confecção. A fábrica
possui 40 operários. O mercado é capaz de absorver toda a produção, e o fabricante deseja
saber qual esquema de produção adotar de modo a maximizar seu lucro diário.
Fazer um programa que leia os valores de X e Y e escreva, para esse esquema
de lucro máximo, o número de operários na linha Standard e na linha de luxo, o número de
rádios Standard e luxo produzidos e o lucro.
11 - Uma empresa deseja calcular os salários de seus empregados, e para isto,
perfurou em cartões magnéticos os seguintes dados:
 matrícula;
 nome do empregado;
 valor de horas normais;
 número de horas normais;
 número de horas extras;
 número de dependentes;
 convênio (1 - tem convênio, 2 - não tem convênio);
Faça um programa que leia um número indeterminado de cartões, usando como
FLAG o cartão com matrícula igual a 0 (zero), e calcule:
salário bruto = (vr. hora normal * nº. de horas normais) +
(vr. hora norma * 1.20) * nº. de horas extras +
(nº. de dependentes * 500);

133
descontos:
IMPOSTO DE
RENDA:
sal. bruto < 1000,00 isento
1000,00 <= sal. bruto < 2000,00 5%
2000,00 <= sal. bruto < 4000,00 8%
sal. bruto >= 4000,00 10%
INSS: sal. bruto < 1000,00 8%
1000,00 <= sal. bruto < 2000,00 9%
sal. bruto >= 2000,00 10%
DESCONTO
CONVÊNIO
75,00.
Obs.: Se o empregado fez mais de 50 horas extra e trabalhou às 240 horas
normais, receberá um prêmio de 2000,00, que será somado ao seu salário líquido. (sal.
líquido = sal. bruto - descontos).
O programa deverá imprimir para cada empregado: matrícula, nome, salário
bruto, imposto de renda, INSS, vr. do convênio e salário líquido.
Deverá também imprimir os seguintes totais: total de salário bruto, total
salário líquido, total INSS, total imposto de renda.
12 - Fazer um programa que calcule o imposto de renda de um grupo de
contribuintes:
a) os dados de cada contribuinte, número do CPF, número de dependentes e
renda anual, estão perfurados em cartão.
b) para cada contribuinte será feito um desconto de 70,00 por dependente.
c) os valores da alíquota para o cálculo do imposto são:
Renda Alíquota
até 10000,00 isento

134
de 10000,00 a
15000,00
5%
de 15000,00 a
30000,00
10%
de 30000,00 a
50000,00
15%
acima de 50000,00 20%
Obs.: a última pessoa que não entrará nos cálculos tem CPF igual a 0 (zero).
13 - Elabore um programa para ler do teclado um número inteiro e positivo n e um
número real x, calcular e escrever a soma dos n prime rios termos da serie:
0 3 6 9 12 15
Z = X/1! - X/2! + X/4! - X/6! + X/8! - X/10! + . . .
14 - Fazer um programa que calcule e escreva o valor de S:
S = 1/1 + 3/2 + 5/3 + 7/4 + . . . + 99/50
15 - Fazer um programa que calcule e escreva o valor da soma:
1 2 3 4 50
S = 2/50 + 2/49 + 2/48 + 2/47 + . . . + 2/1
16 - Fazer um programa que calcule e escreva o valor de S onde:
S = 37*38/1 + 36*37/2 + 35*36/3 + . . . +1*2/37
17 - Fazer um programa que calcule e escreva o valor de S onde:

135
S = 1/1 - 2/4 + 3/9 - 4/16 + . . . + 10/100
18 - Fazer um programa que calcule e escreva a soma dos 30 primeiros termos da
série:
S = 1000/1 - 997/2 + 994/3 - 991/4 + . . .
19 - Fazer um algoritmo que calcule e escreva a soma dos 50 primeiros termos da
série:
S = 480/10 - 470/11 + 460/12 - 450/13 + . . .
20 - Escreva um programa para gerar e escrever uma tabela com os valores do seno
de um ângulo em radianos, utilizando a série de Mca-Laurin truncada, apresentada a seguir:
3 5 7
Sen =  - /6 + /120 - /5040
Obs.: Os valores dos ângulos  devem variar de 0,0 a 6,3 inclusive 0 e 6,3 de 0,1 em
0,1.
21 - Fazer um programa para calcular e escrever o valor do número  (pi), com
precisão de 0.0001, usando a série:
PI = 4 - 4/3 + 4/5 - 4/7 + 4/9 - . . .

Apostila c++

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (17)

Destaque

Destaque (12)

Semelhante a Apostila c++

Semelhante a Apostila c++ (20)

Apostila c++