Livro Algoritmos com Pascal by Edeyson Gomes

Prévia do material em texto

Lógica de Programação 
com Pascal 
Teoria e Prática 
 
Este livro visa ensinar a programação com Pascal 
através de exemplos práticos. 
 
Edeyson Andrade Gomes 
IFBA – 2011 
2ª Edição – Revisão 08.12.2011 
 
SUMÁRIO 
 
 
1
 ............................................................................................................................................... 8 
INTRODUÇÃO À PROGRAMAÇÃO .............................................................................................. 8 
1.1 A Linguagem Pascal ....................................................................................................... 12 
1.2 Estrutura de um Programa Pascal .................................................................................. 24 
1.2.1 Cabeçalho ............................................................................................................... 24 
1.2.2 Área de Declarações ............................................................................................... 25 
1.2.3 Corpo do Programa ................................................................................................ 27 
1.3 Exercícios ...................................................................................................................... 12 
2
 ................................................................................................... Erro! Indicador não definido. 
VARIÁVEIS E CONSTANTES ...................................................................................................... 31 
Palavras Reservadas ........................................................................................................ 31 
Comentários.................................................................................................................... 32 
2.1 Variáveis ....................................................................................................................... 32 
2.2 Constantes .................................................................................................................... 32 
2.3 Tipos de Dados .............................................................................................................. 32 
Inteiros............................................................................................................................ 33 
Reais ............................................................................................................................... 34 
Caracteres ....................................................................................................................... 35 
Tipos Lógicos ................................................................................................................... 38 
3 ............................................................................................................................................. 40 
EXPRESSÕES ............................................................................................................................ 40 
3.1 Prioridades das Operações ............................................................................................ 40 
3.2 Tipos de Expressões ...................................................................................................... 40 
3.3 Tipos de Operadores ..................................................................................................... 41 
Operador de Atribuição ................................................................................................... 41 
Operadores Aritméticos .................................................................................................. 41 
Operador de Concatenação ............................................................................................. 44 
Operadores Relacionais ................................................................................................... 45 
Operadores Lógicos ......................................................................................................... 47 
4
 ............................................................................................................................................. 51 
ESTRUTURAS DE DECISÃO ....................................................................................................... 51 
4.1 IF .. THEN....................................................................................................................... 51 
4.2 IF .. THEN .. ELSE ............................................................................................................ 53 
Exemplos de Código ........................................................................................................ 60 
4.3 CASE .............................................................................................................................. 61 
4.4 EXERCÍCIOS ................................................................................................................... 64 
5 ............................................................................................................................................. 66 
ESTRUTURAS DE REPETIÇÃO ................................................................................................... 66 
5.1 FOR ............................................................................................................................... 68 
5.2 WHILE .. DO ................................................................................................................... 75 
5.3 REPEAT .. UNTIL ............................................................................................................. 82 
6. Arrays ................................................................................................................................. 86 
Apêndice A – Fluxogramas ...................................................................................................... 92 
Seqüência ........................................................................................................................... 92 
Seleção com 1 Via ............................................................................................................... 92 
Seleção com 2 Vias .............................................................................................................. 93 
Seleção com N Vias ............................................................................................................. 93 
Repetição com Teste Antecipado ........................................................................................ 94 
Repetição com Teste Postergado ........................................................................................ 95 
Exemplos ............................................................................................................................ 95 
 
Edeyson Andrade Gomes www.edeyson.com.br 
LISTAGENS 
 
Listagem 1.1 - Cabeçalho de programa Pascal. ........................................................................ 25 
Listagem 1.2 – Utilização de Unit............................................................................................. 26 
Listagem 1.3 – Declaração de Variáveis. .................................................................................. 27 
Listagem 1.4 – Programa que lê 2 números e calcula a soma. .................................................. 28 
Listagem 1.5 - Programa que lê 3 variáveis e calcula a média. ................................................. 30 
Listagem 2.1 – Exemplo de uso de Inteiros .............................................................................. 33 
Listagem 2.2 – Uso de Reais em Pascal .................................................................................... 34 
Listagem 2.3 – Exemplo com Strings........................................................................................ 36 
Listagem 2.4 – Exemplo com Char........................................................................................... 37 
Listagem 2.5 – Exemplo com Boolean ..................................................................................... 38 
Listagem 2.6 – Exemplo com Variáveis e Constantes ............................................................... 39 
Listagem 3.1 – Operador de Atribuição ................................................................................... 41 
Listagem 3.2 – Uso de DIV e MOD ........................................................................................... 42 
Listagem 3.3 – Uso de DIV e MOD com Unidade, Dezena e Centena ........................................ 43 
Listagem 3.4 - Concatenação de Strings .................................................................................. 44 
Listagem 3.5 – Operadores Relacionais com Integer ................................................................ 45 
Listagem 3.6 – Operadores Relacionais com String .................................................................. 46 
Listagem 3.7 – Operadores Relacionais com Reais ................................................................... 47 
Listagem 3.8 – Operadores Lógicos ......................................................................................... 49 
Listagem 4.9 – Fluxograma de sequência ................................................................................ 51 
Listagem 4.1 – Seleção com uma Via – IF .. THEN .................................................................... 52 
Listagem 4.2 – Fluxograma da seleção com uma Via................................................................ 53 
Listagem 4.2 – Seleção com 2 Vias – IF .. THEN .. ELSE ............................................................ 54 
Listagem 4.3 - Fluxograma da seleção com duas Vias .............................................................. 54 
Listagem 4.3 - Seleção com duas Vias ...................................................................................... 55 
 
Listagem 4.4 - Fluxograma da seleção com duas Vias .............................................................. 56 
Listagem 4.5 – Fluxograma do Algoritmo Calcula Desconto 1 .................................................. 58 
Listagem 4.4 - Calcula Desconto 1 ........................................................................................... 58 
Listagem 4.5 - Fluxograma do Algoritmo Calcula Desconto 2 ................................................... 59 
Listagem 4.6 – Fluxograma do algoritmo URA 01 CASE ............................................................ 62 
Listagem 4.5 – Algoritmo URA 01 Case .................................................................................... 63 
Listagem 4.6 – Exercício Teste Condicional .............................................................................. 64 
Listagem 4.7 - ......................................................................................................................... 65 
Listagem 8.1 – Fluxograma RepeteTesteNotas ........................................................................ 67 
Listagem 5.1 – Uso de For para repetir teste de notas ............................................................. 69 
Listagem 5.2 – For Simples ...................................................................................................... 70 
Listagem 6.2 – Fluxograma do ForSimples ............................................................................... 70 
Listagem 5.3 – uso do FOR ...................................................................................................... 72 
Listagem 6.3 – Passo a passo do FOR. ...................................................................................... 73 
Listagem 5.4 – Exemplo de FOR............................................................................................... 73 
Listagem 5.5 – Listagem de números de 1 a 10 ........................................................................ 76 
Listagem 5.6 – Listagem de números de 1 a 10 ........................................................................ 76 
Listagem 5.7 – Listagem de números de 1 a 10 ........................................................................ 78 
Listagem 5.8 – Listagem de números de 1 a 10 ........................................................................ 79 
Listagem 5.9 – While ............................................................................................................... 80 
Listagem 5.10 – Listagem de números de 1 a 10 ...................................................................... 83 
Listagem 5.11 – Listagem de números de 1 a 10 ...................................................................... 84 
Listagem 6 – Fluxograma de Sequencia ................................................................................... 92 
Listagem 7 – Seleção com 1 Via ............................................................................................... 93 
Listagem 8 – Seleção com 2 Vias ............................................................................................. 93 
Listagem 9 – Seleção com N Vias ............................................................................................. 94 
Listagem 10 – Repetição com Teste Antecipado ...................................................................... 94 
 
Edeyson Andrade Gomes www.edeyson.com.br 
Listagem 11 – Repetição com Teste Postergado ...................................................................... 95 
Listagem 12 – Equação do 1º Grau .......................................................................................... 96 
Listagem 13 – Triângulos quanto aos lados ............................................................................. 97 
 
TABELAS 
 
Tabela 2.1 – Tipos Inteiros ...................................................................................................... 33 
Tabela 2.2 - Tipos Reais ........................................................................................................... 34 
Tabela 3.1 – Precedência de Operadores ................................................................................ 40 
Tabela 3.2 – Operadores Relacionais ....................................................................................... 45 
 
 
 
FIGURAS 
 
Figura 1.1 - Fluxograma de Raízes de Equação do 2º Grau ....................................................... 11 
Figura 1.2 - Fluxograma: Ordenar 3 números distintos ............................................................ 14 
Figura 1.3 – Fluxograma: Números naturais entre 1 e N .......................................................... 17 
Figura 1.4 – Fluxograma: Divisores naturais de N .................................................................... 19 
Figura 1.5 – Fluxograma: Determinar se N é primo .................................................................. 21 
Figura 1.6– Fluxograma: Múltiplos de 3 entre 1 e N................................................................. 22 
Figura 1.7 – Fluxograma: múltiplos de 3 e 5 entre 1 e N .......................................................... 23 
Figura 5.AA – While com Contador .......................................................................................... 77 
Figura 5.BB – Pares entre 1 e 10 com WHILE ........................................................................... 78 
Figura 5.CC .............................................................................................................................. 79 
Figura 5.DD – While ................................................................................................................ 80 
Figura 5.EE – Repeat Until de 1 a 10 ........................................................................................ 83 
Figura 5.FF ..............................................................................................................................85 
Figura 6.XYZ ............................................................................................................................ 86 
Figura 7 ................................................................................................................................... 87 
 
Edeyson Andrade Gomes www.edeyson.com.br 
8 Programação com Pascal 
 
 
INTRODUÇÃO À PROGRAMAÇÃO 
 
Um dos maiores desafios para um professor de programação é fazer com que seus 
alunos consigam descrever detalhadamente uma solução para um problema. Fazê-los 
entender um problema não é o mais difícil, todavia, fazê-los organizar uma linha de 
raciocínio para uma solução que seja coerente, efetiva e eficaz não é trivial. 
 
As principais dificuldades apresentadas estão na abstração da solução, como verbalizar 
o entendimento desta e como garantir que ela seja completa. Comumente encontramos 
soluções de alunos que omitem passos que são considerados óbvios. 
 
