c++ - 运算符优先级与计算顺序

Question

术语“运算符优先级”和“求值顺序”是编程中非常常用的术语，对于程序员来说非常重要。而且，据我所知，这两个概念是紧密联系在一起的；在谈论表达时，一个人离不开另一个。

让我们举一个简单的例子:

int a=1;  // Line 1
a = a++ + ++a;  // Line 2
printf("%d",a);  // Line 3

现在，很明显 Line 2导致未定义行为，因为 Sequence points in C and C++ 包括:

1. Between evaluation of the left and right operands of the && (logical AND), || (logical OR), and comma operators. For example, in the expression *p++ != 0 && *q++ != 0, all side effects of the sub-expression *p++ != 0 are completed before any attempt to access q.

2. Between the evaluation of the first operand of the ternary "question-mark" operator and the second or third operand. For example, in the expression a = (*p++) ? (*p++)
: 0 there is a sequence point after the first *p++, meaning it has already been incremented by the time the second instance is executed.

3. At the end of a full expression. This category includes expression statements (such as the assignment a=b;), return statements, the controlling expressions of if, switch, while, or do-while statements, and all three expressions in a for statement.

4. Before a function is entered in a function call. The order in which the arguments are evaluated is not specified, but this sequence point means that all of their side effects are complete before the function is entered. In the expression f(i++) + g(j++) + h(k++), f is called with a parameter of the original value of i, but i is incremented before entering the body of f. Similarly, j and k are updated before entering g and h respectively. However, it is not specified in which order f(), g(), h() are executed, nor in which order i, j, k are incremented. The values of j and k in the body of f are therefore undefined.3 Note that a function call f(a,b,c) is not a use of the comma operator and the order of evaluation for a, b, and c is unspecified.

5. At a function return, after the return value is copied into the calling context. (This sequence point is only specified in the C++ standard; it is present only implicitly in C.)

6. At the end of an initializer; for example, after the evaluation of 5 in the declaration int a = 5;.

因此，通过第 3 点:

在一个完整的表达结束时。此类别包括表达式语句(例如赋值 a=b;)、return 语句、if、switch、while 或 do-while 语句的控制表达式以及 for 语句中的所有三个表达式。
Line 2显然会导致未定义的行为。这显示了 未定义行为 与 紧密结合序列点 .

现在让我们再举一个例子:

int x=10,y=1,z=2; // Line 4
int result = x<y<z; // Line 5

现在很明显 Line 5将使变量 result店铺 1 .

现在表达式 x<y<z在 Line 5可以评估为:
x<(y<z)或 (x<y)<z .在第一种情况下 result 的值将是 0在第二种情况下 result将是 1 .但我们知道，当 Operator Precedence是 Equal/Same - Associativity开始起作用，因此被评估为 (x<y)<z .

这就是这个 MSDN Article中所说的:

C 运算符的优先级和结合性会影响表达式中操作数的分组和计算。仅当存在具有更高或更低优先级的其他运算符时，运算符的优先级才有意义。首先评估具有更高优先级运算符的表达式。优先级也可以用“绑定(bind)”这个词来描述。具有更高优先级的运算符被认为具有更紧密的绑定(bind)。

现在，关于上述文章:

它提到“首先评估具有更高优先级运算符的表达式”。

听起来可能不正确。但是，如果我们考虑到 ()，我认为这篇文章并没有说错什么。也是运算符 x<y<z与 (x<y)<z 相同.我的推理是，如果关联性不发挥作用，那么完整的表达式评估将变得不明确，因为 <不是 Sequence Point .

另外，我发现的另一个链接在 Operator Precedence and Associativity 上说到。 :

此页面按优先顺序(从高到低)列出了 C 运算符。它们的结合性指示在表达式中应用相同优先级的运算符的顺序。

所以拿， int result=x<y<z的第二个例子，我们可以在这里看到，在所有 3 个表达式中， x , y和 z ，因为，最简单的表达式形式由单个文字常量或对象组成。因此表达式的结果 x , y , z会在那里 右值 ，即 10 , 1和 2分别。因此，现在我们可以解释 x<y<z如 10<1<2 .

现在，结合性没有发挥作用，因为现在我们有 2 个要计算的表达式， 10<1或 1<2并且由于运算符的优先级相同，它们是从左到右计算的？

以最后一个例子作为我的论点:

int myval = ( printf("Operator\n"), printf("Precedence\n"), printf("vs\n"),
printf("Order of Evaluation\n") );

现在在上面的例子中，由于 comma运算符具有相同的优先级，表达式被评估 left-to-right和最后一个 printf() 的返回值存储在 myval .

在 SO/IEC 9899:201x下 J.1 未指明的行为 它提到:

计算子表达式的顺序和副作用的顺序
发生，除非为函数调用 ()、&&、||、?: 和逗号指定
运营商(6.5)。

现在我想知道，这样说会不会错:

评估顺序取决于运算符的优先级，留下未指定行为的情况。

如果我在问题中所说的有任何错误，我希望得到纠正。
我发布这个问题的原因是因为 MSDN 文章在我脑海中造成了困惑。是不是在 错误 或不？

