EEL170 COMPUTAÇÃO I www.del.ufrj.br/~ac/eel170.htm Antonio Cláudio Gómez de Sousa ac@del.ufrj.br 2a série de slides Versão 19/03/2012.

Apresentação em tema: "EEL170 COMPUTAÇÃO I www.del.ufrj.br/~ac/eel170.htm Antonio Cláudio Gómez de Sousa ac@del.ufrj.br 2a série de slides Versão 19/03/2012."— Transcrição da apresentação:

1 EEL170 COMPUTAÇÃO I www.del.ufrj.br/~ac/eel170.htm
Antonio Cláudio Gómez de Sousa 2a série de slides Versão 19/03/2012

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

9 Exemplo – ordenar tres variáveis
Ordenar tres variáveis utilizando um módulo que ordena duas variáveis: Início Ler as variáveis a, b, c Ordena a b // módulo devolve ab ordenado Ordena b c // módulo devolve ab ordenado Apresentar as variáveis a, b, c fim

10 Diagrama de estrutura Módulo principal Passa dois valores
Retornam dois valores ordena

11 Algoritmo simplificado
Inicio // 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 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

12 Algoritmo simples Inicio // 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 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

13 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

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 x,y,med med calcMed x,y: Passagem por valor Med: Passagem por referência

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 leia (dado1,dado2); // orientar e validar media  calcMed(dado1,dado2) // chamada da função escreva(‘A média é ‘,media) leia (dado3,dado4); // orientar e validar escreva(‘A média é ‘, calcMed(dado3,dado4) // chamada da função

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 x,y CalcMed 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 [ a a a a 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 escreva (‘Informe a nota do aluno ‘, aluno)‏ leia (notaAluno)‏ (* testar *) notas [aluno]  notaAluno somaNotas  somaNotas + notaAluno fim mediaNotas  somaNotas / 45 se notas [aluno] > mediaNotas então notasAcima  notasAcima + 1 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 somaNotas := 0; // iniciar somatório
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 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 para indice variando de 1 a contador faça
(* algoritmo do bubble sort *)‏ para contador variando de 9 a 1 faça inicio para indice variando de 1 a contador faça se nomeOrdenado[indice] > nomeOrdenado[indice+1] então início auxiliar  nomeOrdenado[índice] nomeOrdenado[índice]  nomeOrdenado[índice+1] nomeOrdenado[índice+1]  auxilir fim

33 { apresentar os dados não ordenados e ordenados}
escreva (‘Nomes antes da ordenação:’)‏ para índice variando de 1 a 10 faça inicio escreva(nomeInicial[índice]) // na mesma linha fim escreva (‘Nomes após a ordenação:’)‏ escreva(nomeOrdenado[índice]) // na mesma linha

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 dados inicio para coluna variando de 1 a 3 faça // entrada dados 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 inicio para coluna variando de 1 a 3 faça dados[linha+3,coluna]  dados [linha,coluna] fim

37 //cálculo do determinante determinante  0
para indice variando de 1 a 3 faça inicio 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 escreva( dados[linha,coluna])‏ fim pule uma linha escreva(‘O determinante da matriz vale ’, determinante)‏

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 Tipo // declaração de tipos de variáveis
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 para índice variando de 1 a 10 faça
Inicio para índice variando de 1 a 10 faça 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 escreva(dvd[índice].título, dvd[índice].intérprete, dvd[índice].autor, dvd[índice].duração)‏

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 Tipo // declaração de tipos de variáveis
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 // preparar - para iniciar a primeira posição livre
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 1: inicio // incluir um DVD
Caso opção seja 1: inicio // incluir um DVD escreva(‘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 DVDs para índice variando de 1 a primeiraPosLivre - 1 faça inicio escreva(dvd[índice].título, dvd[índice].intérprete, dvd[indice].autor, dvd[indice].duração)‏

51 até que opção = 4 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

52 Estrutura de algoritmo com menu
// 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

53 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 leia (mat2[linha,coluna]) (* apresentar a mat2 em forma matricial *) fim // fim do caso 2

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 3 4: inicio // para subtrair a segunda da primeira matResult[linha,coluna]  mat1[linha,coluna] - mat2[linha,coluna] fim // fim do caso 4

59 5: início // para multiplicar as duas raízes ..................
(* apresentar a matResult *) fim // fim do caso 5 6: início // para calcular a transposta da primeira para linha variando de 1 a qtd faça para coluna variando de 1 a qtd faça matResult[linha,coluna]  mat1[coluna,linha] fim // fim do caso 6 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) Fim até 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: inteiro Inicio repita 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 ← op fim

66 procedimento proDigDados (var matDig: tipMat; qtDig: inteiro)
(* procedimento para digitar os dados *) var lin, col: inteiro inicio para 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 para somar e subtrair matrizes *) var
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ça para coSS variando de 1 a qtdSS faça matRSS[liSS,coSS]  mat1SS[liSS,coSS] + (sinal * mat2SS[liSS,coSS]) proListarMat (matRSS, qtdSS) fim

68 (*procedimento para multiplicar matrizes *) var inicio
procedimento proMultiplicar (mat1M, mat2M: tipMat; var matRM:tipMat; qtdM: inteiro) (*procedimento para multiplicar matrizes *) var liM, coM, indice: inteiro inicio para liM variando de 1 a qtdM faça para coM variando de 1 a qtdM faça MatRM[liM,coM]  0 Para indice variando de 1 a qtdM faça matRM[liM,coM]  matRM[liM,coM] + mat1M[liM,indice] * mat2M[indice,coM]) Fim fim proListarMat (matRM, qtdM)

69 (*procedimento para achar a transposta da 1a *) var liT, coT: inteiro
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ça para 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 para coLis variando de 1 a qtdLis faça Escreva (matLis[liLis,coLis] (* Pule uma linha *) fim

71 operaMatriz proQTD opcao proDigDados proSoSub proMultiplicar proTransposta proListarMat

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 {$I-} // para desativar rotina padrão de tratamento de erro
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 {$I-} // para desativar rotina padrão de tratamento de erro
begin repeat writeln (mensReal); {$I-} // para desativar rotina padrão de tratamento de erro readln (valReal); {$I+} // para reativar a rotina padrão de tratamento de erro erro := 1; // para fazer todos os testes 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 Código completo dos procedimentos e funções: (* 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 erro: integer; // variável para o código de erro 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;

91 procedure digReal(mensReal: string; maxReal, minReal: real; var valReal:real);
(* procedimento para orientar, validar, ...; responsável: ...; data:...*)‏ var erro: integer; // variável para o código de erro begin repeat writeln (mensReal); {$I-} // para desativar rotina padrão de tratamento de erro readln (valReal); {$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 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.