Este livro tem como objetivo ajudar o aluno a desenvolver a habilidade de descrever 
soluções computacionais coerentes, sem ambigüidades e completas. Para isto, foca-se o 
desenvolvimento do raciocínio lógico baseando-se num universo de problemas da 
matemática e física do ensino médio. 
 
Alunos do ensino médio são confrontados com problemas como a extração de raízes de 
uma equação do segundo grau. Para a solução, aprendem um conjunto ordenado de 
passos. São estes que compõem um algoritmo. 
 
Um algoritmo descreve detalhadamente uma seqüência finita e ordenada de passos 
necessários à solução de um determinado problema ou uma classe de problemas. É uma 
forma de descrever possíveis soluções a problemas do mundo real, objetivando sua 
implementação no mundo computacional. 
 
Por exemplo, toda equação do segundo grau pode ser resolvida (terá suas raízes 
extraídas) por uma solução que se espera possuir a 5 características importantes de um 
algoritmo: 
 
1. Finitude: Todo algoritmo deve sempre terminar após um número finito 
de passos. 
2. Definição: Cada passo de um algoritmo deve ser definido de forma clara. 
a. As ações devem ser definidas rigorosamente e sem ambigüidades 
para que não sejam cometidos erros durante a resolução do 
problema. 
3. Entradas: Um algoritmo deve ter zero ou mais entradas. 
a. Por exemplo, uma equação do segundo grau precisa informar os 
valores de a, b e c, pois sua forma é ax
2
 + bx + c. 
4. Saídas: Um algoritmo deve ter uma ou mais saídas. 
a. Por exemplo, uma equação de segundo grau tem duas raízes. 
5. Efetividade: Um algoritmo deve ser efetivo. 
a. Todas as operações devem ser suficientemente básicas de modo 
que possam ser executadas com precisão em um tempo finito por 
um humano usando papel e lápis. 
1 
 
9 Introdução à Programação 
b. Cada passo da solução deve ser simples, embora sua composição 
leve a solução de algo complexo. 
 
A construção de um algoritmo deve seguir os 6 passos seguintes: 
 
1. Compreender o problema, descrevendo-o de forma clara e precisa. 
a. Um problema só pode ser resolvido se for bem entendido, o que 
requer uma descrição compreensível e clara. 
2. Identificar os dados de entrada e saída. 
a. Todo problema tem 0 ou mais dados de entrada. 
i. Por exemplo, uma equação do segundo grau tem 3 dados 
de entrada (a, b e c). 
b. Todo problema tem 0 ou mais dados de saída. 
i. Por exemplo, uma equação do segundo grau onde delta é 
menor que zero não possui raízes, logo, não tem dados de 
saída. 
3. Determinar o que é preciso para transformar dados de entrada em 
dados de saída: 
a. Definição de uma seqüência de passos que permitam a solução de 
maneira automática e repetitiva. 
i. usar a estratégia top-down1, sempre buscando passos 
simples que sejam compostos na solução; 
ii. observar regras e limitações; 
1. Como exceções ao problema. 
iii. identificar todas as ações a realizar; 
1. Passos simples para a solução. 
iv. eliminar possíveis ambigüidades. 
4. Construir o algoritmo. 
5. Testar o algoritmo. 
6. Executar o algoritmo. 
 
Um algoritmo bem definido e estruturado garante sua compreensão por terceiros em 
qualquer linguagem de programação. 
 
Um grave problema que se destaca na elaboração de algoritmos é que se ele não for 
descrito de forma padronizada e estruturada, possivelmente não seja compreendido por 
outras pessoas, apenas por seus criadores. 
 
 
1
 A estratégia top-down consiste em dividir um problema em partes menores e extremamente simples 
(subproblemas) de modo que seja mais fácil a sua resolução. 
 
Edeyson Andrade Gomes www.edeyson.com.br 
10 Programação com Pascal 
Para evitar esse possível problema, algoritmos costumam ser representados de três 
formas, como seguem: 
 
1. Linguagem Natural: Os algoritmos são descritos detalhadamente em 
linguagem natural. Por exemplo, em português estruturado. 
2. Fluxograma: Os algoritmos são representados graficamente. 
a. Usam-se formas geométricas padronizadas para descrever ações e 
decisões na resolução do problema. 
3. Pseudo-linguagem: Os algoritmos são descritos através de uma 
linguagem intermediária entre a linguagem natural e uma linguagem de 
programação. 
 
Um exemplo de uso de Linguagem Natural está na especificação de como criar um 
XBurger. Uma possível solução está a seguir: 
 
1. Início do Algoritmo XBurger. 
a. Pegar um pão; 
b. Abrir o pão ao meio; 
c. Passar manteiga no pão; 
d. Colocar queijo no pão; 
e. Colocar presunto no pão; 
f. Colocar ovo frito no pão; 
g. Fechar o pão. 
2. Fim do Algoritmo XBurger. 
 
Algumas perguntas que podem surgir ao leitor são: 
1. Onde estavam a manteiga, o queijo e o presunto? 
2. Quem fritou o ovo? Isso faz parte do algoritmo? 
a. Podemos definir um algoritmo fritar ovo e reusá-lo? 
 
A especificação de um algoritmo deve ser tão detalhada quanto possível para evitar 
dúvidas ou ambigüidades. Tais perguntas deveriam ser respondidas numa especificação 
mais clara e detalhada do Algoritmo XBurger. Por exemplo, pode-se definir que o 
algoritmo tem como entrada um pão, um ovo frito (não faz parte do algoritmo fritar o 
ovo), manteiga, queijo e presunto. Como dado de saída tem-se o sanduíche. 
 
Outro exemplo em Linguagem Natural é como extrair as raízes de uma equação do 
segundo grau na forma ax
2
 + bx + c. 
Sabe-se que: 
a. ∆ = b2 - 4ac 
b. x1 = (-b + √∆) / 2a 
c. x2 = (-b - √∆) / 2a 
d. a deve ser diferente de 0 
e. ∆ deve ser maior que zero para ter raízes reais 
 
11 Introdução à Programação 
 
A definição do algoritmo, em linguagem natural, para extrair as raízes de uma equação 
do segundo grau pode ser a seguinte: 
 
1. Início do Algoritmo Raízes 
a. Obter os coeficientes a, b e c. 
b. Se a é igual a zero, informar que esta é uma equação de 1º grau e 
terminar o algoritmo. 
c. Caso contrário, faça 
i. Calcular delta = b2 - 4ac 
ii. Se delta for negativo, informar que a equação não tem raízes 
reais e terminar o algoritmo. 
iii. Caso contrário, faça 
1. Calcular x1= (-b + √∆)/(2a) 
2. Calcular x2= (-b – √∆)/(2a) 
3. Fornecer como resultado x1 e x2 
4. Terminar o algoritmo. 
2. Fim do Algoritmo Raízes 
 
Como se pode notar, a definição do Algoritmo Raízes especifica detalhadamente como 
calcular as raízes de uma equação do segundo grau. Caso o leitor ainda tenha dúvida 
sobre o mesmo, outro recurso de representação pode ser usado, como é o caso do 
fluxograma da Figura 1.1 (detalhes de uso de fluxogramas estão no Apêndice A). 
 
 
Figura 1.1 - Fluxograma de Raízes de Equação do 2º Grau 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
12 Programação com Pascal 
Outra forma de representação seria via linguagem próxima de uma linguagem de 
programação de alto nível, ou Pseudocódigo. Neste caso, aproxima-se bastante da 
programação. 
A programação consiste na codificação precisa de um algoritmo segundo uma 
linguagem de programação específica. Um programa é umaformalização de um 
algoritmo em uma determinada linguagem de programação, segundo suas regras de 
sintaxe e semântica, de forma a permitir que o computador possa entender sua seqüência 
de ações. 
 
A proposta deste livro é ensinar algoritmos e programação através de múltiplos meios 
de representação e usando a linguagem de programação Pascal. 
 
1.1 Exemplos 
 
Os exemplos a seguir e apresentam problemas e suas respectivas possíveis soluções 
usando linguagem natural e seu fluxograma. 
 
1.1.1 Ler 3 valores distintos e determinar qual o maior, o menor e o mediano. 
Antes de resolver o problema, vamos ilustrá-lo com algumas situações: 
a. Números [3, 5, 8] 
Ao ler 3, maior = 3. 
Ao ler 5, maior = 5 e mediano = 3 
Note que o mediano assumiu o valor antigo do maior (mediano = 
maior) e maior ficou igual a n (maior = n). 
Ao ler 8, maior = 8, mediano = 5, menor = 3 
Note que o menor assumiu o valor antigo do mediano (menor = 
mediano), mediano assumiu o valor antigo do maior (mediano = 
maior) e maior ficou igual a n (maior = n). 
 
b. Números [8, 5, 3] 
Ao ler 8, maior = 8. 
Ao ler 5, maior = 8 e mediano = 5 
Ao ler 3, maior = 8, mediano = 5, menor = 3 
 
c. Números [3, 8, 5] 
Ao ler 3, maior = 3. 
Ao ler 8, maior = 8 e mediano = 3 
Note que o mediano assumiu o valor antigo do maior (mediano = 
maior) e maior ficou igual a n (maior = n). 
Ao ler 5, maior = 8, mediano = 5, menor = 3 
Note que o menor assumiu o valor antigo do mediano (menor = 
mediano), mediano assumiu o valor de n (mediano = n). 
 
Quais os passos do Algoritmo que se deseja? Vejamos: 
 
 
13 Introdução à Programação 
1. Como foi lido um primeiro valor, podemos presumir que ele é o maior, pois 
só existe ele. 
a. Pense em três alunos chegando numa sala: ao chegar o primeiro 
aluno, quem é o mais velho da sala? Por isso maior é igual a n no 
início. 
2. Outro valor é lido para n. Notem que é o segundo valor. 
3. Se o segundo valor lido é maior que o maior valor conhecido (n > maior), 
então ele deve ser o maior conhecido (maior = n). Neste caso, o mediano 
assume o valor do antigo maior conhecido. 
a. Em caso contrário (o segundo valor lido é menor que o maior 
conhecido), como é o segundo valor, ele passa a ser o mediano. Note 
que ainda não sabemos quem é o menor. 
4. Outro valor é lido para n. Notem que é o terceiro valor. 
5. Se o terceiro valor lido é o maior conhecido, então o menor assume o valor 
do mediano, o mediano assume o valor do maior anterior e o maior assume o 
valor de n. Em caso contrário, se o terceiro valor lido é maior que o mediano, 
o menor assume o valor do mediano anterior e n passa a ser o mediano. 
Senão, ele é o menor conhecido (menor = n). 
6. Imprime os valores. 
 
 
Vejamos o Algoritmo em Linguagem Natural: 
 