Answer 1

是的，MSDN 文章是错误的，至少在标准 C 和 C++1 方面是错误的。

话虽如此，让我从有关术语的注释开始:在 C++ 标准中，它们(主要是——有一些失误)使用“评估”来指代对操作数的评估，而“值计算”来指代进行手术。所以，当(例如)你做 a + b ，各a和 b求值，然后进行值计算以确定结果。

很明显，值计算的顺序(主要)由优先级和关联性控制——控制值计算基本上是优先级和关联性的定义。这个答案的其余部分使用“评估”来指代操作数的评估，而不是值(value)计算。

现在，关于由优先级确定的评估顺序，不，不是!就这么简单。举个例子，让我们考虑一下你的例子 x<y<z .根据关联规则，这解析为 (x<y)<z .现在，考虑在堆栈机器上计算这个表达式。完全允许它做这样的事情:

 push(z);    // Evaluates its argument and pushes value on stack
 push(y);
 push(x);
 test_less();  // compares TOS to TOS(1), pushes result on stack
 test_less();

这评估 z之前 x或 y ，但仍然评估 (x<y) ，然后将该比较的结果与 z 进行比较，正如它应该的那样。

总结:求值顺序与结合性无关。

优先级是一样的。我们可以将表达式更改为 x*y+z ，并且仍然评估 z之前 x或 y :

push(z);
push(y);
push(x);
mul();
add();

总结:求值顺序与优先级无关。

当/如果我们添加副作用，这保持不变。我认为将副作用视为由单独的执行线程执行是有教育意义的，带有 join在下一个序列点(例如，表达式的结尾)。所以像 a=b++ + ++c;可以这样执行:

push(a);
push(b);
push(c+1);
side_effects_thread.queue(inc, b);
side_effects_thread.queue(inc, c);
add();
assign();
join(side_effects_thread);

这也说明了为什么明显的依赖性也不一定影响评估顺序。即使 a是分配的目标，这仍然评估 a在评估 b 之前或 c .另请注意，虽然我在上面将其写为“线程”，但这也可以是一个线程池，所有线程都并行执行，因此您也无法保证一个增量与另一个增量的顺序。

除非硬件直接(且廉价)支持线程安全队列，否则这可能不会在实际实现中使用(即使这样也不太可能)。将某些内容放入线程安全队列通常比执行单个增量具有更多的开销，因此很难想象现实中有人会这样做。然而，从概念上讲，这个想法符合标准的要求:当您使用前/后自增/自减操作时，您指定的操作将在计算该部分表达式之后的某个时间发生，并将在下一个序列点。

编辑:虽然它不完全是线程，但某些架构确实允许这种并行执行。例如，Intel Itanium 和 VLIW 处理器(例如某些 DSP)允许编译器指定要并行执行的多个指令。大多数 VLIW 机器都有特定的指令“数据包”大小，用于限制并行执行的指令数量。 Itanium 也使用指令包，但在指令包中指定一个位表示当前包中的指令可以与下一个包中的指令并行执行。使用这样的机制，您可以获得并行执行的指令，就像您在我们大多数人更熟悉的架构上使用多线程一样。

总结:求值顺序独立于明显的依赖关系

任何在下一个序列点之前使用该值的尝试都会产生未定义的行为——特别是，“另一个线程”在那段时间内(可能)正在修改该数据，并且您无法与另一个线程同步访问。任何使用它的尝试都会导致未定义的行为。

仅举一个(不可否认，现在相当牵强)的例子，想想你的代码在 64 位虚拟机上运行，​​但真正的硬件是一个 8 位处理器。当您递增 64 位变量时，它会执行类似以下内容的序列:

load variable[0]
increment
store variable[0]
for (int i=1; i<8; i++) {
    load variable[i]
    add_with_carry 0
    store variable[i]
}

如果您读取该序列中间某处的值，您可以获得一些只修改了一些字节的内容，因此您得到的既不是旧值也不是新值。

这个确切的例子可能相当牵强，但不那么极端的版本(例如，32 位机器上的 64 位变量)实际上相当普遍。

结论

求值顺序不 不是 依赖于优先级、关联性或(必然)依赖于明显的依赖关系。尝试使用在表达式的任何其他部分应用了前/后增量/减量的变量确实会产生完全未定义的行为。虽然不太可能发生实际崩溃，但您绝对不能保证获得旧值或新值——您可能会得到完全不同的东西。

1 我没有检查过这篇特定的文章，但有相当多的 MSDN 文章讨论了 Microsoft 的 Managed C++ 和/或 C++/CLI(或特定于他们的 C++ 实现)，但很少或没有指出他们没有适用于标准 C 或 C++。这可能给人一种虚假的印象，即他们声称他们决定应用于自己语言的规则实际上适用于标准语言。在这些情况下，这些文章在技术上并不是错误的——它们只是与标准 C 或 C++ 没有任何关系。如果您尝试将这些语句应用于标准 C 或 C++，结果为假。