C/C++：GOTO 比 WHILE 和 FOR 更快吗？

Question

我知道，每个人都讨厌 GOTO，也没有人推荐它。但这不是重点。我只是想知道哪个代码最快：

1. goto 循环

   int i=3;
   环形：
   printf("某事");
   if(--i) 转到循环；
   

2. while 循环

   int i=3;
   而（我--）{
       printf("某事");
   }
   

3. for 循环

   for(int i=3; i; i--) {
       printf("某事");
   }
   

Answer 1

我认为正常情况下编译后会有一些代码。

事实上我觉得 goto 有时很方便，虽然它很难读。

Answer 2

在一些利基垂直领域，goto 仍然被一些非常非常聪明的人普遍用作标准实践，并且在这些设置中对 goto 没有偏见。我曾经在一家专注于模拟的公司工作，那里所有的本地 Fortran 代码都有大量的 goto，团队非常聪明，而且软件运行得几乎完美。

因此，我们可以把 goto 的优点放在一边，如果问题只是比较循环，那么我们可以通过分析和/或比较汇编代码来实现。不过，这就是说，问题包括像 printf 等语句。这样做时，您无法真正讨论循环控制逻辑优化。此外，正如其他人指出的那样，给定的循环都将生成非常相似的机器代码。

无论如何，在解码阶段之前，所有条件分支在流水线处理器架构中都被视为“已采用”（真），此外，小循环通常扩展为无循环。因此，根据 Harper 的上述观点，goto 在简单循环控制中具有任何优势是不现实的（就像 for 或 while 彼此没有优势一样）。当将 goto 检查的附加条件添加到每个嵌套循环或嵌套 if 中时，GOTO 通常在多个嵌套循环或多个嵌套 if 中有意义。

当在简单循环中优化搜索类型的操作时，使用标记有时比其他任何方法都更有效。本质上，通过在数组末尾添加一个虚拟值，您可以避免将两个条件（数组末尾和找到的值）检查为只是一个条件（找到的值），从而节省了内部 cmp 操作。我不知道编译器是否自动这样做。

Answer 3

goto Loop:

start_Chicken:
{
    ++x;
    if (x >= loops)
        goto end_Chicken;
}
goto start_Chicken;

end_Chicken:
x = 0;

for Loop:

for (int i = 0; i < loops; i++)
{

}

while Loop:

while (z <= loops)
{

    ++z;
}
z = 0;

来自结果的图像

在任何具有更多混合的情况下循环测试的结果虽然最少，但仍然更好。

Answer 4

一般来说，for 和 while 循环被编译为与 goto 相同的东西，所以通常不会有什么区别。如果您有疑问，可以随意尝试这三种方法，看看哪个需要更长的时间。即使循环十亿次，您也很可能无法测量差异。

如果您查看 这个答案，您将看到编译器可以为 for、while 和 goto 生成完全相同的代码code> （仅在这种情况下没有条件）。

Answer 5

编写简短的程序，然后执行以下操作：

gcc -S -O2 p1.c 
gcc -S -O2 p2.c 
gcc -S -O2 p3.c 

分析输出并查看是否有任何差异。请务必引入一定程度的不可预测性，以便编译器不会将程序优化得一无是处。

编译器在优化这些琐碎的问题方面做得很好。我建议不要担心它，而是专注于让你作为程序员更有效率的事情。

速度和效率是一件值得担心的大事，但 99% 的时间都涉及使用正确的数据结构和算法……不用担心 for 是否比 while 更快 或 goto 等。

Answer 6

我唯一一次看到关于 goto 的论证是在 W. Richard Stevens 的一篇文章或书中。他的观点是，在代码的非常时间关键部分（我相信他的例子是网络堆栈），可以使用 goto 重做具有相关错误处理代码的嵌套 if/else 块。方式带来了宝贵的改变。

就我个人而言，我作为一名程序员还不够好，无法与史蒂文斯的工作争论，所以我不会尝试。 goto 对于与性能相关的问题可能很有用，但是何时使用的限制相当严格。

Answer 7

它可能是编译器、优化器和架构特定的。

例如，代码 if(--i) goto loop; 是一个条件测试，后跟一个无条件分支。编译器可能只是生成相应的代码，或者它可能足够智能（尽管至少不具备那么多智能的编译器可能没有多大价值），以生成单个条件分支指令。另一方面， while(i--) 已经是源代码级别的条件分支，因此无论编译器实现的复杂程度如何，都可能更倾向于翻译为机器级别的条件分支。优化器。

最后，差异可能很小，并且仅在需要大量迭代时才相关，并且您应该回答这个问题的方式是为感兴趣的特定目标和编译器（以及编译器设置）构建代码，并且检查生成的机器级代码或直接测量执行时间。

在您的示例中，循环中的 printf() 在任何情况下都将主导任何时间；循环中更简单的东西将使观察差异变得更容易。我建议使用一个空循环，然后声明 i volatile 以防止循环被优化为空。

Answer 8

只要您生成与普通循环相同的控制流，几乎任何像样的编译器都可以生成相同的代码，无论您使用 for、while、等等。

