Modularidade

Origem: Wikipédia, a enciclopédia livre.
(Redirecionado de Programação modular)
Ir para: navegação, pesquisa

Modularização em tecnologia da informação é um conceito onde o sistema ou software é divido em partes distintas. Compõe o ferramental necessário para um programa mais legível com uma melhor manutenção e melhor desempenho por meio da programação estruturada.

Pode ser caracterizado da seguinte forma: Elemento separadamente endereçável do sistema, menor parte do sistema que realiza uma função completa independente de outras funções, conjunto de instruções de um programa que pode ser chamado por um nome, sendo ideal que para os outros módulos seja uma caixa preta.

Características[editar | editar código-fonte]

A ideia de dividir os programas em módulos surgiu no final da década de 1960. Os países desenvolvidos estavam então passando por uma “crise de software”. Essa crise se deu ao rápido desenvolvimento do hardware ao passo que as técnicas aplicadas ao desenvolvimento de software avançavam lentamente. O Desenvolvimento de sistemas sem uma metodologia para a construção de programas, geralmente resulta em um software com vários erros e com alto custo de desenvolvimento que, consequentemente exige um custo elevado para sua correcção e manutenção futuras. A modularização de programas juntamente com outras técnicas de programação integram o ferramental para a elaboração de programas visando, principalmente, os aspectos de confiabilidade, legibilidade, manutenção e flexibilidade.

Um modulo pode ser definido como um grupo de comandos, constituindo um trecho de algoritmo, com uma função bem definida e o mais independente possível em relação ao resto do algoritmo. A maneira mais intuitiva de proceder à modularização é definir um modulo principal de controle e modulo especifico para as funções do algoritmo. O ideal é que os módulos não sejam grandes demais, pois senão acabam sendo multifuncionais e de difícil compreensão, de modo que o modulo deve ser implementado apenas as estruturas de dados necessários para atingir ao objectivo do modulo.

Ferramentas para a modularização[editar | editar código-fonte]

As ferramentas são as sub-rotinas e as funções.

Sub-rotinas[editar | editar código-fonte]

Porção de código para realizar uma tarefa especifica. Diferente de uma função ela não retorna nenhum valor. Uma sub-rotina é declarada da seguinte forma:

A lista de parâmetros formais é opcional. Todavia, caso seja usada elas podem ser de três formas.

  1. - Passagem por valor;
  2. - Passagem por resultado;
  3. - Passagem por referência;

subrotina NOME(lista-de-parâmetros-formais) declarações dos objectos locais à sub-rotinas comandos das sub-rotinas fimsubrotina


</source>

Exemplo de sub-rotina em C[editar | editar código-fonte]

void Tocarsom(){
    int contador;
    for(contador = 100; contador < 1000; contador += 50){
        sound(contador);
        delay(100);
    }
    nosound();
}


No exemplo acima, temos uma sub-rotina que toca um som. Como podemos perceber não foi passado nenhum parâmetro, embora seja possível usar parâmetros.

Funções[editar | editar código-fonte]

É uma porção de código para realizar uma tarefa especifica. Embora seja muito parecido com uma sub-rotina ela possui uma caracteristica especial, que consiste em retornar um valor associado ao seu nome.

Exemplo de função em linguagem C:

#include <stdlib.h>
#include <conio.h>
#include <dos.h>
#include <stdio.h>
 
        void EsperaEnter()  // Definição da função "EsperaEnter"
        {
            int tecla;
            printf("Pressione ENTER\n");
            do{
                tecla = getch();
                if (tecla !=13) // Se nao for ENTER{
                    sound(700); // Ativa a emissão de um BEEP
                    delay(10);  // Mantém a emissão do som por 10 ms
                    nosound();  // Para de emitir o som
                }
            } while(tecla != 13); // 13 e' o codigo ASCII do ENTER
        }
        void main()
        {
            EsperaEnter();      // Chamada da função definida antes
        }

Vantagens e desvantagens[editar | editar código-fonte]

Existem grandes vantagens no uso do de módulos e algumas desvantagens são alguns deles:

Vantagens[editar | editar código-fonte]

  • Programas feitos com sub-rotinas ou funções são programados e testados uma só vez, embora possam ser usados em várias partes do programa em quantas vezes são necessários.
  • Pode-se criar uma biblioteca com as funções e sub-rotinas que podem ser usados em outros programas ou por outros programadores.
  • Com a modularização conseguimos preservar os refinamentos conseguidos em uma parte especifica do código e estender a toda parte do sistema que ira usar a função ou sub-rotina
  • Economia de memória do computador, uma vez que o modulo utilizado é armazenado uma única vez, mesmo que utilizado em diferentes partes do programa. Permite também, que, em determinado instante da execução do programa, estejam na memória principal apenas o módulo ou os módulos necessários para execução desse trecho de programa.
  • Ocultamento de código, uma vez que apenas as rotinas e sub-rotinas ficam disponíveis para outros programadores.

Desvantagens[editar | editar código-fonte]

  • Aumento no tempo de execução do programa, devido ao tratamento adicional de activação do módulo.

Referências

  • HARRY FARRER...Programação estruturada de Computadores: Algoritmos estruturados - [et. Al.] - 3° ed, [reimpr.] - Rio de Janeiro: LTC, 2008.

Ligações externas[editar | editar código-fonte]