Apostila da Linguagem PASCAL



Universidade Católica de Pelotas

Escola de Informática

L i n g u a g e m P a s c a l

por

Paulo Roberto Gomes Luzzardi

Revisão: Junho, 1996

Bibliografia

CARROLL, David W. - Programação em TURBO PASCAL McGraw-Hill

RAMALHO, Luciano & PRATES, Rubens - Turbo Pascal, Cartão de Referência, Livros Técnicos e Científicos Editora S.A.

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. Ambiente Turbo Pascal

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. Estrutura de um Programa Pascal

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

5.1 Operadores Aritméticos

5.1.1 Com Reais

5.1.2 Com Inteiros

5.1.3 Hierarquia dos Operadores

5.2 Operadores Relacionais

5.3 Operadores Lógicos

5.3.1 Not

5.3.2 And

5.3.3 Or

5.4 Operador de Inclusão (In)

5.5 Procedimentos Especiais

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 Tipos de Comandos

7.1.1 Seqüência

7.1.2 Seleção

7.1.3 Repetição

7.1.4 Atribuição

7.2 Comando SIMPLES e COMPOSTO

7.3 Comando If ... Then ... Else

7.4 Comando Case ... Of ... Else ... End

7.5 Comando For ... Do

7.6 Comando While ... Do

7.7 Comando Repeat ... Until

7.8 Comando Halt

7.9 Comando Exit

8. Entrada e Saída

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. Comandos Especiais

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. Vetores e Matrizes

11.1 Vetores

11.2 Matrizes

11.3 Sort (Ordenação)

12. Manipulação de "Strings"

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

13. Procedures e Functions

13.1 Variáveis Locais e Globais

13.2 Parâmetros

13.3 Passagem de Parâmetro por Valor

13.4 Passagem de Parâmetro por Referência

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

14.3 Como Definir um Registro (Record)

15. Gráficos

15.1 Placas Gráficas

15.1.1 CGA

15.1.2 EGA

15.1.3 VGA

15.2 Coordenadas de Tela

15.2.1 CGA

15.2.2 EGA

15.2.3 VGA

15.3 Detecção e Inicialização da Tela Gráfica

15.4 PutPixel (Pontos)

15.5 Line (Linhas)

15.6 Rectangle (Retângulos)

15.7 Circle (Círculos)

15.8 Arc (Arcos)

15.9 DrawPoly (Polígonos)

15.10 SetColor e SetBkColor (Cor de Frente e Cor de Fundo)

15.11 OutTextXY e SetTextStyle (Textos)

15.12 Preenchimento (Pintura)

15.12.1 Retângulos (Bar)

15.12.2 Polígonos (FillPoly e FloodFill)

15.13 Ativação de Janelas

15.13.1 Janela Ativa

15.13.2 Limpar Janela Ativa

15.13.3 Salvar e Recuperar Janelas Gráficas

16. Criação de Unidades ("Units")

16.1 Como Criar um Unidade

16.2 Exemplo de Criação de uma Unidade

16.3 Exemplo de Programa que usa uma Unidade

17. Memória de Vídeo

18. Passagem de Parâmetros pela Linha de Comandos do Sistema Operacional

19. Ponteiros

19.1 Tipos de Alocação de Memória

19.1.1 Alocação Estática

19.1.2 Alocação Dinâmica

19.2 Acesso Direto a Memória

19.3 Acesso Direto a Memória de Vídeo

19.4 Listas Encadeadas

19.5 Filas e Pilhas

19.6 Listas Duplamente Encadeadas

20. Interrupções

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.

1.3 Características do Sistema em uma Linguagem Ideal

a) Produzir programas-objeto compactos e eficientes;

b) Usar uma linguagem de alto nível, de fácil entendimento;

c) Permitir ao programador fazer alterações e visualizar os resultados rapidamente

d) Produzir programas portáteis para serem rodados em qualquer outro computador.

2. Ambiente Turbo Pascal 5.5

[pic]

Alt: F1-Last help F3-Pick F6-Swap F7/F8-Prev/next error

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.

Load (Carregar) [F3]

