No vasto universo do desenvolvimento de software, compreender os diferentes paradigmas de programação é crucial para qualquer profissional da área. Entre eles, a programação estruturada se destaca como um dos pilares que moldaram a forma como construímos sistemas. Mas o que exatamente ela significa e por que é tão relevante até hoje?

Neste texto, vamos entender o que é esse paradigma, como ele surgiu, quais são suas principais características e estruturas, e por que ele ainda é fundamental no aprendizado e, na prática da programação.

1 – O que é programação estruturada?

A programação estruturada é um paradigma de programação que preconiza a criação de programas organizados e de fácil entendimento, utilizando um conjunto limitado de estruturas de controle de fluxo. Ela surgiu como uma resposta aos desafios da programação não estruturada, que resultava em códigos complexos e difíceis de manter, popularmente conhecidos como “código espaguete”.

O objetivo principal da programação estruturada é simplificar o processo de desenvolvimento e depuração, promovendo a clareza e a modularidade do código. Em vez de saltos incondicionais (como o GOTO), ela incentiva o uso de construções bem definidas.

A programação estruturada parte da ideia central de que podemos desenvolver qualquer software, por mais complexo que ele seja, utilizando apenas três estruturas fundamentais de controle de fluxo.

• Sequência: o sistema executa as instruções em ordem linear, uma após a outra. Essa é a forma mais básica de organizar um código, onde o sistema lê e processa cada comando na sequência em que ele aparece.
• Seleção (ou Condição): permite que o programa execute diferentes blocos de código com base em uma condição. As estruturas mais comuns são o if/else (se/senão) e o switch/case (escolha/caso). Isso dá ao programa a capacidade de tomar decisões.
• Iteração (ou Repetição/Loop): permite executar um bloco de código repetidamente enquanto uma condição for verdadeira ou por um número específico de vezes. Exemplos incluem for (para), while (enquanto) e do-while (faça-enquanto). Essas estruturas são essenciais para automatizar tarefas repetitivas.

Linguagens tradicionais como C, Pascal, Fortran, e ALGOL, por exemplo, adotam amplamente o paradigma da programação estruturada. Além delas, atualmente, muitas linguagens modernas como JavaScript, Python, PHP e outras também incorporam os princípios desse paradigma.

Em suma, a programação estruturada defende que a combinação dessas três estruturas básicas é suficiente para construir algoritmos eficientes, claros e fáceis de manter, independentemente da complexidade do problema.

2 – Quando esse paradigma de programação surgiu?

A programação estruturada ganhou força na década de 1960, impulsionada principalmente pelos trabalhos do cientista da computação Edsger W. Dijkstra. Na época, o desenvolvimento de software enfrentava uma crise de produtividade e qualidade. Os programas eram escritos de forma caótica, com muitos saltos GOTO que dificultavam o rastreamento do fluxo de execução e a identificação de erros. Desse modo, a manutenção e a expansão dos sistemas tornava-se um verdadeiro pesadelo.

Dijkstra, em seu famoso artigo “Go To Statement Considered Harmful” (Declaração Go To Considerada Prejudicial) de 1968, criticou severamente o uso indiscriminado do GOTO, argumentando que ele levava a programas “espalhafatosos” e ininteligíveis. Sua proposta era justamente a utilização das três estruturas de controle que mencionamos: sequência, seleção e iteração.

Assim, o surgimento da programação estruturada representou um avanço significativo para a engenharia de software, promovendo a modularidade, legibilidade e manutenibilidade do código. Ao dividir o programa em blocos menores e mais gerenciáveis (como funções e procedimentos), tornou-se mais fácil para os desenvolvedores entenderem, testarem e corrigirem partes específicas do sistema sem afetar o todo.

3 – Exemplo de programação estruturada

Com a finalidade de ilustrar os conceitos da programação estruturada, vamos analisar um exemplo simples de código que verifica se um número é par ou ímpar. Observe que, para fins didáticos, desenvolvemos esse código em três linguagens diferentes: JavaScript, Python e Java.

Ademais, note em cada linguagem utilizada, como a modularização das funções e o uso das estruturas de controle de fluxo acontecem na prática.

// Função para verificar se o número é par ou ímpar 
function verificarParOuImpar(numero) {

    // Utiliza uma estrutura condicional (if/else) para determinar a paridade
    if (numero % 2 === 0) {
        return "O número é par.";
    } else {
        return "O número é ímpar.";
    }
}

