我在以下情况下使用goto: 当需要从不同位置的函数返回时，并且在返回之前需要进行一些初始化:

non-goto版本:

int doSomething (struct my_complicated_stuff *ctx)    
{
    db_conn *conn;
    RSA *key;
    char *temp_data;
    conn = db_connect();  


    if (ctx->smth->needs_alloc) {
      temp_data=malloc(ctx->some_size);
      if (!temp_data) {
        db_disconnect(conn);
        return -1;      
        }
    }

    ...

    if (!ctx->smth->needs_to_be_processed) {
        free(temp_data);    
        db_disconnect(conn);    
        return -2;
    }

    pthread_mutex_lock(ctx->mutex);

    if (ctx->some_other_thing->error) {
        pthread_mutex_unlock(ctx->mutex);
        free(temp_data);
        db_disconnect(conn);        
        return -3;  
    }

    ...

    key=rsa_load_key(....);

    ...

    if (ctx->something_else->error) {
         rsa_free(key); 
         pthread_mutex_unlock(ctx->mutex);
         free(temp_data);
         db_disconnect(conn);       
         return -4;  
    }

    if (ctx->something_else->additional_check) {
         rsa_free(key); 
         pthread_mutex_unlock(ctx->mutex);
         free(temp_data);
         db_disconnect(conn);       
         return -5;  
    }


    pthread_mutex_unlock(ctx->mutex);
    free(temp_data);    
    db_disconnect(conn);    
    return 0;     
}

goto版本:

int doSomething_goto (struct my_complicated_stuff *ctx)
{
    int ret=0;
    db_conn *conn;
    RSA *key;
    char *temp_data;
    conn = db_connect();  


    if (ctx->smth->needs_alloc) {
      temp_data=malloc(ctx->some_size);
      if (!temp_data) {
            ret=-1;
           goto exit_db;   
          }
    }

    ...

    if (!ctx->smth->needs_to_be_processed) {
        ret=-2;
        goto exit_freetmp;      
    }

    pthread_mutex_lock(ctx->mutex);

    if (ctx->some_other_thing->error) {
        ret=-3;
        goto exit;  
    }

    ...

    key=rsa_load_key(....);

    ...

    if (ctx->something_else->error) {
        ret=-4;
        goto exit_freekey; 
    }

    if (ctx->something_else->additional_check) {
        ret=-5;
        goto exit_freekey;  
    }

exit_freekey:
    rsa_free(key);
exit:    
    pthread_mutex_unlock(ctx->mutex);
exit_freetmp:
    free(temp_data);        
exit_db:
    db_disconnect(conn);    
    return ret;     
}

当您需要更改释放语句中的某些内容时(每个语句在代码中使用一次)，第二个版本使它变得更容易，并减少了在添加新分支时跳过其中任何一个语句的机会。在函数中移动它们在这里不会有帮助，因为可以在不同的“级别”进行释放。

在Perl中，使用标签从循环中“goto”—使用“last”语句，这类似于break。

这样可以更好地控制嵌套循环。

也支持传统的goto标签，但我不确定是否有太多的实例，这是实现您想要的结果的唯一方法-子例程和循环应该足以满足大多数情况。

看看在C语言中编程时何时使用Goto:

Although the use of goto is almost always bad programming practice (surely you can find a better way of doing XYZ), there are times when it really isn't a bad choice. Some might even argue that, when it is useful, it's the best choice. Most of what I have to say about goto really only applies to C. If you're using C++, there's no sound reason to use goto in place of exceptions. In C, however, you don't have the power of an exception handling mechanism, so if you want to separate out error handling from the rest of your program logic, and you want to avoid rewriting clean up code multiple times throughout your code, then goto can be a good choice.

我是什么意思?你可能会有这样的代码:

int big_function()
{
    /* do some work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* do some more work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* do some more work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* do some more work */
    if([error])
    {
        /* clean up*/
        return [error];
    }
    /* clean up*/
    return [success];
}

