Caderno didatico pascal

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


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.

http://www.freepascal.org/


2


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.


3


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


4


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;


5


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.


6


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.


7


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.


8


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


9


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.


10


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


11


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;


12


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;


13


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


14


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.


15


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.


16


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


17


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


18


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


19


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


20


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


21


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;


22


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;


23


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;


24


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


25


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


26


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?


27


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.


28


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;


29


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


30


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;


31


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


32


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


33


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.


34


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

http://www.tabelaascii.com/


35


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)


36


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)


37


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.

Documents

Caderno didatico pascal