4242 - Outras Linguagens Programacao

Linguagem Pascal
Introdução a
Linguagem Pascal
Autor:
Silvestre Santos
. 1
Linguagem Pascal
Introdução a
linguagem Pascal
. 2
Linguagem Pascal
Capítulo 1 - Conceitos básicos de programação
1.1 O programa de computador

Conforme já vimos, um computador, para realizar uma tarefa específica, como, por exemplo, somar 10
números em seqüência, requer que seja instruído, passo a passo para efetivamente realizar a tarefa. Necessita,
pois, que seja projetado com a capacidade de realizar (interpretar e executar) um determinado conjunto de
operações, cada uma sendo constituída de uma instrução específica (instrução de máquina). O conjunto de
instruções ou comandos organizados em uma certa seqüência, para obter o resultado da soma dos 10 números,
compõe o que denominamos programa de computador.
1.2 Linguagens de programação

Uma linguagem de programação é uma linguagem criada para instruir um computador a realizar suas
tarefas. Um programa completo, escrito em uma linguagem de programação, é freqüentemente denominado de
código.
Uma linguagem de programação é um conjunto de ferramentas, regras de sintaxe e símbolos ou
códigos que nos permitem escrever programas de computador, destinados a instruir o computador para a
realização de suas tarefas.
1.2.1 Linguagem de máquina

O tipo mais primitivo de linguagem de programação é a linguagem que o computador entende
diretamente, isto é, as instruções que podem ser diretamente executadas pelo hadware, isto é, pela CPU. É a
linguagem de máquina, que foi utilizada pela primeira geração de programadores. A única verdadeira linguagem
de programação é a linguagem de máquina, mas, para a maioria das pessoas, a linguagem de máquina é
ininteligível.
Um programa em linguagem de máquina é uma longa seqüência de números, alguns dos quais
representam instruções e outros, os dados a serem manipulados pelas instruções. A figura abaixo mostra um
exemplo de um trecho de um programa em linguagem de máquina, na sua forma binária e hexadecimal.
Programa em linguagem Programa em haxadecimal

binária
0010 0100 1001 0001 2491
0100 0100 1001 1111 449F
0100 0100 1001 0011 4493
0001 0100 1001 0010 1492
1000 0100 1001 1000 8498
Para escrever um programa em linguagem de máquina, o programador deve conhecer todas as

instruções disponíveis para aquela máquina e seus respectivos códigos de operação e formatos, assim como os
registradores da CPU disponíveis e os endereços das células de memória onde serão armazenadas as
instruções e os dados. Um programa real em linguagem de máquina, pode conter milhares de instruções, o que
é uma tarefa extremamente tediosa e difícil, pelos detalhes que precisam ser observados pelo programador.
Em um programa escrito em linguagem de máquina, cada instrução escrita pelo programador será
individualmente executada, isto é, a cada instrução do programa corresponderá uma ação do computador. A
relação é portanto 1 para 1 - uma instrução do programa corresponde a uma operação do computador.
Cada família de computadores possui sua própria linguagem de máquina. Um programa em linguagem
de máquina é dependente do computador ou seja, tendo sido escrito para um determinado computador, somente
poderá ser executado em computadores da mesma família, que lhe sejam 100% compatíveis.
. 3
Linguagem Pascal
1.2.2 Linguagem Assembly

Para os cientistas que desenvolveram o primeiro programa para traduzir instruções em código de
máquina, qualquer linguagem mais fácil de compreender do que a linguagem de máquina teria sido considerada
uma linguagem de alto nível.
Para tentar minimizar esta ineficiência (dificuldade de entendimento do significado dos números, todos
semelhantes), foi desenvolvida, ainda para a primeira geração de computadores, uma linguagem que
representasse as instruções por símbolos e não por números. A linguagem assenbly está mais próxima da
linguagem humana, mas também não apresenta legibilidade nem portabilidade.
Esta linguagem simbólica foi denominada Linguagem de Montagem (Assembly Language). Veja abaixo
um trecho de um programa em linguagem assembly.
DOSSEG
.MODEL SMALL
EXTRN _IntDivide:PROC
.CODE
PUBLIC _Average
...
Segundo os padrões dos dias de hoje, a linguagem assembly é uma linguagem de nível muito baixo,
porque seus comandos correspondem, um a um, ao conjunto de instruções de uma CPU. Na verdade não existe
apenas uma linguagem assembly. Cada tipo de CPU que tem um conjunto de instruções exclusivo tem sua
própria linguagem assembly.
Para usar-se linguagem de montagem em um computador, é necessário que haja um meio de converter
os símbolos alfabéticos utilizados no programa em código de máquina, de modo a poder ser compreendido pela
CPU. O processo de conversão (também denominado tradução) é chamado de montagem e é realizado por um
programa chamado Montador (Assembler). O montador lê cada instrução em linguagem de montagem e cria
uma instrução equivalente em linguagem de máquina.
A linguagem assembly continua, apesar de ser de uso tedioso e complexo, a ser importante, porque dá
aos programadores total controle sobre a CPU do computador. Além disso produz-se um código compacto,
rápido e eficiente.
Vantagens:
• Os programas escritos apresentam grande velocidade de execução;

• Os programas gerados são mais compactos, portanto ocupam menos espaço em memória;
• programador tem à sua disposição todos os recursos da máquina, sem limitações da linguagem.
Desvantagens:
• Os programadores devem ter altíssimo nível técnico;

• Os programas levam muito tempo para serem desenvolvidos e apresentam grande dificuldade para
alterações futuras;
• Os programas são muito específicos para cada microprocessador (não são portáveis).
1.2.3 Linguagem de alto nível

A linguagem de alto nível é uma linguagem de fácil aprendizado, apresenta uma melhor legibilidade,
além de ser independente da máquina, isto é, apresenta portabilidade. Da mesma forma que os programas com
instruções de máquina, os programas feitos em uma linguagem de alto nível, também requerem uma conversão
para instruções de máquinas. Este processo é denominado compilação. Normalmente, a conversão de um
simples comando Cobol ou C, redunda em dezenas de instruções de máquina, diferentemente de um programa
em linguagem de montagem, no qual cada instrução implica uma única instrução de máquina. Veja abaixo um
trecho de um programa em linguagem C (linguagem de alto nível).
. 4
Linguagem Pascal
Detail_procedure()
{
int file_status, current_line, id_num;
char *name;
float current_sales, ytd_sales, total_sales;
...
Vantagens:
• programador não se preocupa com aspectos muito técnicos, permitindo que ele se preocupe com o
problema a ser resolvido;
• Permitem rápido desenvolvimento de novos sistemas;
• Permitem que os programadores aprendam mais rapidamente, programem com mais eficiência e
façam alterações mais facilmente em programas anteriormente escritos;
• Maior portabilidade, ou seja, facilidade de transferência de programas para máquinas diferentes.
Desvantagens:
• Os programas (código) ocupam mais espaço de memória;

• A estrutura da linguagem tira parte da liberdade do programador e pode dificultar a implementação
de instruções mais técnicas, aproveitando menos os recursos da máquina.
• A velocidade de execução dos programas tende a ser mais lenta.
Foram desenvolvidas diversas linguagens de programação, buscando afastar-se do modelo centrado

no computador. Essas linguagens foram estruturadas buscando refletir melhor os processos humanos de
solução de problemas. Essas linguagens orientadas a problema são também chamadas linguagens de alto nível,
por serem afastadas do nível de máquina.
As primeiras linguagens foram FORTRAN (1957), usada basicamente para manipulação de fórmulas;
ALGOL (1958), para manipulação de algoritmos; COBOL (1959), para processamento comercial e ainda hoje
bastante usada, especialmente em computadores de grande porte (mainframes) em bancos.
Nas décadas de 60 e 70, podemos citar Pascal, a primeira linguagem de alto nível estruturada; BASIC,
linguagem criada para facilitar a programação por não-profissionais; e ADA, linguagem para processamento em
tempo real criada sob encomenda do DoD (Department of Defense norte-americano) e ainda hoje a única
linguagem aceita para programas escritos sob encomenda do DoD.
Na década de 80, surgiu o C e depois o C++ (com suporte a objetos), que estão entre as linguagens
mais utilizadas hoje.
Cada nova linguagem criada visa atingir níveis de abstração mais altos, isto é, afastam cada vez mais o
programador do nível de máquina. Se por um lado essas novas linguagens facilitam muito o trabalho do
programadores (e reduzem sua necessidade de conhecer o hardware da máquina), elas cobram um alto preço
em termos de desempenho (isto é, são cada vez mais lentas, ao consumir cada vez mais ciclos de máquina e
espaço em memória). Esse aumento de exigência ao poder de processamento dos computadores é
compensado (e desta forma se faz menos notado) pelo aumento acelerado do poder de processamento dos
novos chips (exemplificado pela chamada Lei de Moore, que afirma que o poder de processamento dos chips
dobra a cada 18 meses) e pelos avanços na arquitetura dos computadores.
Dentre as importantes tendências atuais, citamos as linguagens de manipulação de bancos de dados
(como dBase, Clipper, FoxPro, Paradox, Access, etc) e as linguagens visuais, como o Visual Basic, Visual C e
Delphi.
. 5
Linguagem Pascal
1.3 O processo de tradução

Um programa escrito por um programador (chamado código fonte) em uma linguagem de alto nível é
um conjunto de instruções que é clara para programadores, mas não para computadores. Ou seja, os
computadores entendem única e exclusivamente suas linguagens nativas, as linguagens de máquina.
Programas em linguagem de alto nível, a exemplo dos programas escritos em linguagem de Montagem,
também precisam ser traduzidos para linguagem de máquina para poderem ser submetidos ao computador e
processados.
O processo de tradução do programa escrito em uma linguagem simbólica pelo programador, chamado
código fonte (source code) para a linguagem de máquina do computador chamada código objeto (object code), é
chamado compilação e é realizado por um programa chamado Compilador (Compiler).
Vimos que programas de computador não são escritos na linguagem que o computador entende
(linguagem de máquina), mas sim em outras formas simbólicas de representar as instruções que o programador
deseja que sejam realizadas. No entanto, verificamos que as máquinas continuam entendendo somente em
binário e, por isso, sempre há a necessidade da conversão ou tradução de um programa em linguagem
simbólica para outro, equivalente em linguagem numérica binária.
1.3.1 Montagem
É o tipo de tradução mais rápido e simples que existe e é realizada por um programa denominado
montador (assembler). Como o nome já explica, a montagem é realizada para traduzir um programa em
linguagem de montagem para seu equivalente em linguagem binária, executável. Cada ordem do programador é
convertida diretamente em uma única ordem de máquina.
Neste processo o programa escrito em linguagem de montagem, chamado de código fonte, é
examinado, instrução por instrução, e, em seguida, é convertido (traduzido) para um outro programa em
linguagem binária de máquina, denominado código objeto.
Programa
Código Fonte escrito pelo
programad
Montage
m
Programa
Código Objeto resultante,
em
linguagem
. 6
Linguagem Pascal
1.3.2 Compilação
Quando se deseja converter para linguagem de máquina um programa escrito em linguagem de mais
alto nível que o da linguagem de montagem, então o método utilizado se chama compilação. Nas linguagens de
alto nível, todo programa escrito em uma determinada linguagem de programação (chamado de código fonte ou
programa fonte) é convertido em sua versão em linguagem de máquina (código objeto ou programa objeto),
sendo esta tradução feita antes de qualquer tentativa de execução.
No processo de montagem, há uma relação de 1:1, ou seja, cada instrução do código fonte resulta em
uma instrução de máquina, enquanto na compilação a relação é múltipla, cada instrução do código fonte
gerando várias instruções de máquina.
Código Fonte
Open file_entrada Programa
Read A,B,C escrito pelo
While not eof programad
(file_entrada) do or em
linguagem
Programa
compilad Compilaç
or ão
Código Objeto
1011 0011 0000
Programa
0011
resultante,
1010 0000 0000
em
0100
linguagem
1.3.2.1 Bibliotecas
O desenvolvimento de um programa certamente utilizará diversas operações que são comuns a muitos
outros programas. Por exemplo, a execução de uma instrução de entrada e saída, a classificação dos dados de
um arquivo, o cálculo de funções matemáticas, etc. Uma linguagem de alto nível geralmente incorpora diversas
rotinas prontas (que fazem parte da linguagem) e que compõem bibliotecas (librarys) de funções pré-
programadas que poderão ser utilizadas pelo programador, poupando tempo, aumentando a eficiência e
evitando erros. Dessa forma, um programa em alto nível possivelmente conterá diversas chamadas de biblioteca
(library calls).
Essas funções não devem ser confundidas com as instruções da linguagem - na realidade, são
pequenos programas externos que são chamados através de instruções especiais de chamada de biblioteca.
Para serem executadas, essas rotinas precisam ser incorporadas ao código do programador, isto é, a
chamada de biblioteca precisa ser substituída pelo código propriamente dito, incluindo os parâmetros
necessários.
1.3.2.2 Ligação
Assim, o código objeto preparado pelo compilador em geral não é imediatamente executável, pois ainda
existe código (as rotinas de biblioteca) a ser incorporado ao programa. A cada chamada de biblioteca encontrada
no código fonte, o compilador precisará incluir uma chamada para a rotina e o endereço dos dados que devam
ser passados para a rotina.
A tarefa de examinar o código objeto, procurar as referências a rotinas de biblioteca (que constituem
referências externas não resolvidas), buscar a rotina da biblioteca, substituir a chamada pelo código ("resolver as
. 7
Linguagem Pascal
referências externas") e obter os parâmetros para incluí-los no código objeto é executada por um programa
chamado Ligador (LinkEditor). O resultado da execução do Ligador é o código final pronto para ser executado
pelo computador, chamado módulo de carga ou código executável.
Uma biblioteca é uma coleção de códigos objeto, um para cada rotina específica, e é indexada pelo
nome da rotina. Quando um programa de aplicação deseja usar uma dessas rotinas, ele insere uma chamada de
biblioteca no seu código (“library call”).
Programa
Código Fonte
escrito pelo
programad
or em
Programa linguagem
compilad Compilaç
or ão
Programa
Programa
Código Objeto resultante,
resultante,
emem
linguagem
linguagem
Biblioteca A
Ligador
Ligação Biblioteca B
Biblioteca C
Código Executável
O módulo de carga, após testado e depurado (isto é, depois de resolvidos todos os erros, também
chamados "bugs") é armazenado em memória de massa para ser executado quando necessário. O processo de
compilação e ligação é executado apenas pelo programador na fase de desenvolvimento e não mais precisará
ser executado pelo usuário, quando da execução do programa.
1.3.3 Interpretação
Com o processo de execução de um programa em fases distintas (compilação / ligação / execução)
apresentado, um programa para ser executado precisa primeiro ter sido convertido para código objeto pelo
compilador e depois ter passado pelo ligador. Esse processo é o mais largamente utilizado, porém não é o único.
O método alternativo chama-se de interpretação e, a partir do programa fonte, realiza as três fases
(compilação, ligação e execução), comando por comando, em tempo de execução. Não existem fases distintas
nem se produzem códigos intermediários. Todo o processo de conversão é efetuado em tempo de execução e
imediatamente executado. Ou seja, cada comando é lido, verificado, convertido em código executável e
imediatamente executado, antes que o comando seguinte seja sequer lido.
Linguagens como C, Pascal, COBOL, etc, são linguagens tipicamente compiladas, enquanto o BASIC
foi desenvolvido como linguagem interpretada (hoje também existem linguagens BASIC compiladas e o
programador pode optar).
As linguagens de programação tipicamente de usuário, tais como das planilhas Excel, o Word Basic
(linguagem de construção de Macros do Word), o Access, etc, são todas linguagens interpretadas.
1.3.4 Compilação e Interpretação - comparação

Sempre que houver duas opções, haverá vantagens e desvantagens para cada uma delas (pois se
assim não fosse, a que apresentasse sempre desvantagem seria abandonada). Vamos comparar os métodos:
. 8
Linguagem Pascal
1.3.4.1 Tempo de execução

No método de interpretação, cada vez que o programa for executado, haverá compilação, ligação e
execução de cada um dos comandos. No método de Compilação, o tempo de execução do programa é reduzido,
porque todos os passos preliminares (compilação e ligação) foram previamente cumpridos.
1.3.4.2 Consumo de memória

No método de interpretação, o interpretador é um programa geralmente grande e que precisa
permanecer na memória durante todo o tempo que durar a execução do programa, pois um programa necessita
do interpretador para ter traduzidos cada um dos seus comandos, um a um, até o término de sua execução (o
interpretador somente é descarregado depois do término da execução do programa).
No método de compilação, o compilador é carregado e fica na memória apenas durante o tempo de
compilação, depois é descarregado; o ligador é carregado e fica na memória apenas durante o tempo de ligação,
depois é descarregado. Essas são funções realizadas pelo programador e executadas apenas durante o
desenvolvimento do programa. Quando o usuário for executar o programa, apenas o módulo de carga (código
executável) é carregado e fica na memória durante a execução.
Desta forma, vemos que o método de interpretação acarreta um consumo de memória muito mais
elevado durante a execução do programa.
1.3.4.3 Repetição de interpretação

No método de compilação, um programa é compilado e ligado apenas uma vez, e na hora da execução
é carregado apenas o módulo de carga, que é diretamente executável. No método de interpretação, cada
programa terá que ser interpretado toda vez que for ser executado.
Outro aspecto é que, em programas contendo loops, no método de interpretação as partes de código
pertencentes ao loop serão várias vezes repetidas e terão que ser interpretadas tantas vezes quantas o loop
tiver que ser percorrido. No método de compilação, a tradução do código do loop se faz uma única vez, em
tempo de compilação e ligação.
Estas características levam a um maior consumo de tempo no método de interpretação, que é portanto
mais lento.
1.3.4.4 Desenvolvimento de programas e depuração de erros

No método de compilação, a identificação de erros durante a fase de execução fica sempre difícil, pois
não há mais relação entre comandos do código fonte e instruções do executável.
No método de interpretação, cada comando é interpretado e executado individualmente, a relação entre
código fonte e executável é mais direta e o efeito da execução (certa ou errada) é direta e imediatamente
sentido. Quando a execução de um comando acarreta erro, quase sempre o erro pode ser encontrado no
comando que acabou de ser executado. Assim, o interpretador pode informar o erro, indicando o comando ou
variável causador do problema.
Essa característica, que é a rigor a maior vantagem do método de interpretação sob o ponto de vista do
usuário, faz com que esse método seja escolhido sempre que se pretende adotar uma linguagem que vá ser
usada por não-profissionais ou para a programação mais expedita. Por exemplo, o método de interpretação é
usado pela maioria dos Basic (uma linguagem projetada para ser usada por iniciantes), e por todas as
linguagens típicas de usuário como dBase, Access, Excel, etc.
. 9
Linguagem Pascal
1.3.5 Fluxograma Compilação x Interpretação

A figura abaixo ilustra o fluxograma do processo de desenvolvimento e depuração de programas,
utilizando os métodos de compilação e interpretação.
. 10
Linguagem Pascal
Capítulo 2 – Fundamentos de Pascal
2.1 Introdução a linguagem Pascal

“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”.
O Pascal é uma linguagem de programação de alto nível e de fins genéricos, que foi desenvolvida a
partir do Algol-60. As suas instruções são formadas por expressões do tipo algébrico e certas palavras inglesas,
tais como BEGIN, END, read, write, IF, THEN, REPEAT, WHILE, DO. Neste aspecto, o Pascal assemelha-se a
muitas outras linguagens de alto nível. Contudo, o Pascal contém ainda alguns aspectos únicos, que foram
especificamente projetados para estimular o uso da programação estruturada – o método ordenado e
disciplinado de programação que tem como resultado programas claros, eficientes e livres de erros.
Por esta razão, muitos educadores e programadores profissionais preferem utilizar o Pascal em vez de
outras linguagens de fins genéricos.
2.1.1
2.1.1 A história
A linguagem de programação Pascal foi criada para ser uma ferramenta educacional isto no início da
década de 70 pelo Professor Niklaus Wirth do Techinical University em Zurique, Suíça. Foi batizada pelo seu
idealizador de PASCAL, em homenagem à Blaise Pascal, brilhante cientista e matemático francês que entre
outros feitos inventou a primeira calculadora mecânica do mundo.
O pascal ganhou popularidade quando foi adotado pela Universidade da Califórnia, San Diego, em
1973. No msmo período, em seus cursos, também foram feitas implementações para minis e
microcomputadores.
Nas suas primeira implementações, não era muito amigável ao programador, pois eram necessários
vários passos para se obter um programa executável. Primeiro devia se escrever o programa em um editor de
texto, depois compila-lo, “lincá-lo” e montá-lo. Quando era feita uma manutenção no mesmo, todos estes passos
deviam ser refeitos. Isto de certa forma desistimulava os programadores a usar a linguagem Pascal.
Apesar de todas as dificuldades iniciais, de seu propósito educacional e a facilidade de programação, o
Pascal começou a ser utilizado por programadores de outras linguagens, tornando-se para surpresa do próprio
Nicklaus, um produto comercial.
Em 1983, a soft-house americana Borland International, lançou o Turbo Pascal para
microcomputadores, aliado ao lançamento no mercado de microcomputadores.
O Turbo Pacal consegue em um único ambiente, colocar um editor de textos, bastante parecido com o
Wordstar e SideKick, um código fonte ligado a um sistema de detecção de erros, um compilador de 1 passo, o
que o torna bastante veloz, com a desvantagem de que apenas um erro é localizado por vez, e também um
“linkador” que permite a ligação do programa Pascal com objetos, mesmos os gerados por outras linguagens.
Hoje o Pascal é amplamente usado numa grande variedade de aplicações, quer como linguagem de
ensino quer como uma poderosa linguagem de fins genéricos.
2.1.2 Por que Turbo Pascal?

Como já vimos, um compudor 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 (programa fonte) e produzem como saída um programa
em linguagem de máquina (programa 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.
. 11
Linguagem Pascal
Assim, existem linguagens de programação interpretadas e compiladas. O Cobol é compilado, o Basic

pode ser tanto compilado como interpretado e assim por diante. A linguagem Pascal, tradicionalmente é
compilada.
Por outro lado, o processo de compilação, de certa forma pode se tornar 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 estes passos, suponha que você chegue a conclusão de queo programa tenha que sofrer
modificaçõ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.
2.2 Estrutura de um programa em Pascal

Todo programa em Pascal é subdividido em 3 áreas: 1-Cabeçalho do Programa, 2-Área de Declarações
e o 3-Corpo do Programa.
Este é o layout geral de um programa Turbo Pascal:
program ... ; { Cabecalho do programa } 1 -Cabeçalho do Programa
uses ... ; { cláusula Uses}

label ... ; { declaração de Labels }
const ... ; { declaração de Constantes }
2-Área de Declarações
type ... ; { declaração de Tipos }
var ... ; { declaração de Variáveis}
procedure ... ; { declaração de Procedures }
function ... ; { declaração de Funções}
begin
statement; { Instruções }
... 3-Corpo do Programa
end.
2.2.1 Cabeçalho do programa

Esta área é utilizada para se fazer a identificação do programa com um nome, sendo que este deve
seguir as mesmas regras de formação utilizadas para nomear as variáveis.
Sintaxe:
Program <identificador>;
. 12
Linguagem Pascal
Exemplo:
PROGRAM circulo; (*O Cabeçalho do programa*)

...
Observações:
• A primeira linha contém o nome do programa (círculo). Este é o cabeçalho do programa.

• Esta parte do programa tem só uma linha e não é obrigatória.
• Não poderá existir nenhuma variável no programa com o mesmo nome do cabeçalho do programa.
2.2.2 Área de declarações

Esta área é utilizada para definir o uso de qualquer tipo de identificador que não seja os predefinidos,
estando esta subdvidida em sete subáreas, a saber:
Uses, label, const, type, var, procedure e function.
Exemplo:
PROGRAM circulo;
(*Início da Área de Declarações*)
Uses WinCrt;
Var area, raio : Real;
(*Fim da Área de Declarações*)
Begin
Read(raio);
Area := 3.14159*Sqr(raio);
Write(raio,area);
End.
Observações:
• Deve ser salientado que os componentes da secão Área de declarações não tem a obrigatoriedade
de existir, todos, em cada programa em Pascal. Só são obrigatórias caso nós estejamos
precisando.
• As declarações de label, constantes, variáveis, procedures e de funções podem ser listadas em
qualquer ordem e repetidos um número de vezes qualquer.
2.2.3 O corpo do programa

O Corpo do programa contém as instruções que fazem com que se efetuem as ações do programa
propriamente dito. Esta área tem início com a instrução begin e é finalizada pela instrução end seguida do
símbolo (.) ponto final .
Sintaxe:
...
begin
<intrução1>;
<intrução2>;
. 13
Linguagem Pascal
...
<intruçãoN>;
end.
Um programa exemplo:
Eis um programa em Pascal elementar chamado círculo, que uma vez fornecido o raio de um círculo
calcula a sua área, e escreve em seguida o raio e área calculada.
PROGRAM circulo;
Uses WinCrt;
(*Início do Corpo do Programa*)
Begin
Read(raio);
Write(raio,area);
End.
(*Fim do Corpo do Programa*)
Observações:
• As três linhas que estão em evidência entre Begin e End são as instruções do programa. Elas
fazem com que o valor do raio seja introduzido no computador, o valor da área seja calculado e os
valores do raio e da área seja escritos para o exterior.
• Finalmente, note-se a pontuação no fim de cada linha. A maioria das linhas acaba por ponto e
vírgula; algumas não têm pontuação e a última linha acaba com um ponto final. Isto faz parte da
sintaxe do Pascal.
2.3 O conjunto de caracteres do Pascal

Os caracteres que podem ser utilizados no Turbo Pascal são divididos em: letras, números e os
caracteres especiais.
Letras:
de ‘A’ até ‘Z’ e de ‘a’ até ‘z’.
Números:
os dígitos de 0 a 9.
Caracteres especiais:
+ - * / = < >
[ ] , ( ) : ;
^ . @ { } $ #
Alguns caracteres especiais são construídos por dois caracteres distintos e consecutivos:
<= >= := ..
(* *) (. .)
. 14
Linguagem Pascal
Observações:
• Turbo pascal não faz distinção entre letras maiúsculas e minúsculas.
2.4 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. As palavras reservadas do Pascal são:
and asm array begin case

const constructor destructor div do
dowton else end exports file
for function goto if implementation
in Inline interface label library
mod nil not object of
or packed procedure program record
repeat set shl shr string
then to type unit until
uses var while with xor
2.5 Identificadores
Um identificador é um nome que é dado a um elemento do programa, tal como uma constante, campos
de registro, tipo, variável, units, procedimento, programa, etc.. Os identificadores são compostos de letras ou
dígitos, em qualquer ordem, desde que o primeiro caracter seja uma letra. É permitido usar maiúsculas ou
minúsculas, que são consideradas da mesma forma.
Regras para formação de identificadores:
1. Um identificador pode ter qualquer tamanho, entretanto, apenas os primeiros 63 caracteres são
significativos.
2. O primeiro caracter do identificador deve ser obrigatoriamente uma letra ou um traço de sublinhar (
_ ), também chamado de undescore.
3. Os demais caracteres podem ser letras, dígitos ou undescores e não espaços.
4. Um identificador não pode ser palavra reservada.
5. Como regra, um identificador deve conter caracteres suficientes para indicar claramente o seu
significado. Também como regra, deverá ser evitado o número excessivo de caracteres.
6. Não se pode utilizar os caracteres especiais do Turbo Pascal na formação de identificadores.
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 Funções, que podem ser utilizados
normalmente na construção de programas. Exemplos: ClrScr (limpa a tela de vídeo) e DelLine (deleta a linha em
que está o cursor).
Exemplos de identificadores válidos: Exemplos de identificadores inválidos:

Meu_Nome Valor=Valor_Anterior
MEU_NOME 2teste
_Variavel01 Exemplo 23
Exemplo01
. 15
Linguagem Pascal
Exemplo:
PROGRAM circulo; (*CABEÇALHO DO PROGRAMA*)

{
Este programa tem como objetivo o cálculo da área de um círculo
a partir da entrada do valor do raio deste círculo
}
Uses WinCrt;
begin
Read(raio);
Write(raio,area);
end.
2.6 Comentários
Comentários são textos que introduzimos no meio do programa fonte com a intenção de torná-lo mais
claro. É uma boa prática em programação inserir comentários no meio dos nossos programs. No Turbo Pascal,
tudo que estiver entre os símbolos (* e *) ou { e } será considerado como comentário. Os comentários são
ignorados pelo compilador.
Exemplo:
PROGRAM circulo; (*CABEÇALHO DO PROGRAMA*)

{
Este programa tem como objetivo o cálculo da área de um círculo
a partir da entrada do valor do raio deste círculo
}
Uses WinCrt;
begin
Read(raio);
Write(raio,area);
end.
2.7 Instruções no Pascal

Uma Instrução no Pascal é uma ordem, ou um conjunto de ordens, que obriga o computador a executar
certas ações. Existem dois tipos básicos de instruções em Pascal: simples e compostas.
As instruções simples são essencialmente instruções únicas e incondicionais que executam uma ou
mais tarefas, como por exemplo a declaração de uma variável, a atribuição de um valor a uma variável ou uma
chamada a uma função ou procedimento do Pascal.
Exemplos:
a) taxa := 0.14*bruto;
b) clrscr;
A linguagem Pascal reconhece inúmeros tipos de instruções compostas, também chamadas de

instruções estruturadas. As instruções compostas incluem:
. 16
Linguagem Pascal
a) instruções compostas, que consistem numa seqüência de duas ou mais instruções consecutivas.
Neste caso as instruções simples que formam o bloco de instruções compostas devem estar entre
as palavras reservadas begin e end.
b) Instruções repetitivas, que envolvem a execução de forma repetida de várias instruções simples.
c) Instruções condicionais, em que uma ou mais instruções simples são executadas apenas se uma
expressão lógica especificada for atendida.
Observações:
• O ponto e vírgula da última instrução do bloco de instruções compostas típica é opcional.