a. Início do Algoritmo 
1. Ler valor para n 
2. Atribuir n a maior. 
3. Ler valor para n. 
4. Se n > maior, atribuir maior a mediano e n a maior. Senão, 
atribuir n a mediano. 
5. Ler valor para n. 
6. Se n > maior, atribuir mediano a menor, maior a mediano e n a 
maior. 
7. Senão, se n > mediano, atribuir mediano a menor e n a 
mediano. Senão, atribuir n a menor. 
8. Imprimir os valores de menor, mediano e maior. 
b. Fim do Algoritmo 
 
 
Teste do Algoritmo – Valores 1, 7, 15 
Passo 1: n = 1 
Passo 2: maior = 1 
Passo 3: n = 7 
Passo 4: mediano = 1 
maior = 7 
Passo 5: n = 15 
Passo 6: menor = 1 
mediano = 7 
maior = 15 
 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
14 Programação com Pascal 
Teste do Algoritmo – Valores 6, 2, 4 
Passo 1: n = 6 
Passo 2: maior = 6 
Passo 3: n = 2 
Passo 4: maior = 6 
mediano = 2 
Passo 5: n = 4 
Passo 6: maior = 6 
menor = 2 
mediano = 4 
 
A seguir a Figura 1.2 ilustra o Fluxograma do algoritmo proposto. 
Início
n > maior
n
maior = n
n
mediano = maior
maior = n
mediano = n
V
F
n
n > maior
menor = mediano
mediano = maior
maior = n
V F
n > mediano
menor = mediano
mediano = n
V
menor = n
F
menor, 
mediano, 
maior
Fim
 
Figura 1.2 - Fluxograma: Ordenar 3 números distintos 
 
 
15 Introdução à Programação 
1.1.2 Imprimir o número 5 dez vezes. 
A solução deste simples problema cai no que chamamos de repetição. Devemos repetir 
a impressão do número 5 dez vezes. Uma solução trivial seria: 
 
Início do Algoritmo 
1. Imprimir o número 5 
2. Imprimir o número 5 
3. Imprimir o número 5 
4. Imprimir o número 5 
5. Imprimir o número 5 
6. Imprimir o número 5 
7. Imprimir o número 5 
8. Imprimir o número 5 
9. Imprimir o número 5 
10. Imprimir o número 5 
Fim do Algoritmo 
 
O algoritmo proposto acima está correto. Porém, como seria a solução caso se deseje 
imprimir o número 5 um milhão de vezes? Terá um milhão de linhas? 
 
A solução proposta é usar a linguagem natural para informar a repetição de algo, como 
segue: 
 
Início do Algoritmo 
1. Fazer 10 vezes 
a. Imprimir o número 5 
Fim do Algoritmo 
 
Note que um laço Faça algo N vezes (algo pode ser um comando ou um bloco de 
comandos) é criado assim num Fluxograma: 
1. Cria-se uma variável de controle iniciada com 1. 
2. Testa-se se a variável de controle é menor ou igual a N. 
3. Executa-se o comando ou bloco de comandos. 
4. Incrementa-se a variável de controle. 
5. Volta-se ao passo 2 (esta volta é que constrói o laço). 
 
Vejamos isso no Fluxograma ilustrado na Figura 1.3. 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
16 Programação com Pascal 
Início
Fim
Conta = 1
Conta <= 10
Conta = Conta 
+ 1
5
V
F
Conta é a 
variável de 
controle
Este teste controla 
quantas vezes o
 laço será executado
O incremento em 1 
garante 
que Conta mude de 
valor
 
Figura 1.3 - Fluxograma: Imprimir o número 5 dez vezes 
 
 
1.1.3 Imprimir todos os números naturais entre 1 e N. 
 
A solução deste problema necessita de um laço de repetição. Devemos repetir a 
impressão de um número contido no intervalo [1, N]. Uma solução possível é: 
 
Início do Algoritmo 
a. Ler N 
b. Faça a variável valor variar entre todos os valores no intervalo [1 e N] 
i. Imprima valor 
Fim do Algoritmo 
 
Note que necessitaremos novamente de um laço Faça algo N vezes (algo aqui será a 
impressão de um número natural. O problema é bem parecido com o anterior, pois inicia 
em 1 e varia até N. Logo, vamos à mesma solução: 
1. Cria-se uma variável de controle iniciada com 1. 
2. Testa-se se a variável de controle é menor ou igual a N, pois se desejam os 
números entre 1 e N, inclusive. 
3. Imprime-se o valor da variável de controle, pois ela será o próprio número no 
intervalo. 
4. Incrementa-se a variável de controle em 1, pois tem-se uma sequência de 
números naturais. 
5. Volta-se ao passo 2 (esta volta é que constrói o laço). 
 
 
 
17 Introdução à Programação 
Uma revisão do algoritmo em linguagem natural é a seguinte: 
 
Início do Algoritmo 
 Leia um valor inteiro para N 
 Faça valor igual a 1 
 Enquanto valor <= N Faça 
 Imprima valor 
 valor = valor + 1 
Fim do Algoritmo 
 
 
Teste do Algoritmo: 
 
Ler N – suponha que N seja 5 
Faça a variável valor variar entre todos os valores no intervalo [1 e 5] – logo, 
valor assumirá os seguintes valores {1, 2, 3, 4, 5} 
Serão impressos os valores 1, 2, 3, 4, 5 
 
Vejamos isso no Fluxograma ilustrado na Figura 1.4. 
 
Início
n
valor = 1
valor <= n
valor
V
valor = valor + 1
FimN
 
Figura 1.4 – Fluxograma: Números naturais entre 1 e N 
Notem que neste fluxograma há um Laço de repetição de N vezes. O controle do laço é 
feito no teste (condição valor <= n), ou seja, valor inicia com 1 e varia até n. O teste 
garante que valor não será maior que n. Se valor for menor ou igual a n, imprime-se o 
valor e soma-se um a ele para que este assuma o próximo número no intervalo [1, N]. 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
18 Programação com Pascal 
 
1.1.4 Determinar todos os divisores naturais de um número natural N. 
Dado um valor N, imprimir todos os seusdivisores. 
 
Por exemplo, supondo N = 12, como saber seus divisores? Uma solução é testar 
todos os números entre 1 e 12. O teste é para saber se algum destes números 
divide 12, ou seja, se o resto da divisão de 12 por cada um deles é zero. 
 
Início do Algoritmo 
a. Ler N 
b. Faça a variável Divisor variar entre todos os valores no intervalo [1 e N] 
i. Para cada valor de Divisor faça: 
1. Atribua à variável Resto o resto da divisão de N por 
Divisor. 
2. Se Resto = 0, então imprima o valor de Divisor 
Fim do Algoritmo 
 
Veja que a letra b do algoritmo faz com que todos os números entre 1 e N sejam 
testados. Outra forma de escrever o algoritmo, mais próximo da programação, é: 
 
Início do Algoritmo 
a. Leia um valor inteiro para N 
b. Faça Divisor igual a 1 
c. Enquanto Divisor <= N Faça 
Resto = N MOD Divisor 
SE (Resto = 0) ENTÃO 
 Imprima Divisor 
 Divisor = Divisor + 1 
Fim do Algoritmo 
 
 
Teste do Algoritmo: 
Ler N – suponha que N seja 8 
 
Faça a variável Divisor variar entre todos os valores no intervalo [1 e 8] 
 – logo, Divisor assumirá os seguintes valores {1, 2, 3, 4, 5, 6, 7, 8} 
 
Para cada valor de Divisor faça: 
1. Atribua à variável Resto o resto da divisão de N por Divisor (8/1). 
Logo, Resto = 0. Imprime 1. 
2. Atribua à variável Resto o resto da divisão de N por Divisor (8/2). 
Logo, Resto = 0. Imprime 2. 
3. Atribua à variável Resto o resto da divisão de N por Divisor (8/3). 
Logo, Resto = 2. Não Imprime. 
 
19 Introdução à Programação 
4. Atribua à variável Resto o resto da divisão de N por Divisor (8/4). 
Logo, Resto = 0. Imprime 4. 
5. Atribua à variável Resto o resto da divisão de N por Divisor (8/5). 
Logo, Resto = 3. Não Imprime. 
6. Atribua à variável Resto o resto da divisão de N por Divisor (8/6). 
Logo, Resto = 2. Não Imprime. 
7. Atribua à variável Resto o resto da divisão de N por Divisor (8/7). 
Logo, Resto = 1. Não Imprime. 
8. Atribua à variável Resto o resto da divisão de N por Divisor (8/8). 
Logo, Resto = 0. Imprime 8. 
 
Resultado: serão impressos {1, 2, 4, 8} 
 
Vejamos isso no Fluxograma ilustrado na Figura 1.5. 
 
Início
N
Divisor <= N FimF
Resto = resto da divisão 
de N por Divisor
Divisor = 1
Divisor = 
Divisor + 1
V
F
Resto = 0 DivisorV
 
Figura 1.5 – Fluxograma: Divisores naturais de N 
Note que o passo b do algoritmo (Faça a variável Divisor variar entre todos os valores 
no intervalo [1 e N]) é destacado no fluxograma. 
 
 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
20 Programação com Pascal 
1.1.5 Determinar se um número natural N é primo 
 
A principal diferença deste algoritmo para o anterior (1.1.4) é que não serão impressos 
os divisores de um número, e sim, contados (precisamos de uma variável para isso). 
Vale lembrar que um número primo tem apenas dois divisores. 
 
Início do Algoritmo 
a. Definir a variável contaDivisores com valor inicial 0 
b. Ler N 
c. Faça a variável Divisor variar entre todos os valores no intervalo [1 e 
N] 
i. Para cada valor de Divisor faça: 
1. Atribua à variável Resto o resto da divisão de N por 
Divisor. 
2. Se Resto = 0, então some 1 a contaDivisores 
d. Se contaDivisores > 2, então o número não é primo. 
e. Senão, ele é primo. 
Fim do Algoritmo 
 
Note que a letra d do Algoritmo só será executada após o laço da letra c ser 
concluído (testar todos os divisores no intervalo [1, N]. 
 
Vejamos isso no Fluxograma ilustrado na Figura 1.6. 
 
 
21 Introdução à Programação 
Início
N
Divisor <= N F
Resto = resto da divisão 
de N por Divisor
Divisor = 1
Divisor = 
Divisor + 1
V
F
Resto = 0 V
contaDivisores = 0
contaDivisores = 
contaDivisores + 1
Fim
contaDivisores > 2
N não é 
primo
N é primo
V
F
 
Figura 1.6 – Fluxograma: Determinar se N é primo 
 
 
1.1.6 Imprimir todos os múltiplos de 3 compreendidos entre 1 e N (naturais). 
Início do Algoritmo 
a. Ler N 
b. Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e 
N] 
i. Atribua à variável Resto o resto da divisão de Múltiplo por 3. 
ii. Se Resto = 0, então imprima o valor de Múltiplo. 
Fim do Algoritmo 
 
 
Teste do Algoritmo: 
 
Ler N – suponha que N seja 10 
Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e 10] 
Serão impressos os valores 3, 6, 9 
 