This is fine until you realize that you need to change your cleanup code. Then you have to go through and make 4 changes. Now, you might decide that you can just encapsulate all of the cleanup into a single function; that's not a bad idea. But it does mean that you'll need to be careful with pointers -- if you plan to free a pointer in your cleanup function, there's no way to set it to then point to NULL unless you pass in a pointer to a pointer. In a lot of cases, you won't be using that pointer again anyway, so that may not be a major concern. On the other hand, if you add in a new pointer, file handle, or other thing that needs cleanup, then you'll need to change your cleanup function again; and then you'll need to change the arguments to that function.

通过使用goto，它将是

int big_function()
{
    int ret_val = [success];
    /* do some work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
    /* do some more work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
    /* do some more work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
    /* do some more work */
    if([error])
    {
        ret_val = [error];
        goto end;
    }
end:
    /* clean up*/
    return ret_val;
}

这样做的好处是，您的代码可以访问执行清理所需的所有内容，并且您已经成功地减少了更改点的数量。另一个好处是你的函数从多个出口点变成了只有一个;不可能不小心从函数返回而不进行清理。

此外，由于goto仅用于跳转到单个点，因此并不是为了模拟函数调用而创建大量来回跳转的意大利面代码。相反，goto实际上有助于编写更结构化的代码。

总而言之，goto应该谨慎使用，并作为最后的手段——但它是有时间和地点的。问题不应该是“你是否必须使用它”，而应该是“它是使用它的最佳选择”。

下面是我所知道的使用“goto”语句的一些原因(有些人已经谈到了这个问题):

干净地退出函数

通常在一个函数中，您可能会分配资源并需要在多个位置退出。程序员可以通过将资源清理代码放在函数的末尾来简化他们的代码，并且函数的所有“出口点”都将进入清理标签。这样，您就不必在函数的每个“退出点”都编写清理代码。

退出嵌套循环

如果处于嵌套循环中，需要跳出所有循环，那么goto可以比break语句和If -checks更简洁。

低水平的性能改进

这只在对性能要求严格的代码中有效，但是goto语句执行得非常快，并且可以在遍历函数时提高性能。然而，这是一把双刃剑，因为编译器通常不能优化包含goto的代码。

注意，在所有这些示例中，gotos都被限制在单个函数的范围内。

它有时在按字符进行字符串处理时很方便。

想象一下这样一个printf式的例子:

for cur_char, next_char in sliding_window(input_string) {
    if cur_char == '%' {
        if next_char == '%' {
            cur_char_index += 1
            goto handle_literal
        }
        # Some additional logic
        if chars_should_be_handled_literally() {
            goto handle_literal
        }
        # Handle the format
    }
    # some other control characters
    else {
      handle_literal:
        # Complicated logic here
        # Maybe it's writing to an array for some OpenGL calls later or something,
        # all while modifying a bunch of local variables declared outside the loop
    }
}

您可以将goto handle_literal重构为一个函数调用，但如果它修改了几个不同的局部变量，则必须将引用传递给每个局部变量，除非您的语言支持可变闭包。如果您的逻辑使else case不起作用，那么您仍然必须在调用之后使用continue语句(可以说是goto的一种形式)以获得相同的语义。

我还在lexer中明智地使用了gotos，通常用于类似的情况。大多数时候你不需要它们，但在一些奇怪的情况下有它们很好。

如果有，为什么?

C语言没有多级/标记的中断，并不是所有的控制流都可以用C语言的迭代和决策原语轻松建模。Gotos对纠正这些缺陷大有帮助。

有时使用某种类型的标志变量来实现一种伪多级中断更清晰，但它并不总是优于goto(至少goto可以轻松地确定控制的位置，不像标志变量)，有时您只是不想为了避免goto而付出旗帜/其他扭曲的性能代价。

Libavcodec是一段性能敏感的代码。控制流的直接表达可能是优先考虑的，因为它往往会运行得更好。