O comando ‘goto’: boas práticas e alternativas

Fala galera da programação, tudo beleza?

Você já ouviu falar sobre o comando ‘goto’? Venha conhecer mais sobre o assunto neste interessante post.

 

Introdução

O comando goto é uma instrução de controle de fluxo que, em muitas linguagens de programação, permite transferir o controle do programa para um ponto específico do código. Embora seja uma ferramenta poderosa, o seu uso é geralmente desencorajado devido aos desafios que pode apresentar em termos de legibilidade e manutenção do código.

Características do Comando ‘goto’

1. Transferência Incondicional: O goto transfere o controle de forma incondicional para um rótulo especificado, ignorando qualquer lógica condicional.
2. Potencial para Código Incompreensível: O uso excessivo de goto pode resultar em código difícil de entender e dar origem a problemas de manutenção, uma vez que desafia a estruturação natural e lógica do código.
3. Alternativas Preferíveis: Na maioria dos casos, estruturas de controle de fluxo mais estruturadas, como loops (for, while, repeat) e condicionais (if, else), são preferíveis. Elas tornam o código mais legível e ajudam a evitar armadilhas associadas ao uso indiscriminado do goto.

 

Exemplo de Uso Responsável

Embora o goto seja desencorajado, há situações em que seu uso pode ser aceitável, como em código gerado automaticamente ou em casos específicos de otimização. No entanto, é crucial ponderar cuidadosamente sobre as implicações antes de incorporar goto em um projeto.

Boas Práticas:

1. Evite o Uso Excessivo: Limitar o uso do goto apenas a situações excepcionais, quando não há alternativas mais claras e legíveis.
2. Priorize Estruturas de Controle Mais Claras: Opte por estruturas de controle de fluxo que expressem a lógica do programa de forma mais clara e intuitiva.
3. Mantenha a Legibilidade: Certifique-se de que o código seja facilmente compreendido por outros desenvolvedores, promovendo boas práticas de programação.

 

Exemplo de uso em Pascal

Este programa em Pascal é um exemplo simples de um loop utilizando a instrução goto. Vamos explicar cada parte do código:

{

Criado pelo Professor Giovani Da Cruz

}
program ExemploComGoto;

var
  numero: Integer;

label
  InicioDoLoop, FimDoLoop;  // Define pontos para o controle de fluxo
begin
  // Inicialização
  numero := 1;

  // Início do loop usando goto
  InicioDoLoop:
    writeln('Número: ', numero);

    // Condição de saída do loop
    if numero = 5 then
      goto FimDoLoop;

    // Incremento do número
    numero := numero + 1;

    // Ir para o início do loop
    goto InicioDoLoop;

  // Rótulo para o fim do loop
  FimDoLoop:
    writeln('Loop encerrado.');

  // Espera que o usuário pressione Enter antes de fechar
  readln;
end.

Explicação:

1. label InicioDoLoop, FimDoLoop;: Aqui são definidos rótulos (labels) chamados InicioDoLoop e FimDoLoop, que servirão como pontos de referência para o comando goto.
2. Inicialização: A variável numero é inicializada com o valor 1.
3. InicioDoLoop:: Este é o rótulo de início do loop. A execução do programa começará a partir deste ponto sempre que houver um salto para InicioDoLoop usando goto.
4. writeln('Número: ', numero);: Imprime o valor atual da variável numero.
5. if numero = 5 then goto FimDoLoop;: Verifica se o valor de numero é igual a 5. Se for, o programa salta para o rótulo FimDoLoop, encerrando o loop.
6. numero := numero + 1;: Incrementa o valor da variável numero.
7. goto InicioDoLoop;: Salta de volta para o rótulo InicioDoLoop, reiniciando o loop.
8. FimDoLoop:: Rótulo indicando o fim do loop.
9. writeln('Loop encerrado.');: Imprime uma mensagem indicando que o loop foi encerrado.
10. readln;: Espera que o usuário pressione Enter antes de fechar o programa.

