Pascal em 7 Aulas

Be.Cool · 30 de Julho , 2006, 03:25:52 PM

1º Aula
obs: Esse texto foi escrito no EDIT do DOS portanto é melhor visualizado nele!!!

ÚÄÄÄÄÄÄÄÄ¿
³Pref cio³
ÀÄÄÄÄÄÄÄÄÙ
Este curso destina-se a todos aqueles que desejam aprender a linguagem
Pascal, atrav,s do seu mais famoso compilador para a linha IBM/PC, o
Turbo Pascal. O Turbo Pascal , muito mais que um compilador, pois ele ,
uma associa‡,,o entre um compilador, um editor de textos e um
linkeditor. Desta forma, o Turbo Pascal facilita sobre-maneira o ato de
programar. Al,m de tudo isto, o Turbo permite muitas facilidades e
atividades que, com certeza, n,,o estavam planejadas por Niklaus Wirth,
o criador da linguagem Pascal. Levando-se em conta todas essas
considera‡"es, podemos at, mesmo dizer que o Turbo Pascal seria uma
nova linguagem, mais poderosa que a Pascal.

Gostaria de salientar que a melhor forma de aprender uma linguagem ,
programando, assim como a melhor forma de aprender a dirigir , entrar
num autom¢vel e sair com ele por a¡, ou seja, o simples fato de ler
este pequeno e simples curso de linguagem Pascal, n,,o basta para
aprender a programar em Pascal.

Por fim, estou a disposi‡,,o de todos, que se aventurem a acompanhar
este curso, para tirar d£vidas, assim como para receber cr¡ticas.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³I - Introdu‡,,o³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

I.1 - A linguagem Pascal
------------------
Considero que a programa‡,,o deve ser entendida como uma arte ou t,cnica
de se construir algoritmos, sendo que estes s,,o m,todos ou "receitas"
para se resolver problemas. Existem diversas linguagens para se
programar, umas mais adequadas a certos tipos de algoritmos, outras a
outros tipos. No entanto, uma linguagem de programa‡,,o n,,o deve ser um
fim em si mesma, mas um meio, uma ferramenta para se traduzir os
algoritmos em programas a serem executados por computadores. Desta
forma, , importante que os cursos de programa‡,,o n,,o tenham como
objetivo primordial, a perfei‡,,o do conhecimento de uma linguagem
espec¡fica. A linguagem deve t,,o somente, refletir de maneira clara e
facilmente compreens¡vel os aspectos principais dos algoritmos.

Por tudo isso, devemos ter a preocupa‡,,o de ensinarmos aos estudantes a
formula‡,,o sistem tica e met¢dica de algoritmos, atrav,s de t,cnicas
que s,,o caracter¡sticas da programa‡,,o.

Como j disse, existem diversas linguagens de programa‡,,o, podemos
aprender e utilizar quantas desejarmos. Dizer qual a melhor , muito
relativo. H os que defendem o Basic, o Cobol, a C, o Pascal e tantas
outras. Bom, mas a pergunta crucial que fa‡o aqui ,: Qual a primeira
linguagem a ser aprendida? Neste ponto, defendo a linguagem Pascal.

De acordo com observa‡"es feitas por diversos professores, inclusive
por mim, a maior parte das pessoas ficam ligadas para sempre ... primeira
linguagem que aprenderam, e quando aprendem uma nova linguagem, tˆm uma
certa tendˆncia em desenvolver os algoritmos segundo o vocabul rio e
regras sint ticas da primeira linguagem, s¢ que escritas na nova.

Por este motivo, acho que a escolha da primeira linguagem a ser
ensinada deve ser feita de forma judiciosa.

A primeira linguagem deve, desta forma, ser tal que forne‡a ao aprendiz
a possibilidade de desenvolver algoritmos l¢gicos, sistem ticos,
facilmente compreens¡veis segundo os m,todos modernos de programa‡,,o
e deve at, possibilit -lo a "dar asas ... sua imagina‡†o".

I.2 - Por que Turbo Pascal?
---------------------
Um computador n,,o pode entender nem t,,o pouco executar instru‡"es em
linguagens de alto n¡vel. Ele s¢ entende linguagem de m quina. Desta
forma, os programas em linguagens de alto n¡vel devem ser traduzidos
antes de serem executados pelo computador. Quem faz essa tradu‡,,o s,,o
os programas tradutores.

Existem basicamente 2 tipos de programa tradutor: o interpretador; e o
compilador;. Os dois aceitam como entrada um programa em linguagem de
alto n¡vel (fonte) e produzem como sa¡da um programa em linguagem de
m quina (objeto). A diferen‡a entre eles est na forma de executar a
tarefa de tradu‡,,o. O interpretador traduz para a linguagem de m quina
e roda uma linha por vez, at, que todo programa seja executado. J o
compilador traduz para a linguagem de m quina todo o programa fonte e
s¢ ent,,o ele , executado.

Existem linguagens de programa‡,,o interpretadas e compiladas. O cobol ,
compilado, o basic pode ser tanto compilado como interpredado e assim
por diante. A linguagem Pascal , tradiconalmente compilada.

Por outro lado, o processo de compila‡,,o , de certa forma moroso, pois
deve seguir as seguintes etapas:

1-) Devemos utilizar um editor de textos para escrever e armazenar em
disco o nosso programa fonte.

2-) Utilizar um compilador para traduzir o programa fonte para um
programa em linguagem de m quina.

3-) Finalmente, devemos juntar ao programa compilado as diversas
rotinas necess rias que, normalmente, ficam armazenadas numa
biblioteca.

Ap¢s todo esse processo, suponha que vocˆ chegue ... conclus,,o de que o
programa tenha que sofrer modica‡"es, pois bem, vocˆ ter que repetir
os trˆs passos descritos, e assim sucessivamente at, que o programa
fique ao seu gosto.

O compilador Turbo Pascal facilita todo esse processo, pois ele possui
numa forma integrada, um editor de textos compat¡vel com o Wordstar,
um compilador e um linkeditor. O processo de compila‡,,o pode ser feito
tanto em disco como em mem¢ria, o que faz com que ele seja muito
r pido. Al,m disso, o Turbo Pascal atende aos padr"es da linguagem
Pascal definidos por Niklaus Wirth, "o pai da linguagem".

Na realidade, o Turbo Pascal vai muito al,m, pois ele possui in£meras
procedures e fun‡"es a mais do que as existentes no padr,,o da linguagem
Pascal.

I.3 - Equipamento necess rio.
----------------------
Todos os exemplos e programas contidos neste curso, foram escritos num
compat¡vel 486DX 50 com dois acionadores de discos de dupla face e
alta densidade, um winchester de 340 megabytes,um monitor monocrom tico
e 640 Kbytes de mem¢ria RAM. No entanto, a configura‡,,o m¡nima poderia
ser um IBM/PC-XT com um winchester de 40M.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³II - Um programa em Pascal³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

II.1 - O primeiro programa
-------------------
Bom, acho que aqueles que nunca tiveram a oportunidade de fazer um
programa em Pascal, devem estar muito curiosos para saber como deve ser
o seu aspecto. Por isso, antes de prosseguir com os meandros da
linguagem Pascal, eu mostrarei um pequeno programa devidamente
comentado.

{********************************************************
PROGRAMA EXEMPLO.PAS -> Pequeno exemplo de um programa
em Pascal. Tem a finalidade
£nica e exclusiva de mostrar
os diversos componentes de um
programa em Pascal.
********************************************************}

{ Tudo que estiver entre chaves s,,o coment rios e n,,o s,,o
levados em conta pelo compilador.}

Program Primeiro_Exemplo; { este e o cabecalho do
programa }
USES Crt; { Aqui estou utilizando uma UNIT, chamada CRT,
existem v rias, e inclusive vc pode criar
as suas. Nestas units temos procedures e
functions previamente compiladas. }

Label
fim; { a partir deste instante posso
utilizar o label fim }

Const
Meu_Nome = 'Thelmo'; { nesta rea podemos definir todas
as constantes que quisermos
utilizar no programa }
Type
n = (BRASILEIRA,PORTUGUESA,INGLESA,FRANCESA,ALEMA,AMERICANA);

{ o Turbo Pascal possui diversos tipos de vari veis pre-
definidas, mas tamb,m permite definir novos tipos na
sub rea type }

Var idade : integer;
altura : real;
nome : string[30];
sexo : char;
nacionalidade : n;

{ todas as vari veis que forem utilizadas no corpo do programa
dever,,o ser declaradas na sub rea Var }

Procedure Linha; { a procedure equivale ao conceito de sub-rotina.
Sua estrutura pode se tornar t,,o complexa como
de um programa. Esta procedure,tra‡a uma linha
na posi‡,,o atual do cursor }
Var i:integer;
Begin
For i:=1 to 80 do Write('-');
end;

Function Soma(x,y:integer):integer;

{ o Turbo Pascal possui diversas fun‡"es pr,-definidas, mas o
programador tamb,m pode definir as suas proprias }

Begin
Soma:=x+y;
end;

{ Podemos definir quantas procedures e functions quisermos }

{ Aqui come‡a o programa propriamente dito }

Begin
ClrScr; { apaga a tela }
Linha; { Executa a procedure linha }
Writeln('Meu nome e -------> ',Meu_Nome);
Linha;
Write('Qual o seu nome ----> ');
Readln(Nome);
Linha;
Write('Qual a sua idade ---> ');
Readln(idade);
Linha;
Writeln('nossas idades somam --> ',Soma(34,idade));
Linha;
goto fim;
{ estas linhas ser,,o puladas }
nacionalidade:=BRASILEIRA;
Write('Minha nacionalidade e brasileira');
fim:
Write('Prazer em conhece-lo');
End.

II.2 - Estrutura de um programa em Pascal
----------------------------------
Todo programa em Pascal , subdividido em 3 reas:

- cabe‡alho do programa
- rea de declara‡"es
- corpo do programa

Na defini‡,,o padr,,o da linguagem Pascal, o Cabe‡alho do programa ,
obrigat¢rio, no entanto, no Turbo Pascal ele , opcional. A rea de
declara‡"es , subdividida em seis sub- reas, a saber:

- Label
- Const
- Type
- Var
- Procedures
- Functions

Darei agora, uma breve explica‡,,o de cada sub rea, pois mais para
frente estudaremos cada uma delas com profundidade. Na sub rea Label,
devemos declarar todos os labels que forem utilizados no corpo do
programa. Os labels s,,o utilizados em conjunto com a instru‡,,o goto.
Todas as constantes que formos utilizar no nosso programa, podem se
assim desejarmos, ser definidas na sub rea Const.

O Turbo Pascal tem basicamente 6 tipos de vari veis pr,-definidas a
saber: Integer, Real, Byte, Boolean, Char e String. No entanto, podemos
definir novos tipos de vari veis na sub rea Type.

Todas as vari veis utilizadas no programa devem ser declaradas na
sub rea Var, pois a aloca‡,,o de espa‡o de mem¢ria para as vari veis ,
feita durante a compila‡,,o. Na sub rea Procedures, podemos definir
quantas sub-rotinas quisermos. Elas s,,o chamadas durante o programa
pelos seus respectivos nomes.

Finalmente, na sub rea Functions podemos definir novas fun‡"es que
depois poderemos utilizar no programa embora o Turbo Pascal possua
in£meras fun‡"es pr,-definidas. Estas sub reas s¢ s,,o obrigat¢rias caso
n¢s estejamos precisando. Exemplo: se n,,o vamos utilizar vari veis no
nosso programa (coisa rara) ent,,o n,,o precisamos utilizar a sub rea
Var. De acordo com a defini‡,,o padr,,o da Linguagem Pascal, estas
sub reas devem aparecer na sequˆncia que foi dada anteriormente, ou
seja, Label - Const - Type - Var - Procedures - Functions. Mas no Turbo
Pascal isto , livre.

Por fim, como dito no programa exemplo, existe a possibilidade de se
usar a declara‡,,o USES, que nos permite utilizar UNITS que nada mais
s,,o do que bibliotecas de fun‡"es e procedures previamente declaradas.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³III - No‡"es B sicas preliminares.³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

III.1 - Elementos b sicos do Turbo Pascal
---------------------------------

III.1.1 - Caracteres utilizados

Os caracteres que podem ser utilizados no Turbo Pascal s,,o divididos
em :

Letras : 'A' at, 'Z', 'a' at, 'z'

N£meros : 0,1,2,3,4,5,6,7,8 e 9

Especiais: + - * / = ^ < > ( ) [ ] { } . , : ; ' # $

Observa‡"es:

1-) O Turbo Pascal n,,o faz distin‡,,o entre letras mai£sculas e
min£sculas, de tal forma que no desenvolvimento deste curso eu
utilizarei os dois tipos da forma que achar mais conveniente.

2-) Embora na maioria das linguagens o sinal de atribui‡,,o de valores a
vari veis seja o =, em Pascal, o s¡mbolo de atribui‡†o , :=,
exemplos:

A = 100 em Basic
A := 100 em Pascal

3-) Dois pontos em seguida (..) indica um delimitador de faixa,exemplo:

1..30 --> todos inteiros entre 1 e 30 inclusive.

III.1.2 - Palavras reservadas

As palavras reservadas do Turbo Pascal s,,o palavras que fazem parte da
sua estrutura e tˆm significados pr,-determinados. Elas n,,o podem ser
redefinidas e n,,o podem ser utilizadas como identificadores de
vari veis, procedures, functions etc. Algumas das palavras reservadas
s,,o:

absolute(*) and array begin
case const div do
downto else end external(*)
file for forward function
goto if in inline(*)
label mod nil not
of or packed procedure
program record repeat set
shl(*) shr(*) string(*) then
to type until var
while with xor(*)

(*) --> n,,o definidos no Pascal Standard

III.1.3 - Identificadores pr,-definidos

O Turbo Pascal possui in£meros identificadores pr,-definidos, que n,,o
fazem parte da defini‡,,o padr,,o da linguagem Pascal. Esses
identificadores consistem em Procedures e Functions, que podem ser
utilizados normalmente na constru‡,,o de programas. Exemplos:

ClrScr : limpa a tela de v¡deo
DelLine : deleta a linha em que est o cursor e assim por diante.

Constantemente, novas procedures e functions est,,o sendo criadas pela
Borland International (criadora do Turbo Pascal), aumentando desta
forma o n£mero de identificadores. S,,o UNITS que tornam o Turbo Pascal
mais poderoso do que ele j ,.

Regras para forma‡,,o de identificadores:

O usu rio tamb,m pode definir seus pr¢prios identificadores, na verdade
n¢s somos obrigados a isso. Nomes de vari veis,de labels,de procedures,
functions, constantes etc. s,,o identificadores que devem ser formados
pelo programador. Mas para isso existem determinadas regras que devem
ser seguidas:

1-) O primeiro caractere do identificador dever ser obrigatoriamente
uma letra ou um underscore (_).
2-) Os demais caracteres podem ser letras, d¡gitos ou underscores.
3-) Um identificador pode ter no m ximo 127 caracteres.
4-) Como j dissemos anteriormente, n,,o pode ser palavra reservada.

Exemplos de identificadores v lidos:

Meu_Nome
MEU_NOME igual ao anterior
__Linha
EXemplo23

Exemplos de identificadores n,,o v lidos:

2teste come‡a com n£mero
Exemplo 23 tem um espa‡o

III.1.4 - Coment rios

Coment rios s,,o textos que introduzimos no meio do programa fonte com a
inten‡,,o de torn -lo mais claro.

Be.Cool · 30 de Julho , 2006, 03:36:54 PM

2° Aula

III.2.3 - A declara‡,,o type

Al,m dos tipos de dados pr,-definidos no Turbo Pascal, podemos tamb,m
definir novos tipos atrav,s da declara‡,,o Type. A sua sintaxe geral ,:

Type identificador = (valor1,valor2,valor3,valor4, ... ,valorN);

O identificador deve seguir as regras dadas anteriormente e entre os
parentˆses est,,o os valores que podem ser assumidos. Exemplos:

Type
cor = (azul,vermelho,branco,verde,amarelo);
dia_£til = (segunda,ter‡a,quarta,quinta,sexta);
linha = string[80];
idade = 1..99;

(* a partir deste instante, al,m dos tipos de dados pr,-definidos,
podemos tamb,m utilizar os novos tipos definidos cor,dia_£til,
linha e idade *)

Var
i : integer;
d : idade;
nome : linha;
dia : dia_£til;
cores : cor;

(* etc. *)

Observa‡,,o: Quando damos os valores que os dados podem assumir atrav,s
da declara‡,,o type, o Turbo Pascal assume, automaticamente,
que o valor da direita vale mais que o da esquerda e assim
por diante. Por exemplo: no caso da defini‡,,o de cor,amarelo
vale mais que verde, que por sua vez vale mais que branco e
assim por diante.

III.3 - Constantes
----------

III.3.1 - A declara‡,,o const

Nesta sub rea, podemos definir tantas constantes quantas quisermos.
Sintaxe:

Const
Meu_nome = 'Thelmo';
cor_preferida = 'verde';
n£mero_m ximo = 24345;

(* e assim por diante *)

Toda vez que nos referirmos ...s constantes acima, o Turbo Pascal
substitui-las- pelos seus respectivos valores.

