Your SlideShare is downloading. ×
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Caderno didatico pascal
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Caderno didatico pascal

985

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
985
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
67
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Universidade Federal de Santa Maria 2010Caderno Didático Bruno B. Boniati Joel da Silva Teresinha Letícia da Silva Frederico Westphalen, 2010
  • 2. SumárioCAPITULO I – Introdução ao Pascal ............................................................................................................................................ 1 O que é o Pascal ............................................................................................................................................................. 1 Layout de um programa Pascal ....................................................................................................................................... 2 Caracteres utilizados ....................................................................................................................................................... 3 Palavras Reservadas ....................................................................................................................................................... 3CAPITULO II – Características Básicas da Linguagem .............................................................................................................. 4 Básico da Linguagem ...................................................................................................................................................... 4 Declaração de Constantes............................................................................................................................................... 4 Declaração de Variáveis .................................................................................................................................................. 4 Comentários ..................................................................................................................................................................... 5 O Ponto-e-Vírgula e o Ponto............................................................................................................................................ 5 Operadores ...................................................................................................................................................................... 6 Prioridades ....................................................................................................................................................................... 6CAPITULO III – Tipos de Dados .................................................................................................................................................... 7 Tipos Inteiros ................................................................................................................................................................... 7 Tipos Reais (ponto flutuante) ........................................................................................................................................... 7 Tipos Texto ...................................................................................................................................................................... 7 Tipo booleano .................................................................................................................................................................. 7CAPITULO IV – Entrada e Saída de Dados .................................................................................................................................. 8 Comandos de Leitura (entrada) ....................................................................................................................................... 8 Comandos de Impressão (saída)..................................................................................................................................... 8CAPITULO V – Formatação e posicionamento de tela ............................................................................................................. 10 Limpeza da tela.............................................................................................................................................................. 10 Formatação de Cores .................................................................................................................................................... 10 Posicionamento em coordenadas de tela ...................................................................................................................... 11CAPITULO VI – Elementos fundamentais de controle ............................................................................................................. 12 Comandos de Decisão................................................................................................................................................... 12 Comandos de Repetição (Looping) ............................................................................................................................... 13CAPITULO VII – Funções e comandos internos ....................................................................................................................... 16 Tratamento de Strings ................................................................................................................................................... 16 Tratamento de Valores Ordinais ................................................................................................................................... 17 Conversões de Tipos de Dados..................................................................................................................................... 18 Outros comandos e funções .......................................................................................................................................... 18CAPITULO VIII – Modularização ................................................................................................................................................. 22 PROCEDURE (Procedimentos)..................................................................................................................................... 22 FUNCTION (Funções) ................................................................................................................................................... 24 Passagem de parâmetros .............................................................................................................................................. 25CAPITULO IX – Tipos de dados estruturados ........................................................................................................................... 27 Records (Registros) ....................................................................................................................................................... 27 Arrays (Vetores e Matrizes) ........................................................................................................................................... 28CAPITULO X – Arquivos.............................................................................................................................................................. 30 Comandos e Operações sobre Arquivos ....................................................................................................................... 31Anexos .......................................................................................................................................................................................... 34 Anexo I – Tabela de Códigos ASCII .............................................................................................................................. 34Referências Bibliográficas .......................................................................................................................................................... 37
  • 3. 1 Universidade Federal de Santa Maria CAPITULO I – Introdução ao Pascal O que é o Pascal A linguagem e programação PASCAL foi criada para ser uma ferramenta educacional, Ito no início da década de 70 pelo Professor Niklaus Wirth do Technical University em Zurique, Suíça. Foi batizada pelo seu idealizador de PASCAL, em homenagem ao grande matemático Blaise Pascal, inventor de uma das primeiras máquinas lógicas conhecidas. Foi baseada em algumas linguagens estruturadas existentes até então, como ALGOL e PLI, tentando facilitar ao máximo o seu aprendizado. PASCAL somente ganhou popularidade quando foi adotado pela Universidade da Califórnia, San Diego, em 1973. No mesmo período, em seus cursos, também foram feitas implementações para microcomputadores. Nas suas primeiras implementações, não era muito amigável ao programador, pois eram necessários vários passos para se obter um programa executável. Primeiro deveria se escrever o programa em um editor de texto e depois compilá-lo, “lincá-lo” e montá-lo. Quando era feita uma manutenção no mesmo, todos estes passos deviam ser refeitos, o que desestimulava os programadores. Apesar de todas as dificuldades iniciais, de seu propósito educacional e a facilidade de programação, o PASCAL começou a ser utilizado por programadores de outras linguagens, tornando-se para surpresa do próprio Niklaus, um produto comercial. Contudo somente ao final do ano de 1993, é que a soft-house americana Borland International, lançou o TURBO PASCAL para microcomputadores, no mesmo ano em que houve um grande crescimento no mercado de microcomputadores. Comercialmente, a linguagem foi sucedida pela criação da linguagem Object Pascal, atualmente utilizada nos IDEs Delphi, Kylix e Lazarus. Durante a década de 90 a Borland descontinuou os compiladores Turbo Pascal e Borland Pascal. Nessa época vários projetos foram iniciados para produzir um compilador Pascal para preencher essa lacuna. Um destes projetos nasceu dentro de um grupo de estudantes liderado por Florian Paul Klaempfl e foi batizado de FPK-Pascal. Posteriormente o projeto ganhou bastante popularidade e se tornou o Free Pascal, mostrando-se exatamente o que a comunidade queria: um compilador Pascal de 32bits moderno, robusto, estável e confiável. O Ambiente de desenvolvimento Free Pascal pode ser obtido gratuitamente através do site http://www.freepascal.org/, para diferentes plataformas de sistemas operacionais. Caderno Didático PASCAL Página 1
  • 4. 2 Universidade Federal de Santa Maria Layout de um programa Pascal Os programas escritos em Pascal (assim como a maioria das linguagens de programação) têm uma estrutura definida para especificar suas partes integrantes. O texto que compõe um programa Pascal possui várias áreas específicas onde são expressas, através de uma razoável rigidez léxica e sintática, diversas informações para a completa especificação do programa. Qualquer programa em Pascal tem duas partes distintas: Declarações: especificam os instrumentos a serem utilizados pelo programa, como, por exemplo: variáveis, funções, constantes, sub-rotinas, etc. As declarações obedecem a uma ordem fixa quanto à sua natureza e precedem os comandos. Comandos: adicionam procedimentos que se utilizam dos instrumentos discriminados nas declarações. O termo comando é usado em Pascal, indistintamente, para as instruções primitivas e para as estruturas de controle. Os comandos são, portanto, a parte efetivamente ativa na execução dos algoritmos. Observe a seguir, um layout de um programa em Pascal: program nome_programa; { Este é o cabeçalho do programa } uses unidades; {necessária apenas se forem utilizadas informações de units já definidas (obrigatoriamente após o comando program} const lista de constantes; type; lista de tipos de dados específicos; var lista de variáveis e seus respectivos tipos de dados associados; procedure NomeModulo(parâmetros) begin //Corpo do procedimento end; function NomeFuncao(parâmetros) : tipo; begin //Corpo da função end; begin //Corpo do programa; end. Caderno Didático PASCAL Página 2
  • 5. 3 Universidade Federal de Santa Maria Caracteres utilizados Os caracteres que podem ser utilizados na linguagem Pascal são divididos em: Letras: ‘A’ até ‘Z’, ‘a’ até ‘z’; Números: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Especiais: + - * / = ^ < > ( ) [ ] { } . , : ; ‘ # $ A linguagem Pascal não é case sensitive, ou seja, não faz distinção entre letras maiúsculas e minúsculas. Palavras Reservadas As palavras reservadas da linguagem Pascal são expressões que fazem parte da sua sintaxe e têm significados pré-determinados. Elas não podem ser redefinidas e não podem ser utilizadas como identificadores de variáveis, procedimentos, funções, etc. Abaixo a relação de palavras reservadas da linguagem Pascal: and end mod repeat array file nil set begin for not then case forward of to const function or type div goto packed until do if procedure var downto in program while else label record with Caderno Didático PASCAL Página 3
  • 6. 4 Universidade Federal de Santa Maria CAPITULO II – Características Básicas da Linguagem Básico da Linguagem Programas, procedimentos e funções são todos compostos de instruções. Instruções podem ser simples ou compostas. Veja alguns exemplos: x := 13; //atribui o valor 13 à variável x. y:= x + 12; //atribui o resultado da soma à variável y. TestaArquivo(‘c:config.sys’); //executa o procedimento TestaArquivo Declaração de Constantes Constantes são identificadores cujo valor não se altera durante a execução do programa. Esse comando declarativo tem por finalidade associar um nome a uma constante, que pode ser um número (inteiro ou decimal), um identificador de constante (possivelmente um sinal) ou uma sequência de caracteres. Embora não seja uma regra da linguagem, normalmente convenciona-se utilizar o nome da constante em letras MAIÚSCULAS. const PI = 3.171592; IES = ‘UFSM’; PERCENTUAL = 0.10; CoordenadaX = 3; Declaração de Variáveis Quando uma variável precisa ser mencionada no bloco de comandos é preciso que inicialmente a mesma seja decalrada. Associada à variável precisa haver um tipo de dado. Na linguagem Pascal cada variável só pode armazenar um tipo de dado específico de informação. Quando duas ou mais variáveis são do mesmo tipo de dado, podem ser agrupadas em uma mesma declaração. const nome : string; x, y : integer; salário : real; Caderno Didático PASCAL Página 4
  • 7. 5 Universidade Federal de Santa Maria Comentários Comentários são “informações” incluídas no corpo do programa, mas que não são considerados pelo compilador. A utilização de comentários no código é uma excelente prática de programação e permite documentar a intenção de uso e o funcionamento do código. { } Tudo que está entre as chave é ignorado; (* *) Tudo que está entre * é ignorado; // Tudo após o marcador do comentário é ignorado até o final da linha O Ponto-e-Vírgula e o Ponto Como regra geral, todas as instruções em um programa Pascal devem ser separadas por um ponto-e-vírgula. Neste caso, note que instrução refere-se tanto a instruções simples como instruções compostas. É por esta razão que não existe um ponto- e-vírgula após um begin e significa também que um ponto-e-vírgula antes de qualquer end é opcional. Assim, no código a seguir, a instrução de atribuição não possui um ponto-e- vírgula após ela porque é imediatamente seguida por um end, mas o end deve ter um ponto-e-vírgula após, porque ele é o final da instrução composta: if x = 13 then begin writeln(‘X vale Treze’); x:=14 //aqui o ponto-e-vírgula é opcional end; //Aqui o ponto e vírgula é obrigatório //pois termina a instrução composta Na maioria dos casos o par begin ... end estão sempre juntos. Entretanto, existem poucos casos onde você tem um end sem begin (a ocorrência mais comum é a instrução case). O end final do programa é seguido de um ponto e não de um ponto-e- vírgula. Caderno Didático PASCAL Página 5
  • 8. 6 Universidade Federal de Santa Maria Operadores 1. Atribuição e Igualdade: o operador de atribuição em Pascal é o símbolo “dois pontos igual” (:=). É diferente do sinal de igual (=) usado para testar a igualdade e a definição de tipos. 2. Numéricos: observe a tabela a seguir: Operador Operação Tipos de Operandos Tipos de Resultado + Adição integer ou real integer ou real - Subtração integer ou real integer ou real * Multiplicação integer ou real integer ou real / Divisão integer ou real real div Divisão de inteiros integer integer mod Resto da divisão integer integer 3. Relacionais: a tabela a seguir contém os operadores relacionais que retornam dois valores booleanos (true e false): Operador Operação = igual <> não igual < menor que > maior que <= menor ou igual >= maior ou igual not negação and e lógico or ou lógico Prioridades Na resolução das expressões aritméticas, as operações e funções matemáticas guardam entre si uma hierarquia: 1. Parênteses mais internos; 2. Funções; 3. * (multiplicação) e / (divisão); 4. + (soma) e – (subtração); Para operações de mesma prioridade, segue-se a ordem especificada, isto é, primeiro resolvem-se os operadores mais à esquerda e depois os mais à direita e, para alterar a prioridade, utiliza-se parênteses mais internos. Caderno Didático PASCAL Página 6
  • 9. 7 Universidade Federal de Santa Maria CAPITULO III – Tipos de Dados Tipos Inteiros São tipos numéricos exatos, sem casas decimais. O tipo integer é o tipo inteiro padrão. Tipo Tamanho Faixa de Valores shortint 1 -128..127 byte 1 0..255 integer 2 -32768..32767 word 2 0..65535 longint 4 -2147483648..2147483647 cardinal 4 0..4294967295 Tipos Reais (ponto flutuante) São tipos numéricos exatos com casas decimais. O tipo Double é o tipo real padrão. Tipo Faixa Dígitos Tamanho -45 single 1,5 .. 3,438 7-8 4 -39 real 2,9 .. 1,738 11-12 6 double 5-324 .. 1,7308 15-16 8 comp -9,218 .. 9,218 19-20 8 extended 3,4-4932 .. 1,14932 19-20 10 Tipos Texto Os tipos texto podem operar com caracteres simples ou grupos de caracteres. O tipo string é o tipo texto padrão. char – um único caractere ASCII string – texto alocado dinamicamente limitado a 255 caracteres; Tipo booleano Variáveis booleanas (em Pascal boolean) podem receber os valores lógicos true ou false (verdadeiro ou falso). Uma variável boolean ocupa 1 byte de memória. Caderno Didático PASCAL Página 7
  • 10. 8 Universidade Federal de Santa Maria CAPITULO IV – Entrada e Saída de Dados Um requisito básico da construção de programas de computador é a entrada de dados para o programa e a saída dos resultados calculados de forma a ser compreendia por qualquer usuário. Para atender a este requisito a linguagem de programação disponibiliza comandos para entrada (comandos de leitura) e para saída (comandos de impressão de informações). Comandos de Leitura (entrada) A execução da instrução de leitura pressupõe que os dados serão fornecidos do meio externo, através do teclado, e serão armazenados nas variáveis explicitadas no programa, na ordem estabelecida. O comando read procura os valores sempre na mesma linha de entrada. Quando se deseja mudar de linhas utiliza-se o comando readln. Este comando subentende que após cada execução, uma nova linha de entrada será lida. program TesteEntrada; var nome : string; x, y : integer; begin read(nome); readln(x); readln(y); end. Comandos de Impressão (saída) A execução da instrução de impressão pressupõe que os dados estão armazenados na memória e serão exibidos no dispositivo definido como saída (por exemplo: monitor) e na sequência e nos formatos especificados nos parâmetros. A exemplo dos comandos de entrada, o comando writeln difere também do comando write. O primeiro deve ser usado quando, após a impressão de todas as expressões entre parênteses, desejamos que uma nova linha seja carregada. Um recurso dos comandos write/writeln é tabular as informações de saída, isso é possível colocando-se “:n” (dois pontos) após a variável, onde n é o deslocamento a partir da posição corrente do cursor. No caso de valores reais, pode-se ainda determinar a Caderno Didático PASCAL Página 8
  • 11. 9 Universidade Federal de Santa Maria quantia de casas decimais que serão exibidas, colocando-se mais uma sequencia de “:n”, após a anterior. program TesteSaida; var nome : string; salario : real; begin nome := ‘TESTE’; salario := 510.42; write(nome); writeln(salario:5:2); //5 espaços de tabulação e 2 casas decimais end. Caderno Didático PASCAL Página 9
  • 12. 10 Universidade Federal de Santa Maria CAPITULO V – Formatação e posicionamento de tela Limpeza da tela ClrScr Este comando limpa a tela e automaticamente coloca o cursor no canto superior esquerdo da mesma. É a contração das palavras em língua inglesa CLeaR SCReen. Formatação de Cores TextColor Este procedimento permite que seja selecionada a cor do texto que aparecerá no vídeo, sendo as cores representadas por valores numéricos inteiros que variam de 0 a 15, correspondendo às seguintes cores: 0 Preto 8 Cinza escuro 1 Azul 9 Azul claro 2 Verde 10 Verde claro 3 Ciano 11 Ciano claro 4 Vermelho 12 Vermelho claro 5 Magenta 13 Magenta claro 6 Marrom 14 Amarelo 7 Cinza claro 15 Branco Além destas 16 cores disponíveis, podemos somar a qualquer uma delas o valor 128 para que o texto fique piscante, na verdade o que este procedimento faz é ajustar os bits de 0 até 3 para as cores propriamente ditas e mais o bit 7 para o piscante do byte de atributo no modo texto. TextColor(9); //ajusta a cor do texto para azul claro writeln(Este texto é azul claro); TextColor(5+128); //ajusta a cor do texto para vermelho piscante writeln(Este texto é vermelho piscante); Caderno Didático PASCAL Página 10
  • 13. 11 Universidade Federal de Santa Maria TextBackGround Este procedimento permite selecionar a cor de fundo, que é representada por um valor numérico inteiro que pode variar de 0 até 7, correspondendo às seguintes cores: 0 Preto 1 Azul 2 Verde 3 Ciano 4 Vermelho 5 Magenta 6 Marrom 7 Cinza claro TextBackGround(2); //ajusta a cor do fundo para verde clrscr; //limpa toda a tela que agora terá a cor verde Posicionamento em coordenadas de tela GotoXY Em ambiente texto, a saída padrão (vídeo), é composta por 80 colunas e 25 linhas, sendo que todo o posicionamento do texto deve se dar dentro destes valores de coordenadas. Para posicionarmos o cursor em um ponto qualquer da tela, referenciado pelos eixos X e Y, ou seja, coluna e linha, utilizamos o comando GotoXY. Tanto a coluna como a linha deve ser válida, caso contrário o posicionamento poderá ter um resultado inesperado. Normalmente o comando GotoXY é utilizado antes de um comando de entrada ou de saída. program TestePosicionamento; var oper1, oper2 : real; begin clrscr; //limpa a tela gotoxy(10,6); //coluna 10 da linha 6 write(Digite o valor do primeiro operador: ); readln(oper1); gotoxy(10,8); //coluna 10 da linha 8 write(Digite o valor do segundo operador: ); readln(oper2); gotoxy(10,10); writeln(A soma entre o primeiro , oper1:6:2, e o segundo , oper2:6:2, é , oper1+oper2:6:2); end; Caderno Didático PASCAL Página 11
  • 14. 12 Universidade Federal de Santa Maria CAPITULO VI – Elementos fundamentais de controle Comandos de Decisão if...then...else (se...então...senão) O formato básico da instrução if...then é mostrado abaixo: if <expressão lógica> then <instrução>; Esta sintaxe básica pode ser incrementada pela adição da cláusula else: if <expressão lógica> then <instrução> // não vai ponto-e-vírgula else <instrução>; Para utilizar instruções compostas, a sintaxe básica deve ser incrementada pelos comandos de bloco de código: if <expressão lógica> then begin <instrução 1>; <instrução 2>; <instrução n>; end // não vai ponto-e-vírgula else begin <instrução 1>; <instrução 2>; <instrução n>; end; Obs.: Não existe ponto-e-vírgula após o end que aparece antes do else. case...of (escolha...de) A instrução if...then...else mostrada anteriormente funciona bem para um pouca quantidade de opções, mas torna-se inviável se você tiver muitas opções. Nesta situação, a construção case é mais indicada e simples de escrever. A sintaxe geral para a instrução case é: case <variável> of <valor 1> : <instrução 1>; <valor 2> : <instrução 2>; <valor n> : <instrução n>; else <instrução>; end; Caderno Didático PASCAL Página 12
  • 15. 13 Universidade Federal de Santa Maria A instrução case toma uma variável e a compara com os valores possíveis. Múltiplos valores podem aparecer sob o mesmo caso, separados por vírgulas. Observe: case x of A .. Z, a .. z : writeln(Letra); 0 .. 9 : writeln(Número); +, -, *, / : writeln(Operador); else writeln(Caractere inválido); end; Comandos de Repetição (Looping) while...do (enquanto...faça) O laço de repetição while executa instruções até que a condição do laço torne-se falsa. Sintaxe: while <expressão lógica> do <instrução>; Como nas outras estruturas, o comando de repetição while também permite instruções simples ou compostas após o do. Para utilizar instruções compostas é necessário utilizar o par begin...end: i := 10; while i > 0 do begin i:=i-1; writeln(passando pelo loop , i); end; for...to...do (de...até...faça) O laço de repetição for difere do while por executar uma quantidade específica de a ação determinada pela variável de controle. A sintaxe básica é: for <variável de controle> := <valor inicial> to <valor final> do <instrução>; Caderno Didático PASCAL Página 13
  • 16. 14 Universidade Federal de Santa Maria Usando a cláusula downto ao invés de to, a variável de controle sofre um decremento de valor. for i := 10 to 100 do writeln(i); for j := 100 to 10 do writeln(i); repeat...until (repita...até que) A terceira construção de laço de repetição é o repeat...until, ele executa todas as instruções dentro do loop até que a expressão lógica torne-se verdadeira (o contrario do laço while). Sua sintaxe geral: repeat <instrução 1>; <instrução 2>; <instrução n>; until <expressão lógica>; Observe que essa construção pode conter diversas instruções e não requer o par BEGIN...END, exemplo: j := 0; repeat j:=j+1; writeln(passando pelo loop , j); until j >= 10; break e continue (pare e continue) São palavras reservadas que podem ser usadas em qualquer um dos laços de repetição. Exemplo: while true do begin readln(inputFile,i); if strtoint(i) = 5 then break; writeln(i); end; No exemplo acima, o loop é executado eternamente (uma vez que true é sempre true). O loop continuará a ler a entrada de dados de um arquivo e exibirá uma mensagem até que seja lido o número 5, quando isso acontecer o comando break interromperá o laço. Caderno Didático PASCAL Página 14
  • 17. 15 Universidade Federal de Santa Maria O outro modificador de execução do laço de repetição é a instrução continue. Ela ignorará o restante do loop e voltará a avaliar a condição. Assim, se algo for alterado que mude a condição de saída, a instrução continue pode ser utilizada para pular para o topo do loop e avaliar novamente a condição. Exemplo: while i<10 do begin readln(i); if i < 5 then continue; writeln(Este número será maior que 5: , i); end; Neste caso, continue impedirá que qualquer número menor que 5 seja impresso. Este comando é útil para ser utilizado com entradas inválidas dentro de um loop. Caderno Didático PASCAL Página 15
  • 18. 16 Universidade Federal de Santa Maria CAPITULO VII – Funções e comandos internos Tratamento de Strings UpCase(caracter) Converte o caracter passado como parâmetro para maiúsculas. y := UpCase(a); //y = A Copy(texto, pos_inicial, num_posicoes) Retorna um subtexto de um texto passado como parâmetro, de acordo com a posição e a quantidade de caracteres predefinidos. y := Copy(Universidade Federal de Santa Maria,14,7); //y = Federal Delete(variável, pos_inicial, num_posicoes) Remove um número determinado de caracteres a partir de uma posição inicial. y := Universidade Federal de Santa Maria; Delete(y,1,13); //y = Federal de Santa Maria Insert(texto, variável_destino, posição) Insere um subtexto em uma variável a partir de uma posição preestabelecida. y := Frederico Westphalen; Insert(Campus de ,y,1); //y = Campus de Frederico Westphalen Length(texto) Retorna o número de caracteres do texto passado como parâmetro. x := length(UFSM); // x = 4 Pos(texto_pesquisado, texto_objeto) Retorna a posição do texto pesquisado dentro do texto objeto da pesquisa. Se a função retornar zero, o texto pesquisado não existe no texto objeto. x := pos(F,UFSM); // x = 2 Caderno Didático PASCAL Página 16
  • 19. 17 Universidade Federal de Santa Maria Tratamento de Valores Ordinais Dec(ordinal, quantidade) Decrementa um valor ordinal em uma quantidade determinada de unidades. x := 10; x := Dec(x); //x = 9 x := Dec(x,6); //x = 3 Inc(ordinal, quantidade) Incrementa um valor ordinal em uma quantidade determinada de unidades. x := 10; x := Inc(x); //x = 11 x := Inc(x,6); //x = 17 Odd(ordinal) Testa se o ordinal passado com parâmetro é ímpar (neste caso retorna true), ou se é par (retornando false). z := Odd(10); // z = false z := Odd(5); // z = true Pred(ordinal) Retorna o predecessor do ordinal; x := Pred(b); // x = a z := Pred(5); // z = 4 Succ(ordinal) Retorna o sucessor do ordinal; x := Succ(b); // x = c z := Succ(5); // z = 6 Ord(ordinal) Retorna a ordem do valor ordinal na faixa de valores do tipo ao qual ele faz parte. x := Ord(A); // x = 65 (valor de A na tab. ASCII); Caderno Didático PASCAL Página 17
  • 20. 18 Universidade Federal de Santa Maria Low(ordinal) Retorna o menor valor da faixa de valores do tipo ao qual o valor ordinal faz parte. x := 10; // inteiro x := Low(x); // x = -2.147.483.648 High(ordinal) Retorna o maior valor da faixa de valores do tipo ao qual o valor ordinal faz parte. x := 50; // inteiro x := High(x); // x = 2.147.483.648 Conversões de Tipos de Dados Chr(variável_byte) Converte uma variável Byte em Char. Normalmente é utilizada para saber o caractere ASCII de um valor. x := Chr(65); //x = A Round(variável_real) Arredonda um número real transformando-o em um inteiro. x := Round(50.8); //x = 51 ... maior que 5 x := Round(50.5); //x = 50 ... menor ou igual a 5 Trunc(variável_real) “Trunca” (omite) a parte decimal de um valor real. Transforma um valor real em um inteiro ignorando as casas decimais (retorna apenas a parte inteira do número). x := Trunc(50.8); //x = 50 x := Trunc(50.5); //x = 50 Val(texto, variável_destino, variável_erro) Converte uma string passada como parâmetro em um valor numérico. Caso a conversão não seja possível, ou seja, a string não contém um valor numérico, a variável de erro armazenará um número diferente de zero. Val(teste,x,erro); // x = 0 erro = 1 Val(100,x,erro); // x = 100 erro = 0 Caderno Didático PASCAL Página 18
  • 21. 19 Universidade Federal de Santa Maria Str(valor, variável_destino) Converte um valor numérico em uma string, armazenando o resultado na variável destino passada como parâmetro. Str(50,x); // x = 50 Str(950.25:3:2,x); // x = 950.25 Outros comandos e funções Diferentes bibliotecas da linguagem Pascal oferecem comandos e funções que podem ser muito úteis: Int(var_real) Retorna a parte inteira do argumento real devolvendo também um valor real. x := Int(50.80); //x = 50.00 x := Int(50.50); //x = 50.00 Frac(var_real) Retorna a parte fracionária do argumento real devolvendo também um valor real. x := Int(50.80); //x = 0.80 x := Int(50.53); //x = 0.53 Abs(numero) Retorna o valor absoluto (nº puro, sem o sinal) do argumento numérico. x := Abs(-4.21); //x = 4 Pi Retorna o valor do p, com 14 casas decimais. x := Pi; //x = 3.14159265358979 Sqr(numero) Eleva o valor passado como parâmetro ao quadrado e retorna um valor real. x := Sqr(5); // x = 25 Caderno Didático PASCAL Página 19
  • 22. 20 Universidade Federal de Santa Maria Sqrt(numero) Retorna a raiz quadrada do valor passado como parâmetro. x := Sqrt(9); // x = 3 Random Retorna um número (pseudo)-randômico real entre 0 e 1. A sequência de valores randômicos será sempre a mesma. x := Random; Random(numero_limite) Retorna um número (pseudo)-randômico inteiro entre 0 e o valor do número limite passado como parâmetro. A sequência de valores randômicos será sempre a mesma. x := Random(100); //Retorna um valor randômico entre 0 e 100 Randomize É utilizado antes do comando Random, para forçar o uso do relógio e gerar um número randômico real (em uma ordem que não se repita a cada execução do programa). Delay(tempo) Efetua uma pausa no processamento. O tempo de duração da pausa é determinado pelo parâmetro tempo (valor inteiro em milissegundos). Delay(1000); //Aguarda um segundo Sound(frequencia) e NoSound Permite ativar o som do alto-falante interno, a uma frequência especificada no parâmetro. Para desativar a emissão do som deve-se utilizar o procedimento NoSound. Sound(196); //Emite um som em frequência 196 (nota musical Sol) Delay(1000); //Aguarda um segundo NoSound; //desativa a emissão de som Caderno Didático PASCAL Página 20
  • 23. 21 Universidade Federal de Santa Maria ReadKey Retorna o valor de uma tecla pressionada. Este valor é do tipo char. Quando utilizamos essa função para entrada de dados, não é necessário que seja pressionada a tecla ENTER para confirmar o valor digitado. x := ReadKey; Caderno Didático PASCAL Página 21
  • 24. 22 Universidade Federal de Santa Maria CAPITULO VIII – Modularização Ao transformar a lógica em um algoritmo, são desenvolvidas sequências de passos que representam as ações que levam à resolução de um determinado problema. Essas ações são dirigidas segundo as estruturas de controle, totalizando assim o algoritmo que é representado como sendo um único bloco lógico (INÍCIO .. FIM). Na medida em que os problemas a serem solucionados tornam-se mais complexos, ou seja, apresentam uma variedade maior de situações diferentes a serem resolvidas, observa-se uma série de pequenos problemas, que muitas vezes se repetem e cujas respectivas soluções integrarão o conjunto de ações definitivo que irá formar o programa. Quando tal conjunto é construído, podemos nos deparar literalmente com um amontoado de ações que podem afetar a legibilidade, uma vez que podem não ficar claras e concisas as pequenas partes lógicas que solucionam cada pequeno problema. Essa situação dificulta a assimilação das construções por outra pessoa e de certa forma inviabilizam uma perfeita coesão interna do algoritmo. Para evitar essas circunstâncias, utilizamos uma estrutura que deixe explícito as pequenas soluções e resulta em uma atividade conhecida como modularização. Na linguagem pascal, existem duas maneiras de modularizarmos um programa: procedimentos e funções. PROCEDURE (Procedimentos) Procedures (procedimentos) são as sub-rotinas mais comuns na linguagem Pascal. O procedimento de chamada desvia o fluxo de execução do programa para a primeira instrução do procedimento, que passa então a ser executada. Quando a execução do procedimento termina, o fluxo é desviado para a instrução seguinte, retomando-se a execução do programa principais (ou ainda do procedimento de chamada). A modularização com procedimentos obedece a seguinte sintaxe: procedure NomeDaProcedure( <parâmetro 1> : <tipo 1>; <parâmetro 2> : <tipo 2>); const <nome da constante> = <valor literal>; var <nome da variável> : tipo; begin <instrução 1>; <instrução n>; end; Caderno Didático PASCAL Página 22
  • 25. 23 Universidade Federal de Santa Maria Abaixo um exemplo de declaração de procedure: procedure MostraEstrelas(NumEstrelas : integer); var i : integer; s : string; begin for i:=1 to NumEstrelas do s := s + *; WriteLn(s); end; Neste exemplo, uma mensagem com ‘n’ asteriscos será exibida. A quantidade de asteriscos é passada como parâmetro. Quando a procedure é chamada, sendo assim para exibir 20 asteriscos utilizamos a seguinte chamada: MostraEstrelas(20); A passagem de parâmetros em um procedimento não é obrigatória, a seguir um exemplo: procedure MostraDezEstrelas(); const NumEstrelas = 10; var i : integer; s : string; begin for i:=1 to NumEstrelas do s := s + *; WriteLn(s); end; O exemplo acima não permite nenhuma comunicação do código que chamou o procedimento com o código do procedimento em si. Para fazer a chamada do procedimento, basta colocar o nome do mesmo: MostraDezEstrelas; Caderno Didático PASCAL Página 23
  • 26. 24 Universidade Federal de Santa Maria FUNCTION (Funções) Funções são basicamente o mesmo que procedimentos, com uma grande diferença: a função sempre retorna um valor de algum tipo. Para tanto, ao declarar uma função, precisamos declarar também qual o tipo de valor que ela retorna. A modularização com funções obedece a seguinte sintaxe: function NomeDaFuncao( <parâmetro 1> : <tipo 1>; <parâmetro 2> : <tipo 2>) : <tipo retorno > const <nome da constante> = <valor literal>; var <nome da variável> : tipo; begin <instrução 1>; <instrução n>; NomeDaFuncao := <valor de retorno> end; O valor de retorno de uma função pode ser especificado fazendo-se uma atribuição diretamente ao nome da função: function Cubo(base : integer) : integer begin Cubo := base*base*base; end; function Quadrado(base : integer) : integer begin Quadrado := base*base; end; Quando a função é chamada, o valor de retorno deve ser atribuído a uma variável de mesmo tipo: x := Cubo(2); //x será igual a 8 y := Quadrado(3); // y será igual a 9 Caderno Didático PASCAL Página 24
  • 27. 25 Universidade Federal de Santa Maria Passagem de parâmetros A passagem de parâmetros é uma excelente alternativa para que o código chamador se comunique com o código da sub-rotina. Os parâmetros podem ser passados tanto para procedimentos quanto para funções. Em linguagem Pascal há duas formas de passar parâmetros para uma sub-rotina: por valor: neste caso apenas o valor é transferido e todas as alterações feitas nos parâmetros não alteram os valores reais (do código chamador). Por padrão a passagem de parâmetros é feita por valor, dessa forma nada precisa ser alterado para que a passagem se comporte dessa forma. Ex.: procedure MostrarNumeros(De : integer; Ate : integer); var i : integer; begin writeLn(Exibindo os numeros de , De, até , Ate); for i:=De to Ate do writeLn(i); De := 500; //Essa atribuição embora válida //não terá efeito sobre o valor do parâmetro // após a execução do procedimento end; ... MostrarNumeros(50,40); a := 5; b := 10; MostrarNumeros(a,b); por referência: neste caso ao invés de passar o valor, o endereço do parâmetro real é transferido. Todas as alterações nos parâmetros da sub- rotina são feitos sobre as variáveis externas que foram passadas como parâmetro. Em linguagem Pascal para passar parâmetros por referência utilizamos o modificador var na frente do parâmetro (apenas na declaração). Quando sub-rotinas utilizam-se de passagem por referência é obrigatório que o parâmetro a ser passado seja uma variável (não podendo ser, por exemplo, um valor literal). Ex.: Caderno Didático PASCAL Página 25
  • 28. 26 Universidade Federal de Santa Maria procedure Troca(var expr1 : string; var expr2 : string); var aux : string; begin aux := expr1; expr1:= expr2; expr2 := aux; end; procedure TrocaTeste(var expr1 : string; var expr2 : string); var aux : string; begin aux := expr1; expr1:= expr2; expr2 := aux; end; ... a := 5; b := 10; x := 23; y := 14; Troca(a,b); //Qual é o valor de a e b agora? TrocaTeste(x, y); //Qual é o valor de x e y agora? Caderno Didático PASCAL Página 26
  • 29. 27 Universidade Federal de Santa Maria CAPITULO IX – Tipos de dados estruturados Um tipo de dado estruturado difere de um tipo de dado simples pelo fato de conter vários componentes ao invés de um só. Entretanto, cada um desses componentes tem, em sua forma mais básica, a característica de um tipo de dado simples, como os que foram apresentados anteriormente. Além disso, os tipos de dados estruturados permitem um uso mais completo da memória do computador, o que não ocorre com os tipos de dados simples, uma vez que usam apenas porções de memória. Com o uso de tipos de dados estruturados é possível, muitas vezes, programar soluções mais elegantes e legíveis aos problemas propostos. Às vezes, a própria implementação de uma determinada solução só é viável se a linguagem for razoavelmente rica em seus tipos de dados. Records (Registros) Quando temos a necessidade de, por exemplo, registrar diversas informações a respeito de um funcionário de uma empresa, os campos necessários são em geral de diversos tipos. Dados como nome, cargo e filiação são informações do tipo string, já o número de dependentes e o salário são de tipos numéricos e assim por diante. Assim, para representarmos em uma única variável as informações de um funcionário, é necessário dispormos de um tipo especial de dado que permita essa agregação. Em linguagem Pascal o tipo record é uma forma de criar uma única estrutura com valores de diferentes tipos de dados, permitindo agregar em uma mesma variável campos heterogêneos. Cada um dos dados de um record é chamado de campo. A estrutura do tipo de dado record pode ser vista como uma sequência de bytes na memória, resultante da agregação de um ou mais itens de dados. Cada item de dados (no caso, cada informação do funcionário), corresponde a um campo do record (registro). Um campo em um registro pode também se constituir de um outro registro. Caderno Didático PASCAL Página 27
  • 30. 28 Universidade Federal de Santa Maria type Funcionario = record nome : string; cargo : string; filiacao : string; dependentes : integer; salario : real; end; var Func : Funcionario; begin Func.nome := JOAO AUGUSTO DA SILVA; Func.cargo := ANALISTA DE SISTEMAS; Func.filiacao := MARCOS E HELENA DA SILVA; Func.dependentes := 2; Func.salario := 2500.54; Writeln(O funcionário , Func.nome, ganha: R$ , Func.salario); end; Arrays (Vetores e Matrizes) Arrays fornecem uma forma de criar variáveis que contenham múltiplos valores, como em uma lista ou tabela, cujos elementos são do mesmo tipo. Possibilita a utilização de variáveis que permitem o armazenamento de dados de forma similar aos conceitos matemáticos de vetores e matrizes. Em linguagem Pascal, a quantidade de elementos de um Array é constante, ou seja, quando declaramos uma array informamos o tamanho e as dimensões que o mesmo terá e todo o espaço necessário será alocado. De forma análoga ao conceito matemático de vetores, o iésimo elemento de um vetor X é representado por X[i], em que i pode variar de i a N, caso N seja a dimensão do vetor. Os códigos abaixo exemplificam arrays de dimensões variadas. var DiasDaSemana : array [1..7] of string; j : integer; begin DiasDaSemana[1] := domingo; DiasDaSemana[2] := segunda-feira; DiasDaSemana[3] := terça-feira; DiasDaSemana[4] := quarta-feira; DiasDaSemana[5] := quinta-feira; DiasDaSemana[6] := sexta-feira; DiasDaSemana[7] := sábado; Writeln(Abaixo estão os dias da semana: ); for j := 1 to 7 do Writeln(DiasDaSemana[j]); end; Caderno Didático PASCAL Página 28
  • 31. 29 Universidade Federal de Santa Maria Uma situação bastante interessante no uso desse tipo de dado é aquela que simula matrizes matemáticas, ou seja, quando os elementos de um vetor são também vetores: Matriz : array [1..3,1..4] of integer; //Duas dimensões // 3 linhas e 4 colunas O exemplo anterior cria um vetor bidimensional (tabela). Para referenciarmos as posições da matriz devemos informar suas coordenadas de linha e coluna: 67 56 78 32 23 56 98 09 76 89 45 76 Writeln(Matriz[2,3]); //Escreve na tela o conteúdo da linha 2 col. 3 //Resultado = 98 Também é possível especificar matrizes com outras dimensões, e sua aplicação geralmente está relacionada à aplicações gráficas em três dimensões ou outros algoritmos mais complexos (cruzamentos de dados, por exemplo). Cubo : array [1..5,1..5,1..5] of integer; //Três dimensões Caderno Didático PASCAL Página 29
  • 32. 30 Universidade Federal de Santa Maria CAPITULO X – Arquivos Comumente aplicações precisam gravar informações para recuperá-las em outro momento. Quando as informações no qual estamos atuando precisam ser persistidas fisicamente para posterior recuperação faz-se necessário a utilização de arquivos. Informações gravadas em arquivos não ficam limitadas ao tamanho da memória RAM e sim ao tamanho do meio físico utilizado para sua gravação (disco rígido, disco flexível, pen-drive, etc.). Em linguagem Pascal a manipulação de um arquivo pode acontecer de duas formas: arquivo texto (text) ou arquivo binário (file of <tipo>). Os arquivos binários são formados por uma estrutura de elementos do mesmo tipo, dispostos de forma sequencial. Abaixo a sintaxe: type <arquivo> = [text][file [of <tipo>]]; var <variavel> : <arquivo>; ou <variavel> : [text][file [of <tipo>]]; O código a seguir declara uma variável que representará um arquivo binário de inteiros: type arquivoDeInteiros = file of integer; var arquivo : arquivoDeInteiros; A declaração é equivalente a essa: var arquivo : file of integer; A seguir a declaração de um arquivo texto (de duas formas equivalentes): type arquivoDeInteiros = text; var arquivo : arquivoDeInteiros; Ou (forma equivalente): var arquivo : text; Caderno Didático PASCAL Página 30
  • 33. 31 Universidade Federal de Santa Maria Além de tipos básicos podemos utilizar tipos compostos para definição de arquivos binários: type Funcionario = record nome : string; cargo : string; filiacao : string; dependentes : integer; salario : real; end; var arquivo : file of Funcionario; Comandos e Operações sobre Arquivos Assign(variavel, arquivo) Associa um nome lógico de arquivo ao arquivo físico. O primeiro parâmetro é a indicação de uma variável do tipo arquivo, e o parâmetro arquivo é uma string com o caminho e nome do arquivo a ser manipulado. var arquivoDeFuncionarios : file of Funcionario; begin Assign(arquivoDeFuncionarios, c:dadosbddados_func.bin); ... end. Rewrite(variavel_arquivo) Cria um arquivo para uso, utilizando o nome associado ao parâmetro variável_arquivo. Caso o arquivo já exista, esta instrução o apagará para criá-lo novamente. Rewrite(arquivoDeFuncionarios); Reset(variavel_arquivo) Abre um arquivo existente, colocando-o disponível para leitura e gravação, utilizando o nome associado ao parâmetro variavel_arquivo. Caso o arquivo não exista a aplicação acusará um erro. Reset(arquivoDeFuncionarios); Caderno Didático PASCAL Página 31
  • 34. 32 Universidade Federal de Santa Maria Append(variavel_arquivo) Abre um arquivo existente, colocando-o disponível para leitura e gravação, utilizando o nome associado ao parâmetro variavel_arquivo e posicionando o ponteiro lógico no final do arquivo. Assim como o comando Reset, caso o arquivo não exista a aplicação acusará um erro. Append(arquivoDeFuncionarios); Write(variavel_arquivo, variavel_ou_dado) Escreve a informação (dado) no arquivo indicado pelo parâmetro variavel_arquivo. Write(arquivo_texto, Mensagem); Read(variavel_arquivo, variavel_destino) Recupera a informação do arquivo e armazena na variável indicada como parâmetro. A leitura ocorre na possição corrente do arquivo. Read(arquivoDeFuncionarios, func1); Close(variavel_arquivo) Fecha um arquivo em uso dentro de um programa. O encerramento dos arquivos é muito impotante, pois indica ao sistema operacional que aquele arquivo está liberado para outras operações, nenhum programa deve ser encerrado sem antes fechar os arquivos abertos. Close(arquivoDeFuncionarios); Eof(variavel_arquivo) Abreviatura para End of File. Retorna verdadeiro (true) se o ponteiro lógico está posicionado no último registro do arquivo. Eof(arquivoDeFuncionarios); Caderno Didático PASCAL Página 32
  • 35. 33 Universidade Federal de Santa Maria FileSize(variavel_arquivo) Retorna o número de registros do arquivo indicado como parâmetro. Se o arquivo estiver vazio a função irá retomar o valor zero. Se for utilizada com arquivos não tipados, esta função considera que os registros deste arquivo possuem o tamanho de 128 caracteres. FileSize(arquivoDeFuncionarios); Seek(variavel_arquivo, posicao) Posiciona o cursor/ponteiro lógico na posição indicada. //Posiciona o ponteiro lógico no último registro do arquivo FileSize(arquivoDeFuncionarios, FileSize(arquivoDeFuncionarios)); //Posiciona o ponteiro lógico no início do arquivo FileSize(arquivoDeFuncionarios, 0); FilePos(variavel_arquivo) Retorna a posição do cursor/ponteiro lógico no arquivo indicado. x := FilePos(arquivoDeFuncionarios); IOResult Informa um código de erro quando são realizadas operações de Entrada/Saída. Se ioresult não for igual a zero, significa que houve algum erro (geralmente é usado para testar a existência ou inexistência de um arquivo na hora de sua abertura) program gravar_arquivo; var arquivo : Text; begin assign(arquivo,C:tempArquivo.txt); {$i-} //Desabilita a verificação de erros de entrada e saída append(arquivo); //Tenta abrir o arquivo {$i+} //Habilita a verificação de erros de entrada e saída if IoResult > 0 then //Se der um erro rewrite(arquivo); //Cria um arquivo novo writeln(arquivo,Teste); close(arquivo); end. Caderno Didático PASCAL Página 33
  • 36. 34 Universidade Federal de Santa Maria Anexo I Tabela de códigos ASCII (fonte: http://www.tabelaascii.com/) American Standard Code for Information Interchange (ASCII), que em português significa "Código Padrão Americano para Intercâmbio de Informação") é uma codificação de caracteres de sete bits baseada no alfabeto inglês. Os códigos ASCII representam texto em computadores, equipamento de comunicações, entre outros dispositivos que trabalham com texto. Estes dispositivos só percebem números, sendo assim um código ASCII é uma representação numérica de um carácter, tal como um a ou um t. A maioria dos actuais esquemas de codificação modernos, com suporte para muitos caracteres, tiveram origem no código ASCII. ASCII incluí definições para 128 caracteres: 33 caracteres de controle não imprimíveis (a maioria obsoletos) que afetam a forma como o texto é processado; 94 são caracteres imprimíveis, e o espaço é considerado invisível. Atualmente o método de codificação mais comum é o UTF-8. Cód. Caracter Designação Cód. Caracter Cód. Caracter Cód. Caracter 000 CTRL-@ Null 032 (BRANCO) 064 @ 096 ` 001 CTRL-A Start Of Header 033 ! 065 A 097 a 002 CTRL-B Start Of Text 034 " 066 B 098 b 003 CTRL-C End Of Text 035 # 067 C 099 c 004 CTRL-D End Of Transmition 036 $ 068 D 100 d 005 CTRL-E Enquire 037 % 069 E 101 e 006 CTRL-F Acknowledge 038 & 070 F 102 f 007 CTRL-G Bell 039 071 G 103 g 008 CTRL-H Back Space 040 ( 072 H 104 h 009 CTRL-I Horizontal Tabulation 041 ) 073 I 105 i 010 CTRL-J Line Feed 042 * 074 J 106 j 011 CTRL-K Vertical Tabulation 043 + 075 K 107 k 012 CTRL-L Form Feed 044 , 076 L 108 l 013 CTRL-M Carriage Return 045 - 077 M 109 m 014 CTRL-N Shift Out 046 . 078 N 110 n 015 CTRL-O Shift-In 047 / 079 O 111 o 016 CTRL-P Data Link Escape 048 0 080 P 112 p 017 CTRL-Q Device 1 049 1 081 Q 113 q 018 CTRL-R Device 2 050 2 082 R 114 r 019 CTRL-S Device 3 051 3 083 S 115 s 020 CTRL-T Device 4 052 4 084 T 116 t 021 CTRL-U Not Acknowledge 053 5 085 U 117 u 022 CTRL-V Synchronous Idle- 054 6 086 V 118 v 023 CTRL-W End Of Transmition Block 055 7 087 W 119 w 024 CTRL-X Cancel 056 8 088 X 120 x 025 CTRL-Y End Of Medium 057 9 089 Y 121 y 026 CTRL-Z Substitute 058 : 090 Z 122 z 027 CTRL-[ Escape 059 ; 091 [ 123 { 028 CTRL- File Separator 060 < 092 124 | 029 CTRL-] Group Separator 061 = 093 ] 125 } 030 CTRL-^ Register Separator 062 > 094 ^ 126 ~ 031 CTRL-_ Unit Separator 063 ? 095 _ 127 DEL Tabela ASCII original Caderno Didático PASCAL Página 34
  • 37. 35 Universidade Federal de Santa Maria Com o advento e popularização dos microcomputadores pessoais tornou-se necessário representar caracteres acentuados em função dos mesmos estarem atingindo mercados não concebidos originalmente, e que se utilizavam de uma gama maior de tipos imprimíveis. Partindo dessa necessidade a IBM ao lançar o PC (Personal Computer) ampliou a tabela ASCII dando a ela a capacidades de 256 caracteres codificados, incluindo além de caracteres acentuados uma série de caracteres semi-gráficos. Tabela ASCII Estendida (CP 437) Caderno Didático PASCAL Página 35
  • 38. 36 Universidade Federal de Santa Maria A ampliação da tabela ASCII, contemplava muitos caracteres acentuados, porém ainda não acomodava todas as possibilidades, principalmente para os idiomas de origem latina (p. ex.: ã; õ; Ã; Õ; etc.), além de que muitos caracteres maiúsculos e acentuados não foram contemplados. Diante dessa necessidade, a Microsoft implementou o conceito de páginas de código, dessa forma poderiam existir diversas tabelas ASCII estendidas para cada necessidade. Aquela original recebeu a denominação de ASC 437 (código de página para US) e aquela que melhor nos serve para os países da América Latina recebeu a denominação ASC 850 (código de página latin I), mostrada abaixo: Cód. Caracter Cód. Caracter Cód. Caracter Cód. Caracter 128 Ç 160 á 192 + 224 Ó 129 ü 161 í 193 - 225 ß 130 é 162 ó 194 - 226 Ô 131 â 163 ú 195 + 227 Ò 132 ä 164 ñ 196 - 228 õ 133 à 165 Ñ 197 + 229 Õ 134 å 166 ª 198 ã 230 µ 135 ç 167 º 199 Ã 231 þ 136 ê 168 ¿ 200 + 232 Þ 137 ë 169 ® 201 + 233 Ú 138 è 170 ¬ 202 - 234 Û 139 ï 171 ½ 203 - 235 Ù 140 î 172 ¼ 204 ¦ 236 ý 141 ì 173 ¡ 205 - 237 Ý 142 Ä 174 « 206 + 238 ¯ 143 Å 175 » 207 ¤ 239 ´ 144 É 176 _ 208 ð 240 145 æ 177 _ 209 Ð 241 ± 146 Æ 178 _ 210 Ê 242 _ 147 ô 179 ¦ 211 Ë 243 ¾ 148 ö 180 ¦ 212 È 244 ¶ 149 ò 181 Á 213 i 245 § 150 û 182 Â 214 Í 246 ÷ 151 ù 183 À 215 Î 247 ¸ 152 ÿ 184 © 216 Ï 248 ° 153 Ö 185 ¦ 217 + 249 ¨ 154 Ü 186 ¦ 218 + 250 · 155 ø 187 + 219 _ 251 ¹ 156 £ 188 + 220 _ 252 ³ 157 Ø 189 ¢ 221 ¦ 253 ² 158 × 190 ¥ 222 Ì 254 _ 159 ƒ 191 + 223 _ 255 Tabela ASCII Estendida Código de Página Latin I (CP 850) Caderno Didático PASCAL Página 36
  • 39. 37 Universidade Federal de Santa Maria Referências Bibliográficas BOENT, A. Aprendendo a Programar em Pascal. Ed. Brasport, 2003. CANTÙS, M. Essential Pascal. 4ª Edição. Paperback, 2008. EVARISTO, J. Programando com Pascal. 2ª Edição. Ed. Book Express, 2004. GUIMARAES, A. M. Programando O Computador Com Pascal - Um Ambiente Para Autoaprendizagem. Ed. UFMG, 2008. LAUREANO, M. Lógica de Programação - Uma Abordagem Em Pascal. Ed. Ciência Moderna, 2010. MANZANO, J. A.; YAMATUMI, W. Y. Free Pascal - Programação de Computadores. Ed. Érica, 2007. WIRTH, N. Programação Sistemática em Pascal. 6ª Edição. Ed. Campus, 1989. Caderno Didático PASCAL Página 37

×