如果GOTO本身是邪恶的，那么编译器也是邪恶的，因为它们生成jmp。如果跳转到代码块，特别是跟随一个指针，在本质上是邪恶的，那么RETurn指令就是邪恶的。相反，邪恶在于滥用的可能性。

有时我不得不编写应用程序，必须跟踪许多对象，其中每个对象必须遵循复杂的状态序列来响应事件，但整个事情绝对是单线程的。一个典型的状态序列，如果用伪代码表示，将是:

request something
wait for it to be done
while some condition
    request something
    wait for it
    if one response
        while another condition
            request something
            wait for it
            do something
        endwhile
        request one more thing
        wait for it
    else if some other response
        ... some other similar sequence ...
    ... etc, etc.
endwhile

我相信这不是新的，但我在C(++)中处理它的方式是定义一些宏:

#define WAIT(n) do{state=(n); enque(this); return; L##n:;}while(0)
#define DONE state = -1

#define DISPATCH0 if state < 0) return;
#define DISPATCH1 if(state==1) goto L1; DISPATCH0
#define DISPATCH2 if(state==2) goto L2; DISPATCH1
#define DISPATCH3 if(state==3) goto L3; DISPATCH2
#define DISPATCH4 if(state==4) goto L4; DISPATCH3
... as needed ...

然后(假设初始状态为0)上面的结构化状态机转换为结构化代码:

{
    DISPATCH4; // or as high a number as needed
    request something;
    WAIT(1); // each WAIT has a different number
    while (some condition){
        request something;
        WAIT(2);
        if (one response){
            while (another condition){
                request something;
                WAIT(3);
                do something;
            }
            request one more thing;
            WAIT(4);
        }
        else if (some other response){
            ... some other similar sequence ...
        }
        ... etc, etc.
    }
    DONE;
}

在此基础上，可以有CALL和RETURN，因此一些状态机可以像其他状态机的子例程一样工作。

不寻常吗?是的。维护者是否需要学习一些知识?是的。这种学习有回报吗?我想是的。如果没有跳转到方块中的goto，游戏还能完成吗?不。

如果GOTO本身是邪恶的，那么编译器也是邪恶的，因为它们生成jmp。如果跳转到代码块，特别是跟随一个指针，在本质上是邪恶的，那么RETurn指令就是邪恶的。相反，邪恶在于滥用的可能性。

有时我不得不编写应用程序，必须跟踪许多对象，其中每个对象必须遵循复杂的状态序列来响应事件，但整个事情绝对是单线程的。一个典型的状态序列，如果用伪代码表示，将是:

request something
wait for it to be done
while some condition
    request something
    wait for it
    if one response
        while another condition
            request something
            wait for it
            do something
        endwhile
        request one more thing
        wait for it
    else if some other response
        ... some other similar sequence ...
    ... etc, etc.
endwhile

我相信这不是新的，但我在C(++)中处理它的方式是定义一些宏:

#define WAIT(n) do{state=(n); enque(this); return; L##n:;}while(0)
#define DONE state = -1

#define DISPATCH0 if state < 0) return;
#define DISPATCH1 if(state==1) goto L1; DISPATCH0
#define DISPATCH2 if(state==2) goto L2; DISPATCH1
#define DISPATCH3 if(state==3) goto L3; DISPATCH2
#define DISPATCH4 if(state==4) goto L4; DISPATCH3
... as needed ...

然后(假设初始状态为0)上面的结构化状态机转换为结构化代码:

{
    DISPATCH4; // or as high a number as needed
    request something;
    WAIT(1); // each WAIT has a different number
    while (some condition){
        request something;
        WAIT(2);
        if (one response){
            while (another condition){
                request something;
                WAIT(3);
                do something;
            }
            request one more thing;
            WAIT(4);
        }
        else if (some other response){
            ... some other similar sequence ...
        }
        ... etc, etc.
    }
    DONE;
}

在此基础上，可以有CALL和RETURN，因此一些状态机可以像其他状态机的子例程一样工作。

不寻常吗?是的。维护者是否需要学习一些知识?是的。这种学习有回报吗?我想是的。如果没有跳转到方块中的goto，游戏还能完成吗?不。

