apostila c++.DOC
-
Upload
samir-aziz-farah -
Category
Documents
-
view
263 -
download
0
Transcript of apostila c++.DOC
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
3
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
13.3 Estrutura Do-
While.......................................................................pg-25
4
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
1.1Chamando um
função........................................................................pg-35
1.2 Funções
simples................................................................................pg-35
5
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
1.14 O operador de
escopo.....................................................................pg-42
1.15 Funções
recursivas.........................................................................pg-43
6
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
1.8.1declarando a matriz de
estruturas..................................................pg-49
1.9.0
Arquivos.........................................................................................pg-53
1.9.1 Classes
iostream.............................................................................pg-53
7
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
1.0
Ponteiros............................................................................................pg-69
1.1 Por que os ponteiros são
usados.......................................................pg-69
1.2 Ponteiros
variáveis............................................................................pg-70
8
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
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
9
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
10
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
É formado por qualquer seqüência de caracteres e vem entre aspas duplas.
11
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.
12
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;
float med;
13
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
14
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
+ soma
- subtração
* multiplicação
15
/ 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.
Ex.: cin >> anos >> altura
Tela
26 1.70 anos 26
16
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
4.2 - Saída
cout << identificador << . . .
Onde: Identificadores são os nomes das variáveis e/ou mensagem.
<< operador de inserção.
a
A
n
n
a
a
p
P
a
a
u
u
l
l
a
a
17
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:
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;
18
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 (.).
- acrescentar:
cout << setfill(' . ');
cout << '\n'<<"lapis"<<setw(12)<<lap;
.
.
.
.
19
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
.
.
.
{
cout << "\n\n\n";
cout << "objeto"<<setw(12)<<"codigo"<<'\n';
cout <<'\n'<< "lapis"<<setw(12)<<"WQR";
cout << '\n'<< "borracha"<<setw(12)<<"ASO";
.
.
.
}
20
#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)
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
21
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:
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 ( | | )
22
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) * =
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
23
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
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: ? :
24
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
#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;
25
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;
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:
26
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;
}
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.:
27
#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
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
28
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 */
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;
29
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;
}
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;
30
else y = y+3;
2) Mais de uma instrução
if (expressão de teste)
{
instrução1a;
. . .
instrução na;
}
else {
instrução1b;
. . .
instrução nb;
}
Ex2.:
if (sexo = ='f')
{
nm = nm + 1;
k = k+i;
}
else {
nh = nh +1;
y = y+i;
}
31
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 ";
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)
32
{
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;
}
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)
33
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;
}
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.
34
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.
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;
35
}
if (alt < me)
{
me = alt;
aux2 = sexo;
}
clrscr( );
}
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;
}
36
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.
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 ";
37
cin >> id;
clrscr( );
}
if (np!=0)
{
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);
38
while(strcmpi(no,”fim”)) //executa enquanto o nome diferente de fim
{
cout<<“\n digite a idade e o sexo”;
cin>>id>>sexo;
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
39
{
instrução;
instrução;
} 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;
40
m1=no;
aux1=cod;
}
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;
41
do
{
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;
42
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:
43
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 ";
getch( );
return;
44
}
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.
45
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
#include <conio.h>
#include <iostream.h>
46
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;
break;
default : cout<<"\nDigitou o canal errado ";
}
clrscr();
cout<<"\nDigite outro canal e canal = 0 para ";
47
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;
}
48
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++)
{
49
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++)
{
cout<<"\nDigite um numero inteiro "<<(i+1)<<" : ";
50
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
tipo nome-da-variável [nl] [nc];
51
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";
getch( );
return;
}
52
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 ";
getch( );
return;
}
UNIDADE - III
53
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;
}
void main(void)
{
int c,f;
cout<<"\nDigite a temperatura em graus Fahrenheit ";
54
cin>>f;
c=Celsius(f);
cout<<"\n Celsius = "<<c;
cout<<"\n Aperte qualquer tecla";
getch( );
return;
}
55
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);
56
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;
}
1.8 - Passagem por valor
57
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)
{
int m,n;
cout<<"\nDigite a ordem, M<=20 e N<=10 ";
58
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;
}
return so;
}
void main(void)
59
{
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;
}
60
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";
retangulo(12,12);
61
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;
saídas: 5 e 8
62
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)
{
float preco,valreaj;
do
63
{
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 ";
cin>>n1>>n2>>n3;
if(n1>n2)
troca(n1,n2);
if(n1>n3)
64
troca(n1,n3);
if(n2>n3)
troca(n2,n3);
cout<<"\nn1 = "<<n1<<" n2 = "<<n2<<" n3 = "<<n3;
cout<<"\n Aperte qualquer tecla";
getch( );
}
65
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
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
66
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;
cout<<"\nAperte enter ";
getch( );
return;
}
saída: i = 0 j = 234
i = 25 j = 48
1.14 - O Operador de escopo : :
67
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( );
}
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)
68
{
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é 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:
69
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;
}
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
70
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
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
71
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
{
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
72
struct
{
membros;
} nome-das-variáveis;
73
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
{
int pecas;
74
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;
float preco;
data diavenda;
75
};
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>
struct venda
{
76
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( )
{
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;
77
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
4
5
struct cliente
{
char nome[25];
78
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
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
79
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;
long codigodesejado;
clrscr( );
for (i=0;i<=99;i++)
{
cout<<“\ndigite o nome”<<i;
gets(tab[i].no);
cout<<“\ndigite o código”<<i;
80
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:
- 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
81
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
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)
82
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;
};
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];
83
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;
}
cout<<“\nDigite a identificação”;
gets(imovel.ident);
}
cout<<‘\nAperte qualquer tecla”;
getch( );
return;
}
84
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.
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”;
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.
85
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 testo
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;
}
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.
86
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>
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.
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>
void main()
{
ofstream fout(“teste1.txt”);
char ch;
while(cin.get(ch)) // Lê um caracter do teclado
fout.put(ch);
}
87
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 <fstream.h>
void main()
{
ifstream fin(“teste1.txt”);
char ch;
while (fin.get(ch)) // Lê um caractere do arquivo
cout<<ch;
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
88
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().
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 <stdio.h>
#include <conio.h>
class livro
{
private :
char titulo[50];
char autor[50];
int numreg;
double preco;
public :
void novonome();
89
};
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();
}
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;
90
- 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>
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;
91
clrscr();
while(fin.read((char *)&li,sizeof(livro)))
li.print();
cout<<“\n aperte qualquer tecla”;
getch();
return;
}
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>
class livro
{
private :
char titulo[50];
char autor[50];
int numreg;
double preco;
public : void novonome();
void print();
};
void livro::novonome()
{
92
cout<<“\n digite titulo”;
gets(titulo);
cout<<“\n digite o autor”;
gets(autor);
cout<<“\n digite o número do registro”;
cin>>numreg;
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”;
93
cout<<“\n ===================================“;
while(fio.read((char * )&li,sizeof(livro)))
li.print();
cout<<“\n aperte enter”;
getch();
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
94
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.
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”;
95
gets(autor);
cout<<“\n digite o número de registros”;
cin>>numreg;
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();
96
return;
}
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.
97
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 :
// X - coluna (ate' 80)
98
// 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
PutStr(1,24,"Digite <Enter> para continuar.");
getch();
99
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
{
int Dia, Mes, Ano;
}
100
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
//
clrscr();
PutStr(1, 2, "Ler os dados de uma pessoa : ");
101
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;
}
Pausa();
return;
}
FILE *Agenda; // definição global da variável arquivo
102
// 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á\' existe\n\n");
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.";
}
else
{
cout << "Os dados atuais serão mantidos.";
}
}
103
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
//
long N=-1;
ifstream Txt(Agenda);
clrscr();
cout << "Listar ...";
if(Existir(Agenda))
{
104
cout << "Listando ...";
do
{
Txt.getline(Pessoa ,30); // lendo
Txt.getline(Endereco ,60);
Txt.getline(Telefone ,13);
Txt.getline(Aniversario,10);
N++; // contando
Mostrar(); // mostrando
}
while(Pessoa[0] != FDA);
clrscr();
PutStr(1, 2, "Termino da leitura.");
cout << nl << N << " registros lidos.\n";
getch();
}
else
{
PutStr(1,3, "Erro : Agenda nao existe. \n\n");
}
Pausa();
return;
}
void Agendas::Procurar(void) // Procurar()
{
// objetivo :
// procurar no arquivo,
// cujo nome será' passado como parâmetro,
// 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;
105
char Procurado[30];
fstream Txt;
BOOLEAN Achar=FALSE;
clrscr();
cout << "Procurar ...\n\n";
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) ?");
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
Txt << Endereco << nl;
Txt << Telefone << nl;
Txt << Aniversario << nl;
106
}
}
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;
clrscr();
cout << "Acrescentar ...\n\n";
Txt.open(Agenda, ios::ate | ios::out);
Txt.seekg(-3, ios::end); // retirar a marca FDA
do
{
Ler();
Txt << Pessoa << nl; // gravar um novo
Txt << Endereco << nl;
107
Txt << Telefone << nl;
Txt << Aniversario << nl;
N++; // contar mais um gravado
}
while(Pessoa[0] != FDA);
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");
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)
108
{
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 invalida\n");
Pausa();
}
}
while (Opcao != '0');
return;
}
// ------------------------------ Programa principal
void main(void)
{
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.
109
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
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.
110
#include <iostream.h>
#include <conio.h>
void main()
{
int i,k,j;
clrscr();
cout<<“\n “”<<&i;
cout<<“\n”<<&j;
cout<<“\n”<<k;
cout<<“\n aperte enter”;
getch();
return;
}
Eis a saída:
0xfff4 ----------endereço de i
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
111
- 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>
#include <iostream.h>
void reajusta(float *p, float *r)
{
*r=*p*0.2;
*p=p*1.2;
}
void main()
{
float preco,valoreaj;
do
{
cout<<“\n digite o preco”;
cin>>preco;
reajusta(&preco, &valoreaj);
cout<<”\n preco novo “<<preco;
cout<<“\n aumento =“<<valoreaj;
112
}
while(preco!=0.0);
cout<<“\n aperte enter”;
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.
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.
113
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>
#include <iostream.h>
void main()
{
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
114
&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.
#include <iostream.h>
#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 ;
cout<<“\n aperte enter”;
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.
115
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.
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).
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>
116
#include <iostream.h>
void main()
{
int m[5]={92,81,70,69,58};
int i;
for(i=0;i<5:i++)
cout<<“\n “<<*(m+i);
cout<<“\n aperte enter”;
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>
#include <iostream.h>
void main()
{
117
int m[5]={92,81,70,69,58};
int *p=m;
int i;
for (i=0;i<5;i++)
cout<<“\n”<<*(p++);
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>
#include <iostream.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)
{
118
const maxi=20;
int i,notas[maxi],m;
for(i=0;i<maxi;i++)
{
cout<<“\n digite a nota :”<<i;
cin>>*(notas+i);
if(*(notas+i)<0)
break;
clrscr();
}
m=media(notas,i);
cout<<“\n media : “<<media;
cout<<“\n aperte enter”;
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>
119
#include <iostream.h>
#include <stdio.h>
char *procura(char *s,char ch)
{
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”;
cout<<“\n aperte enter”;
getch();
return;
}
1-20 Matrizes de ponteiros.
Exemplo: Imprime o dia da semana a partir de uma data.
120
#include <conio.h>
#include <iostream.h>
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);
cout<<“\n aperte enter”;
getch();
return;
}
121
1-21 Área de alocação dinâmica: HEAP.
Á 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 <iostream.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);
122
}
~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).
123
~ 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)
{
124
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];
125
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.
obs.: O aluno deve adotar um flag.
126
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 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
127
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);
descontos:
IMPOSTO DE
RENDA:
sal. bruto < 1000,00 isento
128
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
de 10000,00 a
15000,00
5%
de 15000,00 a
30000,00
10%
129
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:
S = 1/1 - 2/4 + 3/9 - 4/16 + . . . + 10/100
130
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 - . . .
Para obter a precisão desejada, adicionar apenas os termos cujo valor
absoluto seja maior ou igual a 0.0001.
22 - Fazer um programa que:
- leia o valor de x de uma unidade de entrada;
- calcule e escreva o valor do seguinte somatório:
131
25 24 23 22
S = X/1 - X/2 + X/3 - X/4 + . . . + X/25
23 - Fazer um programa que calcule e escreva o valor de S no seguinte somatório:
S = 1/225 - 2/196 + 4/169 - 8/144 + . . . + 16384/1
24 - Fazer um programa que calcule e escreva a soma dos 30 primeiros termos da
série:
100/0! + 99/1! + 98/2! + 97/3! + . . .
25 - Fazer um programa que:
- calcule e escreva o valor da série abaixo com precisão menor que um
décimo de milésimo (0.0001);
- indique quantos termos forma usados.
S = 63+61/1! + 59/2! + 57/3! + . . .
26 - Fazer um programa que calcule e escreva a soma dos 50 primeiros termos da
série:
S = 1!/1 - 2!/3 + 3!/7 - 4!/15 + 5!/31 - . . .
27 - Fazer um programa para determinar e escrever soma dos n primeiros termos
da série:
2 4 6
S = X - X/3! + X/5! - X/7! + . . .
132
onde: x e n são lidos.
28 - Fazer um programa que:
- calcule o valor do co-seno de X através de 20 termos da série abaixo:
2 4 6 8
Cassino X = 1 - X/2! + X/4! - X/6! + X/8! - . . .
- calcule a diferença entre o valor calculado no item anterior e o valor
fornecido pela função Cos(X);
- escreva o que foi calculado nos itens anteriores.
29 - Fazer um programa que:
- leia um conjunto de linhas contendo cada uma um número inteiro, na base
10 de até cinco dígitos. A última linha contém o valor zero.
- transforme esse número da base 10 para a base 2;
- escreva o número na base 10 e na base 2.
Variável Composta
1 - Fazer um programa que:
- Leia 100 valores numéricos e armazene numa variável composta
unidimensional A;
- Calcule e escreva:
100
S = i/a[i], onde i é o i-ésimo valor armazenado na variável A;
i=1
- Calcule e escreva quantos termos da série tem o valor do numerador
inferior ao denominador.
Exemplo:
133
A
2
5
5
6
7
7
.
. .
8
8
1 2 3 100
somatório = 1/25 + 2/56 + 3/77 + . . . + 100/88
2 - Fazer um programa que:
- Leia duas variáveis compostas unidimensional, contendo, cada uma 200
elementos numéricos;
- Intercale os elementos destes dois conjuntos formando uma nova variável
composta unidimensional de 400 elementos;
- Escreva o novo conjunto, assim obtido.
3 - Em uma cidade do interior, sabe-se que de janeiro a abril de 1.976 (121 dias)
não ocorreu temperatura inferior a 15 graus centígrados nem superior a 40 graus
centígrados. As temperaturas verificadas em cada dia estão disponíveis em uma unidade de
entrada de dados.
- Fazer um programa que calcule e imprima:
a menor temperatura ocorrida;
a maior temperatura ocorrida;
a temperatura média;
o numero de dias nos quais a temperatura foi inferior a temperatura
média.
4 - Fazer um programa que:
a) leia uma frase de 80 caracteres, incluindo brancos;
b) conte quantos brancos existem na frase;
c) conte quantas vezes à letra aparece;
d) conte quantas vezes ocorre um mesmo par de letras na frase e quais são
elas
134
e) imprima o que foi calculado nos itens b, c e d.
5 - Fazer um programa que:
a) leia o valor de N (N < = 1000) e os n valores de uma variável A
composta de valores numéricos, ordenados de forma crescente;
b) determine e imprima para cada número que se repete no conjunto à
quantidade de vezes que ele aparece repetido;
c) elimine os elementos repetidos formando um novo conjunto;
d) imprima o conjunto obtido no item C.
6 - Dado um conjunto de 100 valores numéricos disponíveis num meio de
entrada qualquer, fazer um a programa para armazená-los numa variável composta B,
calcular e imprimir o valor do somatório dado a seguir:
Exemplo:
B
2
10
1
60
.
. .
3
3
9
7
1 2 3 100
S = (210-97) + (160-33) + . . .
7 - Fazer um programa que:
- leia o valor de M (M < = 30) e os M valores de uma variável composta A;
- leia o valor de N (N < = 20) e os N valores de uma variável composta B;
- determine o conjunto C=A B (união de A com B), onde C não deverá
conter elementos repetidos (A e B não contém elementos repetidos);
- escreva os elementos contidos em A, B e C.
7 - Seja
135
P = anxn + an-1xn-1 + an-2xn-2 + . . . + a1x + a0
Escrever um programa que:
- leia o valor de n, sendo n < = 20;
- leia os coeficientes ai, i = 0,1,2, . . ., n;
- calcule o valor de p para 10 valores de x, lidos em cartões;
- escreva o valor de x e o valor de p correspondente.
8 - Fazer um programa que:
a) leia um conjunto de valores inteiros correspondentes a 80 notas dos
alunos de uma turma, notas estas que variam de 0 a 10;
b) calcule a freqüência absoluta e a freqüência relativa de cada nota;
c) imprima uma tabela contendo os valores das notas (de 0 a 10) e suas
respectivas freqüências absoluta e relativa;
Obs.: 1 - freqüência absoluta de uma nota e o número de vezes que ela aparece no
conjunto de dados;
2 - freqüência relativa é a freqüência absoluta dividida pelo numero total de
dados.
9 - Uma grande firma deseja saber quais os três empregados mais recentes. Fazer
um programa para ler um número indeterminado de cartões no máximo de 300, contendo o
numero do empregado e o número de meses de trabalho deste empregado e escrever os três
mais recentes.
10 - Fazer um programa que:
- leia uma variável composta A com 30 valores numéricos;
- leia outra variável composta B com 30 valores numéricos;
- leia o valor de X;
- verifique qual elemento de A que é igual a X;
136
- escreva o elemento de B de posição correspondente a do elemento de A
igual a X;
11 -Dados as variáveis compostas A e B abaixo:
A
2 5 7 9
5 1 6 9
B
0 2 3 7
2 6 8 9
Calcular o conjunto C=A+B
12 - Fazer um prog. em c++ que leia duas variáveis compostas de dimensão
m*n(m<=20,n<=30). Onde os valores de m e n são lidos. Calcule e escreva:
- a soma dos elementos das matrizes.
13 - Fazer um prog. em c++ que leia uma matriz numérica Am*n(m<=20,n<=10).
Onde m e n são lidos. Calcule e escreva:
- a matriz transposta de A.
14 - Fazer um prog. que leia uma matriz numérica Am*n(m<=20,n<=10). Onde m e
n são lidos. Calcule e escreva uma matriz modificada B(m*n+1), sendo que os elementos
de (n+1)-és ima coluna são formados com o produto dos elementos da mesma linha.
Exemplo:
A
137
2 3
4 5
B
2 3 6
4 5 2
0
15 - Fazer um prog. em c++ que leia uma matriz inteira Am*m(m<=30). onde m é
lido. Calcule e escreva:
- o maior elemento par da diagonal secundária;
- a média dos elementos divisíveis por 3 da penúltima coluna da matriz;
- o produto dos elementos ímpares abaixo da diagonal principal da matriz.
Registros:
1 - Declarar o registro cuja representação gráfica é dada a seguir.
reg
nom
e
salá
rio
idad
e
s
exo
2- Uma indústria faz a folha mensal de pagamentos de seus empregados
baseada no seguinte:
Existe uma tabela com os dados de 10 funcionários.
cadastro
138
ficha
insc
rição
n
ome
hora
normais
h.
extras
Fazer um prog. que processe a tabela e emita para cada funcionário, seu
contracheque, cujo formato é dado a seguir:
número de inscrição: nome:
salário horas normais:
salarário horas extras:
dedução INSS:
salário líquido:
O salário de referência deverá ser lido previamente.
O salário referente as horas extras é calculado acrescentando 30% ao salário
hora normal. O desconto do INSS é de 8% do salário bruto(salário bruto
correspondente as horas normais + salário horas extras).
Para o cálculo do salário, considerar que existem duas classes de funcionários,
a classe 1, cujo salário é 1.3 vez o salário de referência e a classe 2, cujo salário é 1.9
vez o salário de referência.
Arquivos:
139
1 - Fazer um programa que lê do teclado um valor inteiro n. Em seguida lê,
também do teclado e grava, num arquivo binário, de nome interno binário e de nome
externo “dados.bin”, o nome e a idade em de n pessoas.
2 - Fazer um programa que mostra no vídeo todos os valores de nome e idade
que foram gravados, pelo exemplo anterior, no arquivo binário de nome interno
binário e de nome externo “dados.bin”.
3- Supondo-se a existência de um arquivo binário A, cujos registros têm
campos nome, com 15 caracteres e idade, inteiro, que pode ter sido criado pelo
programa 1 proposto, o programa proposto criará outro arquivo binário B, copiando
A, registro por registro.
4 - O programa abaixo recebe os dados de uma agenda, digitados no teclado e
cria um arquivo binário, cujos registros possuem os seguintes campos:
nome,telefone,logradouro, número,cidade e estado.
5- Fazer um programa que lê o valor do salário mínimo de um arquivo que só
tem um valor real e depois lê um arquivo com o cadastro geral de uma empresa,
copiando num novo arquivo os registros dos funcionários que recebem mais que 30
salários mínimos. Os campos dos registros do cadastro são:
nome do funcionário, cargo e salário.
6 - Uma instituição de pesquisa recolheu amostras em três regiões a respeito do
nível de vida de suas populações. Cada amostra constitui um registro com os seguintes
campos: sexo, idade, salário, estado civil, número de dependentes, valor do
patrimônio, quantidade de calorias absorvidas por dia e grau de instrução.
Em cada região, os dados foram armazenados em um arquivo binário, com
os registros colocados em ordem crescente de idade. O programa abaixo intercala
estes arquivos, criando um quarto arquivo também em ordem crescente de idade.
140
7 - Deseja-se fazer um prog. que grave, por acesso direto, um arquivo
relacionado com uma turma de até n alunos. Cada registro deste arquivo
corresponderá a um aluno e será formado por:
- um campo com o seu número de chamada;
- um campo, contendo 30 caracteres, com outras informações.
8 - No arquivo gravado no programa proposto anterior, pode-se ter acesso
direto às informações de um aluno qualquer com o programa seguinte.
Repetidamente este programa:
- lê no teclado o numero de um aluno;
- ignora-o, escrevendo uma mensagem, se o número for maior que o número de
registros do arquivo ou se o aluno não teve informações gravadas pelo programa
anterior;
- senão, acessa as informações do aluno diretamente no arquivo e mostra-as no
vídeo, se número for positivo;
- interrompe a repetição se número for menor ou igual a zero.
9 - Cada registro de um arquivo binário contém a parte numérica da placa, o
tipo e o nome do proprietário de um veículo. A partir deste arquivo, criar um outro
arquivo em que estas informações possam ser acessadas diretamente pela parte
numérica da placa, que pode valor de 1 a 9999.
10 - O programa seguinte pressupõe a existência de um arquivo contendo, em
cada registro, o nome, o número da conta e o saldo de um cliente de um banco; o
número da conta coincide com o número de ordem de um registro ou é nulo se a
conta não existir. O programa permite que se digite o número da conta e se obtenha o
nome e o saldo correspondente.
141
142