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 <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.



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


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;

}


main()

{

int verdadeiro,falso

verdadeiro = (15<20);

falso = (15 = = 20);

cout << "\n Verdadeiro "<<verdadeiro;

cout << "\n Falso "<<falso;

}


main( )

{

cout << "\n"<<(4+1<3);

cout << "\n"<<(2<1+3);

}

8 - Manipuladores de bases Numéricas

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

e são os seguintes:

26

dec - decimal (default)

hex - hexadecimal

oct - octal

Ex.:


main( )

{

int n=65

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

cout<<'\n'<<"Octal"<<oct<<n;

cout<<'\n'<<"Hexadecimal"<<dec<<n;

}

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


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


{

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:


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


{

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>


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


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


getch( );

return ;

}

Ex: 2 Fazer um prog. em c++ que leia o nome,idade e o sexo.O último dado que

não entrará tem nome igual a fim. Calcule e escreva:

- o número de mulheres de idade entre 18 e 30 anos e nome igual à Luciane;

- a idade média dos homens.

#inclcude <stdio.h> // Para a função gets()

#include <string.h> // Para a função strcmpi(s1,s2)


#include <conio.h>

void main(void)

{

char no[25],sexo;

int id,nh,nm,sid;

clrscr();

sid=0;nm=0;nh=0;

cout<<“\n digite o nome”;

gets(no);

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>


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>


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;


getch( );

return;

}

Ex.3 Fazer um prog. em c++ que leia o salário e o nome. O último dado que entrará

tem o nome igual a João. Calcule e escreva:

- o maior salário com o respectivo nome.

#include <conio.h>


#include <string.h>

#include <stdio.h>

void main(void)

{

char no[25],aux[25];

float sal,mas;

clrscr();

mas=0;

do

{

cout<<“\n digite o nome e nome igual a joão para”;

gets(no);

cout<<“\n digite o salário: “;

cin>>sal;

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 >


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 <conio.h>

void main( )

{

char ch;

while ((ch=getch( ))!='x')

{

if (ch>='0' && ch <='9')

continue;

cout << ch;

}


getch( );

return;

}

14.3 - switch

switch permite selecionar uma entre várias ações alternativas.

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>


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;


break;


break;


break;


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;

}


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>


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


getch( );

return;

}

Ex2) Fazer um programa em C+ + que leia uma variável composta contendo

n (n<=100) elementos inteiro, onde n é lido.

Calcule e escreva:

- O maior elemento par e indique a posição;

- Uma 2ª. variável composta contendo os elementos divisíveis por 3.


#include <conio.h>

#include <math.h>

void main(void)