• O conjunto de instruções consecutivas delimitadas entre as palavras reservadas begin e end
podem ser tratadas como uma única instrução simples.
Exemplo 1:
Abaixo você pode ver um exemplo de instrução composta típica.
begin
X:= 1.5;
Y:= 2.5;
end;
Exemplo 2:
Abaixo você pode ver um exemplo de instrução composta repetitiva.
For i := to 100 Do writeln(i);
Esta instrução será executa 100 vezes. Cada vez que a instrução for executada o valor atual da variável
i será visualizado na tela. Assim a instrução fará com que os valores 1, 2, 3, e respectivamente até o valor 100
sejam apresentados no monitor.
Exemplo 3:
Abaixo você pode ver um exemplo de instrução composta condicional.
If (salario < 2000.0) Then

writeln(‘Salário Baixo!’)
Else
writeln(‘Salário Bom!’);
Esta instrução faz com que a mensagem ‘Salário Baixo!’ seja mostrada caso a variável salário seja
menor do que 2000.0. Se a variável salário tiver um valor armazenado maior ou igual a 2000.0 então a
mensagem mostrada será ‘Salário Bom!’.
. 17
Linguagem Pascal
Exemplo 4:
Program exemplo;
...
begin
writeln('Digite o valor de A: '); instrução simples
read (A);
writeln('Digite o valor de B: ');
read (B);
if A = B
then begin
X:= 1.5;
Y:= 2.5
end
else begin
X:= -1.5; Bloco de instruções compostas
Y:= -2.5
end;
writeln ('O valor de X é :', X:4:1);
writeln ('O valor de Y é :', Y:4:1);
end.
Capítulo 3 – Tipos de dados e instruções primitivas
3.1 Tipos de dados predefinidos

Uma das mais interessantes características do Pascal é a sua capacidade de tratar muitos tipos
diferentes de dados. Estes incluem dados de tipo simples e dados de tipo estrututado.
Dados de tipo simples (padrão)
• Char (caracteres)
• Boolean (booleanos)
• Integer (inteiros)
• Real (reais)
Dados de tipo estruturado (padrão)
• String (cadeia de caracteres)

• Array (matriz)
• Record (registro)
• File (arquivos)
• Set (conjuntos)
• Text (texto)
Os dados de tipo simples são elementos individuais (números, caracteres, etc.) que estão associados
com identificadores simples um a um.
Os dados de tipo estruturado compõe-se de múltiplos elementos relacionados entre si de forma
especificada. Cada grupo de elementos de informação está associado a um único identificador. Os elementos de
informação individuais, dentro de cada grupo, podem também estar associados com os correspondentes
identificadores individuais.
Inicialmente iremos estudar os dados de tipo simples e o tipo String pela sua utilização prática incial. Os
demais tipos estruturados serão vistos mais para a frente.
. 18
Linguagem Pascal
3.2 Formando números no Pascal

Os números podem ser escritos em Pascal de várias formas diferentes. Em particular um número pode
incluir um sinal, um ponto decimal e um expoente caso se deseje. As regras seguintes aplicam-se a todos os
números:
1. Vírgulas e espaços não se podem incluir dentro de um número.

2. O número pode ser precedido por um sinal positivo (+) ou negativo (-), caso se deseje. Se não
existir sinal o número é considerado positivo.
3. Os números não podem exceder seus valores máximos e mínimos especificados. Estes valores
dependem do tipo de número, do computador e do compilador (versão) específico que você esteja
utilizando.
3.3 Números inteiros

Um número inteiro não contém um ponto decimal nem um expoente. Um número inteiro é simplesmente
uma seqüência de dígitos, precedida (opcionalmente) por um sinal.
Números inteiros permitidos: Números inteiros não permitidos:

25 123,456
0 36.50
1 -10 20 34
+1
-315
O Turbo Pascal fornece cinco tipos pré-definidos de números inteiros. Veja a tabela abaixo.
Tipo Faixa Formato

Shortint -128..127 Sinalizado 8-bit
Integer -32768..32767 Sinalizado 16-bit
Longint -2147483648..2147483647 Sinalizado 32-bit
Byte 0..255 Não Sinalizado 8-bit
Word 0..65535 Não Sinalizado 16-bit
3.4 Números reais

Um número real deve conter um ponto decimal ou um expoente (ou ambos). Se existir um ponto
decimal, este deve aparecer entre dois dígitos. Um número real não pode então começar ou acabar com um
ponto decimal.
Números reais permitidos: Números reais não permitidos:

0.0 1.
1.0 1,000.0
-0.2 .3333
827.602
3.0E+10 (3.0x1010)
5.026E-17 (5.026x10-17)
. 19
Linguagem Pascal
O Turbo Pascal fornece cinco tipos pré-definidos de números reais. Veja a tabela abaixo.
Tipo Faixa Dígitos Bytes

Real 2.9e-39..1.7e38 11-12 6
Single 1.5e-45..3.4e38 7-8 4
Double 5.0e-324..1.7e308 15-16 8
Extended 3.4e4932..1.1e4932 19-20 10
Comp -9.2e18..9.2e18 19-20 8
Observação:
• Uma variável do tipo real pode armazenar um valor inteiro, mas não o contrário.
3.5 Tipos de dados caracteres

São caracterizados tipo caracteres as seqüências contendo os caracteres de ‘A’ a ‘Z’ (maíusculo e
minúsculo), os dígitos de 0 a 9, o espaço em branco e os caracteres especiais. Uma strings de caracteres são
um conjunto de caracteres entre aspas (apóstrofos) simples. No Pascal este tipo de dado é referenciado pelo
identificador string, podendo armazenar de 1 até 255 caracteres.
Existe ainda o tipo char, utilizado da mesma forma que o tipo string, porém com uma pequena
diferença: é utilizado para strings com apenas um caracter de tamanho.
Cadeias de caracteres permitidas:
‘Exemplo de cadeia de caracteres’

‘R$19,95’
‘’
‘Please don’’t go!’
‘217 - 32 – Abc’
Observações:
• Se uma cadeia de caracteres incluir uma aspas, esta (a aspas) deve ser escrita duas vezes. Neste
caso só aparecerá uma das aspas quando a cadeia for impressa ou visualizada.
• Uma string de caracteres de tamanho 0 (zero) é chamado de string nula e só é compatível com o
tipo string.
• Uma string de caracteres de tamanho 1 (um) é compatível com o tipo char e também o tipo string.
3.6 Dados booleanos (ou lógicos)

