Manual de Introducao a Informatica 2021 - (Pascal)

Prévia do material em texto

Universidade Eduardo Mondlane 
Faculdade de Ciências 
Departamento de Matemática & Informática 
 
 
Introdução a Informática
 
 
 
 
Gabriel I. Salimo 
 
Julho, 2019
Introdução a Informática (Gabriel Salimo) Pagina 2 de 72 
Índice 
1. Programação em Pascal ........................................................................................................................ 6 
1.1. Noções Básicas Preliminares ............................................................................................................ 6 
1.2. Descrição ......................................................................................................................................... 6 
1.3. Estrutura de um Programa em Pascal .............................................................................................. 6 
1.4. Sintaxe do Programa Pascal (Estrutura Simples) .................................................................. 7 
2. Identificadores ................................................................................................................................ 8 
2.1. Identificadores Pré-Definidos ............................................................................................... 8 
2.2. Caracteres utilizados ............................................................................................................. 8 
2.3. Regras para Formação de Identificadores ............................................................................ 8 
2.4. Comentários .................................................................................................................................... 8 
3. Palavras Reservadas ....................................................................................................................... 9 
4. Expressão ........................................................................................................................................ 9 
4.1. Tipos de Expressões .............................................................................................................. 9 
4.2. Operadores .................................................................................................................................... 9 
4.3. Operadores Aritméticos ........................................................................................................ 9 
4.4. Operadores Atribuição ........................................................................................................ 10 
4.5. Operadores Relacionais ...................................................................................................... 10 
4.6. Operadores Lógicos............................................................................................................. 11 
5. Tipo de Dados ............................................................................................................................... 11 
5.1. Dados Simples (Escalares Simples) ..................................................................................... 12 
5.2. Dados Estruturados (Escalares Estruturados) ..................................................................... 12 
5.3. Declaração de Dados ................................................................................................................... 12 
5.4. Declaração de todas Dados: VAR ........................................................................................ 12 
5.5. Declaração de Novos Tipos Dados: TYPE ............................................................................ 13 
5.6. Declaração de Constantes: CONST ..................................................................................... 13 
5.7. Constantes Tipadas ............................................................................................................. 14 
5.8. Constantes pré-Definidas .................................................................................................... 14 
5.9. Caracteres de Controle ................................................................................................................. 14 
5.10. Entrada e saída de dados ....................................................................................................... 14 
5.11. Saída na Tela: WRITE e WRITELN ........................................................................................ 14 
5.12. Entrada: READ e READLN .................................................................................................... 15 
5.13. Saída na Video/Impressora: WRITE e WRITELN .................................................................. 16 
5.14. Funções e Procedures para Controlo de Vídeo .................................................................. 17 
5.15. Funções e Procedures para Controlo do Teclado ............................................................... 19 
6. Estruturas Para o Controlo do Fluxo do Programa ........................................................................ 20 
6.1. Estrutura de Decisão ou Escolha Condicional (Simples): IF-THEN-ELSE ............................. 20 
6.2. Estrutura de Decisão ou Escolha Condicional (Múltipla): CASE .......................................... 22 
6.3. Instrução de “Salto” Incondicional: GOTO .......................................................................... 23 
6.4. Estrutura de Repetição com Contador: Ciclo FOR .............................................................. 24 
6.5. Estrutura de Repetição Baseada numa Condição: Ciclo REPEAT UNTIL ............................. 25 
6.6. Estrutura de Repetição Baseada numa Condição: Ciclo WHILE DO .................................... 26 
7. Outros Tipos Dados Estruturados ................................................................................................... 27 
7.1. Tipo Arrays: Variáveis Indexadas Uni-Dimensionais (Vectores) ......................................... 27 
7.2. Tipo Arrays: Variáveis Indexadas Bidimensionais (Matrizes) .............................................. 29 
Introdução a Informática (Gabriel Salimo) Pagina 3 de 72 
7.3. Tipo Record ......................................................................................................................... 31 
7.4. Tipo Set ............................................................................................................................... 33 
8. Subprogramas ............................................................................................................................... 36 
8.1. Declaraçäo de procedures .................................................................................................. 37 
8.2. Variáveis Globais e Locais ................................................................................................... 38 
8.3. Procedures: Passagem de parâmetros ............................................................................... 38 
8.4. Passagem de parâmetros por Valor .................................................................................... 38 
8.5. Passagem de parâmetros por Referência ........................................................................... 38 
8.6. Definição de Funções .......................................................................................................... 39 
8.7. Arquivos (File = Ficheiro) ............................................................................................................... 40 
8.8. Declaração de tipos e variáveis de ficheiros (VAR) ............................................................. 41 
8.9. ASSIGN: associação de identificador de ficheiro com o nome externo de ficheiro ............ 41 
8.10. REWRITE: Criação de um novo ficheiro & Escrita de Dados (WRITE, WRITELN) ................ 42 
8.11. RESET: Abertura de um ficheiro para leitura & Leitura do Ficheiro (READ) ....................... 43 
8.12. APPEND: Abertura de um ficheiro para Acrescentar Informação ......................................43 
8.13. Verificação de Existência de um Ficheiro: {$I-} e {$I+} ........................................................ 44 
9. Exercícios de Revisão .................................................................................................................... 46 
9.1. Exercícios Resolvidos .......................................................................................................... 46 
9.2. Exercícios por Resolver ....................................................................................................... 54 
10. Apêndices ............................................................................................................................ 60 
10.1. Turbo Pascal ........................................................................................................................ 60 
10.2. Iniciar Turbo Pascal (Criação de Ficheiro) ........................................................................... 60 
10.3. Gravação de Ficheiro com Turbo Pascal ............................................................................. 61 
10.4. Compilação do Programa com Turbo Pascal ...................................................................... 61 
10.5. Executar um Programa com Turbo Pascal .......................................................................... 62 
10.6. Abrir Ficheiro com Turbo Pascal ......................................................................................... 63 
11. Funções pré-definidas do Pascal ......................................................................................... 64 
11.1. ABS() .................................................................................................................................... 64 
11.2. CHR() ................................................................................................................................... 64 
11.3. CONCAT() ............................................................................................................................ 64 
11.4. COPY() ................................................................................................................................. 64 
11.5. COS() ................................................................................................................................... 64 
11.6. DEC().................................................................................................................................... 64 
11.7. DELAY() ................................................................................................................................ 65 
11.8. DELETE() .............................................................................................................................. 65 
11.9. COS() ................................................................................................................................... 65 
11.10. FRAC() .................................................................................................................................. 65 
11.11. COS() ................................................................................................................................... 65 
11.12. INC() .................................................................................................................................... 65 
11.13. INSERT() ............................................................................................................................... 66 
11.14. INT()..................................................................................................................................... 66 
11.15. LENGTH() ............................................................................................................................. 66 
11.16. LN() ...................................................................................................................................... 66 
11.17. ODD()................................................................................................................................... 66 
11.18. ORD() ................................................................................................................................... 66 
11.19. PI ......................................................................................................................................... 67 
11.20. POS().................................................................................................................................... 67 
11.21. SIN() ..................................................................................................................................... 67 
11.22. SQR() ................................................................................................................................... 67 
11.23. SQRT() ................................................................................................................................. 67 
11.24. STR() .................................................................................................................................... 67 
Introdução a Informática (Gabriel Salimo) Pagina 4 de 72 
11.25. TRUNC() ............................................................................................................................... 68 
11.26. UPCASE() ............................................................................................................................. 68 
11.27. VAL() .................................................................................................................................... 68 
11.28. Turbo Pascal - Exercícios de Consolidação (Exercícios Resolvidos) .................................... 69 
11.29. Programa de Vectores ........................................................................................................ 69 
11.30. Programa de Gerenciameto de Biblioteca .......................................................................... 69 
11.31. Programa de Ordenamento de Números ........................................................................... 71 
 
Introdução a Informática (Gabriel Salimo) Pagina 5 de 72 
 
 
 
 
 
 
 
Programação  Código  Resultados 
 
 
Quando uma linguagem de programação é criada, a 
partir das suas características, ela é categorizada em 
um ou mais paradigmas 
 
 
 
 
O paradigma de programação é o conceito 
que pressupõe a forma que programador tem sobre 
a programação e execução de um programa 
 
P
ro
gr
am
aç
ão
: 
E
le
m
en
to
s 
e 
co
m
an
do
s 
na
 p
ro
gr
am
aç
ão
 P
as
ca
l 
Introdução a Informática (Gabriel Salimo) Pagina 6 de 72 
1. Programação em 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... 
 
☺uma linguagem de programaçäo é um meio ou uma ferramenta para se traduzir os 
algoritmos em programas a serem executados por computadores! 
 
 A linguagem de programação Pascal, por ser uma linuagem estruturada é das 
melhores linguagens para ser à primeira linguagem a aprender quando se introduz à 
programação; pois permite ao aprendiz a possibilidade de desenvolver algoritmos 
lógicos, sistemáticos, facilmente compreensíveis segundo os métodos modernos de 
programaçäo e possibilitá-lo até a "dar asas à sua imaginaçåo". 
 
1.1. Noções Básicas Preliminares 
A linguagem Pascal é tradiconalmente compilada; assim sendo devemos obdecer as 
seguintes etapas: 
 
1º. 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. 
 
...sempre que o programa fonte sofre qualquer alteração o processo de compilaçãodeve 
ser repetido para que modicaçöes tenham efeito na execução... 
 
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. 
 
1.2. Descrição 
Na descrição da semântica e sintaxe do Pascal neste manual consideraremos os seguintes 
significados nas notaçãoes: 
 
 Maiúscula (Bold) - Palavras Reservadas; 
 Itálico - para a preencher pelo programador; 
 [xxx] - indicação que xxx é opcional (pode ou não surgir no programa); 
 {} - encerram uma lista de itens dos quais somente um item pode ser usado 
(excepto quando usados no programas para indicar comentários); 
 ... - indicam que o item precedente pode aparecer uma ou mais vezes em 
sucessão. 
1.3. Estrutura de um Programa em Pascal 
Um programa em linguagem de programação Pascal obriga que inicialmente a declarar os 
dados; assim todo programa em Pascal é subdividido em 3 áreas: 
 
 cabeçalho do programa 
 área de declarações (parte declarativa) 
 corpo do programa (parte operactiva) 
Introdução a Informática (Gabriel Salimo) Pagina 7 de 72 
 
 Na definição padrão da linguagem Pascal, o Cabeçalho do programa é obrigatório, 