Vejamos isso no Fluxograma ilustrado na Figura 1.7. 
 
Edeyson Andrade Gomes www.edeyson.com.br 
22 Programação com Pascal 
Início
N
Múltiplo <= N FimF
Resto = resto da divisão 
de Múltiplo por 3
Múltiplo = 1
Múltiplo = 
Múltiplo + 1
V
F
Resto = 0 MúltiploV
 
Figura 1.7 – Fluxograma: Múltiplos de 3 entre 1 e N 
 
 
1.3.7 Imprimir todos os múltiplos de 3 e 5 (simultaneamente) compreendidos entre 1 e 
N (naturais). 
Início do Algoritmo 
c. Ler N 
d. Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e 
N] 
iii. Atribua à variável Resto3 o resto da divisão de Múltiplo por 3. 
iv. Atribua à variável Resto5 o resto da divisão de Múltiplo por 5. 
v. Se Resto3 = 0 e Resto5 = 0, então imprima o valor de Múltiplo. 
Fim do Algoritmo 
 
 
Teste do Algoritmo: 
 
Ler N – suponha que N seja 30 
Faça a variável Múltiplo variar entre todos os valores no intervalo [1 e 30] 
Serão impressos os valores 15, 30 
 
Vejamos isso no Fluxograma ilustrado na Figura 1.8. 
 
 
23 Introdução à Programação 
Início
N
Múltiplo <= N FimF
Resto3 = resto da divisão de 
Múltiplo por 3
Resto5 = resto da divisão de 
Múltiplo por 5
Múltiplo = 1
Múltiplo = 
Múltiplo + 1
V
F
Resto3 = 0 
e 
Resto5 = 0
MúltiploV
 
Figura 1.8 – Fluxograma: múltiplos de 3 e 5 entre 1 e N 
 
 
1.3.8 Dado um registro com o seguinte leiaute: 
 
Nome Nota1 Nota2 Nota3 
 
Escreva um algoritmo que leia um arquivo com N registros no leiaute acima e imprima 
um relatório com alunos aprovados e outro com alunos reprovados. 
Um aluno está aprovado apenas de tiver média (aritmética) das notas maior ou igual a 
7,0. Considere em sua solução que só existe uma impressora na execução do algoritmo. 
 
Início do Algoritmo 
1. Criar uma coleção de alunos aprovados e outra de reprovados 
2. Enquanto houver registros no arquivo faça: 
a. Ler registro 
b. Fazer media = (nota1 + nota2 + nota3) / 3 
c. Se média maior ou igual a 7.0, inclua o aluno na coleção de 
aprovados, senão coloque-o na coleção dos reprovados 
3. Enquanto houver registros na coleção Aprovados faça: 
a. Imprima registro 
4. Enquanto houver registros na coleção Reprovados faça: 
a. Imprima registro 
Fim do Algoritmo 
 
Edeyson Andrade Gomes www.edeyson.com.br 
24 Programação com Pascal 
 A LINGUAGEM PASCAL 
 
 
 
 
A linguagem Pascal foi desenvolvida no início da década de 1970 por Nicklaus Wirth, 
na Universidade Técnica de Zurique, Suíça. O primeiro compilador para a linguagem 
foi disponibilizado em 1970. 
 
O objetivo do Pascal é ser uma linguagem de programação de alto nível voltada ao 
ensino da programação estruturada. Por ser simples, é ideal para a introdução à 
programação. 
 
2.2 Estrutura de um Programa Pascal 
 
Todo programa em Pascal é dividido em três áreas distintas: cabeçalho, área de 
declarações e corpo. 
 
 
 
 
2.2.1 Cabeçalho 
 
O cabeçalho é uma área utilizada para que se possa identificar um programa através de 
um nome (instrução program). 
 
 
 
 
 
Exemplo: 
 
 
 
 
2 
corpo 
área de declarações 
program adicionaNumeros; 
 
corpo 
área de declarações 
cabeçalho 
 
{Sintaxe:} 
program nomeDoPrograma; 
 
25 A LINGUAGEM PASCAL 
 
 
O programa da Listagem 1.1, chamado de adicionaNumeros, iniciaria assim: 
 
 
Listagem 1.1 - Cabeçalho de programa Pascal. 
Note que no trecho de programa da Listagem 1.1 anterior, a linha 2 apresenta um 
comentário, pois está entre { }. A linha 1 usa a instrução program para dar nome ao 
programa. No caso, adicionaNumeros. 
 
 
 
 
2.2.2 Área de Declarações 
 
A Área de Declarações de um programa é utilizada paracriar identificadores que não 
sejam predefinidos. 
 
Todo objeto que quisermos usar num programa precisa ser identificado por um nome 
único. Um cuidado que se deve ter é que Pascal predefine nomes como integer, real, 
boolean, etc. 
 
A área de declarações pode ser subdividida em sete subáreas: uses, label, const, type, 
var, procedure e function. Cada uma delas será explicada em seu devido momento. 
 
Utilização de Units 
 
As units são conjuntos de funções que já estão prontas para serem usadas pelo 
programador. Por exemplo, se quisermos limpar a tela ou ler o teclado já existem 
funções prontas para isso nas units, evitando o trabalho de reescrevê-las. São elas: 
 
1. CRT: possui a maior parte das rotinas e variáveis de geração de som, controle de 
vídeo e teclado; 
 
2. DOS: possui as rotinas que envolvem a utilização do sistema operacional; 
 
3. GRAPH: possui rotinas destinadas a manipulações gráficas; 
 
Observações: 
1. Nossos programas sempre aparecerão em caixas como a da Listagem 1.1. 
2. O uso de { } serve para definir comentários: descrições ou informações, em texto livre, 
que auxiliem no entendimento do código. 
Observações: 
1. O nome de um programa é um identificador e deve ser único neste. 
1. program adicionaNumeros; 
2. {Programa que lê 2 números e imprime sua soma.} 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
26 Programação com Pascal 
4. OVERLAY: possibilita gerenciar as atividades de um programa economizando 
memória; 
 
5. PRINTER: permite declarar um arquivo tipo texto com o nome LST e associá-
lo à impressora; 
 
6. SYSTEM: possui a maior parte das rotinas padrão da linguagem Pascal e é 
usada de forma automática. 
 
Para se fazer uso de units é necessário o uso da instrução uses antes da declaração da 
instrução var. 
 
 
 
Nosso programa continuaria como apresenta a Listagem 1.2. 
 
 
Listagem 1.2 – Utilização de Unit. 
Note que no programa da Listagem 1.2 as linhas 2 e 4 apresentam comentários, pois 
estão entre { }. 
 
A linha 1 usa a instrução program para dar nome ao programa (adicionaNumeros). A 
linha 5 usa a instrução uses para habilitar as funções da biblioteca CRT. 
 
 
Declaração de Variáveis 
 
Nos problemas comuns da matemática e física nos deparamos com variáveis. Por 
exemplo, uma equação do segundo grau
2
 possui a forma: ax
2
 + bx + c. Logo, são 
exemplos de equação do segundo grau: x
2
 + 2x + 1 e 2x
2
 + 3x + 4. 
 
Cabe-nos observar que as equações do 2º grau variam, entre si, sempre num aspecto: os 
valores de a, b e c. Para a matemática, a, b e c são constantes (coeficientes), pois a 
equação 2x
2
 + 3x + 4 já tem tais valores definidos. 
 
 
2
 Toda equação da forma ax² + bx + c = 0, em que a, b e c são números reais com a ≠ 0, é chamada de 
equação do 2° grau. Quando b = 0 ou c = 0 tem-se uma equação do 2º grau incompleta. 
Observações: 
1. Comentários são textos livres, escritos dentro do código-fonte para explicar e 
detalhar algo. Não são compilados e não contam como linha de código – LOC (Line 
of Code). 
 
1. program adicionaNumeros; 
2. {Programa que lê 2 números e imprime sua soma.} 
 
4. {Usa a biblioteca CRT onde está a função ReadKey: Lê Tecla} 
5. uses crt; 
 
{Sintaxe:} 
uses nomeDaUnidade; 
 
27 A LINGUAGEM PASCAL 
Para a programação, se quisermos montar uma equação do segundo grau a partir da 
fórmula ax
2
 + bx + c, precisamos saber a parte que varia entre elas, ou seja, as variáveis 
para o algoritmo: a, b e c. Pode-se afirmar que a, b e c serão as variáveis de entrada do 
algoritmo e as raízes, sua saída. 
 
Da mesma forma, na física temos a fórmula da velocidade na forma: v = vo + at
2
. Para 
sabermos a velocidade final de um corpo, precisamos conhecer os valores das variáveis: 
velocidade inicial, aceleração e tempo. 
 
Sempre que tivermos um problema a resolver, o que mudar entre um problema e outro 
similar são variáveis para o algoritmo. 
 
Para a solução de problemas como os citados são necessárias variáveis declaradas num 
programa, o que é feito via a instrução var. Cada variável tem um nome único no 
programa (identificador) e um tipo (inteiro, real, lógico, etc). 
 
 
 
 
 
