Introdução ao Pascal

Universidade Federal de Santa Maria 2010

Caderno Didático

Bruno B. Boniati
Joel da Silva
Teresinha Letícia da Silva

Frederico Westphalen, 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

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 1


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.



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 end mod repeat
array file nil set
begin for not then
case forward of to
const function or type
div goto packed until
do if procedure var
downto in program while
else label record with



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;



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.



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.



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
-45
single 1,5 .. 3,438 7-8 4
-39
real 2,9 .. 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.


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



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.



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');



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;



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:

<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:

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;



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>;



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.



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.



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



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);



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



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



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



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;



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;



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;



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



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.:



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?



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.



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;



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



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;



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:dadosbddados_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);



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);



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:tempArquivo.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.



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



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)



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)



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.


Introdução ao Pascal

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (17)

En vedette

En vedette (20)

Similaire à Introdução ao Pascal

Similaire à Introdução ao Pascal (20)

Introdução ao Pascal