Apostila c++

Prévia do material em texto

� EMBED MSWordArt.2 \s ���
SUMÁRIO
Unidade I
1.0 Itens fundamentais......................................................................pg-8
1.1 Dados Numéricos.........................................................................pg-8
1.2 Dado literal...................................................................................pg-8
2.0 Variável.........................................................................................pg-8
2.1 Formação de Identificadores........................................................pg-9
2.2 Declaração de variáveis.................................................................pg-9
2.3 Modificadores de tipos oferecidos por c++...................................pg-9
3.0 Operadores.....................................................................................pg-10
3.1 Operadores de atribuição...............................................................pg-10
3.2 Operadores aritméticos...................................................................pg-10
4.0 Funções de entrada e saída..............................................................pg-11
4.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
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
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
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
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
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çospara 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
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
�
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.
	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.
�
	Ex.:
			
	d
	10
	nota
	100
	sexo
	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;
	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
	
	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
/	 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
				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
	aA
	nn
	aa
	
	pP
	aa
	uu
	ll
	aa
 
	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.
	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;
	cout << "\n\n\n" // insere linhas
	cout << '\n' << "Borracha" << bor;
	cout << '\n' << "Lapis" << lap;
	cout << '\n' << "Canetas" << can;
	cout << '\n' << "Cadernos" << cad;
	cout << '\n' << "fitas" << fit;
}
#include <iostream.h>
#include <iomanip.h>
main( )
{
	int lap=45,bor=2345, can=420, cad=8, fit=13050;
	cout << "\n\n\n" // insere linhas
	cout << '\n' << "Borracha" << setw(12) << bor;
	cout << '\n' << "Lapis" <<setw(12) << lap;
	cout << '\n' << "Canetas" <<setw(12) << can;
	cout << '\n' << "Cadernos" <<setw(12) << cad;
	cout << '\n' << "fitas" <<setw(12) << fit;
{}
	2) Preencher as colunas em branco com o caracter (.).
	
	- acrescentar:
	cout << setfill(' . ');
	cout << '\n'<<"lapis"<<setw(12)<<lap;
	.
	.
	.
	.
Ex.: Tamanho de campos com pontos flutuantes.
#include <iostream.h>
#include <iomanip.h>
main( )
{
	float lap=4.875,bor=234.542,can=42.036,cad=8.0,fit=13.05;
	cout << "\n\n\n";
	cout << setprecision(2);
	cout <<'\n'<<"lapis"<<setw(12) << lap;
	.
	.
	.
	.
}Ex.: Tamanho de campos com cadeias de caracteres
	.
	.
	.
{
	cout << "\n\n\n";
	cout << "objeto"<<setw(12)<<"codigo"<<'\n';
	cout <<'\n'<< "lapis"<<setw(12)<<"WQR";
	cout << '\n'<< "borracha"<<setw(12)<<"ASO";
	.
	.
	.
}
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
void main(void)
{
	float lap=4.875, bor = 234.542;
	cout<<"\n\n\n";
	cout<<setprecision(2)<<setfill('.');
	cout<<"\nlapis "<<setw(12)<<lap;
	cout<<"\nborracha "<<setw(12)<<bor;
	cout<<"\nAperte enter ";
	getch( );
	return;
}
6.0 - Funções Aritméticas
	1) sin(x)
	2) cos(x)
	3) atan(x) - arco-tangente de x
	4) sqrt(x) - raiz quadrada de x
	5) exp(x) - Nº. e elevado a x
	6) abs(x) - valor absoluto inteiro
	7) fabs(x) - valor absoluto real
	8) log(x) logaritmo
	9) log10 - logaritmo na base 10
	10) pow(x,y) - elevar x a y
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 ( | | )
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
	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: ? :
	Sintaxe: 
		 exp1 ? exp2 : exp3;
	A exp1 é avaliada, se for verdadeira a exp2 é executada; caso contrário, se a exp1 for falsa a exp3 é executada.
	Ex1.: max = (a > b) ? a: b;
	
	A variável max receberá o maior valor.
	Ex2.: abs = (x > 0) ? x : -x;
	Ex3.: cout << ( (x % 2) ? "Impar " : "Par");
// Calcula a média aritmética de 4 notas
#include <iostream.h>
main( )
{
	float nota,media;
	media = 0;
	cout<<"\nDigite a primeira nota : ";
	cin >> nota;
	media + = nota;
	cout<<"\nDigite a segunda nota : ";
	cin >> nota	 ;
	media + = nota;
	cout<<"\nDigite a terceira nota : ";
	cin >> nota;
	media + = nota;
	cout<<"\nDigite a quarta nota : ";
	cin >> nota;
	media + = nota;
	media / = 4;
	cout << "\n Media = "<<media;
}
#include <iostream.h>
main()
{
	int verdadeiro,falso
	verdadeiro = (15<20);
	falso = (15 = = 20);
	cout << "\n Verdadeiro "<<verdadeiro;
	cout << "\n Falso "<<falso;
}
#include <iostream.h>
main( )
{
	cout << "\n"<<(4+1<3);
	cout << "\n"<<(2<1+3);
}
8 - Manipuladores de bases Numéricas
	Os manipuladores de bases numéricas estão definidos no arquivo iostream.h e são os seguintes:
	dec - decimal (default)
	hex - hexadecimal
	oct - octal
Ex.: 
#include <iostream.h>
main( )
{
	int n=65
	cout<<'\n'<<"Hexadecimal"<<hex<<n;
	cout<<'\n'<<"Octal"<<oct<<n;
	cout<<'\n'<<"Hexadecimal"<<dec<<n;
}
	Saída:	 	 41
			101
		 	 65
9 - Imprimindo caracteres gráficos
	O código ASCII dispõe de números de 0 a 127 (decimal) abrangendo letras, dígitos, caracteres de pontuação, etc. Os computadores IBM-PC usam 128 caracteres adicionais, com códigos de 128 a 255, que consistem em símbolos de línguas estrangeiras e caracteres gráficos
	A forma de representar um caractere de código acima de 127 é : \xdd;
	onde: \xdd é um caractere e pode ser contido por uma cadeia de caracteres entre aspas duplas.
