PROGRAMAÇÃO PASCAL

Lição 1 – Introdução

Introdução

É uma linguagem de programação estruturada que recebeu este nome em homenagem ao matemático Blaise Pascal. Foi criada
em 1970 pelo suíço Niklaus Wirth, tendo em mente encorajar o uso de código estruturado.

O próprio Niklaus Wirth diz que Pascal foi criada simultaneamente para ensinar programação estruturada e para ser utilizada em
sua fábrica de software.

A linguagem é extremamente bem estruturada e muito adequada para ensino de linguagens de programação. É provavelmente
uma das linguagens mais bem resolvidas entre as linguagens estruturadas, e certamente, um dos exemplos de como uma
linguagem especificada por uma pessoa pode ser bem melhor do que uma linguagem especificada por um comitê.

Pascal originou uma enorme gama de dialetos, podendo também ser considerada uma família de linguagens de programação.
Grande parte de seu sucesso se deve à criação, na década de 80, da linguagem Turbo Pascal, inicialmente disponível para
computadores baseados na arquitetura 8086 (com versões para 8080 no seu início).

Pascal é normalmente uma das linguagens de escolha para ensinar programação, junto com Scheme, C, e Fortran.

Pré-requisitos

O objetivo deste curso não é ensinar a lógica de programação, assim, ele será melhor aproveitado pelos alunos que já tiverem
conhecimentos básicos sobre ela.

Será necessário instalar um compilador de pascal no seu computador para fazer os exercícios práticos. Escolha um dos
compiladores da lista e instale antes de começar o curso.

Para instalar o free pascal:

#apt-get update

#apt-get install fp-compiler

Como compilar e executar

Sempre que você escrever um programa em Pascal ou quiser testar algum dos exemplos faça o seguinte:

• Abra um editor de texto qualquer (gedit, kate, kedit, etc) e escreva seu programa (ou copie e cole o exemplo);
• Salve o arquivo com a extensão .pas, por exemplo, teste.pas;
• Abra um terminal e digite fpc <nome_do_arquivo.pas>, isto irá compilar seu programa. Se houver algum erro nele
que impessa será exibida uma mensagem na tela dizendo qual o erro;
• Digite então ./<nome_do arquivo>, agora você não deve digitar o .pas do nome do arquivo. O ./ executa o programa.

Lição 2 - Conceitos Iniciais

Constantes e variáveis

Constantes e variáveis são elementos básicos manipulados pelos programas. Ambos armazenam dados. As constantes
armazenam dados que terão o mesmo valor durante toda a execução do programa. As variáveis armazenam dados que podem
ter seus valores alterados durante a execução.

Todas as constantes e variáveis de um programa em Pascal precisam ser declaradas no início do programa. Assim o computador
poderá reservar o espaço de memória que será necessário para a execução do programa.

Cada constante ou variável tem um nome que a identifica, ou um identificador, e um tipo. Os identificadores servem para que se
tenha acesso aos dados, podendo vê-los e modificá-los quando for necessário. Existem algumas regras para os identificadores,
são elas:

• O primeiro caractere de um identificador deve ser obrigatoriamente uma letra;

 • Os caracteres seguintes podem ser letras ou dígitos;
• Não é permitido o uso de caracteres em branco ou quaisquer outros que não sejam letras ou dígitos;
• A linguagem Pascal não diferencia as letras maiúsculas das minúsculas, assim, Variavel3 e variavel3 são considerados o
mesmo identificador.

Os tipos de dados do Pascal serão explicados a seguir:

Para os dados numéricos o Pascal tem diferentes tipos tanto para inteiros quanto para reais. A diferença entre os tipos de cada
um desses grupos é o intervalo de valores que cada um suporta. Por exemplo, os tipos Shortint e Integer armazenam inteiros. A
diferença entre eles é que um dado do tipo Shortint pode assumir valores entre -128 e 127 e os dados do tipo Integer podem
assumir valores de -32768 a 32767. A lista seguinte mostra todos os tipos de dados numéricos da linguagem Pascal e o intervalo
de valores suportado por cada tipo.

Tipos de dados inteiros:

• Shortint -128 a 127;

• Integer -32768 a 327667;
• Longint -2147483648 a 2147483647;
• Byte 0 a 255;
• Word 0 a 65535.

Tipos de dados reais

• Real 2,9 * 10-39 a 1,7 * 10 38

• Single 1,5 * 10 -45 a 3,4 * 1038
• Double 5,0 * 10-324 a 1,7 * 10 308
• Extended 3,4 * 10-4932 a 1,1 * 104932
• Comp -9,2 * 10 18 a 9,2 * 10 18

É importante escolher o tipo certo de dado para cada situação para que não haja desperdício de memória. Por exemplo, uma
variável dia que representa os dias do mês poderá ter apenas valores inteiros de 0 a 31. Então, não faz sentido escolher para
esta variável o tipo de dados real, ou longint. O tipo Byte é capaz de armazenar todos os valores possíveis de dia e é o que
menos ocupa memória (quanto menor o intervalo de valores suportado pelo tipo menor, será a quantidade de memória alocada),
então é a melhor escolha a ser feita. O tipo Shortint também poderia ser escolhido, pois ocupa a mesma quantidade de memória
do tipo Byte e é capaz de armazenar valores inteiros de 0 a 31.