São caracterizados tipos booleanos (lógicos) os dados que podem assumir os valores true (verdadeiro)
e false (falso), sendo que este tipo de dado somente poderá representar um dos dois valores. Esta categoria
inclui as constantes do tipo booleano, as variáveis, funções e expressões.
As expressões do tipo booleano são formadas combinando operandos do mesmo tipo com operadores
relacionais.
Dados booleanos:
true (1)
false (0)
. 20
Linguagem Pascal
3.7 Operadores aritméticos

Operador Operação Tipos de Operandos Tipo de Resultado
+ Adição Inteiro (integer) Inteiro (integer)
Real (real) Real (real)
- Subtração Inteiro (integer) Inteiro (integer)
* Multiplicação Inteiro (integer) Inteiro (integer)
/ Divisão Inteiro (integer) Real (real)
div Divisão de inteiros Inteiro (integer) Inteiro (integer)
mod Resto de divisão Inteiro (integer) Inteiro (integer)
As expressões aritméticas são escritas linearmente, usando-se a notação matemática.
Você pode observar que toda expressão aritmética, ao ser avaliada produz um valor que se constitui no
resultado da expressão. Esse valor possui um tipo, que pode ser inteiro ou real, conforme a natureza dos
operados e operandos envolvidos.
Exemplos de expressões aritméticas em Pascal:
a) X+Y b) Total/N c) X-Y d) SqRt(P)

e) 11 div 4 f) Soma*Soma g) 2*Nota h) 11 mod 4
i) Sqrt(F1+G*G)-H
Observações:
• No pascal não existe sinal para potenciação e radiciação, devendo-se indicá-las com combinações
de produtos ou funções predefinidas.
• div e mod são operadores que só podem ser aplicados com operandos inteiros dando,
respectivamente, o quociente inteiro e o resto inteiro da divisão entre operandos.
• Uma expressão que só tenha operandos inteiros e operadores *, mod, div, + e – terá como
resultado um valor inteiro. Se, pelo menos, um dos operandos for real e se os operadores forem
*,/,+ ou -, o resultado da expressão será real.
• O operador / sempre conduz a um resultado do tipo real, mesmo que os dois operandos sejam
inteiros.
Programa exemplo:
Program Operadores_aritmeticos;
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.
. 21
Linguagem Pascal
Este programa resultaria na seguinte tela:
---------------------------------------------------------
30
6
2
1.4086956522E+00
---------------------------------------------------------
3.7.1 Prioridades nas expressões aritméticas

A expressão 5 mod 2 + 5 div 2 demonstra uma possível fonte de confusão: se houver vários
operadores, qual operação será executada primeiro? Para evitar isso, e da mesma forma que na matemática,
podemos usar parênteses ou a precedência dos operadores, que indicam a seqüência em que devem ser
efetuadas as operações:
Prioridade Operadores
1a. - (unário)
2a. * / div mod
3a. +-
A ordem de precedência acima indica que primeiro são aplicados os - unários, depois as potenciações,
em seguida são efetuadas todas as operações de multiplicação, divisão, resto de divisão inteiro, e só após estas
são efetuadas as adições e subtrações.
Exemplo:
...
begin
writeln(51 div 16 + 48 – 8 mod 5); {resultado: 3+48-3=48}
writeln( (51 div 16) + (48 – 8) mod 5); {resultado: 3+0=3}
writeln( -3*(43/(52 div 3) )); {resultado: -3*(43/17) = -7.588}
writeln( 6/3*2 ); {resultado: 4 (real)}
...
Observações:
1) Um operando entre dois operadores de diferentes prioridade é relacionado ao operador de maior

prioridade.
2) Um operando entre dois operadores de igual prioridade é relacionado ao primeiro operador à sua
esquerda.
3) Operações com operadores de igual prioridade são normalmente executadas (avaliadas) da
esquerda para a direita.
4) Se a expressão tem parênteses , estes têm precedência superior a todos os operadores, isto é,
qualquer expressão entre parênteses é executada primeiro. Dica: use parênteses sempre que
puder!.
3.8 Operadores relacionais

O Turbo Pascal possui ao todo 7 operadores relacionais que são muito utilizados nas tomadas de
decisões. Uma expressão relacional é uma comparação realizada entre valores do mesmo tipo. Estes valores
são representados na relação por constantes, variáveis ou expressões do tipo correspondente. São eles:
. 22
Linguagem Pascal
Operadores Operação Tipo de resultado

= Igual Booleano
<> Diferente Booleano
> Maior Booleano
< Menor Booleano
>= Maior ou igual que Booleano
<= Menor ou igual que Booleano
in Contido em (conjunto) Booleano
Observação:
• Toda expressão relacional retornará um resultado do tipo booleano: verdadeiro (true) ou falso
(false).
Exemplos:
program exemplo;
uses WinCrt;
var x, y:integer;
begin
x:= 3;
y:= 5;
Writeln(2 = 3);
Writeln(0.6 <= 1.5);
Writeln(-4 <> 4);
Writeln(x <= 10);
Writeln(x+y > 10);
Writeln(2*1 >= x div 2);
Writeln( (x div 2) > (y+6) );
end.
---------------------------------------------------------
FALSE
TRUE
TRUE
TRUE
FALSE
TRUE
FALSE
---------------------------------------------------------
3.9 Operadores
Operadores lógicos
No Pascal, assim com em qualquer outra linguagem, existiram ocasiões em que se fará necessário
trabalhar com o relacionamento de duas ou mais condições ao mesmo tempo em uma instrução, efetuando
desta forma testes múltiplos. Para esses casos é necessário então trabalhar com a utilização dos operadores
lógicos, também conhecidos por operadores boleanos. São três os operadores lógicos: and, or e not. Veja a
tabela abaixo.
Operadores Operação Operadores Tipo de resultado

AND E lógico Booleano Booleano
OR OU lógico Booleano Booleano
NOT NÃO lógico (unário) Booleano Booleano
. 23
Linguagem Pascal
3.9.1 Operador lógico AND

O operador and faz com que uma determinada operação seja executada, se e somente se as
expressões avaliadas resultarem simultaneamente um valoro lógico verdadeiro. Veja a tabela verdade para este
operador:
Expressão 1 Expressão 2 Resultado

Falso Falso Falso
Verdadeiro Falso Falso
Falso Verdadeiro Falso
Verdadeiro Verdadeiro Verdadeiro
Sejam as variáveis lógicas P, Q, R, S contendo, respectivamente, os valores true, false, false e true.
Exemplo:
O valor lógico das expressões:
a) P and S c) Q and S
b) P and R d) Q and R
será:
a) true c) false
b) false d) false
3.9.2 Operador lógico OR

O operador or faz com que uma determinada operação seja executada, se pelo menos uma das
expressões avaliadas resultarem um valor lógico verdadeiro. Veja a tabela verdade para este operador:
Expressão 1 Expressão 2 Resultado

Falso Falso Falso
Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Verdadeiro Verdadeiro Verdadeiro
Exemplo:

a) P or S c) Q or S
b) P or R d) Q or R
será:
a) true c) true
b) true d) false
3.9.3 Operador lógico NOT

O operador not faz com que uma determinada operação seja executada, invertendo o resultado lógico
da expressão avaliada. Veja a tabela verdade para este operador:
. 24
Linguagem Pascal
Expressão 1 Resultado
Verdadeiro Falso
Falso Verdadeiro
Exemplo:
a) not P b) not R
será:
a) false b) true
Observações:
• Estes operadores só aceitam como operandos, valores lógicos, ou seja : TRUE e FALSE.
• Com o operador AND a expressão resulta verdadeiro (TRUE) unicamente se ambos os operandos
forem verdadeiros (TRUE).
• Com o operador OR a expressão resulta verdadeiro (TRUE) se qualquer um dos operandos for
verdadeiro, ou se ambos forem verdadeiros.
• O operador NOT é utilizado para negar (isto é, para inverter) o valor de um operando booleano.
Veja abaixo um pequeno programa que utiliza operador lógico AND:
Program testa_logica_and;
Uses WinCrt;
var
numero := integer;
begin
write(‘Digite um número inteiro: ‘);
readln (numero);
if (numero >=20) and (numero <=90) then
writeln (‘O número está na faixa de 20 a 90!’)
else
writeln(‘O número está fora da faixa de 20 a 90!’);
end.

---------------------------------------------------------
Digite um número inteiro: 99
O número está fora da faixa de 20 a 90!
---------------------------------------------------------
3.9.4 Prioridades entre operadores aritméticos, lógicos e

relacionais
Como já vimos anteriormente, pode-se ter mais de um operador lógico na mesma expressão, além dos
operadores relacionais e dos operadores aritméticos. Em Pascal, a prioridade das operações está dada no
quadro abaixo.
. 25
Linguagem Pascal
Prioridade Operadores
1a. not
2a. *, /, div, mod, and
3a. +, -, or
4a. =, <>, <, <=, >=, >, in
Exemplo1:
program Exemplo;
uses WinCrt;
var A, B, C, K: integer;
begin
A:= 2;
B:= 3;
C:= 10;
K:= 1;
writeln ((A=1) and ((B+C<>0) or (K<=2)));
end.

---------------------------------------------------------
FALSE
---------------------------------------------------------
Exemplo2:
...
not ((Total >=2) and (A<>B)) or Teste
...
3.10 Concatenação
O Turbo Pascal permite que você use o operador + para concatenar dois operandos do tipo string. O
resultado da concatenação é compatível com o tipo string.
Operador Operação Tipos de operandos Tipo do resultado

+ Concatenação String ou Char String
Observação:
Se o resultado da concatenação for maior do que 255 caracteres, a strig resultante será truncada após
o caracter 255.
Exemplo:
program exemplo;
Uses WinCrt;
var caracter1, caracter2 :char;

string1, string2, string3 :string;
begin
. 26
Linguagem Pascal
caracter1:=
'A';
caracter2:=
'é';
string1 :='linguagem Pascal';
string2 :='legal';
string3 :=caracter1+' '+string1+' '+caracter2+'
'+string2+'!';
write (string3);
end.

---------------------------------------------------------
A linguagem Pascal é legal!
---------------------------------------------------------
Capítulo 4 – Declarações no Pascal
4.1 Declaração de variáveis

Variável pode ser definido, no sentido de programação, como uma região de memória de um
computador, previamente identificada e que tem por finalidade armazenar as informações (dados) de um
programa temporariamente. Uma variável armazena apenas um valor por vez.
Uma variável é um identificador cujo valor pode variar durante a execução do programa. Todas as
variáveis dever ser individualmente declaradas (isto é, definidas) antes de poderem aparecer numa instrução do
programa.
4.1.1 A declaração Var

Esta é a sub-área onde devemos declarar todas as variáveis que iremos utilizar em nosso programa.
A sua sintaxe geral é:
Var <lista-de-identificadores> : <tipo>;

...
<lista-de-identificadores> : <tipo>;
onde:
• Var – é uma palavra-chave (palavra reservada) que inicia uma parte do programa para a definição
de variáveis;
• lista-de-identificadores – são os identificadores que representam os nomes individuais das
variáveis. Existindo mais de um identificador na declaração, estes terão de ser separados por
vírgula.
• tipo – é o tipo das variáveis, ou seja, define o conjunto ordenado de valores que podem ser
atribuídos a estas variáveis.
Exemplo:
Program Exemplo;
Uses WinCrt;
Var idade, numero_de_filhos : byte;

altura : real;
sexo : char;
nome : string [30];
. 27
Linguagem Pascal
sim_ou_não : boolean;
quantidade : integer;
Begin
idade:= 34;
numero_de_filhos:=2;
sexo := ‘M’;
nome := ‘José’;
sim_ou_nao :=TRUE;
quantidade := 3245;
End.
4.1.2 Atribuindo valores as variáveis

Uma instrução de atribuição é uma instrução simples que é usada para atribuir um valor de uma
expressão a uma variável. Esta instrução é escrita na forma:
Variável := expressão;
onde:
• variável – é qualquer identificador previamente declarado na sub-seção Var da Área de

declarações.
• Expressão –pode ser um elemento único por exemplo, uma constante, outra variável, uma
referência de função ou pode ser uma expressão (aritmética ou lógica por exemplo).
Observação:
• O resultado da expressão deve ter o mesmo tipo da variável. Existe uma exceção a esta regra: um
valor inteiro pode ser atribuído a uma variável do tipo real.
Exemplo1:
X := Y + Z;
conta := conta+1;
area := 3.14159*sqr(raio);
Exemplo2:
X := (I >= 1) and (I < 100);
Suponha que X é uma variável booleana, e I seja uma variável inteira. Então a instrução faz com que à
X seja atribuído o valor verdadeiro (TRUE) ou falso (FALSE), conforme determinado pela expressão
booleana.
4.1.3 Incrementando uma variável - A procedure Inc

Esta procedure incrementa uma variável do tipo ordinal. Esta é uma procedure da unit System.
Sintaxe:
Inc(identificador, incremento);
Onde:
identificador – é o nome da variável. Um identificador válido do pascal.
incremento – é um número inteiro que define em quanto a variável será incrementada. Caso
este valor seja omitido assume-se que o incremento será de 1 em 1.
. 28
Linguagem Pascal
Exemplo:
Var numero: integer;

...
{Incrementa variável numero em 1. É o mesmo que numero := numero+1; }
Inc(numero);
{Incrementa variável numero em 3. É o mesmo que numero := numero+3; }

Inc(numero,3);
...
Observações:
• O valor de incremento poderá ser precedido pelo sinal de menos (-). Desta forma a procedure irá
decrementar o valor da variável.
• O incremento é um valor do tipo longint e conseqüêntemente não poderá ultrapassar a faixa deste
tipo.
4.2 Declaração de constantes

Tem-se como definição de constante tudo aquilo que é fixo ou estável. Quando estivermos
programando em Pascal, existirão vários momentos em que este conceito deverá ser aplicado.
Identificadores podem ser usados, dentro de um bloco, como sinônimos de constantes, desde que
tenham sido previamente definidos como tal. Na sub-área Const, podemos definir quantas constantes forem
necessárias.
4.2.1 A declaração const

const
<identificador> = <expressão>;
...
<identificador> = <expressão>;
Onde:
• const – é uma palavra reservada que inicia uma parte do programa para a definição de constantes;
• identificador – é qualquer identificador permitido pela linguagem Pascal;
• expressão – é um número (com ou sem sinal), valor lógico, literal ou identificador de constante já
definido.
Exemplo:
...
const Pi = 3.1416;
cor_preferida = ‘verde’;
numero_maximo = 24345;
...
Observações:
• Toda vez que nos referirmos às constantes dentro do programa, o Turbo Pascal substituirá-las
pelos seus respectivos valores declarados.
• Após declaradas as constantes, estas não podem receber atribuições posteriormente.
. 29
Linguagem Pascal
4.2.2 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. Diferente da constante não tipada a declaração
de uma constante tipada especifica o tipo e o valor desta constante.
Sintaxe:
...
const
<identificador> : <tipo> = <valor>;
...
<identificador> : <tipo> = <valor>;
Onde:
• Const – é uma palavra reservada que inicia uma parte do programa para a definição de
constantes;
• identificador – é qualquer identificador permitido pela linguagem Pascal;
• tipo – é o tipo das variáveis, ou seja, define o conjunto ordenado de valores que podem ser
atribuídos a estas variáveis.
• valor – pode ser um número (com ou sem sinal), valor lógico, literal, uma expressão ou
identificador de constante já definido.
Observações:
• Constantes tipadas podem ser usadas exatamente como variáveis do mesmo tipo, podendo
inclusive receber atribuições posteriormente.
Exemplo:
...
const
Minimo: Integer = 0;
Maximo: Integer = 9999;
Contador: Integer = 100;
C : char = ‘A’;
...
4.3 Constantes predefinidas

O Turbo Pascal for Windows inclui ainda dois idenficadores predefinidos padrão que representam
constantes. São eles: maxint, maxlongint.
- maxint – a constante maxint especifica o maior valor que pode ser atribuído a uma quantidade do tipo
inteiro (integer). Este valor é 32.767.
- maxlongint – a constante maxlongint especifica o maior valor que pode ser atribuído a uma
quantidade do tipo inteiro longo (longint) . Este valor é 2.147.483.647.
. 30
Linguagem Pascal
4.3 A declaração de tipos

Além dos tipos de dados predefinidos no Turbo Pascal , podemos também definir novos tipos através
da declaração Type. Um novo tipo é criado através de um definição de tipo que determina um conjunto de
valores e associa um identificador a este conjunto.
Uma vez definido o tipo passa a ser referenciado pelo seu identificador. É como se a cada nova
definição fosse acrescentando um novo tipo ao conjunto que, inicialmente, constitui-se dos tipos predefinidos.
4.3.1 Dados do tipo enumerado

Um dado do tipo enumerado consite numa sequência ordenada de identificadores, em que cada um
destes é interpretado como um elemento individual. Estes elementos estão coletivamente associados a um
nome particular que serve para identificar o tipo de informação.
A associação entre o nome do tipo de informação e os seus elementos individuais é estabelecida pelas
definições de tipo (type).
Type identificador= (elemento1,elemento2,...,elementoN);

...
identificador= (elemento1,elemento2,...,elementoN);
Onde:
• Type – é uma palavra reservada que inicia uma parte do programa contendo definições de tipo;
• identificador – é qualquer identificador permitido pela linguagem, que passará a identificar o novo
tipo. O identificador segue as regras dadas anteriormente; é o nome do novo tipo.
• elementoN– é um identificador que passará a representar um elemento do conjunto.
Exemplo:
...
Type cor = (azul,vermelho,branco,verde,amarelo);
dia_util = (segunda,terça,quarta,quinta,sexta);
sexo = (masculino,feminino);
...
Observações:
• Note que os elementos do novo tipo devem ser separados por vírgulas.
• Deve ser entendido que estes elementos são os únicos valores que podem estar associados com o
tipo definido.
• Uma vez que os dados do tipo enumerado estão definidos numa sequüência ordenada, os
operadores relacionais podem ser aplicados de modo a formar uma expressão booleana. As
funções preexistentes Succ(X), Pred(X) e Ord(X) também podem ser utilizadas.
• Considerando os conceitos introduzidos até aqui, a definição do tipo boolean seria, então: Type
boolean = (false, true);
Exemplo:
Vamos considerar a definição do tipo:
Type dias = (domingo, segunda, terça, quarta, quinta, sexta, sabado);
• domingo < terça - retorna true.
. 31
Linguagem Pascal
• quinta >= sábado - retorna false.

