notas de aula - campus camboriúfrozza/2011.1/ix10/programacao_i-pascal.pdf · 4 notas de aula:...

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

Notas de aula: Prof. Marcelo Trindade Rebonatto – Linguagem Pascal

Sumário 1 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

2 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

3 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

4 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

5 Programas seqüenciais ___________________________________________________________ 18 5.1 Exercícios de programas seqüenciais no Turbo Pascal_________________________________ 18

6 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

7 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

3


8 Técnicas avançadas de programação ________________________________________________ 35 8.1 Definição de Constantes ________________________________________________________ 35 8.2 Variáveis locais e variáveis globais _______________________________________________ 35 8.3 Passagem de Parâmetros ________________________________________________________ 37 8.4 Funções _____________________________________________________________________ 38 8.5 Exercícios com funções e passagem de parâmetros ___________________________________ 40

9 Tipo de dados orientados a caracteres________________________________________________ 41 9.1 Caracter _____________________________________________________________________ 41 9.2 Tipo de dados “Char” __________________________________________________________ 41 9.3 Tipo de dados “String” _________________________________________________________ 42 9.4 Exercícios de manipulação de “strings” ____________________________________________ 43

10 Novos tipos de dados ____________________________________________________________ 44 10.1 Conjunto de Dados de mesmo tipo (array) __________________________________________ 44

10.1.1 Manipulação de conjuntos de dados de mesmo tipo_______________________________ 44 10.1.2 Vetores _________________________________________________________________ 45 10.1.3 Exercícios de programas com manipulação de vetores ____________________________ 47 10.1.4 Matrizes_________________________________________________________________ 49 10.1.5 Exercícios de programas com manipulação de matrizes ___________________________ 51

10.2 Conjuntos de dados de tipos diferentes_____________________________________________ 53 10.2.1 Exercícios de programas com manipulação de registros ___________________________ 55

11 Arquivos ______________________________________________________________________ 56 11.1 Exercício com manipulação de arquivos ___________________________________________ 62

12 Glossário de Funções do Pascal ____________________________________________________ 63 12.1 Funções matemáticas __________________________________________________________ 63 12.2 Funções para uso com tipos caracter_______________________________________________ 64 12.3 Funções/procedimentos e comandos de propósito geral________________________________ 66

13 Bibliografia ____________________________________________________________________ 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. 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).

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

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

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

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.

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

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

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

Área de Identificação

Área de definições de variáveis

Área dos procedimentos e Funções

Área do programa Principal

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 : integer; salario : real; folgou_feriado : boolean; dias_trabalhados : integer; <nome>, <nome> : <tipo de variável> ; ......, ...... : ..................

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