no entanto, no Turbo Pascal ele é opcional. Também se torna indispenável começar por 
declarar os dados - área de declarações; enquanto que a parte operactiva é aonde 
são descritas as operações a ser executados pelo programa. 
 
1.4. Sintaxe do Programa Pascal (Estrutura Simples) 
PROGRAM nome_do_programa; [{...as chavetas são usadas para representar 
comentários...}] 
 [VAR mome_da_variavel1, ..., nome_da_variaveln: tipo1; 
mome_da_variavel1, ..., nome_da_variaveln: tipo2; 
... 
mome_da_variavel1, ..., nome_da_variaveln: tipoN;] 
BEGIN [{Início do programa principal}] 
instruçoes/Comandos 
END. [{fim do programa principal}] 
 
Exemplo (Programa Pascal – Área do Trapézio) 
 
Seja o seguinte algoritmo (pseudocódigo), para o cálculo da área de um trapézio: 
Inicio 
Escreva(‘Quais as medidas das bases’) 
Ler(base1, base2) 
Escreva(‘Qual a medidas da altura’) 
Ler(altura) 
area←(base1+base2) *altura/2 
Escreva(‘A area é ’, area) 
Fim. 
 
Teremos a Código-Fonte em Pascal: 
Program Area_Trapezio; 
(* Programa para o cálculo da área de um trapézio dado as medidas 
 Autor : Crocodilo 
 Data : 30/07/2018 *) 
Var base1, base2, altura, area : Real; {declaração de variáveis} 
Begin 
Write(‘Quais as medidas das bases: ’); 
Readln(base1, base2); (* leitura de dados: as bases *) 
Write(‘Qual a medidas da altura: ’); 
Readln(altura); (* leitura de dados: altura *) 
Area := (base1+base2)/2*altura; {cálculo da área} 
Writeln(‘A area é ’,area); (* apresentação de resultados: a área *) 
End. 
 
Introdução a Informática (Gabriel Salimo) Pagina 8 de 72 
2. Identificadores 
São nomes que servem para representar variáveis, funções, sub-rotinas, constantes, etc... 
 
2.1. Identificadores Pré-Definidos 
Os identificadores pré-definidos, representam Procedures (Procedimentos) ou Functions 
(Funções), que podem ser utilizados normalmente na construção de programas para a 
obtenção de resultados já elaborados. 
 
Exemplos: 
 ClrScr (Clear Screen): limpa a tela de vídeo 
 DelLine (Delete Line): apaga a linha em que está o cursor e assim por diante 
 
 mais em diante deste manual se apresentam com mais detalhes algum dos mais usuais 
dos identificadores pré-definidos do Pascal. 
 
2.2. Caracteres utilizados 
Os caracteres que podem ser utilizados em Pascal para a formação de identificadores são 
divididos em : 
 
 Letras : 'A' até 'Z', 'a' até 'z' 
 Números : 0,1,2,3,4,5,6,7,8 e 9 
 Especiais : + - * / = ^ < > ( ) [ ] { } . , : ; ' # $ 
 
2.3. Regras para Formação de Identificadores 
O usuário também pode definir seus próprios identificadores, na verdade o programador é 
obrigado a isso; Nomes de variáveis, de labels, de procedures, functions, constantes etc. São 
identificadores que devem ser formados pelo programador, seguindo as seguites regras: 
 
1º O primeiro caracter deve ser obrigatoriamente uma letra ou o caracter underscore 
‘_’; 
2º Os demais caracteres podem ser letras, dígitos ou underscores; 
3º Um identificador pode ter no máximo 127 caracteres; 
4º Como já dissemos anteriormente, não pode ser palavra reservada; 
5º Não pode conter caracteres especiais. 
 
Exemplos: 
Correctos Errados Razão do Erro 
Nota 
numero_de_notas 
Numero_de_Notas 
N123 
_valor 
12_notas 
+notas 
%notas 
media final 
opção 
O primeiro caracter não é alfabético (letra) 
O primeiro caracter não é alfabético (letra) 
O primeiro caracter não é alfabético (letra) 
Contém um espaço entre o nome do identificador 
Contém caracteres acentuados 
 
2.4. 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 ao longo do 
nosso programa. Em Pascal, tudo que estiver entre os símbolos (* e *) ou { e } é considerado 
como comentário. 
 
Introdução a Informática (Gabriel Salimo) Pagina 9 de 72 
3. Palavras Reservadas 
 As palavras (tokens) reservadas são todas aquelas que por fazerem parte da própria 
linguagem, não podem ser utilizadas pelo programador para representar um 
idenficador; 
 As palavras reservadas no Pascal são: 
absolute(*) and array begin case const div 
do downto else end external(*) file for 
forward function goto if in inline(*) label 
mod nil not of or packed procedure 
program record repeat set shl(*) shr(*) string(*) 
thento type until var while with xor(*) 
 
Observação: 
(*) - não definidos no Pascal Standard 
 
 A utilização de identificadores com o mesmo nome de uma das palavras reservadas 
resultará em erro de compilação. 
 
4. Expressão 
Uma expressão PASCAL, é definida como uma combinação de itens sintácticos, isto é: uma 
expressão pode consistir de uma única constante, de uma única variável, de um único 
elemento ou conjunto, ou uma combinação de constantes, variáveis, elementos ou conjuntos, 
unidos com um ou mais operadores. 
 
Exemplo: expressão: x + z - consiste de duas variáveis unidas pelo operador + 
 
4.1. Tipos de Expressões 
 Aritméticas - produz somente um valor que é sempre um número cujo tipo é real, inteiro 
ou complexo. 
 Caracteres - produz somente um valor que é sempre uma cadeia de caracteres. 
 Relacionais - produz somente um valor que é sempre uma constante lógica. 
 Lógicas - produz somente um valor que é sempre uma constante lógica. 
 Booleanas - produz somente um valore que é sempre do tipo Booleano. 
 
4.2. Operadores 
4.3. Operadores Aritméticos 
Operador Definição Uso do Operador Significado 
** Potenciação ab a elevado a potência b 
* Multiplicação a*b a multiplicado por b 
/ Divisão a/b a dividido por b 
+ Adição a+b a mais b 
+ Mais unitário +a o mesmo que a 
- Subtracção a-b a menos b 
- Menos unitário -a a com sinal negativo 
DIV Divisão Inteira a DIV b Divisão inteira de a por b 
MOD Resto da divisão (de 
Inteiros) 
a MOD b Resto da divisão de a por b 
 
O sinal de adição (+) pode ser usado para uma operação de concatenação de caracteres 
(soma de uma cadeia de caracteres encadeando o primeiro operando imediatamente com 
o segundo operando, sendo seu comprimento final igual à soma dos comprimentos dos 
operandos). 
Introdução a Informática (Gabriel Salimo) Pagina 10 de 72 
 
Exemplo: 
a) 'AB'+'EFG' , é = 'ABEFG'; 
b) a = “tele”, b=”Visao”; c=a+b => c=”televisao” 
 
Program Operadores_aritimeticos; 
(* PROGRAMA EXEMPLO : Mostra como utilizar operadores 
 Autor : Crocodilo 
 Data : 30/07/2018 *) 
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. 
 
4.4. Operadores Atribuição 
Sintaxe: Identificador := expressão/dado 
 
Exemplo: 
a) nome := “Engenharia Quimica” 
b) ano := 1999 ! valores numéricos não precisam de àspas “” no final 
c) data := “20\11\98” 
d) temp(1) := 25.6 
e) temp(2) := 22.4 ! atribuindo valores a vetores 
f) temp(3) := 22.8 
 Dois pontos em seguida (..) indica um delimitador de faixa. 
 
Exemplo: 
1..30 - todos números inteiros entre 1 e 30 inclusive. 
 
4.5. Operadores Relacionais 
Operador Definição Uso do Operador Significado 
= Igual a a=b a = b ? 
<> Diferente de a<>b a ≠ b ? 
< Menor que a<b a < b ? 
<= Menor ou igual a<=b a ≤ b ? 
> Maior que a>b a > b ? 
>= Maior ou igual a>=b a ≥ b ? 
IN Elemento de a IN [1..10] a Є {1,2,3,4,5,6,7,8,9,10}? 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 11 de 72 
 
Exemplos: 
1) Se A=30 e B=50, então 
- ( A = B ) é FALSE 
- ( A < B ) é TRUE 
2) Se A=TRUE e B=FALSE então 
- (A <> B) é TRUE 
- (A = B) é FALSE 
3) Se A=50 , B=35, C='A' , D='B' então 
- ( ( A < B ) OR ( C < D ) ) é TRUE 
 
4.6. Operadores Lógicos 
 
Operador 
 
Definição 
Uso do 
Operador 
 
Significado 
NOT Negação Lógica NOT a Complemento de a: se a é verdade, então 
.NOT.a é falso, se a é falso então .NOT.a. é 
verdade. 
AND Conjunção lógica a AND b Produto Booleano de a por b: se a e b são 
verdade, então a.AND.b é verdade; se a ou b 
ou ambos são falsos, então a.AND.b é falso. 
OR Disjunção 
Inclusiva lógica 
a OR b Soma Booleana de a com b: se a ou b ou ambos 
são verdade, então a.OR.b é verdade; se a e 
b são falsos, então a.OR.b é falso. 
XOR Disjunção 
Exclusiva lógica 
a XOR b operação XOR resulta TRUE quando os 
operandos forem diferentes entre si, isto é, 
quando um for TRUE o outro dever ser FALSE 
 
Exemplo: Se desejarmos testar se o valor da variável A satisfaz a inequação: 0≤A≤10, na 
linguagem PASCAL devemos utilizar: 0 <= a AND a >= 10 
 
Program operadores_logicos; 
(*PROGRAMA EXEMPLO : utilização os operadores lógicos 
 Autor : Crocodilo 
 Data : 30/07/2018 *) 
Uses CRT; 
Var x,y : boolean; 
Begin 
 x:=TRUE; 
 y:=FALSE; 
 Writeln( x OR y ); (* escreve TRUE *) 
 Writeln( x AND y ); (* escreve FALSE *) 
 Weiteln( x XOR y ); (* escreve TRUE *); 
End. 
 
5. Tipo de Dados 
 
Os dados usados em programação, podem ser divididos numa primeira análise em: dados 
simples (numéricos, caracteres, lógicos e booleanos) e dados estruturados (strings, arrays, 
records, files, set e text). 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 12 de 72 
5.1. Dados Simples (Escalares Simples) 
a) Numéricos Inteiros 
Tipo Faixa Formato 
Shortint 
Integer 
Longint 
Byte 
Word 
-128..127 
-32768..32767 
-2147483648..2147483647 
0..255 
0..65535 
Signed 8-bit 
Signed 16-bit 
Signed 32-bit 
Unsigned 8-bit 
Unsigned 16-bit 
 
