Przykłady dobrych gotos w C lub C++ [zamknięty]

Klasyczna potrzeba GOTO w C jest następująca

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

final:

Nie ma prostego sposobu na wyrwanie się z zagnieżdżonych pętli bez goto.

Oto Mój nie-głupi przykład, (od Stevens APITUE) dla wywołań systemu Unix, które mogą być przerwane przez sygnał.

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

        // handle real errors
    }

Alternatywą jest pętla zdegenerowana. Ta wersja brzmi jak angielski "jeśli wywołanie systemowe zostało przerwane przez sygnał, uruchom je ponownie".

Jeśli urządzenie Duffa nie potrzebuje goto, to Ty też nie powinieneś! ;)

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

Powyższy kod z Wikipedii wpis.

Knuth napisał referat "programowanie strukturalne z poleceniami GOTO", można go pobrać np. z tutaj . Znajdziesz tam wiele przykładów.

Bardzo często.

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

Jedyny przypadek, którego używam goto to skakanie do przodu, zwykle z bloków, a nigdy do bloków. Pozwala to uniknąć nadużywania do{}while(0) i innych konstrukcji, które zwiększają zagnieżdżanie, zachowując jednocześnie czytelny, ustrukturyzowany kod.

Nie mam nic przeciwko gotos w ogóle, ale mogę wymyślić kilka powodów, dla których nie chcesz ich używać do pętli, jak wspomniałeś:

• nie ogranicza zakresu, dlatego zmienne temp, których używasz, zostaną zwolnione dopiero później.
• nie ogranicza zasięgu, dlatego może prowadzić do błędów.
• nie ogranicza zakresu, dlatego nie można ponownie użyć tych samych nazw zmiennych później w przyszłym kodzie w tym samym zakresie.
• nie ogranicza zakresu stąd masz możliwość pominięcia deklaracji zmiennej.
• ludzie nie są do tego przyzwyczajeni, a to sprawi, że Twój kod będzie trudniejszy do odczytania.
• zagnieżdżone pętle tego typu mogą prowadzić do kodu spaghetti, normalne pętle nie prowadzą do kodu spaghetti.

Dobrym miejscem do użycia Goto jest procedura, która może zostać przerwana w kilku punktach, z których każdy wymaga różnych poziomów czyszczenia. Gotophobes zawsze może zastąpić gotos ustrukturyzowanym kodem i serią testów, ale myślę, że jest to prostsze, ponieważ eliminuje nadmierne wcięcie:

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: Twój opublikowany fragment kodu jest odpowiednikiem następującego:

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

            break;
        }
    }

Mimo, że z czasem znienawidziłem ten wzorzec, to jest on wkomponowany w programowanie 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;
}

Oto przykład dobrego goto:

// No Code

Widziałem goto używane poprawnie, ale sytuacje są normalnie brzydkie. Tylko wtedy, gdy samo użycie goto jest o wiele mniej gorsze od oryginału. @ Johnathon Holland The poblem is you ' re version is less clear. ludzie zdają się bać lokalnych zmiennych:

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

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

I wolę takie pętle, ale niektórzy wolą while(true).

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

Mój problem z tym polega na tym, że tracisz zasięg bloku; wszelkie zmienne lokalne zadeklarowane między gotos pozostają w mocy, jeśli pętla zostanie kiedykolwiek zerwana. (Może zakładasz, że pętla działa w nieskończoność; nie sądzę, że to jest to, co autor pytania zadawał, chociaż.)

Problem scopowania jest bardziej problemem w C++, ponieważ niektóre obiekty mogą zależeć od wywoływania ich dtor w odpowiednim czasie.

Dla mnie najlepszym powodem do użycia goto jest podczas wieloetapowego proces inicjalizacji, w którym ważne jest, aby wszystkie Inity były wycofane, jeśli jeden się nie powiedzie, 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;

Sam nie używam goto, jednak pracowałem kiedyś z osobą, która używałaby ich w konkretnych przypadkach. O ile dobrze pamiętam, jego uzasadnienie dotyczyło kwestii wydajności - miał też określone zasady Jak. Zawsze w tej samej funkcji, a etykieta była zawsze pod instrukcją 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:

Dlaczego nie zrobić przykład w ten sposób:

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