EEL170 COMPUTAÇÃO I ac/eel170.htm Antonio Cláudio Gómez de Sousa [email protected] 2a série de slides Versão 19/03/2012

EEL170 COMPUTAÇÃO I www.del.ufrj.br/~ac/eel170.htm

Antonio Cláudio Gómez de [email protected]

2a série de slidesVersão 19/03/2012

mailto:[email protected]

2

Programação Estruturada

Utiliza somente as estruturas de controle: Sequencial Iterativa Condicional

3

Pascal

Linguagem de programação: Estruturada De alto nível Fortemente tipificada Permite modularização Refinamento etapa por etapa Escopo de variáveis global e local Alocação estática e dinâmica de memória Orientação a objetos

4

Estrutura de um programa em Pascal

program <identificador>; uses <lista de identificadores de units>; // declarações de utilização de bibliotecas const //declarações para definição de constantes <identificador> = <valor>; // exemplo de declaração de constante type //declarações de tipos <identificador> = <declaração de tipo>; // exemplo de declaração de tipo var //declarações de variáveis <identificador> : <tipo>; // exemplo de declaração de variável procedure <identificador> (<parâmetros>); // declarações de procedimentos function <identificador> (<parâmetros>) :tipo; // declarações de funções begin <comandos>; // comandos do módulo principal end.

5

Principais comandos em Pascal: Atribuição // <identificador> <expressão algébrica>; if <condição> then

<comando> [else <comando>];

case <seletor> of <valor do seletor>>: <comando>; ...

end repeat

<comandos>; until <condição>; while <condição> do

<comando>; for <identificador> := <valor> to | downto <valor> do

<comando>; comandos de entrada e saida

6

Regras para uma programação com qualidade

Colocar um comentário no início dos programas com seu objetivo, responsável e data

Colocar um comentário no início de cada módulo com sua finalidade e separar visualmente os módulos

Comentar Dentear/identar os comandos controlados por repita, para, enquanto,

caso, se-então-senão Utilizar identificador que lembre a semântica do conteúdo da variável ou

finalidade do procedimento – estética Java: identificador em minúsculas e maiúsculas só no início das palavras que o compõem, a partir da segunda palavra

Exemplos: dataDia, somaNotas, totalAlturasHomens Não alterar uma variável controlada por for dentro da iteração Usar for quando o escopo da variável de controle é conhecido Não usar variáveis booleanas desnecessárias

7

Modularização

Dividir para vencer Para resolver programas complexos

Separá-los em programas menores - módulos ou subprogramas

Algoritmos subalgoritmos ou módulos Subalgoritmo

Módulo projetado para executar uma tarefa específica

Partes de algoritmos que se repetem: Colocados em um módulo e chamados quantas vezes for

necessário de diferentes partes

8

Algoritmo complexo - método de refinamento etapa por etapa

• Desenvolver o algoritmo em alto nível de abstração criando subalgoritmos para resolver problemas específicos

• Cada subalgoritmo pode ser separado em outros subalgoritmos em níveis de abstração mais baixos

• Parar quando chegar a subalgoritmos com baixa complexidade

• Subalgoritmos módulos• Cada módulo pode ser programado e testado

de forma independente

Exemplo – ordenar tres variáveis

Ordenar tres variáveis utilizando um módulo que ordena duas variáveis:

InícioLer as variáveis a, b, cOrdena a b // módulo devolve ab ordenadoOrdena b c // módulo devolve ab ordenadoOrdena a b // módulo devolve ab ordenadoApresentar as variáveis a, b, cfim

Diagrama de estrutura

Módulo principal

ordena

Passa dois valores Retornam dois valores

Algoritmo simplificadoInicio // módulo principal

Leia a,b,c

Ordena a,b // passa a,b e recebe ordenados

Ordena b,c // passa b,c e recebe ordenados

Ordena a,b // passa a,b e recebe ordenados

Escreva a,b,c

Fim // módulo principal

// --------------------------------------------------------------------------------------------

Ordena x,y // módulo ordena

Inicio

Se a> b então

inicio

Aux a

A b

B aux

fim

Fim // módulo ordena

Algoritmo simplesInicio // módulo principal com tres variáveis globais

Leia a,b,c

Ordena a,b // passa a,b e recebe ordenados – parâmetros atuais ou reais

Ordena b,c // passa b,c e recebe ordenados – parâmetros atuais ou reais

Ordena a,b // passa a,b e recebe ordenados – parâmetros atuais ou reais

Escreva a,b,c

Fim // módulo principal

// --------------------------------------------------------------------------------------------

Ordena x,y // módulo ordena com dois partâmetros formais e uma variável local

Inicio

Se a> b então

inicio

Aux a

A b

B aux

fim

Fim // módulo ordena

• A modularização do programa pode ser feita através de procedimentos ou funções

• Os procedimentos ou funções são módulos, ou sub-programas, que programamos e podem ser “chamados” de vários pontos do algoritmo

• Procedimentos: podem receber e devolver vários parâmetros