// Função principal para executar o programa 
function main() {
    var entradaValida = false;

    // Loop de repetição (while) para obter uma entrada numérica válida do usuário
    while (!entradaValida) {
        var numero = prompt("Digite um número inteiro: ");
        // Verifica se o valor inserido é de fato um número
        if (!isNaN(numero)) {
            entradaValida = true;
        } else {
            console.log("Por favor, digite um número válido.");
        }
    }

    // Invoca a função que checa a paridade do número (fluxo sequencial)
    console.log(verificarParOuImpar(numero));
}

// Inicia a execução do programa chamando a função principal (fluxo sequencial)
main();

# Função para verificar se o número é par ou ímpar
def verificar_par_ou_impar(numero):
    
    # Aplica uma condição (if/else) para checar se o número é par
    if numero % 2 == 0:
        return "O número é par."
    else:
        return "O número é ímpar."

# Função principal para executar o programa
def main():
    entrada_valida = False

    # Itera (loop while) até que o usuário forneça um número inteiro válido
    while not entrada_valida:
        numero_str = input("Digite um número inteiro: ")
        # Confere se a entrada fornecida é um número
        if numero_str.isdigit() or (numero_str.startswith('-') and numero_str[1:].isdigit()):
            numero = int(numero_str)
            entrada_valida = True
        else:
            print("Por favor, digite um número válido.")

    # Aciona a função que determina se o número é par ou ímpar (execução sequencial)
    print(verificar_par_ou_impar(numero))

# Garante que a função principal seja chamada ao executar o script
if __name__ == "__main__":
    main()

#include <iostream>
#include <string>  
#include <limits>   

// Função para verificar se o número é par ou ímpar
std::string verificarParOuImpar(int numero) {
    // Implementação de uma estrutura condicional (if/else) para validação
    if (numero % 2 == 0) {
        return "O número é par.";
    } else {
        return "O número é ímpar.";
    }
}

// Função principal para executar o programa
int main() {
    bool entradaValida = false;
    int numero = 0; // Inicializa a variável para ser usada no escopo

    // Estrutura de repetição (while) para garantir uma entrada numérica correta
    while (!entradaValida) {
        std::cout << "Digite um número inteiro: ";
        // Tenta ler um número inteiro
        if (std::cin >> numero) {
            entradaValida = true;
        } else {
            std::cout << "Por favor, digite um número válido." << std::endl;
            // Limpa o estado de erro do cin e descarta o restante da linha de entrada
            std::cin.clear();
            std::cin.ignore(std::numeric_limits::max(), '\n');
        }
    }

    // Chama a função que verifica a paridade do número (fluxo de execução)
    std::cout << verificarParOuImpar(numero) << std::endl;

    return 0; // Indica que o programa terminou com sucesso
}

Nestes exemplos, podemos observar claramente os princípios da Programação Estruturada aplicados na prática:

• Modularidade: nas três linguagens que utilizamos em nosso exemplo, o código é dividido em duas funções, cada uma delas com sua responsabilidade específica.
  • verificarParOuImpar: função para verificar se o número é par ou ímpar.
  • main: função principal para executar o programa.
• Estruturas de Controle: utilizamos if/else para tomar decisões (verificar par/ímpar e validar a entrada) e um while para repetir a solicitação de entrada até que um número válido seja fornecido.
• Sequência: observe em todos os códigos que, tanto a organização das instruções dentro de cada função e as suas respectivas chamadas ocorrem em uma ordem lógica e sequencial.

Apesar de novos paradigmas terem surgido, como a programação orientada a objetos, a programação estruturada continua sendo a base para a escrita de código legível, eficiente e fácil de manter. Portanto, entender seus conceitos é fundamental para qualquer desenvolvedor que busca construir sistemas robustos e de alta qualidade.

Conclusão

A programação estruturada representou um divisor de águas na história do desenvolvimento de software, ao propor uma abordagem mais clara, lógica e modular para a construção de programas.

Mesmo que outros paradigmas tenham surgido, como a programação orientada a objetos e programação funcional, por exemplo, os princípios da programação estruturada continuam sendo amplamente utilizados e valorizados.

Por fim, podemos compreender que dominar a programação estruturada é um passo essencial para qualquer desenvolvedor, pois ela fornece a base para escrever códigos mais organizados, legíveis e fáceis de manter — qualidades indispensáveis na criação de sistemas robustos e duradouros.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui!