Modularização - Conceito e Exemplos

Este tópico tem como objetivo passar o conceito básico sobre modularização e exemplificar a aplicação prática da mesma dentro de um algoritmo. É um tópico de apoio ao conhecimento já adquirido estudando a matéria.

O que é modularizar?

Modularizar, significa subdividir o programa em partes menores para trabalharem com tarefas específicas. Muitas vezes os módulos são interdependentes, por isso é importante que todo o algoritmo esteja em "sincronia".

Definição: é o agrupamento de um conjunto de ações que tenham um objetivo específico.

Utilizando uma casa como exemplo, a casa como um todo tem sua função principal mas internamente os cômodos da casa (módulos) também têm a sua função específica que implementam a função principal da casa. E as pessoas podem entrar em cada cômodo e sair deles. Agora pensando a nível de algoritmo, uma calculadora é um bom exemplo:

• Na parte principal do algoritmo o usuário informa qual operação ele deseja realizar (soma, multiplicação, divisão, subtração...) e para cada operação deve existir um módulo (ou sub-rotina) que trate de cada operação.
  

Desta forma, o algoritmo fica visualmente mais entendível e fácil para manutenção. Se houver um erro no programa na parte de divisão, porque não está dividindo X por 0, basta ir nesse módulo em específico e criar uma condição para tratar a divisão por zero.

Procedimentos e Funções

Existem dois tipos de sub-rotinas que podem ser utilizadas no algoritmo: sub-rotinas que retornam um valor e sub-rotinas que não retornam um valor. As sub-rotinas que não retornam um valor, apenas executam a sua tarefa e finalizam, retomando a execução para a linha debaixo onde o algoritmo prossegue. Estas sub-rotinas nós chamamos de procedimento. Já as sub-rotinas que retornam um valor a ser tratado pelo módulo principal ou outros módulos, é chamada de função.

Procedimento

Definição de Procedimento: módulo onde haverá a manipulação das variáveis de memória e este não retornará conteúdo a ser tratado no programa principal.

Em pseudocódigo podemos colocar os módulos secundários ou sub-rotinas abaixo do módulo principal. Esta prática se chama Top-Down em Programação Estruturada.

algoritmo "exemplo"
//Informações, declaração de variáveis globais e etc
var
 //variáveis locais do módulo principal
inicio
 //Módulo Principal do algoritmo
fimalgoritmo

procedimento NomeDoProcedimento()
//Informações <opcional>
var
 //variáveis locais do procedimento
inicio
 //Comandos, tratamento...
fimprocedimento

Como se trata de pseudocódigo, esta sintaxe pode não ser reconhecida pelo Visualg em seu compilador. A notação de parênteses "()" é opcional, mas por prática em programação é sempre bom manter. Dentro dos parênteses podemos indicar que tipo de valor essa sub-rotina recebe para trabalhar, mas ela pode não receber valor nenhum, porém, jamais terá acesso as outras variáveis de outros módulos a não ser que elas sejam globais.

Exemplo de algoritmo modularizado com Procedimentos

Crie um algoritmo que receba um valor n e calcule o seu fatorial e exiba o resultado na tela.
Antes de criar o algoritmo, precisamos saber a quantidade de módulos necessário para o programa. Depois pensar o que cada módulo irá fazer, como irá fazer e por último, o tipo das variáveis a se utilizar. Para este caso, servirá dois módulos: um para receber os dados (módulo principal) e outro para realizar o cálculo e saída do resultado (rotina 1). Mas isso varia de lógica para lógica.

A tarefa a se realizar envolverá um único laço de repetição para calcular n! = (n - 1) * (n - 2) * (n - 3)... ou podemos simplificar a fórmula em:
Significa que queremos o produtório de (n - k). MAS, K não pode ser igual a N, porque n - n = 0 e isso acabaria com nosso fatorial, por isso é o produtório até n - 1. Repare que com n = 0 ou n = 1, temos uma exceção nesse caso, mas o fatorial de 0 é 1 e de 1 é o próprio 1. Agora que já temos a fórmula, vamos ao algoritmo:

algoritmo "fatorial"
var
n: inteiro
inicio
escreva("Informe um valor: ")
leia(n)
//O comando abaixo chama o procedimento que calcula o fatorial de N. A execução é desviada para dentro do módulo
fat(n)
fimalgoritmo


procedimento fat(n: inteiro) //O módulo deve receber um valor do tipo inteiro
var
  k, f: inteiro  //Só precisaremos de um contador, que será o nosso K da fórmula