• segunda <> sexta – retorna true.
• Succ(segunda) = terça – retorna true.
• Ord(quinta) = 4 – o número inteiro 4 indica a ordem do valor quinta no conjunto (a enumeração
começa de zero, contando da esquerda para a direita).
Program exemplo;
uses WinCrt;
type
Cores = (VERMELHO,AZUL,VERDE);
begin
Writeln(‘O AZUL tem um número ordinal = ’,Ord(BLUE));
Writeln('C em código ASCII é ',Ord('c'), ' decimal');
end.
4.3.2 Dados do tipo gama de valores

Uma gama de valores refere-se a uma parte do intervalo original de um tipo de dados simples e
ordenados. O tipo original de dados é referido como o tipo suporte. Cada elemento que esteja dentro da gama
de valores é considerado também como pertencendo ao tipo suporte.
O conceito gama de valores pode ser aplicado a qualquer conjunto de dados ordenados e simples.
Sintaxe:
Type identificador= primeiro elemento..último elemento;

...
identificador= primeiro elemento..último elemento;
Onde:
• Type – é uma palavra reservada que inicia uma parte do programa contendo definições de tipo;
• identificador – é qualquer identificador permitido pela linguagem, que passará a identificar o novo
tipo. O identificador segue as regras dadas anteriormente; é o nome do novo tipo.
• primeiro elemento – é o primeiro dos elementos ordenados dentro da gama de valores;
• último elemento – é o último dos elementos ordenados, dentro da gama de valores;
Exemplo:
...
Type dias = (domingo,segunda,terça,quarta,quinta,sexta,sabado);
Dias_da_semana = segunda..sexta;
mês = 1..31;
maiuscula = ‘A’..’Z’;
...
Observações:
• Os dados do tipo inteiro, caracter e booleanos podem ser usados para definir uma gama de
valores.
• Os dados do tipo real não podem ser usados para definir uma gama de valores.
• Note que dois pontos consecutivos devem separar o primeiro e o último elementos da gama de
valores.
. 32
Linguagem Pascal
Capítulo 5 - Entrada e saída de dados
5.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 na mesma
linha em que foi escrito, enquanto que writeln passa o cursor para a próxima linha.
Write (<lista-de-identificadores e/ou constantes e/ou expressões>)

Writeln (<lista-de-identificadores e/ou constantes e/ou expressões>)
onde:
• write e writeln – são identificadores com significado predefinido em PASCAL.

• lista de identificadores – são os nomes de variáveis do tipo string, char, integer, real ou boolean,
cujos valores serão enviados à unidade de saída.
• constantes e/ou expressões de mesmo tipo das variáveis também podem aparecer nos
comandos de saída.
Observação:
• A instrução Write e Writeln aceita múltiplos parâmetros. Estes parâmetros devem ser separados
por vírgula.
Exemplo:
Program Exemplo;
Uses CRT;
Var i : integer;
r : real;
c : char;
s : string[20];
Begin
ClrScr;
Writeln('Exemplos de aplicacao de writeln e write');
writeln;
i:=100;
r:=3.14;
c:='Muito';
s:='interessante!';
writeln('Valor de i e igual a ',i);
write('valor de r = ');
writeln(r);
writeln(c,'',s);
end.
---------------------------------------------------------
Exemplos de aplicacao de writeln e write
Valor de i e igual a 100

valor de r = 3.1400000000E+00
Muito interessante!
---------------------------------------------------------
. 33
Linguagem Pascal
5.2 Saídas formatadas

A informação de saída pode normalmente ser tornada mais legível alterando as dimensões de campos
associados com os dados numéricos e booleanos. Isto pode ser conseguido facilmente adicionando algumas
especificações de formatação nas instruções write ou writeln.

write(p1,...,pn);
writeLn(p1,...,pn);
onde:
• p1 é um parâmetro com uma das formas:
e
e:e1
e:e1:e2 ,
sendo e, e1, e2 expressões.
• e – representa o valor a ser escrito e pode ser do tipo integer, real, char, string e boolean, podendo
inclusive ser uma constante ou uma expressão.
• e1 – representa um valor inteiro positivo e indica o número mínimo de caracteres a ser escrito. Se
e1 for insuficiente para representar o valor a ser escrito, então será alocado mais espaço. Se e1 for
excessivo, o espaço excedente será preenchido com brancos.
• e2 – só se aplica se e for do tipo real; neste caso, e2 é um valor inteiro positivo e especifica o
número de dígitos que devem ser escritos após o ponto decimal. Caso e2 não seja fornecido o
valor real será escrito no formato exponencial.
Exemplo:
program Exemplo;
uses WinCrt;
var A, B: real;
K, L: char;
begin
A:= 3.2;
B:= 5.81;
K:= 'x';
L:= 'y';
writeln (A:4:2);
writeln (K:2);
writeln (B:5:2);
writeln (A+B:6:3);
writeln (A:4:2, K:2, ' +', B:5:2, L:2,' =', A+B:6:3);
end.
---------------------------------------------------------
3.20
x
5.81
9.010
3.20 x + 5.81 y = 9.010
---------------------------------------------------------
. 34
Linguagem Pascal
5.3 Read e Readln

O comando read é usado para ler dados via teclado e atribuí-los à variáveis do tipo inteiro, real ou do
tipo caracter (char ou string). A procedure Read lê dados do teclado até que se pressione a tecla ENTER, sendo
que cada tecla pressionada é ecoada para o vídeo. Após pressionarmos ENTER, o cursor permanecerá no
mesma posição no vídeo.
read(variáveis de entrada);
onde:
• read e readln – são identificadores predefinidos em Pascal;

• variáveis de entrada – são os nomes das variáveis do tipo string, char, integer ou real, cujos
valores serão lidos na unidade de entrada.
Observação:
• As variáveis de entrada devem estar separadas por vírgulas. Note que as variáveis do tipo
booleano não podem ser incluídas na lista de variáveis de entrada.
• A diferença entre as instruções read e readln é que a instrução readln obriga a próxima instrução
read ou readln a começar a ler em uma nova linha de dados. Já a instrução read permite que a
próxima instrução read ou readln comece na mesma linha.
• Os dados numéricos devem ser separados uns dos outros por espaços ou por indicações de fim de
linha (ENTER).
• Qualquer número pode ser precedido por um sinal de mais ou menos, desde que não haja um
espaço entre o sinal e o número.
• O dado do tipo caracter não deve ser colocado entre aspas.
Exemplo:
Program teste;
Uses WinCrt;
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.
. 35
Linguagem Pascal
---------------------------------------------------------
Digite um numero inteiro ------> 10
Digite um numero real ---------> 10.5
Digite um caractere -----------> a
Digite uma string -------------> abc
10
1.0500000000E+01
a
abc
---------------------------------------------------------
Capítulo 6 - Funções padrão predefinidas
6.1 Funções matemáticas

No pascal estão disponíveis funções predefinidas para o cálculo de várias operações matemáticas.
Função Descrição Tipo de entrada Tipo de valor retornado

Abs(Num) Valor absoluto Inteiro ou Real Inteiro ou Real (o mesmo que
Num)
ArcTan(Num) Arco tangente Inteiro ou Real Real
Cos(Num) Co-seno Inteiro ou Real Real
Exp(Num) Exponencial (ex) Inteiro ou Real Real
e=2.71882818...
Frac(Num) Parte fracionária Real Real
Int(Num) Parte inteira Real Real
Ln(Num) Logaritmo natual (base Inteiro ou Real Real
e)
(Num > 0)
Round(Num) Arrendondamento ao Real Inteiro
inteiro mais próximo
Sin(Num) Seno Inteiro ou Real Real
Sqr(Num) Quadrado Inteiro ou Real Inteiro ou Real (o mesmo que
Num)
SqRt(Num) Raiz quadrada Inteiro ou Real Real
(Num > 0)
Trunc(Num) Extração da parte Real Inteiro
inteira, ou seja perde a
parte decimal
Exemplo:
...
begin
Writeln(2*Sin(3.14));
End.
...
A chamada da função precede as demais operações; se uma função é um operando de uma
expressão, ela deve ser calculada antes que as demais operações possam ser efetuadas. Observe a seqüência
de execução da instrução acima:
. 36
Linguagem Pascal
1o) é calculado o seno;

2o) o resultado deste cálculo é multiplicado então por 2;
3o) e por fim é mostrado na tela o resultado.
Observações:
• Como parâmetros de funções você pode usar expressões e até outras funções.
6.2 Funções literais

O tipo predefinido char é formado pelos caracteres existentes na configuração considerada. Operações
neste tipo são definidas no Turbo Pascal. As expressões do tipo char são formadas por uma constante, ou uma
variável ou a ativação de uma função do tipo char. Existem, porém funções predefinidas, tais como:
Nome Descrição Tipo de Tipo de valor

entrada retornado
Ord (X) Retorna um número decimal que Char Integer
indica a ordem X no conjunto de
caracteres ASCII.
Chr(EA) Retorna o caracter que corresponde Integer Char
à ordem, dada pelo valor da
expressão aritmética EA, se existir,
no conjunto de caracteres ASCII.
Succ(X) Retorna o sucessor de X no Integer ou Char Integer ou Char
conjunto de caracteres ASCII, se
existir.
Pred(X) Retorna o predecessor de X no Integer ou Char Integer ou Char
conjunto de caracteres ASCII, se
existir.
Observação:
• As funções Ord(X), Succ(X), Pred(X) aplicam-se não apenas às variáveis ou constantes do tipo
char, mas de qualquer tipo predefinido, exceto o tipo real.
Exemplo:
a) Succ(‘A’) é ‘B’; Pred(‘D’) é ‘C’;

b) Succ(1) é 2; Pred(100) é 99;
c) Ord(‘C’) é 67; Chr(65) é ‘A’ no código ASCII.
. 37
Linguagem Pascal
Capítulo 7 - As sub-
sub-rotinas do Pascal
7.1 Utilizando as sub-

sub-rotinas
No geral, problemas complexos exigem algoritmos complexos, mas sempre é possível dividir um
problema grande em problemas menores. Desta forma, cada parte menor tem um algoritmo mais simples, e é
este trecho menor que é chamado de sub-rotina. Quando uma sub-rotina é chamada por um programa principal,
ela é executada e ao seu término o controle de processamento do programa retorna automaticamente para a
primeira linha de instrução após a linha que efetuou a sua chamada.
7.2 Tipos de sub-

sub-rotinas
A linguagem Pascal permite a utilização de dois tipos de rotinas definidas pelo programador: Procedure
(procedimento) e Function (função). Uma procedure ou function é, na verdade, um bloco de programas
contendo início e fim, identificado por um nome, através do qual será referenciado em qualquer parte do
programa principal ou do programa chamador da rotina. A diferença entre os dois tipo de sub-rotina está no fato
de uma procedure poder ou não retornar um valor após seu processamento, enquanto uma function sempre irá
retornar um valor após seu processamento.
Além das rotinas definidas pelo programador, existe no Turbo Pascal um conjunto de rotinas embutidas
predefinidas, ou seja, fornecidas pela Borland. Este tipo de rotina embutida é conhecido pelo nome de unidade,
em inglês Unit, que será apresentada a seguir.
7.3 Unidades predefinidas – As Units

As Units são um conjunto de rotinas prontas para serem usadas pelo programador. As Units são rotinas
compiladas separadamente do programa principal. Uma unit é na realidade uma biblioteca de funções e
procedures predefinidas. Neste momento o que nos interessa é o conhecimento das Units já disponíveis no
Pascal. O conceito de Units foi incorporado no Pascal na sua versão 4. As units padrão do Turbo Pascal são:
• Strings
• System
• WinCrt
• WinDOS
• WinProcs
• WinTypes
As units mais importantes para o nosso estudo são a System e a WinCrt.
Antes de utilizarmos algumas das rotinas predefinidas do Pascal devemos antes declarar as Units na
Área de Declarações do programa Pascal. A declaração uses indica ao compilador onde buscar as definições
(código objeto) de certas instruções.
Sintaxe da declaração uses:
Uses <identificador>, ... <identificador>;
Onde:
Uses – é uma palavra reservada do Pascal.

Identificador – é o nome de uma das unidades padrão do Pascal.
. 38
Linguagem Pascal
7.3.1 A unit System

A Unit System é a única que pode ser utilizada sem ser citada num programa Pascal, ou seja, não é
necessário a sua declaração na Área de declarações do Pascal. Nela está contida a maior parte das rotinas
padrões do Pascal.
Algumas procedures e funções da unit System:
Read, Readln, Write e Writeln, Chr, Eof. Lenght.
7.3.1.1 Convertendo de caixa baixa para caixa alta (UpCase)

Esta função converte um caracter para o seu correspondente em caixa alta. É uma função da Unit
System.
Sintaxe:
UpCase(expressão caracter);
Onde:
expressão caracter – é um único caracter ou uma expressão do tipo caracter (Char).
...
Writeln(‘Digite um caracter qualquer............> ‘);
Readln(c);
Writeln(‘O caracter ‘,’’’’,c,’’’’,’ em caixa alta fica assim:
‘,UpCase(c));
...
Considerando que o caracter digitado pelo usuário é o caracter ‘a’ o programa resulta na seguinte tela:
---------------------------------------------------------------
O caracter ‘a’ em caixa alta fica assim: A
---------------------------------------------------------------
7.3.1.2 Verificando o tamanho de uma string (Lenght)

Esta função retorna o tamanho de uma string. É uma função da Unit System.
Sintaxe:
Lenght(expressão caracter);
Onde:
expressão caracter – é uma string de caracteres, uma variável ou uma expressão do tipo string de
caracteres (String).
. 39
Linguagem Pascal
Program exemplo;
Uses WinCrt;
Var x:string;
y:integer;
begin
Write('Digite uma string qualquer...: '); readln(x);
y := Length(x);
Write('Esta string tem ',y,' carateres.');
end.
Considerando que a string digitada pelo usuário foi ‘Pascal’ o programa resulta na seguinte tela:
---------------------------------------------------------------
Digite uma string qualquer...:Pascal
Esta string tem 6 carateres.
---------------------------------------------------------------
7.3.2 A unit WinCrt

Esta é a unit mais utilizada na programação do Turbo Pascal. Por esta razão, ela possui a maior parte
das rotinas e variáveis de geração de som, controle de vídeo e teclado, por exemplo.
Por exemplo, para fazer uso do recurso de limpar e posicionar mensagens na tela do computador, será
usada a principal e mais utilizada unidade do Turbo Pascal: a WinCrt.
Algumas procedures e funções da unit WinCrt:
ClrScr, GotoXY, KeyPressed, etc.
7.3.2.1 Limpando a tela (ClrScr)

ClrScr é um comando, e significa “limpe a tela e coloque o cursor no canto superior esquerdo” (linha 1,
coluna 1 do monitor). O ponto e vírgula após o ClrScr é importante: ele indica ao compilador que terminou uma
instrução. Este comando é uma procedure da unit WinCrt.
Exemplo:
Program exemplo;
Uses WinCrt;
begin
ClrScr;
Writeln(‘O primeiro programa a gente nunca esquece!’);
Readkey;
ClrScr;
Writeln(‘O segundo a gente também nunca esquece!’);
Readkey;
end.
Observação:
• O comando ClrScr limpará a tela e posicionará o cursor no canto superior esquerdo da tela.
. 40
Linguagem Pascal
7.3.2.2 Determinando o pressionar de uma tecla (KeyPressed)