• Funções: podem receber vários parâmetros mas devolvem um valor - como uma função matemática – tem tipo

14

Procedimento

• Quando chamamos um procedimento podemos passar dados para o procedimento e receber dados do procedimento, através de parâmetros que são passados entre o módulo chamador e o módulo chamado

• Exemplo: vamos fazer um algoritmo que permite digitar dois valores e calcular sua média

• A média será calculada em um procedimento que definimos no algoritmo

• Um módulo do algoritmo deverá passar os dois valores para o procedimento e o parâmetro para o resultado, e o procedimento devolverá a média calculada no parâmetro do resultado.

15

algoritmo calcularMédia

(*algoritmo para calcular a média de dois pares de dados com um procedimento*)

Var

dado1, dado2, dado3, dado4, media: real // variáveis globais

// definição do procedimento

procedimento calcMed(x,y:real; var med:real)

// x,y passagem por valor – med passagem por referência

inicio

med (x + y)/2 // o retorno é pelo parâmetro passado por referência

fim

inicio // início do módulo principal

leia (dado1,dado2); // orientar e validar

calcMed(dado1,dado2,media) // chamada do procedimento

escreva(‘A média é ‘,media)

Leia (dado3, dado4); // orientar e validar

calcMed(dado3,dado4,media) // chamada do procedimento


fim

16

Estrutura modular

A estrutura modular do algoritmo apresenta o módulo principal, o procedimento e duas setas indicando que há parâmetros nos dois sentidos

calcularMedia

calcMed

x,y,med med

Med: Passagem por referênciax,y: Passagem por valor

17

Função

• Quando chamamos uma função podemos passar dados para a função por meio dos parâmetros, e receber o resultado calculado pela função

• Exemplo: vamos fazer um algoritmo que permite digitar dois valores e calcular sua média

• A média será calculada em uma função que definimos no algoritmo

• Um módulo do algoritmo deverá passar os dois valores para a função, e a função devolverá a média calculada.

18

algoritmo calcularMédia

(*algoritmo para calcular a média de dois pares de dados com uma função*)

Var

dado1, dado2, dado3, dado4, media: real

// definição da função

função calcMed(x,y:real):real // a função tem tipo

inicio

calcMed (x + y)/2

fim

inicio // início do módulo principal


media calcMed(dado1,dado2) // chamada da função