{

int a[100],i,b[100],map,p,j,n;

map = 0; p=0; j =0;

cout<<"\nDigite o numero de elementos n<=100";

cin>>n;

for (i=0;i<n;i++)

{

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;


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


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


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>



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;


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>


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


getch( );

return;

}

Exemplo2: 1. Fazer uma função que calcule a soma da série abaixo:

2 7 8 13 14 19 . . .

2. Fazer um programa que leia o número de termos da série. Calcule e

escreva a soma dos n primeiros termos da série.

#include <conio.h>


long soma(int n)

{

long so,cont,nu;

so=0; nu=2;

for (cont=1;cont<=n;cont++)

if (nu % 2 = =0)

{

so=so+nu;

nu=nu+5;

}

else {

so=so+nu;

nu=nu+1;

}

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;


getch();

return;

}

60

1.9 - Passando vários argumentos

Ex: Função que desenha retângulos


#include <conio.h>

void retangulo(int l, int alt)

{

int i,j;

l=l/2;

alt=alt/4;

for(i=1;i<=alt;i++)

{

cout<<"\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>


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


getch( );

}

Ex.2

// ordena uma lista de 3 números

#include <conio.h>


void troca(float& n, float& m)

{

float aux;

aux=n;

n=m;

m=aux;

}

void main(void)

{

float n1,n2,n3;

cout<<"\nDigite 3 números ";

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;


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>


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;


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 <conio.h>

int i; // inicializa com zero

int j=234; // inicializa com 234

void main( )

{

int i=5, j=10; // variáveis automáticas

cout<<: : i<<: : j<<"\n"; // externas

cout<<i<<j<<"\n";


getch( );

}

1.15 - Funções recursivas

Uma função é dita recursiva se for definida em termos dela mesma. Isto é,

uma função é recursiva quando dentro dela está presente uma instrução de chamada a ela

própria.

Ex: 1 - Escrever uma função que calcula o fatorial de um número.

#include <conio.h>


long fatorial (int n)

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 <conio.h>

void invert( )

{

char ch;

if ((ch=getche( ) )!= '\r')

invert( );

cout<<ch;

}

void main(void)

{

cout<<"\n";

inverte( );


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>


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


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


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>


void main()

{

ifstream fin(“teste1.txt”);

char ch;

while (fin.get(ch)) // Lê um caractere do arquivo

cout<<ch;


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


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 <stdio.h>

#include <conio.h>

class livro

{

private :

char titulo[50];

char autor[50];

int numreg;

double preco;

public : void novonome();

void print();

};


{

92


gets(titulo);

cout<<“\n digite o autor”;

gets(autor);

cout<<“\n digite o número do registro”;

cin>>numreg;


cin>>preco;

clrscr();

}

void livro::print()

{


cout<<“\ autor : “<<autor;

cout<<“\nno. reg. : “<<numreg;

cout<<“\n preco : “<<preco;

}

void main()

{

fstream fio; // Cria objeto de leitura e gravação.

livro li; // Cria objeto livro

fio.open(“lista.dat”,ios::ate || ios::out || ios::in);

do

{

li.novonome();

fio.write((char *)&li,sizeof(livro));

cout<<“\n Mais um livro (s/n) ? “;

}

while(getche()!=‘n’);

fio.seekg(0); // Coloca o ponteiro no início do arquivo.

cout<<“\n lista de livros do arquivo”;

93

cout<<“\n ===================================“;

while(fio.read((char * )&li,sizeof(livro)))

li.print();


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 <stdio.h> // para exit()

#include <conio.h>

class livro

{

private :

char titulo[50];

char autor[50];

int numreg;

double preco;

public : void novonome();

void print();

};


{


gets(titulo);

cout<<“\n digite autor”;

95

gets(autor);

cout<<“\n digite o número de registros”;

cin>>numreg;


cin>>preco;

clrscr();

}

void livro::print()

{


cout<<“\n autor: “<<autor;

cout<<”\n No. reg. :”<<numreg;

cout<<“\n preco : “<<preco;

}

void main()

{

ifstream fin;

livro li;

fin.seekg(0,ios::end); //aponta para fim do arquivo, deslocamento zero

long nrec=(fin.tellg())/sizeof(livro);

cout<<“\n numero de registros=“<<nrec;

cout<<“\n insira o numero do registro:”;

cin>>nrec;

int posicao=(nrec-1)*sizeof(livro);

fin.seekg(posicao);

fin.red(char *)&li,sizeof(livro));

fin.seekg(posicao);

fin.read((char *)&li,sizeof(livro));

li.print();


getch();

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>



// ------------------------------ 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

}


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




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


107



N++; // contar mais um gravado

}


clrscr();

PutStr(1, 2, "Agenda alterada.\n");

cout << N << " registros novos gravados.\n";

Pausa();

return;

}

void Menu() // Menu()

{

// objetivo :

// mostrar as opções básicas do programa,

// e receber a escolha da função desejada pelo usuário

char Opção;

Agendas Minha ("Agenda.DAT");

do

{

clrscr();

PutStr(25, 5, "PROGRAMA PARA TRATAR UMA AGENDA");

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 <conio.h>

void main()

{

int i,k,j;

clrscr();

cout<<“\n “”<<&i;

cout<<“\n”<<&j;

cout<<“\n”<<k;


getch();

return;

}

Eis a saída:

0xfff4 ----------endereço de i

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>


void reajusta(float *p, float *r)

{

*r=*p*0.2;

*p=p*1.2;

}

void main()

{

float preco,valoreaj;

do

{


cin>>preco;

reajusta(&preco, &valoreaj);

cout<<”\n preco novo “<<preco;

cout<<“\n aumento =“<<valoreaj;

112

}

while(preco!=0.0);


getch();

return;

}

1-6 Variáveis que armazena endereços.

Os endereços são armazenados de modo semelhante as variáveis. Semelhante

as variáveis. Uma variável que armazena um endereço é chamado de ponteiro. Observe que

um ponteiro para um float não é do tipo float, mas sim do tipo float *. O asterisco faz parte

do nome do tipo e indica ponteiro para.

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>


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 <conio.h>

void main()

{

int x,y;

int *px=&x; // inicializa p com o endereço de x

*p=14; // o mesmo que x=14

y=*p; // o mesmo que y=x

cout<<“\n y=“<<y ;


getch();

return;

}

Observação: A instrução y=*p; indica o valor da variável apontada.

1-11 Atribuição

Um endereço pode ser atribuído a um ponteiro.

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


void main()

{

int m[5]={92,81,70,69,58};

int i;

for(i=0;i<5:i++)

cout<<“\n “<<*(m+i);


getch();

return;

}

Onde: *(m+i) tem o mesmo valor de m[i]. Você já sabe que m é um ponteiro int e

aponta para m[0], conhecendo também a aritmética com ponteiros. se somarmos 1 a m,

obtemos o endereço de m[1], m+2 é o endereço de m[2] e assim por diante.Em regra geral,

temos que: m+i é equivalente a &m[i], portanto *(m+i) é equivalente a m[i].

1-16 Ponteiros constantes e ponteiros variáveis.

Na instrução cout<<“\n”<<*(m+i); não pode ser substituída pela instrução

cout”\n”<<*(m++); pois não podemos incrementar uma constante.

O nome de uma matriz é um ponteiro constante e não pode ser alterado.

Um ponteiro variável é um lugar na memória que armazena um endereço. Um ponteiro

constante é um endereço, uma simples referência.

Exemplo: Imprimir os elementos de uma matriz.

#include <conio.h>


void main()

{

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>


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;


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


getch();

return;

}

1-20 Matrizes de ponteiros.

Exemplo: Imprime o dia da semana a partir de uma data.

120

#include <conio.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);


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


série:

100/0! + 99/1! + 98/2! + 97/3! + . . .


- 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! + . . .


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.


- 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.


- 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


- 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


- 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.


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.


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) + . . .


- 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.


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.


- 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

apostila c++.doc

Documents