¿Es este un caso de uso decente para ir a C?

Realmente dudo en preguntar esto, porque no quiero "solicitar debates, argumentos, encuestas o discusiones extendidas", pero soy nuevo en C y quiero obtener más información sobre los patrones comunes utilizados en el lenguaje.

Recientemente escuché cierto desagrado por el gotocomando, pero también recientemente encontré un caso de uso decente para él.

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
}

Si la parte de limpieza es muy similar, podría escribirse un poco más bonita (¿mi opinión?) Así:

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

¿Es este un caso de uso común o aceptable de gotoen C? ¿Hay una manera diferente / mejor de hacer esto?

La gotodeclaración (y sus etiquetas correspondientes) son una primitiva de control de flujo (junto con la ejecución condicional de una declaración). Con eso quiero decir que están allí para permitirle construir redes de control de flujo de programas. Puede pensar en ellos como modelos de las flechas entre los nodos de un diagrama de flujo.

Algunos de estos pueden optimizarse de inmediato, donde hay un flujo lineal directo (solo usa una secuencia de declaraciones básicas). Otros patrones se reemplazan mejor con construcciones de programación estructurada donde están disponibles; si parece un whilebucle, use un whilebucle , ¿de acuerdo? Los patrones de programación estructurados son definitivamente al menos potencialmente más claros de intención que un desorden de gotodeclaraciones.

Sin embargo, C no incluye todas las posibles construcciones de programación estructurada. (No está claro para mí que todos los relevantes hayan sido descubiertos todavía; la tasa de descubrimiento es lenta ahora, pero dudaría en decir que se han encontrado todos). De los que sabemos, C definitivamente carece del try/ catch/ finallyestructura (y excepciones también). También carece de múltiples niveles breakde bucle. Estos son los tipos de cosas que gotose pueden usar para implementar. Es posible usar otros esquemas para hacer esto también: sabemos que C tiene un conjunto suficiente degotoprimitivas, pero a menudo implican la creación de variables de bandera y condiciones de protección o bucle mucho más complejas; aumentar el enredo del análisis de control con el análisis de datos hace que el programa sea más difícil de entender en general. También hace que sea más difícil para el compilador optimizar y que la CPU se ejecute rápidamente (la mayoría de las construcciones de control de flujo, y definitivamente goto , son muy baratas).

Por lo tanto, aunque no debe usarlo a gotomenos que sea necesario, debe tener en cuenta que existe y que puede ser necesario, y si lo necesita, no debe sentirse tan mal. Un ejemplo de un caso en el que se necesita es la desasignación de recursos cuando una función llamada devuelve una condición de error. (Es decir, try/ finally.) Es posible escribir eso sin gotohacerlo, pero hacerlo puede tener sus propios inconvenientes, como los problemas de mantenimiento. Un ejemplo del 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;
}

El código podría ser aún más corto, pero es suficiente para demostrar el punto.

Si.

Se usa, por ejemplo, en el kernel de Linux. Aquí hay un correo electrónico del final de un hilo de hace casi una década , en negrita:

De: Robert Love
Asunto: Re: ¿alguna posibilidad de 2.6.0-test *?
Fecha: 12 de enero de 2003 17:58:06 -0500

El domingo, 12 de enero de 2003 a las 17:22, Rob Wilkens escribió:

Digo "por favor no use goto" y en su lugar tenga una función "cleanup_lock" y agregue eso antes de todas las declaraciones de devolución. No debería ser una carga. Sí, le está pidiendo al desarrollador que trabaje un poco más duro, pero el resultado final es un mejor código.

No, es asqueroso e hincha el núcleo . Incluye un montón de basura para N rutas de error, en lugar de tener el código de salida una vez al final. La huella del caché es clave y la acabas de matar.

Tampoco es más fácil de leer.

Como argumento final, no nos permite limpiar y desenrollar de manera limpia el estilo habitual de la pila , es decir

        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;

Ahora detén esto.

Robert Love

Dicho esto, se requiere mucha disciplina para evitar crear código de espagueti una vez que se acostumbra a usar goto, por lo que, a menos que esté escribiendo algo que requiera velocidad y poca huella de memoria (como un núcleo o un sistema incrustado), realmente debería piénselo antes de escribir el primer goto.

En mi opinión, el código que publicó es un ejemplo de un uso válido de goto, porque solo salta hacia abajo y solo lo usa como un controlador de excepciones primitivo.

Sin embargo , debido al antiguo debate de goto, los programadores han estado evitando gotodurante unos 40 años y, por lo tanto, no están acostumbrados a leer código con goto. Esta es una razón válida para evitar el goto: simplemente no es el estándar.

Hubiera reescrito el código como algo más fácil de leer por los programadores de 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;
}

Ventajas de este diseño:

• La función que realiza el trabajo real no necesita ocuparse de tareas que son irrelevantes para su algoritmo, como la asignación de datos.
• El código se verá menos extraño para los programadores de C, ya que tienen miedo de ir a las etiquetas.
• Puede centralizar el manejo de errores y la desasignación en el mismo lugar, fuera de la función que realiza el algoritmo. No tiene sentido que una función maneje sus propios resultados.

Un famoso artículo que describe un caso de uso válido fue la Programación Estructurada con Declaración GOTO de Donald E. Knuth (Universidad de Stanford). El documento apareció en los días en que el uso de GOTO era considerado un pecado por algunos y cuando el movimiento para la Programación Estructurada estaba en su apogeo. Es posible que desee echar un vistazo a GoTo Considerado nocivo.

En Java lo harías así:

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

Yo uso esto mucho. Por mucho que no me guste goto, en la mayoría de los otros lenguajes de estilo C utilizo su código; No hay otra buena manera de hacerlo. (Saltar de bucles anidados es un caso similar; en Java utilizo una etiqueta breaky en todas partes utilizo a goto.)

Creo que es un caso de uso decente, pero en caso de que "error" no sea más que un valor booleano, hay una forma diferente de lograr lo que desea:

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

Esto hace uso de la evaluación de cortocircuito de operadores booleanos. Si esto "mejor", depende de su gusto personal y de cómo está acostumbrado a ese idioma.

La guía de estilo de Linux proporciona razones específicas para usar gotolas que están en línea con su ejemplo:

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

La razón para usar gotos es:

• las declaraciones incondicionales son más fáciles de entender y seguir
• la anidación se reduce
• errores al no actualizar los puntos de salida individuales cuando se evitan las modificaciones
• guarda el trabajo del compilador para optimizar el código redundante de distancia;)

Descargo de responsabilidad Se supone que no debo compartir mi trabajo. Los ejemplos aquí son un poco artificiales, así que tengan paciencia, tengan paciencia conmigo.

Esto es bueno para la gestión de la memoria. Recientemente trabajé en código que tenía memoria asignada dinámicamente (por ejemplo, un char *devuelto por una función). Una función que analiza una ruta y determina si la ruta es válida analizando los tokens de la ruta:

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;

Ahora para mí, el siguiente código es mucho mejor y más fácil de mantener si necesita agregar un 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;

Ahora el código tenía todo tipo de otros problemas, a saber, que N estaba en algún lugar por encima de 10, y la función tenía más de 450 líneas, con 10 niveles de anidamiento en algunos lugares.

Pero le ofrecí a mi supervisor que lo refactorizara, lo cual hice y ahora es un montón de funciones que son todas cortas, y todas tienen el 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;
}

Si consideramos el equivalente sin 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 mí, en el primer caso, es obvio para mí que si la primera función regresa NULL, nos vamos de aquí y volvemos 0. En el segundo caso, tengo que desplazarme hacia abajo para ver si el if contiene toda la función. De acuerdo, el primero me indica esto estilísticamente (el nombre " out") y el segundo lo hace sintácticamente. El primero es aún más obvio.

Además, prefiero tener free()declaraciones al final de una función. Esto se debe en parte a que, en mi experiencia, las free()declaraciones en el medio de las funciones huelen mal y me indican que debería crear una subrutina. En este caso, creé var1en mi función y no pude free()hacerlo en una subrutina, pero es por eso que el goto out_freeestilo de goto out es tan práctico.

Creo que los programadores necesitan ser educados creyendo que gotoson malos. Luego, cuando sean lo suficientemente maduros, deberían explorar el código fuente de Linux y leer la guía de estilo de Linux.

Debo agregar que uso este estilo de manera muy consistente, cada función tiene retvaluna out_freeetiqueta int , una etiqueta y una etiqueta de salida. Debido a la consistencia estilística, se mejora la legibilidad.

Bonus: se rompe y continúa

Digamos que tienes un ciclo 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);
}

Hay otras cosas mal con este código, pero una cosa es la declaración de continuación. Me gustaría reescribir todo el asunto, pero me encargaron modificarlo de una manera pequeña. Me habría llevado días refactorizarlo de una manera que me satisficiera, pero el cambio real fue aproximadamente medio día de trabajo. El problema es que incluso si nosotros ' continue' todavía necesitamos liberarnos var1y var2. Tuve que agregar un var3, y me hizo querer vomitar tener que reflejar las declaraciones free ().

Era un pasante relativamente nuevo en ese momento, pero había estado mirando el código fuente de Linux por diversión hace un tiempo, así que le pregunté a mi supervisor si podía usar una declaración goto. Él dijo que sí, e hice esto:

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);
}