escreva(‘A média é ‘, calcMed(dado3,dado4) // chamada da função

fim

19

Estrutura modular

A estrutura modular do algoritmo apresenta o módulo principal, o procedimento e duas setas indicando que há parâmetros nos dois sentidos

calcularMedia

calcMed

x,y CalcMed

20

Algoritmos

Estruturas de dados

21

Estrutura de dados homogênea

Problema: Após ler as notas dos alunos de uma turma (uma nota por aluno), calcular a média e quantos alunos ficaram com nota acima da média.

Este problema tem uma dificuldade: em uma primeira etapa digita-se as notas de todos os alunos; em uma segunda etapa calcula-se a média, e só então em uma terceira etapa pode-se comparar a média com a nota de cada aluno, para verificar quantos ficaram com a nota acima da média. Isso exige redigitar todas as notas da primeira etapa ou guardar todas as notas de maneira que se possa recuperá-las. A segunda possibilidade é a melhor.

22

Estrutura de dados homogênea

No ensino médio foi vista uma estrutura de dados que permite guardar vários valores de uma variável: a matriz.

Matriz: estrutura de dados homogênea - permite múltiplos valores de um mesmo tipo, por isso é dita homogênea.

Exemplo: uma matriz com números inteiros – em cada elemento da matriz podemos ter um número inteiro.

Dimensão: a matriz pode ter uma, duas três ou n dimensões.

Para acessar um elemento da matriz temos de saber quantas dimensões ela tem, e o índice para cada dimensão.

23

Elementos de uma matriz com uma dimensão com 5 elementos – um índice

Matriz a

[ a1 a2 a3 a4 a5 ]

24

Matriz em linguagens de computação

As linguagens de computação geralmente tem uma estrutura de matrizes, ou comandos que permitem manipular dados como matrizes.

Uma matriz de uma dimensão também é chamada de vetor

Como se define uma matriz em LEA: <identificador>: matriz [<dimensão1>,...,<dimensãon>]: <tipo>

<dimensão> := <valor inicial>,<valor final>

Exemplo: notas: matriz [1..45] de real; Matriz de uma dimensão com 45 elementos reais.

Exemplo: temperaturas: matriz [1..31, 1..24] de real; Matriz com duas dimensões com 31 e 24 elementos respectivamente nas dimensões

25

Sintaxe das matrizes em Pascal

<identificador> : array [<dimensão1>,...,<dimensãon>]: <tipo>

<dimensão> := <valor inicial>,<valor final> Exemplo: notas: array [1..45] of real;

Matriz de uma dimensão com 45 elementos reais.

Exemplo: temperaturas: array [1..31, 1..24] of real; Matriz com duas dimensões com 31 e 24 elementos respectivamente nas

dimensões.

26

Voltando ao nosso problema

Problema: Após ler as notas dos alunos de uma turma (uma nota por aluno), calcular a média e quantos alunos ficaram com nota acima da média.

Solução: Fazer um programa que permita informar as notas, guardando-as em uma matriz, calcular a média e depois comparar essa média com cada nota, contando as que estão acima da média.

Algoritmo: algoritmo mediaAcima; (* algoritmo para calcular a média das notas de alunos

e quantos estão acima da média; responsável:...; data:...*)

27

var

notas: matriz [1..45] de real

inicio

somaNotas, notasAcima 0

para aluno variando de 1 a 45 faça

inicio

escreva (‘Informe a nota do aluno ‘, aluno)

leia (notaAluno) (* testar *)

notas [aluno] notaAluno

somaNotas somaNotas + notaAluno

fim

mediaNotas somaNotas / 45

para aluno variando de 1 a 45 faça

inicio

se notas [aluno] > mediaNotas então

notasAcima notasAcima + 1

fim

escreva (‘A média dos alunos é ‘,mediaNotas, ‘ e há ‘, notasAcima, ‘alunos com nota acima da média’)

fim.

28

Programa em Pascal

program mediaAcima; (* programa para calcular a média das notas de

alunos e quantos estão acima da média; responsável:...; data:...*)

29

var

notas: array [1..45] of real;

somaNotas, notaAluno, mediaNotas: real;

aluno, notasAcima: integer;

begin

somaNotas := 0; // iniciar somatório

notasAcima := 0; // iniciar somatório

for aluno := 1 to 45 do // para controlar a entrada de dados de 45 alunos

begin

writeln (‘Informe a nota do aluno ‘, aluno:2);

readln (notaAluno);

notas [aluno] := notaAluno;

somaNotas := somaNotas + notaAluno;

end;

mediaNotas := somaNotas / 45;

for aluno := 1 to 45 do // para comparar a nota de cada aluno com a média geral

if notas [aluno] > mediaNotas then

notasAcima := notasAcima + 1;

writeln (‘A média dos alunos é ‘,mediaNotas:4:1, ‘ e há ‘, notasAcima:2, ‘alunos com nota acima da média’);

end.

30

Ordenar elementos em uma estrutura linear

Problema: Ordenar nomes em uma matriz. Solução: Fazer um programa que permita

digitar 10 nomes, ordená-los e apresentar os nomes desordenados e ordenados.

Algoritmo: Algoritmo ordenaNomes (* algoritmo para ordenar nomes em uma lista

linear; responsável: ...; data: ...*)

31

Var

nomeInicial, nomeOrdenado: matriz[1..10] de literal

Inicio

para indice variando de 1 a 10 faça

inicio

escreva(‘Informe o nome ‘,índice)

leia (nomeInicial[índice]) (* testar *)

fim

// copiar os dados para a estrutura que será ordenada

para índice variando de 1 a 10 faça

nomeOrdenado[índice] nomeInicial[índice]

32

(* algoritmo do bubble sort *)

para contador variando de 9 a 1 faça

inicio

para indice variando de 1 a contador faça

inicio

se nomeOrdenado[indice] > nomeOrdenado[indice+1] então

inícioauxiliar nomeOrdenado[índice]nomeOrdenado[índice] nomeOrdenado[índice+1]nomeOrdenado[índice+1] auxilir

fim

fim

fim

33

{ apresentar os dados não ordenados e ordenados}

escreva (‘Nomes antes da ordenação:’)


inicio

escreva(nomeInicial[índice]) // na mesma linha

fim

escreva (‘Nomes após a ordenação:’)


inicio

escreva(nomeOrdenado[índice]) // na mesma linha

fim

fim

34

Calcular o determinante de uma matriz 3x3

Problema: calcular o determinante de uma matriz 3x3.

Solução: fazer um programa que: Permita digitar os dados de uma matriz 3x3; Calcule seu determinante; usar uma matriz 5x3

para repetir as linhas 1 e 2 em 4 e 5 e facilitar o cálculo do determinante;

Apresente a matriz em sua forma matricial; Apresente o valor de seu determinante.

Algoritmo:

35

algoritmo determinante3x3

(* algoritmo para o cálculo do determinante de uma matriz 3x3; responsável:...; data:...*)

var

dados: matriz[1..5,1..3] de real

Inicio

para linha variando de 1 a 3 faça // entrada de dadosinicio

para coluna variando de 1 a 3 faça // entrada dadosinicio

escreva (‘Informe o valor do elemento ‘,linha,’, ‘,coluna)

leia (dados[linha,coluna])

Fim

fim

36

// cálculo do determinante

// copiar as linhas 1 e 2 para as linhas 4 e 5

para linha variando de 1 a 2 faça

iniciopara coluna variando de 1 a 3 faça

iniciodados[linha+3,coluna] dados [linha,coluna]

fim

fim

//cálculo do determinante

determinante 0

para indice variando de 1 a 3 façainicio

determinante determinante + dados[indice+0,1]*dados[indice+1,2]*

dados[indice+2,3]

determinante determinante -dados[indice+0,3]*dados[indice+1,2]*

dados[indice+2,1]

fim

38

// apresentar a matriz em forma matricial

escreva(‘a matriz é:’)

para linha variando de 1 a 3 faça

inicio

para coluna variando de 1 a 3 faça

inicio

escreva( dados[linha,coluna])

fim

pule uma linha

fim

escreva(‘O determinante da matriz vale ’, determinante)

fim

39

Estrutura de dados heterogênea

Problema: manter os dados de uma DVDteca domiciliar. Para cada CD manter: Título Intérprete Autor Duração em minutos

Estes dados são heterogêneos Necessitamos de novo tipo de estrutura de

dados

40

Estrutura: variável heterogênea

A estrutura permite definir dados heterogêneos em uma variável estruturada, através da composição da variável

Exemplo de variável heterogênea: Var Dvd: estrutura título: literal // início da definição .......................intérprete: literal .......................autor: literal .......................duração:real .......................fim // término da definição

41

Como acessar cada elemento de uma variável heterogênea

Cada elemento de uma variável heterogênea é acessado pelo identificador da variável seguido de ponto (.) e do identificador do elemento

Exemplo: leia (dvd.titulo) escreva (dvd.titulo)

42

Guardar os dados em uma variável estruturada

algoritmo dvdTeca1

(* algoritmo para ler e guardar os dados de um dvd; responsável:... ; data:... *)

Var

dvd: estrutura título: literal // início da definição

.......................intérprete: literal

.......................autor: literal

.......................duração:real

.......................fim // término da definição do registro

Inicio

leia (dvd.titulo, dvd.interprete, dvd.autor, dvd.duração) // orientar testar

escreva (dvd.titulo, dvd.interprete, dvd.autor, dvd.duração)

fim

43

Retornando ao problema da DVDTeca

A solução não resolve o problema: permite armazenar os dados apenas de um DVD

Para armazenar os dados de vários DVDs a solução será utilizar uma matriz unidimensional de estruturas

Em cada posição da matriz haverá uma estrutura com seus elementos constitutivos

44

Algoritmo dvdTeca2

(* algoritmo para manter os dados de dez DVDs; responsável: ... ; data: ... *)

Tipo // declaração de tipos de variáveis

tRegDvd = estrutura título: literal

............................ ....intérprete: literal

............................ ....autor: literal

............................ ....duração:real

............................. ...fim

Var // declaração das variáveis estruturadas

dvd: matriz[1..10] de tRegDvd

45

Inicio


Início

escreva(‘Informe o título, intérprete, autor e duração do DVD ‘,índice)

Leia(dvd[índice].título, dvd[índice].intérprete, dvd[índice].autor, dvd[índice].duração) (* testar *)

fim

// apresentação dos dados

para índice variando de 1 a 10 façaescreva(dvd[índice].título, dvd[índice].intérprete, dvd[índice].autor,

dvd[índice].duração)

fim

46

Menu

O algoritmo anterior não dá flexibilidade ao usuário. Muitas vezes é necessário oferecer opções, e o usuário escolher a cada momento a opção mais adequada.

47

DVDteca com menu

Problema: para o problema anterior, oferecer ao usuário as opções: Incluir um DVD Listar todos os DVDs Consultar um DVD pelo título

Solução: fazer um programa que permita ao usuário, de forma interativa, escolher uma das opções até que o usuário escolha sair do programa.

48

Algoritmo dvdTeca3

(* algoritmo para incluir, listar e consultar os dados de dvd; responsável:... ; data:... *)

Tipo // declaração de tipos de variáveis

tRegDvd = estrutura título: literal

.................................intérprete: literal

.................................autor: literal

.................................duração:real

.................................fim

Var // declaração das variáveis estruturadas

dvd: matriz[1..10] de tRegDvd

49

Inicio

// preparar - para iniciar a primeira posição livre

primeiraPosLivre 1

repita // apresentação do menu

escreva(‘digite 1 para incluir os dados de um DVD’)

escreva(‘digite 2 para listar os dados de todos os DVDs’)

escreva(‘digite 3 para consultar os dados de um DVD por seu título’)

escreva(‘digite 4 para sair do programa’)

leia opção

50

Caso opção seja

1: inicio // incluir um DVDescreva(‘Informe o título, intérprete, autor e duração do DVD ‘)

leia(dvd[primeiraPosLivre].título, dvd[primeiraPosLivre].intérprete, dvd[primeiraPosLivre].autor, dvd[primeiraPosLivre].duração) //testar

primeiraPosLivre primeiraPosLivre + 1

fim

2: inicio // listar todos os DVDspara índice variando de 1 a primeiraPosLivre - 1 faça

inicioescreva(dvd[índice].título, dvd[índice].intérprete, dvd[indice].autor, dvd[indice].duração)

fim

fim

51

3: inicio // para consultar um DVD escreva(‘Informe o título do DVD que procura’) leia(titu) Índice 1 enquanto (titu <> dvd[índice].titulo) e (indice < primeiraPosLivre) faça

Ínicio Índice Índice + 1 fim

se índice < primeiraPosLivre então

escreva(‘Os dados do DVD são: ‘, dvd[índice].título, dvd[índice].intérprete, dvd[índice].autor, dvd[índice].duração)

senão escreva(‘Não há DVD com esse título’)

Fim Fim // fim do caso do menu

até que opção = 4 fim

52

Estrutura de algoritmo com menu

Algoritmo ...

// prólogo

// declarações de constantes, tipos e variáveis

Início

// preparar

Repita

apresentar opções do menu

usuário escolhe uma opção

caso opcao seja

(<escalar>: <bloco de comandos>)*

fim // fim do caso

Ate que opcao tenha sido encerrar o menu

// parte final do algoritmo

fim

Modularização

• Exemplo com matrizes

54

Problema: Realizar operações com matrizes e apresentar os resultados na forma matricial

Solução: Fazer um programa que permita realizar operações com matrizes quadradas de 2X2 até 10X10, e ofereça interativamente as opções: 1 - Digitar os dados da primeira matriz 2 – Digitar os dados da segunda matriz 3 - Somar as matrizes 4 - Subtrair a segunda da primeira 5 - Multiplicar as matrizes 6 - Achar a transposta da primeira 7 – Sair do programa

55

algoritmo operaMatriz (* algoritmo para realizar operações sobre matrizes quadradas;

responsável:...; data:... *) tipo // declaração de tipos

– tipmat = matriz[1..10,1..10] de real var

mat1, mat2, matResult: tipmat inicio repita // escolha da quantidade de elementos

escreva (‘Informe a quantidade de elementos nas linhas e colunas – deve variar de 2 a 10’)

• leia (qtd)• se (qtd < 2) ou qtd > 10 então escreva (‘Valor fora do escopo – repita’)

até que (qtd >= 2) e (qtd <= 10)

56

Repita // início do menu

escreva (‘Digite 1 para informar os dados da primeira matriz’)

escreva (‘Digite 2 para informar os dados da segunda matriz’)

escreva (‘Digite 3 para somar as matrizes’)

escreva (‘Digite 4 para subtrair a segunda da primeira’)

escreva (‘Digite 5 para multiplicar as matrizes’)

escreva (‘Digite 6 para achar a transposta da primeira’)

escreva (‘Digite 7 para sair do programa’)

leia (opcao)

57

caso opcao seja // para testar as várias opções

1: início // para incluir os dados na 1a matriz

• para linha variando de 1 a qtd faça

– para coluna variando de 1 a qtd faça

• inicio

• (* orientar o usuário*)

• leia (mat1[linha,coluna])

• fim

• (* apresentar a mat1 em forma matricial *)

fim // fim do caso 1

2: início // para incluir os dados na 2a matriz

• para linha variando de 1 a qtd faça

– para coluna variando de 1 a qtd faça

• inicio

• (* orientar o usuário*)

• leia (mat2[linha,coluna])

• fim

• (* apresentar a mat2 em forma matricial *)


58

3: inicio // para somar as duas matrizes• para linha variando de 1 a qtd faça

– para coluna variando de 1 a qtd faça• matResult[linha,coluna]

mat1[linha,coluna] + mat2[linha,coluna]• (* apresentar matriz result *)

Fim // fim do caso 34: inicio // para subtrair a segunda da primeira• para linha variando de 1 a qtd faça

– para coluna variando de 1 a qtd faça• matResult[linha,coluna]

mat1[linha,coluna] - mat2[linha,coluna](* apresentar matriz result *)fim // fim do caso 4

59

5: início // para multiplicar as duas raízes

..................

..................

(* apresentar a matResult *)


6: início // para calcular a transposta da primeira

para linha variando de 1 a qtd façapara coluna variando de 1 a qtd faça

matResult[linha,coluna] mat1[coluna,linha](* apresentar a matResult *)


Fim // fim do caso

até que opcao = 7

fim // fim do algoritmo

60

Observações sobre o algoritmo

• As entradas de dados para a 1a e 2a matrizes são iguais, muda somente a matriz destino das informações: fazer um só procedimento para os dois casos

• Após cada caso deve-se apresentar a matriz resultante, que pode ser mat1, mat2 ou matresult, mas são procedimentos idênticos: fazer um só procedimento para todos os casos

• O algoritmo ficou muito longo, o que dificulta perceber sua lógica: quebrar o algoritmo em partes menores

61

Modularização do problema de operações com matrizes

• Um módulo principal que apresente a lógica geral do programa: esse módulo deve permitir que o usuário escolha a quantidade de elementos de cada dimensão, e a seguir deve permitir que o usuário escolha uma opção até que o usuário escolha sair do programa. Para cada escolha, o módulo principal chama um outro módulo que implementa a opção selecionada.

– Refinamento etapa por etapa

• Um módulo para a entrada de dados para as duas matrizes

• Um módulo para apresentar os dados das matrizes no formato matricial

62

Algoritmo operaMatriz

(* algoritmo modularizado para realizar operações sobre matrizes quadradas; responsável:...; data:... *)

tipo // declaração de tipos

• tipMat = matriz[1..10,1..10] de real

var

qtd: inteiro• mat1, mat2, matResult: tipMat

63

inicio

proQtd (qtd) (* escolher quantidade elementos *)

Repita

Opção proMenu (* função menu e escolha da opção *)Caso opcao seja

1: proDigDados (mat1, qtd)2: proDigDados (mat2, qtd)3: proSoSub (mat1, mat2, matResult, qtd, 1)4: proSoSub (mat1, mat2, matResult, qtd, -1)5: proMultiplicar (mat1, mat2, matResult, qtd)6: proTransposta (mat1,matResult, qtd)

Fimaté que opcao = 7

fim.

64

procedimento proQtd (var qt: inteiro)

(* procedimento para escolher a quantidade de elementos em cada dimensão da matriz *)

inicio

repita

– escreva (‘Informe a quantidade de elementos nas linhas e colunas – deve variar de 2 a 10’)

– leia (qt)– se (qt < 2) ou qt > 10– então escreva (‘Valor fora do escopo – repita’)

até que (qt >= 2) e (qt <= 10)

fim

65

função proMenu (): inteiro(* função para apresentar o menu e optar*)Var op: inteiroIniciorepita

escreva (‘Digite 1 para informar os dados da primeira matriz’)escreva (‘Digite 2 para informar os dados da segunda matriz’)escreva (‘Digite 3 para somar as matrizes’)escreva (‘Digite 4 para subtrair a segunda da primeira’)escreva (‘Digite 5 para multiplicar as matrizes’)escreva (‘Digite 6 para achar a transposta da primeira’)escreva (‘Digite 7 para sair do programa’)leia (op)Se (op < 1) ou (op > 7) então escreva(‘Opção inválida. Refaça’)

Até que (op >= 1) e (op <= 7)ProMenu ← opfim

66

procedimento proDigDados (var matDig: tipMat; qtDig: inteiro)

(* procedimento para digitar os dados *)varlin, col: inteiroiniciopara lin variando de 1 a qtDig faça

para col variando de 1 a qtDig faça(* orientar *)leia (matDig[lin,col])

proListarMat (matDig, qtDig)fim

67

procedimento proSoSub (mat1SS, mat2SS: tipMat; var matRSS:tipMat; qtdSS, sinal: inteiro)

(*procedimento para somar e subtrair matrizes *)

var

liSS, coSS: inteiro

inicio

para liSS variando de 1 a qtdSS façapara coSS variando de 1 a qtdSS faça

matRSS[liSS,coSS] mat1SS[liSS,coSS] + (sinal * mat2SS[liSS,coSS])

proListarMat (matRSS, qtdSS)

fim

68

procedimento proMultiplicar (mat1M, mat2M: tipMat; var matRM:tipMat; qtdM: inteiro)

(*procedimento para multiplicar matrizes *)varliM, coM, indice: inteiroiniciopara liM variando de 1 a qtdM faça

iniciopara coM variando de 1 a qtdM faça

inicioMatRM[liM,coM] 0

Para indice variando de 1 a qtdM façamatRM[liM,coM] matRM[liM,coM] + mat1M[liM,indice]

* mat2M[indice,coM])Fim

