优化了“ while（1）;” 在C ++ 0x中

更新，请参见下文！

我听说过，C ++ 0x允许编译器为以下代码段打印“ Hello”

#include <iostream>

int main() {
  while(1) 
    ;
  std::cout << "Hello" << std::endl;
}

显然，它与线程和优化功能有关。在我看来，这会让很多人感到惊讶。

有人对为什么要允许这样做有很好的解释吗？作为参考，最新的C ++ 0x草案在6.5/5

在for语句的情况下，在for-init-statement之外的循环，

• 不调用库I / O函数，并且
• 不访问或修改易失性对象，并且
• 不执行任何同步操作（1.10）或原子操作（第29条）

实现可能会假定它终止。[注意：这旨在允许编译器进行转换，例如删除空循环，即使无法证明终止也是如此。—尾注]

编辑：

这篇有见地的文章谈到了该标准文本

不幸的是，没有使用“未定义行为”一词。但是，只要该标准说“编译器可以假定P”，就意味着具有not-P属性的程序具有未定义的语义。

这是正确的，并且允许编译器为上述程序打印“ Bye”吗？

这里有一个更具洞察力的线程，它与对C的类似更改有关，由Guy在上面的链接文章中开始。在其他有用的事实中，他们提出了一种似乎也适用于C ++ 0x的解决方案（更新：在n3225上将不再起作用-参见下文！）

endless:
  goto endless;

看来，不允许编译器对其进行优化，因为这不是循环，而是跳转。另一个人总结了C ++ 0x和C201X的拟议更改

通过编写一个循环，程序员断言或者环路不可见的东西的行为（执行I / O，访问volatile对象，或进行同步或原子操作）， 或者，它最终会终止。如果我通过写一个没有副作用的无限循环违反了这一假设，那我就是对编译器撒谎，而我的程序的行为是不确定的。（如果幸运的话，编译器可能会警告我。）该语言不提供（不再提供？）一种表达无可见行为的无限循环的方法。

在2011年3月31日更新了n3225：委员会将文本移至1.10 / 24并说

该实现可以假定任何线程最终都将执行以下操作之一：

• 终止，
• 调用库I / O函数，
• 访问或修改易失性对象，或
• 执行同步操作或原子操作。

的goto把戏，不工作了！

有人对为什么要允许这样做有很好的解释吗？

是的，汉斯·勃姆（Hans Boehm）在N1528中为此提供了理由：为什么无限循环会出现未定义的行为？，尽管这是WG14文档，但其原理也适用于C ++，并且该文档同时引用了WG14和WG21：

正如N1509正确指出的那样，当前草案实际上为6.8.5p6中的无限循环提供了未定义的行为。这样做的主要问题是，它允许代码在可能终止的循环中移动。例如，假设我们有以下循环，其中count和count2是全局变量（或已使用其地址），而p是未使用其地址的局部变量：

for (p = q; p != 0; p = p -> next) {
    ++count;
}
for (p = q; p != 0; p = p -> next) {
    ++count2;
}

这两个循环可以合并并替换为以下循环吗？

for (p = q; p != 0; p = p -> next) {
        ++count;
        ++count2;
}

如果没有6.8.5p6中针对无限循环的特殊分配，这将是不允许的：如果由于q指向循环列表而导致第一个循环没有终止，则原始循环永远不会写入count2。因此，它可以与另一个访问或更新count2的线程并行运行。尽管使用了无限循环，但转换后的版本仍然可以访问count2，因此这不再安全。因此，转换可能会引入数据竞争。

在这种情况下，编译器不可能证明循环终止。它必须理解q指向一个非循环列表，我认为这是大多数主流编译器无法实现的，并且如果没有整个程序的信息，通常是不可能的。

非终止循环所施加的限制是对编译器无法证明终止的终止循环的优化，以及对实际非终止循环的优化的限制。前者比后者更常见，并且通常更有趣。

显然，还有带有整数循环变量的for循环，在该循环中，编译器将难以证明终止，因此，在没有6.8.5p6的情况下，编译器将难以重构循环。甚至像

for (i = 1; i != 15; i += 2)

要么

for (i = 1; i <= 10; i += j)

似乎很重要。（在前一种情况下，需要一些基本数论来证明终止，在后一种情况下，我们需要了解j的可能值。无符号整数的环绕可能会使这种推理进一步复杂化。 ）

这个问题似乎适用于几乎所有循环重组转换，包括编译器并行化和高速缓存优化转换，这两种转换都可能变得越来越重要，并且对于数字代码而言通常已经很重要。为了能够以最自然的方式编写无限循环，这似乎可能会变成一笔可观的成本，特别是因为我们大多数人很少有意编写无限循环。

与C的一个主要区别是C11提供了一个控制常量表达式的例外，该常量表达式不同于C ++，并使您的特定示例在C11中得到了很好的定义。

对我来说，相关的理由是：

这旨在允许编译器进行转换，例如删除空循环，即使无法证明终止也是如此。

据推测，这是因为难以机械地证明终止，并且无法证明终止会妨碍编译器，否则编译器可能会进行有用的转换，例如将非依赖操作从循环前移到循环后，反之亦然，在一个线程中执行循环后操作，同时循环在另一个循环中执行，依此类推。如果没有这些转换，则循环可能会阻塞所有其他线程，同时它们等待一个线程完成所述循环。（我宽松地使用“线程”来表示任何形式的并行处理，包括单独的VLIW指令流。）

编辑：愚蠢的例子：

while (complicated_condition()) {
    x = complicated_but_externally_invisible_operation(x);
}
complex_io_operation();
cout << "Results:" << endl;
cout << x << endl;