Além dos tipos dados numéricos, o Pascal tem tipos de dados lógicos e de caracteres, mostrados abaixo:

Tipos de dados caracteres:

• String;
• Char.

Tipos de dados lógicos:

• True;
• False.

As variáveis do tipo char armazenam um caractere (isto é, uma letra, um dígito ou um símbolo especial). As do tipo string
armazenam uma cadeia de caracteres, podendo formar palavras. Uma string pode ter no máximo 255 caracteres.

Os dados do tipo lógico só podem assumir os valores verdadeiro (true) ou falso (false). Uma variável, ou constante, lógica deve
ser declarada como boolean.

Declaração de Variáveis

Você já sabe que as variáveis tem de ser declaradas, então, vejamos como se faz isto.

Var

nome: string [30];

idade: shortint;

salário: comp;

Antes das declarações utilizamos a palavra reservada var, que indica que as próximas linhas terão declarações de variáveis.
Depois a sintaxe é a seguinte:

<nome da variável> : <tipo>;

Observe que ao final de cada linha é necessário usar um ponto-e-vírgula. Se houver mais de uma variável do mesmo é possível
escrevê-las na mesma linha. Neste caso o nome das variáveis deve ser separado por vírgulas, como no exemplo abaixo:

nota1, nota2, nota3 : real;

também é permitido declarar variáveis de tipos diferentes em uma linha.

nome: string [30]; idade: shortint;

porém, como você deve ter percebido, isto dificulta a legibilidade do programa. Em alguns casos a declaração de muitas
variáveis do mesmo tipo em uma linha também causa este problema.

Declaração de Constantes

Para declarar uma constante em Pascal basta escrever seu identificador e seu valor, precedidos da palavra const. Como foi feito
abaixo:

const
nome = 'Ana Maria de Souza';
idade = 35;

O valor atribuído a uma constante na declaração pode ser um real, inteiro, uma string ou um valor lógico. A sintaxe de uma
declaração de constante é sempre igual a do exemplo acima:

<identificador> = <valor>;
As operações aritméticas básicas do Pascal são: soma, subtração, multiplicação, divisão, divisão inteira e resto. As operações de
soma e subtração têm menor prioridade que as demais. Entre operações com a mesma prioridade será executada primeiro a que
estiver mais à esquerda na expressão. A representação dos operadores em Pascal é mostrada a seguir:

+ soma
_ subtração
* multiplicação
/ divisão
div divisão de inteiros
mod resto da divisão de inteiros

Os operadores +, -, * e / podem ser usados tanto para reais quanto para inteiros. Os operadores div e mod só podem ser
usados para números inteiros. Em expressões com os operadores +, - e * se um dos operandos for real o resultado será
origatoriamente real. O operador / só produz resultados reais, independentemente do tipo dos operandos.
Veja alguns exemplos:
Considere i1 e i2 variáveis inteiras, e r1 e r2 variáveis reais,

• i1 + i2 tem resultado inteiro;

• i1 + r1 tem resultado real;
• i1 / i2 tem resultado real;
• i1 * i2 tem resultado inteiro;
• i1 mod i2 tem resultado inteiro;
• i1 mod r1 é uma operação inválida, já que os operandos de mod têm de ser necessariamente inteiros.

O Pascal tem também funções para realizar operações diferentes das que já foram citadas, como seno e exponenciação. A tabela
seguir mostra estas funções.

Função Resultado Tipo do resultado

ln(ea) logarítmo natural de ea real
exp(ea) eelevado a ea real
abs(ea) módulo de ea integer ou real
trunc(ea) valor truncado de ea integer
round(ea) valor arredondado de ea integer
sqr(ea) ea elevado ao quadrado integer ou real
sqrt (ea) raíz quadrada de ea real
sin(ea) seno de ea real
cos(ea) cosseno de ea real
arctan(ea) arco tangente de ea real

Obs:
1. ea é uma expressão aritmética.
2. truncar um número significa considerar apenas sua parte inteira. Por exemplo, truncando 4,87 teríamos 4 como resultado.

Pergunta:
De que tipo deverão ser as variáveis a, b, c, d e e para que o seguinte trecho de programa esteja correto?

a := (b+c)/(d mod e)

a: real;
b: integer;
c: real;
d: integer;
e: integer;

Uma expressão lógica é uma expressão à qual podem ser atribuídos os valores verdadeiro ou falso.

Chamamos de relação uma expressão que compara dois valores do mesmo tipo. Freqüentemente utiliza-se uma combinação de
relações com expressões lógicas nos programas em Pascal. Os operadores relacionais estão listados na tabela seguinte.

> maior
>= maior ou igual
< menor
<= menor ou igual
= igual
<> diferente

Podemos utilizar os operadores relacionais tanto para comparar dados numéricos quanto caracteres. A comparação entre strings
é feita caractere a caractere de acordo com a ordem alfabética, assim, 'ana' < 'bruno'. Cada comparação retorna um valor
lógica. Por exemplo, se a = 2 e b = 2.5, a comparação a > b retornará o valor false.