ví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-e-

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

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 }

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.

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 Intervalo de Valores Tamanho em Bytes Byte 0 .. 255 1 Shortint -128 .. 127 1 Integer -32768 .. 32767 2 Word 0 .. 65535 2 Longint -2147483648 .. 2147483647 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 Intervalo de Valores Dígitos significativos Tamanho em Bytes Single 1.5*10-45 .. 3.4*1038 7-8 4 Real 2.9*10-39 .. 1.7*1038 11-12 6 Double 5.0*10-324 .. 1.7*10308 15-16 8 Comp -263 +1.. 2*63 +1 19-20 8 Extended 3.4*10-4932 .. 1.1*104932 19-20 10 3.2.3 Tipos de dados lógicos: Boolean

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;

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.

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;

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.

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 }

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 }

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

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 = C) - (S * B) - (S * A) - (S * S 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.

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.

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 Exemplo Falso = Igual 5 = 5

>= Maior ou Igual 8 >= 2 <= Menor ou Igual 9 <= 9 > Maior 0 > -8 < Menor 2 < 20

<> Diferente 6 <> 7 In Dentro de um Intervalo 5 in [1..10]

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

22


Para criarmos uma condição composta, devemos usar os operadores lógicos, que estão descritos na tabela abaixo.

Operador Lógico Significado Exemplo Verdadeiro Exemplo Falso

and e (produto lógico) (5 = 5) and (5 < 10) or ou (soma lógica) (8 > 2) or (0 > -8) not não (negação) not (6 < 2)

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 P2 Not (P1) Not (P2) (P1) and (P2) (P1) or (P2)

True True False False True True True False False True False True False True True False False True False False True True False 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

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 if media > 5 then begin gotoxy(10,10); write('O aluno foi APROVADO'); gotoxy(10,12); write('Sua média foi de ',media:4:2); end;

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

Início do bloco de comandos

Fim do bloco de comandos

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

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 { Não precisa de parênteses } write(a); if (a >= b) and (b <> 0) then {Necessita obrigatoriamente } write(b); { 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 if media > 7 then begin gotoxy(10,10); write('O aluno foi APROVADO'); end;

Não pode ser colocado o ;

Ifs aninhados

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, avalia-se 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;

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: “São múltiplos”

ou “Não 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.

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 Média (Ma)

A >= 9.0 B >= 7.5 e < 9.0 C >= 6.0 e < 7.5 D >= 4.0 e < 6.0 E < 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 Tipo de triângulo Todos os valores iguais Triângulo Equilátero Dois valores iguais (Quaisquer) Triângulo Isóceles a2 = b2 +c2 Triângulo Retângulo a2 > b2 +c2 Triângulo Obtusângulo a2 < b2 +c2 Triângulo Acutângulo

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

29

Notas de aula: Prof. Marcelo Trindade R

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

procedure leitura; begin for i := 1 to 10 do begin 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;

A variável de controle de laço(1) unidade. Em Pascal, não é possívedeve ser do tipo numérico inteiro, como

Este comando também é conincrementado até alcançar o seu valor fi

Também faz parte do laço cominicial maior do que o valor final, chammaneira que o contador progressivo, decrementada (diminuída) de uma unida

Regra geral

for <variavel> := <valor fi Bloco de Comandos
Valor inicial
e

, l, jhen

admd

n
Valor final
bonatto – Linguagem Pascal

: ');

no caso anterior a variável “i”, é sempre incrementada de uma incrementá-la com mais de uma unidade. Por ser um contador á foi visto. cido como laço com contador progressivo, pois o contador é

al (que obviamente é maior do que o valor inicial). contador um tipo de laço que o contador começa com um valor o de “contador regressivo”. Neste caso, a ação ocorre da mesma as ao invés de incrementar em uma unidade, a variável é

e a cada passagem.

al> downto <valor inicial> do

Variável de controle

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:

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; 7.4 Laço com teste no início

Regra geral while <condição> do comando / bloco de comandos;

Inicio do programa principal

Fim do programa principal

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 .

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 Quadrado Cubo Raiz 5 25 125 2,2361 4 16 64 2 8 64 512 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.

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.

Saldo anterior Juros Saldo Atual 1o mês 1800.00 27 1827.00 2o mês 1827.00 27,40 1854,40 3o mês 1854.40 27,81 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 Quantidade Valor 100 Cachorro Quente 1 2,50 103 X Especial c/ bacon 3 9,90 104 Refrigerante 4 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).

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;

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 }

{ exemplo usado no programa para calculo da empresa Y }

Const const Comiss1 := 3; comiss1 := 4; Comiss2 := 5; 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.

Marca o início da área de declaração de Constantes

Marca o fim da área de declaração de Constantes

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;

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; { procedimentos } a : integer Proc1 b : integer; c : real; a : integer; Proc2 x : integer; d : char;

Variáveis globais, existem em todas as partes do programa

Variáveis locais, só existem dentro do procedimento calcula

Variáveis locais distintas

Variáveis local e global com o mesmo nome. Dentro de “proc2” vale a local.

Valem em todo o programa.

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;

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

Definição dos parâmentros do procedimento

Definição dos parâmetros

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; if p_b > maior then maior := p_b; if p_c > maior then maior := p_c; calcula := maior; end;

Indicação que esta é uma função

Tipo de valor que esta função retorna

Implementação do retorno da função.

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

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)

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.

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 a s s o F u n d o ' posições -> 1 2 3 4 5 6 7 8 9 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”.

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.

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

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 3 -9 7 88 65 0 7 12 15 posições -> 1 2 3 4 5 6 7 8 9 10

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;

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 to 10 do begin if a[i] < 0 then b[i] := a[i] * i else begin b[i] := a[j]; j := j + 1; end; end;

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.

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

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

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 4 5 1 4 15 6 -7 28 2 4 7 2 6 33 3 6 9 0 4 4

m =

4 -38 23 -1 41 -9 5 -78 36 0 6 -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 1 2 3 4 5 1 [1,1] [1,2] [1,3] [1,4] [1,5] 2 [2,1] [2,2] [2,3] [2,4] [2,5] 3 [3,1] [3,2] [3,3] [3,4] [3,5]

Índices de uma matriz quadrada

