Примеры хороших gotos на C или C ++ [закрыто]

В этой теме мы рассмотрим примеры правильного использования gotoC или C ++. Он вдохновлен ответом, за который люди проголосовали, потому что думали, что я шучу.

Резюме (ярлык изменен с оригинала, чтобы прояснить намерения):

infinite_loop:

    // code goes here

goto infinite_loop;

Почему лучше альтернатив:

• Это специфично. gotoэто языковая конструкция, которая вызывает безусловный переход. Альтернативы зависят от использования структур, поддерживающих условные переходы, с вырожденным условием Always-True.
• Этикетка документирует намерение без дополнительных комментариев.
• Читателю не нужно сканировать промежуточный код на ранних этапах break(хотя для беспринципного хакера все еще возможно смоделировать 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:

Нет простого способа выйти из вложенных циклов без перехода.

Вот мой нелепый пример (от Stevens 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 - это процедура, которая может прерваться в нескольких точках, каждая из которых требует различных уровней очистки. Gotophobes всегда может заменить gotos структурированным кодом и серией тестов, но я думаю, что это более просто, потому что он устраняет чрезмерные отступы:

если (! openDataFile ())
  перейти к выходу;

если (! getDataFromFile ())
  goto closeFileAndQuit;

если (! allocateSomeResources)
  goto 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
}

Меня беспокоит то, что вы теряете область видимости блока; любые локальные переменные, объявленные между gotos, остаются в силе, если цикл когда-либо прерывается. (Возможно, вы предполагаете, что цикл выполняется вечно; однако я не думаю, что это то, что задавал исходный автор вопроса.)

Проблема области видимости больше связана с C ++, поскольку некоторые объекты могут зависеть от того, как их dtor вызывается в соответствующее время.

Для меня лучшая причина использовать goto - это во время многоэтапного процесса инициализации, когда жизненно важно, чтобы все inits были отменены в случае сбоя одного из них, а-ля:

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

@ Грег:

Почему бы не сделать ваш пример таким:

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