Ex.:
#include <iostream.h>
main( )
{
	cout<<"\n\n";
	cout<<"\n\xDC\xDC\xDB\xDB\xDB\xDB\xDC\xDC";
	cout<<"\n\xDFO\xDF\xDF\xDF\xDFO\xDF";
	cout<<"\n\n";
	cout<<"\n\xDC\xDC\xDB\xDB\xDB\xDB\xDB\xDB\xDB";
	cout<<"\n\xDFO\xDF\xDF\xDF\xDF\xDFO\xDF";
	cout<<"\n\n";
}
10 - Códigos especiais
	
	Códigos Especiais
	Significado
	\n
	Nova linha 
	\t
	Tab
	\b
	Retrocesso
	\f
	Salta página de formulário
	\a
	Beep - toca o alto falante
	\r
	CR - Cursor para o inicio da linha
	\\
	\ - Barra invertida
	\0
	Null - zero
	\'
	' - Aspa simples
	\"
	" - Aspa dupla
	\xdd
	Representação hexadecimal
11 - Comentários
	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;
Ex2.:
	if (a>b+c | | a>20)
	 y = y + 2;
	2) Mais de uma instrução
	if (expressão de teste)
	 {
	 instrução;
	 instrução;
	 }
Ex1.: 
	if (ch = = '0')
	 {
 		cout<<"\n Zero detectado";
		cont = cont+1;
 }
	12.2 - Estrutura condicional composta
	1) Só uma instrução:
	if (expressão de teste)
	 instrução a;
 	else instrução b;
Ex1.: 
	if (a > 10)
	 k = k+2;
	else y = y+3;
	2) Mais de uma instrução
	
	if (expressão de teste)
	 {
	 instrução1a;
 . . .
	 instrução na;
	 }
	else {
		 instrução1b;
 . . .
		 instrução nb;
		}
Ex2.:
	if (sexo = ='f')
	 {
		nm = nm + 1;
		k = k+i;
	 }
	else {
		nh = nh +1;
		y = y+i;
	 }
Ex: 
	1) Fazer um programa em C+ + que leia valores distintos. Determine e escreva o menor deles.
#include <conio.h>
#include <iostream.h>
void main(void)
{
	float a,b,c,men;
 clrscr();
	cout <<"\nDigite três valores distintos ";
	cin >> a >> b>> c;
	if (a<b && a<c)
	 men=a;
	else if (b<c)
		men=b;
	 else men = c;
 cout<<“\n menor = “<<men;
	cout <<"\n Aperte quqlquer tecla ";
	getch( );
	return;
}
	2) Fazer um programa em C+ + que leia os coeficientes de uma equação do 2º. Grau. Calcule escreva as raízes reais se houver.
#include <conio.h>
#include <math.h>
#include <iostream.h
void main(void)
{
	float x1,x2,a,b,c,d;
	cout<<"\nDigite os coeficientes da equação do 2º. Grau";
	cin>>a>>b>>c;
	d = pow(b,2)-4*a*c;
	if (d>=0)
	 {
	 x1=(-b+sqrt(d))/2*a;
 x2=(-b-sqrt(d))/2*a;
	 cout<<'\n x1= "<<x1<<" x2= "<<x2;
	 }
 	else cout<<"\n Não existem raízes reais ";
	cout<<"\n Aperte qualquer tecla ";
	getch( );
	return;
}	
 
3 - fazer um prog. em c++ que leia os lados de um triângulo. Determine se os lados formam um triângulo se houver indique através de uma mensagem o tipo (eqüilátero, isósceles ou escalenos); caso contrário informe que não existe triângulo.
#include <conio.h>
#include <iostream.h>
#include <math.h>
void main(void)
{
	int x,y,z;
	cout<<"\nDigite os lados do triângulo ";
	cin >> x >> y >> z;
	if (x<y+z && y<x+z && z<x+y)
	 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.
	iii) Todas as variáveis que estiverem dentro da estrutura de repetição tem que atribuir valores iniciais, exceto as lidas.
Ex.:	1) Fazer um programa em C+ + que leia a altura e o sexo de 10 pessoas. Calcule e escreva a maior e a menor altura com os respectivos sexos.
(
	Dados:	 alt
	 sexo
	 10 pessoas (np)
#include <stdio.h>
#include <conio.h> // diretiva limpa tela
#include <iostream.h>
void main(void)
{
	char sexo,aux1,aux2;
	float alt,ma,me;
	int np;
	ma = 0; me =4;
	for (np=1; np<=10; np++)
	 {
	 	cout<<"\nDigite o sexo : "<<np<<” ? “;
		cin >>sexo;
		cout<<"\nDigite a altura : "<<np<<” ? “;
		cin >> alt;
		if (alt > ma)
	 {
		 ma = alt;
	 	 aux1 = sexo;
		 }
		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;
		}		
	Obs.: 
	i) O laço while é apropriado em situações em que o laço pode ser terminado inesperadamente, por condições desenvolvidas dentro do laço.
	ii) while executa as instruções enquanto a expressão de teste for verdadeira.
	Ex. 1) Fazer um programa em C+ + que leia a idade de um grupo de pessoas. O último dado que não entrará nos cálculos tem idade igual a 0 (zero). Calcule e escreva:
a idade média do grupo
	Dado: id
		 idm = sid/np
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
void main(void)
{
	int id;
	unsigned long np,sid;
	float idm;
	np = 0; sid = 0;
	cout<<"\nDigite a idade ; ";
	cin>>id;
	while (id!=0)
	 {
		sid=sid + id;
		np = np + 1;
		cout<<"\nDigite a idade e idade = 0 para ";
		cin >> id;
		clrscr( );
	 }
	if (np!=0)
	 {
	 idm = sid/np;
	 cout<<"\nA média é : "<<idm;
 }
	else cout<<"\nNão existe ";
	cout<<"\n Aperte qualquer tecla ";
	getch( );
	return ;
}
	