III.3.2 - Constantes pr,-definidas

Existem algumas constantes pr,-definidas e que podemos utiliz -las sem
ter que declar -las. S,,o elas:

PI = 3.1415926536E + 00
FALSE
TRUE
NIL Pointer nulo, veremos mais adiante.
MAXINT = 32767

III.3.3 - Constantes tipadas

A declara‡,,o de vari veis na sub rea Var, apenas reserva espa‡o de
mem¢ria para elas, mas n†o as inicializa, ou seja, at, que se atribua
valores a elas, seus valores ser,,o desconhecidos. Sob certas
circunstƒncias, seria interessante que pud,ssemos ao mesmo tempo em que
declaramos a vari vel, dar seu valor inicial. Isto , poss¡vel com o
conceito de constante tipada cuja sintaxe ,:

Const vari vel : tipo = valor;

Exemplos:

const Contador : integer = 100;
c : char = 'A';

Estamos definindo duas vari veis, uma chamada contador que , inteira
e vale inicialmente 100, e outra chamada c que , do tipo char e cujo
valor inicial , 'A'.

III.4 Operadores
----------

III.4.1 - Operadores aritm,ticos

+ adi‡,,o
- subtra‡,,o
* multiplica‡,,o
/ divis,,o entre n£meros reais
DIV divis,,o entre n£meros inteiros
MOD resto da divis,,o

(*******************************************************)
PROGRAMA EXEMPLO : Mostra como utilizar operadores
aritmeticos
********************************************************)

Program Operadores_aritimeticos;
Uses CRT;

Var x,y,z : integer;
r1,r2 : real;

Begin
ClrScr; (* limpa a tela *)
x:=10;
y:=20;
z:=x+y;
writeln(z); (* escreve o valor de z na tela de
video *)
x:= 20 DIV 3;
y:= 20 MOD 3;
writeln(x); (* escreve 6 na tela *)
writeln(y); (* escreve 2 na tela *)
r1:=3.24;
r2:=r1/2.3;
writeln(r2);
end.

III.4.2 - Operadores l¢gicos

AND E l¢gico
OR OU l¢gico
XOR OU EXCLUSIVO l¢gico

Estes operadores s¢ aceitam como operandos, valores l¢gicos, ou seja :
TRUE e FALSE .

A opera‡,,o AND resulta em TRUE se e somente se todos os operandos forem
TRUE, se um deles ou mais de um for FALSE ent,,o o resultado ser FALSE.

A opera‡,,o OR resulta TRUE quando pelo menos um dos operandos for TRUE.

A opera‡,,o XOR resulta TRUE quando os operandos forem diferentes entre
si, isto ,, quando um for TRUE o outro dever ser FALSE.

Exemplo:
(*******************************************************)
PROGRAMA UTILIZANDO OS OPERADORES LOGICOS
(*******************************************************)

Program operadores_logicos;
Uses CRT;

Var x,y : boolean;

Begin
x:=TRUE;
y:=FALSE;
Writeln( x OR y ); (* escreve TRUE *)
Writeln( x AND y ); (* escreve FALSE *)
Weiteln( x XOR y ); (* escreve TRUE *);
End.

III.4.3 - Operadores relacionais

O Turbo Pascal possui ao todo 7 operadores relacionais que s,,o muito
utilizados nas tomadas de decis"es, s,,o eles:

= igual
<> diferente
> maior que
< menor que
>= maior ou igual que
<= menor ou igual que
IN testa se um elemento est incluso em um conjunto

Exemplos:

1-) Se A=30 e B=50 ent,,o

( A = B ) FALSE
( A < B ) TRUE

2-) Se A=TRUE e B=FALSE

( A <> B ) TRUE
( A = B ) FALSE

3-) Se A=50 , B=35, C='A' , D='B'

( ( A < B ) OR ( C < D ) ) TRUE

A avalia‡,,o ser verdadeira se uma ou outra express,,o for
verdadeira, no caso, como C < D ent,,o a resposta , TRUE

III.4.4 - Operadores entre bits

Os operadores entre bits s¢ podem ser aplicados em dados dos tipos byte
ou integer e o resultado , do tipo integer. Eles agem bit a bit e podem
ser aplicados na nota‡,,o hexadecimal ou decimal. S,,o eles:

SHL - SHift Left

Desloca n bits ... esquerda. Durante o deslocamento, os bits ... esquerda
s,,o perdidos e d¡gitos zeros preenchem a posi‡,,o direita. Exemplos:

1-) Se X = 00010101 ent,,o

X shl 2 = 01010100
X shl 5 = 10100000

2-) 55 shl 3 = 184

55 = 00110111 deslocando 3 ... esquerda ficaria:
10111000 que , igual a 184

3-) $F0 shl 2 = $C0

$F0 = 11110000 deslocando 2 ... esquerda ficaria:
11000000 que , igual a $C0

SHR - SHift Right

Desloca n bits ... direita. Durante o deslocamento,os bits ... esquerda s,,o
preenchidos com zeros e os da direita s,,o perdidos. Exemplos:

1-) Se X = 10101100 ent,,o

X shr 3 = 00010101
X shr 6 = 00000010

2-) 55 shr 3 = 6

55 = 00110111 deslocando 3 ... direita ficaria:
00000110 que , igual a 6

3-) $F0 shr 2 = $3C

$F0 = 11110000 deslocando 2 ... direita ficaria:
00111100 que , igual a $3C

OBS: J sei, vc n,,o manja de base 2, eh eh eh, entonces complica, bem
vou tentar em poucas palavras explicar a base 2. N¢s operamos na
base 10, porque trabalhamos com 10 algarismos, 0..9, certo? Bem na
base 2 operamos somente com 2 algarismos, o 0 e o 1. Dessa forma,
temos que representar todos os n£meros da base 10 utilizando
somente o 0 e 1. Parece complicado ? Nem tanto, veja abaixo a
correspondˆncia:

BASE 10 BASE 2
0 0
1 1
2 10
3 11
4 100
5 101
6 110
7 111
8 1000
9 1001
10 1010
11 1011
e assim por diante

Para converter um n£mero da base 10 para a base 2, basta dividir o
n£mero, o qual queremos converter, por dois sucessivamente at, que o
resto seja 0, depois pegamos os restos de baixo para cima, exemplo:

(23) --> ( )
10 2

23 / 2 d 11 e sobra 1
11 / 2 d 5 e sobra 1
5 / 2 d 2 e sobra 1
2 / 2 d 1 e sobra 0
1 / 2 d 0 e sobra 1

Portanto (23) --> (10111)
10 2

Para coverter da base 2 para a base 10, devemos fazer ao contr rio:

(10111) --> ( )
2 10

4 3 2 1 0
( 1 0 1 1 1 )

4 3 2 1 0
1 x 2 + 0 x 2 + 1 x 2 + 1 x 2 + 1 x 2 =
16 + 0 + 4 + 2 + 1 = 23

NOT

O operador NOT nega os bits, isto , os bits iguais a 1 se tornam 0 e os
bits zero se tornam 1. Devemos lembrar, no entanto, que os inteiros
possuem 2 bytes, portanto,ao se trabalhar com n£meros decimais inteiros
ser afetado o byte de mais alta ordem e tamb,m o sinal. Exemplo:

NOT (255) = -256

Para suprimir este problema, vocˆ deve trabalhar com bytes:

Program Exemplo;
Uses CRT;

Var i,j : Byte;

Begin
ClrScr;
i:=255;
j:=NOT(i);
Writeln(j); (* ser escrito 0 *)
End.

AND

Este operador realiza a opera‡,,o E l¢gico bit a bit. Relembrando, a
opera‡,,o E resulta em 1 se e somente se os dois operandos forem iguais
a 1, caso contr rio, o resultado ser igual a 0. Exemplos:

1-) $0F AND $F0 = $0 pois
$0F = 00001111
$F0 = 11110000
00001111 AND 11110000 = 00000000

2-) 255 AND 55 = 55 pois
255 = 11111111
55 = 00110111
11111111 AND 00110111 = 00110111

3-) 34 AND 76 = 0 pois
34 = 00100010
76 = 01001100
00100010 AND 01001100 = 00000000

OR

Este operador realiza a opera‡,,o OU l¢gico bit a bit. Relembrando, a
opera‡,,o OU resulta em 1 se um ou os dois operandos forem iguais a 1.
Exemplos:

1-) $0F OR $F0 = $FF pois
$0F = 00001111
$F0 = 11110000
00001111 OR 11110000 = 11111111

2-) 255 OR 55 = 255 pois
255 = 11111111
55 = 00110111
11111111 OR 00110111 = 11111111

3-) 34 OR 76 = 110 pois
34 = 00100010
76 = 01001100
00100010 OR 01001100 = 01101110

XOR

Este operador realiza a opera‡,,o OU EXCLUSIVO l¢gico bit a bit.
Relembrando, a opera‡,,o OU EXCLUSIVO resulta em 1 se os operandos forem
diferentes entre si . Exemplos:

1-) $0F XOR $F0 = $FF pois
$0F = 00001111
$F0 = 11110000
00001111 XOR 11110000 = 11111111

2-) 255 XOR 55 = 200 pois
255 = 11111111
55 = 00110111
11111111 XOR 00110111 = 11001000

3-) 34 XOR 76 = 110 pois
34 = 00100010
76 = 01001100
00100010 XOR 01001100 = 01101110

III.4.5 - Concatena‡,,o

Esta opera‡,,o , representada pelo sinal de adi‡,,o, ou seja, +. Os
operandos devem ser do tipo string ou char. Exemplo:

'Isto , uma ' + 'string' = 'Isto , uma string'

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³IV - Entrada e sa¡da de dados³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

IV.1 - Write e Writeln
---------------
Estas s,,o as principais procedures destinadas a exibir todos os tipos
de dados no v¡deo. A diferen‡a entre write e writeln reside no fato de
que a procedure write escreve o parƒmetro, e mant,m o cursor do lado
daquilo que foi escrito, enquanto que writeln passa o cursor para a
pr¢xima linha. Estas procedures possuem 3 formas de sintaxes, a saber:

Primeira forma:

Write(parƒmetro_1,Parƒmetro_2, ...);

Exemplo:

Program Exemplo;
Uses CRT;
Var i : integer;
r : real;
c : char;
s : string[20];

Begin
ClrScr; (* apaga a tela e coloca o cursor em 1,1 *)
Writeln('Exemplos de aplicacao de writeln e write');
writeln; (* apenas pula uma linha *)
i:=100;
r:=3.14;
c:='A';
s:='interessante';
writeln('Valor de i e igual a ',i);
write('valor de r = ');
writeln(r);
writeln(c,' ',s);
end.

Este programa resultaria na seguinte tela:

---------------------------------------------------------
Exemplos de aplicacao de writeln e write

Valor de i e igual a 100
valor de r = 3.1400000000E+00
A interessante
---------------------------------------------------------

Segunda forma:

Write(parƒmetro : n);

onde n , um n£mero inteiro que determina quantas colunas o cursor deve
ser deslocado ... direita, antes do parƒmetro ser escrito. Al,m disso, o
parƒmetro , escrito da direita para a esquerda, exemplo:

Program Exemplo;
Uses CRT;
Begin
Writeln('A');
Writeln('A':5);
end.

Resultaria a seguinte tela:
---------------------------------------------------------
A
.....A
---------------------------------------------------------
Os pontos representam espa‡os em branco

Terceira forma:

Write(parƒmetro : n : d);

Neste caso, n tem a mesma fun‡,,o que o caso anterior sendo que d
representa o n£mero de casas decimais. Obviamente, parƒmetro ter que
ser do tipo Real. Exemplo:

Program Exemplo;
Uses CRT;
Var r : real;

Begin
ClrScr;
r:=3.14156;
Writeln(r);
Writeln(r:10:2);
End.

resultaria a seguinte tela:
---------------------------------------------------------
3.1415600000E+00
3.14
---------------------------------------------------------

IV.2 - Read e Readln
-------------

Estas procedures s,,o utilizadas para fazer leitura de dados via
teclado. A procedure Read lˆ um dado do teclado at, que se pressione a
tecla ENTER, sendo que cada tecla digitada , ecoada para o v¡deo. Ap¢s
pressionarmos ENTER, o cursor permanecer no mesmo lugar. J , a
procedure Readln faz a mesma coisa s¢ que o cursor passa para a pr¢xima
linha. A sintaxe geral para estas procedures ,:

Read (Var_1,Var_2,Var_3,...);

Ao se digitar os valores das vari veis pedidas, deve-se separ -los por
espa‡os.

Exemplo 1:

Program teste;
Uses CRT;

Var a,b,c:integer;

Begin
clrscr;
readln(a,b,c);
writeln (a,' ',b,' ',c);
end.

Exemplo 2:

Program teste;
Uses CRT;

Var i : integer;
r : real;
c : char;
s : string[10];

Begin
ClrScr;
Write('Digite um numero inteiro ------> ');
Readln(i);
Write('Digite um numero real ---------> ');
Readln(r);
Write('Digite um caractere -----------> ');
Readln(c);
Write('Digite uma string -------------> ');
Readln(s);
Writeln;Writeln; (* pula duas linhas *)
Writeln(i);
Writeln(r);
Writeln(c);
Writeln(s);
End.

Exemplo 3:

(*******************************************************)
PROGRAMA AREA_DE_TRIANGULOS : calcula area de triangulos
(*******************************************************)

Program Area_de_Triangulos;
Uses CRT;

Var Base, (* base do triangulo *)
altura: (* altura do triangulo *)
Real;

Begin
ClrScr;
Writeln('CALCULO DA AREA DE TRIANGULOS':55);
Writeln;
Write('Valor da base ------> ');
Readln(base);
Writeln;
Write('Valor da altura ----> ');
Readln(altura);
Writeln;
Writeln;
Writeln('Area do triangulo = ',base*altura/2 : 10 : 2);
End.

ReadKey: Lˆ uma tecla do teclado, sem que seja necess rio pressionar a
tecla ENTER

Program Exemplo;
Uses CRT;
Var tecla:char;
Begin
Write('digite uma tecla ->');
Tecla:=readkey;
Writeln;
writeln('vc digitou ',tecla);
end.

IV.3 - Impressora
----------

Podemos enviar dados para a impressora atrav,s das procedures Write e
Writeln. Para tanto, devemos colocar, antes dos parƒmetros a serem
enviados ... impressora, o nome l¢gico LST. Exemplo:

Writeln('isto vai para o v¡deo');
Writeln(lst,'isto vai para a impressora',' e isto tamb,m');

IV.4 - Fun‡"es e procedures para controle de v¡deo
-------------------------------------------

IV.4.1 - ClrScr

Esta procedure tem a finalidade de limpar a tela de v¡deo e colocar o
cursor na primeira coluna da primeira linha. A tela de v¡deo , dividida
em 80 colunas e 25 linhas. O canto superior esquerdo tem coordenadas
(1,1) e o inferior direito (80,25).

IV.4.2 - Gotoxy(x,y)

Move o cursor para a coluna x e linha y.

Exemplo:

Program Exemplo;
Uses CRT;

Var x,y : Byte;

Begin
ClrScr;
Gotoxy(10,2);
Write('Coluna 10 da linha 2');
x:=40;
y:=10;
Gotoxy(x,y);
Write('Coluna 40 da linha 10');
End.

IV.4.3 - ClrEol

Esta procedure limpa desde a posi‡,,o atual do cursor at, o final da
linha.

IV.4.4 - CrtExit

Envia para a tela de v¡deo a string de finaliza‡,,o definida na
instala‡,,o

IV.4.5 - CrtInit

Envia para a tela de v¡deo a string de inicializa‡,,o definida na
instala‡,,o.

IV.4.6 - Delline

Procedure que elimina a linha em que est o cursor. As linhas
posteriores sobem, ocupando a que foi eliminada.

Exemplo:

Program exemplo;
Uses CRT;
Begin
ClrScr;
Writeln('linha 1');
Writeln('linha 2');
Writeln('linha 3');
Writeln('linha 4');
Gotoxy(1,2); (* posicionei o cursor no in¡cio da linha 2 *)
Delline;
End.

O programa anterior ir provocar a seguinte tela:
---------------------------------------------------------
linha 1
linha 3
linha 4
---------------------------------------------------------
Repare que a string 'linha 2' foi eliminada.

IV.4.7 - HighVideo

Coloca o v¡deo no modo normal. Esta procedure , equivalente a
NormV¡deo.

IV.4.8 - InsLine

Esta procedure faz examente o contr rio de Delline, ou seja, insere uma
linha na posi‡,,o atual do cursor.

Exemplo

Program Exemplo;

Begin
ClrScr;
Writeln('linha 1');
Writeln('linha 2');
Writeln('linha 3');
Writeln('linha 4');
Gotoxy(1,3); (* cursor na 1a. coluna da 3a. linha *)
InsLine;
Write('teste');
Gotoxy(1,20);
End.

Este Programa provocar a seguinte tela
---------------------------------------------------------
linha 1
linha 2
teste
linha 3
linha 4
---------------------------------------------------------

IV.4.9 - LowVideo

Coloca o v¡deo em baixa intensidade at, que se execute a procedure
NormVideo ou HighVideo.

IV.4.10 - NormVideo

O mesmo que HighVideo