Operador lógico, assim como um operador aritmético, é uma classe de operação sobre variáveis ou elementos pré-definidos.
AND, OR e NOT são os principais operadores lógicos, base para a construção de sistemas digitais e da Lógica proposicional. Os
operadores AND e OR são operadores binários, ou seja, necessitam de dois elementos, enquanto o NOT é para um único
elemento.

Uso:

• x1 AND x2;
• x1 OR x2;
• NOT x1.

Descrição:

• AND: operador lógico onde a resposta da operação é verdade (1) somente se ambas as variáveis forem verdade.

x1 x2 x1 AND x2
0 0 0
0 1 0
1 0 0
1 1 1
 • OR: operador lógico onde a resposta da operação é verdade (1) se pelo menos uma das variáveis de entrada for
verdade.

x1 x2 x1 OR x2
0 0 0
0 1 1
1 0 1
1 1 1
• NOT: operador lógico que representa a negação (inverso) da variável atual. Se ela for verdade, torna-se falsa, e vice-
versa.

x1 NOT x1
0 1

OBS: nas tabelas acima o valor 0 equivale a false e o valor 1 equivale a true.

Pergunta:
Se a é uma variável do tipo boolean, qual o valor de a depois de ser executada a seguinte linha de código:
a := (b or c) and d;
onde as variáveis b, c e d têm respectivamente os valores false, true e false;

FALSE

A função de um comando de atribuição é modificar o valor de uma variável. A sintaxe de uma atribuição é a seguinte:

<nome da variável> := <novo valor>;

OBS: o novo valor pode ser uma expressão, por exemplo:

salarioliquido := salariobruto - (dependentes * mensalidade);

onde mensalidade é o valor pago para cada um dos dependentes para que ele tenha direito ao plano de saúde do funcionário.

Antes de usar um comando de atribuição lembre-se de que a variável e o novo valor devem ser de tipos compatíveis. Por
exemplo, se idade é uma variável inteira não poderíamos escrever

idade := 'maria';

Mesmo entre um valor inteiro e uma variável inteira é preciso tomar algum cuidado para que não haja erros. Neste caso, o
importante é verificar que o tipo de dado da variável é capaz de armazenar o novo valor. Veja um exemplo:

numerodealunos := 400;

se numerodealunos for do tipo integer não haverá nenhum problema com esta atribuição, porém, se ele for do tipo byte não
será possível atribuir o novo valor a ele, pois variáveis deste tipo só podem assumir valores entre 0 e 255. O mesmo acontece
com os reais. Antes de atribuir um valor a uma variável tenha certeza de que ela será capaz de armazenar este valor.

O comando de atribuição também pode ser usado para variáveis lógicas (boolean). Veja um exemplo:

aprovado := false;

onde aprovado é uma variável booleana que recebe valor verdadeiro se o aluno obteve média maior ou igual a 6, e falso caso
contrário.

Pergunta:
Qual das seguintes atribuições foi feita da maneira correta em Pascal?

idade := 15;
onde idade é uma variável do tipo integer.

Lição 3 - Começando a Programar

Agora que você já sabe um pouco sobre a linguagem Pascal começaremos a programar!
Todo programa em Pascal tem a seguinte estrutura:

Program <nome do programa>;

var
<declarações de variáveis>

begin
<instruções>
end.

Se o programa tiver constantes basta declará-las logo depois das variáveis, como foi mostrado na primeira lição. As palavras
begin e end delimitam o bloco principal do programa, onde são escritos os comandos.

program Hello;
var
mensagem : string;

begin
mensagem := 'Hello World';
write (mensagem);
end.

Copie e cole o programa acima no editor de texto. salve-o com o nome de hello.pas, agora abra o terminal, entre na pasta que
você salvou o hello.pas e digite os seguintes comandos:
$ fpc hello.pas
$ ./hello

O primeiro comando compila o programa, isto é, traduz o seu programa em Pascal para um código objeto, que posteriormente
resultará num programa executável. O segundo comando executa o executável gerado após a compilação. Se tudo der certo
depois destes comandos você verá na tela a frase Hello World.
A maior parte do programa você já deve ter entendido. Primeiro declaramos uma variável do tipo string chamada mensagem.
Depois, dentro do bloco principal do programa, atribuímos a mensagem à string Hello World. A última parte é a que você não
tinha aprendido ainda, write (mensagem); faz com que o conteúdo da variável mensagem seja impresso na tela. Na próxima
página você aprenderá mais alguns comandos de entrada e saída.

Na página anterior foi usado um comando que ainda não tinha sido apresentado neste curso, o comando write. Você muito
provavelmente percebeu que a função deste comando é escrever uma mensagem na tela. Existem outros comandos que têm a
função de receber dados do usuário e mostrar informações a ele. Eles são chamados comandos de entrada e saída, e serão
apresentados a seguir.

Entrada

• read

O comando read é usado para ler dados que o usuário digita. A sintaxe desse comando é a seguinte:

read (lista de identificadores);

quando a lista de identificadores tiver mais de um identificador, separe-os com vírgulas. Quando o programa é executado os
valores devem ser escritos separados por espaços.

