disciplina de 0 ate 4 faca

// E, por fim, um laço para andar nos cursos 12.

para

13. curso de 0 ate 9 faca

escreva

14. (“Digite a média: ”)

leia (

15. notas[aluno, disciplina, curso])

fimpara 16. fimpara 17. fimpara 18. fimalgoritmo 19.

Cada dimensão da matriz é manipulada por um laço exclusivo. Por isso, ao se adicionar uma nova dimensão, deve-se criar uma nova variável e um novo laço para manipulá-la. Ou seja, é criado um laço para..faça para cada dimensão a ser percorrida e a referência

ao elemento da estrutura é feita pela quantidade de índices correspondente a quantidade de dimensões.

Unidade 5 – SubAlgoritmos

A modularização é uma característica muito importante no desenvolvimento de programas. Ela é um método utilizado para facilitar a construção de grandes algoritmos, através de sua divisão em pequenas etapas, que são os subalgoritmos. Ao invés de escrever- se um algoritmo grande, escrevem-se vários algoritmos menores, os quais, não isoladamente, mas em conjunto, resolvem o problema proposto. É o “dividir para conquistar”.

Outra ocasião em que o uso de subalgoritmos é conveniente é quando uma determinada tarefa é efetuada em diversos lugares no mesmo algoritmo. Nisso, ao invés de escrever o mesmo trecho diversas vezes, pode-se escrever um subalgoritmo com aquele trecho de código e chamá-lo diversas vezes.Vamos ilustrar isso com um exemplo: Faça um algoritmo para ler três valores inteiros N1, N2 e N3 e coloca-los em ordem crescente, para ao final imprimir os valores. Use apenas estruturas simples, não precisa usar vetores ou algo do gênero. Algoritmo 1. “ordena” var 2. N1, N2, N3, aux: inteiro 3. inicio 4. 5. // Primeiro lê os valores escreva 6. (“Digite N1: ”) leia( 7. N1₎ escreva 8. (“Digite N2: ”) leia( 9. N2₎ escreva 10. (“Digite N3: ”) leia( 11. N3₎

//faz comparações para colocar o maior valor na 12. variável N3 se (N1 > N2) e (N1>N3) então 13. aux <- N1 14. N1 <- N3 15. N3 <- aux 16.

senão 17. se (N2 > N1) e (N2 > N3) então 18. aux <- N2 19. N2 <- N3 20. N3 <- aux 21. fimse 22. fimse 23.

// agora que o maior já está em N3, basta ver quem 24.

é o maior entre os

// outros dois slementos 25. se (N1>N2) então 26. aux <- N1 27. N1 <- N2 28. N2 <- aux 29. fimse 30. escreval(N1, “ “, N2, “ “, N3) 31. fimalgoritmo 32.

Analisando o código, vemos que há trechos (que foram destacados com chaves) que realizam extamente a mesma tarefa: trocar o valor de dois elementos. Justamente trechos como esses são bons candidatos a subalgoritmos. Mas vamos definir melhor, o que é mesmo um subalgoritmo? Bem, um subalgoritmo é um algoritmo menor que auxilia o algoritmo principal através da realização de uma determinada subtarefa bem definida (até agora, tudo que fizemos estava só no algoritmo principal). O subalgoritmo é também chamado de subprograma, subrotina ou módulo. Ele é declarado antes do início do algoritmo principal e pode ser chamado em qualquer ponto após sua declaração. Ou seja, dentro do algoritmo principal ou a partir de outro subalgoritmo definido abaixo dele. Por exemplo, na Figura 7, o subalgoritmo 1.1 é chamado a partir do subalgoritmo 1.

Os subalgoritmos são chamados dentro do corpo do algoritmo principal ou de outro subalgoritmo como se fossem comandos. Daí o fluxo de execução do que está sendo executado é desviado para executar o subalgoritmo e, após seu término, a execução continua a

provisório no fluxo de execução do algoritmo principal.

Figura 7 - Esquema de uma chamada a subalgoritmo

E que vantagens você vai ter fazendo uso de subalgoritmos? • Eles reduzem o tamanho do algoritmo como um todo. Porque,

por exemplos, trechos repetidos só serão implementados uma vez em um subalgoritmo e, depois, serão apenas “chamados”. • Facilitam a compreensão e visualização do que faz o

algoritmo, porque o desenvolvimento modularizado faz com que se possa pensar no algoritmo por partes