Nosso primeiro programa continuaria como apresenta a Listagem 1.3. 
 
 
Listagem 1.3 – Declaração de Variáveis. 
 
Note que na Listagem 1.3 a linha 8 apresenta a instrução var iniciando uma área de 
declaração de variáveis. A linha 9 define duas variáveis inteiras chamadas a e b e a 
linha 10 define uma variável do tipo inteira (integer) chamada soma. 
 
2.2.3 Corpo do Programa 
 
 1 program adicionaNumeros; 
 2 {Programa que lê 2 números e imprime sua soma.} 
 
 4 {Usa a biblioteca CRT onde está a função ReadKey} 
 5 uses crt; 
 
 7 {Declara a, b e soma como variáveis inteiras} 
 8 var 
 9 a, b : integer; 
10 soma : integer; 
 
Observações: 
1. Após o nome de cada variável deve ser utilizado o símbolo dois-pontos ( : ) seguido pelo 
tipo de dado que a variável irá receber, seguido de ponto-e-vírgula. 
2. Caso as variáveis sejam de mesmo tipo, estas poderão ser relacionadas separadas por 
vírgula. Por exemplo: var a, b, c : integer; Isso define as variáveis a, b e c como sendo do 
tipo integer (inteira). 
{Sintaxe:} 
var nomeDaVariável : tipo de dado; 
 nomeDeOutraVariável : tipo de dado; 
 
Edeyson Andrade Gomes www.edeyson.com.br 
28 Programação com Pascal 
Um programa em Pascal está escrito numa área denominada corpo do programa que tem 
início com a instrução begin e é finalizada pela instrução end, seguida do símbolo 
ponto ( . ). O uso destas instruções caracteriza o que é chamado de bloco de comandos, 
como indicado abaixo: 
 
 
 
 
 
 
Nosso programa continuaria como apresenta a Listagem 1.4. 
 
 
Listagem 1.4 – Programa que lê 2 números e calcula a soma. 
 
Descrição do primeiro exemplo 
 
O objetivo do programa da Listagem 1.4 é efetuar a leitura de dois valores numéricos 
(variáveis a e b), fazer a operação de adição entre elas, atribuir o resultado à variável 
soma e apresentar o resultado obtido. Destaca-se o seguinte: 
 1 program adicionaNumeros; 
 2 {Programa que lê 2 números e imprime sua soma.} 
 
 4 {Usa a biblioteca CRT onde está a função ReadKey} 
 5 uses crt; 
 
 7 {Declara a, b e soma como variáveis inteiras} 
 8 var 
 9 a, b : integer; 
10 soma : integer; 
 
12 begin 
13 {limpa a tela} 
14 clrscr; 
 
16 {escreve no prompt de comandos} 
17 writeln('Insira o valor de a: '); 
19 {esperando que o usuário digite algo e atribui à variável a} 
20 readln(a); 
 
22 writeln('Insira o valor de b: '); 
23 readln(b); 
 
25 {soma a com b e atribui o resultado a soma} 
26 soma := a + b; 
27 writeln('A soma de ', a, ' com ', b, ' eh ', soma); 
 
29 {para o programa até que alguma tecla seja pressionada} 
30 readkey; 
31 end. 
 
Observações: 
1. O corpo do programa pode conter vários blocos. 
{Sintaxe:} 
begin 
instruções do programa; 
end. 
 
 
29 A LINGUAGEM PASCAL 
 
1. O corpo do programa está delimitado pelas linhas 12 (begin) e 31 (end.). 
2. A linha 14 apresenta uma instrução (clrscr) usada para limpar a tela. 
3. As linhas 17, 22 e 27 usam uma instrução (writeln) para imprimir na tela. 
4. As linhas 20 e 23 usam uma instrução (readln) para ler um valor do teclado e 
associar a uma variável. 
5. A instrução da linha 30 (readkey) para o programa até que algo seja teclado. 
 
Outra forma de representar o algoritmo adicionaNumeros é usando a Linguagem 
Natural, como segue: 
 
1. Início do Algoritmo adicionaNumeros 
a. Solicitar ao usuário para inserir o valor de a; 
b. Ler um valor para a variável a; 
c. Solicitar ao usuário para inserir o valor de b; 
d. Ler um valor para a variável b; 
e. Efetuar a soma das variáveis a e b, colocando o resultado na variável 
soma; 
f. Apresentar o valorda variável soma após a operação de soma dos dois 
valores fornecidos. 
g. Aguardar até que algo seja pressionado. 
2. Fim do Algoritmo adicionaNumeros. 
 
 
 
 
 
 
 
Vamos a outro exemplo comentado que serve para calcular a média aritmética de 3 
valores. Ele deve ler três variáveis numéricas (a, b e c) e calcular a média aritmética 
destas, apresentando o resultado obtido. 
 
Algoritmo usado em Linguagem Natural: 
 
1. Início do Algoritmo Média de 3 Números 
a. Solicitar ao usuário para digitar o valor da variável a; 
b. Ler um valor para a variável a; 
Observações: 
1. Os comandos read e readln são responsáveis por entrada de dados, como leitura pelo 
teclado. 
a. ReadLn(var) lê um valor do teclado e atribui à variável var. 
b. O programa fica parado até que a tecla ENTER seja pressionada. Tudo o que 
for digitado antes de ENTER será colocado na variável (var). 
2. Os comandos write e writeln são responsáveis por saída de dados, como impressão na 
tela. 
a. WriteLn(var) imprime o valor da variável (var) na tela. 
3. O uso de LN (acrônimo para New Line – Nova Linha) indica que uma nova linha deve ser 
usada após o comando. 
 
Edeyson Andrade Gomes www.edeyson.com.br 
30 Programação com Pascal 
c. Solicitar ao usuário para digitar o valor da variável b; 
d. Ler um valor para a variável b; 
e. Solicitar ao usuário para digitar o valor da variável c; 
f. Ler um valor para a variável c; 
g. Calcular a média como a soma de a, b e c dividida por 3. 
h. Imprimir os três valores lidos e a média. 
2. Terminar o Algoritmo Média de 3 Números. 
 
A implementação do Algoritmo Média de 3 Números é apresentada na Listagem 1.5. 
 
 
Listagem 1.5 - Programa que lê 3 variáveis e calcula a média. 
 
No programa da Listagem 1.5 destaca-se o seguinte: 
1. O cabeçalho do programa está entre as linhas 1 e 4. 
2. As declarações do programa estão entre as linhas 8 e 10. 
3. O corpo do programa está delimitado pelas linhas 12 e 27. 
4. As linhas 13, 16, 19, 23 e 24 usam instruções – writeln e write – para 
imprimir na tela. 
5. As linhas 14, 17 e 20 usam uma instrução para ler os valores de a, b e c, 
respectivamente. 
6. Na linha 22 calcula-se a média aritmética de a, b e c, atribuindo-a à variável 
media. 
7. A linha 24 imprime a média formatada com 3 dígitos decimais e 2 decimais. 
 
 
 
 1 {O programa deve ler 3 variaveis inteiras, calcular a media 
 aritmetica e atribuir a uma variavel media. 
 2 Qual deve ser o tipo da variavel media? Por que? 
 3 } 
 4 program media3N; 
 
 6 uses crt; 
 
 8 var 
 9 a, b, c : integer; 
10 media : real; 
 
12 begin 
13 writeln('Digite o valor da Variavel 1: '); 
14 readln(a); 
 
16 writeln('Digite o valor da Variavel 2: '); 
17 readln(b); 
 
19 writeln('Digite o valor da Variavel 3: '); 
20 readln(c); 
 
22 media := (a + b + c) / 3; 
23 write('A media entre ', a, ', ', b, ' e ', c, ' eh: '); 
24 writeln(media:3:2); 
 
26 readkey; 
27 end. 
 
 
31 A LINGUAGEM PASCAL 
 
 
 
 
Variáveis e Constantes 
 
Em Pascal, variáveis, constantes, tipos definidos pelo usuário, procedimentos e funções 
precisam de um nome que forneça uma identificação única e isso é feito através de 
identificadores. 
 
Nomes (identificadores) em Pascal devem seguir as seguintes regras de construção: 
1. Iniciar sempre por uma letra (a - z, A - Z) ou um underline (_); 
2. O restante do identificador deve conter apenas letras, underlines ou dígitos (0-
9). Não pode conter outros caracteres; e 
3. Pode ter qualquer tamanho, desde que os primeiros 63 caracteres sejam 
significativos. 
 
Não existe distinção entre letras maiúsculas e minúsculas no nome de um 
identificador. Por exemplo, os nomes ALPHA, alpha e Alpha são equivalentes para o 
Pascal. 
 
 
 
 
Palavras Reservadas 
 
Pascal reconhece certo grupo de palavras como sendo reservadas. Elas têm significado 
especial e não podem ser usadas como identificadores em um programa para objetos 
criados pelo programador. 
 
São elas: absolute, and, array, asm, begin, case, const, constructor, destructor, div, do, 
downto, else, end, file, for, function, goto, if, implementation, in, inherited, inline, 
interface, label, mod, nil, not, object, of, on, operator, or, packed, procedure, 
program, record, reintroduce, repeat, self, set, shl, shr, string, then, to, type, unit, 
until, uses, var, while, with, xor. 
Observações: 
1. CamelCase é a denominação em inglês para a prática de escrever palavras compostas, 
ou frases, onde cada palavra é iniciada com Maiúsculas e unidas sem espaços. 
a. É um padrão largamente utilizado em diversas linguagens de programação, 
como Java, Ruby e Python. 
b. Exemplos: NomeDoCliente, TipoDePeça, MediaPonderada, MediaDe3Numeros. 
Observações: 
1. A variável media precisa ser real, pois a divisão de inteiros nem sempre é um inteiro. Por 
exemplo, 7/3. 
2. O uso de media:3:2 na impressão significa que o resultado será formatado com 3 dígitos 
antes da vírgula e 2 dígitos depois. 
 
Edeyson Andrade Gomes www.edeyson.com.br 
32 Programação com Pascal 
 
Comentários 
 
Comentários são textos escritos dentro do código-fonte para explicar ou descrever 
alguns aspectos relativos ao mesmo ou para esclarecer detalhes de programação que 
podem não ficar claros. 
Seu principal objetivo é adicionar informação textual ao código, facilitando seu 
entendimento por leitores. 
 