Esse exemplo utiliza goto para criar um loop simples que imprime os números de 1 a 5 e, em seguida, exibe uma mensagem indicando que o loop foi encerrado. Vale ressaltar que o uso de goto não é considerado uma prática recomendada na programação moderna devido a preocupações com a legibilidade e manutenção do código.

 

Exemplo em C / C++

Em C, a linguagem não possui uma instrução goto rotulada como em Pascal. No entanto, você pode criar um loop infinito usando goto e uma condição de saída, o que é uma prática desencorajada em muitos casos. Aqui está um exemplo simples:

/****************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

****************************************************************************/
#include <stdio.h>

int main() {
    // Inicialização
    int numero = 1;

    // Início do loop usando goto
    InicioDoLoop:
        printf("Número: %d\n", numero);

        // Condição de saída do loop
        if (numero == 5)
            goto FimDoLoop;

        // Incremento do número
        numero++;

        // Ir para o início do loop
        goto InicioDoLoop;

    // Rótulo para o fim do loop
    FimDoLoop:
        printf("Loop encerrado.\n");

    return 0;
}

É importante ressaltar que o uso irrestrito de goto pode não ser considerado uma boa prática de programação em C, assim como em muitas outras linguagens. Em vez disso, é preferível utilizar estruturas de controle de fluxo mais claras e legíveis, como loops (for, while, do-while) e condicionais (if, else). O exemplo acima é apenas ilustrativo e não representa uma abordagem recomendada na maioria dos casos.

 

Exemplo em C#

Em C#, a linguagem também suporta o uso do comando goto, mas, assim como em outras linguagens, seu uso é deve ser muito bem avaliado devido aos possíveis impactos negativos na legibilidade e manutenção do código. Abaixo está um exemplo simples usando goto para simular um loop:

/****************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

****************************************************************************/
using System;

class Program
{
    static void Main()
    {
        // Inicialização
        int numero = 1;

        // Início do loop usando goto
        InicioDoLoop:
            Console.WriteLine("Número: " + numero);

            // Condição de saída do loop
            if (numero == 5)
                goto FimDoLoop;

            // Incremento do número
            numero++;

            // Ir para o início do loop
            goto InicioDoLoop;

        // Rótulo para o fim do loop
        FimDoLoop:
            Console.WriteLine("Loop encerrado.");

        // Aguarda que o usuário pressione Enter antes de fechar
        Console.ReadLine();
    }
}

Explicação

O código em C# que utilizei como exemplo utiliza o comando goto para criar um loop simples. Vamos explicar cada parte do código:

1. int numero = 1;: Inicializa a variável numero com o valor 1.
2. InicioDoLoop:: Rótulo que marca o início do loop.
3. Console.WriteLine("Número: " + numero);: Imprime o valor atual da variável numero.
4. if (numero == 5) goto FimDoLoop;: Verifica se o valor de numero é igual a 5. Se for, o programa salta para o rótulo FimDoLoop, encerrando o loop.
5. numero++;: Incrementa o valor da variável numero.
6. goto InicioDoLoop;: Salta de volta para o rótulo InicioDoLoop, reiniciando o loop.
7. FimDoLoop:: Rótulo indicando o fim do loop.
8. Console.WriteLine("Loop encerrado.");: Imprime uma mensagem indicando que o loop foi encerrado.
9. Console.ReadLine();: Aguarda que o usuário pressione Enter antes de fechar o programa.

Este exemplo utiliza goto para criar um loop que imprime os números de 1 a 5 e, em seguida, exibe uma mensagem indicando que o loop foi encerrado. No entanto, vale ressaltar que este exemplo é apenas ilustrativo.

 

Conclusão

Em resumo pessoal, o comando goto é uma ferramenta poderosa, no entanto, deve ser utilizada com cautela. Uma boa prática é priorizar estruturas de controle mais modernas e legíveis contribui para o desenvolvimento de código mais sustentável e de fácil manutenção.

 

Beleza pessoal? Espero que tenha ajudado.

 

Dúvidas ou sugestões? Deixe o seu comentário!

 

Um abraço e até o próximo post. Valeu!