Documente Academic
Documente Profesional
Documente Cultură
Escola de Informática
Linguagem Pascal
por
Bibliografia
RAMALHO, Luciano & PRATES, Rubens - Turbo Pascal, Cartão de Referência, Livros
Técnicos e Científicos Editora S.A.
1
Conteúdo Programático
1. Introdução à Linguagem Pascal
1.1 Histórico
1.2 Objetivos
1.3 Características de um Sistema em uma Linguagem Ideal
2.1 File
2.2 Edit
2.3 Run
2.4 Compile
2.5 Options
2.6 Debug
2.7 Break/watch
2.8 Como usar o DEBUG
3.1 Identificadores
3.2 Comentários
3.3 Estrutura Geral
3.4 Definição de Tipos (Type)
4. Tipos de dados
4.1 Integer
4.2 Real
4.3 Byte
4.4 Char
4.5 Boolean
4.6 String
4.7 Array
4.8 Word
4.9 ShortInt
4.10 LongInt
5. Operadores
2
5.3.1 Not
5.3.2 And
5.3.3 Or
5.5.1 Inc
5.5.2 Dec
6. Funções Padrões
6.1 Abs
6.2 ArcTan
6.3 Cos
6.4 Sin
6.5 Exp
6.6 Frac
6.7 Int
6.8 Sqr
6.9 Sqrt
6.10 Ln
6.11 Chr
6.12 Ord
6.13 Round
6.14 Trunc
6.15 Pi
6.16 Random
7. Comandos
7.1.1 Seqüência
7.1.2 Seleção
7.1.3 Repetição
7.1.4 Atribuição
8. Entrada e Saída
3
8.1 Entrada pelo Teclado
8.2 Saída no Vídeo
8.3 Saída na Impressora
9. Controle do Vídeo
9.1 ClrScr
9.2 GotoXY
9.3 ClrEol
9.4 DelLine
10.1 Delay
10.2 TextBackGround
10.3 TextColor
10.4 Window
10.5 Sound e NoSound
10.6 WhereX e WhereY
10.7 TextMode
11.1 Vetores
11.2 Matrizes
11.3 Sort (Ordenação)
12.1 Chr
12.2 Ord
12.3 Concat
12.4 Copy
12.5 Delete
12.6 Insert
12.7 Lenght
12.8 Pos
12.9 Str
12.10 UpcCse
12.11 Val
12.12 FillChar
4
13.5 Function
13.6 Procedure
14. Arquivos
14.1 Procedimentos
14.1.1 Assign
14.1.2 Close
14.1.3 Erase
14.1.4 Read
14.1.5 Write
14.1.6 ReName
14.1.7 Reset
14.1.8 ReWrite
14.1.9 Seek
14.2 Funções
14.2.1 Eof
14.2.2 FilePos
14.2.3 FileSize
14.2.4 SizeOf
15. Gráficos
15.1.1 CGA
15.1.2 EGA
15.1.3 VGA
15.2.1 CGA
15.2.2 EGA
15.2.3 VGA
5
15.12 Preenchimento (Pintura)
19. Ponteiros
20. Interrupções
6
1. Introdução à Linguagem Pascal
1.1 Histórico
Desenvolvido em 1970 pelo Prof. Nicklaus Wirth no Technical University - Zurique -
Suiça.Nome em homenagem à Blaise Pascal (Séc. XVII).
1.2 Objetivos
a) Ensino da Programação, pois é uma linguagem didática;
b) Programação Estruturada.
7
2.1 File (Arquivo) [ALT][F]
Permite carregar arquivo, salvar arquivo, listar diretório, criar novos fontes, renomear
arquivos, saída temporária ao Sistema Operacional e saída definitiva ao sistema operacional.
Pick (Pegar)[ALT][F3]
É exibida uma lista com os nomes dos últimos arquivos que foram carregados. O
programador pode selecionar um deles (seta acima ou abaixo) e então carregá-lo do Disco para o
Editor. Os nomes dos arquivos ficam armazenados em um arquivo chamado "TURBO.PCK".
New (Novo)
Permite ao programador editar um "novo" arquivo. Este arquivo possui o nome de
"NONAME.PAS", este nome deve ser renomeado quando o arquivo for salvo no disco (F2).
Directory (Diretório)
Exibe o diretório do disco corrente, de acordo com uma máscara especificada, permite
ainda, que um arquivo seja carregado.
8
Saída temporária do Turbo Pascal para o Sistema Operacional. Para retornar ao Ambiente
digita-se Exit.
Build (Construir)
Recompila todos os arquivos relacionados ao arquivo primário ("Primary File").
10
Compiler (Compilador)
Permite a inserção de diretivas de compilação sem escrevé-las no programa-fonte.
Range checking (ON ou OFF): Se ligada, verifica se os "array" e "string" estão dentro das
faixas definidas pelo programador.
Stack checking (ON ou OFF): Se ligada, o compilador verifica se há espaço na pilha para
as variáveis locais, antes das chamadas das "procedure" e "function".
I/O checking (ON ou OFF): Se ligada, verifica se há erros de entrada e saída. Em OFF
pode-se testar erros de entrada e saída através da função IoResult.
Force for calls (ON ou OFF): Se ligada, o compilador gera chamadas Near para
"procedure" e "function" que estiverem sendo compiladas.
Overlays allowed (ON ou OFF): Permite a geração de código "OverLay" para uma unidade
(".OVL").
Align data (Word ou Byte): Em "Word" todos os dados maiores que "Byte" são tratados
como tipo "Word".
Emulation (ON ou OFF): Emula (simula) um coprocessador aritmético, se ele não existir.
Local symbols (ON ou OFF): Gera informações sobre símbolos locais (nomes e tipos de
todas as variáveis e constantes locais de um símbolo).
Memory Sizes (Stack size, Low heap limit ou High heap limit): Permite configurar o mapa
de memória de um arquivo de código resultante, ou seja, o tamanho da memória.
Stack size: Permite especificar o tamanho do segmento da pilha em bytes.
Low heap limit: Permite especificar o limite inferior da pilha.
High heap limit: Permite especificar o limite superior da pilha.
11
Linker
Permite especificar diferentes modalidades de geração do mapa do "linker" e o destino do
"link buffer".
Environment (Ambiente)
Permite configurar o ambiente de trabalho.
Edit auto save (ON ou OFF): Salva automaticamente o arquivo fonte quando o arquivo for
executado ("Run") ou quando da saída para o Sistema Operacional ("Quit" ou "Os shell").
Backup files (ON ou OFF): Gera arquivo "*.BAK" quando o arquivo fonte for salvo.
Tab size 8: Especifica o tamanho da tabulação horizontal do editor (tab) (2 até 16 brancos).
Zoom windows (ON ou OFF): se ligada, as janelas Edit, Watch ou OutPut estão
expandidas.
Screen size (25 line display ou 43/50 line display): Permite selecionar o número de linhas
na tela: 25 placa CGA, 43 placa EGA e 50 placa VGA.
Directories (Diretório)
Permite especificar drive:\path para diretórios dos arquivos usados e gerados pelo turbo.
EXE & TPU Diretory: Diretório dos arquivos "*.EXE" (executáveis) e "*.TPU"
(unidades).
12
Include Diretories: Especifica o diretório dos arquivos utilizados pela diretiva de inclusão
de fontes {$I}.
Unit Diretories: Especifica o diretório dos arquivos fontes de unidades ("*.PAS" das
unidades).
Pick File Name: Especifica o drive, caminho e nome do arquivo de seleção "*.PCK".
Current Pick File: Indica o drive, caminho e nome do arquivo de seleção corrente.
Parameters (Parâmetros)
Permite a especificação de parâmetros para que o programa possa ser compilado na
memória.
13
Display swapping (None, Smart ou Always): Permite estabelecer modos de visualização de
"OutPut" de tela durante a depuração do programa.
Add watch [CTRL][F7]: Permite que a variável sob o cursor seja exibida na janela de
assistência quando o "debug" for executado
Delete watch: Permite que uma variável da janela de assistência seja deletada.
Edit watch: Permite que uma variável da janela de assistência seja editada (alterada).
14
2.8 Como usar o DEBUG
Passo 1: Ter as duas janelas na tela: janela de edição e janela de assistência [F5];
Passo 3: Rodar o programa "Run" ou [CTRL][F9], o programa é executado até a linha anterior ao
"BreakPoint";
Observação: Para visualizar o resultado obtido na tela de execução [ALT][F5] ou a opção "User
screen" do menu "Run";
Passo 4: Para selecionar as variáveis que se deseja assistir, posiciona-se o cursor em cima da
variável e [CTRL][F7] ou a opção "Add watch" do menu "Break/watch", após aparecer uma janela
com a variável no seu interior (podendo-se alterar ou mudar a variável) pressiona-se [RETURN];
Passo 5: Para visualizar a execução do programa linha é linha pressiona-se [F8] (opção "Step over"
do menu "Run") ou [F7] (opção "Trace into" do menu "Run"):
[F8]: executa o programa linha é linha sem entrar nas "procedure" e "function";
[F7]: executa o programa linha é linha entrando também nas "procedure" e "function";
Passo 6: Pode-se ainda "Delete watch" (deletar variável), "Edit watch" (editar variável) ou
"Remove all watches" (remover todas as variáveis) no menu "Break / watch".
Passo 7: Pode-se ainda desviar a execução do "debug" para a linha que está o cursor [F4] ou a
opção "Goto cursor" do menu "Run";
Passo 8: Para encerrar a execução do "debug" [CTRL][F2] ou a opção "Program reset" do menu
"Run", deve-se ainda desmarcar todos os "breakpoints" através da opção "Clear all breapoints" do
menu "Break/watch".
15
3. Estrutura de um Programa Pascal
3.1 Identificadores
São os nomes criados pelo programador para:
Regras:
3.2 Comentários
O programador pode, dentro do seu programa, fazer comentários sem que o código seja
compilado, isto pode ser feito de duas maneiras:
(* ------------------------------------------------- Unidades *)
(* ---------------------------------------------- Declarações *)
Const x = 100;
PI = 3.1415;
UP = #72; {tecla acima}
LEFT = #75; {tecla esquerda}
16
RIGHT = #77; {tecla direita}
DOWN = #80; {tecla abaixo}
PGUP = #73;` {tecla pagina acima}
PGDN = #81; {tecla pagina abaixo}
ENTER = #13; {tecla RETURN ou ENTER}
ESC = #27; {tecla ESC}
BACKSPACE = #8; {tecla BACKSPACE}
(* ----------------------------------------------- Definições *)
Procedure nome_do_procedimento(parâmetros);
Begin
comandos;
End;
Begin
comandos;
End.
Uses Crt;
17
Begin
ClrScr;
Data.ano := 1995;
Data.mes := 12;
Data.dia := 19;
Nome := _UCPel';
4. Tipos de Dados
4.1 - Integer: (2 bytes) Faixa: [-32768 à 32767]
18
4.5 - Boolean: (1 byte) Faixa: [True ou False]
19
4.9 - ShortInt: (1 byte) (-128 à 127)
5. Operadores
5.1 - Operadores Aritméticos
5.1.1 - Com REAIS
+ Adição
- Subtração
* Multiplicação
/ Divisão
Uses Crt;
Begin
ClrScr;
X := 7;
Y := 2;
Divisao := X / Y; { Divisao = 3,5 }
Resto := X Mod Y; { Resto = 1 }
Quociente := X Div Y; { Quociente = 3 }
7 2
1 3
Not A F V
AND V F
V V F
Condição B
F F F
5.3.3 - Or (ou):
21
Condição A
OR V F
V V V
Condição B
F V F
XOR V F
V F V
Condição B
F V F
Exemplo (1):
Repeat
Ch := ReadKey;
Until Ch In ['S','s','N','n'];
(* verdadeiro quando Ch é igual a: 'S','s','N','n' *)
É igual a:
Repeat
Ch := ReadKey;
Until (Ch = 'S') Or (Ch = 's') Or (Ch = 'N') Or (Ch = 'n');
(* verdadeiro quando Ch é igual a: 'S','s','N','n' *)
Exemplo (2):
Repeat
ReadLn(X);
Until X In [1,2,3,4,5]; (* ou X In [1..5]; *)
(* verdadeiro quando X é igual a: 1,2,3,4,5 *)
É igual a:
22
Repeat
ReadLn(X);
Until (X=1) or (X=2) Or (X=3) Or (X=4) Or (X=5);
(* verdadeiro quando X é igual a: 1,2,3,4,5 *)
Inc(i); (* i := i + 1 *)
Inc(i,5); (* i := i + 5 *)
5.5.2 Dec
Procedimento que permite o decremento de uma variável inteira.
Dec(i); (* i := i - 1 *)
Dec(i,5); (* i := i - 5 *)
6. Funções Padrões
6.1 - Exp(x): Função exponencial ex
6.2 - Abs(x): Valor absoluto (valor sempre positivo).
6.3 - ArcTan(valor): Função arco tangente (resultado em radianos).
6.4 - Cos(ang): Função cosseno (ângulo em radianos).
6.5 - Sin(ang): Função seno (ângulo em radianos).
6.6 - Frac(x): Retorna a parte fracionária.
6.7 - Int(x): Retorna a parte inteira.
6.8 - Sqr(x): Retorna x elevado a segunda potência.
6.9 - Sqrt(x): Retorna a raiz quadrada de x.
6.10 - Ln(x): Logaritmo Natural.
6.11 - Chr(x): Transforma ordinal em caracter.
6.12 - Ord(x): Transforma caracter em ordinal.
6.13 - Round(x): Converte real em inteiro arredondando.
6.14 - Trunc(x): Converte real em inteiro sem arredondar.
6.15 - Pi: Valor Pi = 3.1415926535897932385.
6.16 - Random(v): Gera um número aleatório de zero até (v-1).
7. Comandos
23
7.1 Tipos de Comandos
7.1.1 Seqüência
É um tipo de comando que no fluxo lógico do programa é executado e o controle passa para
o próximo comando.
Exemplo:
Exemplo:
If numero = 0 Then
WriteLn('Zero')
Else
If numero > 0 Then
WriteLn('Positivo')
Else
WriteLn('Negativo');
Exemplo:
i := 1;
Repeat (* repete até que uma tecla seja pressionada *)
WriteLn('i = ',i);
Inc(i); (* inc(i) é igual a i := i+1 *)
Until KeyPressed;
7.1.4 Atribuição
24
É um tipo de comando que permite que uma expressão (equação) seja resolvida e o seu
valor atribuído (igualado a uma variável).
Exemplo:
i := 1;
x := x + 1;
x1 := (- b + sqrt(sqr(b) - 4 * a * c)) / (2 * a);
For i := 1 to 100 do
WriteLn(i);
Composto: Quando mais de um comando está ligado a outro, usar-se os delimitadores Begin, End;
For i := 1 to 100 do
Begin
WriteLn('i = ',i);
ch := ReadKey;
End;
If condição Then
comando;
ou
If condição Then
comando 1
Else
comando 2;
7.4 - Comando Case ... Of ... Else ... End (Comando de Seleção)
25
Modo de usar:
Case variável
OF
constante 1: comando 1;
constante 2: comando 2;
. .
. .
constante n: comando n;
End;
ou
Case variável
Of
constante 1: comando 1;
constante 2: comando 2;
. .
. .
. .
constante n: comando n;
Else
comandos;
End;
Case letra
Of
'a'..'z': WriteLn('Minúsculas');
'A'..'Z': WriteLn('Maiúsculas');
'0'..'1': WriteLn('Número');
Else
WriteLn('Caracter Especial');
End;
Case digito
Of
'0': WriteLn('Zero');
'1': WriteLn('Um');
'2': WriteLn('Dois');
:
26
'9': WriteLn('Nove');
Else
WriteLn('ERRO: Não é um Número');
End;
A variável de controle não deve ser alterada no corpo do comando, pode-se ter comando
simples ou comando composto, a variável de controle não deve ser real, array ou string.
For i := 0 To 255 Do
Begin
WriteLn('Código: ',i,'- Caracter ASCII:',Chr(i));
ch := ReadKey;
End;
For i := 1 To n-1 Do
For j := i+1 To n Do
Begin
WriteLn('i=',i,' | j=',j);
ch := ReadKey;
End;
While condição Do
comandos;
Exemplo:
i := 1;
While i <= 10 Do
Begin
WriteLn('i = ',i);
i := i+1;
27
End;
Repeat
comandos;
Until condição;
Os comandos são repetidos, até que a condição se torne verdadeira, enquanto a condição é
falsa os comandos são repetidos.
Exemplo:
i := 1;
Repeat
WriteLn('i = ',i);
i := i+1;
Until i >= 10; { Repete até i ser igual a 10 }
i := 0;
Repeat
WriteLn('i = ',i);
i := i+1;
Until KeyPressed; { Repete até que uma tecla seja pressionada }
Modo de Usar:
Repeat
:
If KeyPressed then Exit;
:
Until False;
28
8. Entrada e Saída
8.1 Entrada pelo Teclado
ReadLn: Procedimento que permite entrada de dados via teclado. A variável x pode ser de
qualquer tipo.
ReadLn(x);
ReadKey: Função que permite a entrada de um caracter sem pressionar a tecla <ENTER>. A
variável deve ser do tipo Char e é necessário usar a unidade Crt;.
Uses Crt;
Var Tecla: Char;
Begin
ClrScr;
Write('Digite uma TECLA: ');
Tecla := ReadKey;
WriteLn('Você digitou: ',Tecla);
End.
Uses Crt,Printer;
Begin
ClrScr;
WriteLn(Lst); (* Pula uma linha na impressora *)
Write(Lst,'x = ');
WriteLn(Lst,x);
End.
Observação:
29
WriteLn(lst,#12); (* Salta uma página na impressora *)
WriteLn(lst,#15); (* Comprime os caracteres na impressora *)
Uses Crt;
Begin
ClrScr;
25 Tel a Linh as
2 5
Uses Crt;
Begin
ClrScr;
GotoXY(30,12);
Write('Turbo Pascal');
GotoXY(34,13);
Write('5.5');
Uses Crt;
30
Var L: Byte;
Begin
TextBackGround(WHITE); { Altera a cor de fundo}
ClrScr;
TextColor(BLACK); { Altera a cor do Texto }
For L := 1 to 24 do
Begin
GotoXY(40,L);
ClrEol;
End;
End.
Uses Crt;
Var L: Byte;
Begin
TextBackGround(WHITE); { Altera a cor de fundo}
ClrScr;
TextColor(BLACK); { Altera a cor do Texto }
For L := 1 to 24 do
Begin
GotoXY(40,L);
DelLine;
End;
End.
Modo de Usar:
Delay(x); { x em milisegundos }
Modo de Usar:
31
Número Nome Cor
0 Black preto
1 Blue azul
2 Green verde
3 Cyan azul claro
4 Red vermelho
5 Magenta rosa
6 Brown marrom
7 LightGray cinza
Modo de Usar:
0 Black preto
1 Blue azul
2 Green verde
3 Cyan azul claro
4 Red vermelho
5 Magenta rosa
6 Brown marrom
7 LightGray cinza
8 DarkGray cinza brilhante
9 LightBlue azul brilhante
10 LightGreen verde brilhante
11 LightCyan azul claro brilhante
12 LightRed vermelho brilhante
13 LightMagenta rosa brilhante
14 Yellow amarelo
15 White branco
32
(Xi,Yi)
(Xf,Yf)
Modo de Usar:
Window(Xi,Yi,Xf,Yf);
Observação: Após setar uma janela ativa a posição (1,1) passa ser o canto superior esquerdo.
Modo de Usar:
Sound(nota: Word);
Uses Crt;
Begin
Sound(220); (* ativa o auto-falante com a nota 220 *)
Delay(200); (* período de duração do som *)
NoSound; (* desativa o auto-falante *)
End.
Modo de Usar:
NoSound;
Uses Crt;
Var Coluna,Linha: Byte;
Begin
Coluna := WhereX;
Linha := WhereY;
33
WriteLn('Coluna: ',Coluna);
WriteLn('Linha : ',Linha);
End.
11.1 Vetores
É um tipo particular de matriz onde cada elemento possui só um índice (unidimensional).
O programa exemplo abaixo, permite a entrada de nomes e idades, logo após imprime todos
os nomes e idades contidos na memória.
Program Vetor;
Uses Crt;
Const QUANT = 255;
Var Nome: Array[1..QUANT] of String[40];
Idade: Array[1..QUANT] of Byte;
I,N: Byte;
Ch: Char;
Begin
ClrScr;
I := 1;
Repeat
Write('Nome: ');
ReadLn(Nome[i]); (* entrada de um nome *)
Write('Idade: ');
ReadLn(Idade[i]); (* entrada de uma idade *)
Inc(I);
Write('Continua [S]im ou [N]ão ? ');
Repeat
Ch := ReadKey;
Until Ch IN ['S','s','N','n'];
34
Until (Ch IN ['N','n']) Or (I > QUANT);
N := I - 1; (* número de elementos *)
For I := 1 To n Do
Begin
WriteLn('Nome: ',Nome[i]);
WriteLn('Idade: ',Idade[i]);
Ch := ReadKey;
End;
End.
11.2 Matriz
É um tipo de dado que permite que uma variável contenha vários elementos de mesmo tipo.
Cada elemento possui dois ou mais índices (bidimensional, tridimensional, etc) que o diferencia dos
outros elementos.
O programa abaixo, calcula a soma de duas matrizes: C = A + B.
Program vetor;
Uses Crt;
Const QUANT = 10;
Var A,B,C: Array[1..QUANT,1..QUANT] of Real;
Col,Lin,J,M,N: Byte;
Ch: Char;
Begin
ClrScr;
Write('Informe a ORDEM da MATRIZ (MxN): ');
Repeat
Write('Número de Linhas (M): ');
Readln(M);
Until (M >= 1) And (M <= QUANT);
Repeat
Write('Número de Colunas (N): ');
Readln(N);
Until (N >= 1) And (N <= QUANT);
For Lin := 1 To M Do
For Col := 1 To N Do
Begin
Write('A[',Lin,',',Col,'] = ');
Readln(a[Lin,Col]);
Write('B[',Lin,',',Col,'] = ');
Readln(b[Lin,Col]);
End;
For Lin := 1 To M Do
For Col := 1 To N Do
Begin
C[Lin,Col] := A[Lin,Col]+B[Lin,Col];
Write('C[',Lin,',',Col,'] = ',C[Lin,Col]);
Ch := ReadKey;
35
End;
End.
Program Sort;
Uses Crt;
Const QUANT = 255;
Type TIPO = String[40];
Var Nome: Array[0..QUANT] of TIPO;
Temp: TIPO;
I,J,N: Byte;
Ch: Char;
Begin
ClrScr;
I := 0;
Repeat
Write('Nome: ');
Readln(Nome[i]); (* Entrada de um nome *)
Inc(I);
Write('Continua [S]im ou [N]ão ? ');
Repeat
Ch := ReadKey;
Until Ch IN ['S','s','N','n];
Until (Ch IN ['N','n']) Or (I > QUANT);
N := I - 1; (* Número de Elementos *)
For I := 1 to N do
For J := I+1 to N do
If Nome[I] > Nome[J] then
Begin
Temp := Nome[i];
Nome[i] := Nome[j];
Nome[j] := Temp;
End;
WriteLn('Nomes ORDENADOS');
For I := 0 to N do
Begin
WriteLn('Nome: ',Nome[i]);
Ch := ReadKey;
End;
End.
36
Type TIPO = String[40];
Var Nome: Array[0..QUANT] of TIPO;
Temp: TIPO;
I,N,K: Byte;
Ch: Char;
Ordenado: BOOLEAN;
Begin
ClrScr;
I := 0;
Repeat
Write('Nome: ');
Readln(Nome[i]); (* Entrada de um Nome *)
Inc(I);
Write('Continua [S]im ou [N]ão ? ');
Repeat
Ch := ReadKey;
Until Ch IN ['S','s','N','n'];
Until (Ch IN ['N','n']) Or (I > QUANT);
N := I - 1; (* Número de Elementos *)
K := N - 1;
Repeat
Ordenado := TRUE;
For I := 0 to K do
If Nome[I] > Nome[I+1] then
Begin
Temp := Nome[i];
Nome[I] := Nome[I+1];
Nome[I+1] := Temp;
Ordenado := FALSE;
End;
K := K - 1;
Until Ordenado;
WriteLn('Nomes ORDENADOS');
For I := 0 to N do
Begin
WriteLn('Nome: ',Nome[i]);
Ch := ReadKey;
End;
End.
37
Uses Crt;
Var Codigo: Byte;
Caracter: Char;
Begin
ClrScr;
Repeat
Write('Código: ');
Readln(Codigo);
Caracter := Chr(Codigo);
WriteLn('Código :',Codigo,' Caracter ASCII: ',Caracter);
Until Codigo = 0;
End.
12.2 Ord
Função que retorna o código ASCII correspondente ao caracter da tabela ASCII.
Uses Crt;
Var Codigo: Byte;
Caracter: Char;
Begin
Repeat
ClrScr;
Write('Caracter: ');
Caracter := ReadKey;
Codigo := Ord(Caracter);
WriteLn('Caracter :',Caracter,' Código ASCII: ',Codigo);
Until Caracter = #13; (* #13 é o código da tecla <ENTER> *)
End.
12.3 Concat
Função que retorna as strings s1,s2,... sn concatenadas, ou seja, unidas.
Uses Crt;
Var S1,S2,S3: String[7];
Sr: String[21];
Begin
ClrScr;
S1 := 'Turbo ';
S2 := 'Pascal ';
S3 := '5.5';
Sr := Concat(S1,S2,S3);
WriteLn(S1);
38
WriteLn(S2);
WriteLn(S3);
WriteLn(Sr); (* Sr := 'Turbo Pascal 5.5' *)
Repeat Until KeyPressed;
End.
12.4 Copy
Função que retorna uma substring a partir de outra string.
Uses Crt;
Var Velha: String[15];
Nova: String[10];
Begin
ClrScr;
Velha := 'MICROCOMPUTADOR';
Nova := Copy(velha,6,10);
WriteLn(Velha);
WriteLn(Nova); (* Nova := 'COMPUTADOR' *)
Repeat Until KeyPressed;
End.
12.5 Delete
Procedimento que remove caracteres de uma string.
Uses Crt;
Var Velha: String[15];
Begin
ClrScr;
Velha := 'MICROCOMPUTADOR';
Delete(Velha,6,10);
WriteLn(Velha); (* Velha := 'MICRO' *)
Repeat Until KeyPressed;
End.
12.6 Insert
Procedimento que insere s1 em s2 na posição desejada gerando uma nova string.
Uses Crt;
39
Var S1: String[2];
S2: String[17];
Begin
ClrScr;
S1 := 'ES';
S2 := 'MICROCOMPUTADOR';
Insert(S1,S2,16);
WriteLn(S1);
WriteLn(S2); (* S2 := 'MICROCOMPUTADORES' *)
Repeat Until KeyPressed;
End.
12.7 Length
Função que retorna o número de caracteres de uma string
Uses Crt;
Var Nome: String[40];
Begin
ClrScr;
Write('Digite seu Nome: ');
Readln(Nome);
Write(Nome,' seu Nome tem: ',Length(Nome),' caracteres');
Repeat Until KeyPressed;
End.
12.8 Pos
Função que retorna a posição de s1 em s2 (0 se não encontrar).
Uses Crt;
Var S1: String[6];
S2: String[15];
Posicao: Integer;
Begin
ClrScr;
S1 := 'COMPUT';
S2 := 'MICROCOMPUTADOR';
Posicao := Pos(S1,S2);
If Posicao<>0 then
Write('String Encontrada na Posição: ',Posicao)
Else
Write('String não encontrada');
Repeat Until KeyPresssed;
40
End.
12.9 Str
Procedimento que converte um valor númerico (Real ou qualquer tipo de inteiro) em
String. O tamanho do número é dado pelo tamanho da String, sendo que um byte é deixado para o
sinal.
Uses Crt;
Var N: Real;
S: String[7];
Begin
ClrScr;
N := 3.14151617;
Str(N,S);
WriteLn('String: ',S); (* S := '3.1415' *)
Repeat Until KeyPressed;
End.
12.10 UpCase
Função que retorna o caracter convertido em letra maiúscula.
Uses Crt;
Var Ch: Char;
Begin
ClrScr;
Repeat
Write('Digite uma Tecla: ');
Ch := ReadKey;
WriteLn(UpCase(Ch));
Until UpCase(Ch) = 'F';
End.
Uses Crt;
Var Ch: Char;
Begin
ClrScr;
Repeat
Write('Confirma [S]im ou [N]ão ?');
Ch := UpCase(ReadKey);
Until Ch In ['S','N'];
End.
41
12.11 Val
Procedimento que converte uma string em valor númerico (Real ou qualquer tipo de
inteiro), se a string possuir letras, a variável erro retorna a posição da letra (pois não é númerica),
senão retorna zero.
Uses Crt;
Var S: String[10];
Valor: Integer;
Erro: Integer;
Begin
ClrScr;
Repeat
Write('Digite alguma coisa [Fim para Finalizar]: ');
Readln(S);
Val(S,Valor,Erro);
If Erro=0 then
Begin
WriteLn('SEM ERRO');
WriteLn('Número: ',Valor);
End
Else
WriteLn('ERRO: ',Erro);
Until (S = 'FIM') or (S = 'fim');
End.
12.12 FillChar
Procedimento que inicializa uma variável string com caracteres repetitivos.
Uses Crt;
Var Linha: String[80];
Espacos: String[40];
Begin
FillChar(Linha,80,'-');
Linha[0] := #80; (* indicar o número de caracteres *)
FillChar(Espacos,40,#32);
Espacos[0] := #40;
Variável Global
Todas as variáveis definidas fora de todas as funções são chamadas globais e podem ser
referenciadas em qualquer parte do programa inclusive dentro das funções e procedimentos.
Observações:
a)Todas as variáveis usadas no programa principal são globais e devem, obrigatoiamente ser
definidas no "Var".
b)As variáveis locais tem prioridade sobre as variáveis globais.
c)Também existem constantes ("Const"), tipos ("Type"), procedimentos ("Procedure") e funções
("Function") locais.
d)Todos os parâmetros são locais, por esta razão, não necessitam ter o mesmo nome das variáveis
de chamada.
Program Exemplo;
Uses Crt;
Var Base,Expoente,Resultado: Real;
Tecla: Char;
Procedure TROCA(Var x,y:Real); (* Var passagem por referência *)
Var temp: Real;
Begin
temp := x;
x := y;
y := temp;
End;
Function ELEVA (b,e: Real): Real;
Var pot: Real;
Begin
pot := exp(log(b)*e);
ELEVA := pot; (* Saída da Função *)
End;
Begin
Repeat
ClrScr;
WriteLn('Base: ');
Readln(Base);
WriteLn('Expoente: ');
Readln(Expoente);
Resultado := ELEVA(Base,Expoente);
WriteLn('Resultado: ',Resultado:7:2);
TROCA(Base,Expoente); (* Chamada do Procedimento *)
43
Resultado := ELEVA(Base,Expoente); (* Chamada da Função *)
WriteLn('Resultado: ',Resultado:7:2);
WriteLn('Continua [S]im [N]ão ? ';
Repeat
Tecla := ReadKey;
Until Tecla IN ['S','s','N','n'];
Until Tecla IN ['N','n'];
End.
13.2 Parâmetros
São todas as variáveis que num procedimento ("Procedure") ou Função ("Function") estão
entre parênteses. Existem parâmetros de entrada e saída (são os mesmos, a diferença é se são
alterados ou não).
Entrada x
e TROCA
Saída y
44
parâmetro por Referência. No exemplo abaixo, "x" e "y" são passados por referência, logo alteram
as variáveis do programa principal.
Enx trad
eyFuResltadorn nção
Sa ída
45
Entrada x
y
e Procedimento
z
Saída
x
y
Entrada Procedimento
z
a
Saída Procedimento
b
Procedimento
Exemplos:
46
Program Comandos; (* Procedimento Tipo B *)
Uses Crt;
Var A,B,C: Real;
Tecla: Char;
Procedure BASCARA (a,b,c: Real);
Var delta,x1,x2,r,i: Real;
Begin
delta := sqr(b)-4*a*c; (* Cálculo do Determinante *)
If delta >= 0 then (* Raízes REAIS *)
Begin
x1 := (-b+sqrt(delta))/(2*a);
x2 := (-b-sqrt(delta))/(2*a);
WriteLn('x1 = ',x1:7:2);
WriteLn('x2 = ',x2:7:2);
Repeat Until KeyPressed;
End
Else (* Raízes COMPLEXAS *)
Begin
r := -b/(2*a);
i := sqrt(abs(delta))/(2*a);
WriteLn('x1 = ',r:7:2,' + ',i:7:2,' j');
WriteLn('x2 = ',r:7:2,' - ',i:7:2,' j');
Repeat Until KeyPressed;
End;
End;
Begin
Repeat
ClrScr;
WriteLn('Calcula Raízes');
WriteLn;
WriteLn('Qual o valor de A: ');
Readln(A);
WriteLn('Qual o valor de B: ');
Readln(B);
WriteLn('Qual o valor de C: ');
Readln(C);
BASCARA(A,B,C);
Write('Continua [S]im ou [N]ão ? ');
Repeat
Tecla := UpCase(ReadKey);
Until Tecla IN ['S','N'];
Until Tecla = 'N';
End.
47
Tecla: Char;
Procedure BASCARA (a,b,c: Real;VAR delta,r,i: Real);
Var delta,x1,x2,r,i: Real;
Begin
delta := sqr(b)-4*a*c; (* Determinante *)
r := -b/(2*a); (* Parte Real *)
i := sqrt(abs(delta))/(2*a); (* Parte imaginaria *)
End;
Begin
Repeat
ClrScr;
WriteLn('Calcula Raizes');
WriteLn;
WriteLn('Qual o valor de A: ');
Readln(A);
WriteLn('Qual o valor de B: ');
Readln(B);
WriteLn('Qual o valor de C: ');
Readln(C);
BASCARA(A,B,C,Delta,R,I);
If Delta >= 0 then (* Raizes REAIS *)
Begin
X1 := r+i;
X2 := r-i;
WriteLn('x1 = ',X1:7:2);
WriteLn('x2 = ',X2:7:2);
Repeat Until KeyPressed;
End
Else (* Raizes COMPLEXAS *)
Begin
WriteLn('x1 = ',R:7:2,' + ',I:7:2,' j');
WriteLn('x2 = ',R:7:2,' - ',I:7:2,' j');
Repeat Until KeyPressed;
End;
Write('Continua [S]im ou [N]ão ? ');
Repeat
Tecla := UpCase(ReadKey);
Until Tecla IN ['S','N'];
Until Tecla = 'N';
End.
14. Arquivos
48
a b c d
Ponteiro 0 e
1 f
2 g
3 h
:
a Identificação do Registro
b,c,d Campos
e,f,g,h Registros
Tipos de Arquivos:
Texto
Tipo de Arquivo formado de caracteres organizados em linhas. No final de cada linha
existem dois caracteres de controle LF (#10) + CR (#13).
Como Definir:
Binário
Tipo de Arquivo usado para armazenar tipos de dados diferentes.
14.1 Procedimentos
14.1.1 Assign
Procedimento que associa o nome externo do arquivo (DISCO) ao nome interno do
arquivo dentro do programa (File Of).
ou
14.1.2 Close
Procedimento que permite fechar um arquivo.
14.1.3 Erase
Procedimento que permite deletar um arquivo no disco.
50
14.1.4 Read
Procedimento que permite ler campos ou registros do arquivo contido no disco.
14.1.5 Write
Procedimento que permite gravar campos ou registros no arquivo contido no disco.
14.1.6 ReName
Procedimento que permite renomear o arquivo no disco.
51
14.1.7 Reset
Procedimento que permite abrir de um arquivo.
Na abertura de um arquivo, deve ser verificado sua existência, pois se o arquivo não existir
haverá um erro em tempo de execução (Run Time Error), e o programa será abortado, para que
isto não aconteça é feito o seguinte:
Program Exemplo;
Uses Crt;
Var Arq: File Of Integer;
Reg; Integer;
Nome_arquivo: String[14];
Begin
ClrScr;
Write('Nome do Arquivo: ');
ReadLn(Nome_arquivo);
Assign(Arq,Nome_arquivo);
{$I-} Reset(Arq) {$I+};
Observação: {$I-} e {$I+} são diretivas de compilação que forçam o compilador a não abortar se
houver um erro em tempo de execução (RunTime Error), fazendo ainda com que a variável pré-
definida "IoResult" retorne com a informação se houve erro ou não da seguinte maneira:
If IoResult = 0 Then
WriteLn('Arquivo EXISTE')
Else
WriteLn('ERRO: Arquivo NÃO EXISTE')
14.1.8 ReWrite
Procedimento que permite criar um arquivo em disco, se o arquivo não existe, é criado, se
existe é apagado, e o ponteiro do arquivo é posicionado no registro zero.
14.1.9 Seek
Procedimento que permite posicionar o ponteiro do arquivo no registro especificado
(Acesso Randômico).
52
14.2 Funções
14.2.1 EOF (End Of File)
Função que retorna TRUE se o ponteiro do arquivo chegou ao fim do arquivo, FALSE
enquanto não for fim de arquivo.
14.2.2 FilePos
Função que retorna a posição do registro corrente, ou seja, a posição do ponteiro no arquivo
(o primeiro registro é Zero).
14.2.3 FileSize
Função que retorna o número de registros do arquivo, "zero" se não existir nenhum
registro.
14.2.4 SizeOf
Função que retorna o número de bytes ocupado por uma variável.
53
ReadLn(Nome_do_arquivo);
Assign(Arq,Nome_do_arquivo);
{$I-} Reset(Arq) {$I+};
If IoResult <> 0 Then
Begin
ReWrite(Arq);
Repeat
Write('Nome: ');
ReadLn(Reg.nome);
Write('Idade: ');
ReadLn(Reg.idade);
Write('Fone: ');
ReadLn(Reg.idade);
Write(Arq,Reg); (* Grava um Registro no Disco *)
Write('Continua [S]im ou [N]ão ? ');
Repeat
Ch := UpCase(ReadKey);
Until Ch IN ['S','N'];
Until Ch ='N';
End
Else
WriteLn('ERRO: Arquivo EXISTE')
Close(Arq);
End.
15. Gráficos
15.1 Placas Gráficas
15.1.1 CGA
Resolução: 640x200 alta resolução (2 cores)
320x200 baixa resolução (4 cores)
Observação: Palette é um conjunto de cores disponíveis, sendo que na placa CGA possui 16 cores.
15.1.2 EGA
Resolução: 640x350 alta resolução (16cores, 2 págs. gráficas)
640x200 baixa resolução (16 cores, 4 págs. gráficas)
15.1.3 VGA
Resolução: 640x480 alta resolução (16 cores, 1 página)
640x350 média resolução (16 cores, 2 páginas. gráficas)
640x200 baixa resolução (16 cores, 4 páginas. gráficas)
54
15.2 Coordenadas de Tela
15.2.1 CGA
x 0 à 639 ou 319
y 0 à 199
15.2.2 EGA
x 0 à 639 ou 319
y 0 à 199 ou 349
15.2.3 VGA
x 0 à 639 ou 319
y 0 à 199, 349 ou 479
Placa: É a variável responsável pelo tipo de placa a ser usada. Pode assumir os seguintes tipos:
Número Nome
0 DETECT
1 CGA
2 MCGA
3 EGA
4 EGA64
5 EGAMONO
6 IBM8514
7 HERCMONO
8 ATT400
9 VGA
10 PC3270
Program Detecta_Placa;
Uses Crt,Graph;
Var Placa,Modo: Integer;
Begin
Placa := DETECT;
InitGraph(Placa,Modo,''); (* Procura Arquivos BGI no Diretório Corrente *)
If GraphResult <> GrOk then
WriteLn('ERRO: Inicialização Gráfica');
ou
Program Seta_Placa_VGA;
Uses Crt,Graph;
Var Placa,Modo: Integer;
Begin
Placa := VGA; (* Placa VGA *)
Modo := VGAHI; (* Modo 640 x 480, 16 cores *)
InitGraph(Placa,Modo,'D:\\TP\\BGI'); (* Path dos Arquivos *.BGI *)
If GraphResult <> GrOk then
WriteLn('ERRO FATAL: Inicialização Gráfica');
Program Pontos;
Uses Crt,Graph;
Var Placa,Modo: Integer;
X,Y: Integer;
Cor: Byte;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,''); (* Procura arquivos *.BGI no diretório corente *)
Randomize;
Repeat
X := Random(640);
Y := Random(480);
Cor := Random(16);
PutPixel(X,Y,Cor);
56
Until KeyPressed;
CloseGraph;
End.
Program Retas;
Uses Crt,Graph;
Var Placa,Modo: Integer;
Xi,Yi,Xf,Yf: Integer;
Cor: Byte;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
Randomize;
Repeat
Xi := Random(640);
Yi := Random(480);
Xf := Random(640);
Yf := Random(480);
Cor := Random(16);
SetColor(Cor);
Line(Xi,Yi,Xf,Yf);
Until KeyPressed;
CloseGraph;
End.
Program Retangulos;
Uses Crt,Graph;
Var Placa,Modo: Integer;
Xi,Yi,Xf,Yf: Integer;
Cor: Byte;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
57
Repeat
Xi := Random(640);
Yi := Random(480);
Xf := Random(640);
Yf := Random(480);
Cor := Random(16);
SetColor(Cor);
Rectangle(Xi,Yi,Xf,Yf);
Until KeyPressed;
CloseGraph;
End.
Program Circulos;
Uses Crt,Graph;
Var Placa,Modo: Integer;
Xc,Yc: Integer;
Cor,Raio: Word;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
Repeat
Xc := Random(640);
Yc := Random(480);
Cor := Random(16);
Raio := Random(100);
SetColor(Cor);
Circle(Xc,Yc,Raio);
Until KeyPressed;
CloseGraph;
End.
58
15.8 Arc (Arcos)
Arc: Procedimento que permite plotar um arco na tela gráfica, através de um ponto central
(Xc,Yc), um Raio e dois ângulos (Inicial e Final).
Program Arcos;
Uses Crt,Graph;
Var Placa,Modo: Integer;
Xc,Yc: Integer;
Ang_Inic,Ang_Fim: Word;
Raio,Cor: Word;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
Repeat
Xc := Random(640);
Yc := Random(480);
Ang_Inic := Random(360);
Ang_Fim := Random(360);
Cor := Random(16);
Raio := Random(100);
SetColor(Cor);
Arc(Xc,Yc,Ang_Inic,Ang_Fim,Raio);
Until KeyPressed;
CloseGraph;
End.
Program Boneco;
Uses Crt, Graph;
Const Rosto: Array[1..9,1..2] of Integer = ((109,149),(209,149),(259,124),(259, 74),
(209, 39),(109, 39),( 59, 74),( 59,124),(109,149));
Var Placa,Modo: Integer;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
(* ------------------------------------ rosto *)
DrawPoly(9,Rosto);
59
(* ------------------------------------ olho esquerdo *)
Circle(109,74,7);
(* ------------------------------------ olho direito *)
Circle(209,74,7);
(* ------------------------------------ nariz *)
Circle(159,99,15);
(* ------------------------------------ boca *)
Rectangle(109,120,209,128);
(* ------------------------------------ orelha esquerda *)
Arc(59,99,90,270,20);
(* ------------------------------------ orelha direita *)
Arc(259,99,270,90,20);
(* ------------------------------------ cabelos *)
Arc(139,39,0,105,20);
Arc(179,39,75,180,20);
Repeat Until KeyPressed;
CloseGraph;
End.
0 DefaultFont HorizDir 0
1 TriplexFont VertDir 1
2 SmallFont 2
60
3 SansSerifFont :
4 GothicFont 10
OutTextXY: Permite que um texto seja escrito na tela gráfica na posição P (x,y).
Program Texto;
Uses Crt; Graph;
Var Placa,Modo: Integer;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
SetBkColor(Cyan);
Bar(0,0,639,479);
SetColor(Blue);
SetTextStyle(GothicFont,HorizDir,5);
OutTextXY(100,100,'Turbo Pascal V5.5');
Repeat Until KeyPressed;
End.
Número Estilos
Program ESTILOS;
Uses Crt, Graph;
Var Placa,Modo: Integer;
Estilo: Byte;
Cor: Byte;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
For Estilo := 1 to 12 do
Begin
Cor := 1 + Random(15);
SetFillStyle(Estilo,a);
Bar(0,0,100,100);
ReadLn;
End;
CloseGraph;
End.
15.12.2 Polígonos
a) FillPoly: É usado para pintar um polígono, usando o estilo definido pelo procedimento
SetFillStyle. Este procedimento preenche qualquer polígono fechado, se o polígono estiver aberto
este procedimento preenche até encontrar um objeto fechado.
Program Preenche_Polígono;
Uses Crt, Graph;
Const Objeto: Array[1..5,1..2] of Integer = ((159,0),(0,50),(159,199),(319,50),(159,0));
Var Placa,Modo: Integer;
Estilo: Byte;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
DrawPoly(5,objeto); (* Plota Polígono Vazado*)
Repeat Until KeyPressed;
For Estilo := 0 to 12 do
Begin
SetFillStyle(Estilo,YELLOW); (* Define Estilo e Cor *)
FillPoly(5,Objeto); (* Pinta Polígono *)
ReadLn;
End;
CloseGraph;
62
End.
b) FloodFill: É usado para preencher um polígono, usando o estilo definido pelo procedimento
SetFillStyle. O preenchimento parte de um ponto central Pc (Xc,Yc) do objeto e preenche ao redor
deste ponto até encontrar uma borda com a cor especificada (função recursiva).
Program Rosa_dos_Ventos;
Uses Crt, Graph;
Const Pontos = 17;
Rosa: Array[1..pontos,1..2] of Integer = ((159,0),(189,49),(279,24),(239,72),(319,99),
(239,123),(279,173),(189,149),(159,199),(109,149), (39,173),
(79,123),
(0,99),(79,72),(39,24),(109,49),(159,0));
63
(0,0)
(xi,yi)
(xf,yf)
(Xmax,Ymax)
Program Janela_Ativa_com_Recorte;
Uses Crt,Graph;
Const ENTER = #13;
ESC = #27;
UP = #72;
DOWN = #80;
LEFT = #75;
RIGHT = #77;
Var Placa,Modo: Integer;
X,Y: Integer;
Tecla: Char;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
SetFillStyle(SOLID_FILL,GREEN);
Bar(0,0,639,479);
SetViewPort(19,19,300,180,TRUE); (* Teste o programa usando FALSE *)
SetColor(RED);
ClearViewPort; (* Limpa Janela Ativa *)
X := 319;
Y := 239;
Repeat
SetColor(RED);
Rectangle(X,Y,X+10,Y+10);
Tecla := ReadKey;
SetColor(BLACK);
Rectangle(X,Y,X+10,Y+10);
Case Tecla
Of
UP: Dec(Y,5);
64
DOWN: Inc(Y,5);
LEFT: Dec(X,5);
RIGHT: Inc(X,5);
End;
Until Tecla IN [ENTER,ESC];
End.
0 CopyPut { Mov }
1 XorPut { XOr }
2 OrPut { Or } ou NormalPut
3 AndPut { And }
4 NotPut { Not }
Para definir o ponteiro, que irá conter os pixels da tela, é necessário saber a quantidade de
bytes (porção de memória) para salvar a janela gráfica, isto é feito da seguinte maneira:
ImageSize: Retorna o número de bytes necessários para conter a janela definida pelos pontos Pi
(Xi,Yi) e Pf (Xf,Yf).
GetMem: Procedimento que faz alocação dinânica de memória para o ponteiro p, o qual ocupará
n bytes na memória.
65
Program Janelas;
Uses Crt,Graph;
Type TIPO = String[20];
Var Placa,Modo: Integer;
P: Array[1..5] of Pointer;
Cor: Byte;
Num_Bytes: Array[1..5] of Word;
Begin
Placa := VGA;
Modo := VGAHI;
InitGraph(Placa,Modo,'');
SetFillStyle(SOLID_FILL,BLACK);
Bar(0,0,639,479);
Salva_Janela(1,10,10,100,50);
Moldura(10,10,100,50,0,1);
ReadLn;
Salva_Janela(2,30,30,130,80);
Moldura(30,30,130,80,1,2);
ReadLn
Salva_Janela(3,50,50,150,100);
Moldura(50,50,150,100,2,3);
ReadLn;;
Restaura_Janela(3,50,50,150,100);
66
ReadLn;
Restaura_Janela(2,30,30,130,80);
ReadLn;
Restaura_Janela(1,10,10,100,50);
ReadLn;
CloseGraph;
End.
Unit nome_da_unidade;
Interface
Uses
Const
Type
Var
Procedure
Procedure ... (* Cabeçalho de todos os Módulos *)
Function
Function
Implementation
Procedure
Const
Type
Var
Begin
comandos;
End;
Function
Const
Type
Var
Begin
comandos;
67
End;
End.
Observação: Uma unidade é um programa Fonte Pascal sem programa principal. Possui extensão
"nome.PAS" e após compilada, "nome.TPU". A vantagem de uma unidade definida pelo
programador é que permite que as "procedure" e "function" sejam usadas em qualquer programa.
Interface
Uses Crt;
Implementation
(* ----------------------------------- Pot *)
(* ---------------------------------- Troca *)
(* ---------------------------------- Imprime_String *)
68
Begin
GotoXY(c,l);
Write(s);
End;
(* ---------------------------------- Imprime_Char *)
(* ---------------------------------- Moldura_Dupla *)
(* ------------------------------------ Moldura_Simples *)
69
Imprime_Char(xi,yi,#218);
Imprime_Char(xf,yi,#191);
Imprime_Char(xf,yf,#217);
Imprime_Char(xi,yf,#192);
End;
(* -------------------------------- Limpa_Area *)
(* --------------------------- Entrada *)
70
nome := nome+ch;
i := i+1;
End;
Until (ch In [#13, #27,]) Or (i >= t);
End;
End.
Observação: Para executar o programa e, obrigar que a unidade seja compilada novamente, deve-
se compilar com a opção Build do menu Compile.
71
80colunas
12 80
1024
2
25 linhas
25
Fundo Frente
P I
Program Memoria_Video;
Uses Crt;
(* ------------------------ Imprime *)
72
Video[posicao] := caracter;
End;
Begin
Repeat
For L := 1 To 24 Do
For C := 1 To 80 Do
Begin
GotoXY(C,L);
Write('A');
End;
Ch := ReadKey;
For L := 1 To 24 Do
For C := 1 To 80 Do
Imprime_Caracter(C,L,'B'); (* Imprime na Memória *)
Until KeyPressed;
End.
Variáveis Pré-Definidas
ParamCount: Armazena o número de parâmetros da linha de comandos
C:\>Inverte PELOTAS
SATOLEP
C:\_
Onde: ParamCount = 1
ParamStr(0) = 'A:\INVERTE.EXE'
ParamStr(1) = 'PELOTAS'
Objetivo do Programa: Recebe uma string qualquer pela linha de comandos do Sistema
Operacional e a inverte.
Uses Crt;
Var I,N: Byte;
S: String;
Begin
73
ClrScr;
If ParamCount <> 1 Then
WriteLn('Sintaxe: INVERTE <palavra>')
Else
Begin
S := ParamStr(1);
N := Length(S);
For I := N DownTo 1 Do
Write(S[I]);
End;
End.
A:\>lista LISTA.PAS
Onde: ParamCount = 1
ParamStr(0) = 'A:\LISTA.EXE'
ParamStr(1) = 'LISTA.PAS'
Objetivo do Programa: Recebe o nome de um arquivo texto, abre o arquivo e lista o conteúdo na
tela, numerando as linhas e parando quando a tela está cheia.
Uses Crt;
74
Inc(N);
Write(Linha:3,': ');
Inc(Linha);
If N = 23 Then
Begin
WriteLn;
WriteLn;
Write('Arquivo: ',ParamStr(1));
Write(' - Tecle <ENTER>');
ReadLn;
ClrScr;
End;
End;
Read(Arq,Reg);
End;
Close(Arq);
End;
End;
End;
End.
C:\>procura UNIVERSIDADE E
UNIVERSIDADE possui 2 letras E
C:\>_
Onde: ParamCount = 2
ParamStr(0) = 'A:\PROCURA.EXE'
ParamStr(1) = 'UNIVERSIDADE'
ParamStr(2) = 'E'
Objetivo do Programa: Recebe uma palavra e uma letra e verifica quantas vezes a letra está
presente dentro da palavra
Uses Crt;
Var S,Saux: String;
Letra: Char;
I,N,T: Byte;
Begin
ClrScr;
If ParamCount <> 2 Then
WriteLn('Sintaxe: PROCURA <Palavra> <Letra>')
Else
Begin
S := ParamStr(1);
Saux := ParamStr(2);
Letra := Saux[1];
N := Length(S);
T := 0;
For I := 1 To N Do
75
If S[i] = Letra Then
Inc(T);
WriteLn(S,' possui ',T,' letras ',Letra);
End;
End.
Exemplo:
Alocar um Ponteiro
New(p);
Exemplo: New(p);
If p = Nil Then
WriteLn('ERRO: Falta de Memória')
Else
76
WriteLn('Ok, Ponteiro Alocado');
Nil: Palavra reservada que representa ponteiro nulo, ou seja, ponteiro não aponta para nada.
Desalocar o Ponteiro
Dispose(p);
Exemplo:
Uses Crt;
Var P: ^Integer;
N: Byte;
Num_Bytes: Word;
Begin
ClrScr;
Write("Número de Elementos: ');
ReadLn(N);
Num_Bytes := N * SizeOf(Integer); (* Calcula o Número de Bytes *)
GetMem(P,Num_Bytes);
If P = Nil Then
WriteLn('ERRO: Falta de Memória')
Else
WriteLn('Ok, Ponteiro Alocado');
Definições
p Contém o endereço de memória apontada pelo ponteiro
p^ Contém o conteúdo do ponteiro
@n Contém o endereço da variável n
77
Uses Crt;
Var N: Integer;
P: ^Integer;
Begin
ClrScr;
N := 65;
P := @N; (* Ponteiro aponta para a variável n *)
WriteLn('Conteúdo: ',P^);
End.
Mem óri aRA M
1 By te
@10 n0
65(n 2by tes)
10 1
@10 p2
10 3
10p(4b 0 ytes )
10 4
10 5
ec nderot eçoúd
Endereço: [Segmento:OffSet]
Funções
a) MemAvail: Retorna o número de bytes disponível na memória
b) MaxAvail: Retorna o número de bytes do maior bloco disponível na memória
Exemplo:
Uses Crt;
Var Livre: LongInt;
Bloco: LongInt;
Begin
ClrScr;
Livre := MemAvail Div 1024;
WriteLn(Livre,' K Bytes Livres na Memoria');
Bloco := MaxAvail Div 1024;
WriteLn(Bloco,' K Bytes do Maior Bloco Livre');
78
ReadLn;
End.
Mem[Segmento:OffSet]
Para acessar diretamente a memória usa-se a variável pré-definida Mem. Com esta variável,
pode-se listar ou modificar uma posição de memória.
Objetivo do Programa: Possui dois procedimentos, um para preencher a tela com caracteres
aleatórios e outro para limpar a tela (preencher com espaços) sem Write.
Uses Crt;
Procedure Limpa_Tela;
Var Segmento,OffSet: LongInt;
Begin
Segmento := $B800;
OffSet := $0000;
Repeat
Mem[Segmento:OffSet] := 32; (* 32 - Espaço *)
Inc(OffSet,2);
Until OffSet = 4000;
End;
Procedure Suja_Tela;
Var Segmento,OffSet: LongInt;
Letra: Byte;
Begin
Segmento := $B800;
OffSet := $0000;
Repeat
Letra := Random(256);
Mem[Segmento:OffSet] := Letra;
Inc(OffSet,2);
Until OffSet = 4000;
End;
Begin
Repeat
Limpa_Tela;
Suja_Tela;
79
Until KeyPressed;
End.
Begin
Repeat
ClrScr;
For L := 1 To 24 Do
For C := 1 To 80 Do
Begin
Letra := Random(256);
Imprime(C,L,Letra);
End;
Until KeyPressed;
End.
Header
c b a
3 b 2 a 1 NIL
80
As listas são percorridas seqüencialmente, apenas numa direção, ou seja, do primeiro ao
último elemento. A informação do número de elementos da lista é obtida somente com a varredura
de toda a lista. Para resolver estes dois problemas pode-se usar um descritor da seguinte maneira:
DESCRITOR
Primeiro n Último
Fila: FIfO (First Input First Output), ou seja, o primeiro elemento a entrar na fila é o primeiro
elemento a sair da fila.
Pilha: LIfO (Last Input First Output), ou seja, o último elemento a entrar na pilha é o primeiro a
sair.
E - Entrada de Dados
S - Saída de Dados
E
E/S
3
3
Pilha 2 2 Fila
1 1
S
Pilha: Fila:
Program Pilha;
Uses Crt;
81
Type PONTEIRO = ^ELEMENTO;
ELEMENTO = Record
dado: Integer;
elo: PONTEIRO;
End;
Var P,Header: PONTEIRO;
N: Integer;
Begin
Header := Nil;
Repeat
ClrScr;
Write('Número: ');
ReadLn(N);
If N <> 0 Then
Begin
New(P);
If P = Nil Then
WriteLn('ERRO: Falta de Memória')
Else
Begin
P^.elo := Header;
P^.dado := N;
Header := P;
End;
End;
Until (N = 0) or (P = Nil);
P := Header;
While P^.elo <> Nil Do
Begin
WriteLn('Valor: ',P^.dado);
P := P^.elo;
End;
WriteLn('Valor: ',P^.dado);
ReadLn;
End.
Program Fila;
Uses Crt;
Type PONTEIRO = ^ELEMENTO;
ELEMENTO = Record
dado: Integer;
elo: PONTEIRO;
End;
82
Var P,Q,Header: PONTEIRO;
N: Integer;
Begin
ClrScr;
Write('Número: ');
ReadLn(N);
New(P);
Header := P;
P^.elo := Nil;
P^.dado := N;
Repeat
ClrScr;
Write('Número: ');
ReadLn(N);
If N <> 0 Then
Begin
Q := P;
New(P);
If P = Nil Then
WriteLn('ERRO: Falta de Memória')
Else
Begin
Q^.elo := P;
P^.dado := N;
P^.elo := Nil;
End;
End;
Until N = 0;
P := Header;
While P^.elo <> Nil Do
Begin
WriteLn('Valor: ',P^.dado);
P := P^.elo;
End;
WriteLn('Valor: ',P^.dado);
ReadLn;
End.
Objetivo do Programa: Inserir números inteiros em uma lista duplamente encadeada. A inserção
pode ser pela esquerda ou a direita. A exibição dos elementos da lista pode ser feita pela esquerda
ou direita.
Program Lista_Duplamente_Encadeada;
83
Uses Crt;
Var P: PONTEIRO;
D: DESCRITOR;
N: Integer;
Op: Char;
Procedure Inicializa_Descritor;
Begin
D.primeiro := Nil;
D.n := 0;
D.ultimo := Nil;
End;
84
P^.posterior := q;
q^.anterior := P;
D.primeiro := P;
D.n := D.n + 1;
End;
End;
End;
Procedure Exibir_Lista_Direita;
Begin
P := D.ultimo;
While P^.anterior <> Nil Do
Begin
WriteLn('Valor: ',P^.dado);
P := P^.anterior;
End;
WriteLn('Valor: ',P^.dado);
End;
85
Procedure Exibir_Lista_Esquerda;
Begin
P := D.primeiro;
While P^.posterior <> Nil Do
Begin
WriteLn('Valor: ',P^.dado);
P := P^.posterior;
End;
WriteLn('Valor: ',P^.dado);
End;
Begin
Inicializa_Descritor;
Repeat
ClrScr;
Write('Número: ');
ReadLn(N);
If N <> 0 Then
Begin
Write('[E]squerda ou [D]ireita ?');
Repeat
Op := UpCase(ReadKey);
Until Op IN ['E','D'];
Case op
Of
'E': Insere_Esquerda(N);
'D': Insere_Direita(N);
End;
End;
Until N = 0;
ClrScr;
Repeat
Write('Listar: [E]squerda, [D]ireita ou [F]im?');
Repeat
Op := UpCase(ReadKey);
Until Op IN ['E','D','F'];
WriteLn(Op);
Case Op
Of
'E': Exibir_Lista_Esquerda;
'D': Exibir_Lista_Direita;
End;
Until Op = 'F';
End.
20. Interrupções
86
O Microcomputador PC (Personal Computer) possui um circuito integrado responsável por
interromper o processamento do Microprocessador (8086) chamado PIC 8259 (Programmable
Interrupt Controller), possuindo 256 tipos de interrupções diferentes.
As interrupções podem ser de hardware ou software. Por exemplo Ctrl+Break é uma
interrupção de hardware (teclado).
Procedimento de Interrupção
Intr(número_da_interrupção: Byte; Var regs: Registers);
Registers
Tipo de dado pré-definido do Pascal que permite manipular diretamente os registradores do
8086.
Objetivo do Programa: Testar se a impressora (IBM 2390) está On-Line (Ligada) ou Off-Line
(Desligada)
Begin
ClrScr;
Repeat
If Testa_Impressora Then
WriteLn('Impressora On-Line')
Else
WriteLn('Impressora Off-Line');
Until KeyPressed;
End.
87
Uses Crt, Dos;
Begin
ClrScr;
For L := 1 To 24 Do
For C := 1 To 80 Do
Begin
Cursor(C,L);
Write(' =O-');
Delay(TEMPO); (* Controla a Velocidade *)
End;
End.
88