在这里，一个线程执行一个complex_io_operation循环的速度更快，而另一个线程执行循环中的所有复杂计算。但是如果没有引用的子句，编译器在进行优化之前必须证明两点：1）complex_io_operation()不依赖于循环的结果，以及2）循环将终止。证明1）很容易，证明2）是停顿的问题。使用该子句，可以假定循环终止并获得并行化胜利。

我还可以想象，设计师认为在生产代码中发生无限循环的情况非常少见，通常是事件驱动循环，它们以某种方式访问​​I / O。结果，他们对稀有情况（无限循环）进行了悲观，而倾向于优化更常见的情况（非无限但很难用机械方法证明非无限循环）。

但是，这确实意味着学习示例中使用的无限循环将因此而受苦，并且将增加初学者代码中的陷阱。我不能说这完全是一件好事。

编辑：关于您现在链接的有见地的文章，我会说“编译器可能会假设X有关程序”在逻辑上等同于“如果程序不满足X，则行为未定义”。我们可以如下所示：假设存在一个不满足属性X的程序。在哪里定义该程序的行为？该标准仅在属性X为true的情况下定义行为。尽管标准没有明确声明行为未定义，但它已通过遗漏声明了行为未定义。

考虑一个类似的论点：“编译器可能假设变量x在序列点之间最多只能赋值一次”等同于“未定义在两个序列点之间多次赋给x”。

我认为正确的解释是您所做的编辑：空的无限循环是未定义的行为。

我不会说这是特别直观的行为，但是这种解释比其他解释更有意义，因为可以任意允许编译器忽略无限循环而无需调用UB。

如果无限循环是UB，它只是意味着非终止的程序不被认为是有意义的：根据的C ++ 0x，他们有没有语义。

这确实有一定意义。它们是一种特殊情况，其中不再发生许多副作用（例如，从不会返回任何结果main），并且由于必须保留无限循环而妨碍了许多编译器优化。例如，如果循环没有副作用，则跨循环移动计算是完全有效的，因为最终，无论如何都将执行计算。但是，如果循环永远不会终止，我们将无法安全地重新排列循环代码，因为我们可能只是在程序挂起之前更改实际上要执行的操作。除非我们将挂起的程序视为UB。

我认为这与此类问题类似，它引用了另一个主题。优化有时可以消除空循环。

相关的问题是允许编译器对副作用不冲突的代码进行重新排序。即使编译器为无限循环生成了非终止的机器代码，也可能发生令人惊讶的执行顺序。

我相信这是正确的方法。语言规范定义了强制执行顺序的方法。如果您想要一个无法重新排序的无限循环，请编写以下代码：

volatile int dummy_side_effect;

while (1) {
    dummy_side_effect = 0;
}

printf("Never prints.\n");

我认为这个问题可能是最好的表述，因为“如果后面的代码不依赖于前面的代码，并且前面的代码对系统的任何其他部分都没有副作用，则编译器的输出即使前者包含循环，也可以在前者执行之前，之后或与之混合执行后一段代码，而无需考虑前者代码何时或是否实际完成，例如，编译器可以重写：

无效testfermat（int n）
{
  整数a = 1，b = 1，c = 1;
  while（pow（a，n）+ pow（b，n）！= pow（c，n））
  {
    如果（b> a）a ++; 否则（c> b）{a = 1; b ++}; 否则{a = 1; b = 1; c ++};
  }
  printf（“结果为”）;
  printf（“％d /％d /％d”，a，b，c）;
}

如

无效testfermat（int n）
{
  如果（fork_is_first_thread（））
  {
    整数a = 1，b = 1，c = 1;
    while（pow（a，n）+ pow（b，n）！= pow（c，n））
    {
      如果（b> a）a ++; 否则（c> b）{a = 1; b ++}; 否则{a = 1; b = 1; c ++};
    }
    signal_other_thread_and_die（）;
  }
  else //第二个线程
  {
    printf（“结果为”）;
    wait_for_other_thread（）;
  }
  printf（“％d /％d /％d”，a，b，c）;
}

尽管我可能会担心，但通常不是不合理的：

  int total = 0；
  对于（i = 0; num_reps> i; i ++）
  {
    update_progress_bar（i）;
    total + = do_something_slow_with_no_side_effects（i）;
  }
  show_result（总计）;

会成为

  int total = 0；
  如果（fork_is_first_thread（））
  {
    对于（i = 0; num_reps> i; i ++）
      total + = do_something_slow_with_no_side_effects（i）;
    signal_other_thread_and_die（）;
  }
  其他
  {
    对于（i = 0; num_reps> i; i ++）
      update_progress_bar（i）;
    wait_for_other_thread（）;
  }
  show_result（总计）;

通过让一个CPU处理计算，而另一个CPU处理进度条更新，重写将提高效率。不幸的是，这会使进度条更新的实用性大大降低。

如果编译器根本不是无限循环，则对于非平凡的情况，它是不可决定的。

在不同情况下，您的优化器可能会为您的代码达到更好的复杂度等级（例如，优化因子为O（n ^ 2），优化后得到O（n）或O（1））。

因此，要包含不允许在C ++标准中删除无限循环的规则，将使许多优化工作变得不可能。而且大多数人都不想要这个。我认为这完全可以回答您的问题。

另一件事：我从未见过任何有效的示例，其中您需要一个不执行任何操作的无限循环。

我听说过的一个例子是一个丑陋的骇客，实际上应该以其他方式解决：关于嵌入式系统，触发复位的唯一方法是冻结设备，以便看门狗自动重启它。

如果您知道任何有效/良好的示例，而您需要一个不执行任何操作的无限循环，请告诉我。

我认为值得指出的是，循环是无限的，除了它们通过非易失性，非同步变量与其他线程交互的事实外，现在可以使用新的编译器产生不正确的行为。

换句话说，使您的全局变量易变-以及通过指针/引用传递到这样的循环中的参数。