É exibida uma caixa de diálogo solicitando o nome do arquivo a ser carregado, se for pressionado a tecla é exibida outra caixa de dialógo contendo os nomes de todos os arquivos "*.pas" contidos no disco. O programador seleciona um arquivo (seta direita, esquerda, acima ou abaixo) e pressiona logo após, o arquivo é carregado do Disco para o Editor.

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

Save (Salvar) [F2]

Salva o conteúdo do Editor no Disco. Se o arquivo não tiver nome ("NONAME.PAS"), pode então, ser renomeado. Todo arquivo deve ter um nome que não seja "NONAME.PAS".

Write to (Escrever Como)

Escreve (grava) o conteúdo do editor num outro arquivo indicado pelo usuário (conserva o antigo no disco e o novo no editor).

Directory (Diretório)

Exibe o diretório do disco corrente, de acordo com uma máscara especificada, permite ainda, que um arquivo seja carregado.

Change dir (Mudar Diretório)

Permite mudar o subdiretório (drive:\path) corrente.

Os Shell (Saída Temporária ao Sistema Operacional)

Saída temporária do Turbo Pascal para o Sistema Operacional. Para retornar ao Ambiente digita-se Exit.

Quit (Sair) [ALT][X]

Saída definitiva do Ambiente Turbo Pascal. Volta o controle ao Sistema Operacional.

2.2 Edit (Editar) [ALT][E]

Permite a criação ou edição de programas. Para sair do editor pressiona-se a tecla F10 ou ALT mais a letra maiúscula da opção do menu principal.

2.3 Run (Correr, Executar) [ALT][R]

Run (Executa) [CTRL][F9]

Compila o programa, linka as unidades e executa o programa.

Program reset (Reseta Programa) [CTRL][F2]

Termina a execução de um programa que foi executado com o "Debug". Desmarca a linha atual do "Debug".

Go to cursor (Vá para Cursor) [F4]

Força o "Debug" executar todas as linhas até a posição do cursor, ou seja, pula as instruções intermediárias.

Trace into (Traça Dentro) [F7]

Força o "Debug" a executar linha a linha entrando obrigatoriamente dentro das "procedure" e "function".

Step over (Passa Ssobre) [F8]

Força o "Debug" a executar linha a linha sem entrar nas "procedure" e "function".

User screen (Tela do Usuário) [ALT][F5]

Exibe a tela de execução do programa.

2.4 Compile (Compilar) [ALT][C]

Compile (Compilar) [ALT][F9]

Compila o programa fonte e linka as unidades.

Make (Fazer) [F9]

Compila o arquivo primário ("Primary File: ") ou o arquivo presente no editor; e todos os arquivos que dependem deste, inclusive as unidades ("unit") que foram alteradas.

Build (Construir)

Recompila todos os arquivos relacionados ao arquivo primário ("Primary File").

Destination (Destinação) [Memory ou Disk]

Especifica o destino do programa executável. Se "Memory" o executável é temporário, se "Disk" o arquivo executável é armazenado em disco (como .EXE).

Find error (Achar Erro)

Localiza um erro de execução "RunTime Error" (Erro em Tempo de Execução).

Primary file (Arquivo Principal)

Usado para definir o arquivo principal, usado pelo "Make" e "Build".

Get info (Mostra Informações)

Exibe uma janela contendo informações do arquivo fonte.

2.5 Options (Opções) [ALT][O]

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

Var-string checking (Strict ou Relaxed): Se "Strict" (rigorosa) verifica o tamanho das "string" passadas como parâmetro, se "Relaxed" (moderada) não verifica.

Boolean evaluation (Short circuit ou Complete): Se "Short circuit" os testes de uma expressão booleana são mais rápidos, se "complete" todas as condições são testadas.

Numeric processing (Software ou 8087-80287): Com 8087-80287 é permitido o uso dos tipos: Single, Double, Extended ou Comp. Se "Software" permite somente o uso dos tipos comuns do Turbo.

Emulation (ON ou OFF): Emula (simula) um coprocessador aritmético, se ele não existir.

Debug information (ON ou OFF): Gera um arquivo de informações de depuração de um arquivo que está sendo compilado.

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