• readln

O readln também tem como função ler dados da entrada padrão. Sua sintaxe é a seguinte:

readln (lista de identificadores);

A diferença entre estes dois comandos é que se em uma linha de entrada forem digitados mais valores do que os que o
programa precisa ler no momento, o readln ignora os próximos valores. O read, ao contrário, utilizará estes valores como
entradas na próxima vez que o programa tiver um comando de entrada. Veja um exemplo:

program funcoesdeleitura;

var
i1, i2, i3: integer;
r1, r2, r3: real;

begin
read (i1,r1);
read (i2,r2);
read (i3,r3);
end.

Suponha que o programa foi executado e o usuário digitou os seguintes valores:

1 3.2 3 3.8 2 2.4 <-'
5 4.2 8 2.5 9 4.2 <-'
6 4.3 7 7.3 4 5.5 <-'

em que o símbolo <-' representa a tecla enter.

Neste caso as variáveis i1, i2, i3 e r1, r2, r3 receberiam os seguintes valores:
i1 = 1
r1 = 3.2
i2 = 3
r2 = 3.8
i3 = 2
r3 = 2.4

Se o mesmo programa tivesse sido escrito substituindo os read por readln os valores das variáveis seriam os seguintes:
i1 = 1
r1 = 3.2
i2 = 5
r2 = 4.2
i3 = 6
r3 = 4.3
Isto porque depois de fazer r1 = 3.2 os demais valores da primeira linha seriam ignorados. O segundo read utilizaria os valores
da segunda linha, fazendo i2 = 5 e r2 = 4.2.

Saída

Assim como para a entrada existem dois comandos para saída, write e writeln. A sintaxe desses comandos é idêntica à dos
mostrados anteriormente.

write (lista de identificadores);

writeln (lista de identificadores);

Como ja foi dito, a funcão deles é imprimir algo na tela. No lugar da lista de identificadores podemos colocar valores constantes,
strings, expressões etc. Veja alguns exemplos:

writeln ('Bom Dia');

writeln ('idade: ',idade);
writeln ('media = ', lições*0.7 + prova*0.3);

Se as variáveis tivessem os valores

idade = 18;
lições = 9;
prova = 10.
Os comandos acima teriam as seguintes saídas:

Bom Dia;
idade: 18;
media = 9.3.

A diferença entre os comandos write e writeln é que o segundo depois de imprimir a mensagem muda o cursor para a próxima
linha. Assim, se houver vários writeln no programa, a saída de cada um deles será escrita em uma linha. Por outro lado, se
houver vários write, todas as saídas serão escritas na mesma linha.

Exercício 1
Escreva um programa que leia os dados de uma pessoa, nome, idade, número de identidade, telefone e endereço, e os imprima
na tela.

Lição 4 - Condicionais e Estruturas de Repetição

Os programas em Pascal são executados sequencialmente, isto é, os comandos são executados um a um na ordem em que
foram escritos. Porém, existem algumas estruturas que podem mudar esta ordem. Por exemplo, usando uma estrutura de
repetição pode-se fazer com que o próximo comando executado não seja o da próxima linha, mas o que está cinco linhas acima
do último comando executado. A seguir serão apresentadas as estruturas de decisão e repetição.

Estruturas de Decisão

Se você já conhece a lógica de programação, ou alguma outra linguagem, provavelmente se lembrará de que é muito comum ter
de associar determinados comandos em um programa a condições. Por exemplo,

se (média >= 6.0)

então aprovado := true

senão aprovado := false

Neste caso a condição para que uma pessoa seja aprovada é que sua média final seja maior ou igual a 6. Se isto não acontecer
ela será reprovada (aprovado = false). A sintaxe das estruturas de repetição em Pascal é a seguinte:

If condição;

then comandos;

{else comandos}.

O que essa estrutura faz é primeiro verificar se a condição é verdadeira ou falsa. Se for verdadeira os comandos que vêm depois
do then serão executados. Se for falsa os comandos depois do else serão executados. O else não é necessário. Você pode usar
uma condição apenas para decidir se um comando será ou não executado, sem precisar dizer o que será feito se a condição não
for verdadeira. Quando há mais de um comando a ser executado no then ou no else precisamos sinalizar quais são eles, caso
contrário seria impossível distinguir estes comandos dos que vem depois da estrutura de repetição e devem ser executados
independentemente da condição. Veja o exemplo abaixo:

If (hora >= 16.0);

then write ('O horário de funcionamento já foi encerrado');

write ('Obrigado por visitar nossa página').

Neste caso a linha write ('Obrigado por visitar nossa página'); deverá ser executada apenas se a condição hora >= 16.0 ou em
todos os casos? Seria impossível saber isso. Por isso usamos blocos de comandos que delimitam quais comandos estão dentro
de cada parte da estrutura. As palavras utilizadas para isso são begin e end. Veja outro exemplo:

If (hora >= 16.0)

then

begin

write ('O horário de funcionamento já foi encerrado');

write ('Por favor retorne amanha');

end

else

begin

write ('por favor digite seu número de identificação');

read (numero);

write ('por favor digite a senha de acesso');

read (senha);

end;

write ('Obrigado por visitar nossa página');