• Facilidade de depuração (correção/acompanhamento): é mais fácil corrigir/detectar um erro apenas uma vez do que dez vezes, em dez trechos diferentes.

• Facilidade de alteração do código: se é preciso alterar, altera- se apenas uma vez, no subalgoritmo.

• Generalidade de código com o uso de parâmetros: é possível escrever algoritmos para situações genéricas (você vai ver quando falarmos dos parâmetros!).

Para se criarem subalgoritmos, é preciso descrevê-los/declará- los após a declaração das variáveis do algoritmo principal e antes do início do mesmo. 1. _{Algoritmo “ordena”} var 2. N1, N2, N3, aux: inteiro 3.

// ***** LOCAL PARA A DECLARAÇÃO DOS SUBALGORITMOS ****** 4.

inicio 5.

Há dois tipos de subalgoritmos: PROCEDIMENTOS e FUNÇÕES. Vamos detalhar cada um deles a seguir.

Procedimentos

Um procedimento é um subalgoritmo que não retorna,

explicitamente, valores ao algoritmo principal ou a outro subalgoritmo

que o tenha chamado. Ele pode retornar valores apenas por meio dos parâmetros, e nunca explicitamente como no caso das funções (que veremos depois) que usam a instrução Retorne.

Sua declaração, como descrito anteriormente, deve estar entre o final da declaração de variáveis do algoritmo principal e a linha inicio

do mesmo e obedece à seguinte sintaxe:

procedimento nomeProcedimento ([declarações-de-parâmetros])

[var declaração de variáveis locais]

inicio

//Seção de Comandos

fimprocedimento

onde:

nomeProcedimento _{obedece às mesmas regras de}

nomenclatura de um identificador (vistas no capítulo 1).

[declarações-de-parâmetros]

Um procedimento pode não receber nenhum parâmetro ou pode ter um ou mais parâmetros. Parâmetros são a forma de comunicação entre quem chama o procedimento e o procedimento. São valores de entrada, que precisam ser enviados por quem chamou o procedimento. Essas declarações vão ter o seguinte formato:

[var] seqüência-de-parâmetros : tipo-de-dado

Cada declaração entre um mesmo tipo de dado é separada por vírgula, mas a declaração entre tipos de dados diferentes é separada por ponto-e-vírgula. A presença (opcional) da palavra-chave var indica

que a passagem de parâmetros é feita por referência; caso contrário, a passagem de parâmetros será feita por valor (explicaremos isso melhor na subseção a seguir).

[_{var declaração de variáveis locais]}

locais só são vistas e só podem ser usadas dentro do procedimento Na seção de comandos, você pode ter qualquer instrução que foi vista até agora: estrutura seqüencial, condicional ou de repetição, comandos de entrada e saída de dados, operações etc. Lembre que um subalgoritmo (procedimento ou função) é um algoritmo, só que menor, específico para realizar uma tarefa. Logo, pode ter tudo que um algoritmo pode ter.

E depois do procedimento declarado, como eu faço uso dele? Como eu posso chamá-lo?

CHAMADA DE UM PROCEDIMENTO

A chamada de um procedimento é feita pelo nome dele, como um comando simples, dentro do algoritmo principal, de outro subalgoritmo ou dentro do próprio procedimento (quando um procedimento chama ele mesmo, está se fazendo uso de recursão – esse assunto só será apresentado na linguagem C, no módulo final da disciplina).

Sintaxe: nomeProcedimento(valores para os parâmetros)

Note que é parecido com a ativação do comando instruções Leia e Escreva, porque eles são também procedimentos. Um procedimento não pode ser chamado no meio de expressões ou em atribuições como no caso de funções.

Ao se chamar um procedimento, deve-se observar se ele tiver parâmetros definidos. Se ele tiver, quem o chamou vai ter que passar um valor para cada parâmetro. A quantidade dos parâmetros, sua seqüência e respectivos tipos não podem mudar: devem estar de acordo com o que foi especificado na sua correspondente declaração.

Que tal um exemplo completo agora, para ver se você está entendendo? Vamos pegar aquele algoritmo ordena do início da Unidade 4 e vamos agora, implementá-lo usando procedimento. O trecho que se repete, que é o da troca de valor de duas variáveis, é o que vai ser implementado como procedimento.

Algoritmo 1. “ordena2” var 2. N1, N2, N3: inteiro 3. // depois da declaração de variáveis deve ser definido o procedimento 4. procedimento

5. troca _{(var num1, num2: inteiro)}

var