Notas de Aula
“A linguagem de programação Pascal”
Conceitos básicos
Marcelo Trindade Rebonatto
e-mail: [email protected]
página: http://vitoria.upf.tche.br/~rebonatto
Universidade de Passo Fundo
Curso de Ciência da Computação
2
Sumário
1
2
3
4
5
6
7
Introdução ______________________________________________________________________ 4
1.1 O que é um programa ___________________________________________________________ 4
1.2 Evolução da programação________________________________________________________ 4
1.3 O que é uma Linguagem de Programação ___________________________________________ 5
1.4 Normas Básicas de Programação __________________________________________________ 5
Linguagem TURBO PASCAL ______________________________________________________ 6
2.1 Estrutura de um Programa em Turbo Pascal__________________________________________ 6
2.1.1 Área de Identificação _______________________________________________________ 7
2.1.2 Área das definições de Variáveis ______________________________________________ 7
2.1.3 Área dos Procedimentos e Funções ____________________________________________ 8
2.1.4 Área do Programa __________________________________________________________ 8
2.2 Observações relativas a escrita de programas Pascal ___________________________________ 9
2.3 Comentários __________________________________________________________________ 9
Tipos de dados _________________________________________________________________ 10
3.1 Identificadores________________________________________________________________ 10
3.2 Introdução aos Tipos de Dados Padrão_____________________________________________ 11
3.2.1 Tipos de variáveis numéricas inteiras __________________________________________ 11
3.2.2 Tipos de variáveis numéricas Reais ___________________________________________ 11
3.2.3 Tipos de dados lógicos: Boolean _____________________________________________ 11
3.2.4 Tipos de dados caracter: Char e String _________________________________________ 12
3.3 Ambiente Turbo Pascal _________________________________________________________ 12
3.3.1 Comandos de edição _______________________________________________________ 12
3.3.2 Manipulação de Blocos _____________________________________________________ 12
3.3.3 Funções para uso do ambiente Turbo Pascal ____________________________________ 12
Comandos e funções do Turbo Pascal _______________________________________________ 14
4.1 Comandos/Funções básicos aos programas _________________________________________ 14
4.2 Programa exemplo sem procedimentos ____________________________________________ 16
4.3 Programa exemplo com procedimentos ____________________________________________ 17
Programas seqüenciais ___________________________________________________________ 18
5.1 Exercícios de programas seqüenciais no Turbo Pascal_________________________________ 18
Testes e Seleções________________________________________________________________ 21
6.1 Condição ____________________________________________________________________ 21
6.2 Comando Condicional Simples___________________________________________________ 23
6.3 Comando Condicional Múltiplo __________________________________________________ 25
6.4 Exercícios de programas com seleção no Turbo Pascal ________________________________ 26
Comandos de Repetição __________________________________________________________ 28
7.1 Novos Conceitos na utilização de variáveis _________________________________________ 28
7.1.1 CONTADOR ____________________________________________________________ 28
7.1.2 ACUMULADOR _________________________________________________________ 28
7.1.3 FLAG __________________________________________________________________ 28
7.2 Laço com contador ____________________________________________________________ 29
7.3 Laço com teste no final _________________________________________________________ 30
7.4 Laço com teste no início ________________________________________________________ 31
7.5 Exercícios de programas com repetição ____________________________________________ 32
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
3
8 Técnicas avançadas de programação ________________________________________________
8.1 Definição de Constantes ________________________________________________________
8.2 Variáveis locais e variáveis globais _______________________________________________
8.3 Passagem de Parâmetros ________________________________________________________
8.4 Funções _____________________________________________________________________
8.5 Exercícios com funções e passagem de parâmetros ___________________________________
9 Tipo de dados orientados a caracteres________________________________________________
9.1 Caracter _____________________________________________________________________
9.2 Tipo de dados “Char” __________________________________________________________
9.3 Tipo de dados “String” _________________________________________________________
9.4 Exercícios de manipulação de “strings” ____________________________________________
10 Novos tipos de dados ____________________________________________________________
10.1 Conjunto de Dados de mesmo tipo (array) __________________________________________
10.1.1 Manipulação de conjuntos de dados de mesmo tipo_______________________________
10.1.2 Vetores _________________________________________________________________
10.1.3 Exercícios de programas com manipulação de vetores ____________________________
10.1.4 Matrizes_________________________________________________________________
10.1.5 Exercícios de programas com manipulação de matrizes ___________________________
10.2 Conjuntos de dados de tipos diferentes_____________________________________________
10.2.1 Exercícios de programas com manipulação de registros ___________________________
11 Arquivos ______________________________________________________________________
11.1 Exercício com manipulação de arquivos ___________________________________________
12 Glossário de Funções do Pascal ____________________________________________________
12.1 Funções matemáticas __________________________________________________________
12.2 Funções para uso com tipos caracter_______________________________________________
12.3 Funções/procedimentos e comandos de propósito geral________________________________
13 Bibliografia ____________________________________________________________________
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
35
35
35
37
38
40
41
41
41
42
43
44
44
44
45
47
49
51
53
55
56
62
63
63
64
66
68
4
1 Introdução
“A programação diferencia o computador de todas as outras máquinas. Ao lhe proporcionar
funcionalidade, interatividade e flexibilidade torna-o um aliado útil em inúmeras atividades, como
cálculos, processamento gráfico, comunicação e lazer.”
“A programação exige persistência, paciência, criatividade, raciocínio lógico e capacidade de
estudo.”
“Tudo o que há dentro de um computador, além das funções que ele realiza, foi criado pelo
homem. Pode, portanto, ser explicado e entendido.”
1.1 O que é um programa
Programas são seqüências de instruções executadas pelo computador, ou mais precisamente, pelo
seu cérebro, o processador. As instruções nem sempre são realizadas na mesma seqüência, a ordem muda
e trechos do programa podem ou não ser executados.
O programa age de acordo com as ações do usuário e as condições internas da máquina. É isso
que confere ao computador sua capacidade de “tomar decisões” e agir com “inteligência”.
1.2 Evolução da programação
Desde a década de 40, quando surgiram os primeiros computadores, os programas tem evoluído
com grande rapidez.
I.
II.
III.
IV.
A programação por Hardware : Os engenheiros que desenvolveram os primeiros computadores
criavam os programas mudando fisicamente suas conexões. Eram utilizados grandes painéis, com
centenas de conectores, semelhantes às antigas mesas telefônicas. A programação era alterada
plugando-se os fios em diferentes conectores. O processo era complicado e sujeito a muitos erros.
Para salvar um programa, somente em diagramas impressos em papel (fotografias da mesa de
conexões).
As instruções numéricas : No início cada instrução era representada no formato numérico. Uma
determinada combinação numérica significava “some”, “mova para outra posição”, “inverta”,
“diminua” ou outra operação elementar. Os programas eram montados escrevendo-se um código
composto por uma seqüência dessas instruções elementares. Os programas podiam ser guardados
em dispositivos que possibilitavam sua fácil recuperação.
A Linguagem Assembly : Para contornar o problema, os engenheiros associaram cada instrução a
uma palavra que lembrasse seu significado. Por exemplo, a instrução “somar” foi representada
pela palavra “ADD” (adicionar, em inglês), a instrução “diminua” foi representada pela palavra
“SUB”, entre outros. Apesar do avanço, ainda havia dificuldades. Como as instruções dadas ao
computador devem ser elementares (simples), para a execução de uma única ação eram
necessárias dezenas de instruções em linguagem Assembly. Isso tornava a escrita de programas
muito trabalhosa. E, apesar de baseadas em palavras em no idioma inglês, na prática era muito
difícil entender seu significado.
Linguagens de Programação de médio e alto nível : Criadas para contornar as dificuldades da
linguagem Assembly. Utilizam palavras e expressões em inglês, além de operadores matemáticos
semelhantes ao que usamos em nosso dia-a-dia. Uma única instrução nestas linguagens eqüivale a
dezenas ou centenas de instruções em linguagem Assembly. Escrever um programa agora
assemelha-se a escrever uma série de instruções em inglês. Depois do código pronto, programas
especiais chamados “compiladores” e “interpretadores” traduzem os programas em linguagem de
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
V.
5
alto nível para as instruções elementares em formato numérico que o computador executa.
Existem centenas de linguagens de alto e médio nível, cada uma adequada a um tipo específico de
aplicação. Algumas das mais comuns são : Pascal, Fortran, C, Cobol, Clipper, Basic, Java, entre
outras.
Ambientes gráficos de desenvolvimento : Tradicionalmente, o programador escolhia uma
linguagem e a usava para escrever todas as instruções que formavam seu programa. Mas, com o
tempo, os software ficaram mas sofisticados e o processo de criação ficou demorado, mesmo com
as linguagens de programação de alto nível. Com a popularização dos ambientes gráficos, como
Windows e Mac OS, os diferentes softwares utilizados em um computador passaram a ter
afinidades, ou seja, soluções semelhantes. Isso permitiu a criação de ambientes de programação
que geram as instruções automaticamente segundo diretrizes fornecidas graficamente pelo
programador. Os ambientes de desenvolvimento que automatizam parte da criação do código do
programa são as ferramentas RAD (Rapid Application Development - Desenvolvimento rápido de
aplicativos). Atualmente as ferramentas RAD mais conhecidas são o Borland Delphi e Microsoft
Visual Basic.
1.3 O que é uma Linguagem de Programação
Uma linguagem de programação é o elo entre a linguagem que os seres humanos entendem e as
instruções que uma máquina deve executar para realizar uma determinada ação. Entretanto, a linguagem
sozinha é insuficiente: precisamos do auxílio de um COMPILADOR.
• COMPILADOR: Programa de computador (escrito por outras pessoas), que traduz a linguagem
entendida pelo homem e gera um código a ser entendido pela máquina em um processo de
COMPILAÇÃO.
• COMPILAÇÃO: Passar para a linguagem de máquina as instruções escritas em uma Linguagem de
Programação.
• INTERPRETADOR: Programa de computador que em tempo de execução (ou seja enquanto o
programa esta sendo executado) traduz a linguagem de programação de alto nível para um código que
a máquina entende. Dá mais flexibilidade ao programa, porém o torna mais lento.
1.4 Normas Básicas de Programação
Existem algumas normas de programação que são mundialmente respeitadas. Nada mais útil do
que listá-las. Sempre que escrevermos um programa devemos respeitá-las.
•
•
•
•
•
•
•
•
S E M P R E mesmo
Usar SEMPRE comentários em seu código fonte;
Usar IDENTAÇÃO de seus fontes. (Padrão min 3 espaços);
O padrão de indentação (endenação) deve ser o mesmo em todo o programa e deve ser inserido na
digitação do programa e não após ele já estar pronto;
Nunca tentar redefinir palavras reservadas de um compilador;
Em expressões matemáticas, não existem {} (Chaves), [] (Colchetes). Todos os níveis de precedência
devem ser construídos com () (Parênteses);
Todas as regras matemáticas são respeitadas pelo computador;
O 0 (zero) é totalmente diferente de nada --> 0 <> Nada;
Devemos sempre que possível aproveitar ao máximo as linhas de código e as variáveis já existentes;
• O computador detecta somente erros de sintaxe, nunca erros de lógica.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
6
2 Linguagem TURBO PASCAL
O turbo pascal é uma linguagem de programação de grau médio (não tem muitas funções,
principalmente comercias definitas, mas dá um alto grau de poder ao programador para fazer o que quiser
como quiser). Devido ao seu grau, é uma das linguagens mais rápidas existentes. É uma linguagem de
programação muito difundida no meio tecnológico, ela é de fácil assimilação e rápido aprendizado. Todos
os seus comandos e funções são palavras ou abreviações que podem ser facilmente decifradas
(entendidas, traduzidas) no idioma inglês.
2.1 Estrutura de um Programa em Turbo Pascal
Área de Identificação
Área de definições de variáveis
Área dos procedimentos e Funções
Área do programa Principal
Igual a de qualquer folha, a mesma ordem de leitura de um programa é mantida, ou seja, o
programa é lido de cima para baixo, da esquerda para a direita.
a) Primeiro, devemos dizer que programa estamos escrevendo (área de identificação).
b) Logo após, dizemos quais são as variáveis envolvidas em nosso programa (área de definições de
variáveis).
c) Em seguida, escrevemos o código dos programas propriamente dito, ou seja, devemos escrever tudo
aquilo que desejamos que o nosso programa faça. Escrevemos isto em procedimentos e funções (área
dos procedimentos e funções).
d) Finalmente, decidimos qual a ordem de chamada dos procedimentos e das funções. O primeiro
procedimento a ser chamado será também o primeiro a ser executado (área do programa principal).
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
7
2.1.1 Área de Identificação
•
•
•
•
•
•
É uma área obrigatória em um programa.
Serve para a identificação do programa.
Deve obrigatoriamente conter comentários.
Deve começar pela palavra chave “program”, seguida do nome do programa, que deve começar por
letras, com tamanho máximo de 64 caracteres e ser mnemônico.
Deve-se terminar a frase com um ponto-e-vírgula (;)
A seguir devemos incluir o uso de bibliotecas que contém os principais comandos e funções por nós
utilizados em nossos programas.
Exemplo
program primeiro;
{ Este programa serve para o calculo de anos bissextos }
{ Autor: Fulano de tal
Criado em: 29/02/1500 }
{ Última modificação:
30/02/1900 }
uses crt;
2.1.2 Área das definições de Variáveis
•
•
•
•
•
•
É onde vamos definir todas (mas todas mesmo) as variáveis que vamos utilizar no programa.
Deve começar pela palavra chave “var”
Após, na próxima linha, os nomes das variáveis, divididos por vírgulas.
Os nomes das variáveis seguem as mesmas regras do nome do programa.
Após a última variável de uma linha, utilizaremos o separador dois-pontos e colocaremos o tipo desta
lista de variáveis, terminando a frase com um ponto-e-vírgula.
Nas próximas linhas, repetimos as listas de variáveis (com nomes diversos) de tipos diferentes ou não.
Exemplo
var
mes, dia, ano
salario
folgou_feriado
dias_trabalhados
<nome>, <nome>
......, ......
:
:
:
:
:
:
integer;
real;
boolean;
integer;
<tipo de variável> ;
..................
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
8
2.1.3 Área dos Procedimentos e Funções
•
•
•
•
•
•
•
•
•
É onde definimos os procedimentos e funções a serem utilizados em nosso programa.
Procedimentos e funções executam uma determinada ação que pode ou não se repetir no programa.
A diferença básica entre procedimento e função é que a função retorna um valor, e o procedimento
não.
A definição de um procedimento deve começar com a palavra chave “procedure”, seguida do
nome deste procedimento e terminada por um ponto-e-vírgula.
A seguir, na próxima linha a palavra chave “begin”
Nas demais linhas, os comandos a serem executados, sempre terminando a linha com um ponto-evírgula.
Podemos chamar um procedimento/função dentro de outro, desde que o procedimento/função
chamado tenha sido escrito antes daquele que o chama.
Para terminarmos o procedimento, devemos inserir a palavra chave “end” seguida de um ponto-evírgula
A definição de uma função segue as mesmas regras de um procedimento.
Exemplo:
procedure inicio;
begin
gotoxy(10,10);
write('Inicio do programa');
end ;
2.1.4 Área do Programa
•
•
•
•
•
É uma área obrigatória.
É onde o programa começa realmente a ser executado. O primeiro comando da área de programa será
o primeiro comando a ser executado.
Deve começar pela palavra chave “begin”.
Nas demais linhas devem continuar as chamadas de procedimentos/funções e comandos para
efetuarmos nosso programa, terminadas com um ponto-e-vírgula.
Deve terminar com a palavra chave “end”, seguida de um ponto-final (.).
Exemplo
begin
clrscr;
inicio;
leitura;
x := calculo(a, b);
mostra('o resultado de x vale');
end.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
9
2.2 Observações relativas a escrita de programas Pascal
•
•
•
•
•
•
Uma linha de comando em Pascal termina sempre com um ponto-e-vírgula (;)
Podemos ter dois comandos em uma mesma linha, desde que os mesmos estejam separados por
ponto-e-vírgula (;)
Escrever os comandos e chamadas de funções da linguagem em letras minúsculas (utilização com o
Pascal)
As regras para nomes de identificadores (nome do programa, nomes de variáveis, nomes de
procedimentos/funções) válidas em Pascal são que os mesmos devem obrigatoriamente começar por
letras, ter no máximo 64 caracteres e não possuir espaços em branco no meio do nome.
Os nomes de quaisquer identificadores (variáveis, procedimentos, nome do programa, funções) não
podem em hipótese nenhuma ser repetidos.
Após o término de cada área de programa ou após cada procedimento é aconselhável deixarmos uma
linha em branco para uma melhor organização do nosso código fonte.
2.3 Comentários
Os comentários devem ser escritos, sempre. Eles servem para futuramente sabermos o que
fizemos nos programas, ou até mesmo em grandes empresas para sabermos o que outros fizeram. É
aconselhável ao início de um programa ou um procedimento, escrever para que serve o
programa/procedimento, qual a lógica utilizada e, em programas, o nome do autor e a data de criação bem
como a data da última modificação.
Eles são identificados pelos símbolos “{“, ”}” (chaves) que marcam respectivamente o início e o
fim do trecho de comentários. Os comentários não são interpretados pelo compilador.
Exemplo
program calc_media;
uses wincrt;
{ Este é um programa de teste que calcula a média dos alunos }
procedure calculo;
{ Este procedimento calcula as raizes de uma equação de 2º
grau, usando a formula de báskara }
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
10
3 Tipos de dados
Os dados são representações das informações a serem processadas por um programa de
computador. Estas informações estão classificadas em diversos tipos de dados, cada um com suas
particularidades.
Existem tipos de dados básicos, que se eqüivalem em todas as linguagens de programação. Estes
tipos padrões representam os dados , e são divididos basicamente em quatro categorias:
• Inteiros (números inteiros);
• Reais (números fracionários);
• Caracteres (quaisquer seqüências de letras e números);
• Lógicos (só podem ser verdadeiro ou falso).
As linguagens de programação possuem ainda tipos de dados padrões que representam todos os
tipos básicos. Na linguagem Pascal, ainda podemos criar nossos próprios tipos de dados.
3.1 Identificadores
Para a execução de um programa, o computador faz uso das instruções a serem executadas,
juntamente com os valores dos dados que o programa manipula. Como já vimos, uma instrução pode ser
um comando ou uma chamada de procedimento/função.
Um procedimento/função é identificado pelo seu nome. Os dados que o programa manipula,
devem também ser identificados. Para isto existem as variáveis e constantes, que nada mais são do que a
identificação na memória do computador de um dado em especial. Como a memória do computador é
internamente identificada através de posições (números, onde estão gravados valores em binário), o uso
de identificadores ao invés de sua posição na memória é de vital importância para o programador.
Existem regras para a definição dos identificadores, são elas:
• Devem obrigatoriamente começar por letras, ter no máximo 64 caracteres e não podem possuir
espaços em branco no meio do nome;
• É indiferente o uso de letras maiúsculas ou minúsculas no nome de identificadores. O Pascal
reconhece apenas o significado, não importando se foi escrito em letras maiúsculas ou minúsculas;
• Todos os nomes definidos pelo programador (nomes de variáveis, do programa, de procedimentos e
de funções) devem ser mnemônicos e nunca repetidos;
• Nunca usar uma variável sem antes defini-la. E, após utilizá-la, ter certeza de liberar seu espaço
ocupado na memória;
• Nunca utilizar o valor de uma variável sem antes ter certeza de que ela realmente já possua um valor.
• Constantes: Como o próprio nome diz, são valores que nunca mudam de valor durante a execução de
um programa. Na prática devemos ao início de um programa definir o valor da constante e ela
permanecerá com este valor até o final do programa.
• Variáveis: São identificados por um nome . Seu valor pode mudar durante a execução de um
programa. Tecnicamente são regiões na memória principal em que guardamos determinados dados.
Podemos sempre verificar ou alterar seu conteúdo.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
11
3.2 Introdução aos Tipos de Dados Padrão
Os programas Pascal podem trabalhar com dados expressos como valores literais (tal como o
string 'Passo Fundo' ou o número 5) ou com valores representados simbolicamente por
identificadores (tais como variáveis ou constantes). Sem considerar como o valor do dado está expresso,
deve-se tomar cuidado para distinguir os diversos tipos de dados que o Turbo Pascal reconhece. A mistura
de tipos de dados de modo não apropriado resulta em erros em tempo de compilação. A linguagem Pascal
possui diversos tipos de dados padrão, dos quais os mais usados são:
• Tipos numéricos inteiros (integer);
• Tipos de números reais (real);
• Tipos de caractere (char) e string (string);
• Tipo Booleano (boolean).
3.2.1 Tipos de variáveis numéricas inteiras
São variáveis que guardam apenas tipos de dados inteiros. São usadas para armazenarem dados
que sabidamente são inteiros, e como contadores. Os diversos tipos variam apenas de acordo com o
intervalo de valores e o número de bytes que ocupam na memória. São manipuladas pelo programador em
números decimais e podem ser visualizadas sem nenhuma formatação especial.
Nome
Byte
Shortint
Integer
Word
Longint
Intervalo de Valores
0 .. 255
-128 .. 127
-32768 .. 32767
0 .. 65535
-2147483648 .. 2147483647
Tamanho em Bytes
1
1
2
2
4
3.2.2 Tipos de variáveis numéricas Reais
São variáveis que guardam tipos de dados reais. Sabidamente, englobam também os números
inteiros, ou seja, podemos guardar nelas valores inteiros. Os diversos tipos variam de acordo com o
intervalo de valor e a precisão dos números após a vírgula. Alguns tipos específicos necessitam de
diretivas ao processador. São manipuladas pelo programador em notação científica. Para serem
visualizadas necessitam de formatação.
Nome
Single
Real
Double
Comp
Extended
Intervalo de Valores Dígitos significativos
1.5*10-45 .. 3.4*1038
7-8
-39
38
2.9*10 .. 1.7*10
11-12
-324
308
5.0*10 .. 1.7*10
15-16
63
63
-2 +1.. 2* +1
19-20
3.4*10-4932 .. 1.1*104932
19-20
Tamanho em Bytes
4
6
8
8
10
3.2.3 Tipos de dados lógicos: Boolean
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
12
Variável lógica, só assume dois valores pré-definidos “True” (verdadeiro) e “False” (falso)
representados internamente por 1 e 0, respectivamente. Ocupa 1 byte. São manipuladas pelo programador
como caracteres, “TRUE” ou “FALSE”. Para outro tipo de visualização necessitam de tratamento.
3.2.4 Tipos de dados caracter: Char e String
•
Char: Variável em que se armazena um caracter de acordo com o conjunto ASCII estendido (0-255);
normalmente representado entre aspas (' '), pode ser apenas um caracter e ocupa 1 byte. Mais de 1
caracter, usar o tipo string.
•
String: Cadeia de até 255 caracteres, armazena valores alfanuméricos (números e letras). Ocupa 1
byte por caracter. Pode-se visualizar um string como uma matriz de Char.
São manipuladas pelo programador de forma igual ao seu conteúdo, ou seja, não necessitam nem
de tratamento nem de formatação para uma perfeita visualização.
3.3 Ambiente Turbo Pascal
Para uma maior facilidade na programação, foi desenvolvido o ambiente Turbo Pascal. Este ambiente,
fornece um editor de textos personalizado para a escrita de programas, compilador e ambiente de
execução. Todos os componentes são integrados em apenas um programa. A seguir, uma referência dos
principais comandos e funções utilizados.
3.3.1 Comandos de edição
♦
♦
♦
♦
♦
♦
♦
<Insert>, ^v : Troca o modo Insert/OverWrite
<Delete>, ^d : Apaga o caracter atual (em cima do cursor)
<BackSpace>, ! : Apaga o caracter imediatamente a esquerda do cursor
^t : Apaga a palavra a direita do cursor
^y : Apaga a linha onde está o cursor
^qf : Localiza o texto selecionado
^qa : Localiza o texto selecionado e pode substituí-lo
3.3.2 Manipulação de Blocos
♦
♦
♦
♦
♦
♦
♦
♦
♦
Início do Bloco : ^kb
Fim do Bloco : ^kk
Copia o Bloco Marcado : ^kc
Move o Bloco Marcado : ^kv
Apaga o Bloco Marcado : ^ky
Desmarca/Remarca o Bloco : ^kh
Grava um bloco em forma de arquivo : ^kw
Lê um bloco gravado em forma de arquivo : ^kr
*** Para marcar um bloco, pode também ser utilizadas as teclas <Shift> e setas, em conjunto. Para isso,
segura-se o <Shift> pressionado e movimenta-se o cursor com as setas para as direções onde queremos marcar
o bloco. Também pode-se utilizar o mouse.
3.3.3 Funções para uso do ambiente Turbo Pascal
♦ F1: Help sensitivo;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
13
♦
♦
♦
♦
♦
♦
♦
♦
♦
F2: Salva o arquivo corrente no Editor;
F3: Carrega um arquivo do disco;
F4: Executa o programa até
F5: Zoom;
F6: Troca a janela ativa;
F7: Executa um programa passo a passo;
F8: Executa um programa rotina por rotina;
F9: Executa um "Make" no programa;
F10: Vai para o Menu;
♦
♦
♦
♦
Alt-F3: Fecha a janela ativa;
Alt-F5: Exibe a tela do usuário;
Alt-F6: Ativa a janela anterior;
Alt-F9: Compila o seu programa;
♦ Alt-BkSp: Desfaz a última tarefa no editor;
♦ Alt-0 : Ativa lista de janelas disponíveis;
♦ Alt-X: Termina a sessão do Turbo;
♦
♦
♦
♦
Ctrl-F9: Compila e executa o programa que estiver na janela ativa;
Ctrl-Del: Remove o texto selecionado para a área do "Clipboard";
Ctrl-Ins: Copia o texto selecionado para a área do "Clipboard".
Ctrl-L : Repete a última busca ou busca e troca.
♦ Shift-Del: Remove o texto selecionado para a área do "Clipboard".
♦ Shift-Ins: Copia para o texto o conteúdo selecionado no "Clipboard".
Observações:
Na composição dos nomes dos programas, utilizar apenas nomes com o formato DOS. Para o
nome do arquivo, utilizar no máximo 8 caracteres, sem espaços em branco. Nunca usar “.” ou colocar
extensão nos arquivos, deixar que o próprio ambiente se encarregue de adicionar a extensão aos
programas.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
14
4 Comandos e funções do Turbo Pascal
O Pascal, possui uma série de comandos e funções previamente definidos em seu código. Outros
comandos e funções estão definidas nas inúmeras bibliotecas de comandos/funções disponíveis por ele.
Uma das principais bibliotecas é a “Wincrt”, que já foi incluída em nosso programa (vide Área de
identificação).
Podemos ainda criar nossos próprios comandos (através da definição de procedimentos) e nossas
próprias funções (através da definição de nossas próprias funções), assuntos para mais adiante.
4.1 Comandos/Funções básicos aos programas
• “clrscr” : Limpa a tela e posiciona o cursor na posição (1, 1)
Exemplo
clrscr;
•
“gotoxy(C, L)”: Posiciona o cursor em uma determinada posição da tela especificada pela dupla
(C, L).
C --> Coluna desejada, L --> linha desejada
Exemplo
gotoxy(10,5);
•
“write” : Escreve algo na tela do computador a partir da posição atual do cursor e mantém o cursor
no final do trecho escrito.
Exemplo
write('Informe um No. :');
• “read” : É o comando de entrada de dados, atribui a uma variável um valor lido pelo teclado.
Exemplo
read(varnum);
•
Atribuição : ( := )
Atribui a variável da esquerda o valor da direita.
Exemplo
X := 10;
Y := 20 - X;
Z := X + y;
Z := Z - (X + 8);
varmed := X / Z;
total := Y * 5;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
15
A partir dessa linha a variável varmed vale 5 e a variável total vale 50
Regra geral de atribuições
<variavel> := <expressao>--> Constante ======> a := 5
|-> Variável =======> a := b
|-> com variáveis ==> a := b * 4
Existem muitos outros comandos e tantas outras funções padrões no Pascal, porém, serão vistas
no decorrer das necessidades do semestre. Alguns destes comandos e destas funções estão descritos ao
final desta apostila. A seguir, um programa exemplo extremamente simples em Pascal, escrito em duas
versões: uma com uso de procedimentos e outra sem procedimentos.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
16
4.2 Programa exemplo sem procedimentos
{ Inicio do programa }
program calcmedia ;
{Programa que serve para calcular a media ponderada de notas de uma disciplina}
{A media da 1a. prova tem peso 3 enquanto a da 2a. peso 7
}
{Marcelo Trindade Rebonatto - 14/03/2000 - Modificado em 04/08/2000
}
uses crt ;
{ Final da area de Identificacao }
var
numero_do_aluno
: integer ;
nota_prova1, nota_prova2, media : real ;
{ Final da area de Definicao das variaveis }
begin
clrscr; { limpa a tela }
gotoxy(10,05) ; { posiciona o cursor }
write('Informe o Numero do Aluno .....: ') ;
read(numero_do_aluno) ;
gotoxy(10,07) ;
write('Informe a Nota da 1a. Prova ...: ') ; {Escreve mensagem na tela}
read(nota_prova1); { Le, informa a variavel a partir do teclado }
gotoxy(10,09) ;
write('Informe a Nota da 2a. Prova ...: ') ;
read(nota_prova2) ;
media := ( (nota_prova1 * 3) + (nota_prova2 * 7) ) / 10;
gotoxy(10,15) ; write('RESULTADOS OBTIDOS');
gotoxy(10,17) ;
write('A media das provas e ',media:4:2) ;
readkey; { espera ate que uma tecla seja pressionada para que os resultados }
end.
{ do programa possam ser visualizados pelo usuario }
{ Final da area de Programa }
{ Final do programa }
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
17
4.3 Programa exemplo com procedimentos
{ Inicio do programa }
program calcmedia ;
{Programa que serve para calcular a media ponderada de notas de uma disciplina}
{A media da 1a. prova tem peso 3 enquanto a da 2a. peso 7
}
{Marcelo Trindade Rebonatto - 14/03/2000 - Modificado em 04/08/2000
}
uses crt ;
{ Final da area de Identificacao }
var
numero_do_aluno
: integer ;
nota_prova1, nota_prova2, media : real ;
{ Final da area de Definicao das variaveis }
procedure leituras ;
{ Procedimento para ler (informar) as variáveis p/ o programa }
{ E onde damos ENTRADA nos dados. São lidos: número do aluno e notas das provas}
begin
gotoxy(10,05) ; { posiciona o cursor }
write('Informe o Numero do Aluno .....: ') ;
read(numero_do_aluno) ;
gotoxy(10,07) ;
write('Informe a Nota da 1a. Prova ...: ') ; {Escreve mensagem na tela}
read(nota_prova1); { Le, informa a variavel a partir do teclado }
gotoxy(10,09) ;
write('Informe a Nota da 2a. Prova ...: ') ;
read(nota_prova2) ;
end ;
procedure calculo ;
{ Procedimento onde se faz o PROCESSAMENTO do programa }
begin
media := ( (nota_prova1 * 3) + (nota_prova2 * 7) ) / 10;
end;
procedure mostra_resultados ;
{ Procedimento que serve para externar (mostrar) os resultados obtidos }
{ pelo programa. E este procedimento que faz a SAIDA do programa }
begin
gotoxy(10,15);
write('RESULTADOS OBTIDOS');
gotoxy(10,17);
write('A media das provas e ',media:4:2);
end;
{ Final da area de Procedimento e funcoes }
{ Progama Principal (main) }
begin
clrscr ;
{ Limpa a tela }
leituras ;
calculo ; { Chamada de Procedimento }
mostra_resultados ;
readkey; { espera ate que uma tecla seja pressionada para que os resultados }
end.
{ do programa possam ser visualizados pelo usuario }
{ Final da area de Programa }
{ Final do programa }
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
18
5 Programas seqüenciais
Os primeiros programas que iremos trabalhar são programas estritamente seqüenciais, ou seja, os
programas assim como o programa exemplo, iniciarão na primeira instrução da área de programa. Sendo
esta instrução executada, o computador partirá para a próxima instrução, após ela a seguinte, e assim por
diante.
Caso alguma instrução seja uma chamada de procedimento/função (o que é muito comum), no
momento da chamada deste procedimento/função, a “linha” de execução do programa se deslocará para a
primeira instrução do procedimento/função chamado. A “linha” de execução continuará processando as
instruções de forma seqüencial dentro do procedimento/função. Quando o procedimento/função terminar
sua execução (não restarem mais instruções a serem processadas), a “linha” de execução se deslocará para
a instrução seguinte, logo após a instrução que chamou o procedimento/função, esta próxima instrução
será o alvo da “linha” de execução.
A execução do programa se comporta da maneira acima descrita, passando por todas as
instruções até o seu término.
A ordem que quase todos os programas de qualquer tipo seguem é a seguinte:
• Primeiro, existe uma ENTRADA de dados;
• Após, existe algum tipo de PROCESSAMENTO, a fim de encontrar resultado(s);
• O(s) resultado(s) encontrado(s), devem ser externados, ou seja, mostrados aos usuários. Nesta etapa é
realizada a SAÍDA do programa.
Regra geral
ENTRADA " PROCESSAMENTO " SAÍDA
5.1 Exercícios de programas seqüenciais no Turbo Pascal
1) Escrever um programa que leia a nota de duas provas e de dois trabalhos realizados em uma
disciplina. Calcule a média das provas e a média de dois trabalhos. Mostrar a média das provas e a
média dos trabalhos.
2) Escrever um programa que leia uma temperatura em graus Centígrados. Calcular a conversão desta
temperatura para graus Fahrenheit. Mostrar a temperatura lida em graus Fahrenheit. A fórmula de
conversão é: F # (9 * C + 160) / 5. Onde F é a temperatura em Fahrenheit e C é a temperatura em
Centígrados.
3) Escrever um programa que leia uma temperatura em graus Fahrenheit. Calcular a conversão desta
temperatura para graus Centígrados. Mostrar a temperatura lida em graus Centígrados. A fórmula de
conversão é: C # (F - 32) * (5 / 9). Onde F é a temperatura em Fanrenheit e C é a temperatura em
Centígrados.
4) Escrever um programa que leia dois valores (A e B) e efetuar as operações de adição, subtração,
multiplicação e divisão de A por B, apresentando ao final os quatro resultados obtidos.
5) Escrever um programa que leia o raio de uma circunferência. Calcular a área desta circunferência
através da fórmula AREA # PI * RAIO2. Mostrar a área da circunferência calculada.
6) Escrever um programa que leia a quantidade de horas trabalhadas por um funcionário em um mês, o
valor que ele recebe por hora e o percentual de desconto para o INSS. Calcular o salário bruto (horas
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
19
trabalhadas * valor hora), o valor do desconto para o INSS e o salário líquido (Salário bruto desconto INSS). Mostrar o salário bruto, o valor do desconto do INSS e o salário líquido do
funcionário.
7) Montar um programa que leia três números A, B e C, que representam os valores de uma equação de
2º grau (Ax2 + Bx + C = 0). Calcular e mostrar as raízes reais.
8) Escrever um programa que leia 3 variáveis: A, B e C. Calcular: a área de um triângulo com base A e
B por altura, área de um círculo com raio C, área de um trapézio que tem A e B por bases e C por
altura, área de um quadrado de lado B, área de um retângulo de lados A e B e a área da superfície de
um cubo de aresta C. Mostrar as áreas calculadas.
9) Calcular e apresentar o valor do volume de uma lata de óleo, utilizando a fórmula:
VOLUME # 3.1415 * (r - 2) * ALTURA. Onde “r” é igual ao raio da circunferência da lata.
10) Ler dois valores para as variáveis A e B, efetuar a troca dos valores de forma que a variável A passe a
possuir o valor da variável B e que a variável B passe a possuir o valor da variável A. Apresentar os
valores trocados.
11) Efetuar o cálculo da quantidade de litros de combustível gastos em uma viagem, utilizando-se um
automóvel que faz 12 km por litro. Para obter o cálculo, o usuário deverá fornecer o tempo gasto na
viagem e a velocidade média durante a mesma. Desta forma, será possível obter a distância percorrida
com a fórmula DISTÂNCIA # TEMPO * VELOCIDADE. Tendo o valor da distância, basta calcular
a quantidade de litros de combustível utilizada na viagem com a fórmula:
LITROS_USADOS # DISTÂNCIA / 12. O programa deverá apresentar os valores de velocidade
média, tempo gasto na viagem, a distância percorrida e a quantidade de litros de combustível
utilizados na viagem.
12) Escrever um programa que leia três valores: A, B e C , que são os lados de um triângulo, calcule e
mostre a área deste triângulo. Área = S * (S - A) * (S - B) * (S - C) onde S é o semi-perímetro.
13) Montar um programa que leia três números: A, B e C. Encontrar e mostrar o maior dos três números.
Fórmulas: Maior [A,B] = (A + B + |A – B|) / 2.
Obs.: Valor em módulo: ABS(x) = |X|.
14) Escrever um programa que leia um valor em R$, calcule e mostre o menor número possível de notas
de 100, 50, 10, 5, 1 em que o valor lido pode ser decomposto. Mostrar as quantidades de cada um dos
tipos de notas encontradas.
15) O custo ao consumidor de um carro novo é a soma do custo de fábrica com a percentagem do
distribuidor e dos impostos, ambos aplicados ao custo de fábrica. Supondo que a percentagem do
distribuidor seja 28% e os impostos de 45%, escrever um programa para ler o custo de fábrica de um
carro e escrever o custo ao consumidor.
16) Fazer um novo programa, semelhante ao anterior (número 15), porém, deve-se aplicar a percentagem
do distribuidor após já ter sido calculado o percentual dos impostos.
17) Uma loja de animais precisa de um programa para calcular os custos de criação de coelhos. O custo é
calculado com a fórmula : CUSTO # (70% do NR_COELHOS) / 18 + 10. Escrever um programa
que leia o número de coelhos, calcule o custo de criação e mostre o custo calculado.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
20
18) Um sistema de equações lineares do tipo:
ax + by = c
dx + ey = f
pode ser resolvido segundo o que é mostrado abaixo:
x = ce - ef
e
y = af - cd
ae - db
ae -bd
Escrever um programa Pascal que leia os coeficiente “a”, “b”, “c”, “d”, “e” e “f”. Calcular o mostrar os
valores para “x” e “y”.
19) Um imóvel foi comprado por 5 pessoas. João, comprou a metade do imóvel. Do restante, Pedro,
comprou a metade. O que ainda sobrou, foi divido por Maria, José e Luíza, sendo que José, ficou com
a metade do que ficou Maria, que por sua vez, ficou com parte igual a Luíza. Escrever um programa
em Pascal, que leia o valor recebido pelo aluguel do referido imóvel, e quanto em R$ cada um dos
sócios no imóvel deve receber.
20) Ricardo, apostou em corridas de cavalos R$ 150,00. Acertou o ganhador e com isso, recebeu 80 vezes
o valor apostado. Ao receber o prêmio, constatou que haviam descontos como segue:
a) 3,5 % para a associação dos apostadores
b) R$ 40,00 como taxa de uso do caixa do Hipódromo
c) 1,45% para o seguro do cavalo ganhador
d) e por fim, o I.R. lhe tirou 10%, do saldo já descontando as outras taxas, que ele ia levar para casa.
Escrever um programa que faça o extrato (na tela do computador) que Ricardo deveria receber pelo caixa
do Hipódromo, mostrando o valor ganho bruto, os descontos individualizados e o valor que realmente ele
levou para casa.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
21
6 Testes e Seleções
Como já foi visto até aqui, trabalhamos programas seqüências, onde a lógica consiste sempre de
ENTRADA " PROCESSAMENTO " SAÍDA. Estes programas são úteis para uma grande quantidade
de problemas, porém, seus recursos são um tanto quanto limitados.
Existem vários problemas que, para serem resolvidos, devem levar em conta valores das
variáveis do programa. Um exemplo é um programa que lê as notas de um aluno e calcula sua média
semestral. Até aqui tudo bem, podemos resolvê-lo facilmente do modo seqüencial, porém, se quiséssemos
mostrar ainda se o aluno foi “APROVADO” ou “REPROVADO”, como faríamos ??? Para dizer qual foi
o conceito obtido pelo aluno, devemos analisar o valor da variável que contém sua média. Dependendo
do seu valor, o aluno será “APROVADO” ou não.
Outro exemplo bem comum é um programa que calcule o salário de um funcionário. Caso seu
salário esteja dentro de uma faixa salarial, o desconto do INSS, por exemplo, pode ser de 8%. Caso
contrário, seu desconto terá uma outra alíquota.
Mais um exemplo, é o caso de um programa que calcula as raízes de uma equação de 2o grau. Se
o programa resolve esta equação pela fórmula de Báskara, temos de verificar se o valor do delta
(determinante, aquele termo onde extraímos uma raiz quadrada na fórmula) é superior ou igual a zero
(não existe raiz quadrada de números negativos).
Em todas as situações citadas, os dados manipulados pelos programas necessitam de algum tipo
de tratamento, para verificar, testar seu conteúdo. Para isto, vamos trabalhar com novos comandos, os
chamados comandos condicionais.
Para verificar o conteúdo de uma variável, devemos inseri-la em uma condição. As condições
são formadas por variáveis, constantes, operadores relacionais semelhantes aos que usamos no dia a dia e
na matemática (“>” maior, “<” menor, entre outros) e por operadores lógicos, que serão descritos mais
adiante.
6.1 Condição
Condição nada mais é do que uma (ou várias) Expressão(ões) Lógica(s).
Uma Expressão Lógica é composta de proposições assertivas que podem estar corretas
(verdadeiras) ou incorretas (falsas). No resultado de uma condição, não existem valores diferentes de
“Verdadeiro” ou “Falso”.
Para formar uma expressão lógica, usa-se os seguintes operadores relacionais:
Operador Relacional
Significado
Exemplo Verdadeiro
Igual
5=5
=
Maior ou Igual
8 >= 2
>=
Menor ou Igual
9 <= 9
<=
Maior
0 > -8
>
Menor
2 < 20
<
Diferente
6 <> 7
<>
Dentro de um Intervalo
5 in [1..10]
In
Exemplo Falso
Vale relembrar, que o resultado de uma condição é sempre “TRUE” (verdadeiro) ou “FALSE”
(Falso). Não existem quaisquer outros resultados possíveis. O operador de atribuição (:=), nunca pode
ser utilizado em uma condição.
Podemos ainda, montar um condição composta, ou seja, uma condição que depende de mais de
uma operação de verificação. Sendo uma condição composta ainda uma condição, seu resultado final
continua sendo sempre “TRUE” ou “FALSE”.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
22
Para criarmos uma condição composta, devemos usar os operadores lógicos, que estão descritos
na tabela abaixo.
Operador Lógico
and
or
not
Significado
e (produto lógico)
ou (soma lógica)
não (negação)
Exemplo Verdadeiro
(5 = 5) and (5 < 10)
(8 > 2) or (0 > -8)
not (6 < 2)
Exemplo Falso
Conforme pode ser visto nos exemplos, os operadores lógicos ficam no centro de duas condições
e deve-se obrigatoriamente envolver os operadores relacionais da sentença por parênteses.
Na resolução de uma condição com operadores lógicos, deve-se proceder da seguinte maneira:
a) Encontrar o resultado de cada uma das comparações envolvidas (esta comparação é como se fosse
uma condição separada, resulta em “TRUE” ou “FALSE”);
b) De posse dos resultados encontrados, comparar os resultados que fazem parte de um operador, ou
seja, sempre se compara os resultados, dois a dois (um de cada lado do operador lógico), encontrando
novamente um resultado para a condição, que sempre será “TRUE” ou “FALSE”.
Os operadores lógicos, são resolvidos de acordo com o seu significado:
• “and”: necessita que as duas condições sejam verdadeiras, para dar um retorno verdadeiro.
• “or”: se pelo menos uma condição for verdadeira, seu resultado será verdadeiro.
• “not”: inverte o resultado de uma condição, se era verdadeira, passa a ser falsa, se era falsa, passa a
ser verdadeira.
Uma tabela verdade, pode ser criada para auxiliar a compreensão dos resultados de operadores
lógicos. Observe a tabela abaixo, sendo P1 e P2, proposições (condições) que podem estar verdadeiras ou
falsas.
P1
True
True
False
False
P2
True
False
True
False
Not (P1)
False
False
True
True
Not (P2)
False
True
False
True
(P1) and (P2)
True
False
False
False
(P1) or (P2)
True
True
True
False
Vale lembrar ainda, que todos os exemplos com condições foram feitos com números absolutos
(5, 10, 12, -1, ...), nos dois extremos dos operadores relacionais. Porém uma condição só tem sentido, se
em pelo menos um dos lados, o operador seja uma variável.
Exemplos
P1 = A >=B
P2 = A < C
P3 = C > 1
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
23
6.2 Comando Condicional Simples
{ If ... Then ... [Else]}
Regra geral
if <condição> then
comando[;] / begin <comandos;> end[;]
else
comando; / begin <comandos;> end;
O comando condicional simples (Se ... Então ...[Senão]), tem por finalidade avaliar uma
condição (simples ou composta) e decidir se os comandos serão ou não executados.
A forma de avaliação da condição, segue o descrito nas condições. SE o resultado da condição
for “TRUE” (verdadeiro), as instruções referentes ao ENTÃO (“THEN”) serão executadas, caso contrário,
quando o resultado da condição for “FALSE” (falso), os comandos referentes ao então (“THEN”) não
serão executados. O comando permite ainda opcionalmente (não é obrigatório seu uso) colocar comandos
que somente serão executados se a condição for falsa (“FALSE”). Estes comandos deverão ser escritos
após o comando de SENÃO (“ELSE”).
Em nenhuma hipótese comandos relativos ao ENTÃO e ao SENÃO serão executados juntos. Um
automaticamente exclui o outro, ou seja, caso a linha de execução siga pelo “then”, ela não poderá
passar pelo “else” e caso siga pelo “else” ela não poderá passar pelo “then”.
Em ambos os casos de execução poderá existir apenas 1 comando ou um bloco de comandos
dentro das opções de condição verdadeira ou falsa.
Um bloco de comandos, consiste de um conjunto de comandos envolto pelo par “begin
end”. Um procedimento é delimitado em um bloco de comandos, o programa principal também é
delimitado em um bloco de comandos, entre outros.
Convém lembrar que todo o bloco de comandos deve possuir sempre início e fim (“begin
end”), sob pena de acusar erros em tempo de compilação.
Exemplo
Início do bloco
if media > 5 then
de comandos
begin
gotoxy(10,10);
write('O aluno foi APROVADO');
gotoxy(10,12);
write('Sua média foi de ',media:4:2);
end;
Fim do bloco
de comandos
Quando fazemos uso da condição de senão (“ELSE”), devemos tomar o cuidado de não encerrar
o comando antes. Em Pascal, como já foi visto, um comando encerra-se com um ponto-e-vírgula.
Portanto, para incluirmos a opção de execução, caso a condição seja falsa (“ELSE”), NÃO podemos
inserir o (“;”) no comando ou ao final do bloco de comandos (“end” do bloco de comandos).
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
24
Exemplo
if média > 5 then
begin
gotoxy(10,10);
write('O aluno foi APROVADO');
end
else
begin
gotoxy(10,10);
write('O aluno foi REPROVADO');
end;
gotoxy(10,10);
if media > 5 then
write('Aprovado')
else
write('Reprovado');
Não pode ser colocado o ;
Como já dito anteriormente, em uma condição composta é obrigatório o uso de parênteses
envolvendo as condições simples.
Exemplo
if a > b then
write(a);
{ Não precisa de parênteses }
if (a >= b) and (b <> 0) then
write(b);
{Necessita obrigatoriamente }
{ de parênteses }
Como observação final, podemos ainda frisar, que dentro de um comando condicional simples
(“if
then
[else]”), podemos ter diversos outros comandos condicionais. Isto é conhecido
como “condições aninhadas”.
Exemplo
if matricula <> 0 then
if nr_faltas < 16 then
Ifs aninhados
if media > 7 then
begin
gotoxy(10,10);
write('O aluno foi APROVADO');
end;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
25
6.3 Comando Condicional Múltiplo
{ Case ... of ... : ... End; }
Regra Geral
case <condição> of <opção 1> : Comando; / Bloco de Comandos;
<opção 2> : Chamada de Procedimento/Função
...
...
else Comando; / Bloco de Comandos;
end;
A exemplo do comando condicional simples, o comando condicional múltiplo também faz um
desvio na linha de execução de um programa. A diferença é que em comando condicional simples, avaliase apenas uma condição, que pode ser verdadeira ou falsa, tendo no máximo duas opções para a
continuidade da linha de execução; enquanto que em um comando condicional múltiplo, o desvio poderá
se dar em diversas opções.
Em um comando condicional múltiplo, assim como em um comando condicional simples,
apenas uma das opções de continuidade da linha de execução será executada, ou seja, se a linha segue por
uma opção, não poderá seguir em outra logo após, podendo existir apenas em cada opção um comando ou
bloco de comandos.
As condições são montadas de forma diferente do que em um comando condicional simples.
Todas as comparações são realizadas em cima de uma mesma variável (ou expressão envolvendo
variáveis, mas que resultem sempre em apenas um valor), que deve obrigatoriamente ser uma variável
inteira, um “char” ou um “boolean”. A comparação será feita com cada um dos “valores de caso”
escritos para o programa.
Existe ainda uma condição opcional, que só será selecionada se nenhuma das condições de caso
o foi. Da mesma forma que um comando condicional simples, esta opção é descrita pelo comando
“else”, e segue a mesma regra das outras opções de valores de caso.
O comando deve terminar com a escrita de um “end” (o início é o próprio “case”).
Exemplo
case variavel of
25,50:
begin
write('variavel vale 25 ou 50');
end;
100:
write('variavel vale 100');
101..200:
write('variavel vale de 101 a 200');
300:
mostra300;
else
write('variavel não entrou em nenhum dos casos');
end;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
26
6.4 Exercícios de programas com seleção no Turbo Pascal
21) Escrever um programa que efetue a leitura de três valores (variáveis A, B e C) e apresente os valores
dispostos em ordem crescente.
22) Escrever um programa que leia um número inteiro. Mostrar se o número lido é “par” ou “ímpar”.
(Não pode ser usada a função odd() )
23) Escrever um programa que efetua a leitura de três valores (variáveis A, B e C) e calcula as raízes de
uma equação de 2º grau, apresentando as duas raízes, se para os valores informados for possível
efetuar o referido cálculo, caso os valores não possam ser resolvidos pela fórmula de Báskara, indicar
que a equação “não possui raízes reais”.
24) Escrever um programa que leia quatro valores referentes a quatro notas escolares de um aluno e
imprimir uma mensagem dizendo que o aluno foi “aprovado”, se o valor da média escolar for maior
ou igual a 5.0. Se o aluno não foi aprovado, indicar uma mensagem informando esta condição.
Apresentar junto com uma das mensagens o valor da média do aluno para qualquer condição.
25) Escrever um programa que leia dois valores numéricos e mostre a diferença do maior para o menor.
26) Escrever um programa que leia dois valores A e B. Escrever a seguinte mensagem:
ou “Não são múltiplos”.
“São múltiplos”
27) Escrever um programa que leia três valores A, B e C e verifica se eles formam ou não um triângulo.
Supor que os valores lidos são inteiros e positivos. Caso os valores formem um triângulo, calcular e
escrever a área deste triângulo. Se não formam um triângulo, escrever esta mensagem: “Não formam
um triângulo”.
28) Escrever um programa que leia 2 números. Mostrar quais números são divisíveis por 2 e por 3.
29) Escrever um programa que leia 2 números. Mostrar quais números são divisíveis por 4 ou por 5.
30) O departamento que controla o índice de poluição do meio ambiente mantém três grupos de indústrias
que são altamente poluentes. O índice de poluição aceitável varia de 0,05 a 0,25. Se o índice sobe até
0,3 as empresas do 1º grupo são notificadas a paralisarem suas atividades. Se o índice aumenta até 0,4
as empresas do 1º e 2º grupos são notificadas a paralisarem suas atividades. Finalmente, se o índice
cresce para uma valor maior que 0,4 as empresas do 1º, 2º e 3º grupos devem ser notificadas a
paralisarem suas atividades. Escrever um programa que leia o índice de poluição medido e emita a
notificação adequada aos diferentes grupos de empresas.
31) Escrever um programa que lê o número de um vendedor, seu salário fixo e o total de vendas por ele
efetuado em um determinado mês. Cada vendedor recebe salário fixo mais uma comissão,
proporcional às vendas por ele efetuadas. A comissão é de 10% sobre o total de vendas até
R$1.000,00 e 20% sobre o que ultrapassa este valor. Escrever o total ganho em comissões juntamente
com o salário fixo.
32) Escrever um programa que leia um número inteiro. Caso este número seja divisível por 2, mostrar o
quadrado do número lido. Caso este número seja divisível por 3, mostrar o cubo deste número e caso
o número seja divisível por 4, mostrar a raiz quadrada do número. O número pode ser divisível pelos
3 valores citados, (ex. 12), então deve-se mostrar as 3 condições.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
27
33) Escrever um programa que leia um número inteiro. Mostrar o seu valor em módulo. (Não pode ser
usada a função abs()).
34) Escrever um programa que leia o número de identificação e as três notas obtidas por um aluno nas três
verificações. Para o aluno calcular a média de aproveitamento segundo a fórmula de média ponderada
descrita abaixo:
Ma := (n1 + (n2 * 2) + (n3 * 3) ) / 6
O programa deve escrever a média de
aproveitamento, o conceito correspondente e a mensagem:
“Aprovado”, se o conceito for A ou B, e “Reprovado” se o
conceito for C, D ou E.
A atribuição de conceitos obedece a tabela ao lado
:
Conceito
A
B
C
D
E
Média (Ma)
>= 9.0
>= 7.5 e < 9.0
>= 6.0 e < 7.5
>= 4.0 e < 6.0
<4
35) Escrever um programa que leia 5 números, A, B, C, D e E. Mostrar o maior número e o menor
número.
36) Escrever um programa que leia um valor inteiro. Caso o valor seja menor que 100 e maior que -1,
escrever em qual dezena ele se encontra (8 está na 1a dezena, 23 está na 3a dezena, 91, está na 10a
dezena). Caso o número não esteja em nenhuma das 10 primeiras dezenas, escrever esta informação.
37) Ler quatro valores referentes a notas escolares de um aluno e imprimir uma mensagem dizendo que o
aluno foi aprovado, se o valor da média escolar for maior ou igual a 7.0. Se a média for menor que
7.0, solicitar a nota de exame, somar com a média e obter nova média. Se a nova média for maior ou
igual a 5.0, apresentar uma mensagem dizendo que o aluno foi aprovado em exame. Se o aluno não
foi aprovado, indicar uma mensagem informando esta condição. Apresentar junto com as mensagens
o valor da média do aluno, para qualquer condição.
38) Efetuar a leitura de quatro valores (variáveis A, B, C e D) e apresentar os valores dispostos em ordem
decrescente.
39) Escrever um programa que leia uma hora inicial (horas e minutos) e uma hora final (horas e minutos).
Mostrar o tempo decorrido entre a hora inicial e a hora final, em horas e minutos.
40) Escrever um programa que leia 3 valores. Verificar se eles formam um triângulo. Caso eles não
formem um triângulo, indicar esta mensagem. Caso eles formem um triângulo, indicar o tipo de
triângulo que eles formam. Deve-se para cada triângulo informado, ser mostrado apenas 1 tipo.
Condição
Todos os valores iguais
Dois valores iguais (Quaisquer)
a2 = b2 +c2
a2 > b2 +c2
a2 < b2 +c2
Tipo de triângulo
Triângulo Equilátero
Triângulo Isóceles
Triângulo Retângulo
Triângulo Obtusângulo
Triângulo Acutângulo
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
28
7 Comandos de Repetição
Como o próprio nome diz, são programas que repetem sua execução até um determinado ponto
quando encerram. São vulgarmente conhecidos como “laços”, ou seja, quando chegamos ao final de um
trecho de programa “envolto” por um laço, retornamos ao início do mesmo, e o executamos novamente.
7.1 Novos Conceitos na utilização de variáveis
As variáveis vistas até agora serviram sempre para o armazenamento de valores do programa.
Uma variável era definida, colocado um valor nela via teclado (quando era lida) ou via expressão
numérica (comando de atribuição). Seu valor era utilizado ou em testes ou em cálculos e, finalmente,
quando necessário, era exposto. Todavia, veremos utilizações um pouco mais inteligentes para as
variáveis.
Os tipos de variáveis não mudam, ou seja, os tipos “integer”, “boolean”, “real” entre
outros são os mesmos; o que muda é o enfoque dado a estas variáveis. Elas serão especialmente úteis em
programas com repetição.
7.1.1 CONTADOR
Variável do tipo numérica inteira, que serve para, como diz o seu nome, contar quantas vezes algum
trecho de programa foi executado (quantas vezes alguma ação foi realizada). Por exemplo: para sabermos
quantas vezes foi executado um bloco de comandos, colocamos um comando a fim de incrementar1 a
variável contadora, que já deve ter sido previamente inicializada (para não somarmos nada com algum
número). Quando o programa parar de executar o referido bloco de comandos, a variável conterá o
número de vezes que o referido bloco foi executado.
7.1.2 ACUMULADOR
Variável que serve para acumular valores, geralmente numéricos. Serve na prática para obtermos
uma determinada soma. Por exemplo: para sabermos a soma de 30 números a serem lidos, junto com o
trecho de leitura atualizamos a variável acumuladora, que já deve estar inicializada. No final da 30a
leitura, teremos a soma dos 30 números lidos. Ela é útil também para sabermos a média dos números
lidos pois ela nada mais é do que a soma dos números divididos pela quantidade de números lidos.
7.1.3 FLAG
Tradução do Inglês: bandeira, sinal. É um tipo de variável para controle do estado de um programa.
Usada em testes. Serve na prática para sabermos se um laço pode ou não acabar, se uma fórmula foi ou
não resolvida (o programador deve saber os motivos o porquê da fórmula não ser resolvida). Nos
possibilita a comunicação entre diversas partes de um programa. Pode ser qualquer tipo de variável, mas
no caso de necessitarmos de apenas dois estados, é aconselhável o uso de variáveis do tipo “boolean”,
devido a sua facilidade no uso em testes e por que seu conteúdo são as constantes mnemônicas “true”
ou “false”.
1
ação de somar uma unidade a um valor
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
29
7.2 Laço com contador
Regra geral
for <variavel> := <valor inicial> to <valor final> do
Bloco de Comandos
A “variavel” é uma variável contadora, que é controlada pelo computador. O bloco de
comandos vai ser executado tantas vezes quantas forem necessárias para a “variavel” sair do valor
inicial e alcançar o valor final. A cada final do bloco de comandos, a variável é incrementada (somada) a
uma unidade. Na prática, é como se ao final do bloco o computador realizasse estas três ações:
• Verificar se a variável de controle já chegou ao valor final
• Se chegou, segue para o próximo comando, após o final do bloco
• Se não chegou, incrementa uma unidade à variável de controle, e retorna ao início do laço, a fim do
bloco de comandos ser executado novamente.
Como o contador é controlado pelo computador, é PROIBIDO alterar o valor da variável
dentro do laço. O valor do contador pode ser apenas testado ou visualizado. Ao final do laço, a variável
irá conter o “valor final”, definido no início do comando.
O exemplo abaixo, mostra a leitura de 10 números, encontrando o maior.
Exemplo
Valor inicial
procedure leitura;
begin
for i := 1 to 10 do
begin
Valor final
gotoxy(10,10);
write('Informe um No. : ');
num := 0;
read(num);
if i = 1 then
maior := num;
if num > maior then
maior := num;
end;
end;
Variável de controle
A variável de controle de laço, no caso anterior a variável “i”, é sempre incrementada de uma
(1) unidade. Em Pascal, não é possível, incrementá-la com mais de uma unidade. Por ser um contador
deve ser do tipo numérico inteiro, como já foi visto.
Este comando também é conhecido como laço com contador progressivo, pois o contador é
incrementado até alcançar o seu valor final (que obviamente é maior do que o valor inicial).
Também faz parte do laço com contador um tipo de laço que o contador começa com um valor
inicial maior do que o valor final, chamado de “contador regressivo”. Neste caso, a ação ocorre da mesma
maneira que o contador progressivo, mas ao invés de incrementar em uma unidade, a variável é
decrementada (diminuída) de uma unidade a cada passagem.
Regra geral
for <variavel> := <valor final> downto <valor inicial> do
Bloco de Comandos
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
30
A inclusão do “downto” ao invés do “to”, transforma o comportamento do laço em regressivo. O
exemplo abaixo, mostra os números ímpares entre 1 e 10, começando pelo maior. Este exemplo mostra
ainda uma rotina para controle de posições na tela, a fim de que os valores não apareçam de forma
bagunçada.
Exemplo
coluna := 10; linha := 10;
for i := 10 downto 1 do
begin
if odd(i) then
begin
gotoxy(coluna,linha);
write(i) ;
coluna := coluna + 5;
if coluna > 60 Then
begin
coluna := 10;
linha := linha + 1;
end;
end;
end;
7.3 Laço com teste no final
Regra geral
repeat
comando; / bloco de comandos;
until <condição> ;
O bloco de comandos vai ser executado sempre pelo menos uma vez e só vai ser terminado
quando a condição de saída (FLAG) for verdadeira. Na prática ocorre o seguinte:
a) bloco de comandos é executado inteiro
b) Ao chegar ao final (until), a condição é avaliada. Caso ela seja “TRUE”, a linha de execução segue
para o próximo comando, logo após o “until”. Caso a condição seja “FALSE”, a linha de execução
retorna ao primeiro comando do bloco, onde recomeça a execução
A delimitação de início e de fim do bloco de comandos, é realizada pelas próprias partes do
comando: “repeat” marca o início e “until <condição>” marca o fim.
A condição a ser colocada no final do comando, segue as regras de condições já comentadas,
podendo ser simples ou compostas.
Um exemplo muito comum da utilização de laço com teste no final, é a leitura de uma variável
dentro de um certo domínio de valores válidos. Isto acontece, por exemplo, em um programa que lê
valores de notas para alunos. As notas válidas estão no intervalo de 0.0 a 10.0 (in [0.0 .. 10.0]).
Nos programas anteriores, o usuário poderia digitar a nota que quisesse (por exemplo 312.6) que o
programa iria calcular a média, e, com certeza, estaria errada. Para solucionarmos esses problemas,
usamos o tipo de construção abaixo:
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
31
Exemplo
repeat
var_num := 0;
read(var_num);
until (var_num >= 0.0) and (var_num <= 10.0);
No exemplo anterior, a linha de execução só vai sair de dentro do laço quando for digitada uma
nota válida. Este tipo de construção também é útil quando trabalhamos com números inteiros. Os números
inteiros possuem limites de abrangência de valores. Por outro lado, é impossível “proibir” o usuário de
tentar informar um número real em uma variável inteira. Para isto devemos proteger a leitura da variável
inteira.
Exemplo
repeat
num := 0;
read(num);
until (num >= -32768) and (num <= 32767)and (num = int(num) );
a := trunc(num);
No exemplo acima, a variável de trabalho “num” é utilizada apenas para evitar a ocorrência de
um erro, caso o valor digitado pelo usuário seja do tipo real (é óbvio que a variável “num” é do tipo real).
As duas primeiras condições verificam o escopo do valor, enquanto a última verifica se dentro da variável
“num” existe um número inteiro (a variável “num” é real, mas a verificação é para conferir se o seu
conteúdo é inteiro).
Este comando também é utilizado quando em um programa, se faz a verificação se dois números
lidos são múltiplos. Para resolver o problema, não precisamos de laço de repetição. Mas, e se quiséssemos
informar e verificar outra dupla de números ? Teríamos de executar novamente o programa e, assim,
sucessivamente. Com a utilização do laço, podemos executar o mesmo programa quantas vezes
quisermos. A condição de parada (FLAG de saída) pode ser quando o valor da variável “a” for zero.
Exemplo
begin
repeat
leitura;
verifica;
mostra;
until (a = 0)
end;
Inicio do programa
principal
Fim do programa
principal
7.4 Laço com teste no início
Regra geral
while <condição> do
comando / bloco de comandos;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
32
Diferente do comando visto anteriormente, este laço testa a condição antes de executar o bloco
de comandos. O laço é executado enquanto a <condição> for verdadeira. Na prática, acontece o seguinte:
a) Ao chegar ao comando a condição é avaliada. Se for “FALSE”, o bloco de comandos não é
executado, e a linha de execução passa para o próximo comando após o delimitador de final de bloco;
b) Caso a condição avaliada seja “TRUE”, o bloco de comandos é executado inteiro, e ao final deste, a
condição é novamente avaliada, seguindo novamente esta sistemática.
A condição a ser colocada no início do comando, segue as regras já comentadas e podem ser
simples ou compostas.
A utilização prática deste comando se dá, pela necessidade de que alguns comandos só se
repitam quando e enquanto uma condição for verdadeira. Este comando embute as funcionalidades de um
comando condicional simples, junto com um laço de repetição. Por já realizar o teste no início, a(s)
variável(eis) envolvida(s) na condição devem conter um valor antes do inicio do comando.
Um exemplo prático é a soma de valores (utilização de um acumulador) enquanto este não for
maior do que um valor previamente estabelecido.
Exemplo
soma := 1;
final := 100;
while soma < final do
begin
soma := soma + (soma * 2);
end;
gotoxy(12,5);
write('O valor que está no acumulador vale : ',soma);
Os dois últimos laços tem função bastante semelhante. Em cada caso deve ser avaliada a
utilização de um ou outro, segundo as necessidades. A diferença básica entre eles é que ...
7.5 Exercícios de programas com repetição
41) Escrever um programa que leia 10 números e mostre o maior.
42) Escrever um programa que leia 5 valores para “A”, um de cada vez, contar quantos destes valores são
negativos e escrever esta informação.
43) Escrever um programa que lê 8 valores para a variável “B”, um de cada vez. Mostrar a soma dos
valores lidos que sejam pares.
44) Escrever um programa que leia dois números inteiros “A” e “B”, calcular e mostrar:
• a soma dos inteiros entre eles;
• a quantidade de números ímpares entre eles;
• a quantidade de números pares entre eles, inclusive eles.
45) Escrever um programa que leia um número inteiro “M” e um valor para a variável “N”. Escrever o
valor da potência de NM .
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
33
46) Escrever um programa que gera e escreve os números ímpares entre 100 e 200.
47) Montar um programa que leia um número inteiro, positivo menor ou igual a 10. Montar e mostrar a
tabuada deste número, como o exemplo abaixo.
Informe um número: _
Tabuada de 8
1 x 8 = 8
2 x 8 = 16
10 x 8 = 80
48) Escrever um programa que leia uma quantidade não determinada de vezes um número inteiro. Para
cada número lido calcular e mostrar seu quadrado, seu cubo e sua raiz quadrada. Parar de informar
quando o número lido for igual a zero. A exposição deve ser feita da maneira abaixo.
Informe um número: _
Número
5
4
8
Quadrado
25
16
64
Cubo
125
64
512
Raiz
2,2361
2
2,8284
49) A série de Fibonacci tem como os dois primeiros termos respectivamente 0 e 1. A partir deles, os
demais são construídos pela seguinte regra:
tn = tn-1 + tn-2
Escrever um programa que gere e mostre os 10 primeiros termos da série, um abaixo do outro, indicando
a sua posição de ordem (se é o 1o, ou o 2o ou o 7o da série, etc) mostrando também a soma dos 10
primeiros termos.
50) Escrever um programa que lê um número inteiro. Mostrar se o número é ou não primo.
51) Escrever um programa que gere e escreva os 4 primeiros números perfeitos, juntamente com o seu
número de ordem. Um número perfeito é aquele em que a soma dos seus divisores, exceto ele, seja
igual a ele próprio. Ex.: 6 = 1+2+3; 28=1+2+4+7+14.
52) Supondo que a população de uma cidade “A” seja de 90.000, com taxa de crescimento de 3,1% ao
mês, e que a população de uma cidade “B” seja de 200.000, com taxa de crescimento de 1,5% aos
mês. Escrever um programa que calcule e escreva com quantos meses a cidade “A” ultrapassaria em
população da cidade “B”, mantendo as taxas atuais de crescimento. Mostrar as populações das
cidades.
53) Escrever um programa que lê um número não conhecido de valores inteiros, um de cada vez, e conta
quantos deles estão em cada um dos intervalos : [0..25], (25..50], (50..75] e (75..100]. Parar de
informar quando o número “–1” for digitado. Mostrar quantos números entraram em cada intervalo e
quantos não entraram em nenhum intervalo.
54) Escrever um programa que lê 5 pares de valores “A” e “B”, todos inteiros e positivos, um par de cada
vez, e com “A < B”. Escrever os inteiros pares de “A” até “B”, incluindo “A” e “B” se forem pares.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
34
55) Escrever um programa que lê um número não determinado de valores inteiros e positivos, menores
que 5.000. A cada número lido, mostrar a quantidade de números lidos, juntamente com a média
destes. Parar de informar quando o valor informado seja igual a “–1”.
56) Escrever um programa que lê um número não determinado de pares valores “M” e “N”, ambos
inteiros e positivos, um par de cada vez. Calcular e escrever a quantidade de números inteiros
existentes entre eles, bem como a soma dos inteiros ímpares existentes entre eles. Parar de informar
quando o primeiro número seja igual a 0 (zero).
57) João possui R$ 1.800,00. Gostaria de comprar um computador que custa R$ 2.000. Ele gosta de
aplicar seu dinheiro na caderneta de poupança, que paga sempre 1,5% ao mês. Supondo que o preço
do computador não mude, escreva um programa que calcule em quantos meses João irá poder
comprar o computador, mostrando a evolução de seu saldo na poupança, conforme o modelo abaixo.
o
1 mês
2o mês
3o mês
Saldo anterior
1800.00
1827.00
1854.40
Juros
27
27,40
27,81
Saldo Atual
1827.00
1854,40
1882,21
58) Escrever um programa que leia um valor “x”, e escreve os 20 primeiros termos da série abaixo:
1o termo: 1
2o termo: 1 + 1/x2
3o termo: 1 + 1/x3
4o termo: 1 + 1/x4
59) O cardápio de uma casa de lanches é dado pela tabela abaixo:
Código
Especificação
Preço Unitário
100
Cachorro Quente
2,50
101
X Simples
2,80
102
X Especial
3,00
103
X Especial c/ bacon
3,30
104
Refrigerante
0,70
Escrever um programa que leia o pedido de um cliente, especificando a quantidade de cada item. Parar de
informar quando o código informado seja igual a zero. Montar (na tela do computador) o pedido como
segue:
Escolha o item:
Informe a quantidade do item:
Código Especificação
100
Cachorro Quente
103
X Especial c/ bacon
104
Refrigerante
Quantidade
1
3
4
Valor
2,50
9,90
2,80
------Total--> 11,20
60) Repetir o programa acima para um número indeterminado de clientes. Ao final da conta de cada
cliente, realizar a seguinte pergunta: “Informar mais um cliente (Sim/Não)”. Quando não houverem
mais clientes a informar, mostrar o total do faturamento da lanchonete (o total geral das contas
vendidas).
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
35
8 Técnicas avançadas de programação
8.1 Definição de Constantes
Muitos programas possuem determinados valores que nunca são alterados, como o número de
dias de uma semana, ou se mudam, diferem somente de um programa para outro, com a mesma lógica
(caso de um programa para uma empresa e outro para outra). O uso de identificadores de constantes para
esses valores simplificam os programas e facilitam sua atualização. Para que o valor se altere em todo o
programa, é necessária somente a alteração do seu valor em um ponto.
Para definir uma constante usamos a palavra reservada “const”. Esta inclusão marca o início
da área de declaração de constantes. Esta seção deve estar inserida logo após a área de identificação do
programa, antes da área de definição das variáveis. A utilização de outra palavra reservada (por exemplo
o início da área de definição de variáveis) marca o fim das declarações de constantes.
Exemplo
uses crt;
const
tamanho = 15
nr_leituras = 20
var
i, j : integer;
Marca o início da área de
declaração de Constantes
Marca o fim da área de declaração
de Constantes
O uso de constantes além de auxiliar a leitura e interpretação do código fonte, facilita a
reutilização de um programa para a criação de outro. Por exemplo, caso um programa calcule o salário de
vendedores com percentuais de 3% e 5%, dependendo a quantia vendida num determinado mês (empresa
“X”), para escrever o mesmo programa para outra empresa que paga 4% e 6% de comissão (empresa
“Y”), somente serão mudadas as constantes de comissão, , enquanto todo o restante do programa
permanecerá inalterado.
Exemplo
{ exemplo usado no programa
para calculo da empresa X }
Const
Comiss1 := 3;
Comiss2 := 5;
{ exemplo usado no programa
para calculo da empresa Y }
const
comiss1 := 4;
comiss2 := 6;
O uso de constantes em testes, expressões envolvendo atribuição, ou qualquer outro comando
que não modifique o valor da constante são válidos. Uma constante pode ser encarada como uma variável
que nunca muda de valor. Nas expressões envolvendo atribuições, as constantes devem ficar no lado
direito da expressão.
8.2 Variáveis locais e variáveis globais
As variáveis definidas na “seção de definição de variáveis” de um programa Pascal, são
consideradas globais. Elas são conhecidas em todas as partes do programa, e seu valor também pode ser
verificado ou incluso em operações aritméticas.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
36
Mas devido ao fato de que, ocasionalmente, uma variável é utilizada em apenas um
procedimento, torna-se pouco cômodo deixar sua definição na área das globais. Para isto, podemos incluir
uma nova seção de variáveis, logo após a declaração do procedimento/função, definindo nela , as que
serão usadas somente naquele procedimento. A estas variáveis, declaradas na parte interna de um
procedimento ou função, damos o nome de “variáveis locais”.
Exemplo
uses crt;
var
x,y : integer;
r
: real;
procedure calcula;
var
i,j,k : integer;
p
: real;
begin
...
...
end;
Variáveis globais, existem em
todas as partes do programa
Variáveis locais, só existem dentro
do procedimento calcula
Nenhuma relação existe entre uma variável local e uma global, ainda que definidas com o
mesmo nome. É totalmente desaconselhável a definição de uma variável local com o mesmo nome de
uma global, a fim de evitar confusão por parte do programador. O programa não faz confusão nenhuma,
porém o programador pode facilmente se confundir.
Dentro de um procedimento, as variáveis locais tem preferência sobre as globais, ou seja, caso
exista uma variável “x” global, e uma “x” local (note-se que são duas variáveis distintas, mas com igual
nome), quando for requisitado o valor da variável “x”, será mostrado o valor da variável “x” local.
Vale lembrar ainda, que uma variável local, existe somente dentro do procedimento que a
declarou. Mesmo que um procedimento seja chamado dentro de outro que possui variáveis locais, estas
não existirão dentro do procedimento chamado, ou seja, o valor destas variáveis não poderá ser utilizado.
A grande vantagem das variáveis locais é que o espaço de armazenamento destas na memória, só
é efetivamente ocupado quando o procedimento é executado. Ao final da execução, esse espaço é liberado
para a memória livre. Com isso, os programas ficam mais “leves”, ou seja, ocupam menos memória.
Regra geral
programa
var
x : integer;
y : real;
Valem em todo o
programa.
{ procedimentos }
Variáveis
locais distintas
Proc1
Proc2
a : integer
b : integer;
c : real;
a : integer;
x : integer;
d : char;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
Variáveis local e
global com o
mesmo nome.
Dentro de “proc2”
vale a local.
37
8.3 Passagem de Parâmetros
A passagem de parâmetros é uma necessidade para a programação. Ela possibilita o
reaproveitamento de código, de maneira a tornar o programa mais limpo, curto e fácil de entender. Ela
nada mais é do que a chamada a um procedimento ou função, estabelecendo valores iniciais dos dados
que este sub-programa manipula.
Rotinas com passagem de parâmetros devem ser escritas sempre que um determinado “bloco de
código” (parte de um programa fonte) se repita. Por exemplo, para escrevermos uma mensagem na tela do
computador, é sempre utilizada a dupla de comandos: “gotoxy(C,L)” e “write(texto)”. O
primeiro comando para posicionar o cursor e o segundo para escrever algo na tela. Esta operação se
repete sempre, mudando apenas a posição onde se quer escrever (C,L) e o que se deseja escrever (texto).
Nada mais sensato do que criar um procedimento que realize a tarefa de escrever algo na tela,
que possa ser usado com quaisquer valores para a posição e para o texto a ser escrito.
Exemplo
procedure escreve(p_col, p_lin : integer; texto : string);
begin
gotoxy(p_col,p_lin);
write(texto);
end;
Definição dos parâmentros
do procedimento
Outro exemplo prático da utilização de parâmetros é o caso de um procedimento que calcula as
raízes de uma equação de 2o grau pela fórmula de Báskara. Toda a parte do processamento é idêntica para
todos os valores. A fórmula nunca muda, o que muda são os valores que nela são inseridos. Nada mais
lógico do que construir um sub-programa que execute a fórmula de Báskara, mudando apenas os valores
de entrada.
Exemplo
procedure baskara(p_a, p_b, p_c : real)
begin
Definição dos parâmetros
{ parte relativa ao cálculo da fórmula sempre igual,
usando os parâmetros de entrada deste procedimento }
end;
Quando um procedimento/função é definido para receber parâmetros, a chamada destes deve
obrigatoriamente ser acompanhada dos valores dos argumentos, que devem ser passados na mesma ordem
e na mesma seqüência em que foram definidos, ou seja, se o primeiro parâmetro é o valor de uma coluna
(da tela), o primeiro parâmetro a ser passado deve ser o da coluna. A mesma quantidade de parâmetros
definidos deve ser passada na chamada do procedimento/função, sob pena de erros em tempo de
compilação.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
38
Exemplo
begin
escreve(10,10, 'mensagem de teste');
col := 15;
lin := 15;
escreve(col, lin, 'outro teste');
end;
Os parâmetros dentro de um procedimento/função são considerados variáveis locais, ou seja, só
existem dentro dele próprio. Podem ter seu valor alterado, mas esta técnica não é muito recomendada.
Ainda por serem variáveis locais, os parâmetros não necessitam de uma definição prévia na área de
definições de variáveis, e também não necessitam ser definidos como variáveis locais, porque a própria
definição ao lado do nome do procedimento/função se encarrega disso.
Os parâmetros servem ainda para a comunicação entre diversas partes do programa. Isto
significa que os dados locais de um procedimento podem ser passados a outro, desde que enviados como
parâmetros. Por este motivo e por tudo que já foi visto, os parâmetros são também conhecidos como
“parâmetros de entrada”.
Vale lembrar que a designação dos nomes de parâmetros seguem as normas dos nomes de
identificadores. Os exemplos aqui mostrados sugerem a utilização do “p_” antes do nome, apenas com o
motivo de mais fácil identificação dos mesmos como parâmetros.
8.4 Funções
Funções, como já foi visto, são procedimentos que retornam um valor. Existem códigos de
programas que são utilizados para chegar a um resultado que deve ser enviado de volta ao ponto onde o
bloco de código foi chamado.
Por exemplo, havendo a necessidade de encontrar o maior valor entre 3 números, deve-se
escrever o código para solucionar o pedido (igual a um procedimento, que pode conter parâmetros). De
posse do valor correto, basta enviá-lo como resultado da função. Como retorna um valor, na definição de
uma função deve-se indicar o tipo de dado que ela retornará.
A forma de escrita de uma função difere da de um procedimento em apenas 3 pontos:
a) nome, começa por “function” e não por “procedure”;
b) deve-se definir o tipo de dados que a função retorna
c) deve-se explicitar o retorno da função
Exemplo
function calcula(p_a, p_b, p_c : integer) : integer;
var
maior : integer;
begin
maior := p_a;
Indicação
Tipo de valor que esta
if p_b > maior then
que esta é
função retorna
maior := p_b;
uma
função
if p_c > maior then
maior := p_c;
calcula := maior;
Implementação do retorno da função.
end;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
39
Como o tipo de retorno de uma função é definido em seu cabeçalho, se pode afirmar uma
variável com o nome da função no programa. O tipo desta variável é o tipo definido na função. Podemos
utilizar uma função em qualquer hipótese de utilização de uma variável. No caso de uma função receber
parâmetros (parâmetros de entrada) estes não podem ser omitidos em uma chamada de função. O valor de
retorno de uma função também é conhecido como “parâmetro de saída”.
Exemplo
a := 5;
b := 6;
c := a + b;
{ chamada de função com atribuição }
ma := calcula(a,b,c);
{ chamada de função com uso do valor de retorno em um “if” }
if calcula(a, b, c) = c then
{
{ chamada de função com o uso do valor de retorno em um
“write”}
write('o maior valor vale ',calcula(a,b,c) );
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
40
8.5 Exercícios com funções e passagem de parâmetros
61) Elaborar uma função que converta graus Centígrados em Fahrenheit.
Dados de entrada
: graus Centígrados (real)
Dado de saída
: graus Fahrenheit (real)
62) Elaborar uma função que converta graus Fahrenheit em Centígrados
Dados de entrada
: graus Fahrenheit (real)
Dado de saída
: graus Centígrados (real)
63) Elaborar uma função que calcule o volume de uma lata.
Dados de entrada
: Raio (R) e altura (A) (reais)
Dado de saída
: volume (real)
64) Elaborar uma função que calcule a soma dos quadrados de 3 números.
Dados de entrada
: A, B, C (inteiros)
Dado de saída
: soma (real)
65) Elaborar uma função que eleve um número a um expoente.
Dados de entrada
: Número (real) expoente (inteiro)
Dado de saída
: resultado (real)
66) Elaborar uma função que calcule se um número é primo.
Dados de entrada
: Número (inteiro)
Dado de saída
: Resultado (boolean: True ou False)
67) Elaborar uma função que calcule se um número é multiplo de outro.
Dados de entrada
: A, B (inteiros)
Dado de saída
: Resultado (boolean: True ou False)
68) Elaborar uma função que calcule o quantos números pares existem entre dois números.
Dados de entrada
: A, B (inteiros)
Dado de saída
: Quantidade de números (inteiro)
69) Elaborar uma função que calcule uma determinada operação entre 2 números (soma ‘+’, subtração ‘-’,
divisão‘/’, multiplicação ‘*’).
Dados de entrada
: A, B (inteiros), operação (char)
Dado de saída
: Resultado (real)
70) Elaborar uma função que leia um número inteiro dentro de uma faixa..
Dados de entrada
: COL, LIN, inicio, fim (inteiros), texto (string)
Dado de saída
: número lido (inteiro)
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
41
9 Tipo de dados orientados a caracteres
9.1 Caracter
Um caractere é uma letra, um dígito, um sinal de pontuação, um espaço em branco ou outro
elemento do conjunto de caracteres. Em um programa Pascal, cada caractere é realmente armazenado
como um código de um único byte inteiro, de 0 a 255. Este código é definido como ASCII (American
Standard Code for Information Interchange), define o conjunto de caracteres disponíveis, providenciando
um equivalente numérico para cada um dos 256 caracteres.
A maior parte da primeira metade do código ASCII - números de 0 a 127 - é usada como padrão
pelos computadores pessoais. Ela fornece os códigos para as letras maiúsculas de “A” a “Z” (65 a 90); as
letras minúsculas de “a” a “z” (97 a 122); os dígitos de “0” a “9” (48 a 57); os sinais de pontuação (“:” 58,
“;” 59, “.” 46, “,” 44), o sinais de operações matemáticas (“+” 43,“-” 45,“/” 47,“*” 42). A segunda metade
do código ASCII, 128 a 255, fornece caracteres não padrão que são freqüentemente implementados de
modo diferente por diferentes marcas de computadores.
9.2 Tipo de dados “Char”
Os tipos de dados “char” definem no Pascal as variáveis do tipo caractere. Este tipo de variável
pode armazenar um caracter de cada vez. Os valores manipulados por variáveis deste tipo devem ser
envoltos por aspas simples (nunca acento agudo). Podemos utilizar os valores de acordo com seu código
ASCII, desde que eles sejam precedido do caracter de sustenido (#).
Exemplo
var
ch, ch1 : char;
{ area de programa ou de procedimentos/funcoes }
ch := 'a';
gotoxy(10,10);
write(ch);
{ aparecera na tela o caracter a }
ch1 := #65;
gotoxy(10,12);
write(ch1);
{ aparecera na tela o caracter A }
gotoxy(10,14);
if (ch = #65) then
write('Sao iguais')
else
write('Nao sao iguais');
Vale lembrar, que o caracter “a” é diferente do caracter “A”, devido a eles serem dois caracteres
diferentes, existem um código ASCII para cada um deles.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
42
9.3 Tipo de dados “String”
Os tipos de dados “string”, armazenam seqüências de caracteres. O comprimento de uma
“string” é igual ao número de caracteres que contém. No Pascal, o tamanho máximo de uma
“string” é de 255 caracteres, enquanto o tamanho mínimo é de 0 caracteres. Uma “string” que não
possua caracteres é chamada de “null” ou vazia.
Na declaração de uma variável do tipo “string”, podemos delimitar o tamanho máximo da
mesma, declarando logo após a palavra reservada “string”, um número máximo de caracteres, envolto
entre colchetes.
Exemplo
var
st1 : string;
nome : string[30];
Os valores manipulados por variáveis deste tipo, devem ser envoltos por aspas simples (nunca
acento agudo). Por ser um conjunto de caracteres, podemos acessar apenas um caracter da “string”. Os
caracteres em um “string” são numerados da esquerda para a direita, começando em 1 e terminando no
valor do tamanho da “string”. Para fazer acesso a um caracter apenas, utilizamos o nome da
“string”, indicando qual a posição que queremos acessar, envolta entre colchetes.
Exemplo
st := ' P
posições -> 1
a
2
s
3
s
4
o
5
6
F
7
u
8
n
9
d o '
10 11
Exemplo
st := 'Passo Fundo';
gotoxy(10,10);
write(st[7]);
{ ira mostrar a letra F }
Como cada “parte” de uma “string” pode ser visualizada como um “char”, podemos
realmente manipular cada pedaço da “string” como se fosse uma variável do tipo “char”, valendo
para este pedaço, todas as regras de um tipo de dados “char”.
Vale lembrar que o comprimento real de uma variável do tipo “string” é dinâmico. O
tamanho máximo nela delimitado não significa que seja sempre o seu tamanho real. Este será
determinado pelo número de caracteres que estão armazenados nela em um dado momento.
Uma “string” pode ser aumentada, diminuída, ter seus elementos trocados de ordem ou
mudados de conteúdo através de funções que a própria linguagem Pascal já possui nela embutida (vide
relação de funções).
Por serem conjuntos ordenados de caracteres, as strings se assemelham muito a vetores
(variáveis que armazenam vários valores de um mesmo tipo) de “char”.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
43
9.4 Exercícios de manipulação de “strings”
71) Escrever um procedimento que processe uma string de 8 valores binários. Esta string contém apenas 7
posições preenchidas. O procedimento deve gerar a oitava posição da string, contendo o valor da
paridade par do número binário compreendido nas suas 7 primeiras posições.
72) Escrever um procedimento que processe uma string de 8 valores binários. Esta string contém apenas 7
posições preenchidas. O procedimento deve gerar a oitava posição da string, contendo o valor da
paridade ímpar do número binário compreendido nas suas 7 primeiras posições.
73) Escrever um procedimento que realize a soma binária de duas strings de 7 posições. A string
resultante poderá ter 8 posições.
74) Escrever uma função que receba como parâmetro uma string contendo um valor binário e o retorne no
formato decimal.
75) Escrever uma função que receba como parâmetro um número inteiro. Gerar a string que contenha o
valor correspondente no formato binário e retornar o valor encontrado.
76) Escrever uma função que receba como parâmetro uma string contendo um valor octal e o retorne no
formato decimal.
77) Escrever uma função que receba como parâmetro um número inteiro. Gerar a string que contenha o
valor correspondente no formato octal e retornar o valor encontrado.
78) Escrever uma função que receba como parâmetro uma string contendo um valor hexadecimal e o
retorne no formato decimal.
79) Escrever uma função que receba como parâmetro um número inteiro. Gerar a string que contenha o
valor correspondente no formato hexadecimal. e retornar o valor encontrado.
80) Escrever um programa que leia uma string contendo apenas valores binários (0 e 1). Mostrar a string
lida. Mostar o valor que ela representa em complemento de 2 e em sinal e magnitude.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
44
10 Novos tipos de dados
A linguagem Pascal oferece uma grande variedade de tipos de dados padrão. Entre eles, citamos
o tipo inteiro (“integer”) e o tipo real (“real”). Entretanto, além desses tipos de variáveis (tipos de
dados) padrões, a linguagem de programação Pascal possibilita a construção de tipos de dados
específicos, através do comando “Type”. Esta declaração deve ser acrescentada antes da área das
definições de variáveis, pois cria novos tipos de dados.
Sua sintaxe consiste da declaração do tipo, seguida de um sinal de igualdade. Após, devemos
escrever a estrutura do novo tipo de dados. Para descrevê-la utilizaremos os tipos primitivos de dados.
Exemplo
Type
Inteiro = integer;
Alfanumerico = string;
Nas declarações acima criamos dois novos tipos de dados, baseados em tipos primitivos do
Pascal. Se quisermos, no entanto, declarar variáveis do tipo “inteiro” ou “alfanumérico”
podemos fazê-lo, pois estes foram criados com o comando “Type”.
Exemplo
Var
i
: inteiro;
nome : alfanumerico;
10.1 Conjunto de Dados de mesmo tipo (array)
A linguagem Pascal também nos proporciona a utilização de variáveis que não armazenam um
único dado, mas conjuntos de dados. Entre as variáveis que armazenam conjuntos de dados, encontramos
a definição de “arrays”, que possibilitam o armazenamento de um conjunto de valores de um mesmo
tipo de dados. Assim, podemos criar o tipos de dados que armazenam vários valores de um mesmo tipo.
Exemplo
Type
novotp = array [1..10] of integer;
O tipo de dados “novotp” criado anteriormente, armazena valores inteiros. Variáveis
declaradas como “novotp”, armazenam 10 valores inteiros distintos. Qualquer tipo de dado pode ser
estendido para um “array”. Um “array” é uma variável que repete um tipo de dado por um número
especificado de vezes.
10.1.1 Manipulação de conjuntos de dados de mesmo tipo
Conjuntos de dados de mesmo tipo também são conhecidos como variáveis dimensionadas
(variáveis que possuem mais de uma dimensão).
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
45
Toda a variável dimensionada, OBRIGATORIAMENTE deve ser indexada. Ou seja, deve ser
acessada (manipulada) com a utilização de seus índices.
As variáveis dimensionadas tem a característica de poderem armazenar mais de uma valor
indistintamente. Para tanto, sempre que quisermos acessar uma variável deste tipo, devemos fazer
referência ao seu nome, juntamente com o índice. Os índices das variáveis dimensionadas variam sempre
de 1 até o limite da dimensão, sendo sempre valores inteiros.
É PROIBIDO: Referenciar uma posição fora do limite.
Referenciar uma matriz ou vetor (em leituras, cálculos, mostragens)
sem os índices.
10.1.2 Vetores
Vetor é um conjunto de dados do mesmo tipo (criado com o auxílio de um “array”). Possui
apenas uma dimensão, ou seja, para identificar um elemento qualquer dentro de um vetor, necessitamos
apenas de um valor para índice. Outro conjunto de dados do mesmo tipo são as matrizes, que possuem
sempre mais do que uma dimensão (para acessar um elemento, é necessário mais do que um índice). Os
vetores também são conhecidos como matrizes de uma dimensão.
Podemos especificar um vetor criando um novo tipo de dados, que armazenam variáveis com as
mesmas características e após definindo uma variável deste tipo, ou ainda diretamente declarando a
variável como se fosse um conjunto de dados de iguais características.
Exemplo
type
vetor = array[1..10] of integer;
var
a,b,c : vetor;
x,y
: array[1..10] of integer;
No exemplo acima, todas as variáveis definidas (“a”, “b”, “c”, “x” e “y”), armazenam cada uma
10 valores inteiros distintos. É desaconselhável a definição de variáveis dimensionadas diretamente em
sua seção, pois desta forma é impossível a construção de procedimentos/funções com passagem de
parâmetros manipulando estes tipos de variáveis.
Os valores das posições dentro de um vetor, começam sempre em 1 e vão até o limite de
tamanho do vetor. Em cada posição de um vetor é possível armazenar um valor distinto.
Exemplo
a = 54
posições -> 1
3
2
-9
3
7
4
88 65
5 6
0
7
7
8
12 15
9 10
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
46
O acesso a elementos dentro de um vetor é realizado através das posições. Os índices das
posições são sempre valores inteiros. É importante salientar que apenas os índices devem ser inteiros, e
que os valores dos elementos podem ser de qualquer tipo.
É importante lembrar a diferença entre o valor do elemento de um vetor e o valor de seu índice.
Os índices são sempre fixos, sua ordem é crescente do valor inicial até o final. Os índices também são
conhecidos como “apontadores” pois existe um valor sendo apontado por ele. O conteúdo de uma posição
apontada por um índice é chamado de “valor do elemento” ou simplesmente “elemento”. Relembrando, o
valor do índice não possui nenhuma relação com o valor do seu conteúdo.
Um elemento de um vetor é considerado como se fosse uma variável independente. Todas as
regras de utilização das variáveis valem para os elementos dos vetores. Geralmente, elementos de vetores
não são tratados de forma individual, mas sim em conjunto. Esta é a grande vantagem de trabalhar com
uma variável de mesmo nome, contendo diversos valores.
A manipulação de vetores é semelhante a qualquer outro tipo de manipulação de outra variável.
O único cuidado é lembrar que num vetor, não existe apenas um valor, mas vários (um em cada posição).
Os exemplos de código abaixo demonstrarão este cuidado adicional.
•
Leitura do vetor A de 10 posições
Exemplo
for i:= 1 to 10 do
begin
gotoxy(10,10);
write('Informe um valor para a ',i, ' posição do vetor: ');
read(a[i]);
end;
•
Troca dos valores negativos do vetor B de 25 posições pelo índice da posição atual
Exemplo
for m := 1 to 25 do
begin
if b[m] < 0 then
b[m] := m;
end;
•
Mostragem do vetor C de 15 posições.
Exemplo
col := 10;
lin := 10;
for j := 1 to 15 do
begin
gotoxy(col,lin);
write(c[j]);
col := col + 5;
if (col > 70) then
begin
col := 10;
lin := lin + 1;
end;
end;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
47
Para construir procedimentos/funções com passagem de parâmetros envolvendo vetores se faz
necessária a criação de um tipo específico. Como já foi dito, parâmetros são variáveis locais. Para um
procedimento de leitura (onde os valores devem existir também fora do procedimento/função em
questão), devemos transformar os parâmetros desejados em variáveis globais.
A utilização de uma variável como índice de um vetor não decreta sua utilização como sendo
parte apenas dele. Esta variável pode ser utilizada como índice em outro vetor. Do mesmo modo, um
vetor pode ser acessado utilizando diversos índices. O que é necessário controlar é que a ação desejada,
ou seja, o valor da variável utilizada como índice, está no momento com seu valor correto.
Exemplo
j := 1;
for i := 1
begin
if a[i]
b[i]
else
begin
b[i]
j :=
end;
end;
to 10 do
< 0 then
:= a[i] * i
:= a[j];
j + 1;
10.1.3 Exercícios de programas com manipulação de vetores
81) Escrever um programa que lê um vetor V[6] e o escreve. Conte, a seguir, quantos valores de V são
negativos e escreva a informação.
82) Escrever um programa que lê um vetor A[10] e o escreve. Leia, a seguir, um número qualquer para a
variável “X”. Contar quantas vezes a variável “X” aparece no vetor.
83) Escrever um programa que leia um vetor B[50] de números inteiros e o escreve. Encontrar o menor e
o maior valor lido. Mostrar os valores encontrados.
84) Escrever um programa que leia um vetor A[10] de números inteiros. Mostrar o vetor lido. Ler um
número inteiro e multiplicar todo o vetor pelo número lido. Mostrar o vetor modificado.
85) Escrever um programa que leia um vetor de 80 posições. Encontrar o maior valor do vetor e sua
posição; mostra-lo juntamente com sua posição.
86) Escrever um programa que leia um vetor V[30] e o escreve. Contar quantos valores do vetor são pares
e quantos são ímpares. Mostrar estas informações, juntamente com a média dos valores do vetor.
87) Escrever um programa que leia um vetor V[30] e o escreve. Calcular a média dos valores do vetor, a
média dos valores do vetor das posições pares e a média dos valores do vetor das posições ímpares.
Mostrar as médias calculadas com uma mensagem adequada a cada uma.
88) Escrever um programa que leia um vetor A[20] de número reais. Mostrar o vetor lido. Trocar a seguir
o 1º elemento com o 11º, o 2º com o 12º e, assim, sucessivamente até o 10º com o 20º. Mostrar o vetor
modificado.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
48
89) Escrever um programa que leia um vetor A[20] de números inteiros. Mostrar o vetor lido. Trocar a
seguir o 1º elemento com o 20º, o 2º com o 19º e, assim, sucessivamente até o 10º com o 11º. Mostrar
o vetor modificado.
90) Escrever um programa que leia 2 vetores de 10 posições, A e B. Mostrar os vetores lidos. Gerar um
novo vetor Y, que seja a união dos lidos. Mostrar o vetor Y.
91) Escrever um programa que leia 2 vetores de 10 posições A e B. Mostrar os vetores lidos. Gerar um
novo vetor Y, que seja a interseção dos lidos. Mostrar o vetor Y.
92) Escrever um programa que leia um vetor de 25 posições, de números inteiros. Mostrar o vetor lido.
Ordená-lo, a seguir, em ordem crescente. Mostrar o vetor modificado.
93) Escrever um programa que leia um vetor V[20]. Mostrar o vetor lido. Criar dois vetores: PAR para os
valores pares e IMPAR para os valores ímpares, do vetor V. Mostrar os vetores gerados.
94) Escrever um programa que leia um vetor de 30 posições sem números repetidos. Mostrar o vetor lido.
Mostrar também quantos números o usuário digitou para preencher o vetor.
95) Escrever um programa que leia um vetor de 30 posições. Mostrar o vetor lido. Encontrar o valor
maior e o menor valor. Passar o maior para a última posição do vetor e passar o menor para a primeira
posição, transferindo os valores que estavam nas extremidades do para as posições do maior e do
menor.
96) Escrever um programa que leia 2 vetores X e Y de 10 posições de números inteiros. Ordenar os
vetores em ordem crescente. Passar os vetores para um vetor Z e, a seguir, ordenar o vetor Z em
ordem decrescente.
97) Escrever um programa que leia 2 vetores X e Y de 10 posições de números inteiros. Ordenar os
vetores em ordem crescente. Passar os valores dos dois para um vetor Z, mantendo a ordem crescente,
sendo proibido reordena-lo. Mostrar o vetor Z.
98) Escrever um programa que gere os 10 primeiros números primos acima de 500 e os armazene no vetor
X[10]. Mostrar, ao final, o vetor criado.
99) Escrever um programa que leia um vetor de 30 posições. Mostrar o vetor lido. Mostrar em uma única
tela, todos os seus valores, indicando quantas vezes cada um aparece. Não repetindo os que aparecem
mais de uma vez.
100) Escrever um programa que leia para um vetor de V[30] as suas vinte primeiras posições. Ordenalas em ordem crescente. Ler, a seguir, 10 valores e inseri-los no vetor V, mantendo a ordem crescente.
A cada valor inserido, mostrar a nova formação do vetor.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
49
10.1.4 Matrizes
Conforme já visto no estudo dos vetores, as matrizes fazem parte do grupo de variáveis que
armazenam vários valores de um mesmo tipo. As matrizes diferem dos vetores por possuírem mais de
uma dimensão, ou seja, necessitam de dois índices para identificar um elemento.
O conceito de matriz estende-se para várias dimensões (no máximo 9), porém, para efeito deste
estudo, consideraremos somente 2, a exemplo do que ocorre na matemática.
Para definirmos uma matriz, podemos ou criar um tipo ou declará-la diretamente na área das
variáveis. Os efeitos destas duas maneiras diferentes de declarar variáveis dimensionadas já foi discutido
(ver seção de vetores).
Exemplo
type
matriz = array[1..5,1..5] of integer
var
m, n, o : matriz;
O exemplo acima criou o tipo “matriz” (tipo de dados que armazena 25 valores inteiros) e
definiu as variáveis “m”, “n” e “o” como sendo deste tipo.
De forma semelhante aos vetores, os índices nas matrizes começam sempre em 1 e vão até o
limite da dimensão.
Exemplo
índice das linhas
↓
índice das colunas
1
2
3
→
1
4
15
6
2
4
7
2
m= 3
6
9
0
4 -38 23 -1
5 -78 36
0
4
-7
6
4
41
6
5
28
33
4
-9
-7
Da mesma forma que ocorre com os vetores, o acesso aos elementos dentro de uma matriz é feito
através das posições. Entretanto, como um vetor possui apenas um índice, sua posição é igual ao a este
mesmo índice, enquanto, nas matrizes, a posição é formada pela tupla < “número da linha”, “número da
coluna” > (por exemplo[2,3]).
Exemplo
Índices de uma
matriz quadrada
de ordem 5
1
2
3
4
5
1
[1,1]
[2,1]
[3,1]
[4,1]
[5,1]
2
[1,2]
[2,2]
[3,2]
[4,2]
[5,2]
3
[1,3]
[2,3]
[3,3]
[4,3]
[5,3]
4
[1,4]
[2,4]
[3,4]
[4,4]
[5,4]
5
[1,5]
[2,5]
[3,5]
[4,5]
[5,5]
A diferença entre uma posição de uma variável dimensionada e o seu valor se torna mais
evidente nas matrizes. Enquanto a posição é formada por dois valores distintos de índices, o seu conteúdo
(seu valor) é de apenas um.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
50
Todas as afirmações realizadas para os vetores valem para as matrizes. A seguir, exemplos de
código envolvendo operações básicas sobre matrizes.
•
Leitura de uma matriz M[5 x 5]
Exemplo
for i:= 1 to 5 do
begin
for j := 1 to 5 do
begin
gotoxy(10,10);
write(‘Digite um valor para a posicao [‘,i, ,‘,j,‘] da matriz‘);
read(m[i,j]);
end;
end;
•
Contar os valores ímpares de uma matriz N[100 x 100]
Exemplo
cont := 0;
for l := 1 to 100 do
begin
for c := 1 to 100 do
If odd(n[l,c]) then
cont := cont + 1;
end;
•
Mostragem de uma matriz O[8 x 8].
Exemplo
col := 10;
lin := 10;
for l := 1 to 8 do
begin
for c := 1 to 8 do
begin
gotoxy(col,lin);
write(o[l,c]);
col := col + 5;
end;
col := 10;
lin := lin + 1;
end;
Nos exemplos acima, as matrizes foram trabalhadas “por linha”, ou seja, foram manipulados
primeiro os valores de toda a 1a linha, e após os da seguinte. Nada impede que uma matriz seja acessada
“por colunas” porém sua manipulação por linha é de mais fácil compreensão.
Em alguns tipos de problemas, como encontrar somas, maiores ou menores elementos de uma
coluna da matriz, faz-se necessária a manipulação da mesma “por colunas”.
Apenas para facilitar o entendimento das matrizes, serão mostradas as referências a cada um dos
“pedaços” em que geralmente é dividida uma matriz.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
51
Regra geral
j
i
↓
→
1
2
3
4
5
DP :
DS :
SUP
:
INF :
1
DP
2
3
4
SUP
SUP
SUP
5
DS SUP
INF
DP
SUP
DS SUP
SUP
INF
INF
DP DS
SUP
SUP
INF
DS INF
INF
DP
SUP
DS INF
INF
INF
INF
Significado
Diagonal principal
Diagonal Secundária
Superior a DP
Inferior a DP
DP
Fórmula
i = j
i + j = n* + 1
i < j
i > j
* " n: ordem da matriz, no exemplo 5
10.1.5 Exercícios de programas com manipulação de matrizes
101) Escrever um programa que leia uma matriz M[3,2]. Mostrar a matriz lida. Contar quantos valores
de M são positivos.
102) Escrever um programa que leia uma matriz N[4,3]. Mostrar a matriz lida. Ler, a seguir, um valor
para a variável “X”. Contar quantas vezes este valor aparece na matriz e mostrar a informação.
103) Escrever um programa que leia uma matriz M[3,3]. Mostrar a matriz lida. Encontrar o menor
elemento da matriz e mostrá-lo.
104) Escrever programa que leia uma matriz M[5,5] e calcular as somas:
a) da linha 4 de M
b) da coluna 2 de M
c) da diagonal principal
d) da diagonal secundária
e) de todos os elementos da matriz
Escrever as somas e a matriz.
105) Escrever um programa que leia uma matriz M[5,5] e a escreve. Trocar, a seguir:
a) a linha 1 com a linha 4
b) a coluna 2 com a coluna 5
c) a diagonal principal com a diagonal secundária
d) a linha 2 com a coluna 5
A cada troca realizada, mostrar a matriz. Fazer com que a matriz em todos os estágios de trocas fique
visível em uma única tela.
106) Escrever um programas que lê uma matriz M[5,5] de números inteiros. Mostrar a matriz lida.
Criar dois vetores, SC e SL contendo, respectivamente, as somas das colunas e das linhas de M.
Mostrar os vetores criados.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
52
107) Escrever um programa que leia um matriz M[4,6]. Mostrar a matriz lida e criar:
a) Uma matriz M1, transposta da matriz M
b) Uma matriz M2, com as posições em que a soma dos índices seja par, preenchida com 2, e as demais
preenchidas com 1.
c) Uma matriz N1, como sendo uma matriz identidade de uma matriz quadrada de ordem 6.
Mostrar todas as matrizes envolvidas, de modo que sejam visíveis em uma única tela.
108) Montar um programa que leia uma matriz M[6,6] de números inteiros. Mostrar a matriz lida.
Passar para o vetor V, os elementos da matriz M. Mostrar o vetor V
109) Montar um programa que leia um vetor V[32]. Mostrar o vetor lido. Passar o vetor V para uma
matriz M[8,4], preenchendo a matriz por linhas. Mostrar a matriz M.
110) Ler para uma matriz M[10,4], as 3 primeiras posições de cada linha. Completar a ultima posição
de cada linha, com a soma dos 3 primeiros elementos da linha. Mostrar a matriz.
111) Na teoria de sistemas define-se o elemento mínimax de uma matriz como sendo o menor elemento
da linha onde se encontra o maior elemento da matriz. Escrever um programa que lê uma matriz
M[10,10] e determina o elemento mínimax desta matriz, mostrando a matriz, o elemento e a posição
do mínimax.
112) Escrever um programa que leia uma matriz [5,15] de números inteiros. Criar uma matriz com
apenas 4 colunas, onde cada coluna conterá, respectivamente, o menor e o maior valor da linha, a
média e a soma de todos os valores da linha. Mostrar as matrizes envolvidas.
113) Escrever um programa que leia uma matriz M[7,7] de números inteiros. Passar para o vetor PAR,
todos os elementos das linhas pares e passar para o vetor IMPAR, todos os elementos das linhas
ímpares da matriz. Mostrar os vetores gerados.
114) Escrever um programa que leia uma matriz M[7,7]. Mostrar a matriz lida. Dividir todos os
elementos de uma linha pelo maior elemento da linha em questão. Mostrar a matriz modificada.
115) Escrever um programa que leia três valores A, B e C, todos inteiros, positivos e menores que 11.
Preencher uma matriz M[3,10], com os 10 primeiros múltiplos positivos de cada um dos números
lidos.
116) Escrever um programa que gere um vetor V[6], contendo o resultado da mega-sena obtidos
números aleatórios (os números válidos na mega-sena estão no intervalo [1..60]). Ler, a seguir, de
uma matriz M[10,7], apenas as 6 primeiras posições de cada linha os números apostados em 10
cartões. Calcular o número de acertos em cada cartão, e colocar esta informação na sétima coluna de
cada linha.
117) Escrever um programa que leia uma matriz M[9,9]. Mostrar a matriz lida. Encontrar o maior
elemento de cada linha e passá-lo para a posição da diagonal principal na linha. Mostrar a matriz
modificada.
118)
Escrever um programa que leia uma matriz M[4,4] sem elementos repetidos. Mostrar a matriz lida
119) Muitos problemas de cálculo numérico utilizam o método de Gauss para efetuar o cálculo. O
método de Gauss só pode ser usado quando todos os elementos da diagonal principal sejam diferente
de 0 (zero), não importando se a ordem das linhas da matriz for mudada. Escrever um programa que
leia uma matriz M[5,5], e a prepara para ser utilizada no método de Gauss
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
53
10.2 Conjuntos de dados de tipos diferentes
Regra geral
type
<nome_de _tipo> = record
identificador_de_campo1
identificador_de_campo2
identificador_de_campo3
. . .
identificador_de_campon
end; { Final da declaracao
: tipo;
: tipo;
: tipo;
: tipo;
do registro }
Embora a matriz (lembre-se, vetor é uma matriz de 1 dimensão) seja uma estrutura de dados
muito útil, é limitada, porque todos os seus elementos devem ser do mesmo tipo. Em alguns casos, são
necessários conjuntos de informações em que os dados não sejam de tipo uniforme. As estruturas de
dados, que armazenam um conjunto de dados, não tendo o mesmo tipo em Pascal chamam-se
REGISTROS.
A vantagem que um registro oferece como dado estruturado é a sua flexibilidade. A estrutura dos
registros é formada por campos e cada campo pode ser de um tipo diferente.
Exemplo
type
pessoa = record
nome
: string[20];
idade
: integer;
altura
: real;
peso
: real;
end;
A definição do registro acima criou um novo tipo chamado "pessoa". O novo tipo é um registro.
Portanto quando uma variável é declarada como sendo do tipo "pessoa", poderá armazenar dados
referentes a nome, idade, altura, endereço e peso de uma pessoa. A declaração de uma variável como
sendo um registro, após a criação do tipo registro (com o comando type) é feita de forma semelhante a
qualquer outra variável.
Exemplo
var
fulano
: pessoa;
beltrano, ciclano : pessoa;
A flexibilidade dos registros também proporciona uma maior facilidade no manuseio de
informações do mesmo tipo. Uma data é composta de um conjunto de 3 números: dia, mês e ano. Pode-se
facilmente armazenar datas em um vetor de 3 posições, porém, a referência a um identificador "mes", é
mais facilmente compreendido do que a referência a um "vet[2]".
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
54
Exemplo
type
data =
dia
mes
ano
end;
record
: integer;
: integer;
: integer;
var
hoje
amanha, ontem
: data;
: data;
O acesso aos elementos de uma variável, declarada a partir de um tipo registro, é realizado
usando como prefixo o nome da variável, seguido de um "." (ponto), e logo após o nome do campo do
registro desejado. Todos os comandos e funções do Pascal que podem ser empregados sobre uma
variável, podem ser empregados sobre um campo de um registro.
Exemplo
hoje.dia := 07;
hoje.mes := 12;
hoje.ano := 2000;
read(fulano.nome);
read(amanha.ano);
write(amanha.dia);
write(ciclano.endereco);
x := fulano.idade - hoje.ano;
Nada impede que se crie um conjunto de dados de mesmo tipo sendo este um registro. No caso,
teríamos da mesma forma uma matriz (ou vetor) de dados de tipos semelhantes, porem, cada elemento
desta matriz terá vários campos.
Exemplo
var
amigos : array[1..10] of pessoa;
semana : array[1..7] of data;
O acesso neste caso, deverá ser realizado através do nome da variável, seguido de seus índices
(entre colchetes, é claro) tendo, logo a seguir, um "." junto com o nome do campo desejado.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
55
Exemplos:
{ leitura de 10 amigos }
for i := 1 to 10 do
begin
read(amigos[i].nome);
read(amigos[i].idade);
read(amigos[i].altura);
read(amigos[i].peso);
end;
{ mostrar 10 amigos }
lin := 10;
for i := 1 to 10 do
begin
gotoxy(05,lin);
gotoxy(30,lin);
gotoxy(35,lin);
gotoxy(55,lin);
lin := lin + 1;
end;
write(amigos[i].nome);
write(amigos[i].idade);
write(amigos[i].altura:2:2);
write(amigos[i].peso:4:2);
{ calcular a média de altura de 10 amigos }
soma:=0;
for j := 1 to 10 do
begin
soma := soma + amigo[i].altura;
end;
media := soma / 10;
10.2.1 Exercícios de programas com manipulação de registros
120) Montar um programa que leia os dados de 1 pessoa (você). O programa deverá mostrar a sua
relação peso/altura.
121) Montar um programa em pascal que crie um registro para guardar as informações de carros
(modelo, velocidade máxima, média de consumo, número de marchas e preço de mercado). Após
criado o registro, definir 2 variáveis como sendo do tipo carro. Ler informações para as variáveis e
mostrá-las.
122) Usando o programa anterior, ler novamente 2 carros. Mostrar todos os dados do carro com a
menor média de consumo.
123) Montar um programa que informe dados referentes a 10 amigos seus. O programa deverá mostrar
o nome de seu amigo mais velho.
124) Montar um programa que leia 20 datas aleatórias. O programa deverá mostrar qual a maior e a
menor data. Mostrar ainda a média dos anos (levar em consideração apenas os anos) informados.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
56
11 Arquivos
No decorrer deste trabalho, foram desenvolvidos vários programas interessantes em Pascal.
Porém todos eles compactuam de uma mesma limitação: a entrada de dados deve ser realizada via teclado
ou incluída no código do programa e os resultados aparecem na tela do computador. Este procedimento
pode ser adotado em pequenas aplicações, mas se forem muitos os resultados devem ser fornecidos em
uma impressora, ou conter sua entrada/saída em um arquivo.
Arquivos são estruturas de dados que continuam existindo mesmo após o final da execução do
programa. Eles são utilizados para armazenar dados numa forma utilizável pelo computador sem requerer
a reentrada dos mesmos. Programas muito complexos que geram um elevado volume de dados como
saídas (por exemplo uma grande quantidade de índices calculados) devem ter sua saída direcionada para
um arquivo para posterior depuração dos resultados, com tempo sem necessidade de os mesmos serem
transcritos ou impressos.
Um arquivo é armazenado em um dispositivo de memória secundária (ou seja quando o
programa é encerrado e o micro desligado, suas informações permanecem gravadas) como por exemplo
um winchester (HD) ou um disquete. Tanto pelo sistema operacional quanto dentro de um programa, um
arquivo deve ser referenciado pelo seu nome. Por exemplo "dados.arq", pode ser o nome de um arquivo
que armazena os dados referentes a um programa qualquer. A referência ao arquivo pode conter ainda a
especificação da unidade de disco onde o mesmo se encontra: "A" ou "C".
O Pascal suporta dois tipos básicos de arquivo: os arquivos de dados (baseados em registros) e
os arquivos sem formato definido que armazenam texto. Os arquivos que armazenam texto devem ser
referenciados por um identificador de arquivo texto. Para se definir um identificador de arquivo texto,
sendo seguidas as regras de definição de variáveis, apenas usando a palavra reservada "textfile".
Exemplo:
var
idtexto : textfile;
arq_text : textfile;
Ao contrário dos arquivos baseados apenas em texto, os arquivos com tipos definidos, devem
armazenar apenas dados dos tipos para os quais foram definidos (os arquivos texto podem guardar
qualquer tipo de dado, mas sempre no formato texto). Os arquivos com tipo definido, podem ser baseados
em registros, o que aumenta o leque de suas aplicações. Nada impede que seja definido um arquivo que
irá armazenar informações de apenas um tipo de dado padrão do Pascal. Para definir um arquivo baseado
em registros, deve-se definir um identificador para o arquivo, usando as palavras reservadas "file of".
Exemplo:
type
pessoa = record
nome : string[20]
idade : integer;
. . .
end;
var
arq_pes : file of pessoa ;
arq_dias : file of integer ;
ciclano : pessoa;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
57
No exemplo anterior, foram definidos como variáveis dois identificadores para arquivos de tipos
definidos: "arq_pes" e "arq_dias". O primeiro serve para referenciarmos um arquivo baseado em tipos
(definidos no registro pessoa), enquanto o segundo é um identificador para um arquivo que armazena
apenas dias (de tipo integer).
Uma prática bastante comum em programas que manipulam arquivos de tipo definido baseados
em registros, é a definição de uma variável de memória (os registros de cada arquivo são considerados
variáveis de arquivo) para trabalhar com as informações do arquivo em memória. É o caso da variável
"ciclano" no exemplo acima.
Ambos os tipos de arquivo, possuem características semelhantes no aspecto relativo aos
programas que os manipulam. Os arquivos devem ser: identificados, abertos, lidos/gravados,
posicionados e fechados.
O comando "assign(<variavel de arquivo>,<nome do arquivo>)", liga uma variável
identificadora de arquivo a um arquivo em uma unidade de disco. Sua sintaxe compreende o nome do
identificador, seguido do nome do arquivo. O nome do arquivo pode conter ainda a identificação da
unidade de disco onde o mesmo se encontra, juntamente com a especificação do diretório do arquivo.
Exemplo:
assign(idtexto, ´text.txt´);
assign(arq_pes, ´pessoas.dat´);
assign(arq_dias,´A:dias.dat´);
assign(arq_texto, ´C:\TP\BIN\exemplo.txt´);
Após ligar um identificador a um nome de arquivo, o mesmo deve ser aberto para que
informações possam ser escritas/lidas. Existem basicamente duas formas de se abrir um arquivo: abrir um
arquivo já existente para uso de informações contidas ou criando um arquivo que ainda não possui dados.
O comando "reset(<variável de arquivo>)" abre um arquivo já existente em uma unidade de
disco. Após aberto, pode-se ler as informações nele contidas ou inserir novos dados.
O comando "rewrite(<variável de arquivo>)", cria um novo arquivo em uma unidade de disco.
Caso já exista um arquivo com o mesmo nome na mesma unidade de disco e diretório (ligação pela
<variável de arquivo>), este arquivo será apagado e um novo tomará o seu lugar. Esta opção deve ser
usada apenas na criação de arquivos, nunca em programas que irão ler os dados de um determinado
arquivo.
Exemplo:
reset(idtexto);
{ abre o arquivo ligado em idtexto }
rewrite(arq_pes); { cria um novo arquivo na unidade de disco
com o nome especificado em arq_pes }
As operações de leitura e escrita em arquivo, tanto de tipo definido ou não são realizadas de
forma semelhante a uma leitura/escrita de uma variável em programa Pascal. Os comandos "read" e
"write" funcionam tanto nos dispositivos de E/S padrão (teclado e vídeo) quanto em arquivos. Deve-se
identificar, antes de referenciar o que se deseja gravar/ler, onde se deseja fazer esta operação. Para
identificar onde a ação será realizada, informa-se o identificador de arquivo. Caso nada seja informado, os
dados serão lidos/gravados nos dispositivos padrão (como é feito desde o início dos programas).
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
58
Exemplo:
write(idtexto, ´Passo Fundo´);
{grava a string ´Passo Fundo´ no arquivo apontado por idtexto}
read(arq_pes, ciclano);
{ transefere as informações referentes a um registro de arq_pes para a variável de
memória ciclano }
Em arquivos de tipo definido, a localização de um registro em especial é de extrema utilidade.
Os registros são armazenados de forma seqüencial, podendo ser acessados usando seu número de entrada.
O comando "seek(<variavel de arquivo>,<posicao>)", posiciona um arquivo numa determinada posição.
Arquivos possuem forte semelhança com as matrizes. Uma maneira fácil de entender as posições de cada
registro em um arquivo é visualizar as mesmas com índices de linhas em uma matriz. As colunas da
matriz podem da mesma forma, serem vistas como os campos de cada registro. O posicionamento em
arquivos é de suma importância, pois quando um registro é lido, o que será transferido para a memória é o
registro que estiver na posição atual do arquivo.
Exemplo:
read(posicao); { le um inteiro (posicao desejada) }
seek(arq_pes, posicao);
{ posiciona o arquivo arq_pes, na posição indicada pela variável }
As matrizes possuem sempre um tamanho pré-definido. No caso de uma matriz ser definida para
ter 50 linhas com 10 colunas, se sabia de antemão que a linha de número 50 seria a última. Com arquivos,
o tamanho em linhas (número de registros) é teoricamente limitado pelo espaço disponível na unidade de
disco. Porém, quando estamos procurando dados em um arquivo, devemos saber quando chegamos ao
final do arquivo. A função "eof(<variavel de arquivo>)", retorna um valor booleano (True ou False) se já
foi alcançado o final do arquivo. Sua utilização é imprescindível para, por exemplo, percorrer todas as
linhas (registros) de um arquivo a fim de procurar um número qualquer.
O exemplo abaixo, percorre todo o arquivo, mostrando o conteúdo do mesmo. Ao chegar no
último registro, o laço se encerra.
Exemplo:
lin := 10;
while not eof(arq_pes) do
begin
read(arq_pes,fulano);
gotoxy(10,lin);
write(fulano.nome);
gotoxy(40,lin);
write(fulano.idade);
lin := lin + 1;
if lin > 23
begin
clrscr;
lin := 10;
end;
end;
Todas as operações de escrita/leitura realizadas sobre um arquivo, não são imediatamente
realizadas no meio físico de armazenamento (disquete ou HD). Todos os sistemas operacionais trabalham
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
59
com buffers, que são regiões na memória principal que guardam ´pedaços´ da memória secundária a fim
de não sobrecarregar os acionadores de disco (este é um dos motivos que leva a perda de dados quando da
falta de luz, pois as informações ainda não foram fisicamente transferidas). Quando um programa encerra
sua execução, todas as alterações em arquivos devem ser fisicamente atualizadas, sob pena de perda de
informações e/ou perda de todo o arquivo. Desta forma, após ser utilizado, um arquivo deve ser fechado
de maneira correta, seguindo o comando "close(<arquivo de programa>)". Este comando fecha o arquivo,
atualizando a memória secundária, deixando-o em um estado seguro.
Exemplo:
begin
. . .
{ comandos de manipulação de arquivos }
. . .
close(arq_pes);
end.
Exemplo completo de programa com manipulação de arquivos
program cria_arquivo;
{ Este program cria um arquivo de nome EMPRESA.DAT no meio magnético}
uses crt;
type
registro = record
codigo : integer;
altura : real;
end;
var
cadastro
: file of registro;
func
: registro;
i, opcao, busca, flag : integer;
procedure parada;
begin
gotoxy(10,24);
write('Operacao concluida - pressione qualquer tecla');
readkey;
clrscr;
end;
procedure le_grava_dados;
begin
gotoxy(10,10);
write('Informe o codigo : ');
readln(func.codigo);
gotoxy(10,12);
write('Informe a altura: ');
read(func.altura);
write(cadastro, func);
end;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
60
procedure busca_dados;
begin
gotoxy(10,09);
write('Informe o codigo desejado :');
read(busca);
seek(cadastro, 0);
{ posiona o ponteiro do arquivo no inicio }
flag := 0;
while not eof(cadastro) do
begin
read(cadastro, func);
if func.codigo = busca then
begin
flag := 1;
exit;
{ Abandona a execucao do laco }
end;
end;
end;
procedure mostra_dados;
begin
if flag = 1 then
begin
gotoxy(10,15);
write('Dados buscados do arquivo');
gotoxy(10,16);
write('Codigo : ', func.codigo);
gotoxy(10,18);
write('Altura : ', func.altura:4:2);
end
else
begin
gotoxy(10,15);
write('Registro nao encotrado');
end;
end;
procedure mostra_arquivo;
var
lin : integer;
begin
seek(cadastro, 0);
lin := 10;
gotoxy(10,lin-1);
write('Codigo
Altura');
while not eof(cadastro) do
begin
read(cadastro, func);
gotoxy(10,lin);
write(func.codigo);
gotoxy(20,lin);
write(func.altura:4:2);
lin := lin + 1;
if lin > 22 then
begin
gotoxy(10,24);
write('Pressione qualquer tecla para continuar');
readkey;
clrscr;
lin := 10;
end;
end;
end;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
61
procedure escolhe_opcao;
begin
gotoxy(10,03);
write('[1]
gotoxy(10,04);
write('[2]
gotoxy(10,05);
write('[3]
gotoxy(10,06);
write('[0]
gotoxy(10,07);
write('Informe a sua opção: ');
read(opcao);
end;
Insere dados');
Busca dados');
Mostra todo o arquivo');
Encerra o programa');
procedure controla;
begin
clrscr;
repeat
escolhe_opcao;
if opcao = 1 then
le_grava_dados;
if opcao = 2 then
begin
busca_dados;
mostra_dados;
end;
if opcao = 3 then
mostra_arquivo;
if opcao <> 0 then
parada;
until opcao = 0;
end;
begin
clrscr;
assign(cadastro,'a:EMPRESA.DAT');
rewrite(cadastro);
controla;
close (cadastro);
end.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
62
11.1 Exercício com manipulação de arquivos
125) Montar um programa que crie um arquivo de pessoas chamado ´PESSOAS.DAT´. O programa
deverá ainda inserir dados de seus amigos. Parar de informar pessoas quando o código for igual a 0
(zero). Usar o record abaixo para o arquivo.
type
pessoa = record
codigo
: integer;
idade
: integer;
altura
: real;
peso
: real;
end;
126)
Montar um programa que mostre o conteúdo do arquivo criado no exercício anterior.
127) Montar um programa que processa o arquivo ´PESSOAS.DAT´ e encontra seus o seu amigo mais
alto e o mais baixo.
Montar um programa que processe o arquivo ´PESSOAS.DAT´ e mostra a média de altura e de peso
de seus amigos.
128)
129) Montar um programa que leia o código de um amigo. Procurar no arquivo ´PESSOAS.DAT´ e
mostrar os dados referentes a esta pessoa. Caso o código desta pessoa não exista no arquivo, mostrar
uma mensagem indicando este fato.
130) Montar um programa que leia um matriz M[10,5] de números reais. O programa devera criar o
arquivo ´MATRIZ.DAT´ com os dados desta matriz. Usar o record abaixo para armazenar as
informações.
type
linha = record
coluna1 : real;
coluna2 : real;
coluna3 : real;
coluna4 : real;
coluna5 : real;
end;
Montar um programa que leia o arquivo ´MATRIZ.DAT´. Passar o seu conteúdo para uma matriz
M[10,5]. Mostrar a matriz gerada.
131)
132) Montar um programa que leia o arquivo ´MATRIZ.DAT´. Passar o seu conteúdo para uma matriz
M[10,5]. Mostrar a matriz gerada. Calcular as seguintes somas:
a)
b)
c)
d)
e)
Soma
Soma
Soma
Soma
Soma
das linhas pares (apenas 1 soma)
das colunas ímpares (apenas 1 soma)
da diagonal principal
da diagonal secundária
de toda a matriz.
133) Montar um programa que leia o arquivo ´MATRIZ.DAT´. Passar o seu conteúdo para uma matriz
M[10,6]. Mostrar a matriz gerada. Completar a ultima coluna de cada linha com a soma dos elementos
da linha e mostrar a matriz modificada.
Montar um programa que faça o mesmo do programa anterior, porém após ser completada a sexta
coluna da matriz, gravar a matriz modificada com o nome de ´MATRIZ2.DAT´.
134)
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
63
12 Glossário de Funções do Pascal
O Pascal contém um grande número de funções definidas. Estas funções ajudam o programador
a resolver mais facilmente seus problemas. Existem funções matemáticas, funções para o uso com tipos
de dado caracter, funções de propósito geral, entre outras.
12.1 Funções matemáticas
As funções a seguir são algumas de uso comum com a matemática. Existem mais, porém que
não serão necessárias neste estudo.
Função:
Significado:
Na matemática :
Exemplo de uso :
abs(x : qualquertipo) : mesmotipo;
Retorna o valor (módulo) absoluto de um número (real ou inteiro)
x=|x|
x := -9.8;
y := -8;
z := 17;
x := abs(x);
{ x passa a valer 9.8 }
y := abs(y);
{ y passa a valer 8 }
z := abs(z + y); { z passa a valer 9 }
Função:
Significado:
Na matemática :
Exemplo de uso :
int(x : real) : real ;
Retorna a parte inteira de um número real
x = int( x )
x := 9.8;
y := -8;
x := int(x);
{ x passa a valer 9 }
y := int(y);
{ y passa a valer -8 }
Função:
Significado:
Na matemática :
Exemplo de uso :
frac(x : real) : real ;
Retorna a parte fracionária de um número real
x = frac( x )
x := 9.8;
y := -8;
x := frac(x);
{ x passa a valer 0.8 }
y := frac(y);
{ y passa a valer 0.0}
Operador : mod : integer;
Significado: Retorna o resto da divisão entre dois valores inteiros.
Na matemática :
y := 2;
Exemplo de uso : x := 5;
z := x mod y
{ Z passa a valer 1 }
k := y mod x
{ k passa a valer 5 }
Função: odd(x : integer) : Boolean;
Significado: Retorna se o número é ímpar ou não.
Na matemática :
y := 4;
Exemplo de uso : x := 5;
if odd(x) then
{ retorna TRUE }
if odd(y) then
{ retorna FALSE }
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
Função:
Significado:
Na matemática :
Exemplo de uso :
64
sqr(x : qualquertipo) : mesmotipo;
Retorna o quadrado de um número.
x = x2
x := 5;
y := 4.5;
x := sqr(x)
{ x passa a valer 25 }
y := sqr(X + y) { y passa a valer 90.25 }
Função: sqrt(x : real) : real;
Significado: Retorna a raíz quadrada de um número.
Na matemática : x = x
y := 96;
Exemplo de uso : x := 81;
x := sqrt(x)
{ x passa a valer 9 }
y := sqrt(X + y) { y passa a valer 13,3041}
12.2 Funções para uso com tipos caracter
As funções e os procedimentos a seguir são para uso exclusivo com tipos de dados caracter.
Existem mais, porém que não serão necessárias neste estudo.
Função: concat(s1, s2, ...: string) : string;
Significado: Concatena (agrupa) uma seqüência de strings (tem o mesmo efeito do
operador +)
y := ' ';
z := 'Fundo';
Exemplo de uso: x:= 'Passo';
x:=concat(x,y,z);{ x passa a conter 'Passo Fundo'}
Função: copy(s : string;
PosInicio, NoCaracs : Integer) : string;
Significado: Retorna (extrai) parte de uma string, da posição inicial (PosInicio) um
n° de caracteres (NoCaracs).
Exemplo de uso: x := 'Passo Fundo';
y := copy(x,7,5); { x passa a conter 'Fundo' }
Função: delete(var s : string;
PosInicio, NoCaracs : Integer) : integer;
Significado: Apaga caracteres em um string. Retorna o número de caracteres apagados
da string. A variável que vai como argumento é a mesma que é
modificada.
Exemplo de uso: x := 'Passo Fundo';
delete(x,7,5); { x passa a conter 'Passo' }
Função: insert(substr : string;
var s : string;
PosInicio, NoCaracs : Integer) : integer;
Significado: Insere caracteres numa string. Retorna o número de caracteres inseridos na
string. A variável s que vai como argumento é a mesma que será
modificada.
Exemplo de uso: x := 'PassoFundo';
y := ' ';
insert(y,x,6); { x passa a conter 'Passo Fundo' }
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
65
Função: length(s : string) : integer;
Significado: Retorna o tamanho de um string (quantos caracteres ela possui)
y := '';
z := 'a';
Exemplo de uso: x := 'Passo Fundo';
i := length(x);
{ i passa a valer 11 }
j := length(y);
{ j passa a valer 0 }
k := length(z);
{ k passa a valer 1 }
Função: pos(substr, StrPrincipal : string) :
Significado: Retorna a posição da primeira ocorrência
StrPrincipal.
Exemplo de uso: x := 'Passo Fundo';
y := 'F';
i := pos('o',x);
{ i passa a valer
j := pos(y,x);
{ j passa a valer
k := pos('f',x);
{ k passa a valer
não se encontra na StrPrincipal
byte;
da substr
na
5 }
7 }
0, a substr
}
Função: readkey() : char;
Significado: Lê apenas um caracter do teclado. O caracter lido não é mostrado na tela..
Exemplo de uso: x := readkey;
{ x recebe o caracter que foi digitado no
teclado, não acontecendo nada na tela }
Procedimento : str(x : qualquernumero; var s : string);
Significado: Converte um tipo de dado numérico em um string.
Exemplo de uso: i := -10;
r := 9.8;
str(r:4:2,x); { x passa a conter '9.80' }
str(r,y);
{ y vai valer ' 9.8000000000E+00'}
str(i,z);
{ z passa a conter '-10' }
Procedimento: val(s : string; var i : integer; var r : real)
Significado: Converte uma string em um número real, retornando no argumento inteiro
a posição da string se ocorreu um erro.
Exemplo de uso: x := '9.8';
val(x,i0,r); { r passa a conter 9.8 }
{ i0 passa a conter 0 }
r0 := r + 10; { r0 passa a conter 19.8 }
Função: upcase(ch : char) : char;
Significado: Retorna o caracter enviado como argumento, no formato maiúsculo.
Exemplo de uso: x := 'a';
y := 'B';
x := upcase(x); { x passa a valer 'A' }
y := upcase(y); { y passa a valer 'B' }
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
66
12.3 Funções/procedimentos e comandos de propósito geral
As funções e os procedimentos a seguir são de propósito geral. Existem mais, porém que não
serão necessárias neste estudo.
Função: trunc(r : real) : integer;
Significado: Converte um número real para um número inteiro. Troca o tipo.
q:= 1;
Exemplo de uso: r: 9.8;
i := trunc(r);
{ i passa a valer 9 };
j := trunc(q);
{ j passa a valer 1 },
Procedimento: clreol;
Significado: Limpa toda uma linha, da posição atual do cursor até o final da linha.
Exemplo de uso: gotoxy(20,10);
clreol; { limpa a linha 10, da coluna 20 até o
final }
Função: ramdom(qualquernumero) : qualquernumero;
Significado: Retorna um número aleatório entre 0 e o argumento. Deve ser utilizado em
conjunto com “Ramdomize”
Exemplo de uso: i := ramdom(256); { i vai conter um valor valor
aleatorio entre 0 e 256 }
Procedimento: Ramdomize;
Significado: Inicializa um gerador de números aleatórios, baseado no relógio do
computador.
Exemplo de uso: Randomize;
repeat
{ vai ficar mostrando números }
i:=Random(256); { [0..256] até que seja
}
Write(i,' ');
{ pressionada uma tecla }
until KeyPressed;
Procedimento: Readkey
Significado: Provoca uma parada no processamento até que uma tecla seja pressionada
Exemplo de uso: write(‘Resultados obrtidos’);
readkey;
Comando: exit
Significado: Aborta o processamento do laço atual
Exemplo de uso: cont := 0;
repeat
read(cod);
cont := cont + 1;
if cod = 0 then
exit; { Mesmo que cont não seja igual a 100}
{ o laço tera sua execucao finalizada}
until cont = 100;
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
67
Procedimento: textcolor(cor : integer);
Significado: Altera a cor da letra de todas as escritas na tela. Usa uma tabela fixa de
cores. É recomendada após sua utilização retornar a cor padrão (branco).
Exemplo de uso: textcolor(4); { vermelho }
write(‘escrevendo em vermelho`);
textcolor(2); { verde }
write(‘escrevendo em verde’);
textcolor(15); {voltando a cor branca}
Procedimento: textbackground(cor : integer);
Significado: Altera a cor do fundo de todas as escritas na tela. Usa uma tabela fixa de
cores. É recomendada após sua utilização retornar a cor padrão (preto).
Exemplo de uso: textbackground(7);
write(‘fundo cinza`);
textbackground(14);
write(‘fundo amarelo’);
textbackground(0); {voltando ao fundo preto}
Tabela de Cores
Número
0
1
2
3
4
5
6
7
Cor
Preto
Azul
Verde
Cyano
Vermelho
Lilás
Margenta
Cinza Claro
Número
8
9
10
11
12
13
14
15
Cor
Cinza Escuro
Azul claro
Verde claro
Cyano claro
Vermelho claro
Lilás claro
Amarelo
Branco
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal
68
13 Bibliografia
FIALHO, Lúcio. Guia Rápido Turbo Pascal 6.0, Rio de Janeiro, Editora Ciência Moderna Ltda.
GOTTFRIRED, Byron. Programação em Pascal. Portugla: McGraw-Hill de Portugal, lda, 1988.
HERGET, Douglas. Dominado Turbo Pascal 5. Rio de Janeiro, Editora Ciência Moderna Ltda., 1989
LEITE, Dennis Cintra, PRATES, Rubens. Cartão de referência Turbo Pascal versão 5.0.
MANZANO, José Augusto N. G., FIGUEIREDO, Jayr. Algoritmos. São Paulo: Érica, 1997.
ORTH, Afonso Inácio. Algoritmos Ciência dos Computadores, 1985.
O’BRIEN, Sthephen K. Turbo Pascal 6: completo e total. São Paulo: Makron, McGraw-Hill, 1992.
PRATT, Terrence W. Programming languagens. Englewood Cliffs, Prentice-Hall Internacional, 1984.
SEBESTA, Robert W. Concept of programming languages. Menlo Park, Addison-Wesley Publishing
Company, 1996.
SILVA, José Carlos G. da & ASSIS, Fitelis Sigmaringa G. de. Linguagem de programação: conceitos e
avaliação: FORTRAN, C, Pascal, Modula-2, Ada, Chill. São Paulo, Mc-Graw Hill, 1988.
Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal