Esse é um caso de uso decente para ir para C?

Eu realmente hesito em perguntar isso, porque não quero "solicitar debate, argumentos, sondagens ou discussão prolongada", mas sou novo em C e quero obter mais informações sobre os padrões comuns usados ​​na linguagem.

Recentemente, ouvi uma certa aversão ao gotocomando, mas também encontrei recentemente um caso de uso decente para ele.

Código como este:

error = function_that_could_fail_1();
if (!error) {
    error = function_that_could_fail_2();
    if (!error) {
        error = function_that_could_fail_3();
        ...to the n-th tab level!
    } else {
        // deal with error, clean up, and return error code
    }
} else {
    // deal with error, clean up, and return error code
}

Se a parte da limpeza for muito parecida, poderia ser escrito um pouco mais bonito (minha opinião?) Assim:

error = function_that_could_fail_1();
if(error) {
    goto cleanup;
}
error = function_that_could_fail_2();
if(error) {
    goto cleanup;
}
error = function_that_could_fail_3();
if(error) {
    goto cleanup;
}
...
cleanup:
// deal with error if it exists, clean up
// return error code

Esse é um caso de uso comum ou aceitável gotoem C? Existe uma maneira diferente / melhor de fazer isso?

A gotoinstrução (e seus rótulos correspondentes) são uma primitiva de controle de fluxo (junto com a execução condicional de uma instrução). Com isso, quero dizer que eles estão lá para permitir que você construa redes de controle de fluxo de programas. Você pode pensar neles como modelar as setas entre os nós de um fluxograma.

Alguns deles podem ser otimizados imediatamente, onde há um fluxo linear direto (você apenas usa uma sequência de instruções básicas). Outros padrões são melhor substituídos por construções de programação estruturada, quando disponíveis; se parecer um whileloop, use um whileloop , ok? Os padrões de programação estruturada são definitivamente pelo menos potencialmente mais claros de intenção do que uma bagunça de gotodeclarações.

No entanto, C não inclui todas as possíveis construções de programação estruturada. (Não está claro para mim que todos os relevantes já foram descobertos; a taxa de descoberta é lenta agora, mas eu hesitaria em dizer que todos foram encontrados.) Dos que conhecemos, C definitivamente não tem o try/ catch/ finallyestrutura (e também excepções). Também não possui vários níveis breakde loop. Esses são os tipos de coisas que gotopodem ser usados ​​para implementar. É possível usar outros esquemas para fazer isso também - sabemos que C possui um conjunto suficiente degotoprimitivas - mas geralmente envolvem a criação de variáveis ​​de flag e condições de loop ou guarda muito mais complexas; aumentar o emaranhado da análise de controle com a análise de dados dificulta a compreensão geral do programa. Isso também dificulta a otimização do compilador e a execução rápida da CPU (a maioria das construções de controle de fluxo - e definitivamente goto - é muito barata).

Portanto, embora você não deva usar a gotomenos que seja necessário, deve estar ciente de que ela existe e que pode ser necessária e, se você precisar, não deve se sentir muito mal. Um exemplo de caso em que é necessário é a desalocação de recursos quando uma função chamada retorna uma condição de erro. (Ou seja, try/ finally.) É possível escrever que, sem gotofazer isso, pode haver desvantagens próprias, como os problemas de manutenção. Um exemplo do caso:

int frobnicateTheThings() {
    char *workingBuffer = malloc(...);
    int i;

    for (i=0 ; i<numberOfThings ; i++) {
        if (giveMeThing(i, workingBuffer) != OK)
            goto error;
        if (processThing(workingBuffer) != OK)
            goto error;
        if (dispatchThing(i, workingBuffer) != OK)
            goto error;
    }

    free(workingBuffer);
    return OK;

  error:
    free(workingBuffer);
    return OOPS;
}

O código pode ser ainda mais curto, mas é suficiente para demonstrar o ponto.

Sim.

É usado, por exemplo, no kernel do linux. Aqui está um email do final de um tópico de quase uma década atrás , destacando o meu:

De: Robert Love
Assunto: Re: alguma chance de 2.6.0-test *?
Data: 12 de janeiro de 2003 17:58:06 -0500

No domingo, 12/01/2003 às 17:22, Rob Wilkens escreveu:

Eu digo "por favor, não use goto" e, em vez disso, tenha uma função "cleanup_lock" e adicione-a antes de todas as instruções de retorno. Não deve ser um fardo. Sim, está pedindo ao desenvolvedor que trabalhe um pouco mais, mas o resultado final é um código melhor.

Não, é nojento e incha o kernel . Ele destaca um monte de lixo eletrônico para N caminhos de erro, em vez de ter o código de saída uma vez no final. A pegada de cache é a chave e você acabou de matá-la.

Nem é mais fácil de ler.

Como argumento final, ele não nos permite executar de maneira limpa o vento usual do tipo pilha e relaxar , ou seja,

        do A
        if (error)
            goto out_a;
        do B
        if (error)
            goto out_b;
        do C
        if (error)
            goto out_c;
        goto out;
        out_c:
        undo C
        out_b:
        undo B:
        out_a:
        undo A
        out:
        return ret;

Agora pare com isso.

Robert Love

Dito isso, requer muita disciplina para não criar código espaguete depois que você se acostumar a usar o goto; portanto, a menos que você esteja escrevendo algo que exija velocidade e pouco espaço na memória (como um kernel ou sistema incorporado), você realmente deve pense nisso antes de escrever o primeiro passo.

Na minha opinião, o código que você postou é um exemplo de uso válido goto, porque você apenas pula para baixo e o usa como um manipulador de exceção primitivo.

No entanto , por causa do velho debate sobre o goto, os programadores evitam gotohá cerca de 40 anos e, portanto, não são usados ​​para ler código com o goto. Esta é uma razão válida para evitar ir para lá: simplesmente não é o padrão.

Eu teria reescrito o código como algo mais facilmente lido pelos programadores em C:

Error some_func (void)
{
  Error error;
  type_t* resource = malloc(...);

  error = some_other_func (resource);

  free (resource);

  /* error handling can be placed here, or it can be returned to the caller */

  return error;
}


Error some_other_func (type_t* resource)  // inline if needed
{
  error = function_that_could_fail_1();
  if(error)
  {
    return error;
  }

  /* ... */

  error = function_that_could_fail_2();
  if(error)
  {
    return error;
  }

  /* ... */

  return ok;
}

Vantagens deste projeto:

• A função que está realizando o trabalho real não precisa se preocupar com tarefas irrelevantes para seu algoritmo, como alocar dados.
• O código parecerá menos estranho para os programadores C, uma vez que eles têm medo de ir para rótulos e etiquetas.
• Você pode centralizar o tratamento e a desalocação de erros no mesmo local, fora da função que executa o algoritmo. Não faz sentido para uma função lidar com seus próprios resultados.

Um artigo famoso que descreve o caso de uso válido de foi o Structured Programming with GOTO Statement, de Donald E. Knuth (Universidade de Stanford). O artigo apareceu nos dias em que o uso do GOTO era considerado pecado por alguns e quando o movimento para a Programação Estruturada estava no auge. Você pode dar uma olhada no GoTo Considerado Prejudicial.

Em Java, você faria assim:

makeCalls:  {
    error = function_that_could_fail_1();
    if (error) {
        break makeCalls;
    }
    error = function_that_could_fail_2();
    if (error) {
        break makeCalls;
    }
    error = function_that_could_fail_3();
    if (error) {
        break makeCalls;
    }
    ...
    return 0;  // No error code.
}
// deal with error if it exists, clean up
// return error code

Eu uso muito isso. Por mais que eu não gotogoste, na maioria das outras linguagens de estilo C, uso seu código; não há outra boa maneira de fazer isso. (Saltar de loops aninhados é um caso semelhante; em Java, uso um rotulado breake em qualquer outro lugar em que uso um goto.)

Eu acho que é um caso de uso decente, mas no caso de "erro" nada mais é que um valor booleano, há uma maneira diferente de realizar o que você deseja:

error = function_that_could_fail_1();
error = error || function_that_could_fail_2();
error = error || function_that_could_fail_3();
if(error)
{
     // do cleanup
}

Isso faz uso da avaliação de curto-circuito de operadores booleanos. Se isso "melhor", depende do seu gosto pessoal e de como você está acostumado a esse idioma.

O guia de estilo linux fornece razões específicas para o uso de gotoacordo com o seu exemplo:

https://www.kernel.org/doc/Documentation/process/coding-style.rst

A lógica para usar gotos é:

• declarações incondicionais são mais fáceis de entender e seguir
• aninhamento é reduzido
• erros ao não atualizar pontos de saída individuais ao impedir modificações
• salva o trabalho do compilador para otimizar o código redundante;)

Isenção de responsabilidade Não devo compartilhar meu trabalho. Os exemplos aqui são um pouco inventados, então tenha paciência comigo.

Isso é bom para o gerenciamento de memória. Recentemente, trabalhei em códigos que alocavam memória dinamicamente (por exemplo, um char *retornado por uma função). Uma função que analisa um caminho e verifica se o caminho é válido analisando os tokens do caminho:

tmp_string = strdup(string);
token = strtok(tmp_string,delim);
while( token != NULL ){
    ...
    some statements, some involving dynamically allocated memory
    ...
    if ( check_this() ){
        free(var1);
        free(var2);
        ...
        free(varN);
        return 1;
    }
    ...
    some more stuff
    ...
    if(something()){
        if ( check_that() ){
            free(var1);
            free(var2);
            ...
            free(varN);
            return 1;
        } else {
            free(var1);
            free(var2);
            ...
            free(varN);
            return 0;
        }
    }
    token = strtok(NULL,delim);
}

free(var1);
free(var2);
...
free(varN);
return 1;

Agora, para mim, o código a seguir é muito melhor e mais fácil de manter, se você precisar adicionar um varNplus1:

int retval = 1;
tmp_string = strdup(string);
token = strtok(tmp_string,delim);
while( token != NULL ){
    ...
    some statements, some involving dynamically allocated memory
    ...
    if ( check_this() ){
        retval = 1;
        goto out_free;
    }
    ...
    some more stuff
    ...
    if(something()){
        if ( check_that() ){
            retval = 1;
            goto out_free;
        } else {
            retval = 0;
            goto out_free;
        }
    }
    token = strtok(NULL,delim);
}

out_free:
free(var1);
free(var2);
...
free(varN);
return retval;

Agora, o código tinha todos os tipos de problemas com ele, ou seja, N estava acima de 10, e a função tinha mais de 450 linhas, com 10 níveis de aninhamento em alguns lugares.

Mas eu ofereci ao meu supervisor para refatorá-lo, o que eu fiz e agora são várias funções curtas, e todas elas têm o estilo linux

int function(const char * param)
{
    int retval = 1;
    char * var1 = fcn_that_returns_dynamically_allocated_string(param);
    if( var1 == NULL ){
        retval = 0;
        goto out;
    }

    if( isValid(var1) ){
         retval = some_function(var1);
         goto out_free;
    }

    if( isGood(var1) ){
         retval = 0;
         goto out_free;
    }

out_free:
    free(var1);
out:
    return retval;
}

Se considerarmos o equivalente sem gotos:

int function(const char * param)
{
    int retval = 1;
    char * var1 = fcn_that_returns_dynamically_allocated_string(param);
    if( var1 != NULL ){

       if( isValid(var1) ){
            retval = some_function(var1);
       } else {
          if( isGood(var1) ){
               retval = 0;
          }
       }
       free(var1);

    } else {
       retval = 0;
    }

    return retval;
}

Para mim, no primeiro caso, é óbvio para mim que, se a primeira função retornar NULL, estaremos fora daqui e voltaremos 0. No segundo caso, eu tenho que rolar para baixo para ver que o if contém toda a função. Concedido o primeiro indica isso estilisticamente (o nome " out") e o segundo faz sintaticamente. O primeiro é ainda mais óbvio.

Além disso, eu prefiro ter free()instruções no final de uma função. Isso ocorre em parte porque, na minha experiência, as free()declarações no meio de funções cheiram mal e indicam para mim que eu deveria criar uma sub-rotina. Nesse caso, eu criei var1em minha função e não free()consegui em uma sub-rotina, mas é por isso que o goto out_freeestilo de sair é tão prático.

Eu acho que os programadores precisam ser educados acreditando que gotosão maus. Então, quando estiverem maduros o suficiente, devem procurar o código fonte do Linux e ler o guia de estilo do Linux.

Devo acrescentar que uso esse estilo de maneira muito consistente, toda função tem um int retval, um out_freelabel e um out label. Devido à consistência estilística, a legibilidade é aprimorada.

Bônus: quebra e continua

Digamos que você tenha um loop while