KeyPressed é um comando que determina se uma tecla qualquer foi pressionada ou não através do
teclado. Usamos este comando para fazer com que o programa pare de ser executado e fique aguardando que
alguma tecla seja pressionada; enquanto isso não ocorre, a execução do programa fica parada. Diferentemente
da função ReadKey, que retorna o valor da tecla pressionada, KeyPressed simplesmente retorna true ou false;
false enquanto nenhuma tecla for pressionada e true quando uma tecla qualquer for pressionada.
Este comando é também uma função da unit WinCrt .
Exemplo:
Program exemplo;
uses WinCrt;
var
C: Char;
begin
repeat
Writeln(‘Por favor pressione uma tecla qualquer!');
until KeyPressed;
Writeln(‘Uma tecla qualquer foi pressionada!');
end.
Obs.: O programa escreverá na tela a frase “Por favor pressione uma tecla qualquer!” um número
indefinido de vezes, até que uma tecla qualquer seja pressionada. Neste momento o programa encerra a
estrutura de repetição Repeat-Until e executa a instrução “ Writeln(‘Uma tecla qualquer foi pressionada!');” e
finaliza.
---------------------------------------------------------
Por favor pressione uma tecla qualquer!
...
Você pressionou uma tecla qualquer!
---------------------------------------------------------
7.3.2.3 Aguardando pressionar uma tecla (ReadKey)

ReadKey é um comando que lê um caracter através do teclado, sem contudo, ecoá-lo para a tela do
computador. Usamos este comando para fazer com que o programa pare de ser executado e fique aguardando
que alguma tecla seja pressionada; enquanto isso não ocorre, a execução do programa fica parada. Este
comando é também uma função da unit WinCrt e há ainda outros usos para ela.
Exemplo:
Program exemplo;
uses WinCrt;
var
C: Char;
begin
Writeln(‘Por favor pressione uma tecla qualquer !');
C := Readkey;
. 41
Linguagem Pascal
Writeln('Você pressionou a tecla ', C, '. Seu valor em

ASCII é ', Ord(C), '.');
end.
Obs.: Vamos supor que você tenha pressionado a tecla A (caixa alta).
---------------------------------------------------------
Por favor pressione uma tecla qualquer !
Você pressionou a tecla A. Seu valor em ASCII é 65.
---------------------------------------------------------
7.3.2.3 Posicionando o cursor na tela (GotoXY)

Este procedimento permite posicionar o cursor em um determinado ponto da tela. Este comando é um
procedimento da unit WinCrt.
Sintaxe:
GotoXY(parâmetroX,parâmetroY);
Para utilizá-lo é necessário informar dois parâmetros: o primeiro representa o valor da coluna que
deverá ser um valor numérico do tipo inteiro positivo entre 1 e 80 e o segundo parâmetro representa o número
da linha que deverá ser um valor numérico também do tipo inteiro positivo entre 1 e 25.
Exemplo:
Program exemplo;
uses WinCrt;
var
C: char;
begin
GotoXY(10,10);
Writeln('Olá!');
end.
O comando GotoXY posicionará o cursor na linha 10, coluna 10 da tela do computador. A mensagem
´Olá!´ será mostrada então a partir desta coordenada.
---------------------------------------------------------
Olá!
---------------------------------------------------------
. 42
Linguagem Pascal
Capítulo 8 – A tomada de decisões
8.1 A estrutura de decisão IF

A estrutura de decisão IF pode se apresentar de duas formas: a estrutura de decisão simples (IF-THEN)
e a estrutura de decisão composta (IF-THEN-ELSE). Esta estrutura de decisão permite que uma ação se realize,
se e somente se uma condição lógica for atendida.
8.1.1 A estrutura de
de decisão simples (IF-
(IF-THEN)
Sintaxe:
If <condição> Then <bloco de comando>;
Onde:
• If – Then – são palavras reservadas do Pascal.

• condição – é a expressão booleana que será avaliada no comando If-Then. Esta expressão
retorna verdadeiro (true) ou falso (false).
• bloco de comando – é um único comando (bloco de instrução simples) ou um conjunto de
comandos (bloco de instrução composta) que serão executados, caso a expressão booleana
avaliada retorne verdadeiro (true).
Exemplo:
Program exemplo;
Uses WinCrt;
var A, B, C: real;
begin
read (A, B, C);
if A+B < C then write (‘A soma de A com B é menor que C!’)
end.
ou
...
begin
read (A, B, C);
if A+B < C then
write (‘A soma de A com B é menor que C!’)
end.
...
Neste exemplo, após as variáveis A, B e C serem declaradas reais, os valores de A, B e C serão lidos;
em seguida, o comando If-Then irá avaliar a expressão booleana (A+B<C) e se a resposta for verdadeira (true),
será escrito a mensagem ‘A soma de A com B é menor do que C, e a execução então terminará; caso contrário,
se a expressão retornar falso (false), cessa a execução do programa sem nenhuma mensagem exibida.
Observações:
• Caso a instrução, a ser executada após a avaliação da expressão booleana, seja uma instrução
composta, ou seja, com mais de um comando, deve-se delimitar o bloco de comandos por begin e
end.
. 43
Linguagem Pascal
8.1.2 A estrutura de decisão composta (IF-

(IF-THEN-
THEN-ELSE)
Sintaxe:
If<condição> Then <bloco de comando1> Else <bloco de comando2>;
Onde:
• If – Then-Else – são palavras reservadas do Pascal.

• condição – é a expressão booleana que será ser avaliada no comando If-Then-Else. Esta
expressão retorna verdadeiro (true) ou falso (false).
• bloco de comando1 – é um único comando (bloco de instrução simples) ou um conjunto de
(condição) avaliada retorne verdadeiro (true).
• bloco de comando2 – é um único comando (bloco de instrução simples) ou um conjunto de
(condição) avaliada retorne falso (false).
Exemplo1:
Program exemplo1;
Uses WinCrt;
var A, B, C: real;
begin
read (A, B, C);
if A+B < C
then write (‘A soma de A com B é menor que C!’)
else write (‘A soma de A com B é maior que C!’);
end.
Neste exemplo, após as variáveis A, B e C serem declaradas reais, os valores de A, B e C

serão lidos; em seguida o comando if-then-else irá avaliar a expressão booleana (A+B<C) e se a
resposta for verdadeira (true), será escrito a mensagem ‘A soma de A com B é menor do que C, e a
execução então terminará; caso contrário, se a expressão retornar falso (false), será escrito a
mensagem ‘A soma de A com B é maior do que C, e a execução então terminará.
Exemplo2:
Program exemplo2;
Uses WinCrt;
var A, B, X, Y: real;
begin
writeln('Digite o valor de A: ');
read (A);
writeln('Digite o valor de B: ');
read (B);
if A = B
then begin
X:= 1.5;
. 44
Linguagem Pascal
Y:= 2.5
end
else begin
X:= -1.5;
Y:= -2.5
end;
writeln ('O valor de X é :', X:4:1);
writeln ('O valor de Y é :', Y:4:1);
end.
Observações:
• Caso a instrução, a ser executada após a avaliação da expressão booleana, seja uma instrução
composta, ou seja, com mais de um comando, deve-se delimitar o bloco de comandos por begin e
end.
• O sinal de ponto e vírgula não deve aparecer numa estrutura If-Then-Else, exceto como separador
dentro de um bloco de instrução composta (entre o begin e o end). Colocar um ponto e vírgula
antes da palavra reservada Else resultará num erro de compilação.
8.2 Estrutura de decisão com múltipla escolha - CASE

A estrutura CASE é uma estrutura de controle condicional que permite que alguns grupos particulares
de instruções (bloco de comandos) sejam escolhidos e executados dentre os vários grupos de instruções
disponíveis.
Exemplo utilizando a estrutura if-then:
program exemplo;
...
begin
opcao := ´0´;
while (opção <> ‘5’) do
begin
clrscr;
gotoxy(33,1); write (´Menu Principal´);
gotoxy(28,6); write (´[ 1 ] - Soma´);
gotoxy(28,8); write (´[ 2 ] - Subtração´);
gotoxy(28,10); write (´[ 3 ] - Multiplicação´);
gotoxy(28,12); write (´[ 4 ] - Divisão´);
gotoxy(28,14); write (´[ 5 ] – Fim de Programa´);
gotoxy(28,18); write (´Escolha uma opção.....:´);
readln(opção);
if (opção = ´1´) then
rot_adicao;
rot_subtracao;
rot_multiplicacao;
rot_divisao;
end;
end.
Perceba que neste exemplo o selecionamento das sub-rotinas é feito com instruções if-then. Você pode
observar também que se você tivesse um menu com quinze opções, deverão ser definidas quinze instruções do
. 45
Linguagem Pascal
tipo if-then para verificar a escolha do operador. Esta forma pode ser simplificada com a utilização da estrutura
case-of.
Syntaxe:
Case <variável> Of
<opção1>: <instrução1>;
<opção2>: <instrução1>;
...
<opçãoN>: <instruçãoN>;
Else
<instrução>;
End;
ou
Case <variável> Of
<opção1>: begin
<instrução1.1>;
<instrução1.2>;
<instrução1.N>;
end;
<opção2>: begin
<instrução2.1>;
<instrução2.2>;
<instrução2.N>;
end;
<opçãoN>: begin
<instruçãoN.1>;
<instruçãoN.2>;
<instruçãoN.N>;
end;
Else
<instrução-else>;
End;
Onde:
• Case –Of-Else – são palavras reservadas do Pascal.

• variável– é o nome da variável a ser controlada na estrutura de decisão Case-Of-Else.
• opção – é o conteúdo da variável a ser verificado (lista de constantes), separadas por vírgula, cujo
tipo seja o mesmo da variável de controle da estrutura.
• instrução - é um único comando (bloco de instrução simples) ou um conjunto de comandos (bloco
de instrução composta) que serão executados.
Observações:
• A opção consite de uma ou mais constantes ou gama de valores, separadas por vírgulas.
• As constantes ou gama de valores da opção tem que ser do mesmo tipo da variável de controle da
estrutura Case-of-end.
• Instruções (bloco de comando) vazias são permitidas, para indicar que nenhuma ação deve ser
tomada para certos valores.
• As instruções não necessitam ser únicas, isto é, a mesma instrução pode ser usada com duas ou
mais listas de opção do case.
• A instrução pode ser uma instrução simples do pascal ou uma chamada a uma rotina, por exemplo.
. 46
Linguagem Pascal
• A instrução else só será executada se nenhuma das opções anteriormente testadas, na estrutura
case, for atendida.
Exemplo utilizando a estrutura Case-Of-End:
program principal;
...
begin
while (opcao <> '5') do
begin
clrscr;
gotoxy(33,1); write ('Menu Principal');
gotoxy(28,6); write ('[ 1 ] - Soma');
gotoxy(28,8); write ('[ 2 ] - Subtração');
gotoxy(28,10); write ('[ 3 ] - Multiplicação');
gotoxy(28,12); write ('[ 4 ] - Divisão');
gotoxy(28,14); write ('[ 5 ] - Fim de Programa');
gotoxy(28,18); write ('Escolha uma opção.....:');
readln(opcao);
case opcao of
'1': rot_adicao;
'2': rot_subtracao;
'3': rot_multiplicacao;
'4': rot_divisao;
else
writeln('É o fim do programa!');
end;
end;
end.
. 47
Linguagem Pascal
Capítulo 9 – Estruturas de repetição
9.1 A estrutura de repetição condicional While-

While-Do
A estrutura de repetição While-Do é utilizada para efetuar ciclos condicionais. O bloco de comando,
dentro da estrutura While-Do, será executado repetidamente, enquanto a expressão booleana se
mantiver verdadeira (true). Quando isto não mais ocorrer, a repetição é interrompida, e a seqüência de
comandos, que vier logo após a estrutura While-Do, passa a ser executada.
Sintaxe:
While <expressão> Do <bloco de comando>;
Onde:
• While-do – são palavras reservadas do pascal;

• expressão – é uma expressão booleana que retorna verdadeiro (true) ou falso (false).
• bloco de comando - é um único comando (bloco de instrução simples) ou um conjunto de
comandos (bloco de instrução composta) que serão executados enquanto a expressão booleana
for verdadeira (true).
Observações:
• O bloco de comando pode ser do tipo simples ou composto, apesar de normalmente ser composto.
• Quando o bloco de comando for constituído por um único comando, o begin e o end podem ser
omitidos.
• Quando o bloco de comando for constituído por mais de um comando é obrigatório o begin e o end.
• A expressão booleana do comando While-do é avaliada antes do bloco de comando ser executado.
Se esta expressão retornar um valor falso (false) na primeira vez em que a expressão for avaliada,
os comandos do bloco de comando não serão executados nenhuma vez.
Exemplo:
Vamos supor, por exemplo, que queremos escrever os números inteiros 1,2,...,20, com um inteiro em
cada linha. Isso pode ser conseguido com a seguinte estrutura While-Do:
Program exemplo;
Uses WinCrt;
var digito: integer;
begin
digito:= 1;
while digito <= 20 do
begin
writeln('O ',digito,'º digito é :',digito);
digito := digito+1;
end;
end.

---------------------------------------------------------
O 1o digito é :1
O 2o digito é :2
...
. 48
Linguagem Pascal
O 20o digito é :20

---------------------------------------------------------
9.2 A estrutura de repetição condicional Repeat-

Repeat-Until
A estrutura de repetição Repeat-Until é utilizada para efetuar ciclos condicionais. O bloco de comando
será executado repetidamente, até que a expressão booleana se torne verdadeira (true). Quando isto
ocorrer, a repetição é interrompida, e a seqüência de comandos, que vier logo após a estrutura Repeat-Until,
passa a ser executada.
Sintaxe:
Repeat
<instrução1>;
<instrução2>;
...
<instruçãoN>
Until <expressão>;
Onde:
• Repeat-Until – são palavras reservadas do pascal;

• expressão – é uma expressão booleana que retorna verdadeiro (true) ou falso (false).
• instrução - é um único comando (bloco de instrução simples) ou um conjunto de comandos (bloco
de instrução composta) que serão executados até que a expressão booleana se torne verdadeira
(true).
Observações:
• Note que nesta estrutura o bloco de comando será sempre executado pelo menos uma vez, dado
que a expressão booleana não é testada no ínício e sim no fim da estrutura de repetição.
• A seqüência de instruções dentro da estrutura Repeat-Until não necessita ser incluída dentro de
um bloco Begin e End.
• A expressão booleana do comando Repeat-Until é avaliada após a instrução ou instruções serem
executadas.
Exemplo:
Vamos supor, por exemplo, que queremos escrever os números inteiros 1,2,...,20, com um inteiro em
cada linha. Isso pode ser conseguido com a seguinte estrutura Repeat-Until:
Program exemplo;
Uses WinCrt;
var digito: integer;
begin
digito:= 1;
Repeat
writeln('O ',digito,'º digito é :',digito);
digito := digito+1;
Until digito > 20;
end.

---------------------------------------------------------
O 1o digito é :1
O 2o digito é :2
...
. 49
Linguagem Pascal
O 20o digito é :20

---------------------------------------------------------
9.3 A estrutura de repetição incondicional For

A estrutura de repetição For é utilizada para efetuar ciclos incondicionais. Isto é, esta estrutura permite
que uma ação seja repetida um número especificado de vezes. O bloco de comando será executado
repetidamente, para cada um de vários valores consecutivos atribuídos à variável de controle. O número
de valores atribuídos à variável de controle determina, portanto, o número de vezes que o bloco de comando é
executado.
Sintaxe da primeira forma:
For <variável de controle> := <valor inicial> to <valor final> do

<bloco de comando>;
Onde:
• For-to-do e For-downto-do - são palavras reservadas do pascal;

• variável de controle – é um identificador de variável, que controlará os ciclos da estrutura For-to-
do;
• valor inicial – é o primeiro valor que a variável de controle assume;
• valor final – é o valor máximo que a variável de controle pode assumir.
• bloco de comando - é um único comando (bloco de instrução simples) ou um conjunto de
comandos (bloco de instrução composta) que serão executados enquanto a estrutura For-to-do
estiver ativa.
Observações:
• Esta estrutura é muito utilizada quando conhecemos de antemão o número de ciclos a executar.
• Se a variável de controle é uma variável do tipo inteira, então aumentará automaticamente uma
unidade, cada vez que o bloco de comando da estrutura For-to-do for executado; portanto, a
instrução (bloco de comando) será executada (valor final – valor inicial +1) vezes.
• A variável de controle, o valor inicial e o valor final devem pertencer ao mesmo tipo predefinido
(excluindo o real).
• A variável de controle não pode ser alterada, por qualquer instrução, que esteja dentro do bloco de
comando.
• A variável de controle deve ter sido previamente declarada.
• O valor inicial e o valor final, caso sejam dados como expressão, são calculados uma única vez
antes da primeira execução da estrutura For-to-do.
• Os valores de valor inicial e valor final podem ser expressos como constantes, variáveis ou
expressões. Contudo, estes valores devem ser do mesmo tipo que a variável de controle.
• O valor de valor incial deve ser menor do que valor final se pretendemos que a instrução dentro da
estrutura For-to-do seja executada mais de uma vez. Se valor incial for igual a valor final , a
instrução será executada somente uma vez; se valor incial for maior que valor final, a instrução não
chegará a ser executada.
Exemplo:
Program exemplo;
Uses WinCrt;
var i: integer;
begin
for i:= 1 to 20 do
writeln('O ',i,'º digito é :',i);
end.
. 50
Linguagem Pascal
Sintaxe da Segunda forma:
For <variável de controle> := <valor inicial> downto <valor final> do

<bloco de comando>;
A segunda forma da estrutura for é semelhante à primeira, exceto no uso da palavra reservada
Downto em vez de To. A ação produzida por esta forma da estrutura For é semelhante à primeira
forma, exceto pelo fato de que a variável de controle é decrementada. Esta variável é decrementada
automaticamente de uma em uma unidade, desde o valor incial até o valor final, durante as sucessivas
passagens pelo ciclo.
Observações:
• O valor inicial deve ser maior que o valor final se pretendemos que a instrução dentro da estrutura
For-downto-do seja executada mais de uma vez. Se os dois valores forem iguais, então a instrução
será executada uma única vez; e se o valor inicial for menor que o valor final, então a instrução não
será sequer executada.
Exemplo:
Program exemplo;
Uses WinCrt;
var i: integer;
begin
for i:= 20 downto 1 do
writeln('O ',i,'º digito é :',i);
end.

---------------------------------------------------------
O 1o digito é : 20
O 2o digito é : 19
...
O 20o digito é :1
---------------------------------------------------------
9.4 Labels e Goto

A instrução Goto permite desviar a seqüê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, na área
de declarações.
Veja um exemplo abaixo:
Program CALCULO;
{
Este programa demonstra como quebrar a estrutura
for-to-do utilizando a instrução goto.
}
Uses WinCrt;
label sai_do_loop;
var A, B, R, i: integer;
. 51
Linguagem Pascal
resp: char;
begin
For i:= 1 to 5 do
begin
ClrScr;
Write('Entre com o valor para A: '); readln(A);
Write('Entre com o valor para B: '); readln(B);
Writeln;
R := A+B;
Writeln('O resultado da soma de A com B é: ',R);
Writeln;
Write('Deseja continuar? ');
Readln(resp);
if (resp <> 's') and (resp <> 'S') then
Goto sai_do_loop;
end;
sai_do_loop: Writeln('Saí do loop for-to-do!');
end.
. 52
Linguagem Pascal
Capítulo 10 - Estrutura de dados homogêneas I

Veremos neste tópico uma técnica de programação que permitirá trabalhar com o agrupamento de
várias informações dentro de uma mesma variável. As variáveis homogêneas correspondem a posições de
memória, identificadas por um único nome, individualizadas por índice e cujo o conteúdo é de um mesmo tipo, e
é por esta razão que recebe a denominação de estrutura de dados homogênea.
O tipo de dado homogêneo recebe diversos outros nomes, tais como: variáveis indexadas, variáveis
compostas, variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou arrays. Vamos tratar esta
estrutura simplesmente como matriz.
10.1 Matriz de uma dimensão ou vetores

Este tipo de estrutura, em particular, é também denominado por alguns profissionais como matrizes
unidimensionais, sendo que sua utilização mais comum está vinculada à criação de tabelas. Caracteriza-se por
ser definida uma única variável dimensionada com um determinado tamanho. A dimensão de uma matriz é
constituída por constantes inteiras e positivas. Como já dissemos os nomes dados às matrizes seguem as
mesmas regras de nomes utilizados em variáveis simples.
O nome dado a uma variável composta é um identificador que obedece às mesmas regras de formação
de identificadores das variáveis simples. Este nome refere-se, coletivamente, a todos os elementos da variável
composta. Para podermos fazer referência a um elemento da variável composta, é necessário colocar o nome
da variável, seguido de um ou mais índices, entre colchetes.
Exemplo 1:
Supondo-se que as notas de 10 alunos estejam armazenadas em uma variável composta, identificada
por Nota, e queiramos fazer referência ao terceiro elemento desta variável devemos proceder assim:
Nota[3]
O conteúdo armazenado neste posição é 65. O índice é a constante inteira 3.
Nota
55 60 65 55 100 70 85 90 55 100
1 2 3 4 5 6 7 8 9 10
Se utilizarmos uma variável I como índice de Nota, tem-se a possibilidade de acesso a qualquer uma
das notas armazenadas, através da notação Nota[I].
Exemplo 2:
Vamos considerar um trecho de programa que faça a leitura de 10 notas dos alunos de uma disciplina,
digitadas uma em cada linha, armazene-as na variável composta Nota (vetor Nota) e calcule a sua média.
Program exemplo3;
.
.
begin
for I := 1 to 10 do
begin
readln(Nota[I]);
soma := soma+Nota[I];
end;
media := soma/10;
.
.
end.
. 53
Linguagem Pascal
Exemplo 3:
Considerando o trecho de programa abaixo, podemos também comparar o conteúdo da sétima posição
da variável Nota com o valor 60.
Program exemplo3;
.
.
begin
if Nota[7] > 60 then
.
.
else
.
.
end.
Podemos também, neste caso, utilizar uma variável índice:
Program exemplo3;
.
.
begin
indice := 7;
if Nota[indice] > 60 then
.
.
else
.
.
end.
Exemplo 4:
Considerando a variável composta montada no exemplo 3, podemos codificar um trecho de programa

que calcule e escreva o número de alunos com nota superior à Media.
Program exemplo4;
.
.
begin
quant := 0;
for I := 1 to 10 do
if Nota[I] > Media then
Inc(quant);
Writeln(‘Número de alunos c/ nota superior a média :,quant);
.
.
end.
. 54
Linguagem Pascal
10.2 Operações com matrizes do tipo vetor

Uma matriz de uma dimensão ou vetor é representada por seu nome, tamanho (dimensão) entre
colchetes e seu tipo, tendo assim, a seguinte sintaxe:
<lista de identificadores> : array[li..ls] of <tipo de dado>;
Onde:
• lista de identificadores – são nomes atribuídos às variáveis que se deseja declarar.

• array-of – são palavras-chave.
• li – é o limite inferior do intervalo de variação do índice, que define a dimensão da variável.
• ls– é o limite superior do intervalo de variação do índice, que define a dimensão da variável.
• tipo de dado – é o tipo de dado dos elementos da variável.
Observações:
• As regras para a formação dos identificadores das variáveis compostas são as mesmas que a dos
identificadores das variáveis simples.
• O tipo de dado dos elementos da variável pode ser qualquer tipo de dado válido no pascal.
• O índice da variável, li e ls, deve ser do tipo ordinal: inteiro, caracter, booleano, enumerado ou uma
gama de valores.
• Quando acessamos os elementos individuais das variáveis compostas o valor do índice pode ser
expresso como uma constante, uma variável ou uma expressão. Contudo o valor do índice deve
ser do tipo correto e deve estar dentro do intervalo correto.
• Os elementos individuais da variável do tipo vetor podem ser usados em expressões, instruções de
atribuição, instruções read e write, etc., como se fossem variáveis de tipo simples.
Exemplo 1:
Vamos observar o programa a seguir. Este programa efetua a leitura de dez elementos de
uma matriz A tipo vetor e em seguida constroi uma matriz B de mesmo tipo, acompanhando a seguinte
lei de formação: se o valor do índice for par, o valor deverá ser multiplicado por 5; sendo ímpar, deverá
ser somado com 5. Ao final, mostrar os conteúdos das duas matrizes. Este exemplo demonstra como
fazer o tratamento da condição do índice.
program check_indice;
Uses WinCrt;
var
A, B : array[1..10] of integer;
I : integer;
begin
writeln('Cálculo com checagem do indice da matriz');
writeln;
{ Entrada dos Dados }

for I := 1 to 10 do
begin
write('Informe o ', I:2,' o. valor: ');
readln(A[I]);
end;
{ Processamento Par ou Ímpar }

for I := 1 to 10 do
begin
if (I mod 2 = 0) then
. 55
Linguagem Pascal
B[I] := A[I]*5
else
B[I] := A[I]+5;
end;
writeln;
{ Apresentação das Matrizes}

for I := 1 to 10 do
writeln('A[',I:2,'] = ',A[I]:2,' ',
'B[',I:2,'] = ',B[I]:2);
writeln;
writeln('Tecle <ENTER> para encerrar...');
readkey;
end.
---------------------------------------------------------
Cálculo com checagem do indice da matriz
Informe o 1 o. valor: 10
...
A[ 1] = 10 B[ 1] = 15
A[ 2] = 10 B[ 2] = 50
A[ 3] = 10 B[ 3] = 15
...
A[ 1] = 10 B[10] = 50
Tecle <ENTER> para encerrar...

---------------------------------------------------------
No programa acima, são utilizados três loopings do tipo for: o primeiro looping controla a entrada dos
dados na matriz A, o segundo looping verifica se cada elemento da matriz A é par ou ímpar e faz as operações
de soma ou multiplicação atribuindo o resultado na matriz B, e o terceiro looping é utilizado para apresentar as
duas matrizes.
. 56
Linguagem Pascal
10.3 Classificação dos elementos de uma matriz do tipo vetor

Em algumas situações seria bastante útil, que antes de apresentar os dados de uma matriz,
pudéssemos efetuar a classificação desses dados, colocando-os em uma ordem qualquer (alfabética, numérica,
etc.).
Após a inserção dos dados numa matriz do tipo vetor, podemos ordenar (classificar) os seus elementos
sejam eles do tipo numérico ou alfabético , de forma que todos esses elementos, após a ordenação estarão em
uma ordem particular.
Isso é muito útil, pois assim poderemos mostrar todos os seus elementos em ordem,
independentemente daquela em que foram inseridos na matriz, facilitando desta forma a localização de algum
elemento, quando for efetuada uma pesquisa visual.
Imagine então colocar em ordem crescente cinco valores numéricos armazenados numa matriz A, e em
seguida apresentá-los. Vejamos a tabela a seguir:
Matiz A
Índice Elemento
1 9
2 7
3 5
4 3
5 1
Os valores estão armazenados na ordem: 9, 7, 5, 3 e 1 e deverão ser apresentados na ordem 1, 3, 5, 7

e 9. A tabela acima, no formato matricial, ficaria assim:
A[1] = 9, A[2] = 7, A[3] = 5, A[4] = 3, A[5] = 1.
Para efetuar o processo de troca é necessário aplicar o método de propriedade distributiva:
a) o elemento que estiver em A[1] deverá ser comparado com os elementos que estiverem em A[2],
A[3], A[4] e A[5].
b) depois o elemento que estiver em A[2] não necessita ser comparado com o elemento que estiver
em A[1], pois já foram anteriormente comparados, passando a ser comparado somente com os
elementos que estiverem em A[3], A[4] e A[5].
c) na seqüência, o elemento que estiver em A[3] é comparado com os elementos que estiverem em
A[4] e A[5] e por fim,
d) o elemento que estiver em A[4] é comparado apenas com o elemento que estiver em A[5].
Seguindo este conceito faz-se a troca dos elementos desta forma:
a) basta comparar o valor do elemento armazenado em A[1] com o valor do elemento armazenado
em A[2]. Se o primeiro for maior que o segundo, então trocam-se os seus valores. Podemos
observar na tabela acima que a condição é verdadeira e assim o elemento 9 de A[1] é maior que o
elemento 8 de A[2], passa-se para A[1] o elemento 8 e para A[2] passa-se o elemento 9.
b) desta forma passa-se a fazer as trocas sucessivas até que se alcance o último elemento da matriz,
ou seja, a comparação entre o valor armazenado em A[4] com o valor de A[5] .
Observação:
Este procedimento de troca será o mesmo para dados do tipo caracter (char ou string), uma vez que
cada letra possui um valor diferente da outra. A letra “A”, por exemplo, tem valor menor que a letra “B”, e assim
por diante. Se a letra “A” maiúscula for comparada com a letra “a” minúscula, estas terão valores diferentes.
O processo de ordenação para caracteres no Pascal é baseado no uso da tabela ASCII (American
Standard Code for Information Interchange – Código Americano para Troca de Informações).
. 57
Linguagem Pascal
10.3.1O programa de ordenação

Veja abaixo o codificação de ordenação no programa. Observe o detalhe das estruturas for-to-do
encadeadas.
Program Ordena_Matriz;
Uses WinCrt;
var
nomes : array[1..10] of string;
i, j : integer;
nome, temp : string;
resp : char;
begin
resp := 'S';
while (Upcase(resp) = 'S') do
begin
ClrScr;
writeln('Classifica Nomes em Ordem Crescente');
writeln('===================================');
{*** Entrada dos nomes na matriz ***}

for i:= 1 to 5 do
begin
write('Digite o ',i:2,' º nome...>
');readln(nomes[i]);
end;
{*** A Rotina de Ordenação/Classificação ***}
for i:= 1 to 4 do
for j := i+1 to 5 do
{*** a troca dos elementos começa aqui ***}
if (nomes[i] > nomes[j]) then
begin
temp := nomes[i];
nomes[i] := nomes[j];
nomes[j] := temp;
end;
{*** Mostra os Valores Classificados ***}
writeln;
writeln('Os Nomes Ordenados Alfabéticamente');writeln;
writeln(' i Nome ');
writeln('=============================');
for i:= 1 to 5 do
writeln(i:2,' ',nomes[i]);
writeln;
write('Deseja Digitar Outros Valores?(S/N)'); readln(resp);
end;
donewincrt;
end.
. 58
Linguagem Pascal
Observações:
É importante observar que no caso do encadeamento das estrutura for-to-do, será executado primeiro a
rotina mais interna, no caso a rotina de contagem da variável J, passando o processamento para a rotina mais
externa, quando a rotina mais interna fechar o seu ciclo.
O segundo ponto a se observar é a utilização de uma segunda variável no processo de ordenação, no
caso , a variável J. Observe que somente quando a variável J atinge o valor 5 é que este looping se encerra,
retornando ao looping da variável I, acrescentando mais um em I até que I atinja o seu limite e ambos os
loopings sejam encerrados. Veja abaixo o quadro que mostra o comportamento dos valores das variáveis I e J
durante o processo de ordenação:
Comportamento de I e J
Quando I for J será
1 2, 3, 4, 5
2 3, 4, 5
3 4, 5
4 5
10.3.2 A troca dos elementos

A troca dos elementos de posição é efetuada pelo algoritmo de troca mostrado abaixo:
if (nomes[i] > nomes[j]) then

begin
temp := nomes[i];
nomes[i] := nomes[j];
nomes[j] := temp;
end;
Considere o vetor NOMES[I] com o valor “CARLOS” e o vetor NOMES[J] com o valor “ALBERTO”. Ao
final, NOMES[I] deverá estar com a informação “ALBERTO” e NOMES[J] deverá estar com “CARLOS”. Para se
conseguir esta troca é necessário a utilização de uma variável de apoio, a qual será chamada TEMP.
Para que o vetor NOMES[I] fique livre para receber o valor do vetor NOMES[J], TEMP deverá receber o
valor do vetor NOMES[I], assim sendo TEMP passa a ter o valor “CARLOS”. Neste momento, pode-se atribuir ao
vetor NOMES[I] o valor do vetor NOMES[J]. Assim o vetor NOMES[I] passa a possuir o valor “ALBERTO”. Em
seguida atribui-se ao vetor NOMES[J] o valor da variável TEMP. Ao final deste processo, teremos os valores
trocados, sendo o vetor NOMES[I] com o valor “ALBERTO” e NOMES[J] com o valor “CARLOS”.
. 59
Linguagem Pascal
10.4 Pesquisa em matrizes

A utilização de matrizes em Pascal poderá gerar grandes tabelas onde tornaria difícil localizar um
determinado elemento na matriz de forma rápida. Imagine uma matriz possuindo 5000 elementos (5000 nomes
de pessoas). Você dificilmente conseguiria encontrar rapidamente um elemento desejado de forma manual
(visual), mesmo que esta lista de nomes estivesse em ordem alfabética.
Para solucionar este tipo de problema no Pascal, você poderá através do uso da programação, fazer
pesquisa em matrizes. Existem dois métodos para pesquisa em matrizes: o método da Pesquisa Seqüêncial e o
método da Pesquisa Binária.
10.4.1 A pesquisa seqüencial

seqüencial
Este método consiste em efetuar a busca da informação desejada, a partir do primeiro elemento da
matriz , seqüencialmente, até o último elemento. Encontrando a informação procurada, esta é apresentada.
Este método de pesquisa é lento em relação ao método de pesquisa binária, porém eficiente nos casos
em que uma matriz encontra-se com seus elementos desordenados.
Veja abaixo um programa que efetua uma pesquisa seqüencial numa matriz de dez elementos do tipo
string:
Program Pesquisa_Sequencial;
Uses WinCrt;
var
nomes : array[1..10] of string;
i : integer;
nome : string;
resp : char;
achou : boolean;
begin
writeln('Pesquisa Seqüencial de Nomes');
writeln('============================');
{*** Entrada dos nomes na matriz ***}

for i:= 1 to 10 do
begin
write('Digite o ',i:2,' º nome...> ');readln(nomes[i]);
end;
{*** A Rotina de Pesquisa na Matriz ***}

resp := 'S';
while (Upcase(resp) = 'S') do
begin
writeln;
write('Digite o nome a ser pesquisado: ');readln(nome);
i := 1;
achou := false;
while (i <= 10) and (achou=false) do
if (nomes[i] = nome) then
achou := true
else
Inc(i);
writeln;
if (achou = true) then
writeln(nome,' foi localizado na posição ',i:2,' !')
. 60
Linguagem Pascal
else
writeln(nome,' não foi localizado!');
writeln;
write('Deseja Continuar a Pesquisa? (S/N) '); readln(resp);
end;
donewincrt;
end.
Analisando o trecho da pesquisa seqüencial:
Primeiro é solicitado ao usuário a digitação do nome a ser pesquisado. Este nome é atribuído então à
variável NOME.
À variável “I” (variável contadora do índice) é então atribuído o valor 1 (índice 1) e à variável “ACHOU” é
atribuído o valor falso (false). Isto é necessário para que a expressão da instrução “while (i <= 10) and
(achou=false) do” seja validada no seu primeiro teste da condição. As instruções que se encontram dentro da
estrutura while-do serão executadas enquanto o valor da variável I for menor ou igual a 10 e simultaneamente o
valor da variável ACHOU for igual a falso (false).
A estrutura if-then-else, localizada dentro da estrutura While-do citada acima, verifica se o valor
digitado pelo usuário e atribuído à variável NOME é igual ao valor do elemento da variável indexada NOMES[I] (i
variando de 1 até 10). Se o valor da variável NOME for diferente do valor do elemento da variável indexada
NOMES[I] a variável I será incrementada em 1. Será executada a próxima verificação de NOME com NOMES[I],
e assim por diante. Caso seja igual, a variável ACHOU passa a ter o valor verdadeiro (true), indicando que o
nome procurado foi encontrado. Assim o fluxo de execução do programa é desviado para fora da estrutura while-
do e o programa informará ao usuário, através de uma mensagem, que o valor procurado foi encontrado.
Caso o processamento das instruções da estrutura while-do (while (i <= 10) and (achou=false) do)
chege ao seu final sem encontrar uma equivalência entre a variável NOME e a variável NOMES[I], a variável
ACHOU permanece com o valor falso. Assim o programa irá informar ao usuário, através de uma mensagem,
que o valor procurado não foi encontrado.
Observe que a variável ACHOU exerce um papel importante dentro da rotina de pesquisa, pois esta
serve como um pivô, estabelecendo um valor verdadeiro quando uma determinada informação é localizada. Este
tipo de tratamento de variável é conhecido como FLAG (Bandeira). A variável ACHOU é o flag, podendo-se dizer
que ao começar a rotina a bandeira estava “abaixada” – falsa, e quando a informação foi encontrada, a bandeira
foi “levantada” – verdadeira, indicando a localição da informação desejada.
. 61
Linguagem Pascal
Capítulo 11 – Estruturas de dados homogêneas II
11.1 Matriz multidimensional ou arrays

Vimos anteriormente a utilização de variáveis indexadas (matrizes) do tipo vetor, ou seja, as matrizes
de uma só dimensão. Você aprendeu a trabalhar com a classificação dos seus elementos e a efetuar pesquisa
dentro de sua estrutura.
Podemos dizer que, o conjunto de dados referenciados por um nome e que necessite de mais de um
índice para ter seus elementos individualizados é chamado de matriz multidimensional.
11.2 Matriz bidimensional (duas dimensões)

Uma matriz bidimensional (de duas dimensões) estará sempre fazendo referência a linhas e colunas e
será representada por seu nome e seu tamanho (dimensão) entre colchetes . Abaixo podemos ver uma matriz
de duas dimensões chamada TABELA.
Colunas
1 2 3 4 5 6
Linhas 1
2 Posição 2,3
3
4
5
A matriz TABELA com duas dimensões. 5 linhas e 6 colunas (TABELA[1..5,1..6]).
Observando a matriz TABELA de duas dimensões acima podemos concluir:
a) o seu nome, obviamente, é TABELA;

b) esta matriz possui duas dimensões (linhas e colunas): TABELA[1..5,1..6] ;
c) esta matriz possui o tamanho de 5 linhas (de 1 a 5) e 6 colunas (de 1 a 6), ou seja, é uma matriz de
5 por 6 e,
d) nesta matriz poderão ser armazenados até 30 elementos (5x6=30).
Em matrizes bidimensionais, assim como em matrizes de uma só dimensão, os seus elementos serão
também manipulados (acessados) de forma individualizada, sendo a referência a esses elementos feita sempre
através de dois índices: convenciona-se que o primeiro índice indica a linha da matriz e o segundo índice indica
a coluna. Assim, TABELA[2,3] indica que está sendo feita uma referência ao elemento armazenado na linha 2
coluna 3 da matriz.
Quando manipulamos uma matriz do tipo vetor utilizamos uma única estrutura de repetição (um for-to-
do por exemplo) para acessarmos os seus elementos individuais. No caso de matrizes com mais de uma
dimensão, deverá ser utilizado tantas estruturas de repetição quantas forem as suas dimensões. Para uma
matriz de duas dimensões, por exemplo, deveremos utilizar duas estruturas de repetição encadeadas para que
possamos acessar todos os seus elementos.
Uma matriz de duas dimensões é representada por seu nome, tamanho (dimensão de linhas e colunas)
entre colchetes e o seu tipo, tendo assim, a seguinte sintaxe:
<lista de identificadores> : array[li1..ls1,li2..ls2] of <tipo de dado>;
Onde:
• lista de identificadores – são nomes atribuídos às variáveis que se deseja declarar.
. 62
Linguagem Pascal
• array-of – são palavras-chave.