您可以通过使用 goto 获得一些好处，但通常只有当您生成普通循环根本无法（至少干净地）无法生成的控制流时。一个典型的例子是跳到循环的中间以获得一个半循环构造，大多数语言的普通循环语句（包括 C 语言）都不能清楚地提供这种结构。

Answer 9

所有循环和 goto 之间不应该有任何显着差异。除了这个想法之外，编译器很可能根本不会尝试优化 GOTO 事物。

尝试在循环中优化编译器生成的内容并没有多大意义。优化循环内部的代码，或者减少迭代次数等等更有意义。

Answer 10

在 Linux 上，我使用 g++ 和 clang++ 将下面的代码编译成程序集。有关我如何做到这一点的更多信息，请参阅此处。 （简短版本：g++ -S -O3 filename.cpp clang++ -S -O3 filename.cpp，以及您将在下面看到的一些汇编注释来帮助我。）

结论/TL;DR 在底部。

---

首先，我比较了 label: 和 goto 与 do {} while。您无法将 for () {} 循环与此进行比较（真诚地），因为 for 循环始终首先评估条件。这一次，只有在循环代码执行一次后才会评估条件。

#include <iostream>

void testGoto()
{
  __asm("//startTest");
  int i = 0;
  loop:
  std::cout << i;
  ++i;
  if (i < 100)
  {
    goto loop;
  }
  __asm("//endTest");
}

#include <iostream>

void testDoWhile()
{
  __asm("//startTest");
  int i = 0;
  do
  {
    std::cout << i;
    ++i;
  }
  while (i < 100);
  __asm("//endTest");
}

在这两种情况下，无论 goto 还是 do {} while，每个编译器的程序集都是完全相同的：

g++:

    xorl    %ebx, %ebx
    leaq    _ZSt4cout(%rip), %rbp
    .p2align 4,,10
    .p2align 3
.L2:
    movl    %ebx, %esi
    movq    %rbp, %rdi
    addl    $1, %ebx
    call    _ZNSolsEi@PLT
    cmpl    $100, %ebx
    jne .L2

clang++:

    xorl    %ebx, %ebx
    .p2align    4, 0x90
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
    movl    $_ZSt4cout, %edi
    movl    %ebx, %esi
    callq   _ZNSolsEi
    addl    $1, %ebx
    cmpl    $100, %ebx
    jne .LBB0_1
# %bb.2:

---

然后我比较了 label: 和 goto 与 while {} 与 for () {} 对比。这一次，在循环代码执行一次之前就评估了条件。

对于goto，我必须反转条件，至少是第一次。我看到了两种实现它的方法，所以我尝试了两种方法。

#include <iostream>

void testGoto1()
{
  __asm("//startTest");
  int i = 0;
  loop:
  if (i >= 100)
  {
    goto exitLoop;
  }
  std::cout << i;
  ++i;
  goto loop;
  exitLoop:
  __asm("//endTest");
}

#include <iostream>

void testGoto2()
{
  __asm("//startTest");
  int i = 0;
  if (i >= 100)
  {
    goto exitLoop;
  }
  loop:
  std::cout << i;
  ++i;
  if (i < 100)
  {
    goto loop;
  }
  exitLoop:
  __asm("//endTest");
}

#include <iostream>

void testWhile()
{
  __asm("//startTest");
  int i = 0;
  while (i < 100)
  {
    std::cout << i;
    ++i;
  }
  __asm("//endTest");
}

#include <iostream>

void testFor()
{
  __asm("//startTest");
  for (int i = 0; i < 100; ++i)
  {
    std::cout << i;
  }
  __asm("//endTest");
}

如上所述，在所有四种情况下，无论 goto 1 或 2、while {} 或 for () {} ，程序集都是完全相同的code>，每个编译器，只有 1 个微小的 g++ 异常，可能毫无意义：

g++:

    xorl    %ebx, %ebx
    leaq    _ZSt4cout(%rip), %rbp
    .p2align 4,,10
    .p2align 3
.L2:
    movl    %ebx, %esi
    movq    %rbp, %rdi
    addl    $1, %ebx
    call    _ZNSolsEi@PLT
    cmpl    $100, %ebx
    jne .L2

Exception for g++: 在 goto2 程序集的末尾，程序集添加了：（

.L3:
    endbr64

我认为这个额外的标签是从 中优化出来的goto 1 的程序集。）但我认为这完全无关紧要。

clang++：

    xorl    %ebx, %ebx
    .p2align    4, 0x90
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
    movl    $_ZSt4cout, %edi
    movl    %ebx, %esi
    callq   _ZNSolsEi
    addl    $1, %ebx
    cmpl    $100, %ebx
    jne .LBB0_1
# %bb.2:

---

结论/TL；DR：不，label: 和 的任何可能的等效排列之间似乎没有任何区别>goto、do {} while、while {} 和 for () {}，至少在使用 g++ 的 Linux 上9.3.0 和 clang++ 10.0.0。

请注意，我没有在这里测试 break 和 continue ；但是，鉴于在任何情况下为 4 个中的每一个生成的汇编代码都是相同的，我只能假设它们对于 break 和 continue 来说是完全相同的，特别是因为程序集在每个场景中都使用标签和跳转。

为了确保正确的结果，我在过程中非常细致，还使用了 Visual Studio Code 的比较文件功能。