Creo que las continuas están bien en el mejor de los casos, pero para mí son como un goto con una etiqueta invisible. Lo mismo ocurre con los descansos. Todavía preferiría continuar o interrumpir a menos que, como fue el caso aquí, te obligue a reflejar modificaciones en varios lugares.

Y también debo agregar que este uso goto next;y la next:etiqueta no me satisfacen. Son simplemente mejores que reflejar los free()'sy las count++declaraciones.

gotoCasi siempre están equivocados, pero uno debe saber cuándo son buenos para usar.

Una cosa que no discutí es el manejo de errores que ha sido cubierto por otras respuestas.

Actuación

Se puede ver la implementación 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 */
}

Corríjame si me equivoco, pero creo que la cont:etiqueta y la goto cont;declaración están ahí para el rendimiento (seguramente no hacen que el código sea más legible). Podrían ser reemplazados con código legible haciendo

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

omitir delimitadores. Pero para ser lo más rápido posible y evitar llamadas a funciones innecesarias, lo hacen de esta manera.

Leí el periódico de Dijkstra y lo encuentro bastante esotérico.

google "declaración de dijkstra goto considerada dañina" porque no tengo suficiente reputación para publicar más de 2 enlaces.

Lo he visto citado como una razón para no usar goto's y leerlo no ha cambiado nada en lo que respecta a mis usos de goto's.

Anexo :

Se me ocurrió una regla clara mientras pensaba en todo esto sobre continuos y descansos.

• Si en un ciclo while, tiene una continuación, entonces el cuerpo del ciclo while debe ser una función y la continuación debe ser una declaración de retorno.
• Si en un ciclo while, tiene una instrucción break, entonces el ciclo while en sí mismo debería ser una función y el break debería convertirse en una declaración return.
• Si tiene ambos, entonces algo podría estar mal.

No siempre es posible debido a problemas de alcance, pero he descubierto que hacer esto hace que sea mucho más fácil razonar sobre mi código. Me di cuenta de que cada vez que un ciclo while se interrumpía o continuaba, me daba un mal presentimiento.

Personalmente lo refactorizaría más así:

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);
    }
}

Sin embargo, eso estaría más motivado por evitar el anidamiento profundo que evitar el goto (en mi opinión, un problema peor con el primer ejemplo de código) y, por supuesto, dependería de que CleanupAfterError esté fuera de alcance (en este caso, los "params" podrían puede ser una estructura que contiene memoria asignada que necesita liberar, un ARCHIVO * que necesita cerrar o lo que sea).

Una de las principales ventajas que veo con este enfoque es que es más fácil y más limpio ubicar un hipotético paso adicional futuro entre, por ejemplo, FTCF2 y FTCF3 (o eliminar un paso actual existente), por lo que se presta mejor para la mantenibilidad (y la persona que hereda mi código que no quiere lincharme!) - a un lado, la versión anidada carece de eso.

Eche un vistazo a las pautas de codificación C de MISRA (Motor Industry Software Reliability Association) que permiten ir a criterios estrictos (que cumple su ejemplo)

Donde trabajo, se escribiría el mismo código, sin necesidad de ir a Goto. Evitar debates religiosos innecesarios sobre ellos es una gran ventaja en cualquier casa de software.

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:
} 

o para "goto in drag" - algo aún más dudoso que goto, pero evita el "No goto Ever !!!" campamento) "Seguramente debe estar bien, no usa Goto" ....

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

Si las funciones tienen el mismo tipo de parámetro, colóquelas en una tabla y use un bucle:

También uso gotosi la do/while/continue/breakpiratería alternativa sería menos legible.

gotos tienen la ventaja de que sus objetivos tienen un nombre y leen goto something;. Esto puede ser más legible que breako continuesi realmente no está deteniendo o continuando algo.

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

Siempre habrá campamentos que dicen que una forma es aceptable y otra que no. Las empresas para las que he trabajado han desaprobado o desaconsejado el uso de goto. Personalmente, no puedo pensar en ningún momento en que haya usado uno, pero eso no significa que sean malos , solo otra forma de hacer las cosas.

En C, normalmente hago lo siguiente:

• Pruebe las condiciones que podrían impedir el procesamiento (entradas incorrectas, etc.) y el "retorno"
• Realice todos los pasos que requieren la asignación de recursos (por ejemplo, mallocs)
• Realice el procesamiento, donde múltiples pasos verifican el éxito
• Libere cualquier recurso, si se asigna correctamente
• Devolver cualquier resultado

Para el procesamiento, usando su ejemplo goto, haría esto:

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

No hay anidamiento, y dentro de las cláusulas if, puede hacer cualquier informe de error, si el paso generó un error. Por lo tanto, no tiene que ser "peor" que un método con gotos.

Todavía tengo que encontrarme con un caso en el que alguien tiene problemas que no se pueden hacer con otro método y es tan legible / comprensible y esa es la clave, en mi humilde opinión.