• li1 – é o limite inferior do intervalo de variação do índice, que define a dimensão da linha da
variável.
• ls1– é o limite superior do intervalo de variação do índice, que define a dimensão da linha da
variável.
• li2 – é o limite inferior do intervalo de variação do índice, que define a dimensão da coluna da
variável.
• ls2– é o limite superior do intervalo de variação do índice, que define a dimensão da coluna da
variável.
• tipo de dado – é o tipo de dado dos elementos da variável.
Observações:
• As regras para a formação dos identificadores das variáveis compostas são as mesmas que a dos
identificadores das variáveis simples.
• O tipo de dado dos elementos da variável pode ser qualquer tipo de dado válido no pascal.
• O índice da variável, li1, ls1, li2 e ls2 deve ser do tipo ordinal (inteiro, caracter, booleano ou
enumerado) ou uma gama de valores.
• Quando acessamos os elementos individuais das variáveis compostas o valor do índice pode ser
expresso como uma constante, uma variável ou uma expressão. Contudo o valor do índice deve
ser do tipo correto e deve estar dentro do intervalo correto.
• Os elementos individuais da variável do tipo vetor podem ser usados em expressões, instruções de
atribuição, instruções read e write, etc., como se fossem variáveis de tipo simples.
Exemplo 1:
Declarar a variável composta (variável bidimensional) MatrizA, de 4 linhas por 3 colunas,

