Capa e Sumário - Frederico Westphalenbruno/disciplinas/lab_programacao/material/... ·...
Transcript of Capa e Sumário - Frederico Westphalenbruno/disciplinas/lab_programacao/material/... ·...
Caderno Didático
Bruno B. Boniati
Joel da Silva
Teresinha Letícia da Silva
Frederico Westphalen, 2010
Universidade Federal de Santa Maria
2010
Sumário
CAPITULO I – Introdução ao Pascal ............................................................................................................................................ 1
O que é o Pascal ............................................................................................................................................................. 1 Layout de um programa Pascal ....................................................................................................................................... 2 Caracteres utilizados ....................................................................................................................................................... 3 Palavras Reservadas ....................................................................................................................................................... 3
CAPITULO II – Características Básicas da Linguagem .............................................................................................................. 4
Básico da Linguagem ...................................................................................................................................................... 4 Declaração de Constantes ............................................................................................................................................... 4 Declaração de Variáveis .................................................................................................................................................. 4 Comentários ..................................................................................................................................................................... 5 O Ponto-e-Vírgula e o Ponto ............................................................................................................................................ 5 Operadores ...................................................................................................................................................................... 6 Prioridades ....................................................................................................................................................................... 6
CAPITULO III – Tipos de Dados .................................................................................................................................................... 7
Tipos Inteiros ................................................................................................................................................................... 7 Tipos Reais (ponto flutuante) ........................................................................................................................................... 7 Tipos Texto ...................................................................................................................................................................... 7 Tipo booleano .................................................................................................................................................................. 7
CAPITULO IV – Entrada e Saída de Dados .................................................................................................................................. 8
Comandos de Leitura (entrada) ....................................................................................................................................... 8 Comandos de Impressão (saída) ..................................................................................................................................... 8
CAPITULO V – Formatação e posicionamento de tela ............................................................................................................. 10
Limpeza da tela .............................................................................................................................................................. 10 Formatação de Cores .................................................................................................................................................... 10 Posicionamento em coordenadas de tela ...................................................................................................................... 11
CAPITULO VI – Elementos fundamentais de controle ............................................................................................................. 12
Comandos de Decisão ................................................................................................................................................... 12 Comandos de Repetição (Looping) ............................................................................................................................... 13
CAPITULO VII – Funções e comandos internos ....................................................................................................................... 16
Tratamento de Strings ................................................................................................................................................... 16 Tratamento de Valores Ordinais ................................................................................................................................... 17 Conversões de Tipos de Dados ..................................................................................................................................... 18 Outros comandos e funções .......................................................................................................................................... 18
CAPITULO VIII – Modularização ................................................................................................................................................. 22
PROCEDURE (Procedimentos) ..................................................................................................................................... 22 FUNCTION (Funções) ................................................................................................................................................... 24 Passagem de parâmetros .............................................................................................................................................. 25
CAPITULO IX – Tipos de dados estruturados ........................................................................................................................... 27
Records (Registros) ....................................................................................................................................................... 27 Arrays (Vetores e Matrizes) ........................................................................................................................................... 28
CAPITULO X – Arquivos .............................................................................................................................................................. 30
Comandos e Operações sobre Arquivos ....................................................................................................................... 31
Anexos .......................................................................................................................................................................................... 34
Anexo I – Tabela de Códigos ASCII .............................................................................................................................. 34
Referências Bibliográficas .......................................................................................................................................................... 37
Caderno Didático PASCAL Página 1
1
Universidade Federal de Santa Maria
CAPITULO I – Introdução ao Pascal
O que é o Pascal
A linguagem e programação PASCAL foi criada para ser uma ferramenta
educacional, Ito no início da década de 70 pelo Professor Niklaus Wirth do Technical
University em Zurique, Suíça. Foi batizada pelo seu idealizador de PASCAL, em
homenagem ao grande matemático Blaise Pascal, inventor de uma das primeiras máquinas
lógicas conhecidas. Foi baseada em algumas linguagens estruturadas existentes até então,
como ALGOL e PLI, tentando facilitar ao máximo o seu aprendizado.
PASCAL somente ganhou popularidade quando foi adotado pela Universidade da
Califórnia, San Diego, em 1973. No mesmo período, em seus cursos, também foram feitas
implementações para microcomputadores. Nas suas primeiras implementações, não era
muito amigável ao programador, pois eram necessários vários passos para se obter um
programa executável. Primeiro deveria se escrever o programa em um editor de texto e
depois compilá-lo, “lincá-lo” e montá-lo. Quando era feita uma manutenção no mesmo, todos
estes passos deviam ser refeitos, o que desestimulava os programadores.
Apesar de todas as dificuldades iniciais, de seu propósito educacional e a facilidade
de programação, o PASCAL começou a ser utilizado por programadores de outras
linguagens, tornando-se para surpresa do próprio Niklaus, um produto comercial. Contudo
somente ao final do ano de 1993, é que a soft-house americana Borland International,
lançou o TURBO PASCAL para microcomputadores, no mesmo ano em que houve um
grande crescimento no mercado de microcomputadores.
Comercialmente, a linguagem foi sucedida pela criação da linguagem Object
Pascal, atualmente utilizada nos IDEs Delphi, Kylix e Lazarus. Durante a década de 90 a
Borland descontinuou os compiladores Turbo Pascal e Borland Pascal. Nessa época vários
projetos foram iniciados para produzir um compilador Pascal para preencher essa lacuna.
Um destes projetos nasceu dentro de um grupo de estudantes liderado por Florian
Paul Klaempfl e foi batizado de FPK-Pascal. Posteriormente o projeto ganhou bastante
popularidade e se tornou o Free Pascal, mostrando-se exatamente o que a comunidade
queria: um compilador Pascal de 32bits moderno, robusto, estável e confiável. O Ambiente
de desenvolvimento Free Pascal pode ser obtido gratuitamente através do site
http://www.freepascal.org/, para diferentes plataformas de sistemas operacionais.
Caderno Didático PASCAL Página 2
2
Universidade Federal de Santa Maria
Layout de um programa Pascal
Os programas escritos em Pascal (assim como a maioria das linguagens de
programação) têm uma estrutura definida para especificar suas partes integrantes. O texto
que compõe um programa Pascal possui várias áreas específicas onde são expressas,
através de uma razoável rigidez léxica e sintática, diversas informações para a completa
especificação do programa.
Qualquer programa em Pascal tem duas partes distintas:
Declarações: especificam os instrumentos a serem utilizados pelo programa,
como, por exemplo: variáveis, funções, constantes, sub-rotinas, etc. As
declarações obedecem a uma ordem fixa quanto à sua natureza e
precedem os comandos.
Comandos: adicionam procedimentos que se utilizam dos instrumentos
discriminados nas declarações. O termo comando é usado em Pascal,
indistintamente, para as instruções primitivas e para as estruturas de
controle. Os comandos são, portanto, a parte efetivamente ativa na
execução dos algoritmos.
Observe a seguir, um layout de um programa em Pascal:
program nome_programa; { Este é o cabeçalho do programa } uses
unidades; {necessária apenas se forem utilizadas informações de units já definidas (obrigatoriamente após o comando program}
const lista de constantes;
type; lista de tipos de dados específicos;
var lista de variáveis e seus respectivos tipos de dados associados;
procedure NomeModulo(parâmetros) begin
//Corpo do procedimento
end;
function NomeFuncao(parâmetros) : tipo; begin
//Corpo da função
end;
begin
//Corpo do programa;
end.
Caderno Didático PASCAL Página 3
3
Universidade Federal de Santa Maria
Caracteres utilizados
Os caracteres que podem ser utilizados na linguagem Pascal são divididos em:
Letras: ‘A’ até ‘Z’, ‘a’ até ‘z’;
Números: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9.
Especiais: + - * / = ^ < > ( ) [ ] { } . , : ; ‘ # $
A linguagem Pascal não é case sensitive, ou seja, não faz distinção entre letras
maiúsculas e minúsculas.
Palavras Reservadas
As palavras reservadas da linguagem Pascal são expressões que fazem parte da
sua sintaxe e têm significados pré-determinados. Elas não podem ser redefinidas e não
podem ser utilizadas como identificadores de variáveis, procedimentos, funções, etc. Abaixo
a relação de palavras reservadas da linguagem Pascal:
and
array
begin
case
const
div
do
downto
else
end
file
for
forward
function
goto
if
in
label
mod
nil
not
of
or
packed
procedure
program
record
repeat
set
then
to
type
until
var
while
with
Caderno Didático PASCAL Página 4
4
Universidade Federal de Santa Maria
CAPITULO II – Características Básicas da Linguagem
Básico da Linguagem
Programas, procedimentos e funções são todos compostos de instruções.
Instruções podem ser simples ou compostas. Veja alguns exemplos:
x := 13; //atribui o valor 13 à variável x.
y:= x + 12; //atribui o resultado da soma à variável y.
TestaArquivo(‘c:\config.sys’); //executa o procedimento TestaArquivo
Declaração de Constantes
Constantes são identificadores cujo valor não se altera durante a execução do
programa. Esse comando declarativo tem por finalidade associar um nome a uma constante,
que pode ser um número (inteiro ou decimal), um identificador de constante (possivelmente
um sinal) ou uma sequência de caracteres. Embora não seja uma regra da linguagem,
normalmente convenciona-se utilizar o nome da constante em letras MAIÚSCULAS.
const
PI = 3.171592;
IES = ‘UFSM’;
PERCENTUAL = 0.10;
CoordenadaX = 3;
Declaração de Variáveis
Quando uma variável precisa ser mencionada no bloco de comandos é preciso que
inicialmente a mesma seja decalrada. Associada à variável precisa haver um tipo de dado.
Na linguagem Pascal cada variável só pode armazenar um tipo de dado específico de
informação. Quando duas ou mais variáveis são do mesmo tipo de dado, podem ser
agrupadas em uma mesma declaração.
const
nome : string;
x, y : integer;
salário : real;
Caderno Didático PASCAL Página 5
5
Universidade Federal de Santa Maria
Comentários
Comentários são “informações” incluídas no corpo do programa, mas que não são
considerados pelo compilador. A utilização de comentários no código é uma excelente
prática de programação e permite documentar a intenção de uso e o funcionamento do
código.
{ } Tudo que está entre as chave é ignorado;
(* *) Tudo que está entre * é ignorado;
// Tudo após o marcador do comentário é ignorado até o final da linha
O Ponto-e-Vírgula e o Ponto
Como regra geral, todas as instruções em um programa Pascal devem ser
separadas por um ponto-e-vírgula. Neste caso, note que instrução
refere-se tanto a
instruções simples como instruções compostas. É por esta razão que não existe um ponto-
e-vírgula após um begin e significa também que um ponto-e-vírgula antes de qualquer end
é opcional. Assim, no código a seguir, a instrução de atribuição não possui um ponto-e-
vírgula após ela porque é imediatamente seguida por um end, mas o end deve ter um
ponto-e-vírgula após, porque ele é o final da instrução composta:
if x = 13 then
begin
writeln(‘X vale Treze’);
x:=14 //aqui o ponto-e-vírgula é opcional
end; //Aqui o ponto e vírgula é obrigatório
//pois termina a instrução composta
Na maioria dos casos o par begin ... end estão sempre juntos. Entretanto,
existem poucos casos onde você tem um end sem begin (a ocorrência mais comum é a
instrução case). O end final do programa é seguido de um ponto
e não de um ponto-e-
vírgula.
Caderno Didático PASCAL Página 6
6
Universidade Federal de Santa Maria
Operadores
1. Atribuição e Igualdade: o operador de atribuição em Pascal é o símbolo “dois
pontos igual” (:=). É diferente do sinal de igual (=) usado para testar a
igualdade e a definição de tipos.
2. Numéricos: observe a tabela a seguir:
Operador Operação Tipos de Operandos Tipos de Resultado + Adição integer ou real integer ou real - Subtração integer ou real integer ou real * Multiplicação integer ou real integer ou real / Divisão integer ou real real div Divisão de inteiros integer integer mod Resto da divisão integer integer
3. Relacionais: a tabela a seguir contém os operadores relacionais que retornam
dois valores booleanos (true e false):
Operador Operação = igual <> não igual < menor que > maior que <= menor ou igual >= maior ou igual not negação and e lógico or ou lógico
Prioridades
Na resolução das expressões aritméticas, as operações e funções matemáticas
guardam entre si uma hierarquia:
1. Parênteses mais internos;
2. Funções;
3. * (multiplicação) e / (divisão);
4. + (soma) e – (subtração);
Para operações de mesma prioridade, segue-se a ordem especificada, isto é,
primeiro resolvem-se os operadores mais à esquerda e depois os mais à direita e, para
alterar a prioridade, utiliza-se parênteses mais internos.
Caderno Didático PASCAL Página 7
7
Universidade Federal de Santa Maria
CAPITULO III – Tipos de Dados
Tipos Inteiros
São tipos numéricos exatos, sem casas decimais. O tipo integer é o tipo inteiro
padrão.
Tipo Tamanho
Faixa de Valores shortint 1
-128..127
byte 1
0..255
integer 2
-32768..32767
word 2
0..65535
longint 4
-2147483648..2147483647
cardinal 4
0..4294967295
Tipos Reais (ponto flutuante)
São tipos numéricos exatos com casas decimais. O tipo Double é o tipo real
padrão.
Tipo
Faixa
Dígitos
Tamanho
single 1,5-45
.. 3,438
7-8 4
real 2,9-39
.. 1,738
11-12 6
double
5-324
..
1,7308
15-16
8
comp -9,218
.. 9,218
19-20 8
extended
3,4-4932
.. 1,14932
19-20 10
Tipos Texto
Os tipos texto podem operar com caracteres simples ou grupos de caracteres. O
tipo string é o tipo texto padrão.
char – um único caractere ASCII
string – texto alocado dinamicamente limitado a 255 caracteres;
Tipo booleano
Variáveis booleanas (em Pascal boolean) podem receber os valores lógicos true
ou false (verdadeiro ou falso). Uma variável boolean ocupa 1 byte de memória.
Caderno Didático PASCAL Página 8
8
Universidade Federal de Santa Maria
CAPITULO IV – Entrada e Saída de Dados
Um requisito básico da construção de programas de computador é a entrada de
dados para o programa e a saída dos resultados calculados de forma a ser compreendia por
qualquer usuário. Para atender a este requisito a linguagem de programação disponibiliza
comandos para entrada (comandos de leitura) e para saída (comandos de impressão de
informações).
Comandos de Leitura (entrada)
A execução da instrução de leitura pressupõe que os dados serão fornecidos do
meio externo, através do teclado, e serão armazenados nas variáveis explicitadas no
programa, na ordem estabelecida.
O comando read procura os valores sempre na mesma linha de entrada. Quando
se deseja mudar de linhas utiliza-se o comando readln. Este comando subentende que
após cada execução, uma nova linha de entrada será lida.
program TesteEntrada; var
nome : string; x, y : integer;
begin read(nome);
readln(x); readln(y);
end.
Comandos de Impressão (saída)
A execução da instrução de impressão pressupõe que os dados estão
armazenados na memória e serão exibidos no dispositivo definido como saída (por exemplo:
monitor) e na sequência e nos formatos especificados nos parâmetros.
A exemplo dos comandos de entrada, o comando writeln difere também do
comando write. O primeiro deve ser usado quando, após a impressão de todas as
expressões entre parênteses, desejamos que uma nova linha seja carregada.
Um recurso dos comandos write/writeln é tabular as informações de saída,
isso é possível colocando-se “:n” (dois pontos) após a variável, onde n é o deslocamento a
partir da posição corrente do cursor. No caso de valores reais, pode-se ainda determinar a
Caderno Didático PASCAL Página 9
9
Universidade Federal de Santa Maria
quantia de casas decimais que serão exibidas, colocando-se mais uma sequencia de “:n”,
após a anterior.
program TesteSaida; var
nome : string; salario : real;
begin nome := ‘TESTE’; salario := 510.42;
write(nome);
writeln(salario:5:2); //5 espaços de tabulação e 2 casas decimais
end.
Caderno Didático PASCAL Página 10
10
Universidade Federal de Santa Maria
CAPITULO V – Formatação e posicionamento de tela
Limpeza da tela
ClrScr
Este comando limpa a tela e automaticamente coloca o cursor no canto
superior esquerdo da mesma. É a contração das palavras em língua inglesa CLeaR
SCReen.
Formatação de Cores
TextColor
Este procedimento permite que seja selecionada a cor do texto que
aparecerá no vídeo, sendo as cores representadas por valores numéricos inteiros
que variam de 0 a 15, correspondendo às seguintes cores:
0
Preto
8 Cinza escuro 1
Azul
9 Azul claro 2
Verde
10
Verde claro 3
Ciano
11
Ciano claro 4
Vermelho
12
Vermelho claro
5
Magenta
13
Magenta claro
6
Marrom
14
Amarelo 7
Cinza claro
15
Branco
Além destas 16 cores disponíveis, podemos somar a qualquer uma delas o valor
128 para que o texto fique piscante, na verdade o que este procedimento faz é ajustar os
bits de 0 até 3 para as cores propriamente ditas e mais o bit 7 para o piscante do byte de
atributo no modo texto.
TextColor(9); //ajusta a cor do texto para azul claro writeln('Este texto é azul claro');
TextColor(5+128); //ajusta a cor do texto para vermelho piscante writeln('Este texto é vermelho piscante');
Caderno Didático PASCAL Página 11
11
Universidade Federal de Santa Maria
TextBackGround
Este procedimento permite selecionar a cor de fundo, que é representada
por um valor numérico inteiro que pode variar de 0 até 7, correspondendo às
seguintes cores:
0
Preto
1
Azul 2
Verde 3
Ciano 4
Vermelho 5
Magenta 6
Marrom 7
Cinza claro
TextBackGround(2); //ajusta a cor do fundo para verde clrscr; //limpa toda a tela que agora terá a cor verde
Posicionamento em coordenadas de tela
GotoXY
Em ambiente texto, a saída padrão (vídeo), é composta por 80 colunas e 25
linhas, sendo que todo o posicionamento do texto deve se dar dentro destes valores
de coordenadas. Para posicionarmos o cursor em um ponto qualquer da tela,
referenciado pelos eixos X e Y, ou seja, coluna e linha, utilizamos o comando
GotoXY. Tanto a coluna como a linha deve ser válida, caso contrário o
posicionamento poderá ter um resultado inesperado. Normalmente o comando
GotoXY é utilizado antes de um comando de entrada ou de saída.
program TestePosicionamento; var oper1, oper2 : real; begin
clrscr; //limpa a tela gotoxy(10,6); //coluna 10 da linha 6 write('Digite o valor do primeiro operador: '); readln(oper1);
gotoxy(10,8); //coluna 10 da linha 8 write('Digite o valor do segundo operador: '); readln(oper2);
gotoxy(10,10); writeln('A soma entre o primeiro ', oper1:6:2,
' e o segundo ', oper2:6:2, ' é ', oper1+oper2:6:2); end;
Caderno Didático PASCAL Página 12
12
Universidade Federal de Santa Maria
CAPITULO VI – Elementos fundamentais de controle
Comandos de Decisão
if...then...else (se...então...senão)
O formato básico da instrução if...then é mostrado abaixo:
if <expressão lógica> then <instrução>;
Esta sintaxe básica pode ser incrementada pela adição da cláusula else:
if <expressão lógica> then <instrução> // não vai ponto-e-vírgula
else <instrução>;
Para utilizar instruções compostas, a sintaxe básica deve ser incrementada
pelos comandos de bloco de código:
if <expressão lógica> then begin
<instrução 1>; <instrução 2>; <instrução n>;
end // não vai ponto-e-vírgula else begin
<instrução 1>; <instrução 2>; <instrução n>;
end;
Obs.: Não existe ponto-e-vírgula após o end que aparece antes do else.
case...of (escolha...de)
A instrução if...then...else mostrada anteriormente funciona bem
para um pouca quantidade de opções, mas torna-se inviável se você tiver muitas
opções. Nesta situação, a construção case é mais indicada e simples de escrever. A
sintaxe geral para a instrução case é:
case <variável> of <valor 1> : <instrução 1>; <valor 2> : <instrução 2>; <valor n> : <instrução n>;
else <instrução>;
end;
Caderno Didático PASCAL Página 13
13
Universidade Federal de Santa Maria
A instrução case toma uma variável e a compara com os valores possíveis.
Múltiplos valores podem aparecer sob o mesmo caso, separados por vírgulas.
Observe:
case x of 'A' .. 'Z', 'a' .. 'z' : writeln('Letra'); '0' .. '9' : writeln('Número'); '+', '-', '*', '/' : writeln('Operador');
else writeln('Caractere inválido');
end;
Comandos de Repetição (Looping)
while...do (enquanto...faça)
O laço de repetição while executa instruções até que a condição do laço
torne-se falsa. Sintaxe:
while <expressão lógica> do <instrução>;
Como nas outras estruturas, o comando de repetição while também
permite instruções simples ou compostas após o do. Para utilizar instruções
compostas é necessário utilizar o par begin...end:
i := 10; while i > 0 do begin
i:=i-1; writeln('passando pelo loop ', i);
end;
for...to...do (de...até...faça)
O laço de repetição for difere do while por executar uma quantidade
específica de a ação determinada pela variável de controle. A sintaxe básica é:
for <variável de controle> := <valor inicial> to <valor final> do <instrução>;
Caderno Didático PASCAL Página 14
14
Universidade Federal de Santa Maria
Usando a cláusula downto ao invés de to, a variável de controle sofre um
decremento de valor.
for i := 10 to 100 do writeln(i);
for j := 100 to 10 do writeln(i);
repeat...until (repita...até que)
A terceira construção de laço de repetição é o repeat...until, ele
executa todas as instruções dentro do loop até que a expressão lógica torne-se
verdadeira (o contrario do laço while). Sua sintaxe geral:
repeat <instrução 1>; <instrução 2>; <instrução n>;
until <expressão lógica>;
Observe que essa construção pode conter diversas instruções e não requer
o par BEGIN...END, exemplo:
j := 0; repeat
j:=j+1; writeln('passando pelo loop ', j);
until j >= 10;
break e continue (pare e continue)
São palavras reservadas que podem ser usadas em qualquer um dos laços
de repetição. Exemplo:
while true do begin
readln(inputFile,i); if strtoint(i) = 5 then
break; writeln(i);
end;
No exemplo acima, o loop é executado eternamente (uma vez que true é
sempre true). O loop continuará a ler a entrada de dados de um arquivo e exibirá
uma mensagem até que seja lido o número 5, quando isso acontecer o comando
break interromperá o laço.
Caderno Didático PASCAL Página 15
15
Universidade Federal de Santa Maria
O outro modificador de execução do laço de repetição é a instrução
continue. Ela ignorará o restante do loop e voltará a avaliar a condição. Assim, se
algo for alterado que mude a condição de saída, a instrução continue pode ser
utilizada para pular para o topo do loop e avaliar novamente a condição. Exemplo:
while i<10 do begin
readln(i); if i < 5 then
continue; writeln('Este número será maior que 5: ', i);
end;
Neste caso, continue impedirá que qualquer número menor que 5 seja
impresso. Este comando é útil para ser utilizado com entradas inválidas dentro de um
loop.
Caderno Didático PASCAL Página 16
16
Universidade Federal de Santa Maria
CAPITULO VII – Funções e comandos internos
Tratamento de Strings
UpCase(caracter)
Converte o caracter passado como parâmetro para maiúsculas.
y := UpCase('a'); //y = 'A'
Copy(texto, pos_inicial, num_posicoes)
Retorna um subtexto de um texto passado como parâmetro, de acordo com a
posição e a quantidade de caracteres predefinidos.
y := Copy('Universidade Federal de Santa Maria',14,7); //y = 'Federal'
Delete(variável, pos_inicial, num_posicoes)
Remove um número determinado de caracteres a partir de uma posição inicial.
y := 'Universidade Federal de Santa Maria'; Delete(y,1,13); //y = ' Federal de Santa Maria'
Insert(texto, variável_destino, posição)
Insere um subtexto em uma variável a partir de uma posição preestabelecida.
y := 'Frederico Westphalen'; Insert('Campus de ',y,1); //y = 'Campus de Frederico Westphalen'
Length(texto)
Retorna o número de caracteres do texto passado como parâmetro.
x := length('UFSM'); // x = 4
Pos(texto_pesquisado, texto_objeto)
Retorna a posição do texto pesquisado dentro do texto objeto da pesquisa. Se a
função retornar zero, o texto pesquisado não existe no texto objeto.
x := pos('F','UFSM'); // x = 2
Caderno Didático PASCAL Página 17
17
Universidade Federal de Santa Maria
Tratamento de Valores Ordinais
Dec(ordinal, quantidade)
Decrementa um valor ordinal em uma quantidade determinada de unidades.
x := 10; x := Dec(x); //x = 9 x := Dec(x,6); //x = 3
Inc(ordinal, quantidade)
Incrementa um valor ordinal em uma quantidade determinada de unidades.
x := 10; x := Inc(x); //x = 11 x := Inc(x,6); //x = 17
Odd(ordinal)
Testa se o ordinal passado com parâmetro é ímpar (neste caso retorna true), ou
se é par (retornando false).
z := Odd(10); // z = false z := Odd(5); // z = true
Pred(ordinal)
Retorna o predecessor do ordinal;
x := Pred('b'); // x = 'a' z := Pred(5); // z = 4
Succ(ordinal)
Retorna o sucessor do ordinal;
x := Succ('b'); // x = 'c' z := Succ(5); // z = 6
Ord(ordinal)
Retorna a ordem do valor ordinal na faixa de valores do tipo ao qual ele faz parte.
x := Ord('A'); // x = 65 (valor de A na tab. ASCII);
Caderno Didático PASCAL Página 18
18
Universidade Federal de Santa Maria
Low(ordinal)
Retorna o menor valor da faixa de valores do tipo ao qual o valor ordinal faz parte.
x := 10; // inteiro x := Low(x); // x = -2.147.483.648
High(ordinal)
Retorna o maior valor da faixa de valores do tipo ao qual o valor ordinal faz parte.
x := 50; // inteiro x := High(x); // x = 2.147.483.648
Conversões de Tipos de Dados
Chr(variável_byte)
Converte uma variável Byte em Char. Normalmente é utilizada para saber o
caractere ASCII de um valor.
x := Chr(65); //x = 'A'
Round(variável_real)
Arredonda um número real transformando-o em um inteiro.
x := Round(50.8); //x = 51 ... maior que 5 x := Round(50.5); //x = 50 ... menor ou igual a 5
Trunc(variável_real)
“Trunca” (omite) a parte decimal de um valor real. Transforma um valor real em
um inteiro ignorando as casas decimais (retorna apenas a parte inteira do número).
x := Trunc(50.8); //x = 50 x := Trunc(50.5); //x = 50
Val(texto, variável_destino, variável_erro)
Converte uma string passada como parâmetro em um valor numérico. Caso a
conversão não seja possível, ou seja, a string não contém um valor numérico, a
variável de erro armazenará um número diferente de zero.
Val('teste',x,erro); // x = 0 erro = 1 Val('100',x,erro); // x = 100 erro = 0
Caderno Didático PASCAL Página 19
19
Universidade Federal de Santa Maria
Str(valor, variável_destino)
Converte um valor numérico em uma string, armazenando o resultado na
variável destino passada como parâmetro.
Str(50,x); // x = '50' Str(950.25:3:2,x); // x = '950.25'
Outros comandos e funções
Diferentes bibliotecas da linguagem Pascal oferecem comandos e funções que podem ser muito úteis:
Int(var_real)
Retorna a parte inteira do argumento real devolvendo também um valor real.
x := Int(50.80); //x = 50.00 x := Int(50.50); //x = 50.00
Frac(var_real)
Retorna a parte fracionária do argumento real devolvendo também um valor real.
x := Int(50.80); //x = 0.80 x := Int(50.53); //x = 0.53
Abs(numero)
Retorna o valor absoluto (nº puro, sem o sinal) do argumento numérico.
x := Abs(-4.21); //x = 4
Pi
Retorna o valor do p, com 14 casas decimais.
x := Pi; //x = 3.14159265358979
Sqr(numero)
Eleva o valor passado como parâmetro ao quadrado e retorna um valor real.
x := Sqr(5); // x = 25
Caderno Didático PASCAL Página 20
20
Universidade Federal de Santa Maria
Sqrt(numero)
Retorna a raiz quadrada do valor passado como parâmetro.
x := Sqrt(9); // x = 3
Random
Retorna um número (pseudo)-randômico real entre 0 e 1. A sequência de
valores randômicos será sempre a mesma.
x := Random;
Random(numero_limite)
Retorna um número (pseudo)-randômico inteiro entre 0 e o valor do número
limite passado como parâmetro. A sequência de valores randômicos será sempre a
mesma.
x := Random(100); //Retorna um valor randômico entre 0 e 100
Randomize
É utilizado antes do comando Random, para forçar o uso do relógio e gerar um
número randômico real (em uma ordem que não se repita a cada execução do
programa).
Delay(tempo)
Efetua uma pausa no processamento. O tempo de duração da pausa é
determinado pelo parâmetro tempo (valor inteiro em milissegundos).
Delay(1000); //Aguarda um segundo
Sound(frequencia) e NoSound
Permite ativar o som do alto-falante interno, a uma frequência especificada no
parâmetro. Para desativar a emissão do som deve-se utilizar o procedimento
NoSound.
Sound(196); //Emite um som em frequência 196 (nota musical Sol) Delay(1000); //Aguarda um segundo NoSound; //desativa a emissão de som
Caderno Didático PASCAL Página 21
21
Universidade Federal de Santa Maria
ReadKey
Retorna o valor de uma tecla pressionada. Este valor é do tipo char. Quando
utilizamos essa função para entrada de dados, não é necessário que seja
pressionada a tecla ENTER para confirmar o valor digitado.
x := ReadKey;
Caderno Didático PASCAL Página 22
22
Universidade Federal de Santa Maria
CAPITULO VIII – Modularização
Ao transformar a lógica em um algoritmo, são desenvolvidas sequências de passos
que representam as ações que levam à resolução de um determinado problema. Essas
ações são dirigidas segundo as estruturas de controle, totalizando assim o algoritmo que é
representado como sendo um único bloco lógico (INÍCIO .. FIM).
Na medida em que os problemas a serem solucionados tornam-se mais complexos,
ou seja, apresentam uma variedade maior de situações diferentes a serem resolvidas,
observa-se uma série de pequenos problemas, que muitas vezes se repetem e cujas
respectivas soluções integrarão o conjunto de ações definitivo que irá formar o programa.
Quando tal conjunto é construído, podemos nos deparar literalmente com um
amontoado de ações que podem afetar a legibilidade, uma vez que podem não ficar claras e
concisas as pequenas partes lógicas que solucionam cada pequeno problema. Essa
situação dificulta a assimilação das construções por outra pessoa e de certa forma
inviabilizam uma perfeita coesão interna do algoritmo.
Para evitar essas circunstâncias, utilizamos uma estrutura que deixe explícito as
pequenas soluções e resulta em uma atividade conhecida como modularização. Na
linguagem pascal, existem duas maneiras de modularizarmos um programa: procedimentos
e funções.
PROCEDURE (Procedimentos)
Procedures (procedimentos) são as sub-rotinas mais comuns na linguagem
Pascal. O procedimento de chamada desvia o fluxo de execução do programa para a
primeira instrução do procedimento, que passa então a ser executada. Quando a
execução do procedimento termina, o fluxo é desviado para a instrução seguinte,
retomando-se a execução do programa principais (ou ainda do procedimento de
chamada).
A modularização com procedimentos obedece a seguinte sintaxe:
procedure NomeDaProcedure( <parâmetro 1> : <tipo 1>; <parâmetro 2> : <tipo 2>);
const <nome da constante> = <valor literal>;
var <nome da variável> : tipo;
begin <instrução 1>; <instrução n>;
end;
Caderno Didático PASCAL Página 23
23
Universidade Federal de Santa Maria
Abaixo um exemplo de declaração de procedure:
procedure MostraEstrelas(NumEstrelas : integer); var
i : integer; s : string;
begin for i:=1 to NumEstrelas do
s := s + '*';
WriteLn(s); end;
Neste exemplo, uma mensagem com ‘n’ asteriscos será exibida. A quantidade
de asteriscos é passada como parâmetro. Quando a procedure é chamada, sendo
assim para exibir 20 asteriscos utilizamos a seguinte chamada:
MostraEstrelas(20);
A passagem de parâmetros em um procedimento não é obrigatória, a seguir um
exemplo:
procedure MostraDezEstrelas(); const
NumEstrelas = 10; var
i : integer; s : string;
begin for i:=1 to NumEstrelas do
s := s + '*';
WriteLn(s); end;
O exemplo acima não permite nenhuma comunicação do código que chamou o
procedimento com o código do procedimento em si. Para fazer a chamada do
procedimento, basta colocar o nome do mesmo:
MostraDezEstrelas;
Caderno Didático PASCAL Página 24
24
Universidade Federal de Santa Maria
FUNCTION (Funções)
Funções são basicamente o mesmo que procedimentos, com uma grande
diferença: a função sempre retorna um valor de algum tipo. Para tanto, ao declarar
uma função, precisamos declarar também qual o tipo de valor que ela retorna.
A modularização com funções obedece a seguinte sintaxe:
function NomeDaFuncao( <parâmetro 1> : <tipo 1>; <parâmetro 2> : <tipo 2>) : <tipo retorno >
const <nome da constante> = <valor literal>;
var <nome da variável> : tipo;
begin <instrução 1>; <instrução n>;
NomeDaFuncao := <valor de retorno> end;
O valor de retorno de uma função pode ser especificado fazendo-se uma
atribuição diretamente ao nome da função:
function Cubo(base : integer) : integer begin
Cubo := base*base*base; end;
function Quadrado(base : integer) : integer begin
Quadrado := base*base; end;
Quando a função é chamada, o valor de retorno deve ser atribuído a uma
variável de mesmo tipo:
x := Cubo(2); //x será igual a 8 y := Quadrado(3); // y será igual a 9
Caderno Didático PASCAL Página 25
25
Universidade Federal de Santa Maria
Passagem de parâmetros
A passagem de parâmetros é uma excelente alternativa para que o código
chamador se comunique com o código da sub-rotina. Os parâmetros podem ser
passados tanto para procedimentos quanto para funções. Em linguagem Pascal há
duas formas de passar parâmetros para uma sub-rotina:
por valor: neste caso apenas o valor é transferido e todas as alterações
feitas nos parâmetros não alteram os valores reais (do código chamador).
Por padrão a passagem de parâmetros é feita por valor, dessa forma
nada precisa ser alterado para que a passagem se comporte dessa
forma. Ex.:
procedure MostrarNumeros(De : integer; Ate : integer); var
i : integer; begin
writeLn('Exibindo os numeros de ', De, ' até ', Ate); for i:=De to Ate do
writeLn(i);
De := 500; //Essa atribuição embora válida //não terá efeito sobre o valor do parâmetro // após a execução do procedimento
end;
...
MostrarNumeros(50,40);
a := 5; b := 10;
MostrarNumeros(a,b);
por referência: neste caso ao invés de passar o valor, o endereço do
parâmetro real é transferido. Todas as alterações nos parâmetros da sub-
rotina são feitos sobre as variáveis externas que foram passadas como
parâmetro. Em linguagem Pascal para passar parâmetros por referência
utilizamos o modificador var na frente do parâmetro (apenas na
declaração). Quando sub-rotinas utilizam-se de passagem por referência
é obrigatório que o parâmetro a ser passado seja uma variável (não
podendo ser, por exemplo, um valor literal). Ex.:
Caderno Didático PASCAL Página 26
26
Universidade Federal de Santa Maria
procedure Troca(var expr1 : string; var expr2 : string); var
aux : string; begin
aux := expr1; expr1:= expr2; expr2 := aux;
end;
procedure TrocaTeste(var expr1 : string; var expr2 : string); var
aux : string; begin
aux := expr1; expr1:= expr2; expr2 := aux;
end;
...
a := 5; b := 10; x := 23; y := 14;
Troca(a,b); //Qual é o valor de a e b agora? TrocaTeste(x, y); //Qual é o valor de x e y agora?
Caderno Didático PASCAL Página 27
27
Universidade Federal de Santa Maria
CAPITULO IX – Tipos de dados estruturados
Um tipo de dado estruturado difere de um tipo de dado simples pelo fato de
conter vários componentes ao invés de um só. Entretanto, cada um desses
componentes tem, em sua forma mais básica, a característica de um tipo de dado
simples, como os que foram apresentados anteriormente.
Além disso, os tipos de dados estruturados permitem um uso mais completo da
memória do computador, o que não ocorre com os tipos de dados simples, uma vez
que usam apenas porções de memória. Com o uso de tipos de dados estruturados é
possível, muitas vezes, programar soluções mais elegantes e legíveis aos problemas
propostos. Às vezes, a própria implementação de uma determinada solução só é
viável se a linguagem for razoavelmente rica em seus tipos de dados.
Records (Registros)
Quando temos a necessidade de, por exemplo, registrar diversas informações a
respeito de um funcionário de uma empresa, os campos necessários são em geral
de diversos tipos. Dados como nome, cargo e filiação são informações do tipo string,
já o número de dependentes e o salário são de tipos numéricos e assim por diante.
Assim, para representarmos em uma única variável as informações de um
funcionário, é necessário dispormos de um tipo especial de dado que permita essa
agregação. Em linguagem Pascal o tipo record é uma forma de criar uma única
estrutura com valores de diferentes tipos de dados, permitindo agregar em uma
mesma variável campos heterogêneos. Cada um dos dados de um record é
chamado de campo.
A estrutura do tipo de dado record pode ser vista como uma sequência de
bytes na memória, resultante da agregação de um ou mais itens de dados. Cada
item de dados (no caso, cada informação do funcionário), corresponde a um campo
do record (registro). Um campo em um registro pode também se constituir de um
outro registro.
Caderno Didático PASCAL Página 28
28
Universidade Federal de Santa Maria
type Funcionario = record
nome : string; cargo : string; filiacao : string; dependentes : integer; salario : real;
end;
var Func : Funcionario;
begin Func.nome := 'JOAO AUGUSTO DA SILVA'; Func.cargo := 'ANALISTA DE SISTEMAS'; Func.filiacao := 'MARCOS E HELENA DA SILVA'; Func.dependentes := 2; Func.salario := 2500.54;
Writeln('O funcionário ', Func.nome, ' ganha: R$ ', Func.salario); end;
Arrays (Vetores e Matrizes)
Arrays fornecem uma forma de criar variáveis que contenham múltiplos valores,
como em uma lista ou tabela, cujos elementos são do mesmo tipo. Possibilita a
utilização de variáveis que permitem o armazenamento de dados de forma similar
aos conceitos matemáticos de vetores e matrizes.
Em linguagem Pascal, a quantidade de elementos de um Array é constante, ou
seja, quando declaramos uma array informamos o tamanho e as dimensões que o
mesmo terá e todo o espaço necessário será alocado. De forma análoga ao conceito
matemático de vetores, o iésimo elemento de um vetor X é representado por X[i],
em que i pode variar de i a N, caso N seja a dimensão do vetor. Os códigos abaixo
exemplificam arrays de dimensões variadas.
var DiasDaSemana : array [1..7] of string; j : integer;
begin DiasDaSemana[1] := 'domingo'; DiasDaSemana[2] := 'segunda-feira'; DiasDaSemana[3] := 'terça-feira'; DiasDaSemana[4] := 'quarta-feira'; DiasDaSemana[5] := 'quinta-feira'; DiasDaSemana[6] := 'sexta-feira'; DiasDaSemana[7] := 'sábado';
Writeln('Abaixo estão os dias da semana: ');
for j := 1 to 7 do Writeln(DiasDaSemana[j]); end;
Caderno Didático PASCAL Página 29
29
Universidade Federal de Santa Maria
Uma situação bastante interessante no uso desse tipo de dado é aquela que
simula matrizes matemáticas, ou seja, quando os elementos de um vetor são
também vetores:
Matriz : array [1..3,1..4] of integer; //Duas dimensões // 3 linhas e 4 colunas
O exemplo anterior cria um vetor bidimensional (tabela). Para referenciarmos as
posições da matriz devemos informar suas coordenadas de linha e coluna:
67
56
78
32
23
56
98
09
76
89
45
76
Writeln(Matriz[2,3]); //Escreve na tela o conteúdo da linha 2 col. 3 //Resultado = 98
Também é possível especificar matrizes com outras dimensões, e sua aplicação
geralmente está relacionada à aplicações gráficas em três dimensões ou outros
algoritmos mais complexos (cruzamentos de dados, por exemplo).
Cubo : array [1..5,1..5,1..5] of integer; //Três dimensões
Caderno Didático PASCAL Página 30
30
Universidade Federal de Santa Maria
CAPITULO X – Arquivos
Comumente aplicações precisam gravar informações para recuperá-las em outro
momento. Quando as informações no qual estamos atuando precisam ser persistidas
fisicamente para posterior recuperação faz-se necessário a utilização de arquivos.
Informações gravadas em arquivos não ficam limitadas ao tamanho da memória
RAM e sim ao tamanho do meio físico utilizado para sua gravação (disco rígido,
disco flexível, pen-drive, etc.).
Em linguagem Pascal a manipulação de um arquivo pode acontecer de duas
formas: arquivo texto (text) ou arquivo binário (file of <tipo>). Os arquivos
binários são formados por uma estrutura de elementos do mesmo tipo, dispostos de
forma sequencial. Abaixo a sintaxe:
type <arquivo> = [text][file [of <tipo>]];
var <variavel> : <arquivo>;
ou
<variavel> : [text][file [of <tipo>]];
O código a seguir declara uma variável que representará um arquivo binário de
inteiros:
type arquivoDeInteiros = file of integer;
var arquivo : arquivoDeInteiros;
A declaração é equivalente a essa:
var arquivo : file of integer;
A seguir a declaração de um arquivo texto (de duas formas equivalentes):
type arquivoDeInteiros = text;
var arquivo : arquivoDeInteiros;
Ou (forma equivalente):
var arquivo : text;
Caderno Didático PASCAL Página 31
31
Universidade Federal de Santa Maria
Além de tipos básicos podemos utilizar tipos compostos para definição de
arquivos binários:
type Funcionario = record
nome : string; cargo : string; filiacao : string; dependentes : integer; salario : real;
end;
var arquivo : file of Funcionario;
Comandos e Operações sobre Arquivos
Assign(variavel, arquivo)
Associa um nome lógico de arquivo ao arquivo físico. O primeiro parâmetro é a
indicação de uma variável do tipo arquivo, e o parâmetro arquivo é uma string com o
caminho e nome do arquivo a ser manipulado.
var arquivoDeFuncionarios : file of Funcionario;
begin Assign(arquivoDeFuncionarios, 'c:\dados\bd\dados_func.bin'); ...
end.
Rewrite(variavel_arquivo)
Cria um arquivo para uso, utilizando o nome associado ao parâmetro
variável_arquivo. Caso o arquivo já exista, esta instrução o apagará para criá-lo
novamente.
Rewrite(arquivoDeFuncionarios);
Reset(variavel_arquivo)
Abre um arquivo existente, colocando-o disponível para leitura e gravação,
utilizando o nome associado ao parâmetro variavel_arquivo. Caso o arquivo não
exista a aplicação acusará um erro.
Reset(arquivoDeFuncionarios);
Caderno Didático PASCAL Página 32
32
Universidade Federal de Santa Maria
Append(variavel_arquivo)
Abre um arquivo existente, colocando-o disponível para leitura e gravação,
utilizando o nome associado ao parâmetro variavel_arquivo e posicionando o
ponteiro lógico no final do arquivo. Assim como o comando Reset, caso o arquivo
não exista a aplicação acusará um erro.
Append(arquivoDeFuncionarios);
Write(variavel_arquivo, variavel_ou_dado)
Escreve a informação (dado) no arquivo indicado pelo parâmetro
variavel_arquivo.
Write(arquivo_texto, 'Mensagem');
Read(variavel_arquivo, variavel_destino)
Recupera a informação do arquivo e armazena na variável indicada como
parâmetro. A leitura ocorre na possição corrente do arquivo.
Read(arquivoDeFuncionarios, func1);
Close(variavel_arquivo)
Fecha um arquivo em uso dentro de um programa. O encerramento dos arquivos
é muito impotante, pois indica ao sistema operacional que aquele arquivo está
liberado para outras operações, nenhum programa deve ser encerrado sem antes
fechar os arquivos abertos.
Close(arquivoDeFuncionarios);
Eof(variavel_arquivo)
Abreviatura para End of File. Retorna verdadeiro (true) se o ponteiro lógico está
posicionado no último registro do arquivo.
Eof(arquivoDeFuncionarios);
Caderno Didático PASCAL Página 33
33
Universidade Federal de Santa Maria
FileSize(variavel_arquivo)
Retorna o número de registros do arquivo indicado como parâmetro. Se o
arquivo estiver vazio a função irá retomar o valor zero. Se for utilizada com arquivos
não tipados, esta função considera que os registros deste arquivo possuem o
tamanho de 128 caracteres.
FileSize(arquivoDeFuncionarios);
Seek(variavel_arquivo, posicao)
Posiciona o cursor/ponteiro lógico na posição indicada.
//Posiciona o ponteiro lógico no último registro do arquivo FileSize(arquivoDeFuncionarios, FileSize(arquivoDeFuncionarios));
//Posiciona o ponteiro lógico no início do arquivo FileSize(arquivoDeFuncionarios, 0);
FilePos(variavel_arquivo)
Retorna a posição do cursor/ponteiro lógico no arquivo indicado.
x := FilePos(arquivoDeFuncionarios);
IOResult
Informa um código de erro quando são realizadas operações de Entrada/Saída.
Se ioresult não for igual a zero, significa que houve algum erro (geralmente é usado
para testar a existência ou inexistência de um arquivo na hora de sua abertura)
program gravar_arquivo;
var arquivo : Text;
begin
assign(arquivo,'C:\temp\Arquivo.txt'); {$i-} //Desabilita a verificação de erros de entrada e saída append(arquivo); //Tenta abrir o arquivo {$i+} //Habilita a verificação de erros de entrada e saída if IoResult > 0 then //Se der um erro rewrite(arquivo); //Cria um arquivo novo writeln(arquivo,'Teste'); close(arquivo); end.
Caderno Didático PASCAL Página 34
34
Universidade Federal de Santa Maria
Anexo I
Tabela de códigos ASCII
(fonte: http://www.tabelaascii.com/)
American Standard Code for Information Interchange (ASCII), que em português significa "Código
Padrão Americano para Intercâmbio de Informação") é uma codificação de caracteres de sete bits baseada no
alfabeto inglês. Os códigos ASCII representam texto em computadores, equipamento de comunicações, entre
outros dispositivos que trabalham com texto. Estes dispositivos só percebem números, sendo assim um código
ASCII é uma representação numérica de um carácter, tal como um 'a' ou um 't'. A maioria dos actuais esquemas
de codificação modernos, com suporte para muitos caracteres, tiveram origem no código ASCII.
ASCII incluí definições para 128 caracteres: 33 caracteres de controle não imprimíveis (a maioria
obsoletos) que afetam a forma como o texto é processado; 94 são caracteres imprimíveis, e o espaço é
considerado invisível. Atualmente o método de codificação mais comum é o UTF-8.
Cód.
Caracter
Designação
Cód.
Caracter
Cód.
Caracter
Cód.
Caracter
000
CTRL-@ Null 032
(BRANCO)
064
@ 096
`
001
CTRL-A Start Of Header 033
! 065
A 097
a
002
CTRL-B Start Of Text 034
" 066
B 098
b
003
CTRL-C End Of Text 035
# 067
C 099
c
004
CTRL-D
End Of Transmition
036
$
068
D
100
d
005
CTRL-E Enquire 037
% 069
E 101
e
006
CTRL-F Acknowledge 038
& 070
F 102
f
007
CTRL-G Bell 039
' 071
G 103
g
008
CTRL-H Back Space 040
( 072
H 104
h
009
CTRL-I Horizontal Tabulation 041
) 073
I 105
i
010
CTRL-J Line Feed 042
* 074
J 106
j
011
CTRL-K Vertical Tabulation 043
+ 075
K 107
k
012
CTRL-L Form Feed 044
, 076
L 108
l
013
CTRL-M
Carriage Return
045
-
077
M
109
m
014
CTRL-N
Shift Out
046
.
078
N
110
n
015
CTRL-O Shift-In 047
/ 079
O 111
o
016
CTRL-P Data Link Escape 048
0 080
P 112
p
017
CTRL-Q Device 1 049
1 081
Q 113
q
018
CTRL-R Device 2 050
2 082
R 114
r
019
CTRL-S Device 3 051
3 083
S 115
s
020
CTRL-T Device 4 052
4 084
T 116
t
021
CTRL-U Not Acknowledge 053
5 085
U 117
u
022
CTRL-V Synchronous Idle- 054
6 086
V 118
v
023
CTRL-W
End Of Transmition Block
055
7
087
W
119
w
024
CTRL-X Cancel 056
8 088
X 120
x
025
CTRL-Y End Of Medium 057
9 089
Y 121
y
026
CTRL-Z Substitute 058
: 090
Z 122
z
027
CTRL-[ Escape 059
; 091
[ 123
{
028
CTRL-\ File Separator 060
< 092
\ 124
|
029
CTRL-] Group Separator 061
= 093
] 125
}
030
CTRL-^ Register Separator 062
> 094
^ 126
~
031
CTRL-_ Unit Separator 063
? 095
_ 127
DEL
Tabela ASCII original
Caderno Didático PASCAL Página 35
35
Universidade Federal de Santa Maria
Com o advento e popularização dos microcomputadores pessoais tornou-se necessário representar
caracteres acentuados em função dos mesmos estarem atingindo mercados não concebidos originalmente, e
que se utilizavam de uma gama maior de tipos imprimíveis. Partindo dessa necessidade a IBM ao lançar o PC
(Personal Computer) ampliou a tabela ASCII dando a ela a capacidades de 256 caracteres codificados, incluindo
além de caracteres acentuados uma série de caracteres semi-gráficos.
Tabela ASCII Estendida (CP 437)
Caderno Didático PASCAL Página 36
36
Universidade Federal de Santa Maria
A ampliação da tabela ASCII, contemplava muitos caracteres acentuados, porém ainda não
acomodava todas as possibilidades, principalmente para os idiomas de origem latina (p. ex.: ã; õ; Ã; Õ; etc.),
além de que muitos caracteres maiúsculos e acentuados não foram contemplados. Diante dessa necessidade, a
Microsoft implementou o conceito de páginas de código, dessa forma poderiam existir diversas tabelas ASCII
estendidas para cada necessidade. Aquela original recebeu a denominação de ASC 437 (código de página para
US) e aquela que melhor nos serve para os países da América Latina recebeu a denominação ASC 850 (código
de página latin I), mostrada abaixo:
Cód.
Caracter
Cód.
Caracter
Cód.
Caracter
Cód.
Caracter
128
Ç
160
á
192
+
224
Ó
129 ü 161 í 193 - 225 ß
130 é 162 ó 194 - 226 Ô 131 â 163 ú 195 + 227 Ò
132 ä 164 ñ 196 - 228 õ
133 à 165 Ñ 197 + 229 Õ
134 å 166 ª 198 ã 230 µ
135
ç
167
º
199
Ã
231
þ
136 ê 168 ¿ 200 + 232 Þ
137 ë 169 ® 201 + 233 Ú 138 è 170 ¬ 202 - 234 Û
139 ï 171 ½ 203 - 235 Ù
140
î
172
¼
204
¦
236
ý
141 ì 173 ¡ 205 - 237 Ý
142 Ä 174 « 206 + 238 ¯
143 Å 175 » 207 ¤ 239 ´
144 É 176 _ 208 ð 240
145
æ
177
_
209
Ð
241
±
146 Æ 178 _ 210 Ê 242 _
147 ô 179 ¦ 211 Ë 243 ¾ 148 ö 180 ¦ 212 È 244 ¶
149 ò 181 Á 213 i 245 § 150 û 182 Â 214 Í 246 ÷
151 ù 183 À 215 Î 247 ¸
152
ÿ
184
©
216
Ï
248
°
153 Ö 185 ¦ 217 + 249 ¨
154 Ü 186 ¦ 218 + 250 ·
155 ø 187 + 219 _ 251 ¹
156 £ 188 + 220 _ 252 ³ 157 Ø 189 ¢ 221 ¦ 253 ²
158 × 190 ¥ 222 Ì 254 _
159
ƒ
191
+
223
_
255
Tabela ASCII Estendida Código de Página Latin I (CP 850)
Caderno Didático PASCAL Página 37
37
Universidade Federal de Santa Maria
Referências Bibliográficas
BOENT, A. Aprendendo a Programar em Pascal. Ed. Brasport, 2003.
CANTÙ'S, M. Essential Pascal. 4ª Edição. Paperback, 2008.
EVARISTO, J. Programando com Pascal. 2ª Edição. Ed. Book Express, 2004.
GUIMARAES, A. M. Programando O Computador Com Pascal - Um Ambiente Para Autoaprendizagem. Ed. UFMG, 2008.
LAUREANO, M. Lógica de Programação - Uma Abordagem Em Pascal. Ed. Ciência Moderna, 2010.
MANZANO, J. A.; YAMATUMI, W. Y. Free Pascal - Programação de Computadores. Ed. Érica, 2007.
WIRTH, N. Programação Sistemática em Pascal. 6ª Edição. Ed. Campus, 1989.