Conditional defines: Define símbolos que podem ser referenciados em diretivas de compilação condicionais no arquivo fonte.

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.

Linker

Permite especificar diferentes modalidades de geração do mapa do "linker" e o destino do "link buffer".

Map file (OFF, Segments, Publics ou Detailed):

OFF: Arquivo "*.MAP" não é gerado.

Segments: Inclui informações do segmento de memória no arquivo *.MAP.

Publics: Inclui informações sobre símbolos, procedure/function no arquivo *.MAP.

Detailed: Informações mais detalhadas do que as anteriores.

Link buffer (Memory ou Disk): Define o destino do "Link buffer".

Memory: Mais rápido, mas não aceita programas grandes;

Disk: Mais lento, mas aceita programas maiores.

Environment (Ambiente)

Permite configurar o ambiente de trabalho.

Config auto save (ON ou OFF): Se ligado, atualiza o arquivo de configuração ("TURBO.TP") quando o programador sai do Turbo Pascal.

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.

Turbo Directory: Diretório dos arquivos do Turbo Pascal (drive:\path), normalmente: C:\LING\TP.

EXE & TPU Diretory: Diretório dos arquivos "*.EXE" (executáveis) e "*.TPU" (unidades).

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

Object Directories: Especifica o diretório dos arquivos objetos "*.OBJ".

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.

Save options (Salva Opções)

Salva o arquivo de configuração "*.TP" (default "TURBO.TP").

Retrieve options (Recuperar Opções)

Carrega o arquivo de configuração "*.TP" (default "TURBO.TP").

2.6 Debug (Depuração) [ALT][D]

Evaluate [CTRL][F4]: Exibe uma janela de avaliação com três opções: (Evaluate, Result e New name)

Evaluate: Permite identificar uma expressão ou uma variável a ser submetida ao Debug.

Result: É exibido o resultado da avaliação da expressão ou variável selecionada acima.

New name: Permite atribuir um novo valor.

Call stack [CTRL][F3]: Durante a depuração, permite chamar uma janela com a pilha que contém uma lista de "procedure" e "function" que mostram a posição atual, mostrando também, os parâmetros de cada chamada.

Find procedure: Posiciona o cursor no início de uma "procedure" ou "function".

Integrated debugging (ON ou OFF): Se ligado, aciona o debugger, "BreakPoints" (pontos de parada) podem ser colocados.

Standalone debugging (ON ou OFF): Se ligado com "Compile/Destination" em "Disk", as informações do "Debugger" são anexadas ao arquivo "*.EXE" para uso com o "Turbo Debugger".

Display swapping (None, Smart ou Always): Permite estabelecer modos de visualização de "OutPut" de tela durante a depuração do programa.

None: Não mostra a tela de saída do programa.

Smart: Mostra os efeitos da tela somente quando houver um comando de saída.

Always: Mostra sempre a tela resultante.

Refresh display: Retorna para a tela do ambiente.

2.7 Break/watch [ALT][B]

Se a opção "Integrated debugging" do menu "Debug" estiver em "On" pode-se adicionar, deletar, editar, remover todos os "watches" ou colocar, retirar ou procurar "BreakPoints".

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

Remove all watches: Remove todas as variáveis da janela de assistência.

Toggle breakpoint [CTRL][F8]: Permite que "BreakPoints" (pontos de parada) sejam colocados ou retirados.

Clear all breakpoints: Permite que todos os "BreakPoints" sejam removidos.

View next breakpoint: Permite visualizar o próximo "BreakPoint".

2.8 Como usar o DEBUG

Passo 1: Ter as duas janelas na tela: janela de edição e janela de assistência [F5];

Passo2: Marcar um "BreakPoint" (ponto de parada) [CTRL][F8] ou opção "Toggle breakpoint" do menu "Break/watch";

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

3. Estrutura de um Programa Pascal

3.1 Identificadores

São os nomes criados pelo programador para:

- nomes de Constantes (Const);

- nomes de Variáveis (Var);

- nomes de Tipos (Type);

- nomes de Procedimentos (Procedure);

- nomes de Funções (Function);