constituída de valores numéricos reais.
Var MatrizA : array[1..4,1..3] of real;
Esta declaração cria uma estrutura de dados agrupados com o nome de MatrizA, com
4 x 3 = 12 elementos reais, endereçáveis por um par de índices, com o primeiro deles indicando a linha
e o outro indicando a coluna.
Exemplo 2:
Declarar a variável composta (variável bidimensional) MatrizB, de 5 linhas por 5 colunas,

constituída de valores caracteres do tipo string.
Var MatrizB : array[1..5,1..5] of string;
Esta declaração cria uma estrutura de dados agrupados com o nome de MatrizB, com
5 x 5 = 25 elementos string, endereçáveis por um par de índices, com o primeiro deles indicando a linha
e o outro indicando a coluna.
Exemplo 3:
Exemplificando a utilização de matrizes bidimensionais, vamos considerar o programa de

entrada e saída de notas escolares de alunos . Assim como na leitura e escrita de uma matriz de uma
dimensão, as operações de entrada e saída com matrizes de duas dimensões é processada passo a
passo.
Vamos considerar a manipulação de quatro notas de oito alunos. A tabela em questão (matriz)
armazenará então trinta e dois elementos (4x8=32). Um detalhe importante a ser considerado é a
utilização de duas variáveis para controlar os dois índices de posicionamento de dados na tabela.
Vejamos o programa abaixo.
. 63
Linguagem Pascal
Program Nota_aluno;
Uses WinCrt;
var Notas : array[1..8,1..4] of real;
i,j : integer;
resp: char;
begin
resp := 'S';
while (UpCase(resp)='S') do
begin
{Estrutura for-to-do encadeada - leitura das notas}

for i:= 1 to 8 do {linha - alunos}
begin
clrscr;
writeln('Leitura das Notas dos Alunos');
writeln('============================');
writeln('Entre com as notas do ',i:2,'º aluno');
writeln;
for j:= 1 to 4 do {coluna - notas}
begin
write('Digite a ',j:2,'a. nota: ');
readln(Notas[i,j]);
end;
end;
{Estrutura for-to-do encadeada-apresentação das notas}

for i:= 1 to 8 do
begin
clrscr;
writeln('Apresentação das Notas dos Alunos');
writeln('=================================');
writeln;
writeln('As notas do ',i:2,'º aluno');
writeln;
for j:= 1 to 4 do
begin
writeln(j:2,' a. Nota : ',Notas[i,j]:5:2);
end;
writeln;
write('Tecle algo para ver as notas do próximo
aluno...');
readkey;
end;
writeln;
write('Deseja Continuar? (S/N) ');
readln(resp);
end;
end.
Analisando o trecho do programa acima, onde é feita a leitura das notas dos alunos, podemos observar
que foi utilizada a variável I para controlar as posições dos elementos, a nível de linha (alunos), dentro da matriz.
Podemos observar também que foi utilizada a variável J para controlar as posições dos elementos, a nível de
coluna (notas dos alunos).
Observando o programa podemos verificar também que as variáveis I e J são inicializadas com 1, ou
seja, a leitura ou a apresentação, será iniciada na primeira linha da primeira coluna da matriz. Assim sendo, será
então digitada para o primeiro aluno a sua primeira nota, ou seja, aluno 1, nota 1. Logo em seguida será
. 64
Linguagem Pascal
incrementado mais 1 à variável J, variável que controla as posições da coluna (notas), passando então para a
posição Notas[1,2], ou seja, aluno 1, nota 2.
Quando o contador de coluna, a variável J, atingir o valor 4, a estrutura for-to-do será então encerrada.
Em seguida o contador de linha, a variável I, será incrementado em 1, tornando-se 2. Será então inicializado
novamente o contador J em 1, permitindo assim, que seja, digitado a nota 1 do aluno 2 (Notas[2,1]).
A entrada dos dados estende-se-á até que o valor do contador de linhas (variável I) atinja o seu último
valor, no caso, 8. Esta estrutura “for I:= 1 to 8 do” tem a função de controlar o posicionamento na tabela por
aluno. A outra estrutura mais interna “for J:= 1 to 4 do”, controla o posicionamento das notas.
Primeira tela - lê as quatro notas dos oito alunos.
---------------------------------------------------------
Leitura das Notas dos Alunos
============================
Entre com as notas do 1º aluno
Digite a 1a. nota:

Digite a 2a. nota:
Digite a 3a. nota:
Digite a 4a. nota:
---------------------------------------------------------
Segunda tela - mostra as quatro notas dos oito alunos.
---------------------------------------------------------
Apresentação das Notas dos Alunos
=================================
As notas do 1º aluno
1a. Nota :
2a. Nota :
3a. Nota :
4a. Nota :
Tecle algo para ver as notas do próximo aluno...

---------------------------------------------------------
11.3 Ordenação em matrizes de duas dimensões

O processo de ordenação de elementos de matrizes de duas dimensões é o mesmo utilizado para
ordenar matrizes de uma dimensão. Vamos então, considerar um programa que cadastre o nome, endereço,
cep, bairro e telefone de dez pessoas e ao final tenha que apresentar os seus elementos dispostos em ordem
alfabética, pelo nome da pessoa, independentemente da forma em que foram digitados. Veja abaixo a matriz
AGENDA:
Dados Pessoais
Nome Endereço CEP Bairro Telefone
1 João
2 Andrea
3 ...
Pessoas 4 ...
... ...
10 ...
. 65
Linguagem Pascal
Após o cadastramento de todos os elementos na matriz AGENDA, será iniciado o processo de

classificação alfabética pelo nome de cada pessoa. Este método já foi anteriormente estudado. É o mesmo
processo de ordenação utilizado em matrizes de uma só dimensão. Após a comparação do primeiro nome com o
segundo por exemplo, sendo o primeiro maior que o segundo, estes deverão ser trocados.
É importante observar que além de trocar os nomes de posição, ou seja, o conteúdo de AGENDA[1,1]
passa para a posição AGENDA [2,1] e o elemento de AGENDA [2,1] passa para a posição AGENDA [1,1], troca-
se também todos os elementos relacionados ao nome (o endereço, o cep, o bairro e o telefone). Veja abaixo a
rotina de troca do nome e demais elementos relacionados a ele na mesma linha.
{*** Rotina de entrada ***}

...
{*** Ordenação e troca de elementos ***}
for atual := 1 to 9 do
for proximo := atual+1 to 10 do
if (AGENDA[atual,1] > AGENDA[proximo,1]) then
begin
{troca do nome}
temp := AGENDA[atual,1]
AGENDA[atual,1] := AGENDA[proximo,1];
AGENDA[proximo,1]:= temp;
{troca do endereço}
{troca do cep}
{troca do bairro}
{troca do telefone}
end;
...
{*** Rotina de saída ***}
. 66
Linguagem Pascal
Capítulo 12 - Estruturas de dados heterogêneas

Anteriormente estudamos a utilização de matrizes, um tipo de dados estruturado em que todos os
elementos devem ser do mesmo tipo. Você notou que somente foi possível trabalhar com um tipo de dado por
matriz. Em situações onde se precisou trabalhar com mais de um tipo de dado diferente, se fez necessária a
utilização de duas matrizes, uma de cada tipo.
12.1 Registros
O Registro é a principal estrutura de dados, cujos os elementos constituintes não necessitam ser do
mesmo tipo. Podemos, desta forma, nos referir coletivamente a um conjunto de elementos que diferem entre si
no seu tipo. Aos elementos individuais dessa estrutura damos o nome de campos do registro.
Pelo fato de podermos trabalhar com os vários dados de tipos diferentes (os campos) em uma mesma
estrutura, este tipo de dado é considerado heterogêneo.
A forma mais fácil de se definir um registro é incluir a definição como parte de uma declaração de
variável. Isto nos permite declarar uma variável individual do tipo registro, tal como declaramos variáveis de tipo
simples ou variáveis do tipo array. Veja abaixo a sintaxe.
Sintaxe – Primeira Forma:
Var <identificador> : record

<campo 1: tipo>;
<campo 2: tipo>;
...
<campo n: tipo>
end;
Onde:
Var, Record e End – são palavras reservadas do Pascal.

Identificador – é o nome da variável do tipo registro que se deseja declarar;
Campo – representam as variáveis que serão usadas como campos do registro.
Tipo – são os tipos das variáveis (campos) e podem ser: real, integer, boolean, string entre outros
existentes no Pascal.
Observações:
• Cada declaração de campo é escrita seguindo as mesmas regras de declaração de variáveis no

Pascal.
• Além dos tipos simples, válidos no Pascal, os campos do registro podem ser outro tipo definido
pelo usuário ou um outro registro previamente declarado.
Exemplo:
Suponha que um registro de funcionário de uma empresa consista na sua matrícula do tipo inteiro, no
seu nome do tipo literal, na sua conta bancária do tipo real e no seu cargo do tipo literal. Representamos este
registro como uma variável do tipo registro chamada reg_funcionario. A declaração da variável é mostrada
abaixo.
Var reg_funcionario : record

matricula : integer;
nome : string[30];
conta : real;
cargo : string[10];
end;
. 67
Linguagem Pascal
Outra maneira de definir um registro, que é freqüentemente mais utilizada do que a simples declaração
de variável é a definição de um tipo registro. Assim, as variáveis individuais poderão ser declaradas como sendo
deste tipo previamente declarado. Neste caso um tipo registro é declarado em Pascal com a instrução type em
conjunto com a instrução record. Veja abaixo a sintaxe.
Sintaxe – Segunda Forma:
Type <identificador> = record

<campo 1: tipo>;
<campo 2: tipo>;
...
<campo n: tipo>
end;
Var <identificador> : <tipo>;
Onde:
Type, Record e End – são palavras reservadas do Pascal.

Identificador – na declaração Type é o nome do tipo registro que se deseja declarar. Na declaração
Var é o nome da variável que será declarada como tipo registro;
Campo – representam as variáveis que serão usadas como campos do registro.
Tipo – na declaração Type são os tipos das variáveis (campos) e podem ser: real, integer, boolean,
string entre outros existentes no Pascal. Na declaração Var refere-se ao tipo registro previamente
declarado.
Observe que após a declaração do tipo registro (declaração Type) você poderá então declarar as novas
variáveis individuais como sendo deste tipo declarado.
Vale lembrar que a declaração acima tem o mesmo resultado que a declaração de variável mostrada na
primeira forma de declaração. Esta abordagem é, contudo, mais geral, porque nos permite declarar variáveis
registro adicionais (com a mesma composição) à medida que se faz necessário.
Observações:
• Note que neste caso, os tipos registro devem ser declarados antes das declarações das variáveis
do tipo registro, pois é bastante comum ocorrer a necessidade de se declarar uma variável com o
tipo de registro previamente declarado.
• Cada declaração de campo é escrita seguindo as mesmas regras de declaração de variáveis no
Pascal.
• Além dos tipos simples, válidos no pascal, os campos do registro podem ser outro tipo definido pelo
usuário ou um outro registro previamente declarado.
Exemplo:
Vamos utilizar o mesmo exemplo utilizado anteriormente do registro de funcionário de uma empresa. A
declaração da variável é mostrada abaixo.
Type reg_funcionario = record

nome : string[30];
conta : real;
cargo : string[10];
end;
Var funcionario : reg_funcionario;
. 68
Linguagem Pascal
Observe que primeiro declaramos um o registro lógico chamado reg_funcionário e logo em seguida
declaramos a variável funcionário do tipo reg_funcionário. O registro reg_funcionário é um conjunto de dados
heterogêneos (um campo integer, um campo real e dois campos string).
12.2 Fazendo referência a um componente do registro

A referência ao conteúdo de um componente (campo) do registro é indicado pela notação:
<nome da variável do tipo registro>.<identificador do campo>
Tanto a leitura quanto a escrita de um registro são efetuadas respectivamente com as instruções
read/readln e write/writeln seguidas do nome da variável do tipo registro e de seu campo correspondente
separado por um caracter “.” (ponto), como exemplificado a seguir:
Type reg_funcionario = record

nome : string[30];
conta : real;
cargo : string[10];
end;
Var funcionario : reg_funcionario;
begin
...
write(‘Informe o nome do funcionário....: ‘);
readln(funcionario.nome);
...
end.
A instrução “readln(funcionario.nome)” atribui o valor digitado pelo usuário ao campo nome da

variável funcionário, que é do tipo reg_funcionario.
12.3 Conjunto de registros

Com as técnicas de programação expostas até este momento, passou-se a ter uma mobilidade
bastante grande, podendo-se trabalhar de uma forma mais adequada com diversos problemas, principalmente
os que envolvem a utilização de dados heterogêneos, facilitando a construção de programas mais eficientes.
Porém os programas apresentados até aqui com a utilização de registros, só fizeram menção à leitura
e escrita de um único registro. Seria muito útil poder construir um programa que permitisse trabalhar com vários
registros de alunos. Para exemplificar considere que você deverá fazer um programa que faça a entrada e a
saída de nome e nota de oito alunos. Veja abaixo a definição do tipo registro e também a definição da matriz de
registros para os oito alunos:
Program cadastro_alunos;
Uses WinCrt;
{*** declaração do tipo reg_aluno ***}

Type bimestre = array[1..4] of real;
reg_aluno = record
nome: string[20];
nota: bimestre;
end;
. 69
Linguagem Pascal
{*** declaração do conjunto de registros aluno ***}

Var aluno : array[1..8] of reg_aluno;
...
Observe que a declaração VAR, declara uma variável de registro chamada ALUNO, sendo esta um
conjunto de oito registros (array[1..8]) do tipo reg_aluno, que por sua vez é formado por dois tipos de dados: o
nome (nome do aluno) como caractere e a nota (quatro notas do aluno) como bimestre.
12.4 Fazendo referência ao i-

i-ésimo elemento do conjunto
A referência ao i-ésimo elemento ou registro do conjunto é feita pela seguinte notação:
<identificador da variável tipo registro [i]>.<identificador do campo>
Podemos observar, que no programa cadastro_alunos mostrado abaixo, algumas instruções fazem
referência a campos dos i-ésimos elementos do conjunto (variável ALUNO). Veja alguns exemplos:
a) Na instrução “readln(aluno[i].nome);” ALUNO[I].NOME refere-se ao campo nome do i-ésimo

elemento do conjunto de alunos (variável ALUNO). Assim ALUNO[2].NOME estará fazendo
referência ao campo nome do segundo aluno do conjunto de registro alunos.
b) Na instrução “readln(aluno[i].nota[j]);” ALUNO[I].NOTA[J] refere-se ao j-ésimo elemento do campo
nota do i-ésimo elemento do conjunto de alunos (variável ALUNO). Assim ALUNO[2].NOTA[1]
refere-se à primeira nota do segundo aluno do conjunto de registro alunos.
Veja abaixo o programa completo que nos permite trabalhar com vários registros de alunos. Este
programa deverá receber a entrada do nome e notas (quatro notas) de oito alunos e ao final mostrar os nomes e
as notas dos mesmos.
Program cadastro_alunos;
Uses WinCrt;
Type
notas = array[1..4] of real;
reg_aluno = record
nome : string[20];
nota : notas
end;
Var aluno : array[1..8] of reg_aluno;

i,j : byte;
resp : char;
begin
resp := 'S';
while (UpCase(resp)='S') do
begin
{*** Cadastramento - 8 alunos com 4 notas cada***}

