用C或C ++编写好的getos的示例[关闭]

在这个线程中，我们看一下goto在C或C ++中良好使用的示例。灵感来自人们以为我在开玩笑而投票赞成的答案。

摘要（标签从原始更改为意图更加清晰）：

infinite_loop:

    // code goes here

goto infinite_loop;

为什么比其他更好：

• 具体。 goto是导致无条件分支的语言构造。替代方案取决于使用支持条件分支的结构，并带有退化的始终为真的条件。
• 标签记录了意图，没有额外的注释。
• 读者不必扫描介入的代码以获取早期的breaks（尽管无原则的黑客仍然有可能continue用Early进行模拟 goto）。

规则：

• 假装傻瓜没有赢。可以理解，以上内容不能在实际代码中使用，因为它违反了既定的习惯用法。
• 假设我们都听说过“ Goto认为有害”，并且知道goto可以用来编写意大利面条式代码。
• 如果您不同意一个示例，则仅凭技术优势对其进行批评（“因为人们不喜欢goto”不是技术原因）。

让我们看看是否可以像大人一样谈论这件事。

编辑

这个问题似乎已经解决了。它产生了一些高质量的答案。感谢所有人，尤其是那些认真对待我的小循环榜样的人。大多数怀疑论者担心缺乏障碍的范围。正如@quinmars在评论中指出的那样，您始终可以在循环主体周围放置括号。我顺便指出for(;;)，并while(true)没有给你免费任括号（并忽略他们可能会导致错误伤脑筋）。无论如何，我不会在这个琐事上浪费您的脑力-我可以忍受无害和惯用的语言for(;;)，while(true)（如果我想继续工作，也可以）。

考虑到其他答复，我看到许多人认为goto您总是必须用另一种方式重写。当然，您可以goto通过引入循环，额外的标志，嵌套的ifs或其他方法来避免使用a ，但是为什么不考虑goto也许这是最好的工具呢？换句话说，人们准备忍受多少丑陋，以避免将内置语言功能用于其预期目的？我的观点是，即使添加一个标志也付出了很高的代价。我喜欢用变量来表示问题或解决方案领域中的事物。goto仅仅避免'不会削减它。

我将接受第一个答案，该答案给出了用于分支到清除块的C模式。IMO，这是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;
}

C语言中对GOTO的经典需求如下

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

final:

没有goto，没有直接的方法可以摆脱嵌套循环。

这是我的非傻子示例（来自Stevens APITUE），用于Unix系统调用，该调用可能会被信号中断。

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

        // handle real errors
    }

替代方案是简并循环。该版本的读法类似于英语“如果系统调用被信号中断，请重新启动它”。

如果Duff的设备不需要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);
    }
}

上面维基百科条目中的代码。

Knuth撰写了一篇论文“使用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)和其他会增加嵌套的结构，同时仍保持可读的结构化代码。

一般而言，我对goto毫无抵触，但我可以想到几个您不想将它们用于循环的原因：

• 它没有限制范围，因此您稍后使用在其中使用的任何临时变量都不会被释放。
• 它不限制范围，因此可能导致错误。
• 它不会限制作用域，因此以后您将无法在以后的代码中在相同作用域中重复使用相同的变量名。
• 它没有限制范围，因此您有机会跳过变量声明。
• 人们不习惯它，它将使您的代码更难阅读。
• 这种类型的嵌套循环可能导致意大利面条代码，法线循环不会导致意大利面条代码。

使用goto的一个好地方是可以在多个点中止的过程中，每个过程都需要进行不同级别的清理。Gotophobes总是可以用结构化代码和一系列测试来代替gotos，但是我认为这更直接，因为它消除了过多的缩进：

如果（！openDataFile（））
  退出

如果（！getDataFromFile（））
  转到closeFileAndQuit;

如果（！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
}

我对此的抱怨是，您失去了块作用域；如果循环中断，则在goto之间声明的任何局部变量将保持有效。（也许您假设循环将永远运行；不过，我认为那不是原始问题作者所要问的。）

范围问题更多地是C ++的问题，因为某些对象可能取决于在适当时间调用它们的dtor。

对我来说，使用goto的最佳理由是在多步骤初始化过程中，至关重要的是，如果失败了，则必须退出所有init，例如：

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