后置增量 i++ 何时执行？被处决？

Question

可能的重复：
未定义的行为和序列点

在机器代码级别的 C++ 中，后自增 ++ 运算符何时执行被处决？

优先级表表明 postfix++ 运算符是级别 2：这意味着在

int x = 0 ;
int y = x++ + x++ ;  // ans: y=0

The postfix ++ 中首先执行。

然而，这行代码的逻辑运算似乎是先进行加法（0+0），但这是如何发生的呢？

我的想象如下：

// Option 1:
// Perform x++ 2 times.
// Each time you do x++, you change the value of x..
// but you "return" the old value of x there?
int y = 0 + x++ ;  // x becomes 1, 0 is "returned" from x++

// do it for the second one..
int y = 0 + 0 ;  // x becomes 2, 0 is "returned" from x++... but how?
// if this is really what happens, the x was already 1 right now.

因此，另一个选项是虽然 x++ 在优先级表上比 x + x 更高，但由于 x++ 生成的代码被插入到加法操作的下方

// Option 2:  turn this into
int y = x + x ; // 
x++ ;
x++ ;

第二个选项似乎为了更有意义，但我对这里的操作顺序感兴趣。具体来说，x何时改变？

Answer 1

我不会直接讨论 UB 示例的细节，而是讨论以下完美的示例：

int a = 0, b = 0;
int c = a++ + b++;

现在，运算符的优先级意味着最后一行相当于：

int c = (a++) + (b++);

而不是：

int c = (a++ + b)++; // compile time error, post increment an rvalue

另一方面，后增量相当于两条单独的指令（从这里开始只是一个心理图片）：

a++; // similar to: (__tmp = a, ++a, __tmp) 
     // -- ignoring the added sequence points of , here

也就是说，原始表达式将被编译器解释为：

auto __tmp1 = a;         // 1
auto __tmp2 = b;         // 2
++a;                     // 3
++b;                     // 4
int c = __tmp1 + __tmp2; // 5

但只要满足以下约束，编译器就可以对 5 条指令重新排序满足（其中x>y表示x必须在y之前执行，或者x先于y）：

1 > 3        // cannot increment a before getting the old value
2 > 4        // cannot increment b before getting the old value
1 > 5, 2 > 5 // the sum cannot happen before both temporaries are created

不同指令的执行顺序没有其他限制，因此以下都是有效的顺序：

1, 2, 3, 4, 5
1, 2, 5, 3, 4
1, 3, 2, 4, 5
...

Answer 2

这

int y = x++ + x++ ;

是未定义的行为。任何事情都可能发生，包括一些不合理的结果、程序崩溃或其他任何情况。只是不要那样做。

Answer 3

在 C++ 中，有一些称为“序列点”的东西。如果在没有中间序列点的情况下多次更改某个值，则行为为未定义。

考虑以下情况：

int x = 0;
int y = x++ + x++;

y 的值可以是 0、1 或其他完全随机的值。

底线是，不要这样做。这样做不会有什么好处。 :-)

Answer 4

在您的情况下，当您使用 x++ 时，似乎会发生以下情况

，x 在操作完成后递增。

int y = x++ + x++ ;
// First add 0+0
// Increment x
// Increment 

然而

int y = ++x + ++x ;
// Add (increment x) and (increment x) = 1+1 = 2

，不同的编译器会以不同的方式处理它，如果您在同一条语句中递增两次，您的应用程序可能会崩溃。