b) Numéricos Reais 
Tipo Faixa Dígitos Bytes 
Real 
Single 
Double 
Extended 
Comp 
2.9e-39..1.7e38 
1.5e-45..3.4e38 
5.0e-324..1.7e308 
3.4e-4932..1.1e4932 
-9.2e18..9.2e18 
11-12 
7-8 
15-16 
19-20 
19-20 
6 
4 
8 
10 
8 
 
 o que distingue os dados do tipo numérico inteiros dos dados do tipo numéricos reais 
é que os reais admitem a parte decimal e os inteiros não... 
 
c) Caracter: CHAR 
O tipo char corresponde a todos os caracteres que podem ser gerados pelo teclado 
tais como dígitos, letras e símbolos tais como &, #,* etc. 
 
 os caracteres devem sempre ser representados entre aspas simples 
 
d) Lógicos: BOOLEAN 
O tipo boolean só pode assumir os valores FALSE e TRUE. 
 
5.2. Dados Estruturados (Escalares Estruturados) 
a) Cadeia de caracteres: STRING 
Este tipo é chamado de estruturado ou composto pois é constituído a partir de um tipo 
simples que é o char. O tipo string é composto por um conjunto de caracteres entre aspas 
simples. 
 
 os dados arrays, records, files, set e text serão descritos mais em diantes. 
 
5.3. Declaração de Dados 
Como é sabido, todas as variáveis que forem utilizadas no corpo do programa, devem ser 
declaradas na área de declarações que pode ser subdividida em seis sub-áreas(Label, 
Const, Type, Var, Procedures, e Functions): 
 
5.4. Declaração de todas Dados: VAR 
Esta é a sub-área onde devemos declarar todas as variáveis que iremos utilizar em nosso 
programa; aqui se incluem varáveis do tipo standards (pertencentes a sintaxe do Pascal )e 
os tipos criados pelo programador neste mesmo programa ou importado. 
 
Sintaxe: 
[VAR mome_da_variavel1, ..., nome_da_variaveln: tipo1; 
mome_da_variavel1, ..., nome_da_variaveln: tipo2; 
... 
mome_da_variavel1, ..., nome_da_variaveln: tipoN;] 
Introdução a Informática (Gabriel Salimo) Pagina 13 de 72 
 
Exemplo: 
Program Declaracao_Var; (* cabeçalho do programa *) 
Var (* declaração de variaveis *) 
 idade, número_de_filhos : byte; 
 altura : real; 
 sexo : char; 
 nome : string[30]; 
 sim_ou_nao : boolean; 
 quantidade : integer; 
Begin (* início do programa *) 
 idade:=34; 
 número_de_filhos:=2; 
 sexo:='M'; 
 nome:='José'; 
 sim_ou_nao:=TRUE; 
 quantidade:=3245; 
End. 
 
 a palavra reservada VAR aparece uma única vez num programa; 
 lembre-se que o limite de caracteres numa linha é de 127; 
 uma única linha pode agregar mais que uma instrução desde que estas instruções 
estejam separadas entre si por ponto e vírgula ';'. 
 
5.5. Declaração de Novos Tipos Dados: TYPE 
Além dos tipos de dados pré-definidos no Turbo Pascal, podemos também definir novos 
tipos através da declaração Type. 
 
Sintaxe: TYPE identificador = (valor1,valor2,valor3,valor4, ... ,valorN); 
 o identificador deve seguir as regras de um identificador anteriormente apresentadas; 
 nos parênteses estão os valores que a variável (identificador) deve assumir. 
 
Exemplos: 
Type 
 cor = (azul,vermelho,branco,verde,amarelo); 
 dia_útil = (segunda,terça,quarta,quinta,sexta); 
 linha = string[80]; 
 idade = 1..99; 
 (* agora também podemos utilizar os novos tipos tal como: cor, dia_útil, linha e idade *) 
Var 
 i : integer; 
 d : idade; 
 nome : linha; 
 dia : dia_útil; 
 cores : cor; 
 (* etc. *) 
 
5.6. Declaração de Constantes: CONST 
Nesta sub-área, podemos definir tantas constantes quantas quisermos. Para além da 
declaração de variáveis como na sub-área Var, aqui elas são inicializadas, ou seja, são 
atribuidos um valor inicial. 
 
Sintaxe: [CONST nome_da_constante1=valor[,...],[nome_da_constanten=valor];] 
Introdução a Informática (Gabriel Salimo) Pagina 14 de 72 
 
5.7. Constantes Tipadas 
Exemplo: 
Const 
 Meu_nome = 'Thelmo'; 
 cor_preferida = 'verde'; 
 número_m ximo = 24345; 
(* e assim por diante *) 
 
5.8. Constantes pré-Definidas 
Existem algumas constantes pré-definidas e que podemos utiliza-las sem ter que declará-
las. São elas: 
 
PI = 3.1415926536E + 00 
FALSE 
TRUE 
NIL (…Pointer nulo, veremos mais adiante…) 
MAXINT = 32767 
 
 toda vez que nos referirmos ás constantes acima, o Turbo Pascal substituirá pelos 
seus respectivos valores. 
 
5.9. Caracteres de Controle 
Existem alguns caracteres que têm significados e efeitos especiais quando o programa 
é executado: 
 
Exemplos: 
Control G - Bell ou beep (som) 
Contorl L - Form Feed (avanço) 
 
Também podemos usar estes caracteres, escrevendo pelo seus valores em ASCII 
correspondentes precedidos do símbolo #, ou então a letra correspondente precedida do 
símbolo ^ 
 
Exemplo: Control G #7 ou ^G 
 
5.10. Entrada e saída de dados 
 
5.11. Saída na Tela: WRITE e WRITELN 
Estes são as principais procedures destinadas a exibir todos os tipos de dados no vídeo. A 
diferença entre write e writeln reside no fato de que a procedure write escreve o 
parâmetro, e mantém o cursor do lado daquilo que foi escrito, enquantoque writeln passa 
o cursor para a próxima linha. 
 
Estas procedures possuem 3 formas de sintaxes, a saber: 
 
Sintaxe (Primeira Forma): WRITE(parâmetro_1,Parâmetro_2, ...); 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 15 de 72 
Program Exemplo_Write1; 
Uses CRT; 
Var i : integer; 
 r : real; 
 c : char; 
 s : string[20]; 
Begin 
 ClrScr; (* apaga a tela e coloca o cursor em 1,1 *) 
 Writeln('Exemplos de aplicação de writeln e write'); 
 writeln; (* apenas pula uma linha *) 
 i:=100; r:=3.14; c:='A'; s:='interessante'; 
 writeln('Valor de i e igual a ',i); 
 write('valor de r = '); 
 writeln(r); writeln(c,' ',s); 
End. 
 
Sintaxe (Segunda Forma): WRITE(parâmetro : n); 
 
 onde n é um número inteiro que determina quantas colunas o cursor deve ser deslocado 
à direita, antes do parâmetro ser escrito; além disso, o parâmetro é escrito da direita 
para a esquerda. 
 
Program Exemplo_Write2; 
Uses CRT; 
Begin 
 Writeln('A'); 
 Writeln('A':5); 
End. 
 
Sintaxe (Terceira forma): WRITE(parâmetro : n : d); 
 
 neste caso, n tem a mesma função que o caso anterior sendo que d, representa o número 
de casas decimais; obviamente, o parâmetro terá que ser do tipo Real. 
 
Program Exemplo_Write3; 
Uses CRT; 
Var r : real; 
Begin 
 ClrScr; 
 r:=3.14156; 
 Writeln(r); 
 Writeln(r:10:2); 
End. 
 
5.12. Entrada: READ e READLN 
Estas procedures são utilizadas para fazer leitura de dados via teclado. A procedure 
Read lê um dado do teclado até que se pressione a tecla ENTER, sendo que cada tecla 
digitada é ecoada para o vídeo. Após pressionarmos ENTER, o cursor permanecer no 
mesmo lugar; enquanto que, a procedure Readln faz a mesma coisa só que o cursor passa 
para a próxima linha. 
 
Sintaxe: READ(Var_1,Var_2,Var_3,...); 
 
 ao se digitar os valores das variáveis pedidas, deve-se separá-los por espaços. 
Resultados Exemplo1 
Exemplos de aplicação de writeln e write 
 
Valor de i e igual a 100 
valor de r = 3.1400000000E+00 
A interessante 
 
Resultado Exemplo2 
 
A 
…..A 
 
Nb: Os pontos representam 
espaços em branco 
Resultado Exemplo3 
 
 
3.1415600000E+00 
 3.14 
Introdução a Informática (Gabriel Salimo) Pagina 16 de 72 
 
Program Exemplo_Read1; 
Uses CRT; 
Var a,b,c:integer; 
Begin 
 clrscr; 
 readln(a,b,c); 
 writeln (a,' ',b,' ',c); 
End. 
 
Program Exemplo_Read2; 
Uses CRT; 
Var i : integer; r : real; c : char; s : string[10]; 
 Begin 
 ClrScr; 
 Write('Digite um numero inteiro: '); Readln(i); 
 Write('Digite um numero real:'); Readln(r); 
 Write('Digite um caractere: '); Readln(c); 
 Write('Digite uma string: '); Readln(s); 
 Writeln;Writeln; (* pula duas linhas *) 
 Writeln(i); Writeln(r); Writeln(c); Writeln(s); 
 End. 
 
Program Area_de_Triangulos; 
Uses CRT; 
Var Base,(* base do triangulo *) altura: (* altura do triangulo *) Real; 
Begin 
 ClrScr; Writeln('CALCULO DA AREA DE TRIANGULOS':55); 
 Writeln; Write('Valor da base:'); Readln(base); 
 Writeln; Write('Valor da altura:'); Readln(altura); 
 Writeln; Writeln; Writeln('Area do triangulo = ',base*altura/2 : 10 : 2); 
End. 
 
 ReadKey: Lê uma tecla do teclado, sem que seja necessário pressionar a tecla ENTER 
 
Program Exemplo_Readkey; 
Uses CRT; 
Var tecla:char; 
Begin 
 Write('digite uma tecla:'); 
 Tecla:=readkey; 
 Writeln; writeln('você digitou ',tecla); 
End. 
 
5.13. Saída na Video/Impressora: WRITE e WRITELN 
Podemos enviar dados para a impressora através das procedures Write e Writeln. Para 
tanto, devemos colocar, antes dos parâmetros a serem enviados à impressora, o nome 
lógico LST. 
 