Neste caso fica claro que quando a condição for verdadeira será executado o bloco:

begin

write ('O horário de funcionamento já foi encerrado');

write ('Por favor retorne amanha');

end
e se a condição for falsa será executado o seguinte:

begin

write ('por favor digite seu número de identificação');

read (numero);

write ('por favor digite a senha de acesso');

read (senha);

end;

e o comando write ('Obrigado por visitar nossa página'); será executado independentemente da condição.

Outra forma de mudar a ordem seqüencial de execução de um programa é através das estruturas de repetição ou laços. Estas
estruturas são usadas para que um mesmo bloco de comandos seja executado várias vezes. No Pascal existem três diferentes
formas de fazer isto, for, while e repeat.

For

A primeira forma de laço estudada neste curso será o for. Nela é sempre usado um contador, que controla o número de vezes
que o bloco será repetido. A sintaxe do for é a seguinte:

for contador := valor-inicial to valor-final do

begin
bloco de comandos
end;

ou

for contador := valor-inicial downto valor-final do

begin
bloco de comandos
end;

onde contador é a variável responsável por determinar quantas vezes o bloco ainda será executado. A cada vez que o laço é
executado o valor de contador é incrementado (quando usamos o to) ou decrementado (quando usamos o downto). É
importante observar que o contador deve ser sempre declarado como uma variável inteira. O laço será repetido até que o
contador seja maior que o valor final, se for usado to, ou menor que ele, se for usado o downto.

Observe os valores assumidos pelo contador na execução do seguinte programa:

program UsandoFor;

var
contador: byte;

begin
for contador := 1 to 10 do
writeln ('contador= ', contador);
writeln (fim do laco);
writeln ('contador= ', contador);
end.

A saída impressa na tela será a seguinte:

contador= 1
contador= 2
contador= 3
contador= 4
contador= 5
contador= 6
contador= 7
contador= 8
contador= 9
contador= 10
fim do laço
contador= 10
Ao final de cada execução do laço a variável contador é incrementada automaticamente. Isso acontece até que seu valor seja
igual ao valor final (10). Então o próximo comando depois do for é executado. Observe que após o fim das repetições o contador
terá o útilmo valor que recebeu no for, 10. Os valores inicial e final não precisam ser necessariamente constantes, podem ser
variáveis inteiras, como no exemplo abaixo:

program UsandoFor;

var
valorinicial, valorfinal : byte;
contador : byte;

begin

writeln ('digite o valor inicial');

readln (valorinicial);
writeln ('digite o valor final');
readln (valorfinal);

for contador := valorinicial to valorfinal do

writeln ('contador= ', contador);

writeln ('fim do laco');

writeln ('contador= ', contador);

end.

Exercício:

Agora que você já sabe como utilizar o laço for, escreva um programa que receba as notas finais de oito alunos da turma do
curso de Pascal e calcule a média da turma. Como a média é igual a (soma das notas)/8, você precisará de uma variável que
armazene a soma das notas. Depois de ter lido todas elas basta dividir o valor desta variável por 8.
Depois modifique seu programa para que o usuário possa informar qual o número de alunos da turma.

O for é um laço do tipo contado. Ou seja, há uma variável que conta quantas vezes ele já foi executado e o fim da execução
acontece quando esta variável atinge um valor máximo ou mínimo. Os outros dois tipos de loops do Pascal (while e repeat) não
são contados, são condicionais. Isto quer dizer que a execução não tem um número definido de vezes para acontecer. Seu fim
depende de uma condição. Veja a sintaxe do while:

while (condição)
do
begin
comandos
end;

No exemplo abaixo o usuário pode definir até quando o loop será executado. A situação é a seguinte, deseja-se calcular a renda
per capita de um condomínio, porém, o número de moradores é desconhecido. O programa é executado até que a renda de
todos os moradores já tenha sido digitada. Para que o cálculo seja feito corretamente, se um morador não tem renda alguma
será digitado para ele o valor 0. A execução do loop terminará quando for digitado o valor -1 para a renda.

A condição é uma expressão lógica, que pode assumir os valores verdadeiro ou falso. Antes de entrar no laço esta condição é
testada. Se ele for verdadeira os comandos de dentro do while serão executados. Se for falsa o loop termina.

Program RendaPerCapita;

var

renda : integer;
rendatotal : integer;
nmoradores : integer;
percapita : real;

begin

renda := 0;
rendatotal := 0;
nmoradores := 0;

while (renda <> -1)

do
begin
writeln ('digite a renda do morador');
readln (renda);
if (renda >= 0)
then
begin
rendatotal := rendatotal + renda;
nmoradores := nmoradores +1;
end;
end;

percapita := rendatotal/nmoradores;
writeln ('renda per capita do condiminio: ',percapita:6:2);

end.

Como você já deve ter percebido as variáveis renda, rendatotal e nmoradores foram inicializadas com 0 no início do programa.
Isto é importante porque diferentes compiladores podem atribuir diferentes valores a variáveis não inicializadas. No free pascal
elas teriam o valor zero mesmo que você não atribuisse esse valor a elas, mas em outro compilador talvez tivessem um valor
diferente. O zero é o melhor valor inicial porque antes de entrar no laço ainda não foi contado nenhum morador e nenhuma
renda. Além disso renda = 0 permite que o laço comece.