fim

proListarMat (matRM, qtdM)fim

69

procedimento proTransposta (matT: tipMat; var matR:tipMat; qtdT: inteiro)

(*procedimento para achar a transposta da 1a *)

var

liT, coT: inteiro

inicio

para liT variando de 1 a qtdT façapara coT variando de 1 a qtdT faça

matR[liT,coT] matT[coT,liT]

proListarMat (matRSS, qtdSS)

fim

70

procedimento proListar (matLis: tipMat; qtdLis: inteiro)

(*procedimento para listar a matriz em forma matricial *)

var

liLis, coLis: inteiro

inicio

para liLis variando de 1 a qtdLis faça

inicio

para coLis variando de 1 a qtdLis façaEscreva (matLis[liLis,coLis] (* Pule uma linha *)

fim

fim

71

opcao

operaMatriz

proQTD

proListarMat

proDigDados proSoSub proMultiplicar proTransposta

72

Tratamento de erro

As linguagens verificam a ocorrência de erros em tempo de execução, e executam suas rotinas de tratamento de erro.

Algumas linguagens permitem que o usuário desabilite a rotina padrão de tratamento de erro e faça sua própria rotina de tratamento de erro.

Ao terminar de executar um comando de entrada ou saída de dados, sempre é gerado um código de erro, que será zero se não houve erro, e diferente de zero se houve erro, e esse valor será o código de erro

73

Tratamento de erro padrão em E/S

Exemplo para comando de leitura de teclado: leia (variável) // pode ser mais de uma variável Rotina da linguagem verifica o que foi solicitado e habilita o teclado Usuário digita no teclado um valor e conclui a entrada de dados Rotina da linguagem verifica se o comando foi executado com êxito e se

o valor digitado é compatível com o tipo da variável, e atualiza uma variável com o resultado da execução do comando:

Se não houve erro ativa essa variável do para zero e coloca o valor digitado na variável definida no comando;

Se houve erro ativa essa variável para um valor maior que zero, que indicará o tipo de erro que ocorreu, e poderá colocar qualquer lixo na variável definida no comando ou não colocar nada.

Se houve erro, a rotina da linguagem chama uma rotina padrão de tratamento de erro, que poderá terminar a execução do programa abruptamente

74

Tratamento de erro programado

Se no programa há uma leitura para uma variável numérica e o usuário digita uma tecla não numérica, este erro poderá parar a execução do programa, fazendo o usuário perder todo seu trabalho até o momento.

Solução: o programador desabilita a rotina da linguagem de tratamento padrão de erro e faz uma rotina especial de tratamento de erro que avisa ao usuário de seu erro, e permite que ele refaça a digitação, sem interromper o programa.

75

Exemplo em Pascal program ... var numero: integer; ... begin ... repeat // repetir os comandos abaixo

writeln(‘Informe um valor numérico’); {$I-} // para desativar a rotina padrão de tratamento de erro readln(numero); {$I+} // para ativar a rotina padrão de tratamento de erro

until ioresult = 0 // até que o comando tenha sido executado sem erro

76

Rotinas padronizadas (proposta)

Toda vez em que há entrada de dados é necessário: Orientar o usuário do que deve ser feito Testar se houve erro de execução e neste caso

executar rotina apropriada de tratamento de erro Testar se os valores digitados estão dentro do

escopo dos valores permitidos Informar adequadamente no caso de erros Repetir a entrada de dados até que os dados

estejam corretos

77

Rotina para orientar, digitar e verificar variáveis inteiras

Este procedimento tem tres parâmetros passados por valor: MensInt: a mensagem para orientar o usuário MaxInt: o valor máximo permitido MinInt: o valor mínimo permitido

E um parâmetro passado por referência: ValInt para retornar o valor digitado

78

procedure digInt(mensInt: string; maxInt, minInt: integer; var valInt:integer);

(* procedimento para orientar o usuário, permitir que ele digite um valor inteiro, testar se houve erro e testar se o valor está dentro do escopo de valores aceitos para a variável; responsável: ...; data:...*)

var

erro: integer; // variável para o código de erro

79

begin

repeat

writeln (mensInt);

{$I-} // para desativar rotina padrão de tratamento de erro

readln (valInt);

{$I+} // para reativar a rotina padrão de tratamento de erro

erro := 1; // para fazer todos os testes

if ioresult <> 0

then writeln ('O valor digitado não é um inteiro. Digite novamente') else if (valInt > maxInt)

Then writeln(‘O valor digitado é maior que o valor máximo permitido. Digite novamente’)

Else if (valInt < minInt) Then writeln((‘O valor digitado é menor que o valor mínimo permitido. Digite

novamente’) Else erro := 0; // para aceitar o valor digitado após passar os testes

until erro = 0;

end.

80

Rotina para orientar, digitar e verificar variáveis reais

Este procedimento tem tres parâmetros passados por valor: MensReal: a mensagem para orientar o usuário MaxReal: o valor máximo permitido MinReal: o valor mínimo permitido

E um parâmetro passado por referência: ValReal para retornar o valor digitado

81

procedure digReal(mensReal: string; maxReal, minReal: real; var valReal:real);

(* procedimento para orientar o usuário, permitir que ele digite um valor real, testar se houve erro e testar se o valor está dentro do escopo de valores aceitos para a variável; responsável: ...; data:...*)

var erro: integer; // variável para o código de erro

82

begin

repeat

writeln (mensReal);


readln (valReal);



if ioresilt <> 0

then writeln ('O valor digitado não é um real. Digite novamente')

else if (valReal > maxReal) Then writeln(‘O valor digitado é maior que o maior valor permitido. Digite novamente’) Else if (valReal < MinReal)

Then writeln(‘O valor digitado é menor que o menor valor permitido. Digite novamente’) Else erro := 0; // para aceitar o valor digitado após passar os testes

until erro = 0; end.

83

Rotina para orientar, digitar e verificar variáveis string

Este procedimento tem tres parâmetros passados por valor: MensStr: a mensagem para orientar o usuário MaxStr: o comprimento máximo permitido MinStr: o comprimento mínimo permitido

E um parâmetro passado por referência: ValStr para retornar o valor digitado

84

procedure digStr(mensStr: string; maxStr, minStr: integer; var valStr:string); (* procedimento para orientar o usuário, permitir que ele digite um valor string e testar se o valor

está dentro do escopo de valores aceitos para a variável; responsável: ...; data:...*)

var

tamanho: integer; // para conter o comprimento da variável digitada

begin

repeat

writeln (mensStr);

readln (valStr);

tamanho := length (valStr);

if (tamanho > maxStr)

then writeln ('Valor com comprimento maior que o maior comprimento permitido. Digite novamente');

Else if (tamanho < minStr)

writeln ('Valor com comprimento menor que o menor comprimento permitido. Digite novamente');

until (tamanho <= maxStr) and (tamanho >= minStr); end.

85

Reutilização de código

Reutilização de código é utilizar um código já desenvolvido, evitando-se “reinventar a roda”. Procedimentos e funções podem ser copiados de

um programa para outro. Procedimentos e funções muito usados podem ser

guardados em uma biblioteca, já compilados. Para reutilizá-los basta em um programa informar, através de uma cláusula, a biblioteca que será utilizada. Todos os procedimentos e funções desta biblioteca estarão disponíveis para reutilização.

86

Unit Em Pascal as bibliotecas são definidas como units. A unit é um código Pascal que define procedimentos e

funções, ou mesmo declarações de constantes, tipos ou variáveis, que podem ser reutilizados.

A unit segue a sintaxe do Pascal. O compilador traduz a unit para um código binário não

executável. A unit é dividida em duas partes:

Interface: onde estão declarados os procedimentos e funções, assim como outras declarações, que podem ser acessados pelos programas que utilizam a unit;

Implementation: onde é colocado o código Pascal que implementa os procedimentos e funções declarados na interface; pode ter outras declarações internas à unit.

87

unit <identificador da unit>; (* prólogo com objetivo, responsável, data ... *) Interface

Declarações de incluir, const, type, var Declarações de procedimentos e funções:

Procedure <id do procedimento1> (<lista de parâmetros1>); Function <id da função2> (<lista parâmetros2): <tipo função>;

Implementation Declarações de incluir, const, type, var Código completo dos procedimentos e funções:

Procedure <id do procedimento1> (<lista de parâmetros1>); (* prólogo com objetivo, data, responsável, ...*) Declarações de , const, type, var, outros procedimentos ou funções Begin // início dos comandos

Comandos do procedimento End; ...

[ begin Código de execução inicial ]

end.

88

Exemplo de unit

Unit com os procedimentos padronizados vistos antes para a digitação de três tipos de dados

O nome da unit será digDados

89

Unit digDados; (* biblioteca com rotinas para orientar e validar

a digitação de três tipos de dados; responsável: fulano; data: 17/10/2008 *)

interface procedure digInt(mensInt: string; maxInt,

minInt: integer; var valInt:integer); procedure digReal(mensReal: string; maxReal,

minReal: real; var valReal:real); procedure digStr(mensStr: string; maxStr,

minStr: integer; var valStr:string);

90

implementation

procedure digInt(mensInt: string; maxInt, minInt: integer; var valInt:integer); (* procedimento para orientar e validar inteiro; responsável: ...; data:...*)

Var


begin

repeat

writeln (mensInt);


readln (valInt);



if ioresult <> 0

then writeln ('O valor digitado não é um inteiro. Digite novamente')

else if (valInt > maxInt)

Then writeln(‘O valor digitado é maior que o valor máximo permitido. Digite novamente’) Else if (valInt < minInt)

Then writeln((‘O valor digitado é menor que o valor mínimo permitido. Digite novamente’)

Else erro := 0; // para aceitar o valor digitado após passar os testes until erro = 0;

end;

91

procedure digReal(mensReal: string; maxReal, minReal: real; var valReal:real);

(* procedimento para orientar, validar, ...; responsável: ...; data:...*)

var


begin

repeat

writeln (mensReal);


readln (valReal);



if ioresult <> 0

then writeln ('O valor digitado não é um real. Digite novamente')

else if (valReal > maxReal)

Then writeln(‘O valor digitado é maior que o maior valor permitido. Digite novamente’) Else if (valReal < MinReal)

Then writeln(‘O valor digitado é menor que o menor valor permitido. Digite novamente’) Else erro := 0; // para aceitar o valor digitado após passar os testes

until erro = 0; end;

92

procedure digStr(mensStr: string; maxStr, minStr: integer; var valStr:string); (* procedimento para orientar... ; responsável: ...; data:...*)

var

tamanho: integer; // para conter o comprimento da variável digitada

begin

repeat

writeln (mensStr);

readln (valStr);

tamanho := length (valStr);

if (tamanho > maxStr)

then writeln ('Valor com comprimento maior que o maior comprimento permitido. Digite novamente');

Else if (tamanho < minStr)

Then writeln ('Valor com comprimento menor que o menor comprimento permitido. Digite novamente');

until (tamanho <= maxStr) and (tamanho >= minStr); end; end.

Documents

EEL170 COMPUTAÇÃO I ac/eel170.htm Antonio Cláudio Gómez de Sousa [email protected] 2a série de slides Versão 19/03/2012