- nomes de Unidades (Unit);

- nomes de Programas (Program).

Regras:

- Todo identificador deve começar com uma letra ou subscrito (_);

- Não pode conter espaços;

- Os caracteres válidos são letras, dígitos, subscrito;

- Pode conter qualquer quantidade de caracteres, mas somente os primeiros 63 são significativos.

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:

(* aqui começa o programa *)

ou

{ aqui começa o programa }

3.3 Estrutura Geral

(* ----------------------------------------- Nome do programa *)

Program nome_do_programa; (* opcional *)

(* ------------------------------------------------- Unidades *)

Uses Crt,Printer,Graph; // unidades

(* ---------------------------------------------- Declarações *)

Const x = 100;

PI = 3.1415;

UP = #72; {tecla acima}

LEFT = #75; {tecla esquerda}

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}

Type Nome = String[80];

Var A,B: Integer;

C: Real;

N: Nome;

(* ----------------------------------------------- Definições *)

Procedure nome_do_procedimento(parâmetros);

Begin

comandos;

End;

Function nome_da_função(parâmetros): TIPO DA FUNÇAO;

Begin

comandos;

End;

(* --------------------------------------- Programa Principal *)

Begin

comandos;

End.

3.4 Definição de Tipos (Type)

Em Pascal o programador pode definir seus próprios tipos de dados.

Uses Crt;

Type TIPO_DATA = Record

ano: Integer;

mes: 1..12;

dia: 1..31;

End;

TIPO_NOME: String[80];

Var Data: TIPO_DATA;

Nome: TIPO_NOME;

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]

Var Contador,Acumulador: Integer;

Begin

Contador := 1000;

Acumulador := -32000;

4.2 - Real: (6 bytes) Faixa: [1.0E-38 à 1.0E+38]

Var Pi,Inflacao,Juros,Nota,Salario: Real;

Begin

Pi := 3.1415;

Inflacao := 13.6;

Juros := 25.7;

Nota := 5.99;

Salario := 87657.99;

4.3 - Byte: (1 byte) Faixa: [0 à 255]

Var Dia,Mes,Idade,Numero_de_Dentes: Byte;

Begin

Dia := 31;

Mes := 12;

Idade := 33;

Numero_de_Dentes := 12;

4.4 - Char: (1 byte) Faixa: [0 à 255] caracteres

Var Sexo,Opcao,Letra,Operacao: Char;

Begin

Sexo := 'F';

Opcao := '1';

Letra := 'a';

Operacao := '+';

Caracter := #65; { Letra A }

Letra := CHR(66); { Letra B }

4.5 - Boolean: (1 byte) Faixa: [True ou False]

Var Continua: Boolean;

X,Y: Integer

Begin

Continua := FALSE;

Repeat

ReadLn(X);

ReadLn(Y);

If X = Y then

Continua := TRUE;

Until Continua;

4.6 - String[n]: (n+1 bytes)

Var Nome: String[40];

Begin

ClrScr;

Nome := 'Turbo Pascal 5.5';

Write('Nome: ',Nome);

4.7 - Array[faixa] Of Tipo:

Var Nome: Array[1..10] of String[80];

Nota: Array[1..10] of Real;

Letra: Array[1..40] of Char;

I: Byte;

Begin

ClrScr;

For I := 1 to 10 do

Begin

Write('Nome: ');

Readln(Nome[I]);

Write('Nota: ');

Readln(Nota[I]);

End;

For I := 1 to 40 do

Begin

Write('Letra: ');

Letra[I] := ReadKey;

End;

4.8 - Word: (2 bytes) (0 à 65535)

Var Numero_de_Alunos_Catolica,Numero_de_Funcionarios: Word;

4.9 - ShortInt: (1 byte) (-128 à 127)

4.10 - LongInt: (4 bytes) (-2147483648 à 2147483647)

5. Operadores

5.1 - Operadores Aritméticos

5.1.1 - Com REAIS

+ Adição

- Subtração

* Multiplicação

/ Divisão

5.1.2 - Com INTEIROS

+ Adição

- Subtração

* Multiplicação

/ Divisão com resultado real

Div Resultado inteiro da divisão