IV.4.11 - TextBackGround

Esta procedure seleciona a cor do fundo sobre o qual o texto ser
escrito. Sua sintaxe geral ,:

TextBackGround(cor);

Tabela de cores

0 Black Preto
1 Blue Azul
2 Green Verde
3 Cyan Ciano
4 Red Vermelho
5 Magenta Magenta
6 LightGray Cinza-claro

N¢s podemos entrar com o n£mero ou o nome da cor em inglˆs

Exemplo:

Program Exemplo;
Uses CRT;

Begin
ClrScr;
WriteLn('teste');
TextBackGround(7);
Writeln('teste');
TextBackGround(Brown);
Writeln('teste');
End.

IV.4.12 - TextColor

Esta procedure permite selecionar a cor com que o texto ser imprimido.

Tabela de cores

0 Black Preto
1 Blue Azul
2 Green Verde
3 Cyan Ciano
4 Red Vermelho
5 Magenta Magenta
6 Brown Marrom
7 LightGray Cinza-claro
8 DarkGray Cinza-escuro
9 LightBlue Azul-claro
10 LightGreen Verde-claro
11 LightCyan Ciano-claro
12 LightRed Vermelho-claro
13 LightMagenta Magenta-claro
14 Yellow Amarelo
15 White Branco
16 Blink Piscante

Exemplo:

Program Exemplo;
Uses CRT;

Begin
Clrscr;
TextBackGround(7);
TextColor(black);
writeln('teste');
TextColor(black+blink);
write('teste');
End.

IV.4.13 - Window

Sintaxe: Window(x1,y1,x2,y2);

Esta procedure tem o poder de definir uma janela de texto cujo canto
esquerdo superior , x1,y1 e canto inferior direito , x2,y2. Ap¢s esta
instru‡,,o, as instru‡"es ClrScr, Write Writeln agem somente dentro da
janela rec,m definida. A instru‡,,o Gotoxy passa a utilizar como
referencial o ponto x1,y1 que passa a ser considerado 1,1.

Exemplo:

Program Exemplo;
Uses CRT;
Begin
Window(10,10,70,20);
ClrScr; (* limpa somente a janela *);
Writeln('teste'); (* escreve 'teste' em 10,10 *)
End.

IV.4.14 - WhereX

Fun‡,,o que retorna o n£mero da coluna onde est o cursor.

IV.4.15 - WhereY

Fun‡,,o que retorna o n£mero da linha onde est o cursor.

IV.5 - Controle do teclado
-------------------

IV.5.1 - Kbd

Quando quisermos ler dados do teclado e que n,,o sejam ecoados para o
monitor de v¡deo at, que sejam processados e aceitos, n¢s podemos
utilizar a seguinte sintaxe:

Read(Kbd,Vari vel);

No caso de n£meros inteiros ou reais, o n£mero s¢ ser aceito quando
pressionarmos a tecla , no caso de vari veis do tipo char, o
caractere ser aceito sem que seja necess rio pressionar a tecla
, idem para o tipo string.

Exemplo:

Program Exemplo;
Uses CRT;
Var i:integer;

Begin
ClrScr;
Write('Entre com um inteiro --> ');
Readln(Kbd,i);
Writeln(i);
End.

IV.5.2 - BufLen

Buflen , uma vari vel interna pr,-definida em Turbo Pascal cujo valor
inicial , 126.Ela cont,m o n£mero m ximo de caracteres aceitos por Read.

Exemplo:

Program Exemplo;
Uses CRT;

Var i : Integer;

Begin
ClrScr;
Writeln(Buflen); (* escreve 126 *)
Buflen:=2;
Write('Digite um inteiro --> ');
Readln(i); (* se vocˆ tentar digitar inteiros com
mais de dois d¡gitos, readln n,,o
permitir *)
End.

IV.5.3 - Keypressed

O identificador Keypressed , uma fun‡,,o especial do Turbo Pascal que
retorna um valor booleano - TRUE se uma tecla foi pressionada, ou FALSE
caso contr rio. Ela , muito utilizada para detectar teclas pressionadas
no teclado.

Exemplo

Program Exemplo;
Uses CRT;
Begin
ClrScr;
Write('Pressione uma tecla -> ');
Repeat until Keypressed; (* repita at, que uma tecla
seja pressionada. O comando
Repeat Until ser estudado
mais adiante *)
End.

Be.Cool · 30 de Julho , 2006, 03:40:53 PM

3° Aula

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³V - Comandos para controle do fluxo do programa³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

V.1 - If Then Else
------------

O comando If permite ao programa tomar decis"es. Ele pode ter duas
sintaxes:

Primeira sintaxe:

If Then Comando;

Express,,o_l¢gica pode ser simples ou at, rela‡"es complexas. Se a
express,,o_l¢gica resultar verdadeira (TRUE), ent,,o o comando ser
executado caso contr rio n,,o. Para os casos em que tivermos mais de um
comando para serem executados, eles dever,,o vir delimitados pelas
palavras Begin e End.

If Then
Begin
Comando_1;
Comando_2;
Comando_3;
. . .
End;

No caso acima, se express,,o_l¢gica for TRUE ent,,o todos comandos
inclusos entre as palavras Begin e End ser,,o executados, caso contr rio
n,,o.

Segunda sintaxe:

If Then Comando_1
Else Comando_2;

Neste caso, se express,,o_l¢gica for TRUE ent,,o comando_1 ser executado
e comando_2 n,,o, caso contr rio, comando_2 ser executado e comando_1
n,,o. Repare que n,,o temos ; no final de comando_1.

Podemos tamb,m escrever:

If Then Begin
Comando_1;
Comando_2;
. . .
End (* n,,o tem ; *)
Else Begin
Comando_3;
Comando_4;
. . .
End;

Exemplos:

---------------------------------------------------------
Program Exemplo_1;
Uses CRT;
Var i : Integer;

Begin
Clrscr;
Write('Digite um inteiro maior que 100 --> ');
Readln(i);
Writeln;
Writeln;
If (i>100)
Then Writeln('Voce conseguiu')
Else Writeln(i,' nao e maior que 100');
End.
---------------------------------------------------------
Program Exemplo_2;

(********************************************************
Programa para determinar o maior numero entre dois lidos
do teclado
********************************************************)
Uses CRT;

Var Numero_1,Numero_2 : Integer;

Begin
ClrScr;
Write('Primeiro numero ----> ');
Readln(Numero_1);
Write('Segundo numero -----> ');
Readln(Numero_2);
Writeln;
Writeln;
If (Numero_1 > Numero_2)
Then Write(Numero_1,' e o maior')
Else If (Numero_2 > Numero_1)
Then Writeln(Numero_2,' e o maior')
Else Writeln('sao iguais');
End.
---------------------------------------------------------
Program Exemplo_3;

(********************************************************
Programa para colocar em ordem crescente 3 numeros lidos
do teclado
********************************************************)

Uses CRT;

Var x,y,z : Integer;

Begin
ClrScr;
Write('Primeiro numero --> ');
Readln(x);
Write('Segundo numero ---> ');
Readln(y);
Write('Terceiro numero --> ');
Readln(z);
Writeln;
Writeln;

If (x>=y)
Then If (x>=z)
Then If (y>=z)
Then Writeln(x,' ',y,' ',z)
Else Writeln(x,' ',z,' ',y)
Else Writeln(z,' ',x,' ',y)
Else If (y>=z)
Then If (x>=z)
Then Writeln(y,' ',x,' ',z)
Else Writeln(y,' ',z,' ',x)
Else Writeln(z,' ',y,' ',x);
End.
---------------------------------------------------------

V.2 - Labels e Goto
-------------

A instru‡,,o Goto permite desviar a sequˆncia de execu‡,,o do programa
para um determinado Label pr,-definido. Para utilizarmos algum Label,
ele deve, obrigatoriamente, ser declarado na sub rea Label.

Exemplos:

---------------------------------------------------------
Program Exemplo_1;

(********************************************************
Programa para colocar em ordem crescente 3 numeros lidos
do teclado
********************************************************)

Uses CRT;

Label Inicio;

Var x,y,z : Integer;
tecla : Char;
Begin
Inicio:
ClrScr;
Write('Primeiro numero --> ');
Readln(x);
Write('Segundo numero ---> ');
Readln(y);
Write('Terceiro numero --> ');
Readln(z);
Writeln;
Writeln;

If (x>=y)
Then If (x>=z)
Then If (y>=z)
Then Writeln(x,' ',y,' ',z)
Else Writeln(x,' ',z,' ',y)
Else Writeln(z,' ',x,' ',y)
Else If (y>=z)
Then If (x>=z)
Then Writeln(y,' ',x,' ',z)
Else Writeln(y,' ',z,' ',x)
Else Writeln(z,' ',y,' ',x);
Writeln;
Write('Deseja Continuar --> ');
Tecla:=Readkey;

If ((Tecla = 'S') OR (Tecla = 's')) Then Goto Inicio;

End.
---------------------------------------------------------
Program Exemplo_2;

(********************************************************
Programa para determinar se 3 valores lidos do teclados
s,,o lados de um triƒngulo

Observa‡"es:

Supondo que x,y,z, sejam os valores lidos, ent,,o:

1-) Se x triƒngulo e se:

2-) x=y=z ent,,o , um triƒngulo Equil tero

3-) x=y ou x=z ou y=z ent,,o , um triƒngulo Is¢celes

4-) x<>y<>z ent,,o , escaleno

********************************************************)

Label INICIO;

Uses CRT;

Var x,y,z : Real;
Tecla : Char;

Begin
INICIO:
ClrScr;
Write('X = ');
Readln(x);
Write('Y = ');
Readln(y);
Write('Z = ');
Readln(z);
Writeln;Writeln;
If (x Then If (x=y) and (x=z)
Then Writeln('TRIANGULO EQUILATERO')
Else If (x=y) Or (x=z) Or (y=z)
Then Writeln('TRIANGULO ISOCELES')
Else Writeln('TRIANGULO ESCALENO')
Else Writeln('X,Y,Z NAO SAO LADOS DE UM TRIANGULO');
Writeln;Writeln;
Write('Deseja Continuar ? --> ');
Tecla:=ReadKey;
If (Tecla='s') Or (Tecla='S')
Then Goto INICIO;
End.
---------------------------------------------------------

V.3 - For
---

Este comando permite que um grupo de opera‡"ees ou comandos sejam
repetidos um certo n£mero de vezes. Sintaxe geral:

For := to/downto do ;

A vari vel dever ser, obrigatoriamente, do tipo integer (qualquer um),
char ou Boolean. A varia‡,,o de vari vel entre valor inicial e valor
final ser crescente e de um em um, quando utilizamos a palavra to, e
decrescente de um em um, quando utilizamos a palavra downto.

Exemplos:

---------------------------------------------------------
Program Exemplo_1;

Uses CRT;

Var i : Integer;

Begin
ClrScr;
For i:=10 to 15 do Writeln(i); (* para i igual a 10 at, 15 fa‡a
escreva i *)
End.
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

Var i : Integer;

Begin
ClrScr;
For i:=10 downto 1 do Writeln(i);
End.
---------------------------------------------------------
Program Exemplo_3;
Uses CRT;

{ Este programa escreve na tela os quadrados dos numeros
de 1 at, 20 }

Var i : Integer;

Begin
ClrScr;
For i:=1 to 20 do
Begin
Write('Valor de i --> ');
Write(i:3);
Write('..... quadrado de i = ');
Writeln(i*i:5);
End;
End.
---------------------------------------------------------
Program Exemplo_4;
Uses CRT;

{ Este programa calcula a soma entre todos os n£meros
compreendidos entre dois n£meros lidos do teclado }

Label INICIO;

Var i,Numero_1,Numero_2,soma : Integer;
Tecla : Char;

Begin
INICIO:
ClrScr;
Write('Primeiro Numero --> ');
Readln(Numero_1);
Write('Segundo Numero ---> ');
Readln(Numero_2);
Writeln;
Writeln;
Soma:=0;
For i:=Numero_1 to Numero_2 do Soma:=Soma+i;
Writeln('Soma entre ',Numero_1,' e ',Numero_2,' = ',soma);
Writeln;
Writeln;
Write('Deseja Continuar ? --> ');
tecla:=ReadKey;
If ((Tecla = 'S') OR (Tecla='s')) Then Goto INICIO;
ClrScr;
Write('Tchau .........');
End.
---------------------------------------------------------
Program Exemplo_5;
Uses CRT;

(********************************************************
Programa para c lculo de fatorial de um n£mero lido do
teclado. Lembrando que fatorial de um n£mero , definido
como segue:
N! = 1.2.3.4...N
e 0! = 1
********************************************************)

Label Inicio,fim;

Var n,Fatorial,i : Integer;

Begin
Clrscr;
Inicio:
Write('N = ( menor que 0 = fim) --> ');
Readln(n);
If n<0 then goto Fim;
Fatorial:=1;
Writeln;

If (n>0)
Then For i:=1 to n do
Fatorial:=Fatorial*i;
Writeln('Fatorial de ':30,n,' = ',fatorial);
Writeln;
Goto Inicio;
Fim:
End.
---------------------------------------------------------

V.4 - Repeat Until
------------

Repete um bloco de instru‡"es at, que uma certa condi‡,,o seja
satisfeita. Sua sintaxe ,:

Repeat
Comando_1;
Comando_2;
Comando_3;
. . .
Until (express,,o_l¢gica);

Neste caso, todos os comandos entre as palavras reservadas Repeat e
Until ser,,o executadas, at, que a express,,o l¢gica seja verdadeira
(TRUE), obviamente, devemos ter o cuidado para que ela venha a ser TRUE
em determinado momento, pois caso contr rio, teremos um LOOP INFINITO,
(o programa fica preso dentro da estrutura Repeat - Until).

Exemplos:
---------------------------------------------------------
Program Exemplo_1;
Uses CRT;

(*******************************************************)
Programa exemplo para mostrar o funcionamento da estru-
tura Repeat Until
********************************************************)

Var i : Integer;

Begin
ClrScr;
i:=1;
Repeat
Writeln(i);
i:=i+1;
Until i=10;
End.
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
Programa que soma os n£meros pares compreendidos entre
dois n£meros lidos do teclado
********************************************************)

Var par,numero_1,numero_2,soma:Integer;

Begin
Clrscr;
Soma:=0;
Write('Primeiro Numero ---> ');
Readln(numero_1);
Write('Segundo Numero ----> ');
Readln(numero_2);
par:=numero_1;

If par MOD 2 <> 0 then par:=par+1; (* Verifica se o primeiro n
£mero , par, se n,,o for
adiciona-se um *)
Repeat
Soma:=soma+par;
par:=par+2;
Until par>numero_2;
Writeln;writeln;
Write('Soma dos numeros pares entre ');
Writeln(numero_1,' e ',numero_2,' = ',soma);
end.
---------------------------------------------------------
Program Exemplo_3;
Uses CRT;

(********************************************************
Programa para c lculo de fatorial.
********************************************************)

Label inicio,fim;

Var n,i,fatorial:integer;

Begin
ClrScr;
inicio:
Write('N = (menor que 0 = fim) --> ');
Readln(n);
If n<0 then goto fim;
Writeln;
fatorial:=1;
i:=1;
if n>1
then Repeat
i:=i+1;
fatorial:=fatorial*i;
Until i=n;
Writeln('fatorial de ':30,n,' = ',fatorial);
Writeln;
goto inicio;
fim:
End.
---------------------------------------------------------

V.5 - While Do
--------

A estrutura While..Do permite controlar o n£mero de vezes que uma
instru‡,,o ou bloco de instru‡"es ser executado. Ela difere da
instru‡,,o Repeat..Until porque esta s¢ avalia a express,,o l¢gica no
final do primeiro Loop, enquanto que a instru‡,,o While..Do avalia a
express,,o l¢gica antes da primeira intera‡,,o, isto significa que,
eventualmente, pode n,,o ocorrer sequer a primeira intera‡,,o.

A sintaxe de While..Do ,:

While Do ;

ou

While Do
Begin
comando_1;
comando_2;
. . .
End;

Exemplos:

---------------------------------------------------------
Program Exemplo_1;
Uses CRT;

(********************************************************
Programa exemplo que escreve na tela de 0 at, 10
********************************************************)

Var i : Integer;

Begin
ClrScr;
i:=0;
While (i<11) Do
Begin
Writeln(i);
i:=i+1;
End
End.
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
Programa que le n£meros do teclado e depois informa
a m,dia dos n£meros lidos, a quantidade lida, e soma
deles
********************************************************)

Label INICIO;

Const Quant_de_num : Integer = 0;
Soma : Real = 0;
Media : Real = 0;

Var Numero : Real;
Tecla : Char;

Begin
INICIO:
ClrScr;
Write('Valor numerico (menor que 0=fim) --> ');
Readln(Numero);
While (Numero>=0) Do
Begin
Soma := Soma + Numero;
Quant_de_num := Quant_de_num + 1;
Write('Valor numerico (menor que 0=fim) --> ');
Readln(Numero);
End;

