为什么不同的 C++编译器对此代码给出不同的结果？

Question

我正在编写一些 C++ 代码以供娱乐和练习，以了解有关语言功能的更多信息。我想更多地了解静态变量及其在递归函数中的行为。在 g++ 编译器中尝试此代码，得到了预期结果：

#include <iostream>
using namespace std;

int f(const int& value)
{
   static int result = 0;
   return result += value;
}

int main()
{
   cout << f(10) << ", " << f(f(10)) << ", " << f(f(f(10)));
   return 0;
}

但我的朋友在 Microsoft Visual C++ 6 中测试了相同的代码。输出为 50, 80, 90 我用其他 C++ 编译器（g++、 Borland、Code::blocks 和 Linux、Win 和 Mac 下的 MingW）输出为 110, 100, 40。我不明白输出怎么会是 50, 80, 90 ...

为什么 MSVC 的输出不同？

Answer 1

以下三个子表达式的计算顺序未指定：

f(10)
f(f(10))
f(f(f(10)))

编译器可以按任何顺序计算这些子表达式。您不应依赖程序中特定的求值顺序，特别是如果您打算使用多个编译器进行编译。

这是因为该表达式中的任何位置都没有序列点。唯一的要求是在需要结果之前（即在打印结果之前）对每个子表达式进行计算。

在您的示例中，实际上有几个子表达式，我在这里将其标记为 a 到 k：

//   a  b     c       d  e f      g       h  i j k
cout << f(10) << ", " << f(f(10)) << ", " << f(f(f(10)));

对 operator<< (a, c< /code>、d、g 和 h）都必须按顺序求值，因为每个都取决于前一个调用的结果。同样，b 必须在 a 计算之前计算，并且 k 必须在 j 之前计算，可以计算 i 或 h。

但是，其中一些子表达式之间不存在依赖关系：b 的结果不依赖于 k 的结果，因此编译器可以自由生成计算 b 的代码。代码>k然后b或b然后k。

有关序列点和相关未指定和未定义行为的更多信息，请考虑阅读 Stack Overflow C++ 常见问题解答文章 “未定义的行为和序列点”（您的程序没有任何未定义的行为，但本文的大部分内容仍然适用）。

Answer 2

仅仅因为输出在屏幕上从左到右显示并不意味着计算顺序遵循相同的方向。在 C++ 中，函数参数的求值顺序未指定。另外，通过 << 运算符打印数据只是调用函数的奇特语法。

简而言之，如果您说operator<<(foo(), bar())，编译器可以先调用foo或bar。这就是为什么调用具有副作用的函数并将其用作其他函数的参数通常是一个坏主意。

Answer 3

准确了解它在做什么的简单方法：

int f(const int& value, int fID)
{
   static int result = 0;
   static int fCounter = 0;
   fCounter++;
   cout << fCounter << ".  ID:" << fID << endl;    
   return result += value;
}

int main()
{
   cout << f(10, 6) << ", " << f(f(10, 4), 5) << ", " << f(f(f(10, 1),2),3);
   return 0;
}

我同意其他人在答案中所说的内容，但这将使您能够准确了解它在做什么。 :)

Answer 4

前缀运算符语法被翻译为以下前缀表示法：

<<( <<( <<( cout, f(10) ), f(f(10)) ), f(f(f(10))) )
 A   B   C

现在有三个不同的函数调用，分别标识为上面的 A、B 和 C。每个调用的参数为：

     arg1        arg2
A: result of B, f(10)
B: result of C, f(f(10))
C: cout       , f(f(f(10)))

对于每个调用，编译器可以以任何顺序计算参数，为了正确计算 A 的第一个参数，必须首先计算 B，对于第一个参数也是如此B 的参数，必须评估整个 C 表达式。这意味着第一个参数依赖项要求 A、B 和 C 的执行存在偏序。每个调用和两个参数的计算也有部分排序，因此 B₁ 和 B₂ （指调用 B 的第一个和第二个参数） 这些部分顺序不会导致

对执行调用的唯一要求，因为编译器可以决定在尝试计算第一个参数之前执行所有第二个参数，从而导致等效路径：

tmp1 = f(10); tmp2 = f(f(10)); tmp3 = f(f(f(10)));
cout << tmp1 << tmp2 << tmp3;

or

tmp3 = f(f(f(10))); tmp2 = f(f(10)); tmp1 = f(10);
cout << tmp1 << tmp2 << tmp3;

or

tmp2 = f(f(10)); tmp1 = f(10); tmp3 = f(f(f(10)));
cout << tmp1 << tmp2 << tmp3;

or ...继续组合。