Neste exemplo há uma estrutura que não tinha sido mostrada ainda neste curso, um bloco de comandos dentro de outro (no if).

Exercício
Pesquise a função do :6:2 da última linha do último exemplo.
O repeat é o segundo tipo de loop condicional do Pascal. A diferença entre ele e o while é que no while a condição é testada
antes de entrar no laço, enquanto que no repeat ela é testada no final de cada repetição. A sintaxe deste laço é a seguinte:
repeat
comandos
until condição;

no repeat não é preciso utilizar begin e end para delimitar os comandos que fazem parte do laço, pois o until já faz isso. Como a
condição de parada só é testada no final do laço todos os comandos serão executados pelo menos uma vez. Depois de terem
sido executados a condição é testada. Se ele for verdadeira o programa não entrará de novo no laço, se for falsa repetirá todos
os comandos e testará novamente a condição até que ela seja verdadeira. Sempre que você for utilizar loops tenha certeza de
que há um momento em que o programa sairá deles. Caso contrário você terá um loop infinito.

Lição 5 - Estruturas de Dados e Manipulação de Arquivos

Até agora vimos apenas variáveis que armazenam um único dado, as variáveis simples. Existe um outro tipo de variáveis, as
compostas. As variáveis compostas têm diversos dados armazenados. Elas correspondem a diferentes posições de memória
identificadas por um único nome. A distinção entre essas posições é feita por índices.
Variáveis compostas podem ser unidimensionais (vetores) ou multidimensionais (registros). Em Pascal ambas são chamadas de
arrays. Tais variáveis podem ser ainda classificadas como homogêneas (quando todos os dados são de um mesmo tipo) ou
heterogêneas (quando as variáveis são de tipos diferentes).

Vetores

A declaração de um vetor é feita da seguinte maneira:

<identificador> : array [<inicio>..<fim>] of <tipo>;

em que <tipo> é o tipo dos componentes da variável e início e fim são os limites inferior e superior dos índices. Por exemplo, se
queremos um vetor que armazene os nomes dos 30 alunos de uma turma podemos fazer o seguinte:

nomes : array [1..30] of string;

Matrizes

As variáveis compostas homogêneas multidimensionais são chamadas matrizes. Se um vetor pode ser representado por uma
seqüência linear de elementos, uma matriz pode ser representada por uma tabela (se for bidimensional). Não há um limite para
o número de dimensões de uma matriz. Esse tipo de estrutura é comumente utilizado quando é necessária mais de uma
informação para distinguir um componente de outro. A sintaxe é bastante parecida com a dos vetores. A única diferença é que
para as matrizes é necessário informar os limites superior e inferior de cada dimensão.

<identificador> : array [<i1>..<f1>,<i2>..<f2>,.......,<in>..<fn>] of <tipo>;

em que <i1>,<f1>,<i2>,<f2>, etc são os limites inferior e superior dos índices de cada dimensão da matriz.

O exemplo seguinte mostra um trecho de programa que armazena em um vetor o nome e o endereço 10 pessoas e depois os
imprime na tela.
program Agenda;

var

i: byte;
lista : array [1..10,1..2] of string;
nome,endereco : string;

begin

for i:= 1 to 10 do
begin
writeln ('nome?');
readln (nome);
lista[i,1] := nome;

writeln ('endereco?');
readln (endereco);
lista[i,2] := endereco;
end;

for i:= 1 to 10 do
begin
writeln (i,'-> nome:',lista[i,1],' endereco:',lista[i,2]);
end;

end.

Registros

Um registro é um conjunto de dados de diferentes tipos relacionados. O registro é identificado por um nome. Cada campo de um
registro também tem um nome que o identifica dentro do registro. Por exemplo, para construir um registro que contém os dados
de um filme declararíamos o registro filme com os campos nome, gênero, autor, duração e censura. Esta declaração seria feita
da seguinte forma:

var
filme : record
nome : string;
genero : string;
autor: string;
duração : real;
censura : integer;
end;

Podemos também declarar os registros como tipos e depois declarar variáveis destes tipos. A vantagem deste tipo de declaração
é que podemos declarar várias variáveis com a mesma estrutura sem precisar repetir a declaração acima. Basta dizer uma vez
quais serão os campos. Depois podemos declarar quantas variáveis quisermos com os mesmos campos. No exemplo abaixo
declaramos um tipo endereço como sendo um registro com os campos cidade, bairro, rua, número. Depois declaramos uma
variável dadospessoais que é um registro onde um dos campos é do tipo endereço.
type
endereco = record
cidade : string;
bairro : string;
rua : string;
numero : integer;
end;

var
dadospessoais : record
nome: string;
idade : byte;
residencia : endereço;
telefone : string;
end;

Para acessar um dado de um registro usamos a sintaxe:

identificador.nomedocampo
Se quisermos, por exemplo, saber o autor do filme armazenado em filme podemos escrever:
writeln (filme.autor);
E para imprimir o nome da rua da pessoa cujos dados estão na variável dadospessoais fazemos o seguinte:
writeln (dadospessoais.endereco.rua);