If Quant_de_num > 0
Then Begin
Media := Soma/Quant_de_num;
Writeln;
Writeln('Quantidade de numeros = ',Quant_de_num);
Writeln('Soma ................ = ',Soma:10:2);
Writeln('Media ............... = ',Media:10:2);
End
Else Writeln('Nao se realizou calculos');
Writeln;
Write('Deseja continuar ? ---> ');
tecla:=ReadKey;
If (Tecla='s') Or (Tecla='S') Then Begin
Quant_de_num:=0;
Soma := 0;
Goto Inicio;
End;
End.
---------------------------------------------------------

V.6 - Case
----

Esta instru‡,,o nos permite selecionar uma op‡,,o baseada no valor de
uma vari vel ou express,,o. Existem duas sintaxes, a saber:

Sintaxe n£mero 1:

Case of

: Comando_1;
: Comando_2;
. . .
: Comando_n;

End;

ou

Case of

: Begin
comando_1;
comando_2;
. . .
End;
: Begin
comando_1;
comando_2;
. . .
End;
. . .
: Begin
comando_1;
comando_2;
. . .
End;
End;

A express,,o ou vari vel no comando Case deve ser do tipo simples,
normalmente Char ou Integer. Ap¢s a avalia‡,,o da express,,o, seu valor
ou o valor da vari vel , comparado com os diversos valores discrimina-
dos. Se houver algum que satisfa‡a, o comando subsequente ser
executado.

Sintaxe n£mero 2:

Case of

: Comando_1;
: Comando_2;
. . .
: Comando_n;

Else Comando;
End;

Neste caso, se o resultado da express,,o ou o valor da vari vel n,,o
satisfizer nenhum dos valores discriminados,ent,,o o comando que estiver
na frente da cl usula Else ser executado.

Exemplos:
---------------------------------------------------------
Program Exemplo_1;
Uses CRT;

(********************************************************
Programa exemplo da instru‡,,o Case. Calcula a soma, ou
a subtra‡,,o, ou a multiplica‡,,o, ou a divis,,o entre dois
n£meros lidos do teclado
********************************************************)

Var oper : Char;
x,y : Real;

Begin
ClrScr;
Write('Valor de X = ');
Readln(x);
Write('Valor de Y = ');
Readln(y);
Writeln;
Write('Operacao --> ');
oper:=ReadKey;
Writeln(oper);Writeln;

Case Oper of
'+' : Write('X + Y = ':10,x+y:6:2);
'-' : Write('X - Y = ':10,x-y:6:2);
'*' : Write('X * Y = ':10,x*y:6:2);
'/' : Write('X / Y = ':10,x/y:6:2);
Else Writeln(oper,' nao e operacao');
End; (* case *)
End. (* programa *)
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
Programa para c lculo de rea de figuras
********************************************************)

Var escolha,continua : Char;
x,y : real;

Begin
Repeat
ClrScr;
Write('Calculo de area de figuras':53);
Gotoxy(25, 5);Write('1 - Sair do programa');
Gotoxy(25, 7);Write('2 - Triangulo');
Gotoxy(25, 9);Write('3 - Quadrado');
Gotoxy(25,11);Write('4 - Retangulo');
Gotoxy(25,13);Write('5 - Circulo');
TextBackGround(7);
TextColor(0+16);
Gotoxy(10,17);Write('Sua escolha ---> ');
escolha:=ReadKey;
Textbackground(0);
Textcolor(14);

Case escolha of

'2' : Begin
ClrScr;
Writeln('Calculo da area de triangulos':55);
continua:='s';
While Continua='s' Do
Begin
Writeln;
Write('Base = ');
Readln(x);
Write('Altura = ');
Readln(y);
Writeln;
Writeln('Area = ',x*y/2:8:2);
Writeln;
Writeln;
Write('Mais calculos (s/n) --> ');
continua:=ReadKey;
Writeln;Writeln;
End;
End;

'3' : Begin
ClrScr;
Writeln('Calculo da area de quadrados':55);
continua:='s';
While Continua='s' Do
Begin
Writeln;
Write('lado = ');
Readln(x);
Writeln;
Writeln('Area = ',x*x:8:2);
Writeln;
Writeln;
Write('Mais calculos (s/n) --> ');
continua:=Readkey;
Writeln;Writeln;
End;
End;

'4' : Begin
ClrScr;
Writeln('Calculo da area de retangulos':55);
continua:='s';
While Continua='s' Do
Begin
Writeln;
Write('comprimento = ');
Readln(x);
Write('largura = ');
Readln(y);
Writeln;
Writeln('Area = ',x*y:8:2);
Writeln;
Writeln;
Write('Mais calculos (s/n) --> ');
continua:=readkey;
Writeln;Writeln;
End;
End;

'5' : Begin
ClrScr;
Writeln('Calculo da area de circulos':55);
continua:='s';
While Continua='s' Do
Begin
Writeln;
Write('raio = ');
Readln(x);
Writeln;
Writeln('Area = ',PI*x*x:8:2);
Writeln;
Writeln;
Write('Mais calculos (s/n) --> ');
continua:=readkey;
Writeln;Writeln;
End;
End;
End;
Until escolha='1';
End.
---------------------------------------------------------

Be.Cool · 30 de Julho , 2006, 03:42:11 PM

4° Aula

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³VI - Tipos de dados estruturados ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

VI.1 - Introdu‡,,o
----------

At, o presente instante, n¢s definimos dados do tipo simples ou n,,o
estruturados, como por exemplo: Byte, Integer, Real, Char e Boolean.
No entanto, existem outros tipos de dados chamados complexos ou
estruturados, String , um deles. N¢s j falamos sobre o tipo de dado
estruturado String, por ser extremamente utilizado como j salientamos
antes. Mas o Turbo Pascal possui outros tipos de estruturas, a saber:

   - Array
   - Record
   - Set
   - File
   - String ( j visto )

O tipo file refere-se a arquivos de discos e ser amplamente estudado
num cap¡tulo ... parte. Os demais ser,,o vistos neste cap¡tulo.

VI.2 - Array
-----

Imagine que n¢s precisemos declarar 100 vari veis do tipo integer, isso
poderia ser feito da seguinte forma:

Var i1,i2,i3,i4,...,i100 : Integer;

Embora isso pare‡a uma brincadeira (de mal gosto), , poss¡vel. Mas
podemos tamb,m dizer que , um grande inc"modo. E se al,m dessas 100
vari veis, precisarmos tamb,m 1000 do tipo Char ou 2000 ou ... . Como
podemos ver, as coisas podem se complicar. Mas para quem acessa BBS,
coisa de louco, ent,,o o cara pode achar MUITO LEGAL. (:-))

VI.2.1 - Arrays unidimensionais

Turbo Pascal nos fornece um tipo de dado estruturado chamado Array, que
nos permite criar um grande n£mero de vari veis de determinado tipo,sem
os incovenientes anteriores.

Exemplo 1:

Type Arranjo = Array[1..100] of Integer;

Var i : Arranjo;

ou

Var i : Array[1..100] of Integer;

Ap¢s a declara‡,,o acima, ter¡amos definidas 100 vari veis do tipo
Integer, cujos nomes seriam:

i[1] - i[2] - i[3] - . . . - i[100]

Exemplo 2:

Type
faixa = 1..2000;
Arranjo = Array[faixa] Of Char;

Var
Arranjo_simples : Arranjo;

Ap¢s as declara‡"es acima, ter¡amos definidas 2000 vari veis do tipo
char com o nome Arranjo_simples.

Exemplos:

---------------------------------------------------------
Program Exemplo_1;
Uses Crt;

(********************************************************
Lˆ 10 n£meros inteiros do teclado e os escreve na tela
ao contr rio do que foram lidos
********************************************************)

Type faixa = 1..10;
arranjo = Array[faixa] Of Integer;

Var a : arranjo;
i : Integer;

Begin
ClrScr;
For i:=1 to 10 do
Begin
Write('a[',i:2,'] = ');
Readln(a);
End;
ClrScr;
For i:=10 downto 1 do writeln(a);
End.
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
Programa que le no m ximo 100 n£meros reais do teclado
e os coloca em ordem crescente
********************************************************)

Const Num_max = 100;

Type faixa = 1..Num_max;
arranjo = Array[faixa] of Real;

Var i,j,n : Integer;
a : arranjo;
z : Real;

Begin
ClrScr;
Writeln('Ordenacao de numeros lidos do teclado':40+19);
{escreve no meio da linha}
Writeln;Writeln; { pula duas linhas }
n:=0;
Writeln('digite um no. menor que 0 para terminar':40+19);
Writeln;Writeln;
Repeat
n:=n+1;
Write('a[',n:3,'] = ');
Readln(a[n]);
Until (n=Num_max) Or (a[n]<0);
n:=n-1; { elimina o ultimo no. lido pois e' negativo }
ClrScr;
For i:=1 to n-1 Do
For j:=i+1 to n Do
If a >= a[j]
Then Begin
z:=a;
a:=a[j];
a[j]:=z;
End;
For i:=1 to n Do Writeln(a:10:2);
end.
---------------------------------------------------------
Program Exemplo_3;
Uses CRT;

(********************************************************
Programa semelhante ao anterior s¢ que coloca em ordem
crescente nomes lidos do teclado
********************************************************)

Const Num_max = 100;

Type faixa = 1..Num_max;
nomes = String[30];
arranjo = Array[faixa] of nomes;

Var i,j,n : Integer;
a : arranjo;
z : nomes;

Begin
ClrScr;
Writeln('Ordenacao de nomes lidos do teclado':40+19);
{escreve no meio da linha}
Writeln;Writeln; { pula duas linhas }
n:=0;
Writeln('digite um nome = a zero para terminar':40+19);
Writeln;Writeln;
Repeat
n:=n+1;
Write('a[',n:3,'] = ');
Readln(a[n]);
Until (n=Num_max) Or (a[n]='0');
n:=n-1; { elimina o ultimo nome lido pois e' zero }
ClrScr;
For i:=1 to n-1 Do
For j:=i+1 to n Do
If a >= a[j]
Then Begin
z:=a;
a:=a[j];
a[j]:=z;
End;
For i:=1 to n Do Writeln(a:30);
end.
---------------------------------------------------------
Program Exemplo_4;
Uses CRT;

(********************************************************
Programa que lˆ as notas de alunos de uma determinada
classe e depois lista os alunos e as respectivas notas
menores que 5.0
********************************************************)

Const
No_de_alunos = 30;

Type
Classe = Array[1..No_de_alunos] Of Real;

Var
n : Integer;
a : Classe;

Begin
ClrScr;
For n:=1 to No_de_alunos Do
Begin
Write('Aluno no. ',n:2,' ---> ');
Readln(a[n]);
End;
ClrScr;
Writeln('Alunos com media menor que 5':40+15);
Writeln('numero nota');
For n:=1 to No_de_alunos Do
If a[n]<5
Then Writeln(n:2,a[n]:10:1);
End.
---------------------------------------------------------

VI.2.2 - Arrays Multidimensionais

No item anterior, trabalhamos com Arrays unidimensionais, ou seja, de
uma dimens,,o. No entanto, , poss¡vel trabalhar com arrays de mais de
uma dimens,,o e nesses casos, eles s†o chamados de multidimensionais.

Exemplos:

Var a : array[1..10,2..5] Of Integer;

Na declara‡,,o acima, definimos um Array de 40 elementos chamado 'a'.
Ele , constitu¡do de 10 linhas numeradas de 1 a 10 por 4 colunas
numeradas de 2 a 5. O acesso a cada elemento , feito da seguinte forma:

a[1,2] a[1,3] ... a[1,5]
a[2,2] a[2,3] ... a[2,5]
... ... ... ...
a[10,2] a[10,3] ... a[10,5]

Poder¡amos definir o mesmo array da seguinte forma:

Var a : array[1..10] of array[2..5] Of Integer;

Ou da seguinte forma:

Type b = array[2..5] Of Integer;

Var a : array[1..10] Of b;

Podemos tamb,m definir arrays de maior n£mero de dimens"es pelo mesmo
processo, exemplo:

Var a : array[1..5,1..6,1..7] Of Integer;

Exemplo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

(********************************************************
Programa Matriz --> Tem a finalidade de ler uma matriz
do teclado e em seguida multiplicar uma coluna ou linha
por uma constante. Neste programa, procurei utilizar o
maior n£mero poss¡vel de conceitos dados at, aqui
********************************************************)

(* defini‡,,o das constantes do programa *)

Const NUM_MAX_COL = 20; (* n£mero m ximo de colunas *)
NUM_MAX_LIN = 10; (* n£mero m ximo de linhas *)

Var a : array[1..NUM_MAX_LIN,1..NUM_MAX_COL] of integer;
i,j,k,p,
nl,nc : integer;
lc : char;

Begin
ClrScr;
(* lˆ o n£mero de linhas da matriz *)
Repeat
Write('Numero de linhas da matriz ----------> ');
Readln(nl);
Until nl<=NUM_MAX_LIN;
(* lˆ o n£mero de colunas da matriz *)
Repeat
Write('Numero de colunas da matriz ---------> ');
Readln(nc);
Until nc<=NUM_MAX_COL;
(* lˆ a constante de multiplica‡†o *)
Write('Constante para multiplicacao --------> ');
Readln(k);
(* pergunta se , uma coluna ou linha para ser multiplicada *)
Repeat
Write('Coluna ou linha para mult. (c/l) ----> ');
Readln(lc);
Until (lc='c') Or (lc='l');
(* pergunta pelo n£mero da coluna ou da linha a ser
multiplicada *)
If lc='c'
Then Repeat
Write('Numero da coluna para a multip. -----> ');
Readln(p);
Until p<=nc
Else Repeat
Write('Numero da linha para a multip. ------> ');
Readln(p);
Until p<=nl;
Writeln;
TextBackGround(7);
TextColor(15+16);
Gotoxy(24,7);
Write('Entre com os elementos da matriz');
textcolor(8);
For i:=1 to nl do
for j:=1 to nc do
Begin
gotoxy(8*j,i+8);
Write('+');
End;
TextBackGround(0);
Textcolor(13);
(* lˆ os elementos da matriz *)
For i:=1 to nl do
for j:=1 to nc do
Begin
gotoxy(8*j,i+8);
Read(a[i,j]);
End;
(* faz a multiplica‡†o da coluna ou da linha *)
if lc='c'
Then for i:=1 to nl do a[i,p]:=a[i,p]*k
Else for j:=1 to nc do a[p,j]:=a[p,j]*k;
TextBackGround(0);
TextColor(15+16);
Gotoxy(24,7);
(* apresenta o resultado final na tela *)
Write('........Resultado final.........');
textcolor(13);
For i:=1 to nl do
for j:=1 to nc do
Begin
gotoxy(8*j,i+8);
Write(a[i,j]);
End;
End.
---------------------------------------------------------

VI.3 - Tipo Record
-----------

VI.3.1 - Conceito de estrutura heterogˆnea

At, o presente momento, trabalhamos com estruturas que envolvem dados
do mesmo tipo. O tipo Record nos permite criar um tipo de dado que ,
composto de itens de v rios tipos. Estes itens dos quais o tipo Record
, formado recebem o nome de campos.

Imaginem que queiramos armazenar os seguintes dados a respeito de uma
pessoa:

Nome - Idade - Sexo - Altura

At, o momento, n,,o temos nenhum tipo de vari vel capaz de fazer isso,
pois como podemos reparar, os quatros itens s,,o de tipos diferentes, a
saber:

Nome ---> String
Idade --> Integer
Sexo ---> Char
Altura -> Real

Como veremos a seguir, o tipo Record resolver-nos- o problema.

VI.3.2 - Defini‡,,o de Records

A defini‡,,o de uma vari vel do tipo record, come‡a com a palavra
reservada Record, a qual , seguida pelos campos (vari veis) e os seus
tipos. A palavra reservada End seguida de um ponto e v¡rgula, termina a
defini‡,,o do Record. Exemplo:

Var Nome_Do_Registro : Record
Nome : String[30];
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

OU

Type Registro = Record
Nome : String[30];
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

Var Nome_Do_Registro : Registro;

VI.3.3 - Acesso aos elementos da estrutura.

Para acessarmos os elementos da estrutura, ou seja, os campos, n¢s
devemos incluir o nome da vari vel seguida de um ponto e depois o nome
do campo, exemplos:

Nome_Do_Registro.Altura := 1.78;
Nome_Do_Registro.Sexo := 'M';
Etc...

Exemplos:
---------------------------------------------------------
Program Exemplo_1;
Uses CRT;

(********************************************************
Lˆ uma vari vel do tipo record do teclado e em seguida a
mostra no monitor
********************************************************)

Type Pessoas = Record
Nome : String[30];
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

Var p : Pessoas;

Begin
ClrScr;
Write('Nome ------> ');
Readln(p.Nome);
Write('Idade -----> ');
Readln(p.Idade);
Write('Sexo ------> ');
Readln(p.Sexo);
Write('Altura ----> ');
Readln(p.Altura);
Writeln;
Writeln('Voce digitou os seguintes dados :');
Writeln;Writeln;
Writeln(p.nome);
Writeln(p.idade);
Writeln(p.sexo);
Writeln(p.altura:6:2);
End.
---------------------------------------------------------

Podemos tamb,m definir arrays de records, vejam o exemplo abaixo:

---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
Programa para ler dados de no m ximo 20 pessoas. Em
seguida , feita uma listagem em ordem alfab,tica pelo
nome
********************************************************)

Label fim;

Type Pessoas = Record
Nome : String[30];
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

Var p : array[1..20] of Pessoas;
i,x,y : Integer;
s : Pessoas;

Begin
ClrScr;
i:=0;
Repeat
i:=i+1;
Write('Nome (0=fim) -> ');
Readln(p.Nome);
if p.Nome='0' then goto fim;
Write('Idade --------> ');
Readln(p.Idade);
Write('Sexo ---------> ');
Readln(p.Sexo);
Write('Altura -------> ');
Readln(p.Altura);
Writeln;
fim:
Until ((p.Nome='0') or (i=20));
If i<20 then i:=i-1;
For x:=1 to i-1 do
For y:=x+1 to i do
If ((p
.nome) >= (p[y].nome))
then begin
s:=p
;
p
:=p[y];
p[y]:=s;
End;
ClrScr;
Writeln('NOME':30,'IDADE':6,'SEXO':5,'ALTURA':8);
For x:=1 to i do
Writeln(p
.nome:30,p
.idade:6,p
.sexo:5,p
.altura:8:2);
End.
---------------------------------------------------------

VI.3.4 - Declara‡,,o With

Se existe uma s,rie de campos de uma vari vel do tipo record que ser
acessada repetidamente, pode ser cansativo ter que escrever o nome da
vari vel na frente do campo diversas vezes. Para resolver o problema,
podemos utilizar a declara‡,,o With. Sua forma ,:

WITH Vari vel_do_tipo_record DO comando;

ou

WITH Vari vel_do_tipo_record DO
Begin
comando_1;
comando_2;
. . .
End;

Exemplo:
---------------------------------------------------------
Program Exemplo_1;
Uses CRT;

{ le uma variavel tipo record e em seguida a mostra }

Type Pessoas = Record
Nome : String[30];
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

Var p : Pessoas;

Begin
ClrScr;
With p do
Begin
Write('Nome ------> ');
Readln(Nome);
Write('Idade -----> ');
Readln(Idade);
Write('Sexo ------> ');
Readln(Sexo);
Write('Altura ----> ');
Readln(Altura);
Writeln;
Writeln('Voce digitou os seguintes dados :');
Writeln;Writeln;
Writeln(nome);
Writeln(idade);
Writeln(sexo);
Writeln(altura:6:2);
End;
End.
---------------------------------------------------------

VI.4 - Tipo Set
--------

VI.4.1 - Defini‡,,o e declara‡,,o

Na matem tica, usamos uma linguagem n,,o s¢ adequada ...s suas
necessidades, mas tamb,m ao estudo de outras ciˆncias. Uma boa parte
dessa linguagem vem da teoria de conjuntos.

Em matem tica, definimos um conjunto como sendo uma cole‡,,o de objetos,
nomes, n£meros etc. Chamamos de elementos aos objetos, nomes, n£meros
etc. que pertencem a esse conjunto.

Pois bem, na linguagem Pascal, tamb,m podemos utilizar estes conceitos.
Na linguagem Pascal, um conjunto , uma cole‡,,o de elementos
semelhantes. O tamanho do conjunto pode ser vari vel, sendo que no caso
espec¡fico do Turbo Pascal, o conjunto pode ter no m ximo 256 elementos.

Um conjunto pode consistir em zero ou mais elementos do mesmo tipo base
que, obrigatoriamente dever ser um tipo simples, podendo ser qualquer
escalar com exce‡,,o do REAL.

Em Pascal, os conjuntos tˆm seus elementos inclusos em colchetes e
separados por v¡rgulas. Podemos ter tamb,m a representa‡,,o da sub-faixa.
Exemplos:

[1,3,5,7,9,11,13] - alguns inteiros
[3..7] - inteiros entre 3 e 7
[3,4,5,6,7] - equivalente ao anterior
['A'..'Z'] - caracteres alfab,ticos mai£sculos
[gol,passat,fusca] - marcas de carro
[] - conjunto vazio

Declara‡,,o

A forma geral para defini‡,,o de conjuntos ,:

Type
= SET OF ;

Exemplos:

Type
caracteres = set of Char;
letras_mai£sculas = set of 'A'..'Z';
d¡gitos = set of 0..9;
carros = set of (fusca,gol,escort,opala);

Var c : caracteres;
letras : letras_mai£sculas;
n£meros : d¡gitos;
marca : carros;

etc.

VI.4.2 - Opera‡"es em tipos Set

Atribui‡,,o:

O operador de atribui‡,,o , o mesmo utilizado para tipos simples,
exemplos:

c := ['a','e','i','o','u'];
letras := ['B'..'H'];
n£meros := [0,3,5];
etc.

Uni,,o:

O operador uni,,o , representado pelo sinal '+'. A uni,,o entre dois
conjuntos resulta num terceiro conjunto, constitu¡do dos elementos dos
dois conjuntos. Exemplo:

a := [1,2,3];
b := [2,3,4,5];
c := a+b; resulta c = [1,2,3,4,5]

Intersec‡,,o:

Representada pelo sinal '*'. A intersec‡,,o entre dois conjuntos,
resulta num terceiro conjunto, constitu¡-do pelos elementos que fazem
parte tanto de um como do outro conjunto. Exemplo:

a := [1,2,3];
b := [2,3,4,5];
c := a*b; resulta c = [2,3]

Diferen‡a:

Representada pelo sinal '-'. Retorna um conjunto, cujos elementos est,,o
num conjunto mas n,,o no outro.

a := [1,2,3,6];
b := [2,3,4,5];
c := a-b; resulta c = [1,6]
c := b-a; resulta c = [4,5]

Operadores relacionais:

a = b todos elementos est,,o em ambos conjuntos
a <> b alguns ou todos elementos n,,o est,,o em ambos conjuntos
a >= b todos elementos de b est,,o em a
a <= b todos elementos de a est,,o em b
a IN b a , um elemento do conjunto b

Neste £ltimo caso, a deve ser um elemento do mesmo tipo base do
conjunto b.

Exemplos de programas:
---------------------------------------------------------
Program Exemplo_1;
Uses CRT;

(********************************************************
Lˆ uma tecla e a envia para o monitor at, que se digite
'S' ou 's' ou 'N' ou 'n'
********************************************************)

Var tecla : Char;

Begin
ClrScr;
Repeat
Read(kbd,tecla);
Write(tecla);
Until tecla IN ['s','S','n','N'];
End.
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
lˆ uma tecla e diz se , n£mero, letra mai£scula ou letra
min£scula at, que se leia um '?'
********************************************************)