char *var1, *var2;
char line[MAX_LINE_LENGTH];
while( sscanf(line,... ){
    var1 = functionA(line,count);
    var2 = functionB(line,count);

    if( functionC(var1, var2){
         count++
         continue;
    }

    ...
    a bunch of statements
    ...

    count++;
    free(var1);
    free(var2);
}

Há outras coisas erradas nesse código, mas uma coisa é a instrução continue. Eu gostaria de reescrever a coisa toda, mas fui encarregado de modificá-la em um pequeno caminho. Levaria dias para refatorá-lo de uma maneira que me satisfizesse, mas a mudança real foi de cerca de meio dia de trabalho. O problema é que, mesmo se nós ' continue' ainda precisamos libertar var1e var2. Eu tive que adicionar um var3, e isso me fez querer vomitar ter que espelhar as declarações free ().

Eu era um estagiário relativamente novo na época, mas estava olhando o código-fonte do Linux há algum tempo, então perguntei ao meu supervisor se eu poderia usar uma declaração goto. Ele disse que sim, e eu fiz isso:

char *var1, *var2;
char line[MAX_LINE_LENGTH];
while( sscanf(line,... ){
    var1 = functionA(line,count);
    var2 = functionB(line,count);
    var3 = newFunction(line,count);

    if( functionC(var1, var2){
         goto next;
    }

    ...
    a bunch of statements
    ...
next:
    count++;
    free(var1);
    free(var2);
}

Eu acho que continua bom, na melhor das hipóteses, mas para mim eles são como um goto com uma etiqueta invisível. O mesmo vale para pausas. Eu ainda preferiria continuar ou interromper, a menos que, como foi o caso aqui, o force a espelhar modificações em vários lugares.

E devo acrescentar que esse uso goto next;e o next:rótulo são insatisfatórios para mim. Eles são meramente melhores do que espelhar o free()'s e as count++declarações.

gotoQuase sempre estão errados, mas é preciso saber quando eles são bons de usar.

Uma coisa que não discuti é o tratamento de erros, coberto por outras respostas.

atuação

Pode-se observar a implementação de strtok () http://opensource.apple.com//source/Libc/Libc-167/string.subproj/strtok.c

#include <stddef.h>
#include <string.h>

char *
strtok(s, delim)
    register char *s;
    register const char *delim;
{
    register char *spanp;
    register int c, sc;
    char *tok;
    static char *last;


    if (s == NULL && (s = last) == NULL)
        return (NULL);

    /*
     * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
     */
cont:
    c = *s++;
    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
        if (c == sc)
            goto cont;
    }

    if (c == 0) {       /* no non-delimiter characters */
        last = NULL;
        return (NULL);
    }
    tok = s - 1;

    /*
     * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
     * Note that delim must have one NUL; we stop if we see that, too.
     */
    for (;;) {
        c = *s++;
        spanp = (char *)delim;
        do {
            if ((sc = *spanp++) == c) {
                if (c == 0)
                    s = NULL;
                else
                    s[-1] = 0;
                last = s;
                return (tok);
            }
        } while (sc != 0);
    }
    /* NOTREACHED */
}

Por favor, corrija-me se estiver errado, mas acredito que o cont:rótulo e a goto cont;declaração existem para desempenho (eles certamente não tornam o código mais legível). Eles podem ser substituídos por código legível fazendo

while( isDelim(*s++,delim));

pular delimitadores. Mas, para ser o mais rápido possível e evitar chamadas de função desnecessárias, elas fazem dessa maneira.

Eu li o jornal de Dijkstra e acho bastante esotérico.

google "dijkstra goto declaração considerada prejudicial" porque não tenho reputação suficiente para postar mais de 2 links.

Eu o vi citado como uma razão para não usar o goto e a leitura dele não mudou nada, na medida em que meus usos do goto são considerados.

Adendo :

Eu criei uma regra clara enquanto pensava em tudo isso sobre continuações e interrupções.

• Se em um loop while, você tem uma continuação, o corpo do loop while deve ser uma função e a continuação uma declaração de retorno.
• Se em um loop while, você possui uma instrução break, o próprio loop while deve ser uma função e a interrupção deve se tornar uma declaração de retorno.
• Se você tiver os dois, algo pode estar errado.

Nem sempre é possível devido a problemas de escopo, mas descobri que isso facilita muito o raciocínio sobre meu código. Eu havia notado que sempre que um loop de tempo interrompia ou continuava, isso me dava um mau pressentimento.

Pessoalmente, eu refatoraria isso mais ou menos assim:

int DoLotsOfStuffThatCouldFail (paramstruct *params)
{
    int errcode = EC_NOERROR;

    if ((errcode = FunctionThatCouldFail1 (params)) != EC_NOERROR) return errcode;
    if ((errcode = FunctionThatCouldFail2 (params)) != EC_NOERROR) return errcode;
    if ((errcode = FunctionThatCouldFail3 (params)) != EC_NOERROR) return errcode;
    if ((errcode = FunctionThatCouldFail4 (params)) != EC_NOERROR) return errcode;

    return EC_NOERROR;
}

void DoStuff (paramstruct *params)
{
    int errcode = EC_NOERROR;

    InitStuffThatMayNeedToBeCleaned (params);

    if ((errcode = DoLotsOfStuffThatCouldFail (params)) != EC_NOERROR)
    {
         CleanupAfterError (params, errcode);
    }
}

Isso seria mais motivado ao evitar o aninhamento profundo do que evitar o goto (no entanto, o IMO é um problema pior com o primeiro exemplo de código) e, é claro, dependeria da possibilidade de CleanupAfterError estar fora do escopo (neste caso, "parâmetros" seja uma estrutura contendo alguma memória alocada que você precisa liberar, um ARQUIVO * que você precisa fechar ou o que for).

Uma grande vantagem que vejo com essa abordagem é que é mais fácil e mais limpo dividir uma etapa extra hipotética futura entre, digamos, FTCF2 e FTCF3 (ou remover uma etapa atual existente), para que ela se melhore melhor com a manutenção (e a pessoa que herda meu código, não querendo me linchar!) - vá para o lado, a versão aninhada não tem isso.

Dê uma olhada nas diretrizes de codificação C da MISRA (Motor Industry Software Reliability Association) que permitem ir sob critérios rígidos (que seu exemplo atende)

Onde eu trabalho, o mesmo código seria escrito - não é preciso ir - Evitar um debate religioso desnecessário sobre eles é uma grande vantagem em qualquer software house.

error = function_that_could_fail_1();
if(!error) {
  error = function_that_could_fail_2();
}
if(!error) {
  error = function_that_could_fail_3();
} 
if(!error) {
...
if (error) {
  cleanup:
} 

ou para "goto in drag" - algo ainda mais desonesto do que goto, mas contorna o "No goto ever !!!" acampamento) "Certamente deve estar OK, não usa Goto" ....

do {
  if (error = function_that_could_fail_1() ){
    break 
  }
  if (error = function_that_could_fail_2() ){
    break 
  }
  ....... 
} while (0) 
cleanup();
.... 

Se as funções tiverem o mesmo tipo de parâmetro, coloque-as em uma tabela e use um loop -

Também uso gotose o do/while/continue/breakhackery alternativo seria menos legível.

gotos têm a vantagem de seus alvos terem um nome e lerem goto something;. Isso pode ser mais legível do que breakou continuese você não está realmente parando ou continuando alguma coisa.

for (int y=0; y<height; ++y) {
    for (int x=0; x<width; ++x) {
        if (find(x, y)) goto found;
    }
}
found:

Sempre haverá campos que dizem que uma maneira é aceitável e outra que não é. As empresas para as quais trabalhei desaprovaram ou fortemente desencorajaram o uso. Pessoalmente, não consigo pensar em nenhum momento em que usei um, mas isso não significa que eles sejam ruins , apenas outra maneira de fazer as coisas.

Em C, normalmente faço o seguinte:

• Teste as condições que podem impedir o processamento (entradas incorretas, etc.) e "retornar"
• Execute todas as etapas que requerem alocação de recursos (por exemplo, mallocs)
• Execute o processamento, onde várias etapas verificam o sucesso
• Libere quaisquer recursos, se alocados com êxito
• Retornar quaisquer resultados

Para o processamento, usando seu exemplo goto, eu faria o seguinte:

error = function_that_could_fail_1 (); if (! error) {error = function_that_could_fail_2 (); } if (! error) {error = function_that_could_fail_3 (); }

Não há aninhamento e, dentro das cláusulas if, você pode fazer qualquer relatório de erros, se a etapa gerar um erro. Portanto, não precisa ser "pior" do que um método usando gotos.

Eu ainda tenho que me deparar com um caso em que alguém tem gotos que não podem ser feitos com outro método e é tão legível / compreensível e essa é a chave, IMHO.