for i := 1 to 8 do {linha - alunos}
begin
clrscr;
writeln(‘Leitura das Notas dos Alunos');
writeln('============================');
writeln;
write('Informe o nome do ',i:2,'º aluno...: ');

readln(aluno[i].nome);
. 70
Linguagem Pascal
writeln;
for j := 1 to 4 do {coluna - notas}
begin
write('Informe a',j:2,'a. nota.........: ');
readln(aluno[i].nota[j]);
end;
end;
{*** Apresentação - 8 alunos com 4 notas cada***}
for i := 1 to 8 do
begin
clrscr;
writeln('Apresentação das Notas dos Alunos');
writeln('=================================');
writeln;
writeln('Aluno : ',aluno[i].nome);
writeln;
for j := 1 to 4 do
writeln('Nota ',j:2,'......: '
,aluno[i].nota[j]:5:2);
writeln;
write('Tecle <ENTER> para ver as notas do próximo
aluno...'); readln;
end;
writeln;
write('Deseja Continuar? (S/N) '); readln(resp);
end;
donewincrt;
end.
Primeira tela - lê as quatro notas dos oito alunos.

---------------------------------------------------------
Leitura das Notas dos Alunos
============================
Informe o nome do 1º aluno...: XXXXXXXXXXXXXXXXXXXX
Digite a 1a. nota: 99.99

---------------------------------------------------------
Segunda tela - mostra as quatro notas dos oito alunos.

---------------------------------------------------------
Apresentação das Notas dos Alunos
=================================
Aluno : XXXXXXXXXXXXXXXXXXXX
1a. Nota : 99.99

2a. Nota : 99.99
3a. Nota : 99.99
4a. Nota : 99.99
Tecle <ENTER> para ver as notas do próximo aluno...

---------------------------------------------------------
. 71
Linguagem Pascal
Capítulo 13 - Arquivos
Já estudamos os conceitos de tabelas em memória (memória RAM) através da utilização de VETORES
e MATRIZES. Estudamos também o conceito de utilização do tipo definido REGISTRO. Estes conceitos vistos
anteriormente formaram a base para a utilização de um arquivo, pois um arquivo é na verdade uma estrutura de
dados (tabela de informações) gravada em um meio magnético como disquetes, discos rígidos ou fitas
magnéticas.
As matrizes e os vetores são manipuladas através de um índice de controle ao passo que os arquivos
são manipulados por um ponteiro de registro.
Os arquivos são usados principalmente em dois casos:
a) Quando necessitamos armazenar as informações permanentemente. O conteúdo da memória

principal do computador se perde, quando se executa outro programa ou quando se desliga o
computador, entretanto as informações armazenadas em um meio magnético ficam guardadas
permanentemente, podendo ser utilizadas a qualquer momento.
b) Quando as informações são muito numerosas para caber memória principal do computador.
Utilizando arquivos podemos armazenar um número maior de informações (registros) do que em
uma tabela em memória, estando apenas limitado ao tamanho do meio físico utilizado para a sua
gravação.
13.1 Formas de acesso a um arquivo

Os arquivos criados em meio de armazenamento magnético poderão ter os seus registros acessados
para leitura e/ou gravação de três formas: na forma seqüencial, direta ou indexada. Para o propósito deste curso
iremos nos ater apenas a forma de acesso direto.
13.1.1
13.1.1 O acesso seqüencial
Em um arquivo de acesso seqüencial o processo de leitura e gravação é feito de forma contínua, um
registro após o outro. Assim, quando queremos gravar um novo registro é necessário percorrer todo o arquivo,
passando por todos os registros, até localizar a primeira posição vazia após o último registro. Acontece o mesmo
no processo de leitura. Se o registro a ser lido é o último, por exemplo, será necessário a leitura de todos os
registros que o antecedem.
13.1.2 O acesso direto ou randômico

O acesso direto permite o acesso imediato a cada um dos registros, desde que se conheça a sua
posição no arquivo. Este acesso ocorre através de um campo chave previamente definido. Este campo chave é
utilizado para estabelecer o campo de um registro que será utilizado no processo de localização de todo um
registro dentro de um arquivo. Assim, será possível acessar um determinado registro diretamente, sem nos
preocuparmos com os registros que o antecedem.
As operações de leitura e gravação em um arquivo de acesso seqüencial ocorrem através do
apontamento de um indicador de registro (o ponteiro do arquivo), que avança a cada operação executada, do
primeiro até ao último registro do arquivo. Este ponteiro do arquivo é similar ao índice de uma tabela em
memória. No caso de arquivos de acesso direto este ponteiro será movimentado para qualquer posição do
arquivo, através da procedure seek.
13.2 Arquivo com tipo definido de registro

A manipulação de um arquivo em Pascal ocorrerá com a definição do tipo file , o qual se caracteriza por
ser uma estrutura formada por elementos do mesmo tipo dispostos de forma seqüencial. Esta estrutura tem a
finalidade de fazer a comunicação entre a memória principal (memória RAM) e a memória secundária (meios
magnéticos). Assim sendo este tipo será definido com a utilização da seguinte sintaxe:
. 72
Linguagem Pascal
A sintaxe:
Var <identificador> : File Of <tipo registro>;
Onde:
Var e File Of – são palavras reservadas do Pascal.

Identificador – é o nome da nova variável que será usada para representar o arquivo;
Tipo registro – é o tipo a que pertencem os registros do arquivo.
Observações:
• É importante observar que devemos, antes de declarar a nova variável do tipo arquivo, definir um
tipo registro. O tipo registro, previamente declarado, definirá então a estrutura do registro do novo
arquivo.
Exemplo:
Type reg_agenda = record

nome : string[30];
rua : string[25];
numero: integer;
cidade: string[25];
end;
Var arq_agenda : file of reg_agenda;

agenda : reg_agenda;
Neste exemplo, foi declarado uma variável chamada arq_agenda, um arquivo com tipo definido de
registro, composta por registros do tipo reg_agenda. A variável arq_agenda representará o novo arquivo criado.
Note então que, conforme descrito anteriormente, o tipo registro reg_agenda foi previamente declarado e só
depois foi declarada a variável arq_agenda. A estrutura de arq_agenda foi definida na declaração do novo tipo
record chamado reg_agenda. A figura abaixo mostra a representação do arquivo arq_agenda.
Registro reg_agenda Campo numero
Nome Rua Numero Cidade

Arquivo
arq_agenda
13.3 Operações com arquivos
13.3.1 Associando um arquivo à variável de controle (assign)

A procedure assign tem por finalidade associar um nome lógico de arquivo (variável arquivo) ao arquivo
físico (arquivo em meio magnético). É importante frisar que esta instrução não criará o arquivo físico.
Antes de executarmos a abertura de um arquivo no Pascal devemos fazer uma associação do arquivo
lógico declarado com o arquivo físico. Para se fazer a associação desta identificação interna (a variável arquivo)
com a identificação externa (o arquivo físico) usa-se a procedure assign. Atenção! Este comando deve
anteceder a abertura do arquivo que é feita usando-se a procedure reset. Veja abaixo sua sintaxe:
A sintaxe:
. 73
Linguagem Pascal
Assign(<variável arquivo>,<arquivo>);
Onde:
Assign– é palavra-chave do Pascal;

Variável arquivo – é o nome da variável arquivo (arquivo lógico) declarada no programa, que se deseja
associar ao arquivo físico.
Arquivo – é o nome do arquivo físico (arquivo em meio magnético) pelo qual é conhecido externamente
ao programa. Atenção: este parâmetro deve estar entre aspas simples.
Observação:
• Pode-se acrescentar ao parâmetro “arquivo” da procedure assing um caminho (path). Este caminho
indicará o local (a unidade e a pasta) onde deverá ser feita a gravação do arquivo, quando da sua
criação pela procedure rewrite.
Exemplo:
Assign(arq_agenda,’agenda.dat’);
Esta instrução associa o arquivo lógico arq_agenda ao arquivo físico agenda.dat que será criado
posteriormente com a procedure rewrite.
13.3.2 Criando um arquivo (rewrite)

A procedure rewrite tem por finalidade criar um arquivo físico para uso e também gravar um registro em
branco no mesmo. Devemos observar que caso o arquivo já exista, esta instrução o apagará e o criará
novamente.
A sintaxe:
Rewrite(<variável arquivo>);
Onde:
Rewrite – é palavra-chave do Pascal;

variável arquivo – é o nome da variável arquivo (arquivo lógico) associada ao arquivo físico (arquivo
em meio magnético).
Observação:
• Antes de se criar um arquivo utilizando a procedure rewrite é obrigatório fazer a associação do

arquivo lógico (variável arquivo) com o arquivo físico, utilizando a procedure assing. Caso contrário
uma erro em tempo de execução (Run-time error 102: File not assigned) será apresentado.
• Cuidado! Caso o arquivo já exista a procedure rewrite irá apagar todos as informações (registros)
existentes.
• Quando um arquivo é criado o ponteiro do arquivo posiciona-se no primeiro registro deste arquivo,
ou seja, no registro de número 0 (zero).
Exemplo:
rewrite(arq_agenda);
. 74
Linguagem Pascal
13.3.3 Abertura de um arquivo (reset)

A abertura de um arquivo no Pascal é executada pela procedure reset. Esta procedure tem por
finalidade abrir um arquivo já existente, colocando-o disponível para leitura e escrita . A procedure reset abre o
arquivo e deixa o primeiro registro deste arquivo disponível para leitura e/ou escrita, ou seja, o ponteiro do
arquivo aponta para o registro de número 0 (zero).
A sintaxe:
Reset(<variável arquivo>);
Onde:
Reset – é palavra-chave do Pascal;

Observação:
• Caso você faça a tentativa de abrir um arquivo ainda não existente, será apresentada a mensagem
de erro em tempo de execução (Run-time error 2: File not found). Esta mensagem representa uma
tentativa de abertura de um arquivo inexistente. É necessário então que se crie o arquivo
(procedure rewrite) antes da sua abertura.
Exemplo:
reset(arq_agenda);
13.3.4 Leitura de dados em um arquivo (read)

A procedure read tem por finalidade ler a informação (o registro) no arquivo indicado pela variável
arquivo e armazená-la numa variável do tipo registro.
A sintaxe:
Read(<variável arquivo>,<variável registro>);
Onde:
Read – é palavra-chave do Pascal;

variável arquivo – é o nome da variável arquivo (arquivo lógico) associada ao arquivo (arquivo físico).
variável registro – é o nome de uma variável , geralmente uma variável do tipo registro. Esta variável
receberá a informação lida no arquivo.
Exemplo:
read(arq_agenda,agenda);
Esta instrução faz a leitura de um registro no arquivo arq_agenda e o armazena na variável do tipo
registro chamada agenda. A instrução lê o registro para o qual o ponteiro do arquivo aponta no momento.
. 75
Linguagem Pascal
13.3.5 Gravação de dados em um arquivo (write)

A procedure write tem por finalidade gravar a informação (o registro) no arquivo físico indicado pela
variável arquivo. A informação (registro) armazenada numa variável registro será então gravada no arquivo
indicado pela variável arquivo.
A sintaxe:
Write(<variável arquivo>,<variável registro>);
Onde:
Write – é palavra-chave do Pascal;

variável arquivo – é o nome da variável arquivo (arquivo lógico) associada ao arquivo (arquivo físico).
variável registro – é o nome de uma variável , geralmente uma variável do tipo registro.
Observação:
• Após a gravação da informação no arquivo a instrução write posiciona o ponteiro do registro no

próximo registro.
Exemplo:
write(arq_agenda,agenda);
Esta instrução grava o registro, que se encontra armazenado na variável agenda, no arquivo
arq_agenda. A instrução grava a informação no registro para o qual o ponteiro do arquivo aponta no momento.
13.3.6 Fechando um arquivo (close)

A procedure close tem por finalidade fechar um arquivo em uso dentro de um programa. O fechamento
do arquivo desvincula o arquivo físico do programa que o está utilizando. Nenhum programa deve ser encerrado
antes de se fechar os arquivos por ele abertos.
A sintaxe:
Close(<variável arquivo>);
Onde:
Close – é palavra-chave do Pascal;

Exemplo:
Close(arq_agenda);
13.3.7 Acessando um registro de forma direta (seek)

No Pascal o acesso a um registro qualquer de um arquivo, pode ser feito diretamente desde que se
saiba a sua posição física neste arquivo. Assim não se faz necessário processar todos os registros que estão
fisicamente antes dele no arquivo.
A procedure seek tem por finalidade efetuar o posicionamento do ponteiro do arquivo em um
determinado registro, sem que haja a necessidade de processar todos os registros anteriores. Utilizando esta
. 76
Linguagem Pascal
procedure podemos acessar o n-ésimo registro de um arquivo. Lembre-se: No Pascal o primeiro registro de um
arquivo é o de número 0 (zero).
A sintaxe:
Seek(<variável arquivo>,<n>);
Onde:
Seek – é palavra-chave do Pascal;
variável arquivo – é o nome da variável arquivo (arquivo lógico) associada ao arquivo (arquivo
físico).
n – é o número do registro que se quer acessar.
Exemplo:
Seek(arq_agenda,1);
Esta instrução posiciona o ponteiro do arquivo no registro de número 1 (segundo registro) do arquivo
associado à variável arquivo arq_agenda.
13.3.8 Verificando o valor do registro posicionado (filepos)

A função filepos tem por finalidade retornar o valor do registro aonde se encontra posicionado o
ponteiro do arquivo.
A sintaxe:
FilePos(<variável arquivo>);
Onde:
FilePos – é palavra-chave do Pascal;
variável arquivo – é o nome da variável arquivo (arquivo lógico) associada ao arquivo físico
(arquivo em meio magnético).
Exemplo:
...
Seek(arq_agenda,1);
Writeln(FilePos(arq_agenda));
...
No exemplo acima a instrução “Writeln(FilePos(arq_agenda));” mostrará na tela o valor 1 que

corresponde à posição do registro de número 1 do arquivo arq_agenda. Observe que a procedure seek
“forçou” o ponteiro do arquivo a se posicionar neste registro (o de número 1) através da instrução
“Seek(arq_agenda,1);”.
13.3.9 Verificando o tamanho do arquivo (filesize)

A função filesize tem por finalidade retornar número de registros presentes no arquivo.
A sintaxe:
FileSize(<variável arquivo>);
Onde:
. 77
Linguagem Pascal
FileSize – é palavra-chave do Pascal;

Exemplo:
...
Writeln(FileSize(arq_agenda));
...
No exemplo acima a instrução “Writeln(FileSize(arq_agenda));” mostrará na tela a quantidade de

registros do arquivo arq_agenda.
13.3.10 Identificando o final do arquivo - Eof

A função Eof() (End of File) tem por finalidade identificar o final de um arquivo. Quando estamos
programando, seja em Pascal ou em outra linguagem qualquer, é muito comum ter que determinar o último
registro de um arquivo. No Pascal, para resolver esta questão utilizamos a função lógica Eof() associada ao
arquivo. Esta instrução assume o valor TRUE quando se tenta ler um registro após o último.
A sintaxe:
Eof(<variável arquivo>);
Onde:
Eof – é palavra-chave do Pascal;
variável arquivo – é o nome da variável arquivo (arquivo lógico) associada ao arquivo (arquivo
físico).
Exemplo:
...
while (not Eof(arq_agenda)) do
begin
read(arq_agenda,x);
writeln(x.codigo,’ ‘,x.nome);
end;
...
No exemplo acima a instrução “ writeln(x.codigo,’ ‘,x.nome);;” mostrará na tela os campos codigo e
nome de todos os registros do arquivo arq_agenda até que seja encontrado o fim deste arquivo.
Bibliografia:
Aprendendo a Programa na Prática – Turbo Pascal

Virgílio V. Vilela
Fevereiro 1999.
Programando em Turbo Pascal 7.0

José Augusto N. G. Manzano, Wilson Y. Yamatumi,
Editora Érica, quarta edição – 1996.
Pascal Estruturado
Uarry Farrer, Christiano G. Becker, Eduardo Chaves Faria, Frederico Ferreira Campos, e outros
Editora LTC, terceira edição, 1999.
Programação em Pascal
Byron S. Gottfried, Ph. D.
McGraw-Hill, 1988.
. 78

4242 - Outras Linguagens Programacao

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

4242 - Outras Linguagens Programacao

Uploaded by

Copyright:

Available Formats

Linguagem Pascal

Capítulo 1 - Conceitos básicos de programação

1.1 O programa de computador

1.2 Linguagens de programação

1.2.1 Linguagem de máquina

Programa em linguagem Programa em haxadecimal

Para escrever um programa em linguagem de máquina, o programador deve conhecer todas as

1.2.2 Linguagem Assembly

• Os programas escritos apresentam grande velocidade de execução;

• Os programadores devem ter altíssimo nível técnico;

1.2.3 Linguagem de alto nível

• Os programas (código) ocupam mais espaço de memória;

Foram desenvolvidas diversas linguagens de programação, buscando afastar-se do modelo centrado

1.3 O processo de tradução

1.3.4 Compilação e Interpretação - comparação

1.3.4.1 Tempo de execução

1.3.4.2 Consumo de memória

1.3.4.3 Repetição de interpretação

1.3.4.4 Desenvolvimento de programas e depuração de erros

1.3.5 Fluxograma Compilação x Interpretação

Capítulo 2 – Fundamentos de Pascal

2.1 Introdução a linguagem Pascal

2.1.2 Por que Turbo Pascal?

Assim, existem linguagens de programação interpretadas e compiladas. O Cobol é compilado, o Basic

2.2 Estrutura de um programa em Pascal

Este é o layout geral de um programa Turbo Pascal:

program ... ; { Cabecalho do programa } 1 -Cabeçalho do Programa

uses ... ; { cláusula Uses}

2.2.1 Cabeçalho do programa

PROGRAM circulo; (*O Cabeçalho do programa*)

• A primeira linha contém o nome do programa (círculo). Este é o cabeçalho do programa.

2.2.2 Área de declarações

Uses, label, const, type, var, procedure e function.

(*Início da Área de Declarações*)

(*Fim da Área de Declarações*)

2.2.3 O corpo do programa

(*Início do Corpo do Programa*)

(*Fim do Corpo do Programa*)

2.3 O conjunto de caracteres do Pascal

de ‘A’ até ‘Z’ e de ‘a’ até ‘z’.

• Turbo pascal não faz distinção entre letras maiúsculas e minúsculas.

2.4 Palavras reservadas

and asm array begin case

Regras para formação de identificadores:

Exemplos de identificadores válidos: Exemplos de identificadores inválidos:

PROGRAM circulo; (*CABEÇALHO DO PROGRAMA*)

PROGRAM circulo; (*CABEÇALHO DO PROGRAMA*)

2.7 Instruções no Pascal

A linguagem Pascal reconhece inúmeros tipos de instruções compostas, também chamadas de

• O ponto e vírgula da última instrução do bloco de instruções compostas típica é opcional.

For i := to 100 Do writeln(i);

Abaixo você pode ver um exemplo de instrução composta condicional.

If (salario < 2000.0) Then

3.1 Tipos de dados predefinidos

Dados de tipo simples (padrão)

Dados de tipo estruturado (padrão)

• String (cadeia de caracteres)

3.2 Formando números no Pascal

1. Vírgulas e espaços não se podem incluir dentro de um número.

3.3 Números inteiros

Números inteiros permitidos: Números inteiros não permitidos:

Tipo Faixa Formato

3.4 Números reais

PROGRAM circulo; (O Cabeçalho do programa)

(Início da Área de Declarações)

(Fim da Área de Declarações)

(Início do Corpo do Programa)

(Fim do Corpo do Programa)

PROGRAM circulo; (CABEÇALHO DO PROGRAMA)

PROGRAM circulo; (CABEÇALHO DO PROGRAMA)