Type simbolos = Set of Char;

Var Maiusc,Minusc,Numeros : simbolos;
tecla : char;

Begin
ClrScr;
Maiusc := ['A'..'Z'];
Minusc := ['a'..'z'];
Numeros := ['0'..'9'];
Repeat
Read(kbd,tecla);
If tecla IN Maiusc
Then Writeln('MAIUSCULA')
Else if tecla IN minusc
Then Writeln('minuscula')
else if tecla IN numeros
Then Writeln('numero')
else Writeln('nada');
Until tecla = '?';
End.
---------------------------------------------------------
Program Exemplo_3;
Uses CRT;

(********************************************************
Programa que conta o n£mero de vogais, n£mero de
consoantes e de brancos numa frase lida do teclado
********************************************************)

Type simbolos = set of char;

Var Alfabeto,vogais,consoantes : simbolos;
frase : string[50];
v,c,b,x : integer;

Begin
Vogais:=['a','e','i','o','u','A','E','I','O','U'];
alfabeto:=['a'..'z']+['A'..'Z'];
consoantes:=alfabeto-vogais;
Clrscr;
Write('Digite uma frase --> ');
Readln(frase);
b:=0;c:=0;v:=0;
(* a fun‡,,o length() devolve o n£mero de caracteres que o
parƒmetro tem *)
For x:=1 to length(frase) do
if frase
in vogais
then v:=v+1
else if frase
in consoantes
then c:=c+1
else if frase
= ' ' then b:=b+1;
Writeln;
writeln(b,' brancos');
Writeln(c,' consoantes');
Writeln(v,' vogais');
End.
---------------------------------------------------------

Be.Cool · 30 de Julho , 2006, 03:43:47 PM

5° Aula

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³VII - Procedures³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

VII.1 - Defini‡,,o
---------

Uma das t,cnicas mais utilizadas e tida como vantajosa na confec‡,,o
de programas grandes , a modulariza‡,,o. Consiste em dividir o
programa em diversos m¢dulos ou subprogramas, de certa forma
independentes uns dos outros. Existe um m¢dulo que , o principal, a
partir do qual s,,o chamados os outros m¢dulos, esse m¢dulo recebe o
nome de programa principal, enquanto que os outros s,,o chamados de
subprogramas. No sistema Turbo Pascal, existem dois tipos de sub-
programas, a saber:

- Procedures (procedimentos)
- Functions (fun‡"es)

A procedure , como se fosse um programa. Ela tem a estrutura
praticamente igual a de um programa, como veremos mais adiante. A
procedure deve ser ativada(chamada) pelo programa principal ou por
uma outra procedure, ou at, por ela mesma.

VII.2 - Declara‡,,o de procedures
------------------------

Uma procedure tem praticamente a mesma estrutura de um programa, ou
seja, ela cont,m um cabe‡alho, rea de declara‡'es e o corpo da
procedure. Na rea de declara‡"es, podemos ter as seguintes sub-
reas:

Label - Const - Type - Var - Procedures - Functions.

Devemos salientar que tudo que for declarado dentro das sub reas s¢
ser reconhecido dentro da procedure. Mais para frente, voltaremos
a falar sobre isso.

Exemplo:
---------------------------------------------------------
Program Exemplo_1; (* cabe‡alho do programa *)
Uses CRT;

Procedure linha; (* cabe‡alho da procedure linha *)
Var i : integer; (* sub rea Var da procedure linha *)
Begin (* corpo da procedure linha *)
for i:=1 to 80 do write('-');
End;

Begin (* corpo do programa principal *)
ClrScr;
linha; (* ativa‡,,o da procedure linha *)
writeln('teste');
linha; (* ativa‡,,o da procedure linha,
novamente *)
End.
---------------------------------------------------------
O programa acima, pura e simplesmente faz o seguin-te:

1-) Apaga a tela e coloca o cursor em 1,1
2-) Ativa a procedure linha
3-) Escreve a palavra teste
4-) Ativa novamente a procedure linha.

Por sua vez, a procedure linha tra‡a uma linha a partir da posi‡,,o
atual do cursor. Uma observa‡,,o important¡ssima a ser feita neste
instante, , que a vari vel inteira i, definida dentro da procedure
linha s¢ existe dentro da procedure,isto significa que toda vez que
ativamos a procedure linha, a vari vel i , criada e toda vez que
saimos da procedure linha, ela , destru¡da.

VII.3 - Passagem de parƒmetros.
-----------------------

No exemplo acima, ao ativarmos a procedure linha,n,,o houve passagem
de parƒmetros, mas poderia haver, repare no exemplo abaixo:

Exemplo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

Var i,j:integer;

Procedure soma(x,y:integer);
Begin
writeln(x+y);
end;

Begin
ClrScr;
soma(3,4);
i:=45;
j:=34;
soma(i,j);
end.
-------------------------------------------------------------------
Como podemos reparar, a procedure soma depende de dois parƒmetros
inteiros, e ao ativarmos esta procedure, devemos fornecer os dois
parƒmetros.Esses parƒmetros podem ser dois n£meros inteiros ou duas
vari veis inteiras, obviamente deve haver compatibilidade entre os
parƒmetros passados. Podemos tamb,m passar parƒmetros de tipos
diferentes, sen,,o vejamos:
-------------------------------------------------------------------
Program Exemplo_1;
Uses CRT;

Var i,j:integer;

Procedure soma(x,y:integer;h,g:real);
Begin
writeln(x+y);
writeln(h/g:10:2);
end;

Begin
ClrScr;
i:=34;
j:=35;
soma(i,j,3.4,4.5);
End.
-------------------------------------------------------------------
Nos exemplos acima,houve passagem de parƒmetros para as procedures,
mas elas tamb,m podem passar dados de volta para o programa
chamador, exemplo:
-------------------------------------------------------------------
Program exemplo;
Uses CRT;

Var i : Integer;

Procedure Soma(x,y:Integer;Var z:Integer);
Begin
z:=x+y;
End;

Begin
ClrScr;
Soma(3,4,i);
Writeln(i);
End.
-------------------------------------------------------------------
Da forma como foi declarada a procedure soma, quando a ativamos com
a sequˆncia Soma(3,4,i), ocorrem as seguintes passagens:

- O n£mero 3 , passado para x
- O n£mero 4 , passado para y
- O parƒmetro z , passado para i.

Como podemos ver, houve passagem de dados do programa chamador para
a procedure e da procedure para o programa chamador.

VII.4 - A declara‡,,o forward.
---------------------

Suponha o programa abaixo:

---------------------------------------------------------
Program exemplo;
Uses CRT;

Procedure Soma(x,y:Integer);
Begin
linha;
Writeln(x+y);
End;

Procedure Linha;
Var i:integer;
Begin
For i:=1 to 80 do Write('-');
End;

Begin
ClrScr;
Soma(3,4);
End.
---------------------------------------------------------
Repare que a procedure Soma chama uma procedure chamada linha. No
entanto, a procedure linha est declarada mais ... frente e portanto,
ao compilarmos o programa, o compilador ir "reclamar" que n,,o
conhece o identificador Linha e com justa raz,,o, isto porque a
compila‡,,o , feita de cima para baixo e da esquerda para a direita.
Para tanto, podemos usar a declara‡,,o Forward, cuja finalidade , a
de indicar ao compilador que determinada procedure est definida
mais para frente.

Exemplo:
---------------------------------------------------------
Program exemplo;
Uses CRT;

Procedure Linha; Forward;

Procedure Soma(x,y:Integer);
Begin
linha;
Writeln(x+y);
End;

Procedure Linha;
Var i:integer;
Begin
For i:=1 to 80 do Write('-');
End;

Begin
ClrScr;
Soma(3,4);
End.
---------------------------------------------------------

Agora sim, podemos compilar o programa sem erro.

VII.5 - O escopo de objetos num programa
---------------------------------

Reparem o Exemplo abaixo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

Const a=100; (* constante global *)

Label fim; (* Label global *)

Var i,x,y : Integer; (* vari veis globais *)

Procedure Linha;
Var i : Integer; (* i , local ... procedure
linha *)
Begin
For i:=1 to 80 do Write('-');
End;

Procedure Teste;
Procedure Sub_teste; (* a procedure
Sub_teste , local
... procedure Teste *)
Begin
Write('Estive em sub_teste');
End;
Begin
Sub_teste;
Writeln;
End;

Begin
ClrScr;
i:=100;
Linha;
x:=20;
y:=30;
Teste;
Linha;
Writeln('i=',i,' y=',y,' x=',x);
End.
---------------------------------------------------------

Todos os elementos (constantes, vari veis, labels etc.) que forem
definidos antes de come‡ar o corpo do programa, s,,o considerados
globais e podem ser utilizados por todas as procedures, functions e
o pr¢prio programa. O espa‡o para tais elementos , criado durante a
compila‡,,o. J , os elementos declarados dentro de uma procedure, s¢
existem dentro da procedure, exemplo: ao declararmos uma vari vel
dentro de uma procedure, toda vez que ativarmos a procedure, tal
vari vel ser criada e ao sairmos da procedure ela ser destru¡da.
Portanto, dizemos que esta vari vel , local ... procedure.

No entanto, se repararmos bem no exemplo, veremos que existe uma
vari vel i inteira declarada antes do in¡cio do programa, portanto
global, e outra dentro da procedure linha, portanto local a esta
procedure. Mas n,,o h problema, pois o Turbo Pascal ir consider -
las diferentes. Quando estivermos dentro do programa, teremos
acesso ... vari vel global e quando estivermos dentro da procedure,
teremos acesso ... vari vel local.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³VIII - Functions.³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

VIII.1 - Defini‡,,o
---------

As fun‡"es s,,o muito parecidas com as procedures. A principal dife-
ren‡a , que o identificador de uma fun‡,,o assume o valor de retorno
da fun‡,,o. Uma fun‡,,o deve sempre retornar um valor e em Turbo
Pascal, este valor , retornado no nome da fun‡,,o.

VIII.2 - Declara‡,,o de fun‡"es.
----------------------

A declara‡,,o de uma fun‡,,o , muito parecida com de uma procedure
que por sua vez , parecida com a de um programa, sen,,o vejamos:

---------------------------------------------------------
Function Nome_da_fun‡,,o(parƒmetros) : Tipo_da_fun‡,,o;

< rea de declara‡"es >

Begin

corpo da fun‡,,o

End;
---------------------------------------------------------

A forma‡,,o do nome da fun‡,,o deve seguir as mesmas regras para
forma‡,,o de identificadores em Turbo Pascal. Dentro dos parenteses
devemos declarar os parƒmetros e seus respectivos tipos dos quais a
fun‡,,o depende. O tipo de valor retornado pela fun‡,,o tamb,m deve
ser declarado.

