Ejemplos de buenas goto en C o C++ [cerrado]

La necesidad clásica de GOTO en C es la siguiente

for ...
  for ...
    if(breakout_condition) 
      goto final;

final:

No hay una manera directa de romper los bucles anidados sin un goto.

Aquí está mi ejemplo no tonto, (de Stevens APITUE) para llamadas al sistema Unix que pueden ser interrumpidas por una señal.

restart:
    if (system_call() == -1) {
        if (errno == EINTR) goto restart;

        // handle real errors
    }

La alternativa es un bucle degenerado. Esta versión se lee como en inglés "if the system call was interrupted by a signal, restart it".

Si el dispositivo de Duff no necesita un goto, ¡entonces tú tampoco deberías! ;)

void dsend(int count) {
    int n;
    if (!count) return;
    n = (count + 7) / 8;
    switch (count % 8) {
      case 0: do { puts("case 0");
      case 7:      puts("case 7");
      case 6:      puts("case 6");
      case 5:      puts("case 5");
      case 4:      puts("case 4");
      case 3:      puts("case 3");
      case 2:      puts("case 2");
      case 1:      puts("case 1");
                 } while (--n > 0);
    }
}

Código anterior de Wikipedia entrada .

Knuth ha escrito un documento "Programación estructurada con instrucciones GOTO", puede obtenerlo, por ejemplo, desde aquí. Encontrarás muchos ejemplos allí.

Muy frecuentes.

do_stuff(thingy) {
    lock(thingy);

    foo;
    if (foo failed) {
        status = -EFOO;
        goto OUT;
    }

    bar;
    if (bar failed) {
        status = -EBAR;
        goto OUT;
    }

    do_stuff_to(thingy);

OUT:
    unlock(thingy);
    return status;
}

El único caso que uso goto es para saltar hacia adelante, generalmente fuera de bloques, y nunca dentro de bloques. Esto evita el abuso de do{}while(0) y otras construcciones que aumentan el anidamiento, mientras se mantiene el código legible y estructurado.

No tengo nada en contra de gotos en general, pero puedo pensar en varias razones por las que no querrías usarlos para un bucle como mencionaste:

• No limita el alcance, por lo tanto, cualquier variable temporal que use dentro no se liberará hasta más tarde.
• No limita el alcance, por lo que podría conducir a errores.
• No limita el ámbito, por lo que no puede reutilizar los mismos nombres de variable más adelante en el código futuro en el mismo ámbito.
• No limita el alcance, por lo tanto, tiene la posibilidad de saltarse una declaración de variable.
• La gente no está acostumbrada a ello y hará que tu código sea más difícil de leer.
• Los bucles anidados de este tipo pueden conducir al código spaghetti, los bucles normales no conducirán al código spaghetti.

Un buen lugar para usar un goto es en un procedimiento que puede abortar en varios puntos, cada uno de los cuales requiere varios niveles de limpieza. Gotophobes siempre puede reemplazar el goto con código estructurado y una serie de pruebas, pero creo que esto es más sencillo porque elimina la sangría excesiva:

if (!openDataFile())
  goto quit;

if (!getDataFromFile())
  goto closeFileAndQuit;

if (!allocateSomeResources)
  goto freeResourcesAndQuit;

// Do more work here....

freeResourcesAndQuit:
   // free resources
closeFileAndQuit:
   // close file
quit:
   // quit!

@fizzer.myopenid.com: su fragmento de código publicado es equivalente a lo siguiente:

    while (system_call() == -1)
    {
        if (errno != EINTR)
        {
            // handle real errors

            break;
        }
    }

Definitivamente prefiero esta forma.

A pesar de que he llegado a odiar este patrón con el tiempo, está integrado en la programación COM.

#define IfFailGo(x) {hr = (x); if (FAILED(hr)) goto Error}
...
HRESULT SomeMethod(IFoo* pFoo) {
  HRESULT hr = S_OK;
  IfFailGo( pFoo->PerformAction() );
  IfFailGo( pFoo->SomeOtherAction() );
Error:
  return hr;
}

Aquí hay un ejemplo de un buen goto:

// No Code

He visto que goto se usa correctamente, pero las situaciones son normalmente feas. Es solo cuando el uso de goto en sí es mucho menos peor que el original. @Johnathon Holland el poblem es tu versión es menos claro. la gente parece tener miedo de las variables locales:

void foo()
{
    bool doAsuccess = doA();
    bool doBsuccess = doAsuccess && doB();
    bool doCsuccess = doBsuccess && doC();

    if (!doCsuccess)
    {
        if (doBsuccess)
            undoB();
        if (doAsuccess)
            undoA();
    }
}

Y yo prefiero bucles como este, pero algunas personas prefieren while(true).

for (;;)
{
    //code goes here
}

Mi queja sobre esto es que se pierde el alcance de bloque; cualquier variable local declarada entre los goto permanece en vigor si el bucle se rompe alguna vez. (Tal vez estás asumiendo que el bucle se ejecuta para siempre; no creo que eso sea lo que el escritor de la pregunta original estaba preguntando, sin embargo.)

El problema del alcance es más un problema con C++, ya que algunos objetos pueden estar dependiendo de que su dtor sea llamado en momentos apropiados.

Para mí, la mejor razón para usar goto es durante un paso múltiple proceso de inicialización donde es vital que todos los inits se retiren si uno falla, a la:

if(!foo_init())
  goto bye;

if(!bar_init())
  goto foo_bye;

if(!xyzzy_init())
  goto bar_bye;

return TRUE;

bar_bye:
 bar_terminate();

foo_bye:
  foo_terminate();

bye:
  return FALSE;

Yo mismo no uso goto, sin embargo, trabajé con una persona una vez que los usaría en casos específicos. Si no recuerdo mal, su razonamiento estaba en torno a los problemas de rendimiento-también tenía reglas específicas para cómo . Siempre en la misma función, y la etiqueta siempre estaba DEBAJO de la declaración goto.

#include <stdio.h>
#include <string.h>

int main()
{
    char name[64];
    char url[80]; /*The final url name with http://www..com*/
    char *pName;
    int x;

    pName = name;

    INPUT:
    printf("\nWrite the name of a web page (Without www, http, .com) ");
    gets(name);

    for(x=0;x<=(strlen(name));x++)
        if(*(pName+0) == '\0' || *(pName+x) == ' ')
        {
            printf("Name blank or with spaces!");
            getch();
            system("cls");
            goto INPUT;
        }

    strcpy(url,"http://www.");
    strcat(url,name);
    strcat(url,".com");

    printf("%s",url);
    return(0);
}

@ Greg:

¿Por qué no hacer su ejemplo de esta manera:

void foo()
{
    if (doA())
    {    
        if (doB())
        {
          if (!doC())
          {
             UndoA();
             UndoB();
          }
        }
        else
        {
          UndoA();
        }
    }
    return;
}