de ordem 5 4 [4,1] [4,2] [4,3] [4,4] [4,5] 5 [5,1] [5,2] [5,3] [5,4] [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.

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.

51


Regra geral i ↓ j → 1 2 3 4 5 1 DP SUP SUP SUP DS SUP 2 INF DP SUP DS SUP SUP 3 INF INF DP DS SUP SUP 4 INF DS INF INF DP SUP 5 DS INF INF INF INF DP Significado Fórmula DP : Diagonal principal i = j DS : Diagonal Secundária i + j = n* + 1 SUP : Superior a DP i < j INF : Inferior a DP 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.

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

53


10.2 Conjuntos de dados de tipos diferentes

Regra geral type <nome_de _tipo> = record identificador_de_campo1 : tipo; identificador_de_campo2 : tipo; identificador_de_campo3 : tipo; . . . identificador_de_campon : tipo; end; { Final da declaracao 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]".

54


Exemplo type data = record dia : integer; mes : integer; ano : integer; end; var hoje : data; amanha, ontem : 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.

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); write(amigos[i].nome); gotoxy(30,lin); write(amigos[i].idade); gotoxy(35,lin); write(amigos[i].altura:2:2); gotoxy(55,lin); write(amigos[i].peso:4:2); lin := lin + 1; end;

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

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;

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

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

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;

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;

61


procedure escolhe_opcao; begin gotoxy(10,03); write('[1] Insere dados'); gotoxy(10,04); write('[2] Busca dados'); gotoxy(10,05); write('[3] Mostra todo o arquivo'); gotoxy(10,06); write('[0] Encerra o programa'); gotoxy(10,07); write('Informe a sua opção: '); read(opcao); end; 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.

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.

128) Montar um programa que processe o arquivo ´PESSOAS.DAT´ e mostra a média de altura e de peso

de seus amigos.

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;

131) Montar um programa que leia o arquivo ´MATRIZ.DAT´. Passar o seu conteúdo para uma matriz M[10,5]. Mostrar a matriz gerada.

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) Soma das linhas pares (apenas 1 soma) b) Soma das colunas ímpares (apenas 1 soma) c) Soma da diagonal principal d) Soma da diagonal secundária e) Soma 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.

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

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: abs(x : qualquertipo) : mesmotipo;

Significado: Retorna o valor (módulo) absoluto de um número (real ou inteiro) Na matemática : x = | x |

Exemplo de uso : 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: int(x : real) : real ;

Significado: Retorna a parte inteira de um número real Na matemática : x = int( x )

Exemplo de uso : x := 9.8; y := -8; x := int(x); { x passa a valer 9 } y := int(y); { y passa a valer -8 }

Função: frac(x : real) : real ;

Significado: Retorna a parte fracionária de um número real Na matemática : x = frac( x )

Exemplo de uso : 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 :

Exemplo de uso : x := 5; y := 2; 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 :

Exemplo de uso : x := 5; y := 4; if odd(x) then { retorna TRUE } if odd(y) then { retorna FALSE }

64


Função: sqr(x : qualquertipo) : mesmotipo; Significado: Retorna o quadrado de um número.

Na matemática : x = x2 Exemplo de uso : 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

Exemplo de uso : x := 81; y := 96; 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 +)

Exemplo de uso: x:= 'Passo'; y := ' '; z := 'Fundo'; 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' }

65


Função: length(s : string) : integer; Significado: Retorna o tamanho de um string (quantos caracteres ela possui)

Exemplo de uso: x := 'Passo Fundo'; y := ''; z := 'a'; 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) : byte;

Significado: Retorna a posição da primeira ocorrência da substr na StrPrincipal.

Exemplo de uso: x := 'Passo Fundo'; y := 'F'; i := pos('o',x); { i passa a valer 5 } j := pos(y,x); { j passa a valer 7 } k := pos('f',x); { k passa a valer 0, a substr não se encontra na StrPrincipal }

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

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. Exemplo de uso: r: 9.8; q:= 1;

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;

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 Cor Número Cor 0 Preto 8 Cinza Escuro 1 Azul 9 Azul claro 2 Verde 10 Verde claro 3 Cyano 11 Cyano claro 4 Vermelho 12 Vermelho claro 5 Lilás 13 Lilás claro 6 Margenta 14 Amarelo 7 Cinza Claro 15 Branco

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 - campus camboriúfrozza/2011.1/ix10/programacao_i-pascal.pdf · 4 notas de aula:...

Documents