Na rea de declara‡"es, podemos declarar labels, constantes,
vari veis e at, mesmo Procedures e Functions. Devemos lembrar que
tais elementos s¢ poder,,o ser utilizados dentro do corpo da fun‡,,o,
pois s,,o locais a ela. Abaixo, temos o exemplo de uma fun‡,,o.

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Var x,y : Real; (* vari veis globais *)

Function Soma(a,b:real):real; (* Soma , uma fun‡†o
que depende de dois
parƒmetros reais e
devolve um valor
real *)
Begin
Soma:=a+b; (* reparem que o valor
da fun‡†o , retor-
nado p. seu nome *)
End;

Begin
ClrScr;
x:=Soma(4,5);
y:=Soma(3,6)-Soma(45.5,5.6);
Writeln(x:10:2,y:10:2);
Writeln;
Write('Valor de x --> ');
Readln(x);
Write('Valor de y --> ');
Readln(y);
Writeln;
Writeln(Soma(x,y):10:2);
End.
---------------------------------------------------------

Devemos lembrar que o Turbo Pascal possui in£meras fun‡"es de
procedures pr,-definidas, que iremos ver no decorrer do curso.

Exemplos:
---------------------------------------------------------
Program Fat;
Uses CRT;

(********************************************************
Programa para calcular o fatorial de um n£mero lido do
teclado, usando o conceito de Function
********************************************************)

Label inicio,fim;

Var n : Integer;
tecla : char;

Function Fatorial(numero:integer) : Real;
Var i : Integer;
Fat : Real;
Begin (* da fun‡†o Fatorial *)
Fat:=1;
If numero>1
Then Begin
i:=1;
Repeat
i:=i+1;
Fat:=Fat*i;
Until i=numero;
End;
Fatorial:=Fat;
End; (* da fun‡,,o fatorial *)

Begin (* do programa *)
ClrScr;
inicio:
Write('Valor de n (menor que 0 = fim) --> ');
Readln(n);
Writeln;
If n<0
Then Begin
Write('Nao existe fatorial de numeros negativos');
Goto fim;
End
Else Writeln('Fatorial de n = ',fatorial(n):10:0);
Writeln;
Goto inicio;
Fim:
End. (* do programa *)

---------------------------------------------------------

Program Fibonacci;
Uses CRT;

(********************************************************
Programa para determinar um determinado elemento da se-
quˆncia de Fibonacci. A sequˆncia de fibonacci , defi-
nida como

Fib(0) = 0

Fib(1) = 1

Fib(n) = Fib(n-1) + Fib(n-2)

Como podemos ver, o elemento atual , determi-
nado pela soma dos dois elementos anteriores

********************************************************)

Label inicio;

Var numero:integer;
tecla : char;

Function Fib(n:integer):integer;
Var a1,a2,i,pe : Integer;
Begin
if n=0
Then Fib:=0
Else If n=1
Then Fib:=1
Else Begin
a1:=0;
a2:=1;
i:=1;
Repeat
pe:=a1+a2;
i:=i+1;
a1:=a2;
a2:=pe;
Until i=n;
Fib:=a2;
End;
End;

Begin
ClrScr;
inicio:
Write('Fib(');
Read(numero);
Writeln(') = ',fib(numero));
Writeln;
Write('Deseja continuar ? --> ');
Readln(tecla);
writeln;
writeln;
If tecla='s' Then goto inicio;
End.
---------------------------------------------------------

VIII.3 - Recursividade
-------------

A linguagem Pascal e o Turbo Pascal permitem a utiliza‡,,o de
fun‡"es recursivas. Uma fun‡,,o , dita recursiva quando ela chama a
si mesma. Devemos tomar cuidado ao lidar com esse tipo de fun‡,,o,
pois podemos criar loops infinitos. Existem pessoas que tˆm faci-
lidade para pensar recursivamente e outras n,,o. A recursividade
permite criar fun‡"es elegantes e torna os programas mais f ceis
de serem entendidos. Abaixo, temos os mesmos programas anteriores,
s¢ que utilizando o conceito de recursividade.

---------------------------------------------------------
Program Fatorial;
Uses CRT;

Label inicio,fim;

Var n : Integer;
tecla : char;

Function Fat(n:integer):real;
Begin
if n=0
Then Fat:=1
Else Fat:=n*Fat(n-1); (* repare que estamos
chamando novamente a
fun‡†o Fat *)
End;

Begin
ClrScr;
inicio:
Write('Valor de n (menor que 0 = fim) --> ');
Readln(n);
Writeln;
If n<0
Then Begin
Write('Nao existe fatorial de numeros negativos');
Goto fim;
End
Else Writeln('Fatorial de n = ',fat(n):10:0);
Writeln;
Goto inicio;
Fim:
End.

---------------------------------------------------------

Program Fibonacci;
Uses CRT;

Label inicio;

Var numero:integer;
tecla : char;

Function Fib(n:integer):integer;
Begin
If n=0
Then Fib:=0
Else If n=1
Then Fib:=1
Else Fib:=Fib(n-1)+fib(n-2);
End;

Begin
ClrScr;
inicio:
Write('Fib(');
Read(numero);
Writeln(') = ',fib(numero));
Writeln;
Write('Deseja continuar ? --> ');
Readln(tecla);
writeln;
writeln;
If tecla='s' Then goto inicio;
End.
---------------------------------------------------------

Be.Cool · 30 de Julho , 2006, 03:53:56 PM

6° Aula

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³IX - Arquivos em disco. ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
IX.1 - O tipo File
-----------

O tipo file ou arquivo, , uma estrutura constitu¡da de elementos do
mesmo tipo dispostos sequencialmente. Essa estrutura , utilizada
para comunica‡,,o com o meio externo, principalmente com discos
magn,ticos.

IX.1.1 - Defini‡,,o do tipo File

A sintaxe geral para definir uma vari vel com esse tipo de
estrutura ,:

Type Arquivo = File of ;

Var a : Arquivo

Ap¢s as declara‡"es acima, a vari vel 'a' passa a representar um
arquivo de elementos do tipo .

Exemplos:

Exemplo 1: Arquivo com n£meros inteiros:

Type Arq = File Of Integer;
Var Arquivo : Arq;

Ou

Var Arquivo : File Of Integer;

Exemplo 2: Arquivo de n£meros reais:

Type Arq = File Of Real;
Var Arquivo : Arq;

Exemplo 3: Arquivo de records:

Type Pessoa = Record
Nome : String[30];
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

Var Arquivo : File Of Pessoa;

e assim por diante...

IX.2 - Procedimentos para opera‡"es em arquivos
----------------------------------------

O acesso a arquivos sempre segue a mesma sequˆncia, a saber:

1-) Abertura do arquivo
2-) Leitura e/ou escrita de dados no arquivo
3-) Fechamento do arquivo

Para tanto, existem diversas procedures para executar tais
opera‡"es e que passaremos a examinar agora.

IX.2.1 - Assign

Esta procedure tem a finalidade de atribuir um nome l¢gico ao
arquivo f¡sico, ou seja, ao nome do arquivo em disco. Sintaxe:

Assign(Vari vel_do_tipo_file,Nome_do_arquivo);

Exemplo:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Type Arquivo = File Of Integer;

Var Arq : Arquivo;

Begin
Assign(Arq,'B:EXEMPLO.DTA');

(* a partir desse instante, todas as opera‡"es de escrita
ou leitura que forem realizadas com a vari vel Arq,
ser automaticamente feitas no arquivo EXEMPLO.DTA no
drive B *)

. . .
. . .
End.
---------------------------------------------------------

X.2.2 - Abertura de arquivos ( Rewrite e Reset )
----------------------------------------

Para abrir arquivos, dispomos de duas procedures, a saber:

Rewrite();

Esta procedure apaga o arquivo em disco associado ... vari vel Arq e
cria um novo arquivo. Exemplo:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Type Arquivo = File Of Integer;

Var Arq : Arquivo;

Begin

Assign(Arq,'B:EXEMPLO.DTA');

Rewrite(Arq);

(* Ap¢s estas declara‡"es, teremos um novo arquivo
no drive B com o nome 'EXEMPLO.DTA' *)
. . .
. . .
End.
---------------------------------------------------------

Reset(Arq);

Esta procedure abre o arquivo em disco associado ... vari vel Arq
para leitura ou escrita. Esta procedure parte do princ¡pio que o
arquivo exista em disco, caso ele n†o exista, haver erro. Exemplo:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Type Arquivo = File Of Integer;

Var Arq : Arquivo;

Begin

Assign(Arq,'B:EXEMPLO.DTA');

Reset(Arq);

(* Ap¢s estas declara‡"es, o arquivo no drive B com o
nome 'EXEMPLO.DTA' est aberto e pronto para as
opera‡'es de entrada e sa¡da *)
. . .
. . .
End.
---------------------------------------------------------

IX.2.3 - Escrevendo e lendo dados no arquivo ( Write,Read )
--------------------------------------------------

A procedure utilizada para escrever dados em um arquivo , Write.
Sua sintaxe ,:

Write(Arq,var);

Os dados s,,o gravados sequencialmente no arquivo, ou seja,um ap¢s o
outro e isto , feito automaticamente pela procedure Write. Para
tanto a linguagem Pascal mant,m um apontador de registro de arquivo
que aponta sempre para o n£mero de registro, onde ser gravado ou
lido um dado. Exemplo:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Type Arquivo = File Of Integer;

Var Arq : Arquivo;
i : Integer;

Begin

Assign(Arq,'B:EXEMPLO.DTA');

Rewrite(Arq);

For i:=1 to 100 do Write(Arq,i);

(* com a instru‡,,o acima, ter¡amos escrito sequencialmen-
te no arquivo B:EXEMPLO.DTA os n£meros de 1 a 100 *)

. . .

. . .

End.
---------------------------------------------------------

Como j dissemos anteriormente, a linguagem Pascal mant,m um
apontador de registro que indica o pr¢ximo registro que ser lido
ou escrito, e toda vez que fazemos uma leitura ou escrita num
registro, o apontador , incrementado de um, isto , autom tico. No
entanto, dispomos de uma procedure que nos permite alterar o valor
desse apontador e portanto, nos permite acessar qualquer registro
que quisermos. Essa procedure chama-se Seek. A propr¢sito, o n£mero
do primeiro registro , zero. A sintaxe desta procedure ,:

Seek(Arq,n£mero_do_registro);

Para ler dados do arquivo,dispomos da procedure Read cuja sintaxe ,:

Read(Arq,Var);

Exemplo:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Type Arquivo = File Of Integer;

Var Arq : Arquivo;
i : Integer;

Begin

Assign(Arq,'B:EXEMPLO.DTA');

Rewrite(Arq);

For i:=1 to 100 do Write(Arq,i);

Seek(Arq,0); (* posiciona o apontador de registro
no registro n£mero 0 *)

Read(Arq,i); (* a vari vel i fica igual ao conte£do
do registro n£mero 0 que no presen-
te exemplo valeria 1,a propr¢sito,
o apontador de registro j est va-
lendo 1 *)
Read(Arq,i); (* i agora est valendo 2 *)

. . .

. . .

End.
---------------------------------------------------------

IX.2.4 - Fechamento do arquivo.
---------------------

Como j foi visto, ap¢s a abertura do arquivo, leitura e/ou escrita
de dados, devemos fech -lo. Para tanto, dispomos da procedure close
cuja sintaxe ,:

Close(Arq);

Exemplos de programas:

Exemplo 1:
---------------------------------------------------------
(********************************************************
PROGRAMA Grava --> Le numeros do teclado e em seguida os
grava num arquivo em disco *)
AUTOR : Thelmo J. M. Mesquita
********************************************************)

Program grava;
Uses CRT;

Var arquivo : File Of Integer;
i : Integer;

Begin
ClrScr;
Assign(arquivo,'arquivo.dta');
ReWrite(arquivo);
Repeat
Write('Numero --> ');
Readln(i);
Write(arquivo,i);
Until i=0;
Close(arquivo);
End.

(* O pr¢ximo programa le os n£meros gravados pelo programa anterior *)

(********************************************************
PROGRAMA : Le.pas ---> Le numeros de um arquivo em disco
AUTOR : Thelmo J. M. Mesquita
********************************************************)

Program le;
Uses CRT;

Var arquivo : File Of Integer;
i : Integer;

Begin
ClrScr;
Assign(arquivo,'arquivo.dta');
Reset(arquivo);
Repeat
Read(arquivo,i);
Writeln(i);
Until i=0;
Close(arquivo);
End.
---------------------------------------------------------

Exemplo 2:
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

(********************************************************
Programa que grava num arquivo em disco, o quadrado dos
n£meros de 0 a 100 e depois permite consulta atrav,s da
instru‡,,o seek
********************************************************)

Var Arq : File of Real;
i : Integer;
s : real;

Begin
Assign(Arq,'Arquivo.dta');
Rewrite(Arq);
For i:=0 to 100 do Begin
s:=i*i;
Write(Arq,s);
End;
Close(Arq);
Reset(Arq);
ClrScr;
While i>=0 do
Begin
Write('Numero --> ');
Readln(i);
if (i>=0) And (i<=100)
Then Begin
seek(Arq,i);
Read(Arq,s);
Writeln;
Writeln(s:10:0);
Writeln;
End;
End;
Close(Arq);
End.
---------------------------------------------------------

Exemplo 3:
---------------------------------------------------------
(********************************************************
ARQUIVO.PAS : Este programa tem a finalidade de geren-
ciar um arquivo em disco cujos registros
cont,m dois campos, a saber:

NOME : 20 caracteres

IDADE : integer

O programa apresenta inicialmente o seguinte menu:

1 - ) Sair do programa

2 - ) Entrar com registros

3 - ) Listar todos os registros

4 - ) Pesquisa por nome

********************************************************)

(*$I-*) (* esta diretiva de compila‡†o tem a finalidade
de indicar ao compilador que os erros de I/O
(entrada/sa¡da) ser,,o verificados pelo pro-
gramador, ou seja, se houver algum erro de I/O
durante a execu‡,,o do programa, o programa n,,o
ir abortar. Para que o programador saiba se
uma determinada opera‡,,o de I/O funcionou
corretamente, ele dever verificar o valor da
vari vel IORESULT.Se ela for diferente de zero,
ent,,o ocorreu algum erro e o programador dever
ent,,o tomar alguma providˆncia *)

Program Exemplo_De_Arquivo;
Uses CRT;

Type Pessoa = Record
Nome : String[20];
Idade : Integer;
End;

Frase = String[80];

Var Arquivo : File Of Pessoa;
P : Pessoa;
escolha : Integer;

Procedure Linha; (* tra‡a uma linha na posi‡,,o atual do
cursor *)
Var i : Integer;
Begin
For i:=1 to 80 Do Write('-');
End;

Procedure Centro(S:Frase); (* centra string S na tela *)
Var x:integer;
Begin
x:=40+(Length(S)) DIV 2; (* lenght retorna o n£mero de
caracteres do parƒmetro *)
Writeln(S:x);
End;

Procedure InReg; (* procedimento p/ incluir registros *)
Var resposta:char;
Begin
ClrScr;
Linha;
Centro('ROTINA PARA ENTRAR REGISTROS');
Reset(arquivo);

(* Neste trecho do programa, iremos utilizar uma fun‡,,o
nova :

FILESIZE(arq) retorna quantos registros possui o arquivo
"arq" *)

Seek(arquivo,FileSize(arquivo)); (* posiciona o
apontador de
registros no final
do arquivo *)
resposta:='s';
Linha;
While resposta='s' Do
Begin
gotoxy(1,5);clreol; (* limpa at, final da linha *)
gotoxy(1,6);clreol;
gotoxy(1,5);

Buflen:=20; (* estou limitando o buffer do teclado
em 20 caracteres, o normal , 126 *)

Write('Nome da pessoa ---> ');
Readln(P.Nome);
Buflen:=2;
clreol;
Write('Idade da pessoa --> ');
Readln(P.Idade);
Linha;
Write(arquivo,P);
Write('Deseja Continuar ? -->':50);
Readln(resposta);
end;
close(arquivo);
Buflen:=126;
End;

Procedure LiReg; (* procedimento para listar os registros
na tela *)
Begin
Reset(arquivo);
Clrscr;
Linha;
writeln('NOME':15,'IDADE':18);
linha;
While not eof(arquivo) do
Begin
read(arquivo,P);
Writeln(P.nome:21,' - - - ',P.idade);
end;
Linha;
Close(arquivo);
Write('Digite uma tecla --> ');
repeat until keypressed;
End;

Procedure PeNo; (* pesquisa por nome *)
Var nome : string[20];
Begin
Reset(arquivo);
nome:='1';
While nome<>'0' Do
Begin
Clrscr;
Linha;
Centro('PESQUISA POR NOME');
linha;
Write('Nome (0=fim) --> ');
Readln(nome);
if nome<>'0'
Then Begin
linha;
seek(arquivo,0);
While not eof(arquivo) do
Begin
read(arquivo,P);
if Pos(nome,P.nome)<>0
Then Writeln(P.nome:21,' - - - ',P.idade);
End;
Linha;
Write('Digite uma tecla --> ');
repeat until keypressed;
End;
End;
close(arquivo);
End;

(* aqui come‡a o nosso programa, inicialmente devemos verificar
se o arquivo "arquivo.dta" existe, se n,,o existir, ent,,o ele
dever ser criado *)