Sintaxe: WRITE(LST,informação) 
 
 LST - nome da impressora; quando não presente os dados são enviados para o 
monitor 
 informação - representa variáveis ou constantes dos dados a serem escritos no ficheiro. 
Introdução a Informática (Gabriel Salimo) Pagina 17 de 72 
 
Exemplo: 
Writeln('isto vai para o vídeo'); 
Writeln(lst,'isto vai para a impressora',' e isto também'); 
 
5.14. Funções e Procedures para Controlo de Vídeo 
ClrScr 
Esta procedure tem a finalidade de limpar a tela de vídeo e colocar o cursor na primeira 
coluna da primeira linha. A tela de vídeo é dividida em 80 colunas e 25 linhas. O canto 
superior esquerdo tem coordenadas (1,1) e o inferior direito (80,25). 
 
Gotoxy(x,y) 
Move o cursor para a coluna x e linha y. 
 
Program Posicionamento_Gotoxy; 
Uses CRT; 
Var x,y : Byte; 
Begin 
 ClrScr; Gotoxy(10,2); Write('Coluna 10 da linha 2'); 
 x:=40; y:=10; 
 Gotoxy(x,y); Write('Coluna 40 da linha 10'); 
End. 
 
ClrEol - Esta procedure limpa desde a posição actual do cursor até o final da linha. 
CrtExit - Envia para a tela de vídeo a string de finalização definida na 
instalação. 
Crtnit - Envia para a tela de vídeo a string de inicialização definida na 
instalação. 
Delline - Elimina a linha em que está o cursor. As linhas posteriores sobem, 
ocupando a que foi eliminada. 
 
Program PosicaoEliminar; 
Uses CRT; 
Begin 
 ClrScr; Writeln('linha 1'); Writeln('linha 2'); 
 Writeln('linha 3'); 
 Writeln('linha 4'); 
 Gotoxy(1,2);(* posicionei o cursor no início da linha 2 *) 
 Delline; 
End. 
 
Insline - Esta procedure faz exactamente o Contrário de Delline, ou seja, insere uma 
linha na posição actual do cursor. 
 
 
Resultado do PosiçãoEliminar 
linha 1 
linha 3 
linha 4 
Nb: repare que a string 'linha 2' foi eliminada. 
Introdução a Informática (Gabriel Salimo) Pagina 18 de 72 
Program PosicaoInserir; 
Begin 
 ClrScr; 
 Writeln('linha 1'); 
 Writeln('linha 2'); 
 Writeln('linha 3'); 
 Writeln('linha 4'); 
 Gotoxy(1,3);(* cursor na 1ª coluna da 3ª linha *) 
 InsLine; 
 Write('teste'); 
 Gotoxy(1,20); 
End. 
 
LowVideo - Coloca o vídeo em baixa intensidade até que se execute a 
procedure NormVideo ou HighVideo. 
NormVideo - O mesmo que HighVideo. 
TextBackGround - Esta procedure selecciona a cor do fundo sobre o qual o texto 
ser escrito. 
 
Sintaxe: TextBackGround(cor); 
 
Tabela de cores 
 0 Black Preto 
 1 Blue Azul 
 2 Green Verde 
 3 Cyan Ciano 
 4 Red Vermelho 
 5 Magenta Magenta 
 6 LightGray Cinza-claro 
 
 Pode-se substituir/atribuir ao identificador “cor” pelo número ou o nome da cor em inglês 
apresentados na tabela 
 
Program CoresFundo; 
Uses CRT; 
Begin 
 ClrScr; 
 WriteLn('teste'); 
 TextBackGround(7); 
 Writeln('teste'); 
 TextBackGround(Brown); 
 Writeln('teste'); 
End. 
 
TextColor - Esta procedure permite seleccionar a cor com que o texto deve ser 
impresso. 
Tabela de cores 
0 Black Preto 
1 Blue Azul 
2 Green Verde 
3 Cyan Ciano 
Resultado do InserePosição 
 
linha 1 
linha 2 
teste 
linha 3 
linha 4 
 
Nb: repare que a string 'teste' foi 
inserida entre as linhas 2 e linha 3 
Introdução a Informática (Gabriel Salimo) Pagina 19 de 72 
4 Red Vermelho 
5 Magenta Magenta 
6 Brown Marrom 
7 LightGray Cinza-claro 
8 DarkGray Cinza-escuro 
9 LightBlue Azul-claro 
10 LightGreen Verde-claro 
11 LightCyan Ciano-claro 
12 LightRed Vermelho-claro 
13 LightMagenta Magenta-claro 
14 Yellow Amarelo 
15 White Branco 
16 Blink Piscante 
 
Program CoresTexto; 
Uses CRT; 
Begin 
 Clrscr; 
 TextBackGround(7); 
 TextColor(black); 
 writeln('teste'); 
 TextColor(black+blink); 
 write('teste'); 
End. 
 
Window 
Procedure para o desenho de janela de texto dada as coordenadas do canto esquerdo 
superior e canto inferior direito. 
 
Sintaxe: WINDOW(1,y1,x2,y2); 
 
 Esta procedure tem o poder de definir uma janela de texto cujo canto esquerdo superior 
é x1,y1 e canto inferior direito é x2,y2. Após esta instrução, as instruções ClrScr, Write 
Writeln agem somente dentro da janela recém definida. 
Program Janela;Uses CRT; 
Begin 
 Window(10,10,70,20); 
 ClrScr; (* limpa somente a janela *); 
 Writeln('teste'); (* escreve 'teste' em 10,10 *) 
End. 
 
5.15. Funções e Procedures para Controlo do Teclado 
Kbd 
Quando quisermos ler dados do teclado, e que não sejam ecoados para o monitor de 
vídeo até que sejam processados e aceites, utilizar-se: 
 
Sintaxe: READ(Kbd,Variável); 
 
 no caso de números inteiros ou reais, o número só será aceite quando pressionarmos 
a tecla <enter>; 
Introdução a Informática (Gabriel Salimo) Pagina 20 de 72 
 no caso de variáveis do tipo char, o caractere ser aceito sem que seja necessário 
pressionar a tecla <enter>, idem para o tipo string. 
 
Program Read_Kbd; 
Uses CRT; 
Var i:integer; 
Begin 
 ClrScr; 
 Write('Entre com um inteiro '); 
 Readln(Kbd,i); 
 Writeln(i); 
End. 
 
BufLen 
Buflen é uma variável interna pré-definida em Turbo Pascal cujo valor inicial é 126. Ela 
contém o número máximo de caracteres aceitos por Read. 
 
Program Exemplo_Buflen; 
Uses CRT; 
Var i : Integer; 
Begin 
 ClrScr; 
 Writeln(Buflen); (* escreve 126 *) 
 Buflen:=2; 
 Write('Digite um inteiro '); 
 Readln(i); (* readln não permitir inteiros com mais de dois dígitos, *) 
End. 
 
Keypressed 
O identificador Keypressed é uma função especial do Turbo Pascal que retorna um valor 
booleano - TRUE se uma tecla foi pressionada, ou FALSE caso Contrário. Ela é muito utilizada 
para detectar teclas pressionadas no teclado. 
 
Program Exemplo; 
Uses CRT; 
Begin 
 ClrScr; 
 Write('Pressione uma tecla '); 
 Repeat until Keypressed; (* repita até que uma tecla seja pressionada. *) 
End. 
 
6. Estruturas Para o Controlo do Fluxo do Programa 
A sequência de instruções num programa considera-se simples quando elas se apresentam 
uma ordem de execução uma atrás da outra de cima para baixo e sem “saltos”. Porém, 
frequentemente é necessário alterar a sequência linear da execução; aí temos então 
instruções estruturadas ou estruturas de controlo. 
 
6.1. Estrutura de Decisão ou Escolha Condicional (Simples): IF-THEN-ELSE 
O comando IF permite ao programa tomar decisões de sequencia do curso da execução das 
instruções/comandos com base numa condicão. Ele pode ter duas sintaxes: 
 
Sintaxe (Primeira Forma): IF <expressão_lógica> THEN Comando; 
Introdução a Informática (Gabriel Salimo) Pagina 21 de 72 
 expressão_lógica pode ser simples ou até relações complexas; 
 Se a expressão_lógica resultar verdadeira (TRUE), então o comando será executado e 
no caso contrário nada será executado; 
 Para os casos em que tivermos mais de um comando para serem executados, eles 
deverão vir delimitados pelas palavras BEGIN e END, como se apresenta em seguida: 
 
IF <expressão_lógica> THEN 
BEGIN 
 Comando_1; 
 Comando_2; 
 Comando_3; 
 . . . 
END; 
 
Program Exemplo_IF_1; 
Uses CRT; 
Var i : Integer; 
Begin 
 Clrscr; Write('Digite um inteiro maior que 100:'); Readln(i); 
 Writeln; Writeln; 
 If (i>100) Then Writeln('Você conseguiu!') 
 Else Writeln(i,' não é maior que 100…'); 
End. 
 
Sintaxe (Segunda Forma): IF <expressão_lógica> THEN Comando_1 ELSE Comando_2; 
 
 Neste caso, se expressão_lógica for verdadeira (TRUE) então Comando_1 será 
executado e comando_2 não será executado, e no caso contrário, o Comando_2 será 
executado e Comando_1 não será executado. 
 E, no caso de ter mais que um comando para executar a delimitação com BEGIN e END 
será: 
 
IF <expressão> THEN 
 BEGIN 
 Comando_1; 
 Comando_2; 
 . . . 
 END (* não tem ; *) 
ELSE 
 BEGIN 
 Comando_3; 
 Comando_4; 
 . . . 
END; 
 
Program Exemplo_IF_2; 
(*Programa para determinar o maior numero entre dois lidos do teclado*) 
Uses CRT; 
Var N1, N2 : Integer; 
Begin 
 ClrScr; 
 Write('Digite o Primeiro numero :'); Readln(N1); 
 Write('Digite o Segundo numero: '); Readln(N2); 
 Writeln; Writeln; 
Introdução a Informática (Gabriel Salimo) Pagina 22 de 72 
 If (N1 > N2) Then Write(N1,' é o maior') 
 Else If (N2 > N1) Then Writeln(N2,' é o maior') 
 Else Writeln('São iguais'); 
End. 
 
6.2. Estrutura de Decisão ou Escolha Condicional (Múltipla): CASE 
Instrução para seleccionar a opção entre várias opções baseada no valor de uma variável 
ou expressã: 
 
Sintaxe (Primeira Forma): 
 