inicio
 f <- n //Fatorial é igual a N
 se (n = 0) entao //Sabemos que o fatorial de zero é 1 Matemática Rio - Fatorial de 0
    f <- 1
 senao
    para (k <- 1; k < n; k++) faca   //K deve ser menor que N, ou menor igual a N - 1. Senão temos "n! * 0" e isso dá zero.
       f <- f * (n - k) //Produtório de (n - k) com a condição k <= n - 1
    fimpara
  fimse
 escreva("O fatorial é: ", f)
fimprocedimento

Agora é só realizar o Teste de Mesa e ver se o algoritmo está OK. O algoritmo também só pode receber valores pertencentes ao conjunto dos números naturais, poderia existir um módulo para tratar a entrada ou isto ser feito no próprio módulo principal. Mas vamos assumir que o usuário só irá digitar valores naturais   .

Função

Uma função, assim como na matemática, retorna um valor. Eu posso jogar vários valores de tipos diferentes dentro de uma função, mas ela só pode me retornar um único tipo de valor e um único valor.

Definição de Função: é um módulo onde poderá ou não haver passagem de parâmetros e este retorna um conteúdo a ser tratado no programa principal.

Parâmetro é aquilo que você passa para dentro de uma sub-rotina. Também colocaremos as funções abaixo do módulo principal. Por boa prática de programação, é aconselhável que o nome de sub-rotinas sejam diferentes do nome de variáveis e que não haja repetição de nomes, tanto em variáveis quanto em sub-rotinas. Para nomes compostos, é comum utilizar o CamelCase para funções, procedimento e variáveis.

algoritmo "exemplo"
//Informações, declaração de variáveis globais e etc
var
 //variáveis locais do módulo principal
inicio
 //Módulo Principal do algoritmo
fimalgoritmo

funcao NomeDaFuncao(): <TipoDeRetorno>
//Informações <opcional>
var
 //variáveis locais do procedimento
inicio
 //Comandos, tratamento...
 retorne <ValorASerRetornado>
fimfuncao

Exemplo de Algoritmo modularizado com Funções e Procedimentos

Calcule a Série:

Esta série pode parecer mais difícil. Mas o algoritmo para calcular o fatorial já temos, então em vez de: s = n! + (n - 1)! + (n - 2)! + ... + 1!, só precisamos fazer s = fat(n) + fat(n - 1) + fat(n - 2) + ... + fat(1). Precisamos:

1. Criar o módulo principal para receber os dados a serem distribuídos e trabalhados nos outros módulos;
   
2. Criar um módulo para calcular e exibir a série;
   
3. Criar um módulo para calcular o fatorial e retornar o valor para a série.
   

Claro que isto varia de lógica para lógica, mas em geral nosso algoritmo ficaria assim:

algoritmo "serieFatorial"
var
  n: inteiro
inicio
 //Entrada de Dados
 escreva("Informe um valor natural: ")
 leia(n)
 //Passando como parâmetro o valor de n para o procedimento responsável por calcular a série
 calcSerie(n)
fimalgoritmo


procedimento calcSerie(n: inteiro)
var
  s: real //Como envolve fatorial, deixarei essa variável como real
  k: inteiro //Contador
inicio
  para (k <- 0; k <= (n - 1); k++) faca
     s <- s + fat(n - k)  //Chama a função que calcula o fatorial
  fimpara
  //Exibindo resultado final
 escreva("O resultado da série é: ", s)
fimprocedimento


funcao fat(n: inteiro): inteiro //O módulo deve receber um valor do tipo inteiro
var
  k, f: inteiro  //Só precisaremos de um contador, que será o nosso K da fórmula
inicio
 f <- n //Fatorial é igual a N
 se (n = 0) entao[color=#006600]
    f <- 1
 senao
    para (k <- 1; k < n; k++) faca   //K deve ser menor que N, ou menor igual a N - 1. Senão temos "n! * 0" e isso dá zero.
       f <- f * (n - k) //Produtório de (n - k) com a condição k <= n - 1
    fimpara
  fimse
 retorne f //retorna o valor do fatorial para o módulo que o chamou, no caso ficará s <- s + f no procedimento
fimfuncao

Agora é só realizar o Teste de Mesa:


Perceba que o módulo que realiza o cálculo de fatorial foi chamado diversas vezes. Imagine criar de maneira sequencial, a fusão destes dois módulos em um único. Com certeza, ficará muito difícil fazer a manutenção e mesmo que seja fácil para quem o criou, talvez não seja para o resto da equipe de programadores que forem trabalhar no projeto.

Em um outro tópico falarei sobre passagem de parâmetros, assinatura e escopo para não tornar este muito grande.