Go To可以在某些情况下为“真正的”异常处理提供一种替代品。考虑:

ptr = malloc(size);
if (!ptr) goto label_fail;
bytes_in = read(f_in,ptr,size);
if (bytes_in=<0) goto label_fail;
bytes_out = write(f_out,ptr,bytes_in);
if (bytes_out != bytes_in) goto label_fail;

显然，这段代码被简化了，以占用更少的空间，所以不要太纠结于细节。但是考虑一下我在产品代码中多次看到的另一种选择，即程序员为了避免使用goto而费尽心机:

success=false;
do {
    ptr = malloc(size);
    if (!ptr) break;
    bytes_in = read(f_in,ptr,size);
    if (count=<0) break;
    bytes_out = write(f_out,ptr,bytes_in);
    if (bytes_out != bytes_in) break;
    success = true;
} while (false);

现在这段代码在功能上做了完全相同的事情。事实上，编译器生成的代码几乎完全相同。然而，在程序员对Nogoto(可怕的学术指责之神)的热情中，这个程序员完全打破了while循环所代表的底层习惯，并对代码的可读性造成了实质性的影响。这样也好不到哪里去。

所以，这个故事的寓意是，如果你发现自己为了避免使用goto而求助于一些非常愚蠢的事情，那么就不要这样做。

在我的程序列表中，Goto只是为了它而包含的东西非常低。这并不意味着这是不可接受的。

Goto可以很好地用于状态机。循环中的switch语句(按典型重要性排序):(A)不能实际代表控制流，(b)丑陋，(c)可能效率低下，这取决于语言和编译器。因此，您最终为每个状态编写一个函数，并执行类似“return NEXT_STATE;”的操作，这甚至看起来像goto。

当然，以易于理解的方式对状态机进行编码是很困难的。然而，这些困难都与使用goto无关，也不能通过使用替代控制结构来减少。除非你的语言有一个“状态机”结构。我不喜欢。

在极少数情况下，当您的算法通过通过有限的允许转换集(goto)连接的节点(状态)序列的路径而不是通过任何更具体的控制流(循环、条件等等)来理解时，那么应该在代码中显式地说明这一点。你应该画一个漂亮的图。

Setjmp /longjmp可以很好地实现异常或类似异常的行为。虽然没有得到普遍的赞扬，但异常通常被认为是一种“有效的”控制结构。

Setjmp /longjmp比goto“更危险”，因为它们更难正确使用，更不用说理解了。

从来没有，将来也不会有 永远是，任何语言都是 写不好一点也难 代码。——唐纳德·克努特

从C中去掉goto并不会使用C编写好的代码变得更容易。事实上，这样做反而会忽略一点，即C应该能够作为一种被美化的汇编语言。

接下来是“有害的指针”，然后是“有害的鸭子类型”。那么，当他们来拿走你不安全的编程结构时，谁来保护你呢?是吗?

是的，GOTO仍然被认为是有害的。当您发现自己处于使用GOTO可能有效的罕见情况时，您应该对自己的编程技能有足够的信心，而不需要其他人的验证。任何类似GOTO的函数允许你在GOTO允许的范围内跳得更远，都应该被认为比GOTO更危险。

我们已经讨论过这个问题了，我坚持我的观点。

此外，我受够了人们将高级语言结构描述为“伪装的goto”，因为他们显然根本没有抓住重点。例如:

即使Scheme中先进的连续控制结构也可以被描述为复杂的后向。

那完全是胡说八道。每个控制结构都可以在goto方面实现，但这个观察完全是微不足道和无用的。Goto被认为是有害的，因为它的积极影响，而是因为它的消极后果，这些已经被结构化编程消除了。

Similarly, saying “GOTO is a tool, and as all tools, it can be used and abused” is completely off the mark. No modern construction worker would use a rock and claim it “is a tool.” Rocks have been replaced by hammers. goto has been replaced by control structures. If the construction worker were stranded in the wild without a hammer, of course he would use a rock instead. If a programmer has to use an inferior programming language that doesn't have feature X, well, of course she may have to use goto instead. But if she uses it anywhere else instead of the appropriate language feature she clearly hasn't understood the language properly and uses it wrongly. It's really as simple as that.