CASE <expressão ou variável> OF 
<valor 1> : Comando_1; 
<valor 2> : Comando_2; 
. . . 
<valor n> : Comando_n; 
END; 
 
ou 
 
CASE <expressão ou variável> OF 
<valor 1> : BEGIN 
 Comando_1; 
 Comando_2; 
 . . . 
 END; 
<valor 2> : BEGIN 
 Comando_1; 
 Comando_2; 
 . . . 
 END; 
 . . . 
<valor n> : BEGIN 
 Comando_1; 
 Comando_2; 
 . . . 
 END; 
END; 
 
 A expressão ou variável no comando Case deve ser do tipo simples, normalmente Char 
ou Integer. Após a avaliação da expressão, seu valor ou o valor da variável é 
comparado com os diversos valores discriminados. Se houver algum que satisfaça, 
o comando subsequente será executado. 
 
Sintaxe (Segunda Forma): 
 
CASE <expressão ou variável> OF 
<valor 1> : Comando_1; 
<valor 2> : Comando_2; 
. . . 
<valor n> : Comando_n; 
ELSE Comando; 
END; 
 
Introdução a Informática (Gabriel Salimo) Pagina 23 de 72 
 Neste caso, se o resultado da expressão ou o valor da variável não satisfizer nenhum 
dos valores discriminados, então o comando que estiver na frente da cláusula Else será 
executado. 
 
Program Exemplo_Case_1; 
Uses CRT; 
(* Calcula a soma, ou a subtracção, ou a multiplicação, ou a divisão entre dois números lidos 
do teclado*) 
Var oper : Char; 
 x,y : Real; 
Begin 
 ClrScr; 
 Write('Valor de X = '); Readln(x); 
 Write('Valor de Y = '); Readln(y); 
 Writeln; Write('Operação? '); 
 oper:=ReadKey; 
 Writeln(oper);Writeln; 
 Case Oper of 
 '+' : Write('X + Y = ':10,x+y:6:2); 
 '-' : Write('X - Y = ':10,x-y:6:2); 
 '*' : Write('X * Y = ':10,x*y:6:2); 
 '/' : Write('X / Y = ':10,x/y:6:2); 
 Else Writeln(oper,' nao e operação'); 
 End; (* case *) 
End. (* programa *) 
 
Program Exemplo_Case_2; 
Uses CRT; 
(* Identificação das fases da lua *) 
Var mudancas,fase,dias:integer; 
BEGIN 
 write('Nº de dias decorridos desde o início do ano:'); 
 read(dias); 
 mudancas:=dias div 7; dias:= dias mod 7; 
 fase:=mudancas mod 4; 
 if dias=0 then fase:=fase-1; 
 case (fase) of 
 0:writeln('Lua Nova'); 
 1:writeln('Quarto Crescente'); 
 2:writeln('Lua Cheia'); 
 3:writeln('Quarto Minguante'); 
 end; 
END. 
 
6.3. Instrução de “Salto” Incondicional: GOTO 
A instrução Goto permite desviar a sequência de execução do programa para um 
determinado Label pré-definido. Para utilizarmos algum Label, ele deve, obrigatoriamente, 
ser declarado na subárea Label. 
 
Program Exemplo_GoTo_1; 
(*Programa para colocar em ordem crescente 3 números lidos do teclado*) 
Uses CRT; 
Label Inicio; 
Var x,y,z : Integer; 
Introdução a Informática (Gabriel Salimo) Pagina 24 de 72 
tecla : Char; 
Begin 
Inicio: 
 ClrScr; 
 Write('Primeiro numero: '); Readln(x); 
 Write('Segundo numero: '); Readln(y); 
 Write('Terceiro numero: '); Readln(z); 
 Writeln; Writeln; 
 If (x>=y) Then 
 If (x>=z) Then 
 If (y>=z) Then Writeln(x,' ',y,' ',z) 
 Else Writeln(x,' ',z,' ',y) 
 Else Writeln(z,' ',x,' ',y) 
 Else If (y>=z) Then 
 If (x>=z) Then Writeln(y,' ',x,' ',z) 
 Else Writeln(y,' ',z,' ',x) 
 Else Writeln(z,' ',y,' ',x); 
Writeln; Write('Deseja Continuar: '); 
Tecla:=Readkey; 
If ((Tecla = 'S') OR (Tecla = 's')) Then Goto Inicio; 
End. 
 
6.4. Estrutura de Repetição com Contador: Ciclo FOR 
Este comando permite que um grupo de operações ou comandos sejam repetidos um certo 
número de vezes determinados. 
 
Sintaxe Geral: FOR <variável> := <valor inicial> TO/DOWNTO <valor final> DO 
<comando>; 
 
 A variável deverá ser, obrigatoriamente, do tipo integer (qualquer um), char ou 
Boolean; 
 A variação de variável entre valor inicial e valor final será crescente e de um em um, 
quando utilizamosa palavra TO; e decrescente de um em um, quando utilizamos a 
palavra DOWNTO. 
 
Program Exemplo_For_1; 
Uses CRT; 
Var i : Integer; 
Begin 
 ClrScr; 
 For i:=10 to 15 do Writeln(i); (* para i igual a 10 até 15 faça escreva i *) 
End. 
Program Exemplo_For_2; 
Uses CRT; 
Var i : Integer; 
Begin 
 ClrScr; 
 For i:=10 downto 1 do Writeln(i); 
End. 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 25 de 72 
Program Exemplo_For_3; 
Uses CRT; 
{ Este programa escreve na tela os quadrados dos números de 1 até 20 } 
Var i : Integer; 
Begin 
 ClrScr; 
 For i:=1 to 20 do 
 Begin 
Write('O Valor ',i:3); 
Writeln(', o quadrado é ',(i*i:5)); 
 End; 
End. 
 
6.5. Estrutura de Repetição Baseada numa Condição: Ciclo REPEAT UNTIL 
Repete um bloco de instruções até que uma certa condição seja satisfeita. 
 
Sintaxe: 
 
REPEAT 
 Comando_1; 
 Comando_2; 
 Comando_3; 
 . . . 
UNTIL (expressão_lógica); 
 
 Neste caso, todos os comandos entre as palavras reservadas Repeat e Until serão 
executadas, até que a expressão lógica seja verdadeira (TRUE) 
 
 Nos ciclos devemos tomas especial atençãocom as condições, pois no caso de nunca 
alcalçar a verdade(TRUE) em nhenhum momento teremos um LOOP INFINITO, (o 
programa fica preso dentro da estrutura Repeat - Until). 
 
Program Exemplo_Repeat_1; 
Uses CRT; 
(* Programa exemplo para mostrar o funcionamento da estrutura Repeat Until *) 
Var i : Integer; 
Begin 
 ClrScr; 
 i:=1; 
 Repeat 
 Writeln(i); 
 i:=i+1; 
 Until i=10; 
End. 
 
Program Exemplo_Repeat_2; 
Uses CRT; 
(* Soma dos números pares compreendidos entre dois números lidos do teclado*) 
Var i, numero_1, numero_2, soma: Integer; 
Begin 
 Clrscr; 
 soma:=0; 
 Write('Primeiro Numero: '); Readln(numero_1); 
 Write('Segundo Numero: '); Readln(numero_2); 
Introdução a Informática (Gabriel Salimo) Pagina 26 de 72 
 i:=numero_1; 
 Repeat 
 If i MOD 2 = 0 then soma:=soma+i; (* Verifica se o número é par, se sim adiciona *) 
 i:=i+1; 
 Until i>numero_2; 
 Writeln;writeln; 
 Writeln('Soma dos números pares entre ’, numero_1,' e ',numero_2,' é igual a ',soma); 
End. 
 
6.6. Estrutura de Repetição Baseada numa Condição: Ciclo WHILE DO 
A estrutura While..Do, permite controlar o número de vezes que uma instrução ou bloco de 
instruções será executado. 
 
 While..Do, difere da instrução Repeat..Until porque esta só avalia a expressão lógica 
no final do primeiro Loop, enquanto que a instrução While..Do avalia a expressão 
lógica antes da primeira interacção, isto significa que, eventualmente, no While..Do 
pode não ocorrer sequer a primeira interacção. 
 
Sintaxe: WHILE <expressão_lógica> DO <comando>; 
 
ou 
 
WHILE <expressão_lógica> DO 
BEGIN 
 Comando_1; 
 Comando_2; 
 . . . 
END; 
 
Program Exemplo_While_1; 
Uses CRT; 
(* Programa que escreve na tela de 0 até 10*) 
Var i : Integer; 
Begin 
 ClrScr; 
 i:=0; 
 While (i<11) Do 
 Begin 
 Writeln(i); 
 i:=i+1; 
 End; 
End. 
 
 
Program verificar_se_primo; 
uses crt; 
var e_primo,contador,divisores:integer; 
BEGIN 
writeln('Insira um número inteiro para verificar se é primo:'); 
read(e_primo); 
contador:=1; 
divisores:=0; 
while (contador<=e_primo) do 
Introdução a Informática (Gabriel Salimo) Pagina 27 de 72 
 begin 
 if (e_primo mod contador = 0) then divisores:=divisores+1; 
 contador:=contador+1; 
 end; 
 if (divisores <=2) then writeln('O número ',e_primo,' é primo.') 
 else writeln('O número ',e_primo,' não é primo.'); 
END. 
 
 
7. Outros Tipos Dados Estruturados 
 
Para além do String, existem outros tipos de dados chamados complexos ou estruturados, 
tais como: Array, Record, Set e File. 
 
 O tipo file refere-se a arquivos de discos e será amplamente estudado num capítulo à 
parte... 
 
7.1. Tipo Arrays: Variáveis Indexadas Uni-Dimensionais (Vectores) 
Uma variável uni-dimencional é um “Vector” aonde é possível definir a variável com 
quaisquer tipo de dados válidos no Pascal. 
 
Array é um tipo estruturado que pode agrupar numa mesma variável um conjunto de valores 
do mesmo tipo. 
 
 Uma variável do tipo array, como qualquer variavel, é designada por um identificador 
que, neste caso, é o mesmo para todos os elementos do conjunto. 
 Apesar de um array ter um so identificador para todos os elementos que agrupa, cada 
elemento desse agrupamento tem um ou mais indices associados. 
 Sao os indices que permitem identificar cada elemento individual no conjunto 
representado pelo array. 
 Há arrays unidimensionais (vectores) e arryas multidimensionais (matrizes). 
 
Um array unidimensional – que tambem é costume designar por vector - é um conjunto de 
elementos representados por um identificador e um indice; este ultimo varia entre um limite 
inferior e um limite superior, em correspondencia com o numero de elementos do conjunto. 
Sintaxe: VAR <identificador>: ARRAY [iINICIO..iFIM] OF <tipo>; 
 
 “ARRAY” é uma palavra reservada do Pascal 
 Os valores “iINICIO” e “iFIM” correspondem aos índices inicial e final 
 Uma variável indexada pode ser apenas de um tipo de dado 
 
Exemplo 1: Definir uma variável indexada como sendo do tipo REAL, sendo que a mesma 
deverá corresponder a 10 posições de memória. 
 
VAR 
 Vet: ARRAY [1..10] OF REAL; 
Após a definição da variável, a memória estará como mostrado no esquema abaixo: 
 
Vet 
 
 1 2 3 4 5 6 7 8 9 10 
Introdução a Informática (Gabriel Salimo) Pagina 28 de 72 
 Os Valores numéricos apresentados acima (de 1 a 10) correspondem aos índices da 
variável. 
 
Exemplo 2: Suponhamos que pretendiamos representar num programa os gastos de um 
determinado departamento em cada um dos 12 meses do ano. Evidentemente, poderiamos 
definir 12 variaveis, designadas por 12 identificadores diferentes; por exemplo: jan, fev, 
mar, ou m1, m2, m3, etc... 
 
Todavia, o uso de uma varaivel estruturada, neste caso, array, com um único identificador 
agrupando os 12 elementos em causa revela-se uma tecnica muito mais economica em termos 
de escrita, encerra muito mais potencialidades de manipulação em termos de programação. 
 
Neste caso, poderiamos definir um array mediante um unico identificador, por exemplo : 
gastosmes. 
 
Mas, para que esse identificador possa representar os 12 elementos correspondentes aos 
12 meses de um ano, temos de utilizar indices. 
 
Em pascal poderiamos escrever assim: Var gastosmes : array[1..12] of real; 
 
Depois de declarada ou definida uma variavel do tipo array, a designação individual de 
cada um dos seus elementos faz-se escrevendo o identificador da variavel, seguido do seu 
indice entre parentesis rectos. 
 
De um modo geral, cada elemento desta variavel do tipo array designa-se por: gastosmes[i] 
em que [i] representa a posição do elemento no conjunto que compoe o array, ou seja, neste 
caso, o numero do mês que se pretende designar. 
 
Por exemplo, tendo em conta a declaração anterior da variavel “gastosmes”, os seus 12 
itens ou elementos seriam asssim designados: 
 
Identificador: Gastos do mes: 
gastosmes[1] Janeiro 
gastosmes[2] Fevereiro 
..... 
gastosmes[12] Dezembro. 
 
7.1.1.1. Utilização da variável array para Leitura, Escrita e Atribuição 
Se quisermos utilizar uma variavel do tipo array com qualquer uma das três instruções básicas 
(leitura, escrita, atribuição), apenas temos de ter em conta o identificador do array e os 
respectivos índices. 
 
Exemplos 
 
1) Instrução de leitura: Read(gastosmes[1]) 
Faz a leitura do valor dos gastos do mês do indice 1, ou seja, Janeiro. 
 
