在这段代码中使用 goto 有什么好处？

Question

static gboolean
gst_fd_src_start (GstBaseSrc * bsrc)
{
  GstFdSrc *src = GST_FD_SRC (bsrc);

  src->curoffset = 0;

  if ((src->fdset = gst_poll_new (TRUE)) == NULL)
    goto socket_pair;

  gst_fd_src_update_fd (src, -1);

  return TRUE;

  /* ERRORS */
socket_pair:
  {
    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL),
        GST_ERROR_SYSTEM);
    return FALSE;
  }
}

为什么这里有人使用了goto socket_pair;我不明白为什么使用这种机制？ 为什么我们不直接在那里写入错误消息并返回？

注意：这是 gstreamer 插件代码

Answer 1

在较大的例程中，函数中可能有多个点需要转到错误处理代码。该例程应该在根据代码约定编写的上下文中查看，该代码约定要求采用通用的错误处理形式。

确实，goto 应该被认为是危险的，但对于像 C 这样没有异常处理的语言来说，它可能是错误处理中最不坏的选择。

Answer 2

在您引用的代码中，基本上没有任何充分的理由。

不过，一般来说，如果函数需要在失败时执行不止一件事（例如，不仅仅是返回错误代码），或者如果编码标准每个函数都需要一个单一 返回（某些政府工作会这样做）。然后，主体代码在需要时使用 goto 触发错误处理。这有点像穷人的try/catch/finally事情。

例如：

int someNiftyFunction() {
    int rv = 0;

    acquireSomeResource();

    if (some_failure_condition) {
        rv = -1;
        goto error_out;
    }

    if (some_other_failure_condition) {
        rv = -2;
        goto error_out;
    }

    if (yet)_another_failure_condition) {
        rv = -3;
        goto error_out;
    }

    setUpSuccessStuff();

exit:
    cleanUpSomeResource();
    return rv;

error_out:

    setUpFailureStuff();
    logSomeValuableInfo();
    goto exit;
}

基本上，从 acquireSomeResource() 到 exit: 标签的所有内容都非常粗略地是一个 try 块，exit: 标签是 finally，error_out 是 catch。非常粗略。 :-)

Answer 3

如果这是在老式 C 语言中，它没有作为语言结构内置异常处理，那么这个习惯用法是模拟它的好方法。

假设有 10 个提前退出条件。如果您想将每个代码都编码为 return 语句，则必须重复调用 GST_ELEMENT_ERROR 10 次，而使用 goto 意味着您只需将其放置一次。

显然，在这种情况下，只有 1 个提前退出条件，但通常最好通过代码一直实现此习惯用法，而不是仅在严格需要它的函数中实现

Answer 4

这是 C 语言中将错误处理和清理与正常代码分开的常见方法。在其他语言中，您将使用某种结构化异常。这是用 C 语言实现的更简洁的方法。在更复杂的情况下，好处更明显。在许多情况下，必须从不同的地方调用错误处理/清理代码。重构它没有多大意义，我认为如果您因此在 C 中使用 goto 并没有那么邪恶。在其他具有更好机制的编程语言中，您当然应该避免使用 goto...

Answer 5

这样做可以具有用于处理套接字错误的通用代码。在这种特殊情况下，仅在一种情况下需要，并且在这种情况下可能不需要使用 goto，但只是出于一致性原因（所有代码库的通用方法）。

Answer 6

如上所述，如果你只看这个功能，那是没有意义的。然而，如果你的函数有很多错误情况，并且在退出函数之前有一些清理问题，这种编程是不可避免的，否则你的代码将会因所有错误问题或一些清理问题而增加。为了使编程更加结构化，有时所有函数都可以用 goto 析构函数编写，就像您提到的代码一样。

Answer 7

正如其他答案中指出的那样，它在简单的示例中没有多大作用；当需要获取多种资源和多种错误情况时，它的好处更加明显。此伪代码演示了这一点：

boolean allocate_resources (ObjectA **a, ObjectB **b, ObjectC **c)
{
    *a = allocate_a();
    if (*a == NULL) {
        LOG_ERROR("failed to allocate A");
        goto fail0;
    }

    *b = allocate_b();
    if (*b == NULL) {
        LOG_ERROR("failed to allocate B");
        goto fail1;
    }

    *c = allocate_c();
    if (*c == NULL) {
        LOG_ERROR("failed to allocate C");
        goto fail2;
    }

    return true;

fail2:
    release_b(*b);
fail1:
    release_a(*a);
fail0:
    return false;
}

请注意，从外部看，上述函数如何以原子方式工作 - 当它返回时，要么分配所有资源，要么不分配任何资源，从而避免泄漏。

将此版本与使用嵌套而不是 goto 的一个可能版本进行比较：

// Bad style. Don't do this.
boolean allocate_resources (ObjectA **a, ObjectB **b, ObjectC **c)
{
    *a = allocate_a();
    if (*a == NULL) {
        LOG_ERROR("failed to allocate A");
    } else {
        *b = allocate_b();
        if (*b == NULL) {
            LOG_ERROR("failed to allocate B");
        } else {
            *c = allocate_c();
            if (*c == NULL) {
                LOG_ERROR("failed to allocate C");
            } else {
                return true;
            }

            release_b(*b);
        }

        release_a(*a);
    }

    return false;
}

该版本更难阅读。在 goto 版本中，乍一看主要执行路径是什么是显而易见的；在这里'它不是。嵌套使代码更难以阅读，并且还浪费了水平空间。

希望我没有搞砸它，它在功能上等同于 goto 示例；我建议你尝试证明它是等价的，并亲眼看看它的工作有多困难。

Answer 8

goto 没有任何优点（除了退出嵌套循环）。有些人可能会说这里的错误处理与逻辑是分离的。但我会把它写成：

static gboolean
gst_fd_src_start (GstBaseSrc * bsrc)
{
  GstFdSrc *src = GST_FD_SRC (bsrc);

  src->curoffset = 0;

  if ((src->fdset = gst_poll_new (TRUE)) == NULL)
  {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL),
    GST_ERROR_SYSTEM);
return FALSE;
  }



  gst_fd_src_update_fd (src, -1);

  return TRUE;
}