A sintaxe requerida aos comentários permite o uso de chaves como em: { 
comentário } ou de parêntesis e asteriscos, como em: (* comentário *). 
 
 
2.1 Variáveis 
 
Uma variável é uma região da memória, identificada através de um nome, cujo valor 
pode mudar durante a execução do programa. Como Pascal é uma linguagem fortemente 
tipada, cada variável precisa obrigatoriamente de um tipo de dados predeterminado. 
 
 
 
 
Nesta especificação de sintaxe, variável tem seu tipo definido por tipo de dado. Note 
que variável1 e variável2 são definidas juntas, separadas por vírgulas e atribuindo-se um 
único tipo de dados. Isso pode ser feito para qualquer número de variáveis que 
compartilhem um mesmo tipo de dados. 
 
2.2 Constantes 
 
Uma constante é uma região rotulada da memória através de um nome cujo valor não 
pode mudar durante a execução do programa. Um exemplo de constante é o PI na 
matemática. 
 
 
 
2.3 Tipos de Dados 
 
Um tipo de dado especifica as características, ou seja, quais os possíveis valores e 
operações que um dado possui. Por exemplo, um valor inteiro pode ser somado a outro, 
{Sintaxe:} 
const 
nomeDaConstante = expressão; 
{Sintaxe:} 
var 
 variável : tipo de dado; 
 variável1, variável2 : tipo de dado2; 
 
33 A LINGUAGEM PASCAL 
subtraído, multiplicado, etc. Variáveis, como apresentado em sua sintaxe, requerem um 
tipo de dado em sua definição. 
 
A linguagem Pascal fornece ao programador um conjunto de tipos de dados 
predefinidos e que serão descritos a seguir. 
 
Inteiros 
 
Inteiros são valores numéricos positivos ou negativos, excluindo-se qualquer número 
fracionário. Em Pascal, este tipo de dado pode ser referenciado por um dos seguintes 
identificadores: Byte, Shortint, Smallint, Word, Integer, Cardinal, Longint, 
Longword, Int64 e QWord. 
 
 
Tabela 2.1 – Tipos Inteiros 
Tipo Valores 
Tamanho 
em Bytes 
Byte 0..255 1 
Shortint -128 .. 127 1 
Smallint -32768 .. 32767 2 
Word 0 .. 65535 2 
Integer Smallint ou Longint 2 ou 4 
Cardinal Longword 4 
Longint -2147483648 .. 2147483647 4 
Longword 0 .. 4294967295 4 
Int64 -9223372036854775808 .. 
9223372036854775807 
8 
QWord 0 .. 1844674473709551615 8 
 
A definição de variáveis inteiras é feita com a seguinte sintaxe: 
 
 
 
A Listagem 6 apresenta um exemplo de uso de Inteiros. 
 
Listagem 2.1 – Exemplo de uso de Inteiros 
No programa da Listagem 6 destaca-se o seguinte: 
1. Na linha 7 declara-se a variável forca do tipo integer.1 program InteirosEmPascal; 
 2 {Este programa vai demonstrar o uso de Inteiros em Pascal.} 
 
 4 uses crt; 
 
 6 var 
 7 forca : integer; 
 8 massa, aceleracao : integer; 
 
 9 begin 
10 massa := 100; 
11 aceleracao := 2; 
12 forca := massa * aceleracao; 
13 writeln ('A forca eh: ', forca); 
14 readkey; 
15 end. 
 
{Sintaxe:} 
variável : integer; 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
34 Programação com Pascal 
2. A linha 8 apresenta a declaração de duas variáveis inteiras: massa e 
aceleração. Embora as três variáveis pudessem ter sido declaradas numa 
única linha, optou-se por duas declarações separadas para exemplificação. 
3. Na linha 10 atribui-se o valor 100 à variável massa, enquanto na linha 11 
atribui-se 2 à variável aceleração. 
4. Na linha 12 atribui-se à variável forca o produto entre massa e aceleração. 
5. A linha 13 imprime o valor resultante da forca. 
 
A execução do programa imprimirá: 
 
 
Reais 
 
O tipo de dado real permite trabalhar com números fracionários, tanto positivos como 
negativos, sendo sua capacidade de armazenamento maior que dos números inteiros. 
Vejamos os tipos: Real, Single, Double, Extend, Comp e Currency. 
 
Tabela 2.2 - Tipos Reais 
Tipo Valores 
Dígitos 
Signific. 
Tamanho 
em Bytes 
Real Depende da Plataforma 4 ou 8 
Single 1.5E-45 .. 3.4E38 7-8 4 
Double 5.0E-324 .. 1.7E308 15-16 8 
Extended 1.9E-4932 .. 1.1E4932 19-20 10 
Comp -2E64+1 .. 2E63-1 19-20 8 
Currency 
 
 
A definição de variáveis reais é feita com a seguinte sintaxe: 
 
 
 
A Listagem 7 apresenta um exemplo de uso de Reais. 
 
 
Listagem 2.2 – Uso de Reais em Pascal 
A forca eh: 200 
 1 program ReaisEmPascal; 
 2 {Este programa vai demonstrar o uso do tipo Real em Pascal.} 
 
 4 uses crt; 
 
 6 var 
 7 forca : real; 
 8 massa, aceleracao : real; 
 
 9 begin 
10 forca := 235; 
11 aceleracao := 2; 
12 massa := forca / aceleracao; 
13 writeln ('A massa eh: ', massa:3:2); 
14 readkey; 
15 end. 
 
{Sintaxe:} 
variável : real; 
 
 
35 A LINGUAGEM PASCAL 
 
No programa da Listagem 7 destaca-se o seguinte: 
1. Na linha 7 declara-se a variável forca do tipo real. 
2. A linha 8 apresenta a declaração de duas variáveis reais: massa e aceleração. 
Embora as três variáveis pudessem ter sido declaradas numa única linha, 
optou-se por duas declarações separadas para exemplificação. 
3. Na linha 10 atribui-se o valor 235 à variável forca, enquanto na linha 11 
atribui-se 2 à variável aceleração. 
4. Na linha 12 atribui-se à variável massa a razão entre forca e aceleração. 
5. A linha 13 imprime o valor resultante da massa. 
 
A execução do programa imprimirá: 
 
 
 
 
 
Caracteres 
String 
 
Tipos de Dados Caracteres em Pascal são seqüências contendo letras, números e 
símbolos especiais e devem ser representadas entre apóstrofos (‘’). Este tipo de dado é 
referenciado pelo identificador string, podendo armazenar de 1 até 255 caracteres. 
 
Para definir uma variável cujo conteúdo pode ter até 255 caracteres, usa-se a seguinte 
sintaxe: 
 
 
Como a sintaxe anterior não determina um tamanho, a variável definida sempre ocupará 
255 bytes na memória, pois o Pascal na tem como saber quantos bytes realmente serão 
necessários. 
 
Para o caso de variáveis String que o programador conheça o tamanho máximo, pode-se 
usar a seguinte sintaxe para determiná-lo 
 
A massa eh: 117.50 
Observações: 
1. Write e WriteLn permitem que sejam definidos formatos aos números. 
a. Estes formatos são úteis na impressão de números reais para evitar a forma 
com exponenciação. 
b. O formato é: numero:tamanho:precisão 
i. numero é o número que se quer imprimir. 
ii. tamanho informa a largura da saída. 
iii. precisão informa com quantos dígitos o numero será impresso. 
{Sintaxe:} 
variável : string; 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
36 Programação com Pascal 
 
 
 
O uso de colchetes determina que a variável terá um conteúdo de até tamanho 
caracteres. A Listagem 8 apresenta um exemplo de uso de Strings. 
 
 
Listagem 2.3 – Exemplo com Strings 
No programa da Listagem 8 destaca-se o seguinte: 
1. Na linha 7 declara-se a variável endereco que terá até 255 caracteres (é o 
limite máximo de uma string), 
2. A linha 8 apresenta a declaração da variável nome que terá, no máximo, 30 
caracteres. 
3. A linha 8 apresenta a declaração da variável CPF que terá, no máximo, 11 
caracteres. 
4. Na linha 12 atribui-se um valor 235 à variável endereço. Note que atribuição 
de string requer o uso de apóstrofos. 
5. A linha 15 faz-se a impressão das três variáveis e seus valores. 
 
A execução do programa imprimirá: 
 
 
 
Observações: 
1. Write e WriteLn permitem imprimir múltiplos valores separando-os por vírgulas. 
a. A impressão de constantes string é feita colocando-as entre apóstrofos. 
b. O comando writeln('Endereco: ', endereco); imprimirá Endereco: seguido pelo 
valor da variável endereco. 
Endereco: Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador, Bahia - CEP: 40.130.280 Cliente: Jose da 
Silva Santos CPF: 12345678901 
 
 1 program StringsEmPascal; 
 2 {Este programa vai demonstrar o uso de String em Pascal.} 
 
 4 uses crt; 
 
 6 var 
 7 endereco : string; {endereço é uma cadeia com 0 a 255 caracteres.} 
 8 nome : string[30]; 
 9 CPF : string[11]; {O uso de [] delimita o número de caracteres. 
 Neste caso CPF tem 11 caracteres.} 
 
11 begin 
12 endereco := 'Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador, Bahia - 
CEP: 40.130.280'; 
13 nome:= 'Jose da Silva Santos'; 
14 CPF := '12345678901'; 
15 writeln('Endereco: ', endereco, ' Cliente: ', nome, ' CPF: ', cpf); 
16 readkey; 
17 end. 
 
{Sintaxe:} 
variável : string[tamanho]; 
 
 
37 A LINGUAGEM PASCAL 
Char 
 
Pascal suporta o tipo Char, que ocupa exatamente 1 byte e contém um caractere ASCII 
(American Standard Code for Information Interchange). 
 
Para definir uma variável do tipo char usa-se a seguinte sintaxe: 
 
 
 
A Listagem 9 apresenta um exemplo de uso de char. 
 
 
Listagem 2.4 – Exemplo com Char 
Nas linhas 7, 8 e 9 definem-se variáveis do tipo char. 
 