2) Instrução de atribuição: Gastosmes[4]:=25350 
Faz com que o elemento indice 4 do array, o mes de Abril, seja atribuido com o valor 
25350. 
 
3) Instrução de escrita: Write(‘Gastos do mes de Dezembro: ’, gastosmes[12]) 
Escreve a mensagem da string indicada, seguida do valor dos gastos do mes de 
Dezembro. 
Introdução a Informática (Gabriel Salimo) Pagina 29 de 72 
 
 No lugar onde se indicam os indicesdo array podem empregar-se variaveis, em vez de 
numeros inteiros directos, como por exemplo: 
 
M:=2; 
Gastosmes[m]:=3039; 
Write(‘Gastos do mes corrente: ’, gastosmes[m]); 
 
 Aonde a variavel “m” terá de ser definida como uma variavel de tipo inteiro, ou como 
subconjunto[1..12], de modo a ser compativel com o indice do respectivo array 
“gastosmes”. 
 
 Combinando uma estrutura de um array com um ciclo de repetição, podemos usar os 
respectivos indices na tecnica de iteração. 
 
No exemplo que se segue pretende-se calcular o total anual e a média dos gastos mensais 
do mesmo exemplo atras apresentado: 
 
 
Program Medias; 
Var m: integer; 
 Totalano, mediames : real; 
 Gastosmes : array[1..12] of real; 
Begin 
 Totalando:=0; 
 For m:=1 to 12 do 
 Begin 
 Writeln(‘Introduza o gasto do mes ’, m); 
 Readln(gastosmes[m]); 
 Totalano:=totalano+gastosmes[m]; 
 End; 
 Mediames:=totalano/12; 
 Readln; 
End. 
 
7.2. Tipo Arrays: Variáveis Indexadas Bidimensionais (Matrizes) 
Também conhecida por “Matriz”. Uma variável Bidimencional, como o próprio Nome já 
indica, possui duas dimensões, sendo ser possível definir variáveis com quaisquer tipo de 
dados validos do Pascal. 
 
Sintaxe: VAR <Nome>: ARRAY [I..J, L..M] OF <tipo>; 
 
 I,J,L e M - devem ser inteiros péviamnte declarados e inicializados (constantes). 
 
Exemplo: Definir uma variável indexada bidemensional para armazenar os dados de uma 
matriz 4 por 4 de números do tipo REAL, sendo que a mesma deverá corresponder no total 
a 16 posições de memória. 
 
VAR MAT: ARRAY [1..4,1..4] OF REAL; 
 
 Neste exemplo, após a definição da variável, a memória estará como mostrado no 
esquema abaixo: 
 
Introdução a Informática (Gabriel Salimo) Pagina 30 de 72 
 1,1 1,2 1,3 1,4 
MAT = 2,1 2,2 2,3 2,4 
 3,1 3,2 3,3 3,4 
 4,1 4,2 4,3 4,4 
 
 Os Valores numéricos apresentados acima correspondem aos índices da variável. 
 
Outros exemplos: Var a : array[1..10,2..5] Of Integer; 
 
Na declaraçäo acima, definimos um Array de 40 elementos chamado 'a'. Ele é constituído 
de 10 linhas numeradas de 1 a 10 por 4 colunas numeradas de 2 a 5. O acesso a cada 
elemento é feito da seguinte forma: 
 
 a[1,2] a[1,3] ... a[1,5] 
 a[2,2] a[2,3] ... a[2,5] 
 ... ... ... ... 
 a[10,2] a[10,3] ... a[10,5] 
 
Poderíamos definir o mesmo array da seguinte forma: Var a : array[1..10] of array[2..5] Of 
Integer; 
ou da seguinte forma: Type b = array[2..5] Of Integer; Var a : array[1..10] Of b; 
 
7.2.1.1. Iteração de um array bidimensional numa estrutura de ciclos encaixados 
Se quisermos utilizar tecnicas iterativas com arrays bidimemensionais, teremos de utilizar uma 
estrutura de ciclos encaicxados, ou seja, um ciclo dentro de outro ciclo; neste caso o ciclo com 
contador (coclo “For”) se apresenta mais apropriado. 
 
Por exemplo, para medir a introdução consecutiva de todos os valores da variavel “gaveta”, 
a melhor tecnica é precisamente a dos dois ciclos encaixados; assim: 
 
Gaveta : array[1..3, 1..4] of integer; 
 
For i:=1 to 3 do 
 For j:=1 to 4 do 
 Readln(gaveta[i, j]); 
 
Sintaxe (Atribuição): <Nome>[<Índice>,<Índice>]: =Valor; 
ou seja, 
 
READ (<Nome>[<Índice>,<Índice>]); 
 
PROGRAM Atribui; 
VAR 
 Nomes : ARRAY[1..4,1..4] OF STRING; 
 I,J : INTEGER; 
BEGIN 
 FOR I: = 1 TO 4 DO 
 FOR J := 1 TO 4 DO 
 READ (Nomes[ I,J] ); 
END. 
 
Introdução a Informática (Gabriel Salimo) Pagina 31 de 72 
7.3. Tipo Record 
O tipo Record introduz o conceito de estrutura heterogênea: estrutura que nos permite criar 
um tipo de dado que é composto de itens de vários tipos. Estes itens dos quais o tipo Record 
é formado recebem o nome de campos. 
 
 Imaginem que queiramos armazenar os seguintes dados a respeito de uma pessoa: 
Nome - Idade - Sexo - Altura 
 
Até o momento, näo temos nenhum tipo de variável capaz de fazer isso, pois como podemos 
reparar, os quatros itens säo de tipos diferentes, a saber: 
 
Nome => String; 
Idade => Integer; 
Sexo => Char; 
Altura => Real. 
 
 Em seguida, se apresenta a solução com base no tipo Record. 
 
Declaração de Records 
A definiçäo de uma variável do tipo record, começa com a palavra reservada Record, 
a qual é seguida pelos campos (variáveis) e os seus tipos. A palavra reservada End seguida 
de um ponto e vírgula, termina a definiçäo do Record. 
 
Sintaxe: 
VAR identificador-registo :RECORD 
 Identificador-campo1:<tipo>; 
 Identificador-campo1:<tipo>; 
 ... 
 Identificador-campo1:<tipo>; 
END; 
 
Exemplo: 
 
Var individuo : Record 
Nome : String[30]; 
Idade : Integer; 
Sexo : Char; 
Altura : Real; 
End; 
 
ou 
Type individuo = Record 
Nome : String[30]; 
Idade : Integer; 
Sexo : Char; 
Altura : Real; 
End; 
 
Var Registro:individuo; 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 32 de 72 
7.3.1.1. Acesso aos elementos da estrutura (Records) 
Para acessarmos os elementos da estrutura, ou seja, os campos, nós devemos incluir o 
nome da variável seguida de um ponto e depois o nome do campo. 
 
Exemplo: 
Registro.Altura := 1.78; 
Registro.Sexo := 'M'; 
Etc... 
 
Exemplo: 
Program Registo1; 
Uses CRT; 
(* Lê uma variável do tipo record do teclado e em seguida a mostra no monitor *) 
Type Pessoas = Record 
 Nome : String[30]; 
 Idade : Integer; 
 Sexo : Char; 
 Altura : Real; 
End; 
Var p : Pessoas; 
Begin 
 ClrScr; 
 Write('Nome: '); Readln(p.Nome); Write('Idade: '); Readln(p.Idade); 
 Write('Sexo: '); Readln(p.Sexo); Write('Altura: '); Readln(p.Altura); 
 Writeln; Writeln('Voce digitou os seguintes dados :'); 
 Writeln;Writeln; Writeln(p.nome); 
 Writeln(p.idade); Writeln(p.sexo); 
 Writeln(p.altura:6:2); 
