eng06842 - prof. jacson...
TRANSCRIPT
UNIVERSIDADE FEDERAL DO ESPÍRITO SANTOCENTRO DE CIÊNCIAS AGRÁRIASDEPARTAMENTO DE ENGENHARIA RURAL
ENG06842
PROGRAMAÇÃO I
PARTE 2
Prof. Geraldo Regis Mauri
CCA-UFESAgosto - 2009
ENG06842 – Programação I
Sumário
7.Linguagens de programação e execução de programas ........................................................... 3 7.1.Introdução ............................................................................................................................. 3 7.2.Tradutores: compiladores e interpretadores .......................................................................... 5 7.3.Compilador PASCAL ........................................................................................................... 6 7.4.Exercícios ............................................................................................................................ 14 8.A Linguagem Pascal .............................................................................................................. 16 8.1.Introdução ........................................................................................................................... 16 8.2.Tipos de dados simples ....................................................................................................... 16 8.3.Mapeamento Portugol x Pascal ........................................................................................... 18 8.4.Unidades pré-definidas ....................................................................................................... 21 8.5.Palavras reservadas ............................................................................................................. 22 8.6.Funções pré-definidas ......................................................................................................... 22 8.7.Tipos definidos pelo usuário ............................................................................................... 29 8.8.Exercícios ............................................................................................................................ 31 9.Estruturas de dados ................................................................................................................ 33 9.1.Introdução ........................................................................................................................... 33 9.2.Variáveis compostas homogêneas ...................................................................................... 33 9.3.Variáveis compostas heterogêneas ..................................................................................... 39 9.4.Algoritmos de classificação e busca ................................................................................... 46 9.5.Exercícios ............................................................................................................................ 48 10.Modularização ...................................................................................................................... 51 10.1.Introdução ......................................................................................................................... 51 10.2.Procedimentos ................................................................................................................... 52 10.3.Funções ............................................................................................................................. 53 10.4.Escopo de variáveis ........................................................................................................... 56 10.5.Parâmetros ......................................................................................................................... 56 10.6.Recursividade .................................................................................................................... 60 10.7.Exercícios .......................................................................................................................... 60 11.Armazenamento de dados .................................................................................................... 67 11.1.Arquivos ............................................................................................................................ 67 11.2.Exercícios .......................................................................................................................... 76 Referências ................................................................................................................................ 78 Apêndice A – Mensagens de erro do Turbo Pascal .................................................................. 79 Apêndice B – Tabela de códigos ASCII ................................................................................... 82
2
ENG06842 – Programação I
7. Linguagens de programação e execução de programas
7.1. Introdução
A linguagem de programação é o meio pelo qual se pode indicar os
“passos” que devem ser realizados pelo computador para resolver
problemas. Utilizando as linguagens de programação, pode-se colocar os
algoritmos numa forma que o computador possa interpretá-los, ou seja, na
forma de programas computacionais.
Para que o computador execute o algoritmo proposto, as operações
devem ser transcritas para uma linguagem que a máquina consiga
compreender. Na realidade, os computadores só podem executar
algoritmos expressos em linguagem de máquina, que se constitui de um
conjunto de instruções capazes de ativar diretamente os dispositivos
eletrônicos do computador.
Características da Linguagem de Máquina:
• diferente para cada tipo de computador, dependendo de sua
arquitetura;
• extremamente rudimentar, onde até as operações mais simples têm
que ser expressas em termos de registros, acumuladores e outros
dispositivos de máquina;
• totalmente expressa em forma numérica - sistema de numeração
binário (0s e 1s) ou hexadecimal.
Conseqüentemente, é uma linguagem de difícil aprendizado e pouco
expressiva para as pessoas. Para tornar a atividade de programação mais
acessível, foram desenvolvidas outras linguagens, denominadas de
“Linguagens de Programação”, que funcionam como uma forma
alternativa de se comunicar com o computador.
3
ENG06842 – Programação I
As linguagens de programação são compostas por um grupo de elementos
e regras que permitem a construção das instruções utilizadas para
resolver os problemas computacionais. Com elas, pode-se construir
programas que devem ser, posteriormente, transformados em instruções
em Linguagem de Máquina. Para realizar a transformação, cada linguagem
de programação possui um programa-suporte denominado,
genericamente, de tradutor.
Linguagem de Programação de Baixo Nível: Conhecida como Linguagem
Assembler ou Linguagem de Montagem, ou ainda, Linguagem Simbólica.
Utiliza números binários, hexadecimais, alguns símbolos e letras para
compor os programas. Está muito próxima da Linguagem de Máquina,
onde cada instrução simbólica corresponde, praticamente, a uma
instrução de máquina. Para transformar o programa escrito em Linguagem
Assembler em código de máquina executável, é utilizado um programa-
suporte denominado de MONTADOR.
Linguagens de Programação de Alto Nível: São linguagens de
programação que utilizam notações matemáticas e grupos de palavras
para representar as instruções de máquina, tornando o processo de
programação mais próximo do entendimento humano. Muitas destas
linguagens foram desenvolvidas para atender os problemas de áreas de
aplicação específicas, como, por exemplo, linguagens para aplicações
comerciais, científicas, administrativas, de ensino, etc. A primeira
linguagem de alto nível foi desenvolvida em 1957 - denominada de
FORTRAN (Formula Translator) - e destina-se a aplicações científicas e de
engenharia.
Principais vantagens das linguagens de Alto Nível:
• facilidade de entendimento e uso;
• independência de máquina (é praticamente a mesma, não
importando o computador utilizado).
4
ENG06842 – Programação I
Para transformar os programas escritos com Linguagens de Alto Nível em
códigos de máquina, é usado um programa-suporte denominado
TRADUTOR (Compilador ou Interpretador).
7.2. Tradutores: compiladores e interpretadores
Para executar um programa escrito numa linguagem de alto nível é
preciso primeiro traduzir o código-fonte para código-objeto. O processo de
tradução pode dar-se em tempo de execução caso a linguagem use um
interpretador (traduz e executa instrução a instrução), ou todas as
instruções podem ser traduzidas antes que se inicie a execução do
programa, o que ocorre no caso de linguagens que usam tradutores do
tipo compilador.
Código-fonte: não é executável diretamente pelo processador - permite
apenas que o programador consiga definir o programa em uma forma
legível aos humanos.
Código-objeto: é o código produzido pelo compilador; é uma forma
intermediária, similar a linguagem de máquina do computador. Apesar de
estar representado em binário, não é executável diretamente pelo
processador, pois normalmente, o código-objeto referencia partes de
programa que não estão necessariamente definidas no mesmo arquivo
que o gerou, por exemplo, arquivos de bibliotecas de sub-rotinas.
Editores de ligação (ou linkeditores ) : Um programa que reúne módulos
compilados e arquivos de dados para criar um programa executável. Os
linkeditores têm também outras funções, como a criação de bibliotecas.
Compilador: No sentido mais geral, qualquer programa que transforme um
conjunto de símbolos em outro obedecendo a uma série de regras
sintáticas e semânticas; no sentido mais comum, um programa que traduz
5
ENG06842 – Programação I
todo o código-fonte de programas escritos numa linguagem de alto nível
em código-objeto antes da execução do programa. Ou seja, traduz o
programa escrito em linguagem de alto nível (código-fonte) para um
programa equivalente escrito em linguagem de máquina (código-objeto).
Interpretador: traduz e envia para execução, instrução por instrução e o
programa permanece na forma fonte.
7.3. Compilador PASCAL
O Turbo Pascal é um programa que contém, além do compilador PASCAL,
um ambiente completo de programação, com editor de programa,
depurador de erros, sistema de ajuda, etc.
Existem diversos compiladores para a linguagem Pascal, porém para esse
curso, será utilizado como padrão o compilador Borland Turbo Pascal 7.0,
pois este é um programa gratuito e de simples utilização. Algumas dicas
para aquisição e instalação deste programa são apresentadas no Erro:
Origem da referência não encontrada.
O ambiente de desenvolvimento do Turbo Pascal (ver figura abaixo) é
composto de um editor de texto, um compilador, um programa ligador
(linkeditor) e um depurador (debugger), harmonicamente integrados.
6
ENG06842 – Programação I
Após editar um arquivo, é natural compilá-lo e rodá-lo, para ver os
resultados do programa. Durante esse processo, o Turbo Pascal irá
procurar erros em tempo de compilação. Senão houver erros, o programa
rodará normalmente. Caso contrário, o processo de compilação será
interrompido e o compilador indicará o erro e a sua posição. Os programas
podem conter três tipos de erros:
Erro de sintaxe: ocorre quando se viola uma regra da linguagem. Ao
encontrar um destes erros, o Turbo Pascal interrompe a compilação do
programa, dá uma mensagem com o número e a descrição do erro, e
deixa o cursor piscando no item do programa que permitiu a detecção do
erro. Deve-se observar que este item pode não estar errado, mas apenas
permitiu detectar o erro. O Turbo Pascal não executa um programa
enquanto houver erros de sintaxe.
Erro de semântica: é um erro que o programa detecta durante a sua
execução, interrompendo-a; por exemplo, quando o programa é levado a
ler um arquivo inexistente, a tirar a raiz quadrada de um número negativo,
a dividir por zero, etc. Ocorrendo um erro de semântica, o Turbo Pascal
interrompe a execução do programa e mostra a descrição do erro, com o
cursor piscando no início da linha em que ele foi detectado.
7
ENG06842 – Programação I
Erro de lógica: aparece em programas, sintática e semanticamente
corretos, que, apesar disso, não produzem os resultados desejados. São
devidos a instruções corretas, para o computador, mas que não são
apropriadas para a solução lógica do problema que motivou o programa. A
correção dos erros de lógica é muitas vezes trabalhosa e demorada. Para
ajudar a depuração de erros de lógica, o Turbo Pascal oferece diversos
recursos que permitem ver e acompanhar o que ocorre durante a
execução de um programa.
Erros de sintaxe e semântica não são preocupantes, pois o próprio
computador os localiza e os identifica. Uma lista com os principais erros
apresentados no Turbo Pascal são descritos no Apêndice A – Mensagens
de erro do Turbo Pascal.
Para compilar um programa, deve-se utilizar a opção COMPILE (compilar)
do Menu COMPILE ou pressione Alt+F9. Caso seja detectado algum erro
(de sintaxe), este será exibido na tela, caso contrário, será exibida uma
mensagem dizendo que o programa foi compilado com sucesso. A partir
daí, basta pressionar qualquer tecla para fechar essa mensagem e
executar o programa.
Para executar um programa, deve-se utilizar a opção RUN (executar) do
Menu RUN ou pressione Ctrl+F9. Ao terminar a execução, o Pascal volta
para a janela de edição. Para ver os resultados do programa, basta
pressionar Alt+F5.
O Turbo Pascal 7.0 também oferece alguns recursos para depuração do
programa. Um desses recursos é a utilização de break points (pontos de
parada). Para sua utilização, basta clicar com o botão direito do mouse
sobre a linha onde a execução do programa deverá parar, e selecionar a
opção Toogle breakpoint (ou pressionar Ctrl+F8). A linha ficará vermelha,
e quando o programa for executado, assim que seu fluxo de execução
chegar nessa linha, será possível acompanhar passo-a-passo o restante da
execução do programa. Para isso, basta pressionar a tecla F8, que cada
instrução subseqüente será executada uma a uma. Para verificar o
8
ENG06842 – Programação I
conteúdo das variáveis presentes na instrução atual, basta pressionar
Ctrl+F4, ou clicar com o botão direito e selecionar a opção
Evaluate/Modify.
A seguir são descritos os menus do Turbo Pascal 7.0.
File – esta opção possibilita executar operações de controle com
arquivos.
o New – criar um novo programa.
o Open – abrir um programa existente.
o Save – salvar um programa em disco.
o Save as – salvar um programa em disco com outro nome.
o Save all – salvar todos os programas modificados.
o Change dir – mudar o diretório de trabalho.
o Print – imprimir o programa da janela ativa.
o Print setup – configurar o uso de outra impressora.
o DOS shell – sair temporariamente para o sistema operacional
(DOS).
o Exit – finalizar a execução do Turbo Pascal.
Edit – esta opção possibilita executar operações do editor do
programa, sendo possível remover, movimentar e copiar textos que
estejam selecionados.
o Undo – desfazer uma operação com texto.
o Redo – refazer uma operação com texto.
9
ENG06842 – Programação I
o Cut – remover um texto previamente selecionado, enviando-o
para área de transferência.
o Copy – copiar um texto selecionado do editor para uma área
de transferência.
o Paste – copiar um texto da área de transferência para o editor.
o Clear – remover o texto selecionado sem transferi-lo para a
área de transferência.
o Show Clipboard – apresentar o conteúdo existente na área de
transferência.
Search – esta opção possibilita executar operações de busca, troca e
deslocamento dentro de um programa.
o Find – localizar uma seqüência de caracteres em um
programa.
o Replace – substituir uma seqüência de caracteres por outra.
o Search again – repetir a última busca.
o Go to line number – posicionar-se em uma determinada linha
do programa.
o Show last compiler error – mostrar o último erro de
compilação, quando ocorrer.
o Find error – posicionar-se na última posição de erro
encontrada pelo compilador.
o Find procedure – localizar uma sub-rotina dentro do programa
no momento de depuração de um programa.
Run – esta opção possibilita colocar em execução o programa da
janela ativa.
10
ENG06842 – Programação I
o Run – compilar e executar o programa.
o Step over – rodar o programa passo a passo com exceção das
sub-rotinas existentes.
o Trace into – rodar o programa passo a passo inclusive as suas
sub-rotinas.
o Go to cursor – rodar o programa até a posição em que está o
cursor.
o Program reset – interromper a execução de um programa
durante sua depuração.
o Parameters – efetuar a passagem de parâmetros.
Compile – esta opção possibilita compilar o programa.
o Compile – compilar o programa da janela ativa.
o Make – recompilar apenas os programas alterados.
o Build – recompilar todos os programas.
o Destination – determinar se o programa será compilado
somente em memória ou disco.
o Primary file – determinar numa lista de arquivos qual será o
arquivo principal que será carregado primeiro no processo de
compilação.
o Clear primary file – limpar o arquivo anteriormente
configurado como o arquivo primário.
o Information – obter informações a respeito da última
compilação executada.
11
ENG06842 – Programação I
Debug – esta opção possibilita depurar o programa para facilitar a
localização de erros lógicos.
o Breakpoint – colocar ou retirar um ponto de parada (exame)
na depuração de um programa.
o Call stack – apresentar uma janela com a seqüência de
chamadas efetuadas de sub-rotinas.
o Register – visualizar a janela de registradores da CPU.
o Watch – abrir a janela de acompanhamento de valores nas
variáveis do programa.
o Output – abrir uma janela para apresentar as telas de saída do
programa em execução ou depuração.
o User Screen – exibir na sua totalidade a tela do usuário.
o Evaluate/modify – permite efetuar a avaliação de expressões,
constantes ou variáveis.
o Add watch – possibilidade de incluir expressões na tela de
vigia.
o Add breakpoint – permite a inclusão de um ponto de parada
quando for executado o programa.
Tools – esta opção possibilita a utilização de ferramentas
configuradas pelo usuário.
o Messagens – abrir uma janela para a apresentação de
mensagens.
o Go to next – visualizar a próxima mensagem da janela de
mensagens.
12
ENG06842 – Programação I
o Go to previous – visualizar a mensagem anterior da janela de
mensagens.
o Grep – efetuar a busca de seqüências de caracteres em
programas gravados através do utilitário GREP.EXE.
Options – esta opção permite configurar a forma de trabalho do
ambiente do Turbo Pascal.
o Compiler – alterar o estado das diretivas de compilação.
o Memory sizes – definir o tamanho de memória.
o Linker – a possibilidade de usar ou não o recurso de link.
o Debugger – estabelecer critérios de depuração.
o Directories – determinar os diretórios de trabalho.
o Browser – especifica configurações globais do visualizador.
o Tools – efetuar a manutenção do menu de ferramentas.
o Environment – efetuar mudanças no ambiente de trabalho
(Preferências, Editor, Mouse, Inicialização e Cores) do Turbo
Pascal conforme necessidade do usuário.
o Open – a abertura do arquivo de configuração.
o Save – gravar o arquivo de configuração.
o Save as – gravar o arquivo de configuração com outro nome.
Window – esta opção possibilita o controle das janelas que estejam
abertas.
o Tile – ordenar as janelas lado a lado.
o Cascade – ordenar as janelas em cascata.
13
ENG06842 – Programação I
o Close all – fechar todas as janelas.
o Refresh display – redesenhar a janela ativa.
o Size/Move – movimentar ou alterar o tamanho de uma janela.
o Zoom – alterar o tamanho de uma janela para o tamanho
máximo ou para o tamanho preestabelecido.
o Next – selecionar a próxima janela como ativa.
o Previous – selecionar a janela anterior como ativa.
o Close – fechar a janela ativa.
o List – apresentar a listagem das janelas que estejam abertas.
Help – esta opção permite executar o modo de ajuda do Turbo
Pascal. O modo de ajuda poderá ser executado de qualquer parte do
programa com a tecla de função F1 ou Ctrl+F1 para visualizar
explicações de instruções que estejam marcadas com o
posicionamento do cursor sobre elas.
o Contents – apresenta o sumário.
o Index – apresenta todas as instruções em ordem alfabética.
o Error messages – apresenta uma lista de erros de execução e
de compilação.
o About – informações sobre o Turbo Pascal 7.0.
7.4. Exercícios
1. Defina, com suas palavras, os seguintes termos:
a) programa
b) linguagem de programação
14
ENG06842 – Programação I
c) tradutor
2. Qual a diferença entre linguagem de baixo nível e linguagem de alto
nível?
3. Qual a diferença entre código-fonte e código-objeto?
4. Explique a diferença entre compilador e interpretador.
5. Diferencie com suas palavras os três tipos de erros encontrados em
programas.
15
ENG06842 – Programação I
8. A Linguagem Pascal
8.1. Introdução
A linguagem de programação PASCAL foi criada para ser uma ferramenta
educacional, isto no início da década de 70 pelo Prof. Niklaus Wirth da
Universidade de Zurique. Foi batizada pelo seu idealizador 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 na época, ALGOL e PLI.
O próprio Niklaus Wirth diz que esta linguagem foi criada
simultaneamente para ensinar programação estruturada e para ser
utilizada em sua fábrica de software.
A linguagem é extremamente bem estruturada e muito adequada para
ensino de linguagens de programação. É provavelmente uma das
linguagens mais bem resolvidas entre as linguagens estruturadas, e
certamente um dos exemplos de como uma linguagem especificada por
uma pessoa pode ser bem melhor do que uma linguagem especificada por
um comitê.
Apesar de seu propósito inicial, o PASCAL começou a ser utilizado por
programadores de outras linguagens, tornando-se, para surpresa do
próprio Niklaus, um produto comercial.
Comercialmente, a linguagem foi sucedida pela criação da linguagem
Object Pascal, atualmente utilizada nas IDEs Borland Delphi, Kylix e
Lazarus. Academicamente, seus sucessores são as linguagens
subseqüentes de Niklaus Wirth: Modula-2 e Oberon.
8.2. Tipos de dados simples
integer - Envolve os números inteiros. A partir da versão 5.0 do Turbo
Pascal passaram a existir também outros tipos de números inteiros:
shortint, byte, word e longint.
16
ENG06842 – Programação I
Exemplos: -45, 1, 138, 0, -2.
Tipo Valor mínimo Valor máximo Bytes ocupados
shortint -128 127 1byte 0 255 1integer -32768 32767 2word 0 65535 2longint -2147483648 2147483647 4
real - abrange os números reais. A partir da versão 5.0 passaram a existir
também outros tipos de números reais: single, double, extended e comp.
Exemplos: 4.5, -32.0, .5, 7.8E3, 21E+3, -315E-3.
TipoValor
mínimoValor
máximoBytes
ocupados
Dígitos significativo
sreal +-2.9 x 10-39 -+1.7 x 1038 6 11-12single +-1.5 x 10-45 +-3.4 x 1038 4 7-8double +-5.0 x 10-324 +-1.7 x 10308 8 15-16extended +-3.4 x 10-
4932+-1.1 x 104932 10 19-20
comp -263 + 1 263 - 1 8 19-20
boolean - representa um valor lógico (booleano). Utiliza apenas duas
constantes lógicas: true (verdadeiro) e false (falso).
char - representa um único caractere, escrito entre apóstrofos ( ‘ ’ ). A
maioria dos computadores utiliza a tabela de códigos ASCII (ver Apêndice
B – Tabela de códigos ASCII) para representar todos os caracteres
disponíveis. Qualquer caractere poderá ser representado pelo seu código
ASCII em decimal, precedido por #, ou em hexadecimal, precedidos por #
e $.
Exemplos: ‘A’, ‘B’, ‘a’, ‘1’, ‘@’, ‘ ’, #65 (é o caractere A).
17
ENG06842 – Programação I
string - formado por um conjunto de elementos do tipo char. O tamanho
máximo é de 255 caracteres. Também pode apresentar um tamanho pré-
definido: string[5], por exemplo (máximo de 5 caracteres).
Exemplos: ‘CPU’, ‘Processamento de Dados’, ‘123’.
8.3. Mapeamento Portugol x Pascal
A passagem de um código em Portugol para a linguagem Pascal é
praticamente direta, como se fosse uma simples tradução de português
para inglês. Entretanto, algumas estruturas devem ser cuidadosamente
observadas. A seguir são apresentadas as principais regras para realizar o
mapeamento de Portugol para Pascal.
PORTUGOL PASCAL
algoritmo CALCULA_MEDIA;var
P1, P2, P3, P4, MEDIA: real;in icio
leia (P1);leia (P2);leia (P3);leia (P4);MEDIA (P1 + P2 + P3 + p4) /
4;escreva (MEDIA);se MEDIA ≥ 7,0 então escreva (APROVADO);senão escreva (REPROVADO);fim-se;
fim.
program CALCULA_MEDIA;var
P1, P2, P3, P4, MEDIA: real;begin
read (P1);read (P2);read (P3);read (P4);MEDIA := (P1 + P2 + P3 + p4) /
4;write (MEDIA);if MEDIA ≥ 7,0 then write (‘APROVADO’)else write (‘REPROVADO’);
end.
No exemplo acima, nota-se claramente que é feita um tradução
português-inglês do algoritmo. Entretanto, deve-se observar as
equivalências definidas na tabela abaixo:
PORTUGOL PASCALalgoritmo program
inicio beginfim endleia read
escreva write
18
ENG06842 – Programação I
:=se if
então thensenão elsecaso case
enquanto ... faça while ... dorepita ... até repeat ... until
para ... até ... faça for ... to ... doComo pode ser observado no exemplo anterior, a palavra fim-se não é
usada em Pascal, pois deve-se entender que apenas uma instrução será
executada após o if e o else. Caso seja necessária a execução de mais de
uma instrução dentro do if, por exemplo, deve-se definir um “bloco”
(conjunto de comandos delimitados pelas palavras begin e end) através
dos comandos begin e end. Exemplos:
if condição1 then begin
comando 1; if condição2 then
comando 2;end
else comando 3;
Obs.: O comando anterior ao “else” nunca terminará com “;”. No caso
acima o “end” anterior ao “else” não termina com “;”.
Exemplos:
if condição then
comando 1
else
comando 2;
if condição then begin
comando 1; comando 2;...
endelse
begincomando 3; comando 4;...
end;
19
ENG06842 – Programação I
Resumindo então, utiliza-se a definição de blocos apenas nos casos onde
mais de uma instrução deverá ser executada. Esse conceito de blocos
também é usado nas estruturas de repetição.
Os comandos read e write podem ser substituídos pelos comandos readln
e writeln, respectivamente. Esses novos comandos saltam uma linha após
sua execução. Ex: writeln(‘teste’); Esse comando escreve teste e pula para
a linha abaixo na tela.
No comando write, pode-se definir o formato de saída das variáveis
numéricas (casas decimais, com arredondamento), pois no seu modo
padrão, os valores aparecerão em notação científica. Ex: Seja a variável a
= 2.36780984.
write(a); { Será mostrado o valor: 2.3678098400E+00 }
write(a:3:2); { Será mostrado o valor: 2.37 }
No caso do comando for (para), o contador é atualizado, por padrão, de 1
em 1. Entretanto, esse comando pode ser usado com TO, onde a variável
de controle assume valores crescentes e com DOWNTO, onde a variável
assume valores decrescentes. Exemplos:
for identificador := valor1 to/downto valor2 do { escolher entre to e
downto }
comando ; { ou bloco de comandos, usando begin e end
}
Exemplo: fatorial de N (inteiro maior que 1).
…readln(N);fat := 1;for I := N downto 1 do
fat := fat * I;writeln(‘O fatorial de ’, N:5, ‘ é ’, fat:5);...
20
ENG06842 – Programação I
8.4. Unidades pré-definidas
O Turbo Pascal possui diversas unidades predefinidas: system, printer, crt,
dos, overlay e graph são as principais. Os identificadores usados nestas
unidades geralmente são formados por palavras compostas em inglês que
lembram seu significado.
Uma unidade (unit) nada mais é que um conjunto de procedimentos e
funções que trabalham sob um mesmo objetivo. É uma coleção de
declarações de constantes, tipos, variáveis, funções e procedimentos,
compilada separadamente. Algumas destas declarações são de uso
interno da unidade, enquanto outras são visíveis, isto é, podem ser usadas
por programas ou outras unidades.
Por exemplo, a unit graph possui comandos para criação de desenhos,
figuras, barras, entre outros; a unit crt possui os procedimentos básicos
de entrada e saída de dados e comandos de controle do monitor. Dessa
forma, para utilizar uma função criada dentro de uma unidade, deve-se
declarar o uso dessa unidade no início do código-fonte (após a definição
do nome do programa). Ex: uses crt; A cláusula uses permite que uma
unidade faça uso de outras unidades. Para usar uma ou mais unidades,
um programa deve conter a cláusula uses antes das declarações de
variáveis. A seguir são apresentadas algumas das principais unidades
disponíveis no Pascal.
system – é a única unidade que não necessita estar na cláusula uses dos
programas ou das outras unidades que a utilizarem. Ex.: tipos de
constantes e variáveis; comentários; expressões aritméticas, lógicas e
literais; funções numéricas predefinidas; funções literais predefinidas;
comandos de entrada e saída; comandos de estrutura condicional e de
repetição.
printer – define um arquivo lst do tipo texto, associado à impressora do
computador, permitindo a sua utilização com os comandos write(lst, ...) e
writeln (lst, ...).
21
ENG06842 – Programação I
crt – oferece diversos recursos para utilizar o vídeo no modo texto, o
teclado e o som do computador. Essa unidade é usada em praticamente
todos os programas escritos em Pascal.
dos – contém constantes, tipos, variáveis, funções e procedimentos
relacionados com o sistema operacional. Ex.: obter data e hora; espaço no
disco rígido; espaço livre no disco rígido, etc.
graph – permite utilizar o vídeo em modo gráfico, define um grande
número de constantes, tipos, variáveis, funções e procedimentos.
8.5. Palavras reservadas
São palavras que fazem parte da estrutura da linguagem e têm
significados pré-determinados. Elas não podem ser redefinidas e não
podem ser utilizadas como identificadores. A tabela a seguir apresenta as
palavras reservada da linguagem Pascal.
absolute end inline procedure typeand external interface program unitarray file interrupt record untilbegin for label repeat usescase forward mod set varconst function nil shl whilediv goto not shr withdo if of string xordownto implementati
onor then
else in packed to
8.6. Funções pré-definidas
A seguir, são apresentadas algumas funções matemáticas pré-definidas na
linguagem Pascal.
Função Finalidade Tipo do argumento
Tipo do resultado
abs(X) valor absoluto integer, real o mesmo do argumento
frac(X) parte fracionária real realtrunc(X) parte inteira real integerround(X) valor
arredondadoreal integer
22
ENG06842 – Programação I
sqr(X) eleva ao quadrado
integer, real o mesmo do argumento
sqrt(X) raiz quadrada integer, real realln(X) logaritmo
naturalreal real
exp(X) exponencial real real
Como não existe em Pascal um operador nem uma função específica para
a operação de potenciação, pode-se consegui-la utilizando as funções
ln(X) e exp(X). Para calcular o valor de XN é suficiente usar:
exp(ln(X)*N)
Exemplos:
Expressão Resultadoabs(-2.5) 2.5
abs(8) 8frac(5.234) 0.234trunc(2.78) 2round(2.78) 3
sqr(2) 4sqr(1.5) 2.25sqrt(4) 2
sqrt(2.25) 1.5exp(ln(2)*3) 8
A seguir, são apresentadas outras funções interessantes disponíveis na
linguagem Pascal.
val(atr,num,code): a função val tentará converter a string informada na
variável atr em um valor numérico (que será armazenado na variável
num), seja real ou integer. Caso não seja possível, a variável inteira code
retornará a posição de erro encontrada. Exemplo:
val(str_idade,val_idade,code); { se str_idade tiver “12a”, code terá 3, ou seja, erro
}
val(str_idade,val_idade,code); { se str_idade tiver “12”, code terá 0, ou seja, sem
erros }
str(num,str): a função str converterá o valor numérico informado em
uma string. Exemplo: str(val_idade,str_idade);
23
ENG06842 – Programação I
keypressed: a função keypressed retornará true caso haja alguma
informação no buffer do teclado, ou seja, caso alguma tecla seja
pressionada. Caso contrário retornará false. Exemplo:
repeat until keypressed; {dará uma pausa no programa até que se pressione
alguma tecla}
readkey: a função readkey pára a execução do programa até que alguma
tecla seja pressionada. É muito utilizada como última instrução de um
programa, pois assim o usuário pode ler o que está escrito na tela com
calma, e quando terminar, pressiona uma tecla e o programa é encerrado.
Exemplo: readkey;
odd(num): a função odd retornará true se o valor informado for ímpar
(inteiro). Caso contrário retornará false. Exemplo: if odd(num) then
write(‘é ímpar’);
inc(num,val): a função inc irá incrementar o número informado em 1
(um), caso o segundo parâmetro não seja informado. Se o mesmo for
informado, o incremento será de seu valor. Exemplos:
inc(x); {o mesmo que x := x+1;}
inc(y,5); {o mesmo que y:=y+5;}
dec(num,val): a função dec irá decrementar o número informado em 1
(um), caso o segundo parâmetro não seja informado. Se o mesmo for
informado, o decremento será de seu valor. Exemplos:
dec(x); {o mesmo que x:=x-1;}
dec(y,5); {o mesmo que y:=y-5;}
ord(car): a função ord retornará o código ASCII (em decimal) da variável
car (do tipo char). Exemplo: write(ord(‘a’),ord(‘A’)); {mostrará 97 65, os
respectivos códigos ASCII}
24
ENG06842 – Programação I
upcase(char): a função upcase retornará o caractere informado em
formato maiúsculo. Caso o caractere informado não seja alfabético, o
mesmo será retornado como foi informado. Exemplo: write(upcase(‘a’));
{mostrará A}
Obs.: para converter um caractere em maiúsculo basta diminuir 32 de
seu código ASCII. Exemplo:
…
write(letra); {‘a’}
dec(letra,32);
write(letra); {‘A’}
…
chr(code): a função chr retornará o caractere correspondente ao código
ASCII informado. Exemplo: write(chr(97)); {mostrará ‘a’}
insert(str,str_destino,pos_inicio): a função insert irá inserir a string str
na string str_destino a partir da posição pos_inicio. Somente a variável
str_destino será alterada. Exemplo:
msg := ‘O Brasil foi penta!’;
adic := ‘não’#32;
insert(adic,msg,10);
write(msg); {‘O Brasil não foi penta!’}
delete(str,pos_inicio,quant): a função delete irá eliminar uma string
interna a outra string. O primeiro parâmetro é a string, o segundo é a
posição inicial, e o terceiro e último a quantidade de caracteres a remover.
Somente o primeiro parâmetro será alterado. Exemplo:
msg := ‘O Brasil não foi penta!’;
delete(msg,10,4);
write(msg); {‘O Brasil foi penta!’}
concat(str1,str2,...,strN): a função concat retornará a concatenação
(união) de todas as strings informadas como parâmetros. O resultado da
25
ENG06842 – Programação I
concatenação não pode ultrapassar os 255 caracteres permitidos. Utilize o
operador “+” ao invés de concat, pois “+” é mais veloz. Exemplo:
msg1:= ‘Linguagem’;
msg2:=#32;
msg3:= ‘Pascal’;
write(concat(msg1,msg2,msg3)); {‘Linguagem Pascal’}
É mais rápido usar: write(msg1 + msg2 + msg3);
copy(str,pos_inicio,quant): a função copy retornará uma substring a
partir de uma string original. A string original é o primeiro parâmetro, a
posição inicial de cópia é o segundo e a quantidade de caracteres a serem
copiados é o terceiro. Exemplo:
msg := ‘A Linguagem Pascal’;
write(copy(msg,13,6)); {Pascal}
length(str): a função length retornará o comprimento da string, ou seja,
seu número de caracteres. Exemplo:
msg := ‘A Linguagem Pascal’;
write(length(msg)); {18}
clrscr: a função clrscr limpará toda a tela; Exemplo: clrscr;
textbackground(c): altera a cor de fundo da tela. O parâmetro c pode
variar de 0 a 7, e também pode-se usar o nome da cor em inglês. Para
alterar a cor de toda a tela deve-se usar o comando clrscr em seguida.
Exemplo:
textbackground(1);
clrscr; { toda a tela ficará azul }
textcolor(c): altera a cor do texto. O parâmetro c pode variar de 0 a 15, e
também pode-se usar o nome da cor em inglês.. Exemplo: textcolor(10);
26
ENG06842 – Programação I
clreol: a função clreol limpará parte da tela, apenas da posição do cursor
até o final da mesma linha. Exemplo: clreol;
delline: a função delline limpará toda a linha onde estiver o cursor, sem
movê-lo. Exemplo: delline;
insline: a função insline irá inserir uma linha onde estiver o cursor, sem
movê-lo. Todos os dados que estiverem abaixo da posição do cursor serão
deslocados para baixo. Caso se queira inserir mais de uma linha, basta
colocar essa função dentro de um laço (loop). Exemplo:
for x := 1 to 10 do
insline; {irá inserir10 linhas a partir da posição do cursor}
sound(freq): a função sound irá ativar o auto-falante do micro, bastando
apenas informar no parâmetro a freqüência do som desejado.
Normalmente utiliza-se esse procedimento com os procedimentos delay e
nosound, já que sound sozinho irá ativar o som e o mesmo ficará tocando
o tempo todo. Exemplo: sound(200);
nosound: a função nosound irá desligar o som do auto-falante do micro.
Exemplo: nosound;
delay(ms): O procedimento delay irá dar uma pausa na execução do
programa, só que diferentemente dos procedimentos já citados, essa
pausa se dará por um tempo informado no parâmetro em milisegundos
(10-3s). Exemplo:
sound(240);
delay(1000); {equivale a 1s}
nosound;
random(num): a função random retornará um valor randômico
(aleatório) a partir do número informado. Esse número randômico será um
número qualquer na faixa de 0 <= a < num. Caso não seja informado um
número, o valor randômico estará na faixa 0 <= a < 1. Normalmente esta
função é utilizada com o procedimento randomize. Exemplo:
27
ENG06842 – Programação I
random(300); {através de fórmulas internas, será gerado um número entre 0 e
300}
randomize: a função randomize irá fazer apenas um pequeno diferencial
no uso da função random. Toda vez que se utiliza random, o valor inicial
das fórmulas é o mesmo. Portanto, os valores randômicos sempre serão os
mesmos. Para que isto não aconteça, basta utilizar o procedimento
randomize, o mesmo irá fazer com que o valor inicial das fórmulas de
randomização seja baseado na hora do sistema, o que sabemos que muda
constantemente. Exemplo:
randomize;
repeat
write(random(500));
delay(50);
until keypressed;
exit: a função exit irá fazer com que a execução do programa saia do
procedimento atual e vá para o seu chamador. Caso o procedimento atual
seja o programa principal, exit terminará a execução do programa.
Exemplo:
if tecla = #27 then
exit; { Pressionou ESC, fim }
Exemplo: Um programa para ler um número e mostrar se é igual a zero,
positivo ou negativo. O fundo de tela deve estar em azul e as letras em
amarelo.
program teste;
uses crt;
var
num: real;
begin
textbackground (blue);
clrscr;
28
ENG06842 – Programação I
textcolor (yellow);
write (‘Digite um numero: ’);
readln (num);
if num = 0 then
writeln (‘Igual a zero.’)
else
if num > 0 then
writeln (‘Numero positivo.’)
else
writeln (‘Numero negativo.’);
readkey;
end.
8.7. Tipos definidos pelo usuário
Os tipos byte, integer, real, boolean, char, etc são pré-definidos em Pascal
e constituem conjunto de valores inteiros, reais, lógicos, caractere, etc. O
Pascal permite a criação de novos tipos. Um novo tipo é criado através de
uma definição que determina um conjunto de valores associados a um
identificador. Uma vez definido, o tipo passa a ser referenciado pelo seu
identificador.
O novo tipo criado pelo usuário também é denominado tipo enumerado.
Os identificadores que criamos para um tipo enumerado não representam
mais nenhum valor, exceto seus próprios. Os tipos enumerados
constituem ferramentas extremamente úteis na criação de programas
limpos e auto-documentados, podendo ser referenciados em qualquer
parte do programa.
Um tipo enumerado é uma seqüência ordenada de identificadores
definidos pelo usuário, que forma um tipo ordinal. A palavra reservada
para criação de tipos enumerados é type. Exemplo:
type semana = (segunda, terça, quarta, quinta, sexta, sábado, domingo);
29
ENG06842 – Programação I
Uma das mais importantes características de um tipo enumerado é a
ordem na qual os valores são ordenados. Além de estabelecer os próprios
identificadores, a declaração do mesmo define a ordem dos
identificadores no tipo.
Diversas operações são válidas usando os tipos enumerados. Exemplo:
program cores;
uses crt;
type cores = (preto, azul, vermelho, amarelo, verde, rosa, branco,
roxo, lilas);var
uma_cor: cores;begin
clrscr;
uma_cor := roxo; {atribuir um identificador a variável de
tipo}
uma_cor := succ(uma_cor); {receber lilás, o sucessor}
uma_cor := pred(uma_cor); {receber roxo novamente, o
antecessor}
uma_cor := succ(azul); {receber vermelho, sucessor de azul}
if succ(uma_cor)>=lilas then
uma_cor := preto;
writeln(ord(uma_cor)); {escrever 2, a ordem do vermelho}
uma_cor := preto;
writeln(ord(uma_cor)); {escrever 0, a ordem do preto}
for uma_cor := preto to rosa do
writeln(ord(uma_cor)); {escrever as posições, do preto ao
rosa}
end.
As variáveis de tipos enumerados não podem ser lidas ou escritas.
Não é válida nenhuma operação aritmética com os elementos de um tipo
enumerado, como somar 1, diminuir 2 ou somar duas constantes ou mais
constantes do tipo.
30
ENG06842 – Programação I
Pode-se usar as constantes dos tipos enumerados para servir de índice de
vetores/matrizes e também no laço (loop) for. A ordem do primeiro
elemento do tipo tem valor 0.
Um tipo pode ser definido como uma parte de um dado tipo escalar. Esta
parte ou faixa define o domínio de um tipo escalar que está associado a
um novo tipo, que é chamado de tipo escalar. A definição de uma faixa
(subrange) indica quais os valores mínimo e máximo que podem ser
assumidos. A descrição de uma faixa se faz com a indicação dos seus
limites separados por dois pontos (..), onde o limite inferior deve ser
menor que o limite superior. Exemplo:
program dias;uses crt;type
semana = (seg, ter, qua, qui, sex, sab, dom); {tipo enumerado}coluna = 1..80; {tipo escalar associado: byte}maius = ‘A’..’Z’; {tipo escalar associado: char}d_util = seg..sex; {tipo escalar associado: semana}num = -128..130; {tipo escalar associado: integer}
varletra: maius;dia: d_util;
beginclrscr;for letra := ‘J’ to ‘P’ do
write(letra:2);for dia := seg to sex do
case dia ofseg: writeln(‘Segunda’);ter: writeln(‘Terça’);qua: writeln(‘Quarta’);qui: writeln(‘Quinta’);other
writeln(‘Sexta’);end;
readkey;end.
8.8. Exercícios
1. Transforme os algoritmos elaborados nas questões 24 e 25 do Capítulo
4 para a linguagem Pascal. Execute esses algoritmos no computador.
31
ENG06842 – Programação I
2. Transforme os algoritmos elaborados nas questões 1, 2, 5, 6, 10, 11,
12, 13, 14, 15, 16, 17, 24, 25, 26, 27, 28, 29, 30 e 31 do Capítulo 5 para
a linguagem Pascal. Execute esses algoritmos no computador.
3. Transforme os algoritmos apresentados ou elaborados nas questões 1,
2 e 3 do Capítulo 6 para a linguagem Pascal. Execute esses algoritmos
no computador.
32
ENG06842 – Programação I
9. Estruturas de dados
9.1. Introdução
Os tipos estruturados são compostos por múltiplos elementos relacionados
entre si. Cada grupo de elementos está relacionado a um identificador. Os
elementos do grupo podem estar também relacionados a identificadores
individuais, representando vários locais de memória que guardam vários
valores, e que podem ser acessados em conjunto ou individualmente.
9.2. Variáveis compostas homogêneas
Correspondem a posições de memória, identificadas por um mesmo nome,
individualizadas por índices e cujo conteúdo é de mesmo tipo.
O conjunto de 10 notas dos alunos de uma disciplina pode constituir uma
variável composta. A este conjunto, associa-se o identificador NOTA, que
passará a identificar não uma única posição de memória, mas 10.
A referência ao conteúdo do n-ésimo elemento do conjunto será indicada
pela notação NOTA[n] onde n é um número inteiro ou uma variável
numérica contendo um valor inteiro.
Exemplo: Supondo que a variável composta NOTA contivesse os seguintes
valores:
60
70
90
60
55
91
100
47
74
86
1 2 3 4 5 6 7 8 9 10
NOTA[3] estaria referenciando o terceiro elemento do conjunto cujo
conteúdo é 90.
Vetores (array): definem conjuntos de dados homogêneos (todos os
elementos são do mesmo tipo). Cada elemento ocupa uma posição
definida no conjunto e pode ser referenciado através dela. Esses conjuntos
33
ENG06842 – Programação I
necessitam de apenas um índice para endereçar seus elementos. São
conhecidos como Variáveis Compostas Unidimensionais.
Declaração de vetores:
<identificador>: array [tipo_índice] of tipo_elemento;
tipo_índice: é um tipo simples ordenado (inteiro, caractere, booleano,
enumerado). É formado por: [li..ls] , onde li: limite inferior e ls: limite
superior. Este tipo pode ser utilizado tanto na declaração de variáveis
como também na definição de novos tipos.
Ex1:
var
lista: array [1..100] of real; { o identificador do vetor é lista e ele
poderá conter 100 elementos do tipo
real }
Ex2:
type
indice = 1..100; { tipo definido pelo usuário - tipo subrange }
var
lista: array [indice] of real;
Ex3:
type
max = 300;
vetor = array[1..max] of string[20];
var
endereco: vetor; { a variável endereço está associada ao tipo
vetor }
Ex4:
var
dados: array[‘A’..’Z’] of integer;
Definição de Vetores como constantes: sintaxe geral:
34
ENG06842 – Programação I
<identificador_constante>: tipo_array = (lista de valores);
Ex1:
const
vetconst: array [1..3] of integer = (0, 1, 2);
Ex2:
type
vetsemana = array [1..7] of string [3];
const
dias_semana: vetsemana = (‘DOM’, ‘SEG’, ‘TER’, ‘QUA’, ‘QUI’,
‘SEX’, ‘SAB’);
Obs: Os valores das constantes array de tipo char podem ser especificados
ou como valores de caracteres simples ou como um string. Ex:
const
digito: array [0..9] of char = (‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’,
‘9’);
ou
const
digito: array [0..9] of char = ‘0123456789’;
A manipulação de vetores nos programas Pascal pode ser expressa com
uma constante, variável ou expressão, devendo ser do tipo correto
(correspondente à definição do array) e estar dentro do intervalo pré-
definido. Ex: lista[5] lista[i], onde i é uma variável inteira com valores
variando de 1 a 100. lista[i+j], onde i e j são variáveis inteiras cuja soma
não ultrapassa 100. Os elementos do ARRAY podem ser usados em
expressões, instruções de atribuição, instruções read e write, etc.
Exemplo:
program exVetor;
type
vetorNotas = array [1..40] of real;
35
ENG06842 – Programação I
var
nota: vetorNotas;
i: integer;
begin
i := 1;
media := 0;
repeat
begin
write (‘Digite a nota :’);
read(nota[i]);
media:= media + nota[i];
i:= succ(i); { função que incrementa a variável ⇒ i := i
+ 1 }
end;
until i > 40;
writeln (‘Notas dos alunos ’);
for i:= 1 to 40 do
writeln (nota[i]);
writeln (‘Media da turma:’, media/40:5:2);
end.
Matrizes (vetores multidimensionais): também definem conjuntos de
dados homogêneos (todos os elementos são do mesmo tipo), entretanto,
esses conjuntos necessitam de mais de um índice para endereçar seus
elementos. São conhecidos como Variáveis Compostas Multidimensionais
(matrizes). Exemplo de matriz bidimensional:
1 2 31 1
047
94
2 67
98
74
3 16
21
32
Declaração de matrizes:
36
ENG06842 – Programação I
<identificador>: array [dim1,dim2,...] of tipo_elemento;
As dimensões são definidas como: dim1 = li1..ls1, dim2 = li2..ls2, etc.
Exemplo de declaração de uma matriz TRIDIMENSIONAL:
mat3D: array [1..10, 1..20, 1..40] of real;
A 1ª dimensão tem 10 elementos, a 2ª tem 20 elementos e a 3ª tem 40
elementos. Todos os elementos são números reais.
Matriz BIDIMENSIONAL:
mat2D: array [1..5,1..9] of char;
É uma matriz bidimensional com 5 elementos do tipo char na 1ª dimensão
e 9 na 2ª dimensão.
A manipulação de matrizes nos programas em Pascal pode ser expressa
com constantes, variáveis ou expressões, devendo ser do tipo correto
(correspondente à definição do array) e estar dentro do intervalo pré-
definido. Exemplo: mat3D[5,4,8], mat2D[i,9], onde i é uma variável inteira
com valores variando de 1 a 5. Os elementos da matriz podem ser usados
em expressões, instruções de atribuição, instruções read e write, etc.
Exemplo:
program Matrizes;
var
matriz: array [1..20, 1..10] of integer;
lin, col: integer;
begin
for lin := 1 to 20 do
for col := 1 to 10 do
read (matriz[lin,col]);
...
37
ENG06842 – Programação I
Uma matriz também pode ser definida como uma constante, e nesse caso,
essa matriz deve ser definida da seguinte forma:
type
apart = array[1..5,1..2] of string[3];
const
num: apart = ((‘101’,’102’), (‘103’,’104’), (‘105’,’106’), (‘107’,’108’),
(‘109’,’110’));
{ 1ª linha 2ª linha 3ª linha 4ª linha 5ª linha }
...
write(num[3,2]); {106}
write(num[1,1]); {101}
Exemplo:
program matriz;
uses crt;
const
alunos: array[1..3,101..103] of string[10] =
((‘Cenira’,’Joana’,’Marcia’),
{primeira linha}
(‘Lourdes’,’Nágyla’,’Luciana’),
{segunda linha}
(‘Patrícia’,’Marcos’,’Angélica’)); {terceira
linha}
var
i,j: integer;
begin
clrscr;
for i:=1 to 3 do
for j:=101 to 103 do
writeln(‘Aluno(a)’,I,’ da turma ‘,j,’: ‘,alunos[i,,j]); {listará por
linha}
writeln;
38
ENG06842 – Programação I
for j:=101 to 103 do
for i:=1 to 3 do
writeln(‘Aluno(a)’,I,’ da turma ‘,j,’: ‘,alunos[i,,j]); {listará por coluna}
readkey;
end.
Cuidados ao utilizar arrays:
Caso o seu limite seja ultrapassado, o programa pode travar e junto
com ele o sistema.
O Pascal só acusará erro se você tentar atribuir a um vetor um dado
qualquer com índice fora da faixa escrita no programa. Mas isso não
acontecerá se a origem do índice for alguma expressão.
Os tipos array em Pascal são estáticos, ou seja, o comprimento e as
dimensões alocadas são fixas em tempo de compilação e não
podem ser redefinidas durante a execução do programa.
9.3. Variáveis compostas heterogêneas
O principal tipo de variáveis compostas heterogêneas é o registro, que
consiste em conjuntos de dados logicamente relacionados, mas de tipos
diferentes (numéricos, lógicos, literais, etc).
Pode-se definir registros em Pascal na sessão type ou diretamente
declarar variáveis do tipo record.
a) Declaração na sessão TYPE:
type
<nome_novo_tipo> = record
campo 1: tipo 1;
campo 2: tipo 2;
…
campo n: tipo n;
end;
39
ENG06842 – Programação I
var
<identificador_variavel>: <nome_novo_tipo>;
Exemplo:
type { Atencao para a indentacao dos campos do registro}
funcionario = record
nome: string[40];
idade: integer;
funcao: string[30];
salario: real;
end;
var
funcionarioUFES: funcionario;
b) Declaração na sessão VAR:
var
<identificador_registro>: record
campo 1: tipo 1;
campo 2: tipo 2;
…
campo n: tipo n;
end;
Ex emplo :
var
funcionarioUFES: record
nome: string[40];
idade: integer;
funcao: string[30];
salario: real;
end;
40
ENG06842 – Programação I
Os campos dos registros podem ser por sua vez de tipos simples ou
estruturados (array, registros, etc.).
Ex emplo :
type
estadosBrasil = (AC,AL,AM,AP,BA,CE,DF,ES,GO,MA,MG,MS,MT,PA,PB,PE,
PI,PR,RJ,RN,RO,RR,RS,SC,SE,SP,TO);
var
cliente: record
nome: string[50];
endereco: record
rua: string [30];
numero: integer;
complemento: string [40];
cep: string [10];
cidade: string[20];
estado: estadosBrasil;
end;
valoresUltimasCompras: array [1..10] of real;
end;
O acesso aos campos de um registro pode ocorrer de duas formas:
a) uso da notação <identifRegistro>.<campo>. Ex:
write(‘Digite o nome do funcionario: ’);
readln(funcionarioUFES.nome); {acesso ao campo
nome }
write(‘Digite a funcao do funcionario: ’);
readln(funcionarioUFES.funcao); {acesso ao campo
funcao }
...
b) uso da estrutura with <identif_Registro> do. Ex:
with funcionarioUFES do
41
ENG06842 – Programação I
begin
writeln(‘Dados do funcionario cadastrado’);
writeln(‘Nome: ’, nome);
writeln(‘Idade: ’, idade);
writeln(‘Funcao: ’, funcao);
writeln(‘Salario: ’, salario:5:2);
end;
Exemplo:
program exRegistro;
var
aluno : record { variável aluno do tipo registro }
matricula: string[6]; {definição dos campos do registro }
nome: string[15];
serie: integer;
turma: char; { cada campo tem um nome e
um tipo }
end;
begin
write('Numero de matricula: ');
readln(aluno.matricula);
write('Nome: ');
readln(aluno.nome); {acesso ao campo nome do
registro aluno}
write('Serie: ');
readln (aluno.serie);
write ('Turma: ');
readln (aluno.turma);
{ comando with indica o registro que será usado - não há necessidade
de se colocar begin e end quando se tem apenas um comando na
estrutura with }
with aluno do
write (‘O aluno ’, nome , ‘ estuda na ’, serie, ‘serie!’);
42
ENG06842 – Programação I
end.
Conjunto de registros: utilizado para armazenar n informações referentes
ao mesmo tipo de registro, como, por exemplo, informações de vários
funcionários ou vários alunos. Em Pascal, esse tipo de conjunto é definido
por um array unidimensional (vetor) de registros. A declaração é dada da
seguinte forma:
type
<tipo_registro> = record
campo 1: tipo 1;
…
campo n: tipo n;
end;
var
<identif_vetor>: array[n..m] of <tipo_registro>;
Exemplo:
type
aluno = record
matricula: string[6];
nome: string[15];
serie: integer;
end;
var
vetAlunos: array [1..45] of aluno;
A manipulação de conjuntos de registros é dada da seguinte forma:
<identif_vetor>[posicao].campo. Ex:
for i:= 1 to 45 do
begin
readln(vetAlunos[i].matricula);
readln(vetAlunos [i].nome);
readln(vetAlunos [i].serie);
43
ENG06842 – Programação I
end;
Também pode-se usar a estrutura with. Ex:
for i:=1 to 45 do
with vetAlunos[i] do
begin
readln(matricula);
readln(nome);
readln(serie)
end;
Exemplo:
44
ENG06842 – Programação I
program produtos;
uses crt;
type
produto = record
ident: string[3];
descr: string[10];
preco: real;
quant: integer;
end;
var
vet_prod: array [1..3] of produto;
i: integer;
begin
clrscr;
writeln (‘*** CADASTRO DE PRODUTOS ***’);
for i:=1 to 3 do
with vet_prod[i] do { vet_prod[i] representa cada
elemento do vetor }
begin
write(‘identificação: ’);
readln(ident) ;
write(‘descrição: ’);
readln(descr) ;
write(‘preco: ’);
readln(preco) ;
write(‘quantidade: ’);
readln(quant)
end;
writeln (‘***** Produtos no Estoque *****’) ;
writeln (‘---Identif.----Descricao----Preco----Quantidade---’) ;
for i:=1 to 3 do
with vet_prod[i] do
if quant > 0 then
45
ENG06842 – Programação I
write(‘ ’, ident, ‘ ’, descr, ‘ ’, preco:6:2, ‘ ’, quant);
end.
9.4. Algoritmos de classificação e busca
Algoritmos de classificação : existem diversos métodos para classificar (ou
ordenar) uma estrutura de dados. Os mais conhecidos são o “Método da
Bolha”, o “Método da Seleção Direta” e o “Método Quick Sort”, porém o
mais comum desses é o Método da bolha (Bubble Sort).
Exemplo: Método da Bolha para ordenação de um vetor de “nomes de
objetos”.
program BubbleS;
uses crt;
const
N=5;
type
letras = string[10];
vet_letras = array[1..N] of letras;
var
objetos: vet_letras;
aux: letras;
i, j, cont: integer;
begin
clrscr;
write('>>> Exercicio - Ordenacao de Vetores com metodo da
Bolha<<<'); write('Digite ',N,' nomes de objetos para compor o
conjunto');
for i:=1 to N do
begin
write ('Digite o elemento objetos(',i,'): ');
readln(objetos[i]);
write(' ');
end;
46
ENG06842 – Programação I
{ ***************** Ordenação do Vetor ******************* }
for i:= 2 to N do
for j:= N downto i do
if objetos[j] < objetos[j-1] then
begin
aux := objetos[j];
objetos[j] := objetos[j-1];
objetos[j-1] := aux
end;
{ ********************* Saida Ordenada ****************** }
writeln ('Vetor Ordenado: ');
for i:=1 to N do
writeln(objetos[i]);
end.
Algoritmos de busca : também existem diversos métodos para procurar (ou
buscar) um valor dentro de uma estrutura de dados. Os mais conhecidos
são o “Busca Seqüencial” e o “Busca Binária”, porém o mais comum
desses é o Seqüencial.
Exemplo: Considere um vetor A com 50 elementos. Verificar se existe um
elemento igual a K no vetor. Se existir mostrar a posição em que se
encontra, senão imprimir “não encontrei K no vetor”.
program Procura_K; uses crt; const
max = 10; { Indica o numero maximo de elementos do array num } var
i, k: integer; achou: boolean; num: array[1..max] of integer;
begin clrscr; writeln('Digite ',max,' numeros inteiros!'); for i:=1 to max do
begin write('Digite o elemento (',i,'): '); readln(NUM[i]);
47
ENG06842 – Programação I
end; write('Digite o numero que deseja procurar no conjunto: '); readln(k); achou := false; i:=1; while (not achou) and (i<=max) do
if num[i]=k then achou := true
else i := i+1;
if achou then write('Achei o numero ',k,' na posicao (',i,') do vetor !!!')
else write('Nao achei o numero ',k,' no vetor !!!');
end.
9.5. Exercícios
1. Elabore um programa que leia dois vetores inteiros de 20 elementos
cada, depois some seus elementos, gerando um terceiro vetor. Ao final,
mostre o novo vetor gerado.
2. Considere um vetor VET com 30 elementos. Verificar se existe um
elemento igual a K no vetor. Se existir mostrar a posição em que se
encontra, senão imprimir “não encontrei K no vetor”.
3. Faça um programa para ler um conjunto de 10 inteiros e escreve-los na
ordem inversa à ordem de leitura.
4. Faça um programa para ler um conjunto de 10 inteiros e escreve-los na
ordem crescente.
5. Elabore um programa que leia um conjunto A com 50 números reais e
construa um conjunto B, onde os elementos de ordem (posição) par são
os elementos correspondentes de A divididos por 2, e os de ordem
(posição) ímpar correspondem aos elementos de A multiplicados por 3.
Ao final, mostre os dois conjuntos de números.
6. Fazer um programa Pascal que, ao ser fornecida uma data no formato
DD/MM/AA, mostre-a por extenso. Ex: Entrada: 12/06/95; Saída: 12 de
junho de 1995.
48
ENG06842 – Programação I
7. Elabore um programa que utilize dois vetores V1 e V2, formados de
números reais com 20 posições cada um, e efetue neles as operações
indicadas no vetor OP, cujos elementos são caracteres que indicam as
quatro operações aritméticas básicas (+, -, *, /) . O resultado obtido das
operações devem ser colocados num vetor resultante VR e mostrado ao
final do programa.
8. Escreva um programa que leia duas matrizes bidimensionais reais
MAT1 e MAT2 de dimensões 3x5 cada, calcule e imprima a matriz soma
MSOMA.
9. Calcule e imprima a soma dos elementos situados abaixo da diagonal
principal da matriz A (dimensões 10x10), incluindo os elementos da
própria diagonal.
10. Escreva um programa que leia duas matrizes reais A e B de
dimensões 3x5 e 5x3, respectivamente, calcule e imprima o produto
delas.
11. Dada uma matriz A de dimensões 5x4 formada de elementos
numéricos reais, calcule e mostre sua matriz transposta T.
12. Dada uma matriz B formada por números inteiros com 10 linhas por
15 colunas, determinar o elemento de maior valor algébrico. Mostre tal
elemento e sua posição na matriz (linha e coluna).
13. Faça um programa para ler 2 vetores a e b, de inteiros, e montar o
vetor soma = a + b.
14. Faça um programa para multiplicação de matrizes: leia a e b (4x4), crie
C = A*B, escreva C.
15. Loteria esportiva. Faça um programa para ler um "gabarito" com os
resultados dos jogos da loteria esportiva (coluna 1, coluna2, coluna do
meio, 13 jogos), armazenando em um vetor. Depois leia um conjunto
indeterminado de jogos e verifique se ganhou o prêmio. Ao final da
49
ENG06842 – Programação I
verificação, pergunte se o usuário quer entrar mais jogos. Ao final do
programa, informe quantos ganharam o prêmio.
50
ENG06842 – Programação I
10. Modularização
10.1. Introdução
Dentre as técnicas de programação estruturada, encontra-se a
modularização. Esta técnica consiste em decompor um programa em uma
série de subprogramas individuais. A modularização é um método
utilizado para facilitar a construção de grandes programas, através de sua
divisão em pequenas etapas (dividir para conquistar), que são os módulos
ou subprogramas. A primeira delas, por onde começa a execução do
trabalho, recebe o nome de programa principal, e as outras são os
subprogramas propriamente ditos, que são executados sempre que ocorre
uma chamada dos mesmos, o que é feito através da especificação de seus
nomes.
A modularização permite o reuso de partes do programa num mesmo
programa ou mesmo em novos programas, exemplo: imagine um trecho
de programa que verifica se uma data é valida ou não. Este módulo pode
ser usado várias vezes num mesmo programa que leia várias datas
diferentes e pode ser reaproveitado em novos programas que serão
escritos. Outras conseqüências positivas do uso de modularização é o
aumento de clareza e concisão do programa, pois o comprimento do
programa diminui com o uso de módulos. Em Pascal existem dois tipos de
módulos de programas: Procedimentos e Funções.
Vantagens da utilização de subprogramas:
Economia de código: escreve-se menos;
Desenvolvimento modularizado: pensa-se no algoritmo por partes;
Facilidade de depuração (correção/acompanhamento): é mais fácil
corrigir/detectar um erro apenas uma vez do que dez vezes;
Facilidade de alteração do código: se é preciso alterar, altera-se
apenas uma vez;
51
ENG06842 – Programação I
Generalidade de código com o uso de parâmetros: escreve-se
algoritmos para situações genéricas.
10.2. Procedimentos
Um subprograma do tipo PROCEDIMENTO é, na realidade, um programa
com vida própria, mas que, para ser processado, tem que ser solicitado
pelo programa principal que o contém, ou por outro subprograma, ou por
ele mesmo.
Declaração:
procedure nome;
declaração dos objetos (constantes, variáveis, etc.) locais ao
procedimento
begin
comandos do procedimento;
end;
Onde: nome é o identificador associado ao procedimento.
Exemplo: O programa abaixo calcula a média aritmética entre duas notas,
sem o uso de procedimentos.
program CALCULA_MEDIA; {sem o uso de procedimentos}
var
NOTA1,NOTA2,MEDIA : real;
begin
{lê as notas}
write('Digite a primeira nota: ');
readln(NOTA1);
write('Digite a segunda nota: ');
readln(NOTA2);
{calcula a media}
MEDIA := (NOTA1 + NOTA2) / 2;
{escreve o resultado}
52
ENG06842 – Programação I
writeln('Media = ',MEDIA,4:1)
end.
Agora, o mesmo programa, utilizando um procedimento.
program CALCULA_MEDIA; {usando procedimento}
var
NOTA1,NOTA2,MEDIA : real;
{ declaração do procedimento }
procedure LER_NOTAS;
begin
write('Digite a primeira nota: ');
readln(NOTA1);
write('Digite a segunda nota: ');
readln(NOTA2);
end;
{ programa principal }
begin
LER_NOTAS; {ativação do procedimento
LER_NOTAS}
MEDIA := (NOTA1 + NOTA2) / 2; {calcula a media}
Writeln('Media = ',MEDIA,4:1) {escreve o resultado}
end.
10.3. Funções
As funções, embora bastante semelhantes aos procedimentos, têm a
característica especial de retornar ao programa que as chamou um valor
associado ao nome da função. Esta característica permite uma analogia
com o conceito de função da Matemática.
Declaração:
function nome: tipo;
53
ENG06842 – Programação I
declaração dos objetos locais à função
begin
comandos da função;
end;
Onde: nome é o identificador associado à função; e tipo é o tipo da função,
ou seja, o tipo do valor de retorno.
Exemplo: O programa abaixo calcula a média dos elementos de um vetor,
sem uso de procedimentos ou funções.
program SOMA_VETOR; {sem o uso de procedimentos ou funções}
const
N = 30;
var
VETOR: array[1..N] of integer;
I,SOMA,MEDIA: integer;
begin
{lê os valores do vetor}
for I:=1 to N do
readln(VETOR[I]);
{calcula a media}
SOMA := 0;
for I:=1 to N do
SOMA := SOMA + VETOR[I];
MEDIA := SOMA div N;
{escreve o resultado}
writeln(MEDIA);
end.
Agora, o mesmo programa, porém utilizando um procedimento para ler os
valores do vetor e uma função para efetuar o cálculo da média.
program SOMA_VETOR; {usando uma função e um
procedimento}
54
ENG06842 – Programação I
const
N = 30;
var
VETOR: array[1..N] of integer;
{ declaração do procedimento }
procedure LER_DADOS;
var
I: integer;
begin
for I := 1 to N do
readln(VETOR[I]);
end;
{ declaração da função }
function MEDIA: integer;
var
I, SOMA: integer;
begin
SOMA := 0;
for I := 1 to N do
SOMA := SOMA + VETOR[I];
MEDIA := SOMA div N;
end;
{ programa principal }
begin
LER_DADOS; {ativa o procedimento LER_DADOS}
writeln(MEDIA); {escreve o resultado, chamando a função
MEDIA}
end.
55
ENG06842 – Programação I
10.4. Escopo de variáveis
Observe que, no exemplo anterior, foi declarada uma variável no
programa principal e outras nos subprogramas. Pode-se dizer que a
variável VETOR, que foi declarada no programa principal é uma variável
global aos subprogramas, enquanto que a variável I é dita variável local ao
procedimento LER_DADOS e as variáveis I e SOMA são locais à função
MEDIA. É importante ressaltar que a variável I do procedimento
LER_DADOS é diferente da variável I da função MEDIA, embora possuam o
mesmo identificador.
O uso de variáveis globais dentro de procedimentos e funções serve para
implementar um mecanismo de transmissão de informações de um nível
mais externo para um mais interno. As variáveis locais dos procedimentos
e funções são criadas e alocadas quando da sua ativação e
automaticamente liberadas quando do seu término.
A utilização de variáveis globais não constitui, no entanto, uma boa prática
de programação. Assim, todos os subprogramas devem apenas utilizar as
variáveis locais, conhecidas dentro dos mesmos, e a transmissão de
informações para dentro e fora dos subprogramas deve ser feita através
dos parâmetros de transmissão, que serão apresentados a seguir.
10.5. Parâmetros
Quando se deseja escrever um subprograma que seja o mais genérico
possível, deve-se usar a passagem de parâmetros. A passagem de
parâmetros formaliza a comunicação entre os módulos. Além disto,
permite que um módulo seja utilizado com operandos diferentes,
dependendo do que se deseja do mesmo. Dá-se a designação de
parâmetro real ou de chamada ao objeto utilizado na unidade
chamadora/ativadora, e de parâmetro formal ou de definição ao recebido
como parâmetro no subprograma. Dentre os modos de passagem de
parâmetros, destaca-se a passagem por valor e a passagem por
referência.
56
ENG06842 – Programação I
P assagem de parâmetros por valor : as alterações feitas nos parâmetros
formais, dentro do subprograma, não se refletem nos parâmetros reais. O
valor do parâmetro real é copiado no parâmetro formal, na chamada do
subprograma. Assim, quando a passagem é por valor, isto significa que o
parâmetro é de entrada.
P assagem de parâmetros por referência : toda alteração feita num
parâmetro formal corresponde a mesma alteração feita no seu parâmetro
real associado. Assim, quando a passagem é por referência, isto significa
que o parâmetro é de entrada-saída.
Na linguagem Pascal, a declaração dos procedimentos e funções com
parâmetros se diferencia da forma já apresentada apenas pela inclusão da
lista de parâmetros formais no cabeçalho. Esta deve vir entre parênteses
e cada parâmetro deve ter o seu tipo especificado. A forma geral é:
procedure nome (lista de parâmetros formais)
function nome (lista de parâmetros formais): tipo
A lista de parâmetros formais tem a seguinte forma:
parâmetro1: tipo; parâmetro2: tipo; ...; parâmetro n: tipo
Exemplos da lista de parâmetros:
procedure PROC (X, Y, Z: integer; K: real);
function FUNC (A, B: real; C: string): integer;
Na forma apresentada, a passagem dos parâmetros será por valor. Para se
utilizar a passagem por referência, deve-se acrescentar a palavra VAR
antes do nome do parâmetro.
Exemplo:
procedure PROC(A: integer; var B, C: integer);
57
ENG06842 – Programação I
Na chamada de procedimentos ou funções utilizando parâmetros,
devemos acrescentar após o nome do procedimento ou função uma lista
de parâmetros reais (de chamada), os quais devem ser do mesmo tipo e
quantidade dos parâmetros formais declarados. O exemplo a seguir
demonstra a diferença entre a passagem de parâmetros por referência e a
passagem de parâmetros por valor.
program EXEMPLO_PASSAGEM_PARAMETROS;
var
N1, N2 : integer;
procedure PROC(X: integer; var Y: integer);
begin
X := 1;
Y := 1;
end;
begin
N1:=0;
N2:=0;
PROC(N1,N2);
writeln(N1); {será exibido o valor 0}
writeln(N2); (será exibido o valor 1}
end.
Exemplo: Escrever um procedimento chamado DOBRA que multiplique um
número inteiro (recebido como parâmetro) por 2. Escrever um programa
para ler um valor inteiro e, utilizando o procedimento DOBRA, calcular e
exibir o dobro do mesmo.
program CALCULA_DOBRO;
var
X: integer;
58
ENG06842 – Programação I
procedure DOBRA (var NUM: integer);
begin
NUM := NUM * 2
end;
begin
readln(X);
DOBRA(X);
writeln(X);
end.
Exemplo: Escrever uma função chamada MAIOR que receba dois números
inteiros e retorne o maior deles. Escrever um programa para ler dois
números inteiros e, utilizando a função MAIOR, calcular e exibir o maior
valor entre os números lidos.
program CALCULA_MAIOR;
var
X, Y, M: integer;
function MAIOR (NUM1, NUM2: integer): integer;
begin
if NUM1 > NUM2 then
MAIOR := NUM1
else
MAIOR := NUM2;
end;
begin
readln(X,Y);
M := MAIOR(X,Y);
writeln(M);
end.
59
ENG06842 – Programação I
Exemplo: Escreva um procedimento que receba uma string S e converta o
mesmo para letras maiúsculas.
procedure MAIUSC (var S: string);
var
I, TAM: byte;
begin
TAM := length(S);
for I := 1 to TAM do
S[I] := upcase(S[I]);
end;
10.6. Recursividade
Existem casos em que um procedimento ou função chama a si próprio.
Diz-se então que o procedimento ou função é recursivo. Por exemplo, o
fatorial de um número n pode ser definido recursivamente, ou seja:
=>−
=0 n se1
0 n se1)!(nn !n
Dessa forma, pode-se escrever uma função recursiva em Pascal que
traduz esta definição matemática:
function FAT(n: integer): integer;
begin
if n = 0 then
FAT := 1
else
FAT := N * FAT(N-1);
end;
10.7.Exercícios
1. Cite as principais vantagens da utilização de subprogramas.
60
ENG06842 – Programação I
2. Conceitue procedimento e função. Em que eles são semelhantes e em
que eles são diferentes?
3. Que tipo de informação deve ser incluído na declaração de um
procedimento? E na declaração de uma função? Se houver diferenças,
explique o motivo.
4. Qual a diferença entre variável global e variável local?
5. Como deve ser feita a transmissão de informações entre um
subprograma e o programa principal?
6. Qual a diferença entre parâmetro real e parâmetro formal?
7. Cite os modos de passagem de parâmetros, explicando como funciona
cada um deles.
8. Escreva um procedimento que limpe a tela do micro e exiba o seu
nome.
9. Escreva um procedimento que receba uma string S e um inteiro
positivo N e exiba a string S por N vezes seguidas na tela.
10. Escreva uma função chamada CUBO que receba um valor do tipo real e
retorne a potência elevado a 3 do mesmo.
11. Escreva um procedimento chamado TROCA que receba duas variáveis
inteiras (X e Y) e troque o conteúdo entre elas;
12. Escreva uma função que receba uma string S e retorne o número de
espaços existentes na mesma.
13. Escreva uma função que receba uma string S e um valor inteiro N e
retorne os N primeiros caracteres da string S.
14. Escreva um procedimento chamado SINAL que receba como parâmetro
um valor N inteiro e escreva a palavra POSITIVO se N for um número
61
ENG06842 – Programação I
maior que zero, NEGATIVO se N for menor que zero, ou ZERO se N for
igual a zero.
15. Escreva um programa que leia um número inteiro e, usando o
procedimento SINAL (criado na questão anterior), mostre se ele é
maior, menor ou igual a zero.
16. Escreva um procedimento chamado METADE que divida um valor do
tipo real (passado como parâmetro) pela metade.
17. Escreva um programa que leia um vetor A de 30 elementos reais e,
usando o procedimento METADE (criado na questão anterior), divida
todos seus elementos pela metade.
18. Escreva uma função chamada MEDIA que retorne a média aritmética de
três valores reais (X, Y e Z) passados como parâmetros.
19. Escreva um programa que, para um número indeterminado de alunos,
faça para cada uma deles:
ler o nome e as três notas do aluno (a leitura do nome FIM indica o
fim dos dados - flag);
calcular a média do aluno (usando a função MEDIA criada na
questão anterior);
exibir o nome e a média do aluno.
20. Quantos números o programa abaixo imprimirá na tela?
program pares; var
contador: integer;
function NumeroPar(numero: integer): Boolean; begin
NumeroPar := (numero mod 2) = 0; end; begin
for contador := 1 to 100 do if (NumeroPar(contador)) then
writeLn(contador);
62
ENG06842 – Programação I
end.
21. O que o programa abaixo imprimirá na tela?
program Linhas; var
contador: Integer;
procedure ImprimeLinha(linha: integer); var
contador: integer; begin
for contador := 1 to linha do write(contador);
writeLn; end;
begin for contador := 1 to 10 do
ImprimeLinha(contador); end.
22. Descreva uma função POTENCIA que realize a operação de
potenciação e que contenha os seguintes parâmetros formais:
VALOR: número inteiro que se deseja elevar à potência.
POT: potência elevada
Ex: Na chamada da função POTENCIA(5,3), o resultado seria 125. Na
chamada da função POTENCIA(2,0), o resultado seria 1.
23. Escrever uma função DIGITO(N,K) que determine o valor do k-ésimo
dígito da direita para a esquerda de um número N inteiro. Ex:
DIGITO(379836,3) = 8 DIGITO(567,8) = 0.
24. Escreva uma função chamada SEG para receber uma medida de tempo
expressa em Horas, Minutos e Segundos e retornar esta medida
convertida apenas para segundos.
25. Escreva um procedimento chamado HMS para receber uma medida de
tempo expressa apenas em segundos em retornar esta medida
convertida para horas, minutos e segundos.
63
ENG06842 – Programação I
26. Faça um programa que leia duas medidas de tempo (expressas em
horas, minutos e segundos) e, usando a função SEG e o procedimento
HMS, calcule e exiba a diferença (também em horas, minutos e
segundos) entre elas.
27. Escreva uma função chamada NOME_MES que receba um valor inteiro
N (de 1 a 12) e retorne uma string contendo o nome do mês
correspondente a N.
28. Escrever um procedimento para leitura de um valor inteiro entre 1 e
100. Se o usuário fornecer um valor fora desta faixa, deve-se repetir o
processo até que seja fornecido um valor válido.
29. Fazer um programa para ler duas matrizes e apresentar a soma. Utilize
subprogramas (procedimentos e/ou funções) para ler, somar e escrever
as matrizes.
30. O que o programa abaixo faz? Quantas vezes o procedimento
AcertaPosicao será executado? Quantas vezes o procedimento Troca
será executado?
program Numeros; const
LIMITE = 5; var
contador: integer; numeros: array[1..LIMITE] of integer;
procedure Troca(x, y: integer); var
temporario: integer; begin
temporario := numeros[x]; numeros[x] := numeros[y]; numeros[y] := temporario;
end;
procedure AcertaPosicao(posicao: integer); var
indice: integer; begin
for indice := posicao + 1 to LIMITE do
64
ENG06842 – Programação I
if (numeros[indice] < numeros[posicao]) then Troca(posicaoindice);
end;
procedure LeNumeros; var
indice: integer; begin
writeln('Digite ', LIMITE, ' numeros: '); for indice := 1 to LIMITE do
readln(numeros[indice]); end;
procedure MostraNumeros; var
indice: integer; begin
write('O resultado e: '); for indice := 1 to LIMITE do
write(numeros[indice]:6); writeln;
end;
begin LeNumeros; for contador := 1 to 4 do
AcertaPosicao(contador); MostraNumeros;
end.
31. Leia 50 valores do tipo (nome, P1, P2, Nota_trabalhos,
Percentual_de_presença), e determine quantos alunos foram aprovados
e quantos foram reprovados. Para aprovação é preciso ter média maior
ou igual a 6 e 75% de presença. A média é calculada pela expressão:
Media = (P1 + P2) * 70% + Nota_trabalhos * 30%. Use uma função
para calcular a média. Utilize pelo menos um procedimento ou função.
32. Fazer uma função para multiplicar 2 matrizes A (MxN) e B (NxK) e
retornar a matriz resultado (MxK).
33. Escreva uma função recursiva FIB(n) que receba o inteiro n e
devolva o n-ésimo terma da seqüência de Fibonacci, definida
recursivamente por:
65
ENG06842 – Programação I
<<≥+
=3 n 0 se1
3 n se2)-FIB(n1)-FIB(n FIB(n)
66
ENG06842 – Programação I
11. Armazenamento de dados
A manipulação de dados apresentada nos capítulos anteriores estavam
em memória, ou seja, após a execução dos programas os dados se
perdiam. Para resolver esse problema, deve-se começar a trabalhar com
discos (HDs, disquetes, etc.), onde os dados poderão ser armazenados e
manipulados por um ou vários programas, pois ficarão armazenados em
algum local dos discos existentes no computador.
Geralmente, o armazenamento de dados é realizado através de um banco
de dados ou de um simples arquivo. A utilização de bancos de dados é
baseada na utilização de um Sistema Gerenciador de Banco de Dados
(SGBD), que oferece recursos para uma adequada e eficiente manipulação
dos dados. Entretanto, para utilização de um SGBD, deve-se inicialmente
compreender os conceitos para criação e utilização de um banco de
dados, e isso leva tempo. Normalmente, os bancos de dados são tratados
em uma disciplina única e exclusiva, cuja finalidade é trabalhar
diretamente nos seus principais conceitos. Dessa forma, será tratado
neste capítulo apenas o armazenamento de dados via arquivos, cuja
manipulação é menos eficiente, porém significativamente mais simples.
11.1. Arquivos
Um arquivo de dados tem a propriedade de ser independente dos
programas. É separado de qualquer programa e pode ser acessado e
usado por muitos programas diferentes. Na maioria dos casos, usa-se um
único programa para introduzir as informações no arquivo de dados e
gravá-lo em disco. A partir deste momento, pode-se ler as informações
daquele arquivo de dados usando muitos programas diferentes, cada um
executando uma atividade diferente com o arquivo.
Suponha que você tenha necessidade de criar um arquivo de dados, para
guardar os nomes, endereços e telefones de seus amigos. Inicialmente,
você precisará de um programa para introduzir as informações no arquivo
67
ENG06842 – Programação I
e adicionar novos dados ao mesmo. Um outro programa poderá ser criado
para listar as informações do arquivo.
Outro permitirá você selecionar um número de telefone do arquivo usando
o nome do amigo como critério de seleção. Você pode criar outro
programa para mudar os endereços e os telefones. Outro para imprimir
etiquetas contendo as informações do arquivo. As possibilidades
continuam...
O arquivo de dados é gravado no disco, separadamente dos programas,
num lugar específico, e pode ser acessado por muitos programas
diferentes. Cada programa descrito acima, copia as informações gravadas
no disco para memória do computador e esses dados são manuseados em
memória de acordo com as necessidades de cada programa.
Alternativamente, o programa poderá transferir as informações da
memória do computador para serem gravadas no disco.
O Turbo Pascal admite três tipos de arquivos:
Arquivo typed (arquivo tipado): pode conter praticamente todos
os tipos de dados, menos o tipo FILE. Isto quer dizer que pode-se
criar um arquivo para guardar reais, arrays, records, mas não se
pode criar um arquivo de arquivo. Cada elemento pertencente ao
arquivo tipado pode ser acessado diretamente pelo número, isto é,
um registro pode ser acessado imediatamente sem que tenhamos
que acessar todos os registros anteriores. Esse tipo de acesso é
denominado randômico ou direto. Um arquivo tipado é um arquivo
randômico.
Arquivo text (arquivo texto): pertence a um tipo predefinido do
Pascal denominado text. Os arquivos text são armazenados no disco
como linhas de caracteres ASCII e só podem ser acessados de forma
seqüencial, isto é, só podem ser lidos ou escritos do início para o fim
do arquivo. Um arquivo seqüencial em disco está projetado para ser
lido do início ao fim, toda vez que for aberto. Em outras palavras,
68
ENG06842 – Programação I
não existe uma forma de pular diretamente de um determinado
registro para outro num ponto qualquer do arquivo. Por essa razão,
os arquivos seqüenciais são melhor usados em aplicativos que
executam tarefas sobre todo um conjunto de dados ao invés de
executá-las sobre um determinado registro.
Arquivo untyped (sem tipo): pode ser associado a qualquer
arquivo de disco, sendo que o tamanho do registro seja de 128
bytes. As operações de entrada e saída usando um arquivo sem tipo
transferem dados diretamente de um arquivo em disco para uma
variável de memória e vice-versa, sem passar pela memória
temporária (buffer), o que, além de economizar espaço na memória,
também torna a operação ligeiramente mais rápida. Seu uso é muito
limitado. Quando um arquivo é aberto apenas para uma operação de
remoção ou troca de nome, é aconselhável usar um arquivo sem
tipo.
Os procedimentos para manipulação de qualquer arquivo são:
Definir uma variável de arquivo e associar a variável ao nome do
arquivo no disco.
Abrir o arquivo, para leitura ou para escrita ou para ambos.
Ler os dados do arquivo ou gravar dados no mesmo.
Fechar o arquivo quando o processo terminar.
O Pascal usa a palavra reservada text como identificador padrão de
arquivos-texto. A sintaxe para definir variáveis desse tipo é:
var
arq_alunos: text;
arq_func: text[512];
69
ENG06842 – Programação I
Os arquivos-texto são definidos inicialmente com memória temporária de
128 bytes. Isto quer dizer que o Pascal trabalha com 128 bytes de
informações de cada vez.
Esse tamanho de memória temporária é adequado para a maioria das
aplicações. Entretanto, no caso de programas que utilizam repetidamente
informações guardadas em disquetes, como é o caso de programas de
banco de dados, pode ser conveniente aumentar a capacidade de
memória temporária. Para estabelecer o tamanho da memória temporária,
basta colocar o número de bytes desejado entre colchetes depois da
palavra text, na declaração da variável de arquivo (como no exemplo
acima).
Normalmente, se declara uma variável de memória, do mesmo tipo de
dados que vão ser gravados ou lidos no arquivo. É essa variável que
guarda em memória os conteúdos dos registros que vão ser lidos do
arquivo ou que vão ser gravados no arquivo. Todo o manuseio com os
dados é feito em memória. O arquivo de dados é utilizado apenas para
gravar ou ler informações.
Exemplo:
type
dados = record
nome: string[30];
tel: string[10];
end;
var
arq_alunos: text;
registro: dados;
Para utilizar uma variável de arquivo para acessar um arquivo-texto, deve-
se associar a variável a um determinado nome de arquivo em disco.
Denomina-se esse processo como assinalamento. A função predefinida
que executa esta tarefa é assign. Assign associa o nome da variável de
70
ENG06842 – Programação I
arquivo a um nome de arquivo em disco. Nunca deve ser usada em
arquivos que já estejam em uso.
Exemplo:
assign(arq_alunos,‘alunos.dat’);
A partir desse comando, toda referência a “arq_alunos” no programa será
dirigida ao arquivo no disco chamado “alunos.dat”.
Caso um programa tenha mais de uma variável de arquivo, teremos que
assinalar individualmente cada variável, isto é, teremos tantos assign
quanto forem as variáveis de arquivo.
Assinalar uma variável a um arquivo é criar um buffer específico para
aquela variável. Um buffer é uma parte da memória do computador, com
determinada capacidade, que é criada para atuar como intermediário
entre o programa e o arquivo de dados no disco. A informação que se
encontra no disco, primeiro é copiada para buffer, uma determinada
quantidade de bytes de cada vez, estando, portanto, disponível ao
programa para manipulação. Do mesmo modo, as informações, para
serem gravadas em disco, são primeiramente acumuladas no buffer.
Quando o buffer está cheio, as informações são copiadas para o disco.
Graças aos buffers, os dados são movimentados corretamente, para os
arquivos especificados. O default (padrão) de arquivos que podem ser
abertos simultaneamente no Pascal é 16.
Exemplo:
uses crt;
type
dados = record
nome: string[30];
tel: string[10];
end;
var
71
ENG06842 – Programação I
arq_alunos: text;
registro: dados;
begin
clrscr;
assign(arq_alunos,‘alunso.dat’);
Um determinado arquivo-texto pode ser aberto para leitura ou gravação,
mas não para ambas operações ao mesmo tempo.
O Pascal fornece três funções diferentes para abertura de um arquivo-
texto:
rewrite(var de arquivo): cria um novo arquivo e o abre para
operações de escrita. Após a abertura, pode-se usar os comandos
WRITE e WRITELN para escrever os dados e linhas de texto no
arquivo. Caso o nome do arquivo já exista no disco, este
procedimento destrói o arquivo antigo e cria outro vazio e com o
mesmo nome, isto significa que todos os dados do arquivo existente
serão perdidos.
append(var de arquivo): abre um arquivo-texto já existente, de
modo que podemos adicionar novos registros no fim do arquivo.
Ocorre um erro de I/O (entrada e saída) se o arquivo não existir no
disco. Após a abertura, pode-se usar as funções WRITE e WRITELN
para escrever dados no arquivo.
reset(var de arquivo): abre um arquivo já existente para leitura.
Após a abertura do arquivo, pode-se usar as funções READ e
READLN para ler dados e linhas de texto do arquivo.
Em contraste com a função REWRITE que cria um arquivo novo destruindo
o antigo, caso exista, os comandos APPEND e RESET assumem a
existência de um arquivo nomeado no disco. Se o arquivo não puder ser
localizado, em ambos os casos, resultarão em erros de I/O em tempo de
execução.
72
ENG06842 – Programação I
Exemplo:
uses crt;
type
dados = record
nome: string;
tel: string;
end;
var
registro: dados;
arq_reg: text;
begin
clrscr;
assign(arq_reg,‘alunos.dat’);
rewrite(arq_reg);
write(‘Arquivo ALUNOS.DAT criado’);
readkey;
close(arq_reg);
end.
Exemplo:
uses crt;
type
dados = record
nome: string;
tel: string;
end;
var
registro: dados;
arq_reg: text;
conf: char;
begin
clrscr;
73
ENG06842 – Programação I
assign(arq_reg,‘alunos.dat’);
rewrite(arq_reg);
write(‘Arquivo ALUNOS.DAT criado’);
readkey;
repeat
write(‘Entre com um nome: ’);
readln(registro.nome);
write(‘Seu telefone: ’);
readln(registro.tel);
write(‘Confirma gravação? <S/N>: ’);
conf := upcase(readkey);
if conf = ‘S’ then
writeln(arq_reg,registro.nome,#32,registro.tel);
until conf=‘N’;
close(arq_reg);
end.
Obs.: podem ser usados como caracteres delimitadores de campos:
espaço (#32) e tabulação (#9).
Para fechar qualquer arquivo aberto, o Pascal dispõe do comando CLOSE,
como foi visto nos exemplos anteriores de programas.
Se vários arquivos foram abertos simultaneamente, teremos que fechá-los
individualmente, usando um comando close para cada um.
O comando CLOSE fecha o arquivo externo em disco, mas não termina
com o assinalamento feito pelo comando ASSIGN. Isto significa que o
programa pode usar um comando REWRITE, RESET ou APPEND após o
comando CLOSE se necessário.
CLOSE é um comando muito importante, pois é usado para manter a
integridade e exatidão dos arquivos de dados. Relembre que o buffer atua
como um intermediário entre o programa e o arquivo em disco. Quando se
executa uma operação de gravação, os dados são enviados
74
ENG06842 – Programação I
primeiramente para o buffer. Quando o buffer está cheio, os dados são
gravados em disco. Freqüentemente essa operação é chamada de
atualização de arquivos em disco.
O que acontece quando o buffer só está parcialmente cheio e não existem
mais dados para preenchê-lo. Se você está esperando que o buffer semi-
cheio simplesmente transfira seu conteúdo para o disco quando o
programa termina a sua execução, você está enganado. Os dados de um
buffer semi-cheio não são necessariamente gravados no arquivo.
O comando CLOSE força o buffer a transferir o seu conteúdo para o
arquivo de disco, mesmo que o buffer não esteja cheio.
Exemplo:
uses crt;
type
dados = record
nome: string;
tel: string;
end;
var
registro: dados;
arq_reg: text;
conf: char;
begin
clrscr;
assign(arq_reg,‘alunos.dat’);
reset(arq_reg);
with registro do
begin
repeat
readln(arq_reg,nome,tel); {lendo do arquivo}
write(nome,‘ ’,tel); {listando na tela}
75
ENG06842 – Programação I
until eof(arq_reg); {repita até que o final do arquivo seja
atingido}
end;
close(arq_reg);
readkey;
end.
Quando o programa está lendo uma seqüência de valores de um arquivo
texto, o comando READ reconhece os caracteres delimitadores usados
durante o processo de gravação.
O arquivo-texto foi projetado para conter só caracteres ASCII. Mesmo
assim, os comandos READ e READLN podem ler apropriadamente valores
de dados numéricos ou strings. É evidente que durante um processo de
leitura, não se pode colocar valor de uma variável string numa variável
numérica.
Já foi dito que um arquivo-texto é um arquivo seqüencial, por isso é
necessário sabermos quando o fim de arquivo foi atingido. A quantidade
de linhas gravadas pode ser controlada pelo programador, através de
técnicas, porém, o modo mais prático para se descobrir o fim do arquivo é
usar a função booleana EOF, como foi aplicado no exemplo acima.
A função EOF retorna true se o ponteiro estiver no final do arquivo. Caso
contrário, a função retornará false, indicando que o fim do arquivo não foi
atingido.
11.2. Exercícios
1. Dado um arquivo existente, com registros com os dados: nome, sexo,
endereço e idade. Criar 2 arquivos, um só com os homens e outro só
com as mulheres.
2. Criar um arquivo de alunos (nome, nro, p1, p2, media) para armazenar
elementos (quantos o usuário quiser). Abrir o arquivo e atualizá-lo com
as médias dos alunos. A seguir, liste nome e média de cada aluno.
76
ENG06842 – Programação I
3. Estoque de supermercado. Faça um programa para controlar o estoque
de um supermercado. Para cada produto armazene (em arquivo):
nome, estoque, preço, e estoque mínimo. Leia os dados para o estoque
e guarde em um vetor. Depois percorra o vetor e escreva o nome e as
demais informações de todos os produtos que estão com estoque
abaixo do estoque mínimo.
4. Folha de pagamentos. Monte um vetor para armazenar o nome, cargo,
salário bruto de cada funcionário de uma empresa. Depois execute a
folha de pagamentos da seguinte forma: para cada funcionário,
imprima nome, salário bruto e salário líquido (para salários menores
que 1000 o salário líquido é o próprio salário bruto; para salários
maiores ou iguais a 1000 o salário líquido é cerca de 87% do salário
bruto).
77
ENG06842 – Programação I
Referências
[1] COLLINS, W. J. Programação estruturada com estudos de casos
em Pascal. McGraw-Hill. (1988) São Paulo. 1988. 712p.
[2] FARRER, H. et al. Algoritmos estruturados. Livros Técnicos e
Científicos. 3a ed. Rio de Janeiro. 1999.
[3] FARRER, H. et al. Pascal estruturado. Livros Técnicos e Científicos. 3a
ed. Rio de Janeiro. 1999. 278p.
[4] FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lógica de programação:
a construção de algoritmos e estruturas de dados. Pearson
Education do Brasil. 2a ed. São Paulo. 2000.
[5] GUIMARÃES, A. M.; LAGES, N. A. C. Algoritmos e Estruturas de
Dados. Rio de Janeiro, LTC, 1994.
[6] MANZANO, J. A. N. G. Algoritmos: lógica para desenvolvimento de
programação. Erica. 10a ed. São Paulo. 2000.
78
ENG06842 – Programação I
Apêndice A – Mensagens de erro do Turbo Pascal
A seguir são apresentados os principais “possíveis” erros de compilação
do Turbo Pascal 7.0.
ERRO DESCRIÇÃO TRADUÇÃO1 Out of memory Não existe espaço em memória2 Identifier expected Identificador esperado3 Unknown identifier Identificador desconhecido4 Duplicate identifier Identificador já existente5 Syntax error Erro de sintaxe6 Error in real Constant Erro na constante real7 Error in integer Constant Erro na constante inteira8 String Constant exceeds line Constante string excede a linha9 Too many nested files Muitos arquivos aninhados10 Unexpected end of file Fim de arquivo não esperado11 Line too long Linha muito longa12 Type identifier expected Espera a identificação do tipo13 Too many open files Muitos arquivos abertos simultaneamente14 Invalid file name Nome de arquivo inválido15 File not found Arquivo não encontrado16 Disk full Disco cheio17 Invalid file name Diretiva de compilação inválida18 Too many files Excesso de arquivos19 Undefined type in pointer def Ponteiro nunca antes declarado20 Variable identifier expected Identificador de variável esperado21 Error in type Erro de tipo22 Structure too large Estrutura muito larga23 Set base type out of range Faixa de valores inválida para a faixa
24File components may not be files or objects
Componentes do arquivo não devem ser arquivos ou objetos
25 Invalid string length Tamanho de string inválido26 Type mismatch Tipos misturados / incompatível27 Invalid subrange base type Faixa de valores inválida28 Lower bound > than upper bound Limite inferior > limite superior29 Ordinal type expected Tipo escalar esperado30 Integer Constant expected Constante inteira esperada31 Constant expected Constante esperada32 Integer or real Constant expected Constante inteira ou real esperada33 Pointer type identifier expected Identificador de tipo ponteiro esperado34 Invalid function result type Tipo de resultado da função inválido35 Label identifier expected Identificador Label esperado36 Begin expected Begin esperado37 End expected End esperado38 Integer expression expected Expressão inteira esperada39 Ordinal expression expected Expressão ordinal esperada40 Boolean expression expected Expressão booleana esperada41 Operand types do not match Operando incompatível com o operador42 Error in expression Erro na expressão43 Illegal assignment Associação ilegal44 Field identifier expected Identificador de campo esperado45 Object file too large Arquivo objeto muito grande46 Undefined extern Extern indefinido47 Invalid object file Record Objeto de registro de arquivo inválido48 Code segment too large Segmento de código muito grande49 Data segment too large Segmento de dados muito grande
79
ENG06842 – Programação I
50 Do expected Do esperado51 Invalid public definition Definição public inválida52 Invalid extern definition Definição extern inválida53 Too many extern definitions Excesso de definições extern54 Of expected Of esperado55 Interface expected Interface esperada56 Invalid relocatable reference Referência relocável inválida57 Then expected Then esperado58 To or Downto expected To ou Downto esperado59 Undefined forward Forward indefinido60 Too many procedures Excesso de procedures61 Invalid typecast Tipo de resultado inválido62 Division by zero Divisão por zero63 Invalid file type Tipo de arquivo inválido
64Cannot read or write vars of this type
Variáveis desse tipo não podem ser lidas / escritas
65 Pointer variable expected Variável do tipo ponteiro esperada66 String variable expected Variável do tipo String esperada67 String expression expected Expressão string esperada68 Circular unit reference Referência circular da unit69 Unit name mismatch Nome da unit incompatível70 Unit version mismatch Versão da unit incompatível71 Duplicate unit name Nome da unit duplicada72 Unit file format error Erro no formato do arquivo unit73 Implementation expected Implementation esperado
74Constant and case types don’t match
Constante e expressão do case incompatíveis
75 Record variable expected Variável do tipo Record esperada76 Constant out of range Constante fora de faixa77 File variable expected Variável de arquivo esperada78 Pointer expression expected Expressão tipo ponteiro esperada79 Integer or real expression expected Expressão inteira ou real esperada80 Label not within current block Label for a do bloco atual81 Label already defined Label já foi definido82 Undefined label in stmt part Label não declarado83 Invalid @@ argument Argumento @@ inválido84 Unit expected Unit esperado85 “;” expected “;” esperado86 “:” expected “:” esperado87 “,” expected “,” esperado88 “(“ expected “(” esperado89 “)” expected “)” esperado90 “=” expected “=” esperado91 “:=” expected “:=” esperado92 “[“ or “(“ expected “[” or “(” esperado93 “]” or “)” expected “]” or “)” esperado94 “.” Expected “.” Esperado95 “..” expected “..” esperado96 Too many variables Variáveis demais97 Invalid for control variable Variável de controle loop for inválida98 Integer variable expected Variável do tipo integer esperada
99Files and procedure types are not allowed here
Arquivos e procedimentos não permitidos aqui
100 String length mismatch Comprimento da string incompatível
A seguir é apresentada uma tabela com uma relação dos principais erros
em tempo de execução (run-time errors) do Turbo Pascal 7.0.
80
ENG06842 – Programação I
ERRO DESCRIÇÃO TRADUÇÃO1 Invalid function number Função numérica inválida2 File not found Arquivo não encontrado3 Path not found Caminho não encontrado4 Too many open files Muitos arquivos abertos5 File Access denied Acesso ao arquivo negado6 Invalid file handle Arquivo handle inválido
12 Invalid file Access code Código de acesso de arquivo inválido15 Invalid drive number Número do drive inválido
16Cannot remove current directory
Impossível remover diretório atual
17 Cannot rename across drives Impossível renomear diretório18 Não há mais arquivos
100 Disk read error Erro de leitura do disco101 Disk write error Erro de gravação do disco102 File not assigned Arquivo não assinalado103 File not open Arquivo não aberto104 File not open for input Arquivo não está aberto para entrada105 File not open for output Arquivo não está aberto para saída106 Invalid numeric format Formato numérico inválido150 Disk is write-protect Disco protegido151 Erro interno do dispositivo DOS152 Drive not ready Drive não pronto para leitura154 CRC error in data Erro de CRC nos dados156 Disk seek error Erro de pesquisa no disco157 Unknown media type Tipo de mídia desconhecida158 Sector not found Setor não encontrado159 Printer out of paper Impressora sem papel160 Device write fault Falha no dispositivo de escrita161 Device read fault Falha no dispositivo de leitura162 Hardware failure Falha no hardware200 Division by zero Divisão por zero201 Range check error Erro de faixa202 Stack overflow error Erro de estouro de pilha203 Heap overflow error Erro de estouro de heap204 Invalid pointer operation Operação de ponteiro inválida205 Floating point overflow Estouro de ponto flutuante207 Invalid floating point operation Operação de ponto flutuante inválida208 Overlay manager not installed Gerenciador de overlay não instalado209 Overlay file read error Erro na leitura de arquivo overlay210 Object not initialized Objeto não inicializado211 Call to abstract method Chamada a um método abstrato213 Collection index out of range Índice de coleção fora da faixa214 Collection overflow error Erro de estouro da coleção215 Arithmetic overflow error Erro de estouro aritmético216 General protection fault Falha de proteção geral
81
ENG06842 – Programação I
Apêndice B – Tabela de códigos ASCII
ASCII (acrônimo para American Standard Code for Information
Interchange) é um conjunto de códigos para o computador representar
números, letras, pontuação e outros caracteres. É uma padronização da
indústria de computadores, onde cada caractere é manipulado na
memória, discos, etc.
O código ASCII representa uma maneira de codificar caracteres na forma
de valores inteiros. Neste código, os caracteres são mapeados para
valores numéricos representáveis por 8 bits. Este código abrange 95
caracteres passíveis de impressão e 33 caracteres especiais utilizados,
entre outros, no controle de comunicação entre computadores ou um
computador e seus periféricos. Os 33 caracteres de controle são os de
código 0 a 31 (NUL a US) e o de código 127 (DEL).
A tabela abaixo descreve o padrão ASCII.
Código Valor Comentário0 NUL Caracter Nulo1 SOH Começo de cabeçalho de transmissão2 STX Começo de texto3 ETX Fim de texto4 EOT Fim de transmissão5 ENQ Interroga6 ACK Confirmação7 BEL Sinal sonoro8 BS Volta um caracter9 HT Tabulação Horizontal
10 LF Próxima linha11 VT Tabulação Vertical12 FF Próxima Página13 CR Início da Linha14 SO Shift-out15 SI Shift-in16 DLE Data link escape17 D1 Controle de dispositivo18 D2 Controle de dispositivo19 D3 Controle de dispositivo20 D4 Controle de dispositivo21 NAK Negativa de Confirmação22 SYN Synchronous idle23 ETB Fim de transmissão de bloco24 CAN Cancela
82
ENG06842 – Programação I
25 EM Fim de meio de transmissão26 SUB Substitui27 ESC Escape28 FS Separador de Arquivo29 GS Separador de Grupo30 RS Separador de registro31 US Separador de Unidade32 Espaço 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N
83
ENG06842 – Programação I
79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ 96 ` 97 a 98 b 99 c
100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 DELETE
84