Begin
Assign(arquivo,'arquivo.dta');
Reset(arquivo);
If IOresult <> 0 Then ReWrite(arquivo);
Close(arquivo);

Repeat
ClrScr;
Linha;
Writeln('..... Programa para gerenciar um arquivo contendo nomes e');
Writeln(' idades de pessoas');
Writeln('..... Escrito em 06/09/93 por Thelmo J.M.Mesquita');
Linha;

Gotoxy(24,12);Writeln('1 - Sair do programa');
Gotoxy(24,14);Writeln('2 - Entrar com registros');
Gotoxy(24,16);Writeln('3 - Listar todos os registros');
Gotoxy(24,18);Writeln('4 - Pesquisar por nome');
Gotoxy(33,10);LowVideo;
Writeln('SUA ESCOLHA :');NormVideo;

Repeat
Gotoxy(47,10);
read(escolha);
Until (escolha > 0 ) and (escolha < 5);

Case escolha of
2 : InReg;
3 : LiReg;
4 : PeNo;
end;

Until escolha=1;

ClrScr;
Gotoxy(33,12);Writeln('T C H A U . . . . . ');

End.
---------------------------------------------------------

Be.Cool · 30 de Julho , 2006, 03:56:01 PM

Exemplo 4:
---------------------------------------------------------
(*******************************************************)
Este programa tem a finalidade de gerenciar um arquivo
em disco com a seguida estrutura:

Nome : frase;

Idade : Integer;

Sexo : Char;

Altura : Real;

********************************************************)

Program Arquivo;
Uses CRT;

Type Frase = string[20];
Pessoa = Record
Nome : frase;
Idade : Integer;
Sexo : Char;
Altura : Real;
End;

Var Arq : File Of Pessoa;
escolha : char;
p : pessoa;
s : frase;

Procedure tecla;
Begin
Write(chr(7));
Write('Digite uma tecla --> ');
Repeat until keypressed;
End;

Procedure Linha;
Var i:byte;
Begin
For i:=1 to 80 do write('-');
End;

Function Maiuscula(s:frase):frase;
var i:byte;
Begin
for i:=1 to length(s) do s:=upcase(s);
maiuscula:=s;
end;

Function Acha_Nome(s:frase):integer;
Label fim;
Begin
Acha_Nome:=-1;
While not eof(arq) do
Begin
Read(arq,p);
if pos(s,p.nome) > 0 Then Begin
Acha_Nome:=Filepos(arq)-1;
Goto fim;
End;
End;
fim:
End;

Procedure Consulta;
Var escolha : Char;

Procedure lireg;
Begin
Seek(Arq,0);
ClrScr;
Linha;
lowvideo;
Writeln('NOME':18,'IDADE':12,'SEXO':5,'ALTURA':10);
Normvideo;
linha;
While not eof(arq) do
Begin
Read(arq,p);
With p do
Writeln(nome:22,idade:6,sexo:5,altura:10:2);
End;
linha;
tecla;
End;

Procedure peno;
label fim;
Begin
Repeat
clrscr;
write('Nome para pesquisa (0=fim) -> ');
readln(s);
s:=maiuscula(s);
if s='0' then goto fim;
Seek(Arq,0);
ClrScr;
Linha;
lowvideo;
Writeln('NOME':18,'IDADE':12,'SEXO':5,'ALTURA':10);
Normvideo;
linha;
While not eof(arq) do
Begin
Read(arq,p);
if pos(s,p.nome)>0 then
With p do
Writeln(nome:22,idade:6,sexo:5,altura:10:2);
End;
linha;
tecla;
fim:
until s='0';
End;

Procedure lidade;
label fim;
var i1,i2:byte;
Begin
Repeat
clrscr;
write('Idade no.1 (0=fim) -> ');
readln(i1);
if i1=0 then goto fim;
write('Idade no.2 ---------> ');
readln(i2);
Seek(Arq,0);
ClrScr;
Linha;
lowvideo;
Writeln('NOME':18,'IDADE':12,'SEXO':5,'ALTURA':10);
Normvideo;
linha;
While not eof(arq) do
Begin
Read(arq,p);
if ((p.idade>=i1) and (p.idade<=i2)) then
With p do
Writeln(nome:22,idade:6,sexo:5,altura:10:2);
End;
linha;
tecla;
fim:
until i1=0;
End;

Procedure lisexo;
label fim;
var s:char;
Begin
Repeat
clrscr;
write('Sexo para pesquisa (0=fim) -> ');
readln(s);
s:=maiuscula(s);
if s='0' then goto fim;
Seek(Arq,0);
ClrScr;
Linha;
lowvideo;
Writeln('NOME':18,'IDADE':12,'SEXO':5,'ALTURA':10);
Normvideo;
linha;
While not eof(arq) do
Begin
Read(arq,p);
if p.sexo=s then
With p do
Writeln(nome:22,idade:6,sexo:5,altura:10:2);
End;
linha;
tecla;
fim:
until s='0';
End;

Procedure lialtura;
label fim;
var i1,i2:real;
Begin
Repeat
clrscr;
write('Altura no.1 (0=fim) -> ');
readln(i1);
if i1=0 then goto fim;
write('Altura no.2 ---------> ');
readln(i2);
Seek(Arq,0);
ClrScr;
Linha;
lowvideo;
Writeln('NOME':18,'IDADE':12,'SEXO':5,'ALTURA':10);
Normvideo;
linha;
While not eof(arq) do
Begin
Read(arq,p);
if ((p.altura>=i1) and (p.altura<=i2)) then
With p do
Writeln(nome:22,idade:6,sexo:5,altura:10:2);
End;
linha;
tecla;
fim:
until i1=0;
End;

Begin
Repeat
ClrScr;
Gotoxy(32,3);LowVideo;Write('MENU DE CONSULTA');NormVideo;
Gotoxy(23, 6);Write('1 - Voltar ao menu anterior');
Gotoxy(23,8);Write('2 - Listar todos os registros na tela');
Gotoxy(23,10);Write('3 - Pesquisa por nome');
Gotoxy(23,12);Write('4 - Listar Registros de pessoas com');
Gotoxy(27,13);Write('certa idade');
Gotoxy(23,15);Write('5 - Listar Registros de pessoas de');
Gotoxy(27,16);Write('determinado sexo');
Gotoxy(23,18);Write('6 - Listar registros de pessoas de');
Gotoxy(27,19);Write('certa altura');
Gotoxy(32,21);Write('SUA ESCOLHA -> ');
Repeat
escolha:=readkey;
Until escolha IN ['1','2','3','4','5','6'];
Write(chr(7));
Case escolha of
'2' : lireg;
'3' : peno;
'4' : lidade;
'5' : lisexo;
'6' : lialtura;
End;
Until escolha='1';
End;

Procedure Altera;
Var escolha : Char;

Procedure Inreg;
Label fim;
Begin
seek(Arq,filesize(Arq));
ClrScr;
Gotoxy(25,6);LowVideo;
Write('INTRODUCAO DE UM NOVO REGISTRO');NormVideo;
Gotoxy(5, 9);Write('NOME (0=fim) --> ');
Gotoxy(5,11);Write('IDADE ---------> ');
Gotoxy(5,13);Write('SEXO ----------> ');
Gotoxy(5,15);Write('ALTURA --------> ');
Repeat
Gotoxy(26, 9);write('....................');
Gotoxy(26,11);write('...');
Gotoxy(26,13);write('.');
Gotoxy(26,15);write('....');
Gotoxy(26, 9);Read(p.nome);
If p.nome='0' Then Goto Fim;
Gotoxy(26,11);Read(p.idade);
Gotoxy(26,13);Read(p.sexo);
Gotoxy(26,15);Read(p.altura);
p.nome:=maiuscula(p.nome);
p.sexo:=maiuscula(p.sexo);
Write(Arq,p);
Fim:
Until p.nome='0';
End;

Procedure Delreg;
label fim;
var r,i:integer;
resp,resposta:char;
temp:file of pessoa;
Begin
seek(arq,0);
Repeat
ClrScr;
Gotoxy(25,2);LowVideo;
Write('ROTINA PARA DELETAR REGISTROS');NormVideo;
Gotoxy(10,6);Write('Nome (0=fim) --> ');
Readln(s);
s:=maiuscula(s);
if s='0' then goto fim;
repeat
r:=acha_nome(s);
if r=-1
Then Begin
Gotoxy(40,23);
lowvideo;
write('FIM DE ARQUIVO. . ');
normvideo;
seek(arq,0);
tecla;
End
Else Begin
gotoxy(10, 6);clreol;Write('NOME ...: ',p.nome);
gotoxy(10, 8);clreol;Write('IDADE ..: ',p.idade);
gotoxy(10,10);clreol;write('SEXO ...: ',p.sexo);
gotoxy(10,12);clreol;write('ALTURA .: ',p.altura:6:2);
gotoxy(1,16) ;clreol; write('POSSO DELETAR -->');
Readln(resposta);
resposta:=maiuscula(resposta);
if (resposta='S')
Then Begin
assign(temp,'tempor');
rewrite(temp);
seek(arq,0);
while not eof(arq) do
if filepos(arq)<>r
then begin
read(arq,p);
write(temp,p);
end
else read(arq,p);
close(arq);
close(temp);
erase(arq);
rename(temp,'dados.dta');
reset(arq);
end
else Begin
gotoxy(1,16);clreol;
write('CONTINUA A PESQUISA ? --> ');
readln(resp);
resp:=maiuscula(resp);
if (resp='N')
Then r:=-1;
End;
end;
until r=-1;
fim:
Until s='0';
End;

Procedure Modreg;
label fim;
var r,i:integer;
resp,resposta:char;
temp:file of pessoa;
Begin
seek(arq,0);
Repeat
ClrScr;
Gotoxy(25,2);LowVideo;
Write('ROTINA PARA MODIFICAR REGISTROS');NormVideo;
Gotoxy(10,6);Write('Nome (0=fim) --> ');
Readln(s);
s:=maiuscula(s);
if s='0' then goto fim;
repeat
r:=acha_nome(s);
if r=-1
Then Begin
Gotoxy(40,23);
lowvideo;
write('FIM DE ARQUIVO. . ');
normvideo;
seek(arq,0);
tecla;
End
Else Begin
gotoxy(10, 6);clreol;Write('NOME ...: ',p.nome);
gotoxy(10, 8);clreol;Write('IDADE ..: ',p.idade);
gotoxy(10,10);clreol;write('SEXO ...: ',p.sexo);
gotoxy(10,12);clreol;write('ALTURA .: ',p.altura:6:2);
gotoxy(1,16) ;clreol; write('MODIFICA ? ----->');
Readln(resposta);
resposta:=maiuscula(resposta);
if (resposta='S')
Then Begin
gotoxy(20, 6);
read(p.nome);clreol;
gotoxy(20, 8);
read(p.idade);clreol;
gotoxy(20,10);read(p.sexo);
clreol;
gotoxy(22,12);
read(p.altura);clreol;
p.nome:=maiuscula(p.nome);
p.sexo:=maiuscula(p.sexo);
seek(arq,r);
write(arq,p);
end
else Begin
gotoxy(1,16);clreol;
write('CONTINUA A PESQUISA ? --> ');
readln(resp);
resp:=maiuscula(resp);
if (resp='N')
Then r:=-1;
End;
end;
until r=-1;
fim:
Until s='0';
End;

Begin
Repeat
Clrscr;
Gotoxy(27,10);Write('1 - Voltar ao menu anterior');
Gotoxy(27,12);Write('2 - Entrar com um registro');
Gotoxy(27,14);Write('3 - Deletar um registro');
Gotoxy(27,16);Write('4 - Modificar um registro');
Gotoxy(31,7);Lowvideo;Write('MENU DE ALTERACAO');NormVideo;
Gotoxy(32,19);Write('SUA ESCOLHA -> ');
Repeat
escolha:=readkey;
Until escolha IN ['1','2','3','4'];
Write(chr(7));
Case escolha of
'2' : Inreg;
'3' : Delreg;
'4' : Modreg;
End;
Until escolha='1';
End;

Begin
Assign(Arq,'dados.dta');
(*$I-*)
Reset(Arq);
If IORESULT <> 0 Then Rewrite(Arq);
(*$I+*)
Repeat
ClrScr;
Gotoxy(29,10);Write('1 - Sair do programa');
Gotoxy(29,12);Write('2 - Consulta de dados');
Gotoxy(29,14);Write('3 - Alteracao de dados');
Gotoxy(33,7);LowVideo;Write('MENU PRINCIPAL');NormVideo;
Gotoxy(32,17);Write('SUA ESCOLHA -> ');
Repeat
escolha:=readkey;
Until escolha IN ['1','2','3'];
Write(chr(7));
Case escolha of
'2': Consulta;
'3': Altera;
End;
Until escolha='1';
Close(Arq);
ClrScr;
End.
---------------------------------------------------------

IX.2.5 - Erase

Esta procedure permite deletar um arquivo em disco. Sintaxe:

Erase( Arq : File of tipo);

ou

Erase( Arq : File );

Exemplo:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Var arq : file;

Begin
assign(arq,'thelmo.001');
erase(arq);
(* ap¢s a execu‡,,o deste trecho de programa, o arquivo
'thelmo.001' seria eliminado do disco *)
End.

---------------------------------------------------------

IX.2.6 - Rename

Procedure utilizada para trocar o nome de um arquivo. Sintaxe:

Rename( Arq : File , Novo_Nome);

onde

Arq deve ser uma vari vel do tipo file e

Novo_nome uma string.

Exemplo:
---------------------------------------------------------
Program Exemplo_2;
Uses CRT;

Var Arq : File;

Begin
Assign(Arq,'teste.001');
Rename(Arq,'soma.dta');
(* ap¢s a execu‡,,o deste trecho de programa, o arquivo
'thelmo.001' teria seu nome trocado para 'soma.dta' *)

End.
---------------------------------------------------------

IX.2.7 - BlockWrite e BlockRead

A procedure BlockRead lˆ um no. especificado de blocos de 128 bytes
de um arquivo n†o tipado para uma vari vel. O n§ de registros lidos
, retornado numa vari vel inteira que , opcional. BlockWrite
Escreve ao inv,s de ler. Sintaxe:

BlockWrite(Arquivo,Vari vel,No_de_Regs,Resultado);

BlockRead(Arquivo,Vari vel,No_de_Regs,Resultado);

Exemplo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

(********************************************************
Programa para copiar um arquivo para outro, em seguida ,
feita uma verifica‡,,o se a c¢pia foi bem feita
********************************************************)

Const Buf_Regs = 100; (* N£mero de blocos de 128 bytes
que ser†o transferidos pelo
BlockRead ou pelo Block-
Write *)

Label FIM;

Var Fonte, (* Nome do arquivo fonte *)
Destino (* Nome do arquivo destino *)
: String[33];
F, (* Nome l¢gico do arq. fonte *)
D (* Nome l¢gico do arq. destino *)
: File; (* Arquivos n,,o tipados *)

No_Regs_restantes, (* No. de registros que faltam
para serem transferidos *)
Regs_para_ler, (* No. de registros que ser†o
lidos e/ou escritos *)
i,r,r1 (* Vari veis auxiliares *)
: Integer;
Buffer, (* Vari vel que receber o blocos
de registros lidos pelo Block-
Read *)
Buffer1 (* Idem ao anterior *)
: Array[1..12800] Of Byte;

Procedure Erro(x:integer);
Begin
Writeln('. . . . . . Problemas com a copia');
If x=1
Then Writeln('. . . . . . Arquivos de tamanhos diferentes')
Else Writeln('. . . . . . Arquivos diferentes');
Writeln('Tente novamente');
End;

Begin
ClrScr;
Lowvideo;
Writeln('Copiador de arquivos':50);
NormVideo;
Write('Fonte ----> ');
Readln(Fonte);
Assign(F,Fonte);
{$I-} (* j explicado em programa
anterior *)
Reset(F);
{$I+}
If IORESULT <> 0
Then Begin
Writeln('..... Este arquivo nao existe');
Writeln('..... Operacao nao realizada');
Goto FIM;
End;
Write('Destino --> ');
Readln(Destino);
Assign(D,Destino);
Rewrite(D);
No_Regs_Restantes := Filesize(F);
(* FileSize retorna o n£mero de registros que cont,m o arquivo *)
While No_Regs_Restantes > 0 do
Begin
If Buf_Regs < No_Regs_Restantes
Then Regs_para_ler := Buf_regs
Else Regs_para_ler := No_Regs_Restantes;
BlockRead(F,Buffer,Regs_para_ler);
BlockWrite(D,Buffer,Regs_para_ler);
No_Regs_restantes := No_regs_restantes-Regs_para_ler;
End;
Close(F);
Close(D);
Reset(F);
Reset(D);
No_Regs_Restantes := Filesize(F);
While No_Regs_Restantes > 0 do
Begin
If Buf_Regs < No_Regs_Restantes
Then Regs_para_ler := Buf_regs
Else Regs_para_ler := No_Regs_Restantes;
BlockRead(F,Buffer,Regs_para_ler,r);
BlockRead(D,Buffer1,Regs_para_ler,r1);
No_Regs_restantes := No_regs_restantes-Regs_para_ler;
If r<>r1
Then Begin
Erro(1);
Goto FIM;
End;
For i:=1 to 128*r do
if buffer<>buffer1
Then Begin
Erro(2);
Goto FIM;
End;
End;
FIM:
End.
---------------------------------------------------------

