Приклади хороших гото в C або C ++ [закрито]

У цій темі ми розглянемо приклади ефективного використання gotoC або C ++. Це надихається відповіддю, яку люди проголосували, бо думали, що я жартую.

Короткий зміст (мітка змінена з оригінальної, щоб зробити намір ще чіткішим):

infinite_loop:

    // code goes here

goto infinite_loop;

Чому це краще, ніж альтернативи:

• Це конкретно. goto- це мовна конструкція, яка викликає безумовну гілку. Альтернативи залежать від використання конструкцій, що підтримують умовні гілки, з виродженим завжди істинним станом.
• Етикетка документує намір без зайвих коментарів.
• Читачеві не потрібно сканувати проміжний код на ранні breaks (хоча все ще можливо для безпринципного хакера симулювати continueз ранньою goto).

Правила:

• Робіть вигляд, що готофоби не перемогли. Зрозуміло, що вищезазначене не можна використовувати в реальному коді, оскільки це суперечить усталеній ідіомі.
• Припустимо, що всі ми чули про "Goto вважається шкідливим" і знаємо, що goto можна використовувати для написання коду спагетті.
• Якщо ви не згодні з прикладом, критикуйте його лише з технічної точки зору («Тому що люди не люблять goto» - це не технічна причина).

Давайте подивимось, чи можна говорити про це як про дорослих.

Редагувати

Здається, це питання зараз закінчене. Це дало кілька високоякісних відповідей. Дякую всім, особливо тим, хто серйозно сприйняв мій маленький приклад. Більшість скептиків були стурбовані відсутністю блоку блоків. Як зазначив @quinmars у коментарі, ви завжди можете розмістити фігурні дужки навколо тіла циклу. Зауважу принагідно , що for(;;)й while(true)не дають вам брекети безкоштовно або для (і опускаючи їх може викликати прикрі помилки). У будь-якому разі, я більше не буду витрачати на це дрібницю вашу силу мозку - я можу жити з нешкідливим і ідіоматичним for(;;)і while(true)(так само добре, якщо хочу зберегти свою роботу).

Беручи до уваги інші відповіді, я бачу, що багато людей розглядають gotoяк те, що ти завжди повинен переписати по-іншому. Звичайно, ви можете уникнути a goto, ввівши цикл, додатковий прапор, стек вкладених ifs або що завгодно, але чому б не подумати, чи gotoце, мабуть, найкращий інструмент для роботи? Іншими словами, скільки потворності готові витерпіти люди, щоб уникнути використання вбудованої мовної функції за призначенням? Я вважаю, що навіть додавання прапора є занадто високою ціною, яку потрібно заплатити. Мені подобається, щоб мої змінні представляли речі в доменах проблеми чи рішення. "Тільки щоб уникнути goto" не вирізає.

Я прийму першу відповідь, яка дала шаблон C для розгалуження до блоку очищення. ІМО, це робить найбільш вагомий випадок gotoз усіх розміщених відповідей, звичайно, якщо ви вимірюєте це за викривленнями, які ненависник повинен пройти, щоб уникнути цього.

Ось один трюк, який я чув про те, як люди використовують. Я ніколи не бачив цього в дикій природі. І це стосується лише C, оскільки C ++ має RAII, щоб зробити це більш ідіоматично.

void foo()
{
    if (!doA())
        goto exit;
    if (!doB())
        goto cleanupA;
    if (!doC())
        goto cleanupB;

    /* everything has succeeded */
    return;

cleanupB:
    undoB();
cleanupA:
    undoA();
exit:
    return;
}

Класична потреба в GOTO на C наступна

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

final:

Немає простого способу вирватися з вкладених петель без goto.

Ось мій нерозумний приклад (від Стівенса APITUE) для системних дзвінків Unix, які можуть бути перервані сигналом.

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

        // handle real errors
    }

Альтернатива - вироджена петля. Ця версія читається як англійська "якщо системний дзвінок був перерваний сигналом, перезапустіть його".

Якщо пристрій Даффа не потребує goto, то вам не потрібно! ;)

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

Код вище з Вікіпедії записи .

Кнут написав статтю "Структуроване програмування з операторами GOTO", її можна отримати, наприклад, звідси . Там ви знайдете багато прикладів.

Дуже часто.

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

Єдиний випадок, який я коли-небудь використовую, goto- це стрибки вперед, як правило, з блоків і ніколи в блоки. Це дозволяє уникнути зловживань do{}while(0)та інших конструкцій, які збільшують вкладеність, зберігаючи при цьому читабельний структурований код.

Я взагалі нічого не маю проти gotos, але я можу придумати кілька причин, чому ви не хотіли б використовувати їх для циклу, як ви вже згадували:

• Це не обмежує сферу дії, отже, будь-які тимчасові змінні, які ви використовуєте всередині, не будуть звільнені до пізніше.
• Це не обмежує сферу застосування, отже, це може призвести до помилок.
• Це не обмежує область, отже, ви не можете повторно використовувати ті самі імена змінних пізніше в майбутньому коді в тій самій області.
• Це не обмежує область дії, отже у вас є шанс пропустити оголошення змінної.
• Люди до цього не звикли, і це ускладнить читання вашого коду.
• Вкладені цикли цього типу можуть вести до коду спагетті, звичайні цикли не ведуть до коду спагетті.

Одне хороше місце для використання goto - це процедура, яка може перерватись у декількох точках, кожна з яких вимагає різного рівня очищення. Готофобі завжди можуть замінити гото структурованим кодом та низкою тестів, але я думаю, що це простіше, оскільки це виключає надмірне відступ:

if (! openDataFile ())
  перейти;

if (! getDataFromFile ())
  перейти до closeFileAndQuit;

if (! allocateSomeResources)
  перейти до freeResourcesAndQuit;

// Виконайте тут більше роботи ....

freeResourcesAndQuit:
   // вільні ресурси
closeFileAndQuit:
   // закрити файл
кинути:
   // кинути!

@ fizzer.myopenid.com: ваш розміщений фрагмент коду еквівалентний наступному:

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

            break;
        }
    }

Я точно віддаю перевагу цій формі.

Незважаючи на те, що я з часом зненавидів цей шаблон, він вбудований у програмування 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;
}

Ось приклад хорошого goto:

// No Code

Я бачив, як правильно вживали goto, але ситуації звичайно потворні. Це лише тоді, коли використання самого gotoсебе набагато гірше, ніж оригіналу. @Johnathon Holland, проблема в тому, що ти версія, менш зрозуміла. здається, люди бояться локальних змінних:

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

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

І я віддаю перевагу таким циклам, але деякі воліють while(true).

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

Моя думка з цього приводу полягає в тому, що ви втрачаєте масштаб блоків; будь-які локальні змінні, оголошені між гото, залишаються в силі, якщо цикл коли-небудь перервано. (Можливо, ви припускаєте, що цикл працює назавжди; я не думаю, що це те, що задавав оригінальний автор запитань.)

Проблема масштабування є більшою проблемою з C ++, оскільки деякі об'єкти можуть залежати від виклику їх dtor у відповідний час.

Для мене найкраща причина використовувати goto - це під час багатоетапного процесу ініціалізації, де життєво важливо, щоб усі ініціали були захищені, якщо хтось не вдається, 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;

Я сам не використовую goto, однак колись працював із людиною, яка б використовувала їх у конкретних випадках. Якщо я добре пам’ятаю, його обгрунтування було навколо питань продуктивності - він також мав конкретні правила щодо того, як . Завжди в одній функції, і мітка завжди була ПІД заявою 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:

Чому б не зробити ваш приклад таким:

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