Forma elegante para salir de una función cuidadosamente sin usar goto en C

Por ejemplo

void f()
{
    do
    {
         ...
         ...{..{... if(exit_cond) break; }..}..
         ...
    }  while ( 0 );

    some general work such as cleanup
}

O puede utilizar la siguiente estructura

while ( 1 )
{
   //...
}

La principal ventaja del enfoque estructural contrario al uso de sentencias goto es que introduce una disciplina en la escritura de código.

Estoy seguro y tengo suficiente experiencia de que si una función tiene una sentencia goto entonces a través de algún tiempo tendrá varias sentencias goto.:)

He visto muchas soluciones para hacer esto y tienden a ser oscuras, ilegibles y feas en algún grado.

Personalmente creo que la forma menos fea es esta:

int func (void)
{
  if(some_error)
  {
    cleanup();
    return result;
  }

  ...

  if(some_other_error)
  {
    cleanup();
    return result;
  }

  ...

  cleanup();
  return result;
}

Sí, utiliza dos filas de código en lugar de una. ¿Y? Es claro, legible, mantenible. Este es un ejemplo perfecto de donde tienes que luchar contra tus reflejos instintivos contra la repetición de código y usar el sentido común. La función de limpieza se escribe solo una vez, todo el código de limpieza está centralizado allí.

Creo que la pregunta es muy interesante, pero no puede ser respondida sin ser influenciada por la subjetividad porque la elegancia es subjetiva. Mis ideas al respecto son las siguientes: En general, lo que desea hacer en el escenario que describe, es evitar que control pase a través de una serie de instrucciones a lo largo de la ruta de ejecución. Otros idiomas harían esto levantando una excepción, que tendrías que atrapar.

Ya había escrito hacks limpios para hacer lo que quieras hacer con casi todas las declaraciones de control que hay en C, a veces en combinación, pero creo que todas son formas muy oscuras de expresar la idea de saltar a un punto especial. En su lugar, simplemente explicaré cómo llegamos a un punto donde goto puede ser preferible : Una vez más, lo que desea expresar es que ha ocurrido algo que impide seguir la ruta de ejecución regular. Algo que no es solo una condición regular que se puede manejar tomando un ramificación diferente en la ruta, pero algo hace imposible usar la ruta al punto de retorno regular de una manera segura en el estado actual. Creo que hay tres opciones para proceder en ese punto:

1. volver a través de una cláusula condicional
2. ir a una etiqueta de error
3. cada sentencia que podría fallar está dentro de una sentencia condicional, y la ejecución regular se considera una serie de operaciones condicionales.

Si su limpieza es similar lo suficiente en todas las salidas de emergencia posibles, preferiría el goto, porque escribir el código redundantemente solo desordena la función. Creo que deberías intercambiar el número de puntos de retorno y código de limpieza replicado que creas contra la incomodidad de usar un goto. Ambas soluciones deben ser aceptadas como una elección personal del programador, a menos que haya razones severas para no hacerlo, por ejemplo, usted acordó que todas las funciones deben tener una sola salida. Sin embargo, el uso de cualquiera de los dos debe ser consecuente y consistente a través del código. La tercera alternativa es-imo - el primo menos legible del goto, porque, al final se saltará a un conjunto de rutinas de limpieza - posiblemente encerrados por else-declaraciones también, pero hace que sea mucho más difícil para los seres humanos seguir el flujo regular de su programa, debido a la anidación profunda de las declaraciones condicionales.

Tl; dr: Creo que elegir entre retorno condicional y goto basado en decisiones de estilo consecuentes es lo más elegante manera, porque es la forma más expresiva de representar sus ideas detrás del código y la claridad es la elegancia.

^{Supongo que elegante puede significar para ti raro y que simplemente quieres evitar la palabra clave goto, así que....}

Podría considerar usar setjmp(3) y longjmp:

void foo() {
jmp_buf jb;
if (setjmp(jb) == 0) {
   some_stuff();
   //// etc...
   if (bad_thing() {
       longjmp(jb, 1);
   }
 };
};

No tengo idea si se ajusta a sus criterios de elegancia. (Creo que no es muy elegante, pero esto es solo una opinión ; sin embargo, no hay una goto explícita).

Sin embargo, lo interesante es que longjmp es un salto no local : Podrías haber pasado (indirectamente) jb a some_stuff y tener alguna otra rutina (por ejemplo, llamada por some_stuff) hacer el longjmp. Esto puede convertirse en código ilegible(así que coméntalo sabiamente).

Aún más feo que longjmp: use (en Linux) setcontext(3)

Lea acerca de continuacionesy excepciones (y la operación call/cc en Scheme).

Y por supuesto, el estándar exit(3) es una forma elegante (y útil) de salir de alguna función. A veces se puede jugar aseado truco también usando atexit(3)

POR cierto, el código del kernel de Linux utiliza bastante a menudo goto incluyendo en algún código que se considera elegante.

Mi punto es : IMHO no seas fanático contra goto-s ya que hay casos en los que usar (con cuidado) es de hecho elegante.

Soy fan de:

void foo(exp) 
{
    if(    ate_breakfast(exp)
        && tied_shoes(exp)
        && finished_homework(exp)
      )
    {
        good_to_go(exp);
    }
    else
    {
        fix_the_problems(exp);
    }
}

Donde ate_breakfast, tied_shoes, y finished_homework toman un puntero a exp en el que trabajan, y devuelven bools indicando un fallo de esa prueba en particular.

Ayuda recordar que la evaluación de cortocircuitos está trabajando aquí, lo que puede calificar como un olor a código para algunas personas, pero como todos los demás han estado diciendo, la elegancia es algo subjetiva.

La instrucción Goto nunca es necesaria, también es más fácil escribir código sin usarlo.

En su lugar, puede usar una función más limpia y regresar.

if(exit_cond) {
    clean_the_mess();
    return;
}

O puede romper como Vlad mencionado anteriormente. Pero un inconveniente de eso, si su bucle tiene una ruptura de estructura profundamente anidada solo saldrá del bucle más interno. Por ejemplo:

While ( exp ) {
    for (exp; exp; exp) {
        for (exp; exp; exp) {
            if(exit_cond) {
                clean_the_mess();
                break;
            }
        }
    }
}

Solo saldrá del bucle for interno y no abandonará el proceso.