Baixe Lógica de Programação e outras Notas de estudo em PDF para Informática, somente na Docsity!
ESTUDO SOBRE O TURBO PASCAL
C O N T E Ú D O
1. ORIGEM E USO DO TB ♦ Histórico ♦ Convenções a serem usadas neste estudo ♦ Abrir TP ♦ Digitar um programa TP ♦ Comandos usados durante a codificação ♦ A gravação ♦ Testar e corrigir erros ♦ Imprimir 2 ♦ Tornar o programa executável (EXE) 2. CONCEITOS PRELIMINARES ♦ Tipos de dados ♦ Variável ♦ Constante ♦ Estrutura de um programa na linguagem TP ♦ Codificação de um programa ♦ Salvar este programa no drive A (disquete) com o nome ‘’SOMA’’ ♦ Tornar um programa executável 3. TERMOS, NORMAS E COMANDOS DO TP – Versão 6. ♦ Strings ♦ Atribuição de valores às variáveis ♦ Comentários ♦ Delimitador de faixas ♦ Variáveis usadas no corpo do programa ♦ Instruções ( comandos, ordens ) ♦ Valor inicial de uma variável ♦ Comandos de entrada (Leitura) ♦ Comandos de saída (Escrita) ♦ Readkey ♦ Clrscr ♦ Gotoxy(a,b) ♦ Clreol ♦ Insline ♦ Delline ♦ TexColor(byte) ♦ Delay(1000) ♦ $7 { Bip } ♦ Window(a,b,c,d) ♦ Declaração Type SET - ARRAY - RECORD - FILE ♦ Units ♦ Label e Goto ♦ Operadores ♦ Funções e procedimentos para controle de vídeo ♦ Upcase 3. ESTRUTURAS DE DECISÃO I. DE SELEÇAO 1º) Caso → Repetição simples contendo um único comando ⇒ IF ... THEN sem bloco 2º) Caso → Repetição simples contendo vários comandos ⇒ IF ... THEN com bloco 3º) Caso → Repetição composta contendo um único comando ⇒ IF ... THEN ... ELSE sem bloco 4º) Caso → Repetição composta contendo um vários comandoz ⇒ IF ... THEN ... ELSE com dois blocos 5º) Caso → IF junto com AND, OR ou NOT ⇒ IF ... AND(OR, NOT) … THEN
II. IF – ELSE – IF ⇒ seleção encadeada III. CASE ( Seleção de múltipla Escolha ) IV. DE REPETIÇÂO 3 1º) Caso → De repetição indefinida com teste no início ⇒ WHILE ... DO 2º) Caso → De repetição indefinida com teste no final ⇒ REPEAT ... UNTIL 3º) Caso → Repetição com variável de controle → Caso FOR ... TO ... DO
5. ESTRUTURAS CONSTRUÍDAS a) Vetor b) Matrizes c) Registros 1º) Registros simples somente com tipos básicos 2º) Registros simples com tipos básicos e construídos ( Registro de Conjunto) 3º) Registro Composto ou Conjunto de Registro Uso da declaração (comando) WITH 6. SUB-ROTINAS (SR) _ Clrscr _ Gotoxy(a, b) 1º) Procedure 2º) Function **7. PROGRAMAÇÃO ESTRUTURADA
- ESCOPO DE VARIÁVEIS, PARÂMETROS E PASSAGEM DE PARÂMETROS
- ARQUIVOS** _ FILE _ TEXT _ Comandos do arquivo FILE: _ Declaração _ assign _ rewrite _ reset _ Ioresult _ read – readln _ write – writeln _ close _ Ponteiro _ EOF _ Seek _ Filepos _ Fileseze _ Seek<nome lógico arquivo>, Filesize(ome lógico arquivo); ♦ Comandos do arquivo text: _ declaração, assign, rewrite, reset, ioresult, read-readln, write-writeln, close _ Append **10. SUB-RFOTINAS BÁSICAS
- QUESTIONÁRIO**
- Enunciados
- Respostas 4 12. EXEMPLOS DE PROGRAMAS PARA ANÁLISE E APRENDIZAGEM DA TEORIA. 13;. UM “PROJETINHO” MUITO LEGAL ========================================================== =================== 1. ORIGEM E USO DO TURBO PASCAL ♦ Histórico - O Pascal é um aplicativo que foi criado por volta de 1970 pelo professor Niklaus Wirth da Universjdade de Zurique (Suíça), tomando por base as linguagens Algol e PL/I que já existiam desde 1960. O nome “Pascal” foi atribuído em homenagem ao notável filósofo e matemática francês chamado Blaise Pascal (
arquiva-lo } Isso é primordial porque, se alguma coisa ocorrer ( e isto quase sempre acontece) e o texto for deletado da tela, você já tem a garantia da sua cópia gravada e não precisará repetir o cansativo trabalho de digitar novamente a referida codificação. 5 ♦ Comandos usados durante a codificação - Um dos comandos mais usados durante a digitação do programa é o Edit , juntamente com Copy { lê-se: có’pi → copiar }, Cut (lê-se: câ’t → recortar ) e Paste (lê-se: pê’ist → colar). Para usar [ edit, copy ou cut ] é necessário selecionar (escurecer) os itens que devem ser manipulados. Lembramos que:
_ para selecionar uma ou mais linhas → posicionar o Cursor no início da linha
+ < shift + ↑ ou ↓ >. { lê-se: shift → mudar de lugar, posição } _ para selecionar caractere por caractere → posicionar o Cursor no início do primeiro caractere + < shift’s>. _ para selecionar palavra por palavra → posicionar o Cursor no início da primeira palavra + <Shift+Ctrl ‘ s >. { Ctrl é a tecla que se lê: CÔNTROL; ela é programável e só funciona junto com outras teclas} Feita a seleção, para copiar usa-se: [ edit, copy[; para recortar usa-se: [edit, cut] e para colar usa-se: [edit, paste]. ♦ A gravação - É feita através do seguinte procedimento: inserir disquete + [ file, save as ] + escrever: ‘drive: nome. extensão’ Exemplo: ‘ A: AlunosAprovados. Dta’ ( aqui é indiferente usar letras maiúsculas ou minúsculas ). Finalmente, < ENTER > ou [ OK ]. Pronto, o arquivo está gravado { armazenado } no disquete que foi colocado no drive A ( ou no HD se usou o drive C). ♦ Testar e corrigir erros - Após codificação, o programa deve ser executado para que sua funcionalidade seja testada. Os comandos para iniciar a execução são: [ run, run ]. Em seguida basta fornecer os dados solicitados pelo programa e verificar o que acontece até chegar no resultado esperado. Se existir algum tipo de erro o “Depurador” emite uma mensagem indicando o tal erro e orientando sobre o modo de efetuar a correção. À medida que os erros forem aparecendo eles devem ser devidamente corrigidos no texto da tela e na gravação. Após corrigir um erro na codificação da tela, a correção da gravação é feita simplesmente acionando ou [ file, save]. { save ⇒ lê-se: sêiv → salvar, poupar, economizar } ♦ Imprimir - Após codificação e depuração o programa torna-se um documento que deve ser
devidamente preservado. Por isso, além da sua gravação é necessário que ele seja impresso, o que é feito do seguinte modo: Ligar a impressora + [ file, print ]. { print ⇒ lê-se: prín’t : → imprimir, publicar } O documento assim obtido deverá ser fichado e guardado em local de inteira segurança. Por medida de maior segurança, muitos profissionais fazem até três cópias. Aqui cabe uma observação: o interessado não deve confundir as tarefas de imprimir a codificação do programa { que é facilmente feita, conforme foi exposto acima } e a de imprimir os resultados obtidos da aplicação do programa. Esta tarefa é mais trabalhosa e depende de uma programação. No momento oportuno veremos que esta programação usa, basicamente, os comandos Printer { lê- se: Prín’târ → impressora } e Lst. { forma simplificada de LIST ⇒ Lís’t : → listar, especificar, registrar, relacionar, ...} ♦ Tornar o programa executável ( EXE) - depois que o programa é gravado e impresso é preciso tornálo executável ( isto é, EXE), a fim de que possa ser executado diretamente sem a necessidade da sua codificação ficar na tela. Isto é importante porque evita do programa ser alterado, mesmo que involuntariamente. Procedimento: [ compile, D em Destination Memory] → volta à tela + [ compile, compile, Destination Disk]. Pronto, o executável já foi criado na pasta PASCAL de caminho: Meu Computador \ C \ TP
PASCAL \ Pasta contendo os Programas Executáveis ( são aqueles cujos ícones são desenhos de uma “tela de TV” em branco). Em seguida, se o interessado desejar, poderá criar uma pasta só para o arquivamento dos programas executáveis do TP, e fazer a transferência desses programas para esta nova pasta. 6 Para acessar um programa EXE basta dar um clique duplo no seu ícone. Observação: Destination disk lê-se: destinêi’shân disk → disco de destino, disco designado. Destination memory → lê-se: destinêi’shân mé’mori → memória de destino ou designada. ================================================ ===============
2. CONCEITOS PRELIMINARES ♦ Tipos de dados - São: NUMÉRICOS { inteiros e reais }, CARACTERES { letras e números } e LÓGICOS { True _ lê-se: tru → V=Verdadeiro e False _ lê-se:fól’s → F= Falso }. ♦ Variável - É um símbolo que representa uma área de memória. O identificador de uma variável é
Resp: char; Índice: byte; { Números inteiros de 0 até 255 } Valor: real; Resp: boolean; { true ou false } N: integer
_ Corpo do programa → é constituído por um bloco. Obrigatoriamente deve
conter: begin ... comandos; ... end. Os comandos são separados por PONTO E VÍRBULA: “;”. Numa mesma linha pode-se discriminar diversos comandos, desde que separados por “;”. Cada linha suporta no máximo 127 caracteres. Exemplo: read(A); read(B); ... No decorrer desse estudo o interessado terá oportunidade de trabalhar com essa estrutura “centenas” de vezes. ♦ Codificação de um programa - Para efetuar a codificação de um programa o estudante deverá seguir a seguinte orientação: _ Ligar Micro _ [[ ícone de atalho do TP ]] → coloca o Editor de texto na tela _ Digitar o texto de codificação do programa. : Exemplo: Program ADIÇÃO; Var R, A, B : integer; Begin write ( ‘A = ‘); readln(A); write ( ‘ B =’); readln(B); R := A + B; Gotoxy(10,10); Writeln ( ‘ A soma é ‘ , R ); Readln; end. Executar o programa usando A = 23 e B = 45 → Fazer: [ run, run ] + fornecer esses valores às variáveis A e de B → o programa fornecerá o seguinte resultado na tela: A soma é 68. 8
♦ Salvar este programa no drive A( disquete), com o nome “SOMA” -
Inserir o disquete no drive A + [ file, save as ] + digitar o nome: A : SOMA + < Enter >. Pronto, o programa ficou gravado { salvo } no referido disquete com o nome SOMA. Em seguida o programador pode: a) tornar o programa executável e b) criar uma pasta só para alocar { armazenar } programas executáveis.
♦ Tornar esse programa EXE - Ainda com o disquete no drive A, seguir os
seguintes comandos: [
compile, D em Destination Memory} → volta para a tela + [ compile, compile, Destination Disk] → o executável é armazenado em MC \ C \ TP \ PASCAL \ SOMA.EXE , onde seu ícone -é o desenho de uma tela de TV em branco.. ================================================ =====
3. TERMOS, NORMAS e COMANDOS DO TP - Versão- ♦ Strings - são expressões alfanuméricas { cadeia ou conjunto de caracteres } que devem ficar entre apóstrofos { também se diz:entre aspas simples }. Exemplo: write ( ‘ O resultado é :’). Quando a string contém um só caractere ela é dita char. Também se usa: string[20] - significa que a expressão alfanumérica { cadeia de caractere } dessa string pode ter no máximo 20 caracteres. ♦ Atribuição de Valores às variáveis - a atribuição de valores às variáveis é feita pela seguinte indicação “:=” { “” }. Exemplos: A := 12 , AL := “José”, ... Não se usa somente igualdade “=” , porque a variável não representa um valor fixo e inalterável. Por isso, neste contexto, em lugar de := , também é lícito “” (A _ 12, AL _ “José”, ...). O símbolo de igualdade só é usado para indicação de um valor constante: Pi=3,1416. ♦ Comentários - podem ser escritos entre chaves: { ... }, depois de // ou, ainda, *entre asterísticos: * ... . Exemplo: { O resultado é sempre positivo }, // usar negrito , * pode usar readln * , ... ♦ Delimitador de faixa - é indicado por a .. b. Significa considerar os valores de a até b. Exemplo de inteiros: 2 ..7 → significa: 2, 3, 4, 5, 6 e 7. ♦ Variáveis usadas no corpo do programa - são declaradas na subárea Var. Exemplo: Var I, J: integer; Name: string; Resp: char Genericamente: < identificador > : tipo ♦ Instruções (comandos, ordens ) - são separadas por PONTO E VÍRGULA “;”. Exemplos: A: integer; Aluno: string; ... ♦ Valor inicial de uma variável - junto com uma declaração pode-se indicar um valor inicial. Exemplos: A: string :=T → significa que esta string começa pela letra T; I: integer := 5 → I começa pelo 9 número 5. ♦ Comandos de Entrada ( Leitura ) - Read(X) { lê-se: rid → ler } → faz a leitura via teclado,
var N:integer; ho: char; begin clrscr; 10 write('N='); readln(N); if (N>20) then begin writeln ('O numero e ', N); readln ; end Else begin writeln( 'numero esta errado'); ho:=readkey; end; end. { OBSERVACOES --> 1) READLN; tem o mesmo efeito que HO:READKEY; } { serve para fixar o resultado do processamento na tela } { 2) Antes de ELSE o end nao pode ser seguido por nenhum } { caractere }
Program UsoReadkeyDOIS; uses crt; var opcao: char; R,A,B: integer; procedure ADICAO; begin clrscr; write('A='); readln(A); write('B='); readln(B); R:=A+B; writeln; writeln(' SOMA = ', R); opcao:= readkey; end; { PP } begin Opcao := '0'; while (opcao <> '2') do begin clrscr; gotoxy(15,12); write ('Menu Principal'); gotoxy(15,14); write( '1 ---> soma'); gotoxy(15,16); write( '2 ---> fim'); gotoxy(15,18); write( 'Escolha opcao '); readln(opcao); if (opcao <> '2') then case opcao of '1': Adicao; else gotoxy(15,23); writeln(' opcao invalida - pressione qualquer tecla'); opcao:=readkey; end; end; end. { OBS. 1) na ausencia do comando Opcao: READKEY; o sistema nao } 11 { exibe a mensagem de opcao invalida } { 2) Este comando opcao: readkey; e equivalente a READLN;,} { que e muito mais simples e pratico, inclusive porque elimina } { a necessidade de se declarar OPCAO: char; , o que economiza } { tempo e espaco }
Program UsoReadkey_TRÊS; uses crt; var A,B: integer; ho: char; { usar junto com readkey para fixar o resultado de execucao } begin clrscr; write('A= '); readln(A); write('B= '); readln(B); if (A>B) then Begin A:=A+B; B:=A-B; A:=A-B; end; gotoxy(12,12); writeln( 'Os nrs. s o: ', A, ' e ', B); HO:=READKEY; end. { Observação: Em lugar de ho:readkey; poderá usar repeat until keypressed; , readln; ... existem outras maneiras.} ♦ Clrscr - é um comando colocado logo depois da palavra BEGIN, para limpar a tela de vídeo e colocar o cursor na posição (1,1). É o resultado da contração de duas palavras da língua inglesa: CLEAR SCREEN { lêse: clir scrinn }, que significa limpar a tela. Esse comando efetua a limpeza da tela retirando qualquer caractere anteriormente escrito, posicionando o cursor no canto esquerdo superior. ♦ Gotoxy(a,b) - coloca a informação do comando subseqüente na posição (a,b) da tela. Entretanto, aqui a convenção é que a ( que varia de 1 até 80) representa o número da COLUNA e b ( que varia de 1 até 25) a da LINHA. Cuidado!! É o contrário do que se usa na Geometria Analítica, da Matemática Pura. Exemplo: gotoxy(3,5) write( ‘aluno’) → a palavra aluno tem o a na tela na posição (3,5) → terceira coluna e 1uinta linha ♦ Clreol { abreviação de clear end of line : lê-se: clir end of láinn → limpar o fim da linha } - limpa todos os caracteres da linha a partir da posição do cursor sem que seja modificada a posição atual do cursor. Exemplo: Program UsoClreol; uses crt; var I: integer; Tecla: char; begin clrscr; gotoxy(3,10); write('Pressione algo para continuar'); tecla:=readkey; gotoxy(3,10); clreol; 12 gotoxy(3,10); write( 'final de teste'); tecla:=readkey; end. Observaçao: Na ausencia do comando CLREOL as frases 'Pressione algo para continuar' e 'final de teste' ficam remontado.
end. Observação: TextColor → lê-se: téks’t câ’lâr ⇒ significa: texto colorido. F 0 A 8 TextBackGround (byte) - permite selecionar uma cor de fundo para a tela. A numeração do byte representa as seguintes cores: 0=preto, 1=azul, 2=verde, 3=ciano, 4=vermelho, 5-magenda, 6=marron e 7=cinza claro. Exemplos:
Program CorFundo; uses crt; var fundo: byte; begin clrscr; gotoxy(20,10); textbackground(4); { esta instrucao sombreia o texto da linha 10 em } { vermelho } readln end.
Program CORES; uses crt; var texto, fundo: byte; begin clrscr; for texto :=0 to 15 do for fundo:=0 to 6 do begin gotoxy( (fundo+1)*9, texto+1 ); TEXTCOLOR(texto); TEXTBACKGROUND(fundo); write(fundo:4, texto:4); end; writeln; TextColor(7); TextBackGround(0); readln; clrscr; end. Observação: TextBackGround → lê-se: téks’t bék gráund ⇒ significa: cor de fundo do texto. ♦ Delay(1000) {lê-se: dilêi → demorar, adiar, retardar,...} - provoca uma pausa antes de executar o próximo comando. 14 ♦ $7 - produz som de alguns segundos { bip }. ♦ Window(a,b,c,d) {lê-se: uíndous → janela } - delimita o espaço de uso da tela. Exemplo: window(2,3, 6,7) → fornece o seguinte espaço de uso na tela: ♦ Declaração de Type: { TYPE _lê-se: táip → significa: servir de: modelo, padrão, norma, exemplo ) - o TP já possui Types definidos e prontos. Esses tipos são declarados na subárea Var. Os mais usados são: Var frase: string; Peso: real;
Habitantes: integer; Resp: char Valor: boolean; { lê-se: bú’lean → True(V=verdadeiro) [lê-se: trú] ou False (F= falso) [lê-se: fóls } ETC. Além desses tipos básicos, o TP possui um conjunto de recursos através dos quais o interessado pode definir seus próprios tipos. Esses tipos são modelos pré-definidos ou construídos. Os modelos construídos pelo programador são declarados na subárea TYPE; os mais usados são: set {lê-se:
set → conjunto }, array { lê-se: érrê’i → vetor, matriz }, Record { lê-se:
récor(d) → registro } e file { lê-se: fáil → arquivo }. No decorrer desse estudo faremos um estudo mais detalhado sobre cada uma dessas estruturas { = conjuntos }. Todavia, objetivando que o interessado tenha o primeiro contacto com o processo declaratório, já vamos mencionar os procedimentos que definem as condições de uso dessas estruturas. _ SET → Type Tela (2,3) (6,7) 15 < identificador {nome}} = set of < tipo>; Exemplos: H = set of char; Dígitos = set of 0 .. 9; vogal = set of [‘a’, …,‘u’]; _ ARRAY → esse tipo engloba vetores e matrizes que são constituídos por uma composição de vários elementos - por isso também são ditos tipos estruturados. { Uma estrutura é uma composição de vários elementos } Esse tipo pode ser declarado de duas maneiras: Type Vetor = array [´1 .. N] of ; Matriz = array [ 1..M , 1..N] of ; Var A : vetor → A[I] M: Matriz → M[I,J] Note-se que na subárea Type usa-se “=” e na subárea Var usa-se “:”. Aqui também é importante destacar que: em Type foram CRIADOS os tipos array {vetor ou matriz}; em seguida, na subárea Var, foram definidas as VARIÁVEIS { nomes lógicos } A como sendo do tipo vetor e M como sendo do tipo matriz. Esse procedimento de: 1º) CRIAR tipo e 2º) Em seguida DEFINIR UMA VARIÁVEL {= nome lógico} como sendo do tipo criado é uma prática constante e rotineira quando se usa a linguagem de programação do TP.
HO: aluno. _ Arquivo TEXT Var < identificador> : text; Exemplo: Var Helena: text; ♦ UNITS {lê-se: iu’nits → Unidades } - é um conjunto de rotinas prontas para serem usadas pelo programador. Essas rotinas foram incorporadas ao TP a partir da versão-4, pelo empresa Borland, criadora desse projeto. Na realidade uma Unit é uma biblioteca de funções { functions _ lê-se: fân’kshân → função} e procedimentos { Procedures _ lê-se: proci’djur ou proci’diur → procedimento }. As UNITs sempre vêm depois da citação do nome do programa e obrigatoriamente antecedida do comando Uses. Também se diz que são identificadores pré-definidos. A unit Crt é usada em “todos” os programas. Ela possui a maior parte 17 das rotinas e variáveis de geração de som, controle de vídeo e teclado. Outra Unit muito usada é a Printer. Esta declara um arquivo tipo texto com o nome LST e associa-o à impressora. A sintaxe básica é: Program NOME; ‘ Uses Crt ; { ou Printer, ...} ♦ Mas, afinal, qual é o motivo e necessidade para se fazer uso da Unit Crt em “todos” os programas do TP? ⇒⇒ Os programas isentos desse recurso apresentam as mensagens uma abaixo da outra e, após o seu uso, não fazem a limpeza da tela. Isso implica em que um conjunto de dados já supérfluo fique desnecessariamente tomando lugar na tela, atrapalhando sobremaneira o manuseio e verificação das novas informações. É justamente para dirimir essas dificuldades que a unit CRT foi criada: ela executa pelo menos três tarefas básicas: 1) LIMPA A TELA do computador quando um programa é executado; 2) POSICIONA as mensagens em um determinado ponto da tela e 3) EFETUA A INTERRUPÇÃO DO PROCESSAMENTO DE UM PROGRAMA, aguardando que seja posicionada qualquer tecla para que o programa possa continuar. De um modo mais geral, podemos dizer que a UNIT “possui a maior parte das rotinas e variáveis de geração de som, controle de vídeo e teclado” { MANZANO, J. A.N.G, e YAMATUMI, W.Y. Turbo Pascal. 7ª Edição, São Paulo: Érica , 1997. } ♦ LABEL e GOTO - Label { lê-se: lêi’bel → rotular, por etiqueta, marcar, classificar, identificador } é a
Unit discriminada logo depois de uses e sempre é usada junto com o comando Goto { lê-se: gôu’tu → ir para } com a finalidade de efetuar desvios em qualquer ponto do programa. A sua sintaxe { atribuição } Label : início, fim, 5 A, Sócio, etc; → a partir deste instante esses labels: início, fim, etc. ficam disponibilizados para uso. Exemplo: Programa TAL; Uses crt; LABEL início, fim, etc...;
início: { depois de qualquer label usa-se dois pontos “:” }
**goto início;
goto fim;
fim:
- - - -** Exemplo: Program Uso_Label_Goto; Uses Crt; Label Adicao, Multiplicacao, inicio, Fim; Var A,B,R: real; opcao: char; begin clrscr; inicio: clrscr; gotoxy(5,5); writeln('Escolha Opcao: 1-->Adicao, 2-->Multiplicacao, 3-->Fim'); 18 gotoxy(5,7); readln(opcao); writeln; if (opcao = '1') then goto Adicao; if (opcao = '2') then goto Multiplicacao; if (opcao = '3') then goto Fim; Adicao: begin gotoxy (20,10); write('A='); readln(A); gotoxy(20,12); write('B='); readln(B); R:=A+B; gotoxy(20,14); writeln( 'Soma=' , R:5:0); end; gotoxy(20,16); writeln('Tecle algo para finalizar'); readln; goto inicio; Multiplicacao: begin gotoxy (20,10); write('A='); readln(A); gotoxy(20,12); write('B='); readln(B);
delay(1000); end. _ A função READKEY pode ser usada junto com: 1) a DECISÃO SN { Sim/Não)
- LABEL início para retornar num ponto do programa onde está mencionada inicio:. Exemplo: Program TELA_Decidir_SN; { na verdade é uma procedure } uses crt; label inicio; var tecla: char; A: integer; begin inicio: clrscr; gotoxy(10,10); write( 'A='); read(A); write ( ' Deseja continuar? SN? '); tecla:= readkey; { pressione S para continuar ou N para finalizar } if(tecla='S') or (tecla='s') then goto inicio; end. _ Keypressed é uma função especial do TP que retorna um valor bolleano: True (V) se a tecla foi pressionada ou False(F) caso contrário. É muito usada para detectar teclas pressionadas no teclado. Exemplo: 20 program TELAtres; uses crt; var tecla: char; begin clrscr; gotoxy(10,10); write(char(7)); { produz um bip } write('digite uma tecla--->'); readln(tecla); repeat until KEYPRESSED; { na ausencia deste comando a tecla digitada} { nao permanece exibida na tela } end. ♦ Upcase { lê-se: up’kêis → caso, estado, ...} - é a função que converte o caractere digitado para o formato maiúsculo Exemplos:
Program UsoUPCASEum; { na verdade e uma procedure } uses crt; var tecla: char; A: integer; begin repeat clrscr; gotoxy(10,10); write( 'A='); read(A); write ( ' Deseja continuar? SN? '); repeat tecla:= UPCASE(readkey); { pressione S para continuar ou N para } { parar; se pressionar Tecla<>SN, nada ocorre } until tecla in ['S' , 'N' ]; until tecla= 'N'; end.
program EmpregoUPCASE; uses crt;
var tecla: char; begin clrscr; gotoxy(10,10); write('Uma tecla='); readln(tecla); gotoxy(10,12); tecla:=UPCASE(tecla); writeln('Tecla digitada = ' , tecla); readln; end. ================================================ ================= 21
4. ESTRUTURAS DE DECISÃO Essas estruturas tratam dos comandos que estão relacionados com o controle do fluxo do programa. Podemos destacar as seguintes situações: I. De SELEÇÃO: 1º Caso : → Repetição Simples contendo um único comando: Exemplo:
if r < 25 then Writeln ( ‘ O resultado é correto”);
2º Caso: → Repetição Simples contendo vários comandos: Exemplo:
if a < b then Begin H = A; A = B; B = H; End;
3º Caso: → Repetição Composta contendo um único comando: IF < condição > THEN ( instrução única ) { o processo continua enquanto as condições estabelecidas pela instrução forem VERDADEIRAS } IF < condição > THEN Bloco { o processo continua enquanto as condições estabelecidas pelo bloco forem VERDADEIRAS } IF < condição > THEN ( instrução única )
ELSE ( instrução única ) 22 Exemplo:
if x > 100 then writeln ( ‘Resultado satisfatório’ );