End. 
 
Pode-se também definir arrays de records, como se pode ver no exemplo abaixo: 
 
Program Exemplo_2; 
Uses CRT; 
(******************************************************************************** 
ler dados (máximo 20 pessoas) e fazer uma listagem em ordem alfabética (nome) 
******************************************************************************) 
Label fim; 
Type Pessoas = Record 
 Nome : String[30]; 
 Idade : Integer; 
 Sexo : Char; 
 Altura : Real; 
End; 
Var p : array[1..20] of Pessoas; 
 i,x,y : Integer; 
 s : Pessoas; 
Begin 
 ClrScr; 
 i:=0; 
 Repeat 
 i:=i+1; 
 Write('Nome (0=fim): '); 
 Readln(p[i].Nome); 
Introdução a Informática (Gabriel Salimo) Pagina 33 de 72 
 if p[i].Nome='0' then goto fim; 
 Write('Idade: '); 
 Readln(p[i].Idade); 
 Write('Sexo: '); 
 Readln(p[i].Sexo); 
 Write('Altura: '); 
 Readln(p[i].Altura); 
 Writeln; 
 fim: 
 Until ((p[i].Nome='0') or (i=20)); 
 If i<20 then i:=i-1; 
 For x:=1 to i-1 do 
 For y:=x+1 to i do 
 If ((p[x].nome) >= (p[y].nome)) then 
 Begin 
 s:=p[x]; 
 p[x]:=p[y]; 
 p[y]:=s; 
 End; 
 ClrScr; 
 Writeln('NOME':30,'IDADE':6,'SEXO':5,'ALTURA':8); 
 For x:=1 to i do 
 Writeln(p[x].nome:30,p[x].idade:6,p[x].sexo:5,p[x].altura:8:2); 
 End. 
 
7.4. Tipo Set 
Na matemática, usamos uma linguagem näo só adequada às suas necessidades, mas 
também ao estudo de outras ciências. Uma boa parte dessa linguagem vem da teoria de 
conjuntos. 
 
Na linguagem Pascal, ao invés de difinirmos os conjuntos como sendo uma coleçäo de objetos, 
nomes, números etc., chamaremos de elementos aos objetos, nomes, números, etc. que 
pertencem a um conjunto; assim se considera, um conjunto é uma coleçäo de elementos 
semelhantes. O tamanho do conjunto pode ser variável, sendo que no caso específico do 
Turbo Pascal, o conjunto pode ter no máximo 256 elementos. 
 
Um conjunto pode consistir em zero ou mais elementos do mesmo tipo base que, 
obrigatoriamente deverá ser um tipo simples, podendo ser qualquer escalar com exceçäo 
do REAL. 
 
Em Pascal, os conjuntos têm seus elementos inclusos emcolchetes e separados por vírgulas. 
Podemos ter também a representaçäo da sub-faixa: 
 
Exemplos: 
[1,3,5,7,9,11,13] - alguns inteiros 
[3..7] - inteiros entre 3 e 7 
[3,4,5,6,7] - equivalente ao anterior 
['A'..'Z'] - caracteres alfabéticos maiúsculos 
[gol,passat,fusca] - marcas de carro 
[] - conjunto vazio 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 34 de 72 
7.4.1.1. Declaração de Records 
Sintaxe: Type <identificador> = SET OF <tipo base>; 
 
Exemplos: 
Type 
 caracteres= set of Char; 
 letras_maiúsculas = set of 'A'..'Z'; 
 dígitos = set of 0..9; 
 carros = set of (fusca,gol,escort,opala); 
 
Var 
 c : caracteres; 
 letras : letras_maiúsculas; 
 números : dígitos; 
 marca : carros; 
etc. 
 
7.4.1.2. Operações em tipos Set 
Atribuição: O operador de atribuição é o mesmo utilizado para tipos simples, 
 
Exemplos: 
c := ['a','e','i','o','u']; 
letras := ['B'..'H']; 
números := [0,3,5]; 
etc. 
 
União: O operador uniäo é representado pelo sinal '+'. A uniäo entre dois conjuntos 
resulta num terceiro conjunto, constituído dos elementos dos dois conjuntos. 
 
Exemplo: 
a := [1,2,3]; 
b := [2,3,4,5]; 
c := a+b; resulta c = [1,2,3,4,5] 
 
Intersecção: Representada pelo sinal '*'. A intersecçäo entre dois conjuntos, resulta num 
terceiro conjunto, constituí-do pelos elementos que fazem parte tanto de um como do outro 
conjunto. Exemplo: 
 
Exemplo: 
a := [1,2,3]; 
b := [2,3,4,5]; 
c := a*b; resulta c = [2,3] 
 
Diferença: Representada pelo sinal '-'. Retorna um conjunto, cujos elementos estäo num 
conjunto mas näo no outro. 
 
Exemplo: 
a := [1,2,3,6]; 
b := [2,3,4,5]; 
c := a-b; resulta c = [1,6] 
c := b-a; resulta c = [4,5] 
 
 Usando operadores relacionais: 
Introdução a Informática (Gabriel Salimo) Pagina 35 de 72 
 
Exemplos de programas: 
-------------------------------------------------------------------------------------------------------- 
Program Exemplo_1; 
Uses CRT; 
(******************************************************************************* 
Lê uma tecla e a envia para o monitor até que se digite 'S' ou 's' ou 'N' ou 'n' 
*******************************************************************************) 
Var tecla : Char; 
 Begin 
 ClrScr; 
 Repeat 
 Read(kbd,tecla); 
 Write(tecla); 
 Until tecla IN ['s','S','n','N']; 
End. 
 
Program Exemplo_2; 
Uses CRT; 
(******************************************************************************** 
Lê uma tecla e diz se é número, letra maiúscula ou letra minúscula até que se leia um '?' 
*******************************************************************************) 
Type simbolos = Set of Char; 
Var Maiusc,Minusc,Numeros : simbolos; 
tecla : char; 
Begin 
 ClrScr; 
 Maiusc := ['A'..'Z']; Minusc := ['a'..'z']; Numeros := ['0'..'9']; 
 Repeat 
 Read(kbd,tecla); 
 If tecla IN Maiusc Then Writeln('MAIUSCULA') 
 Else if tecla IN minusc Then Writeln('minuscula') 
 Else if tecla IN numeros Then Writeln('numero') 
 Else Writeln('nada'); 
 Until tecla = '?'; 
End. 
 
Program Exemplo_3; 
Uses CRT; 
(******************************************************************************** 
Programa que conta o número de vogais, número de consoantes e de brancos numa frase 
*******************************************************************************) 
Type simbolos = set of char; 
Var Alfabeto,vogais,consoantes : simbolos; 
frase : string[50]; 
v,c,b,x : integer; 
 Begin 
 Vogais:=['a','e','i','o','u','A','E','I','O','U']; 
 alfabeto:=['a'..'z']+['A'..'Z']; 
 consoantes:=alfabeto-vogais; 
 Clrscr; 
 Write('Digite uma frase: '); 
 Readln(frase); 
 b:=0;c:=0;v:=0; 
Introdução a Informática (Gabriel Salimo) Pagina 36 de 72 
 For x:=1 to length(frase) do (*funçäo length() devolve o tamanho do parâmetro*) 
 if frase[x] in vogais then v:=v+1 
 else if frase[x] in consoantes then c:=c+1 
 else if frase[x] = ' ' then b:=b+1; 
 Writeln; 
 writeln(b,' brancos'); 
 Writeln(c,' consoantes'); 
 Writeln(v,' vogais'); 
 End. 
 
8. Subprogramas 
 
Os subprogramas destinam-se principalmente a: 
 
 permitir a criação de rotinas ou partes de codigo que podem ser usadas mais do que 
uma vez num programa; 
 ajudar a estruturar melhor o programa, permitindo que determinadas porcoes de codigo 
sejam escritas de uma forma mais autonoma e que a leitura do programa resulte mais 
facil e compreensivel. 
 
 
Figura 3-1: Exemplo de dois subprogramas derivados de um Programa (cálculo da hipotenusa) 
 
Em pascal, os subprogramas podem assumir duas formas principais: 
 “procedures” ou procedimentos; 
 “functions” ou funções. 
 
 A principal diferenca entre estes dois tipos de subprogramas é que, enquanto um 
procedimento executa uma ou mais operacoes, uma função, para além disso, tem de 
deveolver um determinado resultado. 
 
 Uma função tem estatuto de uma variável, isto é, uma função é de um determinado tipo 
de dados da mesma forma que uma variável é de um tipo - uma função é declarada 
e chamada num programa é ligeiramente diferente do que se passa num procedimento, 
como veremos mais adiante. 
Introdução a Informática (Gabriel Salimo) Pagina 37 de 72 
 
8.1. Declaraçäo de procedures 
Um procedimento pode ser referido escrevendo simplesmente o seu nome seguido de um lista 
opcional de parâmetros. 
 
Uma procedure tem praticamente a mesma estrutura de um programa, ou seja, ela contém 
um cabeçalho, área de declarações e o corpo da procedure. Na área de declaraçöes, tal 
como no programa, podemos ter as seguintes sub-áreas: Label - Const - Type - Var - 
Procedures - Functions. 
 
Devemos salientar que tudo que for declarado dentro das subáreas só será reconhecido 
dentro da procedure. 
 
PROCEDURE <Nome>([<lista-de-parâmentro>]) 
VAR 
<declaração-variáveis-locais> 
BEGIN 
<commandos/instruções> 
END; 
 
Exemplo: 
--------------------------------------------------------- 
Program Exemplo_1; (* cabeçalho do programa *) 
Uses CRT; 
 
Procedure linha; (* cabeçalho da procedure linha *) 
Var i : integer; (* subárea Var da procedure linha *) 
Begin (* corpo da procedure linha *) 
 for i:=1 to 80 do write('-'); 
End; 
 
Begin (* corpo do programa principal *) 
 ClrScr; 
 linha; (* ativaçäo da procedure linha *) 
 writeln('teste'); 
 linha; (* ativaçäo da procedure linha, novamente *) 
 End. 
 --------------------------------------------------------- 
 
O programa acima, pura e simplesmente faz o seguin-te: 
 
a) Apaga a tela e coloca o cursor em 1,1 
b) Ativa a procedure linha 
c) Escreve a palavra teste 
d) Ativa novamente a procedure linha. 
 
 Por sua vez, a procedure linha traça uma linha a partir da posiçäo atual do cursor; 
 Uma observaçäo importantíssima a ser feita neste instante, é que a variável inteira i, 