Ex: 2 Fazer um prog. em c++ que leia o nome,idade e o sexo.O último dado que não entrará tem nome igual a fim. Calcule e escreva:
- o número de mulheres de idade entre 18 e 30 anos e nome igual à Luciane;
- a idade média dos homens.
#inclcude <stdio.h> // Para a função gets()
#include <string.h> // Para a função strcmpi(s1,s2)
#include <iostream.h>
#include <conio.h>
void main(void)
 {
 char no[25],sexo;
 int id,nh,nm,sid;
clrscr();
sid=0;nm=0;nh=0;
cout<<“\n digite o nome”;
gets(no);
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
	{
	 instrução;
	 instrução;
	} while (expressão de teste);
	Obs.: i) do-while é utilizado em situações em que é necessário executar o corpo do laço uma primeira vez e depois avaliar a expressão de teste e criar um ciclo repetido.
	 ii) Este ciclo de execução do bloco e teste é repetido até que a expressão de teste se torne falsa (igual à zero), então o laço termina e o controle do programa passa para a linha seguinte ao laço.
	Ex.1) Fazer um programa em C+ + que leia a nota e o código. O último dado que entrará tem código igual a 3020. Calcule e escreva:
	- As duas maiores notas, com os respectivos códigos.
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
void main(void)
{
	float no,m1,m2,cod,aux1,aux2;
	m1=0;m2=0;aux1=0;aux2=0;
	do
	{ 
	 cout<<"\nDigite a nota e o código : ";
	 cin>>no>>cod;
	 if (no>m1)	
	 {
		m2=m1;
		aux2=aux1;
		m1=no;
		aux1=cod;
	 }
 	 else if (no>m2 && no!=m1)
 {
		 m2=no;
		 aux2=cod;			
 }
	 clrscr( );
	} while (cod!=3020);
	cout<<"\nm1 = "<<m1<<"aux1 = "<<aux1;
	cout<<"\nm2 = "<<m2<<"aux2 = "<<aux2;
	cout<<"\n Aperte qualquer tecla";
	getch( );
	return;
}
ex.2 Fazer um prog. em c++ que calcule e escreva o número de anos necessários para que a população de A seja maior ou igual à de B. Sabendo que a população de A é 90000000 milhões de habitantes com uma taxa de crescimento constante de 3% ao ano e que B tem 200000000 de habitantes com uma taxa constante de 1.5% ao ano.
#include <conio.h>
#include <stdio.h>
#include <iostream.h>
void main(void)
{
	long popa,popb;
	int na;
	popa=9E7; popb=2E8; na=0;
	do
	{
	 na = na+1;
	 popa=popa+0.03*popa;
	 popb=popb+0.015*popb;
	}
	while (popa<popb);
	cout<<"\nO numero de anos : "<<na;
	cout<<"\n Aperte qualquer tecla ";
	getch();
	return;
}
Ex.3 Fazer um prog. em c++ que leia o salário e o nome. O último dado que entrará tem o nome igual a João. Calcule e escreva:
- o maior salário com o respectivo nome.
#include <conio.h>
#include <iostream.h>
#include <string.h>
#include <stdio.h>
void main(void)
 {
 char no[25],aux[25];
 float sal,mas;
 clrscr();
 mas=0;
 do
 {
 cout<<“\n digite o nome e nome igual a joão para”;
 gets(no);
 cout<<“\n digite o salário: “;
 cin>>sal;
 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:
i = i + 2
d = d * (i-1) * i
e = e +2
sinal = (-1)*sinal
s = s + pow(x,e)*sinal/d
#include <conio.h>
#include <math.h >
#include <iostream.h>
void main (void)
{
	int sinal,e,cont,i;
	long d;
	float s,x;
	cont << "\ndigite X ";
	cin >> x;
	s=0; i=3; d=6; e=2; sinal = -1;
	for (cont=1;cont<=19;cont++)
	 {
		if (x<0)
		 break;
		s = s + pow(x,e)*sinal/d;
		i = i+2;
		d = d*(i-1)*i;
		sinal = (-1)*sinal;
		e = e + 2;
	 }
	cout << "\nO valor de X é = "<<(s+x);
	cout <<"\n Aperte qualquer tecla ";
	getch( );
	return;
}
	14.2 - Continue
	Continue faz com que o controle do programa avalie imediatamente a expressão de teste e depois continua o processo do laço.
exemplo: imprima os caracteres diferentes dos dígitos.
#include <iostream.h>
#include <conio.h>
void main( )
{
	char ch;
	while ((ch=getch( ))!='x')
	 {
		if (ch>='0' && ch <='9')
		 continue;
		cout << ch;
	 }
	cout<<"\n Aperte qualquer tecla";
	getch( );
	return;
}
	 
	14.3 - switch
	switch permite selecionar uma entre várias ações alternativas.
	
	Sintaxe:
	switch (variável seletora)
	 {
		case constante1 : instrução;
		 instrução;
		 break;
		case constante2 : instrução;
		 instrução;
		 break;
		default : instrução;
	 		 instrução;
		}
	onde: variável seletora é do tipo enumerável (inteira ou char).
	Ex1) Fazer um programa que leia o canal e o número de pessoas que estão assistindo. O último dado que não entrará tem canal igual a 0 (zero). Calcule e escreva:
	- As porcentagens de audiência dos principais canais de televisão.
	dados: { canal, npas }
	p4 = n4*100/tot
		.
		.
		.
	p12 = n12*100/tot
#include <conio.h>
#include <iostream.h>
void main(void)
{
	long tot,n4,n5,n6,n7,n12;
	int canal,npas;
	float p4,p5,p6,p7,p12;
	n4=0; n5=0; n6=0; n7=0; n12=0;
	cout<<"\n Digite o canal ";
	cin>>canal;
	while (canal!=0)
	 {
		cout<<"\nDigite o numero de pessoas";
		cin >> npas;
		switch(canal)
		 {
			case 4 : n4=n4+npas;
				 break;
			case 5 : n5=n5+npas;
				 break;
			case 6 : n6=n6+npas;
				 break;
			case 7 : n7=n7+npas;
				 break;
			case 12 : n12=n12+npas;
				 break;
			default : cout<<"\nDigitou o canal errado ";
		 }
		clrscr();
 cout<<"\nDigite outro canal e canal = 0 para ";
		cin>>canal;
	 }
	tot=n4+n5+n6+n7+n12;
	if (tot!=0)
	 {
	 p4 = n4*100/tot;
		.
		.
		.
	 p12 = n12*100/tot;
	 cout<<"\np4 = "<<p4<< . . . <<"p12 = "<<p12;
	 }
	cout<<"\n Aperte qualquer tecla ";
	getch( );
	return;
}
�
UNIDADE - II
	1.0 - Matrizes
	Matriz é um tipo de dado em C+ + usado para representar uma coleção de variáveis de mesmo tipo.
	1.1 - Matriz Unidimensional
	É um conjunto de dados do mesmo tipo, referenciados por um único nome, onde cada elemento é referenciado por um único índice.
	1.1.1 - Declaração de variável
		tipo nome-da-variável[n];
		onde: n é o número de elementos.
	Ex1) Fazer um programa que leia 10 notas. Calcule e escreva:
	 - A média das notas;