Arrays de Registros
Podemos construir arrays de registros da mesma forma que fizemos com variáveis simples. Para fazer um vetor de filmes por
exemplo teríamos a seguinte declaração:

Type
filme = record
nome : string;
genero : string;
autor: string;
duração : real;
censura : integer;
end;
Var
filmes : array [1..15] of filme;

Arquivos

Arquivos são estruturas de dados armazenadas fora da memória principal e que podem ser acessadas durante a execução do
programa. Isto inclui discos rígidos, fitas magnéticas, disquetes, DVDs ou qualquer outro dispositivo que possa ser acessado
pelo computador onde ocorre a execução. Os arquivos podem ser de dois tipos, binários ou de texto. Ambos serão explicados a
seguir.

Declaração de Arquivos

A declaração de um arquivo é feita da seguinte forma:

type <nome do tipo> = file of <tipo>

var <nome da variável> : file of <tipo>

em que:

nome do tipo é o nome o identificador do novo tipo;

tipo é o tipo dos dados do arquivo, pode ser text, string, real, record, etc.

Exemplo 1

type

endereco = record
cidade : string;
bairro : string;
rua : string;
numero : integer;
end;

arqend : file of endereco;

var

arq1: arqend;

Exemplo 2

var
arquivotexto : text;

OBS : text é o tipo dos arquivos de texto.

Operações com arquivos

As principais operações que podem ser realizadas sobre arquivos são, abertura, fechamento, leitura e escrita. Antes de abrir um
arquivo é preciso associá-lo à variável declarada no começo. Para isso usamos o comando assign, que tem a seguinte sintaxe:

assign (nome da variável, nome do arquivo);

poderíamos por exemplo escrever:

assign (arquivo, 'nomes.txt');

Depois de associar o nome do arquivo à variável precisamos abri-lo. Existem diferentes tipos de abertura do arquivo,
dependendo do que será feito com ele:

Reset (nome da variável) - Abre o arquivo que foi associado à variável para leitura. Este comando só funciona se o arquivo já
existir, caso contrário haverá erro de execução;

Rewrite (nome da variável) – Abre o arquivo que foi associado à variável para escrita. Se o arquivo ainda não existir ele será
criado pelo programa. Porém, se ele já existir todo seu conteúdo será apagado. Só use este comando quando você quiser que os
dados sejam apagados ou quando o arquivo ainda não existir;

Append (nome da variável) – Abre o arquivo que foi associado à variável para escrita. Este comando só funciona se o arquivo já
existir, caso contrário haverá erro de execução. Se já houver algum conteúdo no arquivo ele será preservado e os novos dados
serão escritos no final do arquivo.

As operações básicas sobre um arquivo são leitura e escrita. Os comandos de leitura e escrita em arquivos são os mesmos que
utilizamos para a entrada e saída padrão, read, readln, write e writeln. A única diferença é que antes do nome da variável a ser
lida ou escrita, ou da string a ser escrita devemos escrever o identificador da variável correspondente ao arquivo. Veja alguns
exemplos:

Read (arqnomes, nome);

Readln (arqnomes, nome);

Write (arq1, identidade);

Writeln (arq2, 'Hello World');

OBS: os comandos readln e writeln só podem ser usados para arquivos de texto, para arquivos binários utiliza-se apenas read e
write.

Se você abrir um arquivo para leitura não poderá escrever nele, e se abri-lo para escrita não poderá ler dados dele.

Depois de executar todas as operações necessárias em um arquivo você deve fechá-lo. Isto garante a corretude dos dados após
o término do programa. Nunca deixe um arquivo aberto após a execução. O comando utilizado para fechar arquivos é o close e
sua sintaxe é a seguinte:

close (nome da variável);

Arquivos binários

Existem algumas operações que só podem ser realizadas em arquivos binários. Algumas delas são descritas abaixo:

seek (nome do arquivo, n) - Acessa o n-ésimo registro do arquivo. n deve ser menor que o número total de registros do
arquivo. É importante lembrar que para o primeiro registro do arquivo n=0. Assim, se queremos acessar o quinto registro do
arquivo arq fazemos:

seek (arq, 4);

Se você não souber o número total de registros do arquivo use o comando filesize. A sua sintaxe é:
filesize (nome do arquivo);
A linha de código abaixo imprime o número de registros do arquivo arq:
writeln('numero de registros: ',filesize(arq));

Localizando o fim do arquivo

Em muitas situações você precisará verificar se o arquivo já terminou ou se ainda há registros nele. Para isto o Pascal tem a
função eof (end of file) que retorna true se o arquivo já terminou e false caso contrário. Veja um exemplo de utilização desta
função:

repeat
readln (arquivo, nome);
until eof (arquivo);

este bloco lê do arquivo uma string nome até que chegue o fim do arquivo.
Modularizar um programa significa dividi-lo em pequenas partes simples. Cada parte deve realizar uma tarefa e ao final o
conjunto das partes deve ser capaz de fazer tudo que a especificação do programa exige. Estas partes, ou subprogramas, em
Pascal são classificadas como funções ou arquivos. Entre as vantagens de se modularizar um programa estão:

• Maior legibilidade;
• Facilidade de manutenção;
• Possibilidade de divisão do trabalho para um grupo de pessoas;
• Possibilidade de reaproveitamento de código (um trecho do programa que se repete várias vezes poderá ser escrito
apenas uma vez).

Nas próximas páginas você aprenderá a utilizar procedimentos e funções.

Procedures

Procedimentos são subprogramas. Isto é, programas menores que ficam dentro de um programa principal. Sendo assim, sua
estrutura é bastante semelhante à dos programas vistos até agora.

procedure <nome do procedimento> (lista de parâmetros);

var
{ declaração de variáveis }
begin
{ comandos}
end;

A primeira diferença que pode ser vista entre um programa principal e um procedure é a lista de parâmetros. Parâmetros são
variáveis declaradas fora do procedure que serão utilizadas dentro dele. É por meio deles que é feita a comunicação do
procedimento com a parte do programa externa a ele. Não é obrigatório que um subprograma receba parâmetros, mas muitas
vezes eles ajudam a possibilidade de reutilização do software. O programa seguinte contém um procedimento que troca os
valores das variáveis v1 e v.

procedure troca (var v1, v2: integer);

var aux: integer;
begin
aux:=v1;
v1:=v2;
v2:=v1;
end;

Na seção var são declaradas as variáveis locais do procedure. Também é possível declarar nesta parte constantes e tipos, como
foi feito em seções anteriores do curso. Os procedures são escritos antes do programa principal. A estrutura de um programa
com um procedure é a seguinte:

Program <nome do programa>;

const {declarações de contantes tipos e variáveis globais que forem necessárias}

type
var

Procedure
.
begin
.
.
end;

Begin
.
.
.
End.

Note que os comandos do programa principal só começam depois de todos os procedures.

Para utilizar um procedimento dentro do programa principal basta escrever no local onde ele deve ser chamado seu nome e os
parâmetros de entrada, caso existam, por exemplo:

Program CalculaResto;

Procedure resto(a,b,r:integer);
begin
r:= a mod b;
writeln ('o resto e; ', r);
end;
var
a1,a2,r1: integer;

begin
writeln (r1);
writeln ('a1?');
read (a1);
writeln ('a2?');
read (a2);
resto (a1,a2,r1);
writeln ('r1: ', r1);
end.

Neste programa a linha resto (a1,a2,r1); chama o procedure resto com os parâmetros a1, a2, r1. Você deve ter reparado que
mesmo após a execução do procedimento a variável r1 continuou tendo o valor com o qual foi inicializada, 0. Isto aconteceu
porque os procedimentos não alteram o valor dos parâmetros a não ser que essa intenção seja explicitada. No último exemplo
após a execução de resto todos os parâmetros mantiveram os valores que tinha antes da chamada de resto. Se o valor dos
parâmetros deve ser modificado após a execução do procedure usamos a palavra var antes da lista de parâmetros, como no
próximo exemplo:

Program CalculaResto;

Procedure resto(var a,b,r:integer);

begin
r:= a mod b;
writeln ('o resto e; ', r);
end;

var
a1,a2,r1: integer;

begin
r1 := 0;
writeln ('r1: ', r1);
writeln (r1);
writeln ('a1?');
read (a1);
writeln ('a2?');
read (a2);
resto (a1,a2,r1);
writeln ('r1: ', r1);
end.

Exercício

Faça uma pesquisa sobre a técnica de ordenação booble sort. Então crie um programa que use o procedure troca e ordene em
ordem crescente os dados de um vetor de inteiros de tamanho 5.

Functions

Funções também são subprogramas. A diferença entre functions e procedures é que as primeiras retornam um valor ao final de
sua execução, os procedures não. A sintaxe de uma function é a seguinte:

Function <nome da function> (lista de parâmetros) : tipo retornado;

var
{ declaração de variáveis }
begin
{ comandos}
end;

onde tipo retornado é o tipo do valor que a função retorna. A função do exemplo seguinte recebe como parâmetros a altura e a
largura de um retângulo e retorna o comprimento de sua diagonal.

function Diagonal (altura, largura : real): real;

begin
Diagonal := sqrt (sqr(altura)+sqr(largura));
end;

Agora podemos escrever um programa maior que pergunta ao usuário a altura, largura e profundidade de um paralelepípedo e
calcula sua diagonal. Para fazer isso será preciso primeiro calcular a diagonal da base do paralelepípedo (formada por largura e
profundidade). Depois calculamos a diagonal do retângulo formado pela diagonal da base e a altura do paralelepípedo, que é
igual a diagonal do paralelepípedo.
Program DiagParalelepipedo;

function Diagonal (altura, largura : real): real;

begin
Diagonal := sqrt (sqr(altura)+sqr(largura));
end;

var
altura, largura, profundidade : real;
diag: real;
aux: real;

begin

writeln ('altura?');
readln (altura);
writeln ('largura?');
readln (largura);
writeln ('profundidade');
readln (profundidade);

aux := Diagonal (largura, profundidade);

diag := Diagonal (aux, altura);
writeln ('A diagonal do paralelepipedo e: ',diag);

end.