definida dentro da procedure linha só existe dentro da procedure,isto significa que toda 
vez que ativamos a procedure linha, a variável i é criada e toda vez que saimos da 
procedure linha, ela é destruída. 
 
Introdução a Informática (Gabriel Salimo) Pagina 38 de 72 
8.2. Variáveis Globais e Locais 
Uma variável é considerada Global quando é declarada no início de um programa escrito 
em Pascal, podendo ser utilizada por qualquer procedimento ou função. Assim sendo, este 
tipo de variável passa a ser visível a todas as funções ou procedimentos. 
 
8.3. Procedures: Passagem de parâmetros 
A passagem de parametros é feita com base no número e tipo de parâmentros declarados; 
isto significa que os parametros devem: 
 ser declarados como variáveis; 
 na chamada (execução da procedure) os parâmetros podem ser números inteiros 
“constantes” ou duas variáveis inteiras, obviamente desde que haja compatibilidade entre 
os parâmetros passados. 
 
A passagem de parâmetros pode ser feita de duas formas: passagem por valor e passagem 
por referência.8.4. Passagem de parâmetros por Valor 
A passagem por valor passa para a procedure apenas o valor; isto significa que as 
alterações feitas nos parâmentros (varáveis) no subprograma não alteram os valores no 
programa principal (chamador). 
 
Sintaxe: PROCEDURE <nome>(<identiticador>:<tipo>); 
 
Exemplo: 
Program Exemplo; 
Uses CRT; 
 
Var i,j:integer; 
 
Procedure soma(x,y:integer); 
Begin 
 writeln(x+y); 
end; 
 
Begin 
 ClrScr; 
 soma(3,4); 
 i:=45; j:=34; 
 soma(i,j); 
end. 
 
8.5. Passagem de parâmetros por Referência 
A passagem por referência passa para a procedure o endereço do parâmetro real; isto 
significa que todas as alterações feitas sobre o parâmentros (varáveis) no subprograma 
serão reflectidos sobre as variáveis correspondentes no programa principal (chamador). 
 
Sintaxe: PROCEDURE <nome>(VAR<identiticador>:<tipo>); 
 
 
Introdução a Informática (Gabriel Salimo) Pagina 39 de 72 
Program exemplo; 
Uses CRT; 
 
Var i : Integer; 
 
Procedure Soma(x,y:Integer;Var z:Integer); 
Begin 
 z:=x+y; 
End; 
 
Begin 
 ClrScr; 
 Soma(3,4,i); 
 Writeln(i); 
End. 
 
 Na passagem de parâmetro por referência, o parâmetro deve abrigatóriamente ser uma 
variá. 
 
8.6. Definição de Funções 
As funçöes säo muito parecidas com as procedures. A principal diferença é que o 
identificador de uma funçäo assume o valor de retorno da funçäo. Uma funçäo deve 
sempre retornar um valor e em Turbo Pascal, este valor é retornado no nome da funçäo. 
Declaração de Funções 
A declaraçäo de uma funçäo é muito parecida com de uma procedure que por sua vez é 
parecida com a de um programa, senäo vejamos: 
 
FUNCTION nome_da_função(parâmetros) : Tipo_da_função; 
 < área de declaraçöes > 
BEGIN 
 <corpo da funçäo> 
END; 
 
 A formaçäo do nome da funçäo deve seguir as mesmas regras para formaçäo de 
identificadores em Turbo Pascal; 
 Dentro dos parenteses devemos declarar os parâmetros e seus respectivos tipos dos 
quais a funçäo depende; 
 O tipo de valor retornado pela funçäo também deve ser declarado. 
 
Na área de declaraçöes, podemos declarar labels, constantes, variáveis e até mesmo 
Procedures e Functions. Devemos lembrar que tais elementos só poderäo ser utilizados 
dentro do corpo da funçäo, pois säo locais a ela. 
 
Program Exemplo; 
Uses CRT; 
 
Var x,y : Real; (* variáveis globais *) 
 
Function Soma(a,b:real):real; 
(* Soma é uma função que depende de dois parâmetros reais e devolve um valor real *) 
Begin 
 Soma:=a+b; (* reparem que o valor da função é retornado pelo seu nome *) 
End; 
Introdução a Informática (Gabriel Salimo) Pagina 40 de 72 
 
Begin 
 ClrScr; 
 x:=Soma(4,5); 
 y:=Soma(3,6)-Soma(45.5,5.6); 
 Writeln(x:10:2,y:10:2); 
 Writeln; 
 Write('Valor de x --> '); 
 Readln(x); 
 Write('Valor de y --> '); 
 Readln(y); 
 Writeln; 
 Writeln(Soma(x,y):10:2); 
End. 
 
 Devemos lembrar que o Turbo Pascal possui inúmeras funções de procedures pré-
definidas, das quais algumas iremos ver neste manual. 
 
8.7. Arquivos (File = Ficheiro) 
O tipo file ou arquivo, é uma estrutura constituída de elementos do mesmo tipo dispostos 
sequencialmente. Essa estrutura é utilizada para comunicaçäo com o meio externo, 
principalmente com discos magnéticos. 
 
 Todos os dados com que se tem trabalhado até aqui são dados voláteis – quer dizer 
que são armazenados temporariamente na RAM do computador, enquanto estamos a 
funcionar com o programa; quando se sai do programa, toda a informação 
desaparece. 
 
Ficheiro – é a unidade de informação, armazenada fisicamente num suporte de memória 
secundária; há ficheiros que são legíveis directamente no sistema operativo (Type ou Edit), 
pois são constituídos por caracteres ASCII – são os Ficheiros de Texto; outros tipos de ficheiros 
não são formados apenas por caracteres ou não têm qualquer caracter legível – são os 
ficheiros em código – máquina (executáveis); estes são chamados ficheiros binaries - porque 
a informação se encontra em formato binário. 
 
Assim, em Pascal os ficheiros em que se armazenam os dados com que os programas 
trabalham 
são de 2 tipos: 
 
 “TEXT FILES” – ficheiros de texto - Aqui a informação é totalmente armazenada em 
formato de caracteres ASCII. Podem ser criados, consultados, modificados no Sistema 
Operativo ou no editor de texto fora do programa que os usa. 
 
O acesso aos dados é do tipo sequencial ou seja, a leitura dos dados não pode ser iniciado 
num ponto qualquer escolhido pelo utilizador, mas sempre o início e percorrer todos os 
elementos até chegar ao ponto pretendido. 
 
 “TYPED FILES” – ficheiros de tipo não texto - Ficheiros definidos pelo utilizador; Estes 
agrupam dados simples ou estruturados, no formato binário, não legíveis nem 
manipuláveis fora do programa em que foram criados. 
 
Introdução a Informática (Gabriel Salimo) Pagina 41 de 72 
 
Podemos ter ficheiros de números inteiros ou reais, matrizes, registos, etc....; Em particular, os 
ficheiros de registos permitem manipular dados num formato bem estruturado para trabalho 
com informação externa (disco ou disquete). O acesso aos dados pode ser feito de forma 
aleatória ou seja por escolha da posição pretendida (directa). 
 
Independentemente do tipo de ficheiro, sobre ele, são válidas as seguintes acções: 
 
8.8. Declaração de tipos e variáveis de ficheiros (VAR) 
1. Ficheiro Tipo TEXT 
Sintaxe: VAR <identificador-do-ficheiro>:TEXT; 
 
2. Ficheiro Tipo Definidos pelo Programador 
Sintaxe: TYPE Arquivo = FILE OF <Tipo>; VAR a : Arquivo; 
 
 as declarações acima, a variável 'a' passa a representar um arquivo do tipo <Tipo>. 
 
Exemplos: 
a) Arquivo com números Inteiros 
Type Arq = File Of Integer; 
Var Arquivo : Arq; 
ou 
Var Arquivo : File Of Integer; 
 
b) Arquivo com números Reais 
Type Arq = File Of Real; 
Var Arquivo : Arq; 
 
c) Arquivo de Records 
Type Pessoa = Record 
 Nome : String[30]; 
 Idade : Integer; 
 Sexo : Char; 
 Altura : Real; 
 End; 
 
Var Arquivo : File Of Pessoa; 
 
 neste manual aprofudaremos apenas os ficheiros do tipo texto 
 
8.9. ASSIGN: associação de identificador de ficheiro com o nome externo de ficheiro 
Esta procedure tem a finalidade de atribuir um nome lógico ao arquivo físico, ou seja, 
ao nome do arquivo em disco. 
 
No Pascal, quando se declara uma variável do tipo texto ou file, não se está a designar o 
nome externo ou físico de um qualquer ficheiro do sistema operativo, mas sim o, identificador 
interno do programa. É preciso associar a variável do ficheiro com um nome efectivo do 
ficheiro ao nível do sistema operativo. Faz-se através do comando ASSIGN. 
 
Sintaxe: ASSIGN(<identificador>, <nome-do-ficheiro>); 
Exemplo: ASSIGN (fich, ‘PESSOAL.DAT ’); 
 
Introdução a Informática (Gabriel Salimo) Pagina 42 de 72 
 identificador - nome lógico do ficheiro; 
 Fich - é a variável interna do tipo file ou text, e 
 pessoal.dat - é o nome físico do ficheiro. 
 
8.10. REWRITE: Criação de um novo ficheiro & Escrita de Dados (WRITE, WRITELN) 
Sintaxe Criação: REWRITE (<identificador>); 
Exemplo: REWRITE (fich); 
 
Sintaxe Escrita: WRITE (<identificador>,<colecção-de-dados>); 
 
 identificador - nome lógico do ficheiro; 
 colecção-de-dados - representa variáveis ou constantes dos dados a serem escritos no 
ficheiro. 
 
Exemplo: WRITE (fich, ‘Quantidade: ‘ , 1000); 
 Escreve no ficheiro identificado por fich (pessoal.dat) a string (palavra) quantidade e o 
valor 1000. 
 
No caso dos ficheiros de texto, tal como na escrita de dados no écran existe a mesma 
diferença entre 
o Write e o Writeln – mudança ou não de linha. 
 
Programa 1:( Criação de um ficheiro do tipo TEXT) - Registar os nomes de alguns produtos, 
os seus preços por unidade e as respectivas quantidades existentes em armazém: 
 
Program FICHTEXTOCRIAÇÃO; 
var 
produtos: text; 
i,quantos:integer; 
nomeprod: string; 
precprod, quantid:integer; 
begin 
assign(produtos, 'artigos.txt');