^[1]Copyright © 2026 Alyce Suza.

Divisão de problemas complexos e reaproveitamento de código

12.1 O Paradigma da Divisão e Conquista

A construção de algoritmos até este momento ocorreu integralmente dentro do bloco principal do programa. Esta abordagem monolítica funciona perfeitamente para problemas pequenos e de escopo limitado. No entanto, quando a regra de negócio exige a criação de sistemas extensos, manter todo o código concentrado numa única função gera ficheiros ilegíveis, dificulta a deteção de falhas lógicas e promove a repetição desnecessária de instruções. A modularização resolve este obstáculo aplicando o princípio matemático da divisão e conquista, fracionando um problema gigantesco em pequenos subprogramas independentes e especializados. Cada módulo assume a responsabilidade exclusiva de resolver uma única fração do problema, permitindo que o programador isole o raciocínio, teste cada componente individualmente e reaproveite a mesma lógica diversas vezes sem precisar de reescrever uma única linha de código.

12.2 Procedimentos e Funções do Tipo Vazio

Na arquitetura do Portugol, os subprogramas dividem-se em duas categorias operacionais ditadas pelo comportamento do seu retorno. A primeira categoria abrange os procedimentos, que são declarados com a palavra reservada indicando um tipo vazio. Um procedimento executa uma sequência de comandos, altera o estado do ecrã ou processa informações, mas não devolve nenhum dado matemático ou lógico para quem o invocou. A sua aplicação clássica ocorre na estruturação de elementos visuais do terminal, como a impressão de menus interativos, a limpeza da interface ou a exibição padronizada de mensagens de erro. Ao encapsular a construção de um cabeçalho dentro de um procedimento, o programador pode invocar o nome da função dez vezes em diferentes partes do sistema, garantindo que qualquer futura alteração no design visual precise de ser feita num único ponto centralizado do código-fonte.

programa
{
    // Declaracao de um procedimento sem retorno
    funcao vazio exibirCabecalho()
    {
        escreva("====================================\n")
        escreva("    SISTEMA DE GESTAO ACADEMICA     \n")
        escreva("====================================\n")
    }

    funcao inicio()
    {
        // Invocacao do procedimento pelo seu nome exato
        exibirCabecalho()
        escreva("O modulo principal esta em execucao.\n")
        exibirCabecalho()
    }
}

12.3 Funções com Retorno de Dados

A segunda categoria de subprogramas engloba as funções que produzem e devolvem um resultado concreto para o módulo que as solicitou. Para construir esta estrutura, o programador substitui a palavra vazio pelo tipo de dado exato que a função deve emitir no final do seu processamento, como um valor inteiro, real ou lógico. O encerramento obrigatório destas funções dá-se com o comando de retorno, que paralisa a execução interna do módulo e transfere o valor processado de volta para a linha de código original. Este mecanismo é fundamental para isolar cálculos matemáticos complexos, permitindo que a função principal delegue o trabalho pesado e apenas recolha o produto final para prosseguir com o fluxo de decisão do algoritmo.

programa
{
    // Declaracao de uma funcao que obrigatoriamente devolve um valor real
    funcao real obterImpostoPadrao()
    {
        real impostoBase = 0.15
        retorne impostoBase
    }

    funcao inicio()
    {
        real taxaAtual
        
        // A variavel recebe diretamente o valor devolvido pela funcao
        taxaAtual = obterImpostoPadrao()
        
        escreva("O sistema opera com a taxa fiscal de: ", taxaAtual, "\n")
    }
}

12.4 Escopo de Variáveis e Passagem de Parâmetros

O conceito de escopo dita a fronteira de visibilidade e o tempo de vida de uma variável na memória do computador. Uma variável declarada no topo do ficheiro, fora de qualquer função, é considerada global e pode ser lida ou alterada por qualquer módulo do sistema. A programação estruturada moderna condena o uso excessivo de variáveis globais, pois elas quebram o isolamento dos módulos e permitem que partes desconexas do código alterem dados de forma imprevisível. Em oposição, as variáveis declaradas dentro de uma função são locais. Elas nascem quando a função é invocada e são totalmente destruídas pelo sistema operacional no milissegundo em que a função termina o seu trabalho, garantindo que a memória permaneça limpa.

Para permitir que funções locais comuniquem entre si sem recorrer a variáveis globais, utilizamos a passagem de parâmetros. Os parâmetros atuam como canais de comunicação instalados nos parênteses da função, exigindo que o módulo invocador forneça os dados exatos necessários para o processamento. O valor enviado é copiado para a memória local da função, permitindo que ela execute cálculos personalizados baseados nas necessidades específicas daquele momento exato da execução.

programa
{
    // A funcao exige a entrega de dois parametros reais para existir
    funcao real calcularMedia(real notaA, real notaB)
    {
        real resultado = (notaA + notaB) / 2.0
        retorne resultado
    }

    funcao inicio()
    {
        real prova1 = 7.5
        real prova2 = 9.0
        real mediaFinal
        
        // Os valores sao injetados nos parametros da funcao durante a chamada
        mediaFinal = calcularMedia(prova1, prova2)
        
        escreva("O calculo algoritmico da media resultou em: ", mediaFinal, "\n")
        
        // Reaproveitamento da mesma funcao com dados completamente diferentes
        escreva("A media entre 4 e 6 e: ", calcularMedia(4.0, 6.0), "\n")
    }
}

12.5 Exercícios do Capítulo 12

Gabarito do Capítulo 12

programa
{
    funcao vazio imprimirAlerta(cadeia mensagem)
    {
        escreva("--------------------------------------\n")
        escreva(" AVISO: ", mensagem, "\n")
        escreva("--------------------------------------\n")
    }
    
    funcao inicio()
    {
        imprimirAlerta("Falha ao estabelecer conexao de rede")
        imprimirAlerta("Base de dados operando com lentidao")
        imprimirAlerta("Sistema atualizado com absoluto sucesso")
    }
}

programa
{
    funcao logico validarParidade(inteiro alvo)
    {
        se (alvo % 2 == 0)
        {
            retorne verdadeiro
        }
        senao
        {
            retorne falso
        }
    }
    
    funcao inicio()
    {
        inteiro dado
        escreva("Forneca o valor numerico destinado a avaliacao logica: ")
        leia(dado)
        
        se (validarParidade(dado))
        {
            escreva("Diagnostico atestado: O elemento matematico e Par.\n")
        }
        senao
        {
            escreva("Diagnostico atestado: O elemento matematico e Impar.\n")
        }
    }
}