Mod Resto da divisão

Uses Crt;

Var X,Y: Integer;

Divisao: Real;

Resto,Quociente: Integer;

Begin

ClrScr;

X := 7;

Y := 2;

Divisao := X / Y; { Divisao = 3,5 }

Resto := X Mod Y; { Resto = 1 }

Quociente := X Div Y; { Quociente = 3 }

[pic]

5.1.3 HIERARQUIA (Precedência)

1. Parênteses: ()

2. Operador unário: -(valor)

3. Funções

4. Operador Not

5. * / Div Mod And

6. + - Or Xor

7. = > < >= = Maior ou igual

Maior

5.3 - Operadores Lógicos

5.3.1 - Not (negação):

[pic]

5.3.2 - And (e):

[pic]

5.3.3 - Or (ou):

[pic]

5.3.4 - Xor (ou exclusivo):

[pic]

5.4 Operador de Inclusão (In)

Operador que testa a inclusão de uma variável em uma lista de constantes.

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:

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

5.5 Procedimentos Especiais

5.5.1 Inc

Procedimento que permite o incremento de uma variável inteira.

Modo de Usar: Inc(variável,passo);

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.

Modo de Usar: Dec(variável,passo);

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

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:

Var Nome: String;

Begin

ClrScr;

Write('Nome: ');

Readln(Nome);

7.1.2 Seleção (If e Case)

É um tipo de comando que no fluxo de execução do programa permite que, através de condições, desvios sejam feitos, ou seja, alguns comandos são executados e outros não.

Exemplo:

If numero = 0 Then

WriteLn('Zero')

Else

If numero > 0 Then

WriteLn('Positivo')

Else

WriteLn('Negativo');

7.1.3 Repetição (For, While e Repeat)

É um tipo de comando que no fluxo de execução do programa, permite que outros comandos sejam repetidos até que uma condição seja satisfeita ou enquanto uma condição é satisfeita. Por exemplo:

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

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

7.2 - Comando SIMPLES e COMPOSTO:

Simples: Quando há apenas um comando ligado a outro.

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;

7.3 - Comando If ... Then ... Else (Comando de Seleção)

Modo de usar:

If condição Then

comando;

Se a condição é verdadeira então o comando é executado, senão é executado o próximo comando.

ou

If condição Then

comando 1

Else

comando 2;

Se a condição é verdadeira o comando 1 é executado senão é executado o comando 2. Comando, comando 1 e comando 2 podem ser simples ou compostos.

7.4 - Comando Case ... Of ... Else ... End (Comando de Seleção)

Modo de usar:

Case variável

OF

constante 1: comando 1;

constante 2: comando 2;

. .

. .

constante n: comando n;

End;

Se a variável é igual a alguma constante o comando correspondente é executado, se nenhuma constante for encontrada o comando será terminado.

ou

Case variável

Of

constante 1: comando 1;

constante 2: comando 2;

. .

. .

. .

constante n: comando n;

Else

comandos;

End;

Se a variável for igual a alguma constante, o comando correspondente é executado, se nenhuma constante for encontrada os comandos após o Else são executados, logo após o comando Case é terminado.

Observação: A variável não pode ser Array, String e Real.

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

:

'9': WriteLn('Nove');

Else

WriteLn('ERRO: Não é um Número');

End;

7.5 Comando For ... Do (Comando de Repetição)

Modo de usar:

For Variável_de_Controle := Valor_Inicial (To) Valor_Final Do

comando;

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.

To: Comando de repetição crescente

DownTo: Comando de repetição decrescente

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;

7.6 Comando While ..Do (Comando de Repetição)

Modo de Usar:

While condição Do

comandos;

Enquanto a condição é verdadeira os comandos são repetidos. Pode-se usar comando simples ou comando composto.

Exemplo:

i := 1;

While 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 }

7.8 O Procedimetro Halt

Força o término do programa (aborta o programa), retornando ao sistema operacional, se o programa for executável ou ao ambiente do Turbo Pascal, se o programa for um arquivo fonte.

Modo de Usar:

Halt (x: Word);

ou

Halt;