IX.2.8 - Truncate

Esta procedure trunca o arquivo a partir do registro corrente.
Sintaxe:

Truncate(Arq);

Exemplo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

Var a : file of integer;
i : integer;

Begin
Assign(a,'Arquivo.Dta');
Rewrite(a);
For i:=1 to 100 do write(a,i);
Close(a);
(* O arquivo 'Arquivo.Dta' contem 100 numeros inteiros de 1 at, 100 *)

Reset(a);
Seek(a,10);
truncate(a); (* o arquivo foi truncado a partir do registro 10 *)
Seek(a,0);
while not eof(a) do (* eof() est explicado logo abaixo *)
Begin
read(a,i);
writeln(i); (* ser escrito de 1 at, 10 no v¡deo *)
end;
end.
---------------------------------------------------------

IX.3 - Fun‡"es para opera‡"es em arquivos
----------------------------------

IX.3.1 - Eof()

Esta fun‡,,o retorna um TRUE, caso tenha se alcan‡ado um fim de
arquivo, caso contr rio, retorna um FALSE. Um exmplo de aplica‡,,o
foi mostrado no £ltimo programa.

IX.3.2 - SeekEof()

Fun‡,,o semelhante ao Eof() exceto que ela pula brancos e tabula-
‡"es, checando somente o marcador de fim de arquivo (CTRL-Z).

IX.3.3 - FilePos

Retorna o n£mero do registro corrente. Lembramos novamente, que o
primeiro registro recebe o n£mero zero. Sintaxe:

FilePos(Arquivo);

IX.3.4 - FileSize

Retorna o n£mero de registros de determinado arquivo. Retorna zero
se o arquivo estiver vazio. Caso o arquivo n,,o seja tipado, ent,,o a
fun‡,,o FileSize considera que os registros tenham 128 bytes cada um
Sintaxe:

FileSize(Arquivo);

Esta fun‡,,o em conjunto com a procedure Seek, nos permite colocar o
apontador de registros para o final do arquivo. Isto , muito £til
quando desejamos adicionar mais registros num arquivo. Para tanto,
basta declarar a seguinte instru‡,,o:

Seek(Arquivo,FileSize(Arquivo));

IX.3.5 - IORESULT

IORESULT , uma vari vel pr,-definida no Turbo Pascal que assume
determinados valores inteiros, quando algum erro de Entrada/Sa¡da
ocorre.

IORESULT pode assumir os seguintes valores:

01 Arquivo n,,o existe

02 Arquivo n,,o foi aberto para entrada Provavelmente, vocˆ
est tentando ler de um arquivo que ainda n,,o foi aberto.

03 Arquivo n,,o foi aberto para sa¡da Provavelmente, vocˆ est
tentando escrever num arquivo que ainda n†o foi aberto.

04 Arquivo n,,o aberto Este tipo de erro costuma acontecer
quando tentamos utilizar as procedures BlockRead ou
BlockWrite sem antes usarmos Reset ou Rewrite.

16 Erro no formato num,rico Quando tentamos ler uma string de
um arquivo texto, para uma vari vel num,rica que n,,o est
de acordo com o formato num,rico.

32 Opera‡,,o n,,o permitida para um dispositivo l¢gico.
Por exemplo,vocˆ tenta ler de um arquivo que foi assinalado
para a impressora.

33 N,,o permitido no modo direto.

34 N,,o permitido assinala‡,,o para arquivos standards.

144 Erro de comprimento de registros.
Por exemplo,vocˆ tenta ler um registro que cont,m um n£mero
inteiro, e uma string para uma vari vel de estrutura
diferente.

145 Seek dado para uma posi‡,,o posterior ao final do arquivo.

153 Fim de arquivo foi alcan‡ado antes de se encontrar o CTRL-Z.

240 Erro de escrita no disco.

241 Diret¢rio cheio

242 Overflow do comprimento do arquivo.

243 Arquivo desapareceu.
Imagine que antes de se executar um close() vocˆ troque o
disco.

IX.3.6 - LongFilePos

Esta fun‡,,o deve ser utilizada em lugar da FilePos quando o arquivo
em quest,,o tiver mais de 32K.

IX.3.7 - LongFileSize

Esta fun‡,,o deve ser utilizada em lugar de FileSize quando o
arquivo em quest†o tiver mais de 32K.

IX.3.8 - LongSeek

Esta fun‡,,o deve ser utilizada em lugar de Seek para arquivos
maiores de 32K.

IX.4 - Arquivos Textos
---------------

IX.4.1 - Defini‡,,o

Os arquivos textos s,,o utilizados para uma s,rie de aplica‡"es,
que n,,o s,,o cobertas pelos arquivos, cujos conte£dos s,,o dados
bin rios. Exemplo: Wordstar, Word, Dbase III etc.

Para declarar um arquivo como sendo do tipo Texto, procedemos da
seguinte forma:

Var Arquivo : Text;

Ap¢s esta declara‡,,o, o Turbo Pascal aloca um buffer de 128 bytes
para as opera‡"es de entrada e sa¡da com rela‡,,o ao arquivo. N¢s
podemos modificar o tamanho desse buffer da seguinte forma:

Var Arquivo : Text[256];

Da mesma forma que nos arquivos n,,o textos, devemos assinalar o nome
l¢gico e em seguida, abrir o arquivo para ent†o podermos ler ou
escrever dados no arquivo.

IX.4.2 - Procedures e Functions para arquivos texto.

IX.4.2.1 - Append

Esta procedure abre um arquivo do tipo texto para inclus,,o de dados
no final do arquivo. Sintaxe:

Append(Arquivo);

IX.4.2.2 - Readln

Lˆ uma linha de dados de um arquivo de texto, isto ,, lˆ dados do
arquivo at, que se encontre um fim de linha. Sintaxe:

Readln(Arquivo,Vari vel);

Arquivo dever ser do tipo Text e a vari vel do tipo String.

IX.4.2.3 - Writeln

Escreve uma linha de dados no arquivo, isto ,, escreve dados e mais
o fim de linha. Sintaxe:

Writeln(Arquivo,Vari vel);

Arquivo dever ser do tipo Text e a vari vel do tipo String.

Exemplo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

Var frase : String[200];
a : Text;

Begin
ClrScr;
Assign(a,'arquivo.dta');
ReWrite(a);
Frase:=' ';
While Frase<>'fim' do
Begin
Write('Frase --> ');
Readln(frase);
Writeln(a,frase);
End;
Close(a);
Reset(a);
ClrScr;
While not eof(a) do
Begin
Readln(a,frase);
Writeln(frase);
End;
Close(a);
End.
---------------------------------------------------------

IX.4.2.4 - Eoln

Esta fun‡,,o retorna um TRUE se foi alcan‡ado um fim de linha no
arquivo texto. Sintaxe:

Eoln(arquivo);

Onde arquivo tem que ser do tipo texto.

Be.Cool · 30 de Julho , 2006, 03:58:36 PM

7° Aula

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³X - Vari veis dinƒmicas³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ

X.1 - Compara‡,,o entre vari veis est ticas e vari veis dinƒmicas.
----------------------------------------------------------

At, o presente momento, lidamos com vari veis que tiveram de ser
criadas antes de se executar um programa. S,,o vari veis que existem
o tempo todo, ou seja, s,,o vari veis est ticas. Portanto,a aloca‡,,o
de mem¢ria para esse tipo de vari vel , feita antes da execu‡,,o do
programa. A grande desvantagem desse tipo de vari vel , o fato de
que uma vez criada, o espa‡o de mem¢ria que ela ocupa n,,o pode mais
ser alterado. As vari veis dinƒmicas podem ser criadas e ou
destru¡das durante a execu‡,,o de um programa, e esta, , a grande
vantagem delas sobre as est ticas. As vari veis dinƒmicas podem ser
obtidas atrav,s de um tipo pr,-definido em Pascal, chamado Pointer.

O pointer ou apontador, como o pr¢prio nome diz, aponta para um
local de mem¢ria onde est armazenada uma vari vel.

X.2 - O tipo Pointer
--------------

O procedimento para se declarar uma vari vel do tipo pointer ,
simples, sen,,o vejamos:

Var
p : ^Integer;

Ap¢s esta declara‡,,o, ter¡amos criado uma vari vel do tipo pointer
que ocupa 4 bytes (lembre-se que ela aponta um endere‡o, e como
sabemos, no IBM/PC, um endere‡o , formado pelo Segment e pelo
offset, cada um com 2 bytes) e que ir apontar uma vari vel do tipo
Integer. Eu utilizei como exemplo, o tipo Integer, mas poderia ser
qualquer outro tipo e at, mesmo Records.

At, esse instante, n,,o criamos a t,,o famosa vari vel dinƒmica, e
sim uma vari vel do tipo pointer, que ir apontar o endere‡o de uma
vari vel dinƒmica do tipo Integer. Isto parece meio complicado a
princ¡pio, mas aos poucos, iremos entender o funcionamento desse
novo tipo de vari vel.

E agora eu pergunto, para onde est apontando a vari vel rec,m-
criada chamada p ? Simplesmente para nenhum lugar. E isto recebe o
nome em Pascal de NIL. Quando escrevemos no meio de um programa a
declara‡,,o abaixo:

p := NIL;

Estamos querendo dizer que a vari vel do tipo pointer, chamada p,
n,,o est apontando para nenhuma vari vel no momento. Sempre que
criamos uma vari vel do tipo pointer, ela tem o valor inicial NIL.

X.3 - Cria‡,,o de vari veis dinƒmicas.
------------------------------

O pr¢ximo passo, , a cria‡,,o de uma vari vel dinƒmica, para tanto,
utilizamos a procedure New. Sua sintaxe ,:

New(p);

Isto faz com que seja alocado um espa‡o de mem¢ria, suficiente para
armazenar uma vari vel do tipo associado a p, no caso integer. Esse
espa‡o de mem¢ria fica num local especial chamado HEAP. No caso do
IBM/PC, o HEAP , toda a mem¢ria n,,o utilizada pelo sistema.

Portanto, a declara‡,,o New(p) aloca um espa‡o de mem¢ria no HEAP,
suficiente para armazenar uma vari vel do tipo Integer e retorna o
endere‡o inicial desta regi,,o de mem¢ria para a vari vel p. Lembre-
se que p , do tipo pointer.

A grande quest,,o agora ,: Como acessamos essa vari vel dinƒmica?.
Atrav,s da seguinte simbologia:

p^

Est na hora de um exemplo para esclarecer melhor as coisas:

---------------------------------------------------------
Program Exemplo;
Uses CRT;

Type Ponteiro = ^Integer;

Var p : Ponteiro;
i : Integer;

(* p , uma vari vel do tipo pointer que aponta para vari veis
dinƒmicas do tipo integer *)

Begin
ClrScr;
If p = NIL Then Writeln('sim');

(* como p acabou de ser criada, ela n,,o deve estar apontando para
algum endere‡o, ou seja, seu valor inicial deve ser NIL. Para
descobrirmos se isso , verdadeiro, basta compar -la com NIL *)

New(p);

(* acabamos de criar uma vari vel dinƒmica do tipo Integer, e
seu endere‡o foi colocado no pointer p *)

p^:=100;

(* estamos atribuindo o valor 100 ... vari vel dinƒmica rec,m-
criada *)

Writeln(p^);

i:=200;
p^:=i;
Writeln(p^); (* ser escrito 200 *)

(* A fun‡,,o addr(var) retorna o endere‡o da vari vel var *)

p:=addr(i); (* o pointer cont,m agora o endere‡o da
vari vel i *)

p^:=1000; (* indiretamente estou atribuindo o valor
1000 ... vari vel i *)

Writeln(i); (* ser escrito 1000 *)
End.
---------------------------------------------------------

X.4 - Estruturas de dados com ponteiros
---------------------------------

Suponha que vocˆ tenha que fazer um programa que ter que ler uma
certa quantidade indeterminada de registros do teclado. Vocˆ n,,o
sabe se ser,,o 10, 100 ou at, 1000 registros. A princ¡pio, vocˆ
poderia super-dimensionar um array, desde que seu computador tenha
mem¢ria suficiente, mas mesmo assim,corre-se o risco de ,no futuro,
termos que redimensionar a matriz. Para um caso como este, podemos
utilizar o conceito de vari veis dinƒmicas. Para tanto, devemos
declarar um pointer para uma vari vel, cuja estrutura seja consti-
tu¡da de dois campos: um contendo o valor propriamente dito que se
quer armazenar e o outro apontando para a pr¢xima vari vel dinƒmica.

Exemplo:
---------------------------------------------------------
Program Exemplo;
Uses CRT;

(********************************************************
Este programa lˆ registros com a estrutura abaixo, at,
que se digite 'fim' quando , perguntado o nome da
pessoa. Repare que o programa tem a capacidade de ler um
n£mero ilimitado de registros sem a preocupa‡,,o de se
definir um array e sua respectiva dimens,,o.

Nome : String[30];

Sexo : Char;

Idade : Integer;

Altura: Real;

********************************************************)

Type

Pessoa = Record
Nome : String[30];
Sexo : Char;
Idade : Integer;
Altura: Real;
End;

ponteiro = ^Pessoas;

Pessoas = Record
Valor : Pessoa;
Prox : Ponteiro;
End;

Var
p,prim : Ponteiro;

Procedure Linha;
Var i:integer;
Begin
For i:=1 to 80 do write('-')
End;

Begin
Prim:=nil;
ClrScr;
Repeat
Linha;
New(p);
Write('Nome da pessoa -----> ');
Readln(p^.valor.Nome);
If (p^.valor.Nome<>'fim')
Then Begin
Write('Sexo ---------------> ');
Readln(p^.valor.Sexo);
Write('Idade --------------> ');
Readln(p^.valor.Idade);
Write('Altura -------------> ');
Readln(p^.valor.altura);
p^.Prox:=Prim;
Prim:=p;
End;
Until p^.valor.nome='fim';

ClrScr;
Linha;
p:=prim;
While p<>nil do
Begin
With p^.valor do
Writeln(nome:30,sexo:5,idade:5,altura:6:2);
p:=p^.prox;
End;

End.
---------------------------------------------------------

X.5 - Procedures para vari veis dinƒmicas
-----------------------------------

X.5.1 - Dispose

Esta procedure libera o espa‡o ocupado pela vari vel em quest,,o que
deve ser do tipo pointer.Ela n,,o mexe com o resto do HEAP. Sintaxe:

Dispose(Var);

Podemos dizer que Dispose , contr rio a New, pois esta aloca espa‡o
no HEAP para determinado tipo de vari vel enquanto Dispose libera
este espa‡o.

X.5.2 - Mark e Release

Como vimos, as vari veis dinƒmicas s,,o armazenadas num local de
mem¢ria especial chamado de HEAP. Esse trecho de mem¢ria funciona
como se fosse uma pilha. E para controlar o topo da pilha, o Turbo
Pascal mant,m um apontador. N¢s podemos alterar o valor do
apontador do topo do HEAP. N,,o podemos esquecer que alterarando o
valor deste apontador, todas as vari veis dinƒmicas que estiverem
acima deste endere‡o ser,,o perdidas. A procedure que nos permite
alterar o valor deste apontador , a Release e sua sintaxe ,:

Release(Var);

Onde Var deve ser uma vari vel do tipo pointer e que deve conter o
endere‡o desejado, para se atribuir ao apontador do topo do HEAP.

J a procedure Mark nos permitem atribuir, a uma vari vel do tipo
pointer, o valor atual do apontador do topo do HEAP. Sintaxe:

Mark(Var);

Estas duas procedures em conjunto nos permite controlar e liberar,
quando desejarmos, um trecho de mem¢ria do HEAP.

X.5.3 - GetMem e FreeMem

Com a procedure New, podemos alocar espa‡o necess rio no HEAP
somente para uma vari vel de determinado tipo. Com o par Mark e
Release ou Dispose, podemos liberar tal espa‡o no HEAP. J , as
procedures GetMem e FreeMem, podemos alocar o n£mero de bytes que
desejarmos, sem estarmos presos a um determinado tipo de vari vel.
Sintaxes:

GetMem(Var,i);

Onde Var , do tipo pointer e i Integer.

Ap¢s esta declara‡,,o, ter¡amos alocado no HEAP,um espa‡o de mem¢ria
no HEAP no tamanho de i bytes. O endere‡o inicial desse trecho de
mem¢ria , retornado em Var.

FreeMem(Var,i);

Esta procedure faz exatamente o contr rio da GetMem, ou seja,libera
i bytes no HEAP a partir do endere‡o armazenado em Var.

X.6 - Functions para vari veis dinƒmicas
----------------------------------

X.6.1 - MaxAvail

Retorna um n£mero inteiro, que corresponde ao n£mero de par grafos
(conjunto de 16 bytes) livres dispon¡veis no maior bloco de espa‡o
cont¡guo no HEAP.

X.6.2 - MemAvail

Retorna o n£mero de par grafos dispon¡veis no HEAP.

Bem espero ter ajudado!, e como disse no começo esse texto é melhor visualizado pelo EDIT do DOS
fonte: http://www.txt.org