Um caractere pode ser especificado colocando o caractere entre aspas simples 
(apóstrfos), como 'a' ou 'B', por exemplo, nas linhas 14 e 18. Também pode ser 
especificado pelo seu valor de caracteres (normalmente um código ASCII), precedendo 
o valor ordinal com o símbolo (#). Por exemplo, na linha 15, especificando #65 é o 
mesmo que 'A'. 
 
O resultado da execução do programa é: 
 
 
{Sintaxe:} 
variável : char; 
 
Sexo: M 
Letras Maiusculas: AB 
Letras Minusculas: ab 
 1 program CharEmPascal; 
 2 {Este programa vai demonstrar o tipo Char do Pascal} 
 3 
 4 uses crt; 
 5 
 6 var 
 7 letraAMinuscula, letraAMaiuscula : char; 
 8 letraBMinuscula, letraBMaiuscula : char; 
 9 sexo : char; {char representa um único caracter. Neste caso 
sexo pode ser 'M' ou 'F'} 
10 
11 begin 
12 {Atribuições de valores às variáves} 
13 sexo := 'M'; 
14 letraAMinuscula := 'a'; 
15 letraAMaiuscula := #65; 
16 
17 letraBMinuscula := #98; 
18 letraBMaiuscula := 'B'; 
19 
20 writeln('Sexo: ', sexo); 
21 writeln('Letras Maiusculas: ', letraAMaiuscula, letraBMaiuscula); 
22 writeln('Letras Minusculas: ', letraAMinuscula, letraBMinuscula); 
23 readkey; 
24 end. 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
38 Programação com Pascal 
Tipos Lógicos 
 
Pascal suporta o tipo Boolean, com dois possíveis valores predefinidos: true e false. 
Qualquer expressão que resulte em um valor booleano (verdadeiro ou falso) também 
pode ser atribuída a um tipo booleano. 
 
Para definir uma variável do tipo boolean usa-se a seguinte sintaxe: 
 
 
 
A Listagem 10 apresenta um exemplo de uso de boolean. 
 
 
Listagem 2.5 – Exemplo com Boolean 
O resultadoda execução do programa é: 
 
 
 
A linha 11 atribui diretamente o valor TRUE à variável aprovado. As linhas 12 a 14 
atribuem o valor lógico do teste às variáveis maior, igual e menor. 
 
Note que uma atribuição tem duas partes: uma antes do := e outra depois. No caso da 
linha 12 estamos atribuindo à variável maior o resultado da expressão que avalia se dois 
é maior que um, o que é verdade (TRUE). As linhas 13 e 14 seguem o mesmo princípio, 
atribuindo a igual e a menor o resultado dos respectivos testes lógicos. 
 
 
 A Listagem 11 a seguir apresenta um exemplo com variáveis e constantes. 
{Sintaxe:} 
variável : char; 
 
Aprovado: TRUE 
2 > 1? eh: TRUE 
2 = 1 eh: FALSE 
2 < 1 eh: FALSE 
 1 program BooleanEmPascal; 
 2 {Este programa vai demonstrar o tipo boolean do Pascal} 
 3 
 4 uses crt; 
 5 var 
 6 aprovado : boolean; {Variáveis lógicas - podem ser TRUE ou FALSE} 
 7 maior, menor, igual : boolean; 
 8 
 9 begin 
10 {Atribuições de valores às variáves} 
11 aprovado := true; {Atribui TRUE a aprovado} 
12 maior := 2 > 1; {Atribui o resultado do teste: 2 > 1? a maior} 
13 igual := 2 = 1; {Atribui o resultado do teste: 2 > 1? a igual} 
14 menor := 2 < 1; {Atribui o resultado do teste: 2 > 1? a menor} 
15 
16 writeln('Aprovado: ', aprovado); 
17 writeln('2 > 1? eh: ', maior); 
18 writeln('2 = 1 eh: ', menor); 
19 writeln('2 = 1 eh: ', igual); 
20 readkey; 
21 end. 
 
 
39 A LINGUAGEM PASCAL 
 
Listagem 2.6 – Exemplo com Variáveis e Constantes 
 
O programa VariaveisEConstantes declara na linha 7 as variáveis área e raio do tipo 
REAL. Como o nome já informa, variáveis podem ter seu valor mudado durante a 
execução do programa. As linhas 14, 15, 18 e 19 exemplificam isso, mudando os 
valores de raio e área. 
Para um novo valor do raio é calculada a área de um círculo usando-se a fórmula: 
Área = π * raio2 
Note que raio
2 
foi calculado como raio * raio 
A constante matemática π é representada no programa pela constante PI, cujo valor é 
atribuído na própria declaração, como é visto na linha 10. 
O resultado da execução do programa da Listagem 9 é: 
 
 
A area do circulo de raio 10 eh: 314.1593 
A area do circulo de raio 15 eh: 706.8583 
 1 program VariaveisEConstantes; 
 2 {Este programa vai demonstrar variáveis e constantes no Pascal} 
 3 
 4 uses crt; 
 5 
 6 var 
 7 area, raio : real; {Declara area e raio como variáveis REAIS} 
 8 
 9 const 
10 pi = 3.1415926536; {Declara pi como uma constante} 
11 
12 begin 
13 {Atribuições de valores às variáves} 
14 raio := 10; 
15 area := pi * raio * raio; 
16 writeln('A area do circulo de raio 10 eh: ', area:3:4); 
17 
18 raio := 15; 
19 area := pi * raio * raio; 
20 writeln('A area do circulo de raio 15 eh: ', area:3:4); 
21 
22 {pi := 10;} 
23 readkey; 
24 end. 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
40 Programação com Pascal 
 
 
EXPRESSÕES 
 
Expressões são arranjos de operandos (variáveis, constantes ou valores gerados por 
funções) e operadores (operações a serem efetuadas sobre os operandos) que ocorrem 
nas atribuições ou em testes e produzem um valor de um determinado tipo. 
 
Um operador pode ser binário, ou seja, requer 2 operandos (como em X / Y e em A * B) 
ou unário, isto é, exige apenas um argumento (como em -X). 
 
Cada tipo de dados possui um conjunto de operadores relacionados. 
 
3.1 Prioridades das Operações 
 
Se vários operadores aparecerem em uma expressão, sua ordem de execução será dada 
segundo os seguintes critérios: 
1. Pelo emprego explícito de parênteses; 
2. Pela ordem de precedência existente entre os operadores; e 
3. Se existirem operadores de mesma ordem de precedência, a avaliação será feita 
da esquerda para a direita. 
 
Como exemplo, qual será o resultado da expressão: 3 + 2 * 5? A resposta é 25 ou 13? 
Como sabemos, na matemática a multiplicação precede a soma. Logo, a expressão pode 
ser lida assim: 3 + (2 * 5), o que resulta em 13. O uso de parêntesis facilita a leitura de 
expressões com múltiplos operadores, explicitando sua precedência. 
 
Vejamos a ordem de precedência dos operadores (da maior para a menor): 
 
Tabela 3.1 – Precedência de Operadores 
OPERADOR PRECEDÊNCIA CATEGORIA 
Not, @ Primeira Unária 
*, /, div, mod, and, shl, shr, 
as 
Segunda Multiplicação 
+, -, or, xor Terceira Adição 
<, <>, >, <=, >=, in, is Última Relacional 
 
3.2 Tipos de Expressões 
 
As expressões podem ser divididas em três grupos: 
 
 Numérica - quando os operandos e o resultado são numéricos (inteiros ou reais). 
 
 Literal - quando os operandos e o resultado são literais do tipo string (não pode 
ser char). Só existe um operador para expressões literais: Concatenação ( + ). 
 
3 
 
41 EXPRESSÕES 
 Booleana - quando seu resultado é do tipo boolean (TRUE ou FALSE). 
 
3.3 Tipos de Operadores 
 
Existem vários operadores para a realização de expressões em Pascal, como detalhado a 
seguir. 
 
Operador de Atribuição 
 
O operador de atribuição é utilizado para atribuir o valor de uma expressão a uma 
variável. 
 
 
 
 
Exemplos de atribuições: 
 
 
Listagem 3.1 – Operador de Atribuição 
Das linhas 13 a 21, exceto a linha 16, temos atribuições de valores a variáveis de 
diversos tipos. Note que o que está após o := é uma expressão. 
 
Operadores Aritméticos 
 
Os operadores aritméticos são utilizados para efetuar operações aritméticas com 
números inteiros e reais. São eles: Subtração (-), Adição (+) e Multiplicação (*). 
 
 1 program VariaveisPascal; 
 2 
 3 var 
 4 a, b, c : integer; {Declara a, b e c como variáveis inteiras} 
 5 media : real; {Declara media do tipo real} 
 6 aprovado : boolean; {Variáveis lógicas - podem ser TRUE ou FALSE} 
 7 endereco : string; {endereço é uma cadeia com 0 a 255 caracteres.} 
 8 CPF : string[11]; {O uso de [] delimita o número de caracteres.} 
 9 sexo : char; {char representa um único caracter.} 
10 
11 begin 
12 {Atribuições de valores às variáves} 
13 endereco := 'Rua dos Alferes, 1234, Ap. 1001, Barra, Salvador, 
Bahia - CEP: 40.130.280'; 
14 nome:= 'Jose da Silva Santos'; 
15 CPF := '12345678901'; 
16 writeln('Endereco: ', endereco, ' Cliente: ', nome, ' CPF: ', cpf); 
17 sexo := 'M'; 
18 a := 7; 
19 b := a + 2; 
20 c := 8; 
21 media := (a + b + c) / 3; 
22 readkey; 
23 end. 
 
{Sintaxe:} 
nomeDaVariável := expressão; 
 
Edeyson Andrade Gomes www.edeyson.com.br 
42 Programação com Pascal 
O operador de Divisão Real (/) só se aplica a números reais e os operadores de Divisão 
Inteira (DIV) e Resto da Divisão Inteira (MOD) só se aplicam a números inteiros. 
 
A (/) é chamada de Divisão Real, pois sempre resultará num número real. Não se pode 
garantir que a divisão de dois inteiros resultará num número inteiro, como é o caso da 
divisão de 10 por 3. Logo, para obter a parte inteira da divisão entre inteiros existe o 
operador DIV. O operador MOD fornece o resto inteiro da divisão. 
Exemplos: 
1. 16 / 3  5,3333 (número real) 
2. 7 / 2  3,5 (número real) 
3. 16 DIV 3  5 (note que todos os fatores são inteiros) 
4. 16 MOD 3  1 
 
A listagem 11 apresenta um código que ilustra o uso de DIV e MOD apresentando o 
dividendo, divisor, quociente, resto numa divisão inteira e a Listagem 12 demonstra 
como extrair todos os dígitos de um número com 3 dígitos. 
 
 
Listagem 3.2 – Uso de DIV e MOD 
Na Listagem 11 as linhas 7 e 8 definem as variáveis dividendo, divisor, quociente e 
resto como inteiros e quocienteReal como real. Tais variáveis representarão os 
elementos numa divisão. 
As linhas 11 e 12 iniciam o dividendo com 10 e o divisor com 3. A divisão entre 10 e 3 
é uma dízima periódica 3.333, que será o valor de quocienteReal calculado na linha 14. 
Pensando-se numa divisão com todos os fatoresinteiros, quociente (linha 13) assumirá 
o valor 3 e resto (linha 16) assumirá o valor 1. Vale lembrar que 10 dividido por 3 é 
igual a 3 com resto 1 (10 = 3 * 3 + 1). 
 1 program UsoDivMod; 
 2 {Este programa demonstra o uso de DIV e MOD como operadores de 
 inteiros.} 
 3 
 4 uses crt; 
 5 
 6 var 
 7 dividendo, divisor, quociente, resto : integer; 
 8 quocienteReal : real; 
 9 
10 begin 
11 dividendo := 10; 
12 divisor := 3; 
13 quociente := dividendo div divisor; 
14 quocienteReal := dividendo / divisor; 
15 
16 resto := dividendo mod divisor; 
17 
18 writeln('Dividendo: ', dividendo:3, ' Divisor: ', divisor:3); 
19 writeln('Quociente: ', quociente:3, ' Resto : ', resto:3); 
20 writeln('Quociente Real: ', quocienteReal:3:4); 
21 
22 readkey; {Para o programa até que algo seja teclado} 
23 end. 
 
 
43 EXPRESSÕES 
O resultado da execução do programa da Listagem 11 é: 
 
 
 
 
Listagem 3.3 – Uso de DIV e MOD com Unidade, Dezena e Centena 
O objetivo do programa da Listagem 12 é apresentar os valores de unidade, dezena e 
centena de um número. Na linha 12 atribui-se o valor 367 à variável numero. Note que 
367 = 3 * 100 + 67. 
A linha 13 atribui à variável centena o valor de numero div 100, ou seja, o quociente 
inteiro da divisão entre 367 e 100, que resulta em 3. 
A linha 14 atribui à variável resto o valor de numero mod 100, o que representa o resto 
inteiro da divisão. Como número é igual a 367, resto será 67. 
Seguindo o raciocínio do uso de DIV e MOD, a linha 15 atribui 6 a dezena e a linha 16 
atribui 7 a unidade. 
O resultado da execução do programa da Listagem 12 é: 
 
 
Centena: 3 
Dezena : 6 
Unidade: 7 
 1 program UsoDivMod2; 
 2 {Este programa vai demonstrar o uso de DIV e MOD.} 
 3 
 4 uses crt; {Usa a biblioteca CRT onde está readkey} 
 5 
 6 var 
 7 numero, centena, dezena, unidade, resto : integer; 
 8 {Operações sobre Inteiros: +, -, *, DIV e MOD} 
 9 
10 begin {inicia o programa} 
11 {Atribuições de valores às variáves} 
12 numero := 367; {XYZ = X * 100 + YZ} 
13 centena := numero div 100; {centena = X} 
14 resto := numero mod 100; {resto = YZ} {YZ = Y * 10 + Z} 
15 dezena := resto div 10; {dezena = Y} 
16 unidade := resto mod 10; {unidade = Z} 
17 
18 writeln('Centena: ', centena); 
19 writeln('Dezena: ', dezena); 
20 writeln('Unidade: ', unidade); 
21 
22 readkey; {Para o programa até que algo seja teclado} 
23 
24 end. {termina o programa} 
 
Dividendo: 10 Divisor: 3 
Quociente: 3 Resto : 1 
Quociente Real: 3.3333 
 
Edeyson Andrade Gomes www.edeyson.com.br 
44 Programação com Pascal 
Operador de Concatenação 
 
O operador de concatenação efetua a junção de duas variáveis ou constantes do tipo 
string. Por exemplo, suponha as strings nome e sobrenome. Nome armazena ‘Edeyson’ 
e sobrenome, ‘Gomes’. Como obter uma string com o nome completo? Strings 
suportam a operação de soma (+) que funciona com a concatenação (junção). 
 
A Listagem 13 exibe um exemplo de concatenação de strings. 
 
 
Listagem 3.4 - Concatenação de Strings 
Na Listagem 13, as linhas 7, 8 e 9 declaram strings com tamanho definido. As variáveis 
nome e sobrenome só podem armazenar cadeias com, no máximo, 20 caracteres. Já a 
variável nomeCompleto pode armazenar cadeias de até 40 caracteres. 
 
Na linha 12 atribui-se a string ‘Edeyson’ à variável nome. Na linha 13 atribui-se 
‘Gomes’ para sobrenome. 
 
Note que na linha 14 faz-se uma operação de soma entre strings. Isso significa que as 
strings ‘Edeyson’, espaço em branco e ‘Gomes’ serão concatenadas e o resultado 
atribuído à variável nomeCompleto. 
 
O resultado da linha 15 será: Nome Completo: Edeyson Gomes. 
 
 1 program ConcatenacaoDeStrings; 
 2 {Este programa vai demonstrar a Concatenação de Strings em Pascal.} 
 3 
 4 uses crt; 
 5 
 6 var 
 7 nome : string[20]; {Definição de variáveis} 
 8 sobrenome : string[20]; 
 9 nomeCompleto : string[40]; 
10 
11 begin 
12 nome := 'Edeyson'; {Atribui Edeyson para a var. nome} 
13 sobrenome:= 'Gomes'; {Atribui Gomes para a var. sobrenome} 
14 nomeCompleto := nome + ' ' + sobrenome; {Concatena nome, 
 espaço em branco e sobrenome} 
15 writeln('Nome Completo: ', nomeCompleto); {Exibe o nome completo} 
16 
17 readkey; 
18 end. 
 
 
45 EXPRESSÕES 
Operadores Relacionais 
 
Os operadores relacionais são utilizados para efetuar a comparação entre dados de 
mesmo tipo, por exemplo, se um número inteiro é maior que outro, se um número real é 
menor ou igual a outro, se duas strings são iguais, etc. 
 
Tabela 3.2 – Operadores Relacionais 
OPERADOR SÍMBOLO 
Maior que > 
Menor que < 
Igual = 
Maior Igual >= 
Menor Igual <= 
Diferente <> 
 
Exemplo de operadores relacionais: 
 
 
Listagem 3.5 – Operadores Relacionais com Integer 
 
Na Listagem 14 a linha 5 define uma variável valorLogico do tipo boolean, ou seja, ela 
só armazena Verdade (TRUE) ou Falso (FALSE). A linha 6 define duas variáveis 
inteiras que são inicializadas nas linhas 10 e 11, respectivamente. 
A linha 13, valorLogico := inteiro1 = inteiro2, precisa de destaque aos :=, que é o 
símbolo de atribuição do Pascal. Este atribui ao símbolo da esquerda do :=, no caso 
valorLogico, o valor lógico ou absoluto do que está à direita do símbolo. 
 
1 program OperadoresRelacionaisComInteger; 
 2 {Este programa vai demonstrar Operadores Relacionais do Pascal} 
 3 uses crt; 
 4 var 
 5 valorLogico : boolean; {Variáveis lógicas - podem ser TRUE ou FALSE} 
 6 inteiro1, inteiro2 : integer; 
 7 
 8 begin 
 9 {Atribuições de valores às variáves} 
10 inteiro1 := 10; 
11 inteiro2 := 20; 
12 
13 valorLogico := inteiro1 = inteiro2; 
14 writeln('Teste se ', inteiro1, ' eh = a ', inteiro2, ' : ', 
 valorLogico); 
15 
16 valorLogico := inteiro1 < inteiro2; 
17 writeln('Teste se ', inteiro1, ' eh < que ', inteiro2, ' : ', 
 valorLogico); 
18 
19 valorLogico := inteiro1 > inteiro2; 
20 writeln('Teste se ', inteiro1, ' eh > que ', inteiro2, ' : ', 
 valorLogico); 
21 
22 readkey; 
23 end. 
 
 
Edeyson Andrade Gomes www.edeyson.com.br 
46 Programação com Pascal 
A linha 13 é lida assim: o valor do inteiro1 é igual ao valor do inteiro2? Se sim, atribua 
TRUE para valorLogico; se não, atribua FALSE. 
A linha 14 imprime o resultado do teste lógico. Note que as linhas 16/17 e 19/20 fazem 
algo similar às linhas 13/14, apenas mudando o operador relacional. 
O resultado da execução do programa da Listagem 14 é: 
 
 
Listagem 3.6 – Operadores Relacionais com String 
Na Listagem 15, similar a Listagem 14, a linha 5 define uma variável valorLogico do 
tipo boolean, ou seja, ela só armazena Verdade (TRUE) ou Falso (FALSE). A linha 6 
define duas variáveis do tipo string (cadeias de caracter) que são inicializadas nas 
linhas 10 e 11, respectivamente. 
A linha 13 é lida assim: o valor da string1 é igual ao valor do string2? Se sim, atribua 
TRUE para valorLogico; se não, atribua FALSE. 
A linha 14 imprime o resultado do teste lógico. Note que as linhas 16/17 e 19/20 fazem 
algo similar às linhas 13/14, apenas mudando o operador relacional. Note que strings 
podem ser comparadas com >, <, etc. O resultado da execução do programa da 
Listagem 15 é: 
Teste se 10 eh = a 20 : FALSE 
Teste se 10 eh < que 20 : TRUE 
Teste se 10 eh > que 20 : FALSE 
 1 program OperadoresRelacionaisComString; 
 2 {Este programa vai demonstrar Operadores Relacionais do Pascal} 
 3 uses crt; 
 4 var 
 5 valorLogico : boolean; {Variáveis lógicas - podem ser TRUE ou FALSE} 
 6 string1, string2 : string; 
 7 
 8 begin 
 9 {Atribuições de valores às variáves} 
10 string1 := 'abc'; 
11 string2 := 'def'; 
12 
13 valorLogico :=