#include <conio.h>
#include <iostream.h>
void main(void)
{
	int nota[10],i;
	float media;
	media = 0;
	for(i=0;i<10;i++)
	 {
		cout<<"\nDigite a nota "<<(i+1)<<": ";
		cin>>nota[i];
		media=media+nota[i];
	 clrscr( );
	 }
	cout<<"\nA media é = "<<(media/10);
	cout<<"\n Aperte qualquer tecla";
	getch( );
	return;
}
	Ex2) Fazer um programa em C+ + que leia uma variável composta contendo n (n<=100) elementos inteiro, onde n é lido. 
	
	Calcule e escreva: 
	- O maior elemento par e indique a posição; 
	- Uma 2ª. variável composta contendo os elementos divisíveis por 3.
	
#include <iostream.h>
#include <conio.h>
#include <math.h>
void main(void)
{
	int a[100],i,b[100],map,p,j,n;
	map = 0; p=0; j =0;
	cout<<"\nDigite o numero de elementos n<=100";
	cin>>n;
	for (i=0;i<n;i++)
	 {
		cout<<"\nDigite um numero inteiro "<<(i+1)<<" : ";
		cin>>a[i];
		if (a[i]>map && a[i]%2= =0)
		 {
		 map=a[i];
		 p=i;
		 }
		if (a[i]%3= =0)
		 {
		 b[j]=a[i];
		 j++;
		 }
		clrscr( );
	 }
	for(i=0;i<j;i++)
	 cout<<"\nOs elementos de B são :"<<b[i];
	cout<<"\nO maior elemento par = "<<map <<"p = "<<p;
	cout<<"\n Aperte qualquer tecla";
	getch( );
	return;
}
	1.2 - Matrizes multidimensionais
	São as que necessitam de mais de um índice para individualizar um elemento no conjunto de dados.
	1.2.1 - Declaração de variáveis
	tipo nome-da-variável [nl] [nc];
	onde: 
		- nl : é o número de linhas
		- nc : é o número de colunas
	Ex1) Fazer um programa que leia uma matriz A3 x 3 de elementos numéricos. Calcule e escreva:
	- A média dos elementos
#include <iostream.h>
#include <conio.h>
void main(void)
{
	float a[3][3], med;
	int i,j;
	med=0;
	for(i=0;i<3;i++)
	 for(j=0;j<3;j++)
	 {
		cout<<"\nDigite um valor "<<i<<" "<<j;
		cin>>a[i][j];
		med=med+a[i][j];
		clrscr( );
	 }
	cout<<"\nA média é = "<<(med/9);
	cout<<"\n Aperte qualquer tecla";
	getch( );
	return;
}
	Ex2) Fazer um programa que leia uma matriz Am x n (m<=20, n<=25) onde m e n são lidos. Calcule e escreva:
	- a matriz transposta de A
#include <iostream.h>
#include <conio.h>
void main(void)
{
	float a[20][25], b[25][20];
	int i,j,m,n;
	cout<<"\nDigite a ordem (m<=20, n<=25) ";
	cin>>m >>n;
	for (i=0;i<m;i++)
	 for (j=0;j<n;j++)
		{
		 cout<<"\nDigite um valor : "<<i<<" "<<j;
		 cin>>a[i][j];
		 b[j][i]=a[i][j];
		 clrscr( );
		}
	
	for (i=0;i<n;i++)
	 for(j=0;j<m;j++)
	 	cout<<"\nA matriz é : "<<b[i][j];
	cout<<"\nAperte enter ";
	getch( );
	return;
}
	
UNIDADE - III
	1.0 - Funções
	Uma função é um conjuntode instruções desenhadas para cumprir uma tarefa particular e agrupadas numa unidade com um nome para referenciá-la.
	1.1 - Chamando uma função
	É o meio pelo qual solicitamos que o programa desvie o controle e passe para a função, executar suas instruções e depois volte à instrução seguinte a da chamada da função.
	1.2 - Funções simples
	Exemplo: converter a temperatura de graus Fahrenheit para Celsius
	#include <conio.h>
	#include <iostream.h>
	#include <iomanip.h>
	int Celsius (int f)
 {
	int c;
	c=(f-32)*5/9;
	return c;
 }
 	void main(void)
	 {
		int c,f;
		cout<<"\nDigite a temperatura em graus Fahrenheit ";
		cin>>f;
		c=Celsius(f);
		cout<<"\n Celsius = "<<c;
		cout<<"\n Aperte qualquer tecla";
		getch( );
		return;
	 }
�
	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);
	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
	Sua declaração indica que o valor enviado será armazenado na variável indicada e é criada quando a função inicia a sua execução e destruída quando a função termina.
	Exemplo1: Fazer um programa que leia uma matriz AM*N (M<=20,N<=10). Onde M e N são lidos. Calcule e escreva: a matriz transposta de A.