7.9 O Procedimento Exit

Força a saída de um laço, passando a execução para a próxima instrução.

Repeat

:

If KeyPressed then Exit;

:

Until False;

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

8.2 Saída no Vídeo

Procedimento que permite escrita no vídeo:

Write(x); (* Imprime x e cursor fica ao lado *)

ou

WriteLn(x); (* Imprime x e cursor vai para próxima linha *)

ou

WriteLn; (* Deixa uma linha em branco na tela *)

8.3 Saída na Impressora

É necessário usar a unidade Printer.

Uses Crt,Printer;

Begin

ClrScr;

WriteLn(Lst); (* Pula uma linha na impressora *)

Write(Lst,'x = ');

WriteLn(Lst,x);

End.

Observação:

WriteLn(lst,#12); (* Salta uma página na impressora *)

WriteLn(lst,#15); (* Comprime os caracteres na impressora *)

9. Controle do Vídeo e Teclado:

9.1 ClrScr (Clear Screen)

Procedimento que permite limpar a tela, o cursor permanece no canto superior esquerdo. É obrigatório o uso da unidade Crt. A tela é limpa com a cor de fundo corrente.

Uses Crt;

Begin

ClrScr;

9.2 GotoXY(coluna,linha) (Vá para posição X,Y)

Procedimento que permite o posicionamento do cursor em qualquer posição da tela. É obrigatório o uso da unidade Crt.

[pic]

Uses Crt;

Begin

ClrScr;

GotoXY(30,12);

Write('Turbo Pascal');

GotoXY(34,13);

Write('5.5');

9.3 ClrEol (Clear End Of Line)

Procedimento que permite que uma linha seja apagada desde a posição do cursor até o final da linha. É obrigatório o uso da Unidade Crt.

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

ClrEol;

End;

End.

9.4 DelLine (Delete Line)

Procedimento que permite que uma linha seja apagada. É obrigatório o uso da Unidade Crt.

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.

10 Comandos Especiais (Unidade Crt)

10.1 Delay (Atraso)

Procedimento que permite uma parada temporário da execução por parte do computador.

Modo de Usar:

Delay(x); { x em milisegundos }

10.2 TextBackGround (Cor de Fundo)

Procedimento que permite mudança na cor de fundo do vídeo.

Modo de Usar:

TextBackGround(cor); { cor: número ou nome }

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

10.3 TextColor (Cor de Frente)

Procedimento que permite mudança na cor de texto do vídeo.

Modo de Usar:

TextColor(cor); { cor: número ou nome }

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

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

Observação: Piscante (Blink é cor a 128)

10.4 Window (Janela)

Procedimento que permite definir a janela de texto ativa, ou seja, parte do vídeo ativo onde as escritas são feitas. Normalmente a janela ativa é toda tela, ou seja: Window(1,1,80,25);

[pic]

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.

10.5 Sound e NoSound (Som e Sem Som)

Sound: Procedimento que ativa o auto-falante do computador.

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.

NoSound: Procedimento que desativa o auto-falante do computador.

Modo de Usar:

NoSound;

10.6 WhereX e WhereY (Localização do Cursor)

Funções que indicam a posição corrente do cursor [x (coluna) e y (linha)].

Uses Crt;

Var Coluna,Linha: Byte;

Begin

Coluna := WhereX;

Linha := WhereY;

WriteLn('Coluna: ',Coluna);

WriteLn('Linha : ',Linha);

End.

10.7 TextMode (Modo do Texto)

Procedimento que define o tipo de modo texto, colorido ou preto e branco e 40 ou 80 colunas.

C80 - Colorido com 80 colunas

C40 - Colorido com 40 colunas

BW80 - Preto e Branco com 80 colunas

BW40 - Preto e Branco com 40 colunas

11. Vetores e Matrizes

Vetores e matrizes são variáveis que possuem vários elementos de mesmo tipo, cada elemento possui um ou mais índices que os referenciam e os diferenciam. Uma característica importante é que todos os valores permanecem na memória ao mesmo tempo. Os elementos são alocados com contigüidade física, ou seja, um ao lado do outro.

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

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 = 1) And (N ................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download