#include <conio.h>	
#include <iostream.h>
void matriz(int m, int n)
 {
	float a[20][10], at[10][20];
	int i,j;
	for (i=0;i<m;i++)
		for (j=0;j<n;j++)
		{
		cout<<"\n Digite um elemento "<<i<<" "<<j;
		cin>>a[i][j];
 at[j][i]=a[i][j];
		clrscr( );
		}
	for (i=0;i<n;i++)
	 for(j=0;j<m;j++)
		cout<<"\n at["<<i<<" "<<j<<"] = "<<at[i][j];
 return:
 }
void main(void)
 {
	int m,n;
	cout<<"\nDigite a ordem, M<=20 e N<=10 ";
	cin>>m>>n;
	matriz(m,n);
	cout<<"\nAperte enter ";
	getch( );
	return;
 }
		
Exemplo2: 1. Fazer uma função que calcule a soma da série abaixo:
 2 7 8 13 14 19 . . .
 2. Fazer um programa que leia o número de termos da série. Calcule e escreva a soma dos n primeiros termos da série.
#include <conio.h>
#include <iostream.h>
long soma(int n)
 {
long so,cont,nu;
so=0; nu=2;
for (cont=1;cont<=n;cont++)
 if (nu % 2 = =0)
 {
 so=so+nu;
 nu=nu+5;
 }
 else {
 so=so+nu;
 nu=nu+1;
 }
return so;
}
void main(void)
 {
 int n;
 long so;
 cout<<“\n digite o número de termos da série”;
 cin>>n;
 so=soma(n);
 cout<<“\n a soma da série é : “<<so;
 cout<<“\n aperte qualquer tecla”;
 getch();
 return;
 }
	
�
1.9 - Passando vários argumentos
	Ex: Função que desenha retângulos
	#include <iostream.h>
	#include <conio.h>
	void retangulo(int l, int alt)
	 {
	 int i,j;
	 l=l/2;
	 alt=alt/4;
	 for(i=1;i<=alt;i++)
		{
		 cout<<"\t\t";
		 for(j=1;j<=l;j++)
		 cout<<'\XDB';
		 cout<<'\n';
		 }
	 }
	void main(void)
 {
	 cout<<"\nSala\n";
	 retangulo(22,12);
	 cout<<'\nCozinha\n";
	 retangulo(16,16);
	 cout<<"\nBanheiro\n";
	 retangulo(6,8);
	 cout<<"\nQuarto\n";
	 retangulo(12,12);
	 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
Obs: O operador unário &, quando usado na criação de referência, faz parte do tipo:
 
 int& é um tipo de dado.
 
 Toda referência deve obrigatoriamente ser inicializada.
 
 int n;
 int& n1; //errado
 int& n1=n; // certo
	1.11 - Passagem por referência
	A principal vantagem da passagem por referência é a de que a função pode acessar as variáveis da função que chamou. Este mecanismo, possibilita que uma função retorne mais de um valor para a função que chama.
	Exemplo: Mostra passagem de argumentos por referência
#include <conio.h>
#include <iostream.h>
void reajusta (float& p, float& r ) // reajusta o preço em 20%
 { 	
	r=p*0.2;
	p=p*1.2;
 }	
 void main(void)
	{
	 float preco,valreaj;
	 do
	 {
 cout<<"\n Entre com o preço ";
	 	cin>preco;
		reajusta(preco,valreaj);
		cout<<"\n Preco novo = "<<preco;
		cout<<"\n Valreaj = "<<valreaj;	
	 }
	 while (preco !=0);
	 cout<<"\n Aperte qualquer tecla";
	 getch( );
	}
	Ex.2
	// ordena uma lista de 3 números
	#include <conio.h>
	#include <iostream.h>
	void troca(float& n, float& m)
	{
	 float aux;
	 aux=n;
	 n=m;
	 m=aux;
	}
	void main(void)
	{
	 float n1,n2,n3;
	 cout<<"\nDigite 3 números ";
	 cin>>n1>>n2>>n3;
	 if(n1>n2)
	 troca(n1,n2);
	 if(n1>n3)
	 troca(n1,n3);
	 if(n2>n3)
	 troca(n2,n3);
	 cout<<"\nn1 = "<<n1<<" n2 = "<<n2<<" n3 = "<<n3;
	 cout<<"\n Aperte qualquer tecla";
	 getch( );
	}
�
	1.12 - Referências Constantes
	Você pode combinar a palavra chave const com a declaração de uma referência para uma variável.
	Ex.: int n = 456;
	 const int &n1 = n;
	Estas declarações fazem de n1 um nome "read-only" para n. Você não poderá fazer nenhuma modificação em n1, somente em n.
	1.13 - Classes de armazenamento
	São quatro as classes de armazenamento em C ++:
	1 - auto - automáticas (default)
	2 - extern - externas
	3 - static - estáticas
	4 - register - em registradores
	1) Classe auto
		Podem ser acessadas somente pelas instruções do mesmo bloco e escritas após a sua declaração.
		Quando uma variável automáticaé criada, o programa não a inicializa com nenhum valor específico. Variáveis automáticas conterão um valor inicial aleatório, chamado " lixo ".
	2) Classe extern
		São declaradas fora de qualquer função. O acesso a elas é permitido a todas as funções definidas após a sua declaração, e elas existirão enquanto o programa estiver sendo executado.
	Ex.:
	#include <conio.h>
	#include <iostream.h>
	int i; // externa
	int j=234; // externa
	
	void func( )
	{
	 i=25; j=48;
	 }
	void main(void)
	{
	 cout<<"\n i = "<<i<<"j = "<<j;
	 func( );
	 cout<<"\n i = "<<i<<"j = "<<j;
	 cout<<"\nAperte enter ";
	 getch( );
	 return;
	}
	( saída: i = 0 j = 234
 i = 25 j = 48
	1.14 - O Operador de escopo : :
	Em C ++, as variáveis automáticas têm precedência sobre variáveis externas. Você pode solicitar ao compilador que utilize a variável externa em vez da automática colocando o operador : : antes do nome da variável.
	Ex.:
	#include <iostream.h>
	#include <conio.h>
	int i; // inicializa com zero
	int j=234; // inicializa com 234
	void main( )
	{
	 int i=5, j=10; // variáveis automáticas
	 cout<<: : i<<: : j<<"\n"; // externas
	 cout<<i<<j<<"\n";
	 cout<<"\n Aperte qualquer tecla";
	 getch( );
	 }
	1.15 - Funções recursivas
	Uma função é dita recursiva se for definida em termos dela mesma. Isto é, uma função é recursiva quando dentro dela está presente uma instrução de chamada a ela própria.
	Ex: 1 - Escrever uma função que calcula o fatorial de um número.
	#include <conio.h>
	#include <iostream.h>
	long fatorial (int n)
	 {
	 if (n<=1)
	 return (1);
	 else return (n*fatorial(n-1));
	 }
	void main(void)
	{
	 int n;
	 cout<<"\nDigite um numero inteiro";
	 cin>>n;
	 cout<<"\nFat = "<<fatorrial(n);
	 cout<<"\nAperte enter";
	 getch( );
	 return;
	}
	Quando o programa for executado a função fatorial será acessada repetidamente, uma vem em main e (n-1) vezes dentro dela mesma apesar do usuário não se preocupar com isso.	Quando um programa recursivo é executado, as chamadas das funções recursivas não são executadas imediatamente. Elas são colocadas em uma pilha (stack) até que a condição de término da recursão seja encontrada. As chamadas da função são executadas, então, em ordem inversa, à medida que forem retiradas (popped off) da pilha. Quando uma expressão fatorial for avaliada recursivamente, as chamadas de função serão executadas da seguinte ordem:
	n! = n*(n-1)!
	(n-1)! = (n-1)*(n-2)!
	(n-2)! = (n-2)*(n-3)!	
	2! = 2*1!
	
	Os valores serão então devolvidos na seguinte ordem:
	1! = 1
	2! = 2*1! = 2*1 = 2
	3! = 3*2! = 3*2 = 6
	4! = 4*3! = 4*6 = 24
	Ex.2 - Imprime uma frase de ordem inversa a que foi lida.
	#include <iostream.h>
	#include <conio.h>
	void invert( )
	 {
	 char ch;
	 if ((ch=getche( ) )!= '\r')
	 invert( );
	 cout<<ch;
	 }
	void main(void)
	 {
	 cout<<"\n";
	 inverte( );
	 cout<<"\n Aperte qualquer tecla";
	 getch( );
	 return;
	 }
1.16 - O conjunto das diretivas mais comuns reconhecidas pelo pré-processador é o seguinte:
	1 - #define
	2 - #undef
	3 - #include
	4 - #if
	5 - #ifdef
	6 - #ifndef
	7 - #else
	8 - #elif
	9 - #endif
 10 - #error
	1.16.1 - #define é usada para definir constantes simbólicas com nomes apropriados
		 Ex.: #define PI 3.14
	1.16.2 - #undef remove a mais recente definição criada com #define
	1.16.3 - #include causa a inclusão de outro arquivo em nosso programa fonte.
	1.16.4 - #error provoca uma mensagem de erro do compilador em tempo de compilação.
UNIDADE - IV
1.0 - Estruturas
	Há cinco tipos de dados simples que estão pré-definidos no compilador e que nos já conhecemos e já utilizamos. São eles: char, int, float, double e void.
	Estruturas são tipos de variáveis que agrupam dados geralmente desiguais. Os itens de dados de uma estrutura são chamados membros.
	1.1 - definindo a estrutura
		struct nome-do-tipo
		{
		 membros
		};
		onde: struct indica que um novo tipo de dado está sendo definido.
	Ex.:	struct aluno
		{
		 int idade;
		 float altura;
		 char sexo, nome[25];
		};
	1.2 - Acessando os membros da estrutura. Seus membros podem ser acessados por meio do operador ponto.
		nome-da-estrutura.membro
		Ex.: aluno.idade
	1.3 - Combinando declarações 
		struct
		{
		 membros;
		 } nome-das-variáveis;
�
	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;
		 float preco;
		 };
		venda a={20,110.0}, b= {3,16.5}, total;
		Operações simples como a soma não está definida para tipos criados com a palavra struct. A soma deve ser efetuada membro a membro:
		total.pecas=a.pecas+b.pecas;
		total.preco=a.preco+b.preco;
	1.6 - Estruturas aninhadas
		exemplo:
		//mostra estruturas aninhadas
		#include <conio.h>
		#include <iostream.h>
		struct data
		{
		 int dia;
		 char mes[10];
		 int ano;
		 };
		struct venda
		 {
		 int pecas;
		 float preco;
		 data diavenda;
		 };
		void main( )
		 {
		 venda a={20,110.0,{7,”novembro”,1.993}};
		 cout<<“\npecas: “<<a.pecas;
		 cout<<“\npreco: “<<a.preco;
		 cout<<“\ndata: “<<a.diavenda.dia<<“de”<<a.diavenda.ano;
		 getch( );
		 return;
		 }
		Eis a saída:
		
		pecas: 20
		preco: 110
		data: 7 de novembro de 1.993.
	1.7 - Passando estruturas para funções.
		As estruturas podem ser passadas como argumentos de funções de mesma forma que variáveis simples.
	Exemplo: 
	// mostra passagem de estruturas para funções por valor.
	#include <iostream.h>
	#include <conio.h>
	struct venda
	 {
		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;
	 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 primeiraestrutura 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
	
	
	rua
	número
	cpf
	3
	
	
	saldo
	4
	
	
	
	5
	
	
	
struct cliente
 {
	char nome[25];
	char rua[40];
	int numero;
	char cpf[14];
	float saldo;
 };
cliente contas[6];
2.0 - Dada à tabela abaixo
	
	Código
	Nome
	0
	1000
	Alfaiate
	1
	1020
	Analista
	2
	1030
	Vendedor
	.
.
.
	
	
	99
	1099
	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
	
	
	
	1
	
	
	
	2
	
	
	código
	nome
	3
	
	
	
	.
.
.
	
	
	
	99
	
	
	
#include <conio.h>
#include <iostream.h>
#include <string.h>
#include <stdio.h>
void main(void)
 {
	struct tabela
	{
	 char no[25];
	 long codigo;
	};
	tabela tab[100];
	int i,k;
	long codigodesejado;
	clrscr( );
	for (i=0;i<=99;i++)
	 {
		cout<<“\ndigite o nome”<<i;
		gets(tab[i].no);
		cout<<“\ndigite o código”<<i;
		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
	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é
	percentual
	0
	5.000
	1
	5.001
	18.000
	2
	18.001
	50.000
	4
	50.001
	120.000
	7
	120.001
	
	10
	Para os dados de cada imóvel, será adotado o seguinte registro (variável composta heterogênea)
	
	identific
	imposto
	mesesat
 
	 literal	 numérico numérico
#include <conio.h>
#include <string.h>
#include <stdio.h>
#include <iostream.h>
void main(void)
{
	float tab[5][3];
	struct imóvel
	 {
		char ident[8];
		float imposto;
		int meseat;
	 };
	int i,j;
	float multa;
	clrscr( );
	cout<<“\nLeitura da tabela”;
	for (i=0;i<=4;i++)
		for (j=0;j<=2;j++)
		 {
		cout<<“\nDigite um valor “<<i<<“ “<<j;
		cin>>tab[i][j];
		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;
}
�
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.
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.
 
 Exemplo: Podemos verificar o fim de arquivo ao mesmo tempo em que lemos uma linha.Esta é uma forma mais composta.
#include <fstream.h>
#include <conio.h>
void main()
const int max=80;
char buff[max];
ifstream fin(“teste.txt”); // cria arquivo para leitura em modo texto.
while(fin.getline(buff,max)) // enquanto nao eof
 cout<<buff<<‘\n’;
cout<<“\n aperte enter”;
getch();
return;
}
1.9.3- Lendo e gravando um caracter por vez no arquivo.
 Para trabalhar com um único caracter por vez, usamos as funções put() e get(), membros das classes ostream e istream respectivamente.
Ex:
// Grava um caracter por vez num arquivo
#include <fstream.h>
void main()
 {
 ofstream fout(“teste1.txt”);
 char ch;
 while(cin.get(ch)) // Lê um caracter do teclado
 fout.put(ch);
 }
Obs:1. O laço while verifica se o caractere que indica fim-de-arquivo foi digitado no teclado. Este caractere tem código ´\x1a’ e é inserido pressionando-se tecla ctrl-z.
 2. A instrução fout.put(ch) grava o caractere contido em ch no arquivo associado à fout.
 Ex: Lê um caractere por vez de um arquivo.
#include <conio.h>
#include <fstream.h>
void main()
 {
 ifstream fin(“teste1.txt”);
 char ch;
 while (fin.get(ch)) // Lê um caractere do arquivo
 cout<<ch;
 cout<<“\n aperte enter”;
 getch();
return;
}
1.9.4- A função open()
 
 Tanto o construtor como a função open() aceitam a inclusão de um segundo argumento indicandoo modo de abertura do arquivo. Este modo é definido por bits de um byte, onde cada um especifica certo aspecto de abertura do arquivo.
 A lista de modos é definida na classe ios por meio do tipo enum open-mode.
	Modos
	Descrição
	ios::ou
	abre para gravação
	ios::ate
	abre e posiciona no fim do arquivo.Este modo trabalha com leitura e gravação.
	ios::in
	abre para leitura
	ios::app
	grava a partir do fim do arquivo
	ios::trunc
	abre e apaga todo o conteúdo do arquivo
	ios::nocreate
	erro de abertura se o arquivo não existir.
	ios::noreplace
	erro de abertura se o arquivo existir
	ios::binary
	abre em binário(default é texto).
1.9.5-Gravando Objetos.
 As funções apropriadas para o processo de gravação e leitura de objetos são as funções write() e read().
Exemplo: Para mostrar o seu uso, primeiramente criaremos um programa para gravar registros de livros de uma biblioteca.
// Grava objetos em disco.
#include <fstream.h>
#include <stdio.h>
#include <conio.h>
class livro
 {
 private :
 char titulo[50];
 char autor[50];
 int numreg;
 double preco;
 public :
 void novonome();
 };
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;
 - o segundo o tamanho do objeto deve ser convertido para um ponteiro char.
1.9.6- Lendo Objetos
 
 Para ler os objetos gravados pelo programa anterior, usaremos a função read().
Ex: Lê objetos do disco.
#include <fstream.h>
#include <stdio.h>
#include <conio.h>
class livro
 {
 private :
 char titulo[50];
char autor[50];
int numreg;
double preco;
public : void print();
};
void livro::print()
 {
 cout<<“\n titulo: “<<titulo;
 cout<<“\n autor: “<<autor;
 cout<<“\n no. reg :”<<numreg;
 cout<<“\n preco: “<<preco;
 }
void main()
 {
 ifstream fin(“lista.dat”);
 livro li;
 clrscr();
 while(fin.read((char *)&li,sizeof(livro)))
 li.print();
 cout<<“\n aperte qualquer tecla”;
 getch();
 return;
}
onde: - A função read() é membro da classe istream e recebe 2 argumentos:- o primeiro é o endereço do objeto para onde irão os dados lidos;
 - o segundo, tamanho do objeto deve ser convertido para um ponteiro char.
1.9.7- Gravando e Lendo Objetos de um mesmo arquivo.
 Ex: grava e lê objetos de disco.
#include <fstream.h>
#include <stdio.h>
#include <conio.h>
class livro
 {
 private :
 char titulo[50];
 char autor[50];
 int numreg;
 double preco;
 public : void novonome();
 void print();
 };
void livro::novonome()
 {
 cout<<“\n digite titulo”;
 gets(titulo);
 cout<<“\n digite o autor”;
 gets(autor);
 cout<<“\n digite o número do registro”;
 cin>>numreg;
 cout<<“\n digite o preco”;
 cin>>preco;
 clrscr();
 }
void livro::print()
 {
cout<<“\n titulo: “<<titulo;
cout<<“\ autor : “<<autor;
cout<<“\nno. reg. : “<<numreg;
cout<<“\n preco : “<<preco;
}
void main()
{
fstream fio; // Cria objeto de leitura e gravação.
livro li; // Cria objeto livro
fio.open(“lista.dat”,ios::ate || ios::out || ios::in);
do
{
li.novonome();
fio.write((char *)&li,sizeof(livro));
cout<<“\n Mais um livro (s/n) ? “;
 }
while(getche()!=‘n’);
fio.seekg(0); // Coloca o ponteiro no início do arquivo.
cout<<“\n lista de livros do arquivo”;
cout<<“\n ===================================“;
while(fio.read((char * )&li,sizeof(livro)))
 li.print();
cout<<“\n aperte enter”;
getch();
return;
} 
 
onde: - A instrução fstream fio cria um objeto para leitura e gravação.
 - Na instrução fio.open(“lista.dat”,ios::ata | ios::out | ios::in)
vários modos podem ser aplicados simultaneamente por meio do operador OR (||).
 - Usamos “ate” para preservar os objetos que já existem no arquivo e acrescentar novos objetos ao final dele. Usamos “out” e “in” pois queremos executar as duas operações de gravação e de leitura.
 - A instrução fio.seekg(0) modifica a posição corrente do arquivo para o seu início. 
1.9.8- As funções seekg(),tellg(),seekp() e tellp().
 Cada objeto stream está associado a dois valores inteiros chamados ponteiro de posição corrente de leitura e ponteiro de posição corrente de gravação.
 A fonação seekg() permite movimentar a posição corrente de leitura do arquivo para uma posição escolhida.
 A função seekp() executa a mesma tarefa para a posição corrente de gravação.
 A função seekg() tem o seguinte protótipo:
istream&seeg(long pos,sek-dir posição=ios::beg);
 O primeiro argumento indica o deslocamento em bytes a partir da posição escolhida. Quando a função é chamada com um único argumento, a posição é assumida como sendo o início do arquivo (ios::beg).
 O segundo argumento quando usado, deve ser um dos modos seguintes:
ios::beg A partir do início do arquivo
ios::cur A partir da posição corrente
ios::end A partir do fim do arquivo.
Como a leitura do nosso arquivo deve começar no seu início, queremos deslocar o byte a partir do início do arquivo.
 A função tellg() tem o seguinte protótipo:
 long tellg();
 Esta função retorna a posição corrente de leitura(em bytes), sempre a partir do início do arquivo.
1.9.9- Calculando o número de registros do arquivo.
Exemplo: O exemplo mostra o uso das funções seekg() e tellg().
#include <fstream.h>
#include <iostream.h>
#include <stdio.h> // para exit()
#include <conio.h>
class livro
 {
 private :
 char titulo[50];
 char autor[50];
 int numreg;
 double preco;
 public : void novonome();
 void print();
 };
void livro::novonome()
 {
 cout<<“\n digite titulo”;
 gets(titulo);
 cout<<“\n digite autor”;
 gets(autor);
 cout<<“\n digite o número de registros”;
 cin>>numreg;
 cout<<“\n digite o preco”;
 cin>>preco;
 clrscr();
 }
void livro::print()
 {
 cout<<“\n titulo: “<<titulo;
 cout<<“\n autor: “<<autor;
 cout<<”\n No. reg. :”<<numreg;
 cout<<“\n preco : “<<preco;
 }
void main()
 {
ifstream fin;
livro li;
fin.seekg(0,ios::end); //aponta para fim do arquivo, deslocamento zero
long nrec=(fin.tellg())/sizeof(livro);
cout<<“\n numero de registros=“<<nrec;
cout<<“\n insira o numero do registro:”;
cin>>nrec;
int posicao=(nrec-1)*sizeof(livro);
fin.seekg(posicao);
fin.red(char *)&li,sizeof(livro));
fin.seekg(posicao);
fin.read((char *)&li,sizeof(livro));
li.print();
cout<<“\n aperte enter”;
getch();
return;
}
A saída será :
Numero de registros=3
insira o númerode 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.
�
1.10 Exemplos extras de arquivos.
// ------------------------------ Programa inicial para uma agenda
//
// PUC - Minas - Departamento de Ciência da Computação - 02/96
//
// Programa para exercitar conceitos básicos sobre arquivos.
//
//
// ------------------------------ Bibliotecas necessárias
#include <conio.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <fstream.h>
#include <iostream.h>
// ------------------------------ Definicoes globais
#define BOOLEAN int
#define TRUE 1
#define FALSE 0
#define nl '\n'
#define FDA '.'
// ------------------------------ Biblioteca basica
char GetOption(int X, int Y, char * Valida) // GetOption()
{
 // objetivo :
 // colher uma resposta do teclado, posicionando-a na tela
 // nas coordenadas (X,Y) e verificando sua validade
 //
 // parâmetros :
 // X - coluna (ate' 80)
 // 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();
 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;
 }
 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 : ");
 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
				 // 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.";
 }
 }
 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))
 {
 cout << "Listando ...";
 do
 {
 Txt.getline(Pessoa ,30); // lendo
 Txt.getline(Endereco ,60);
 Txt.getline(Telefone ,13);
 Txt.getline(Aniversario,10);
 N++; // contando
 Mostrar(); // mostrando
 }
 while(Pessoa[0] != FDA);
 clrscr();
 PutStr(1, 2, "Termino da leitura.");
 cout << nl << N << " registros lidos.\n";
 getch();
 }
 else
 {
 PutStr(1,3, "Erro : Agenda nao existe. \n\n");
 }
 Pausa();
 return;
}
void Agendas::Procurar(void) // Procurar()
{
 // objetivo :
 // procurar no arquivo,
 // cujo nome será' passado como parâmetro,
 // pelo registro que contenha um determinado nome de pessoa
 //
 // parâmetros :
 // Nome - nome externo do arquivo onde se quer procurar um registro
 //
 long N=1,P;
 char Opção;
 char Procurado[30];
 fstream Txt;
 BOOLEAN Achar=FALSE;
 clrscr();
 cout << "Procurar ...\n\n";