“x = x++”之后的 x 是什么？

Question

执行时（在幕后）会发生什么？

int x = 7;
x = x++;

也就是说，当变量在一个语句中后递增并分配给自身时？我编译并执行了这个。即使在整个语句之后，x 仍然是 7。在我的书中，它说 x 是递增的！

Answer 1

x = x++;

相当于

int tmp = x;
x++;
x = tmp;

Answer 2

x 确实会增加。但是您正在将 x 的旧值分配回其自身。

---

x = x++;

1. x++ 递增 x 并返回其旧值。
2. x = 将旧值分配回自身。

所以最后，x 被分配回其初始值。

Answer 3

该语句：

x = x++;

相当于：

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

简而言之，该语句没有任何作用。

要点：

• 后缀递增/递减表达式的值是递增/递减发生之前操作数的值。 （在前缀形式的情况下，该值是操作数之后运算的值，）

• 赋值表达式的 RHS 被完全求值（包括任何递增、递减和/或其他副作用）在将值分配给 LHS 之前。

_{请注意，与 C 和 C++ 不同，Java 中表达式的求值顺序是完全指定的，没有平台特定变化的空间。仅当这不会改变从当前线程的角度执行代码的结果时，才允许编译器对操作进行重新排序。在这种情况下，编译器将被允许优化整个语句，因为可以证明它是一个无操作。}

---

如果它还不是很明显：

• “x = x++;”几乎可以肯定任何程序中都会有一个错误。
• OP（对于最初的问题！）可能意味着“x++;”而不是“x = x++;”。
• 在同一变量上结合自动递增/递减和赋值的语句很难理解，因此无论其正确性如何，都应该避免。根本不需要编写这样的代码。

希望像 FindBugs 和 PMD 这样的代码检查器能够将这样的代码标记为可疑。

Answer 4

int x = 7;
x = x++;

它在 C 中具有未定义的行为，对于 Java，请参见 这个答案。这取决于编译器会发生什么。

Answer 5

像 x = x++; 这样的构造表明您可能误解了 ++ 运算符的作用：

// original code
int x = 7;
x = x++;

让我们在删除 的基础上重写它以执行相同的操作++ 运算符：

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

现在，让我们重写它来执行您想要的操作（我认为）：

// original code
int x = 7;
x++;

这里的微妙之处在于 ++ 运算符修改了变量 x< /code>，与诸如此类的表达式不同x + x，其计算结果为 int 值，但变量 x 本身保持不变。考虑像古老的 for 循环这样的构造：

for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

注意到其中的 i++ 了吗？是同一个运营商。我们可以像这样重写这个 for 循环，它的行为是相同的：

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

我还建议在大多数情况下不要在较大的表达式中使用 ++ 运算符。由于当它在前增量和后增量中修改原始变量（分别是++x和x++）的微妙之处，它很容易引入难以追踪的微妙错误。

Answer 6

根据从类文件中获取的字节码，

两次赋值都会增加x，但不同的是时间当值被压入堆栈时

在 Case1 中，Push 在增量之前发生（然后分配）（本质上意味着您的增量不执行任何操作）

在 Case2< /代码>,首先发生增量（使其变为 8），然后压入堆栈（然后分配给 x）

情况 1：

int x=7;
x=x++;

字节代码：

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

---

情况 2：

int x=7; 
x=++x;

字节码

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

• 这里的栈是指操作数栈，本地：x 索引：1 类型：int

Answer 7

后递增运算符的工作原理如下：

1. 存储操作数的先前值。
2. 增加操作数的值。
3. 返回操作数的前一个值。

因此，该语句

int x = 7;
x = x++; 

将按如下方式求值：

1. x 用值 7 进行初始化
2. ，后增量运算符存储 x 的先前值，即要返回的 7。
3. 增加 x，所以现在 x 是 8
4. 返回 x 的先前值，即 7，并将其分配回 x，因此 x 再次变为 7

所以 x 确实增加了，但由于 x++ 将结果分配回x 因此 x 的值将被覆盖为其先前的值。

Answer 8

它在“x = x++;”之后递增。如果执行“x = ++x;”，则为 8。

Answer 9

递增发生在调用 x 之后，因此 x 仍然等于 7。当调用 x 时，++x 将等于 8

Answer 10

当您重新分配 x 的值时，它仍然是 7。尝试 x = ++x，您将得到 8，否则可以

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

Answer 11

因为 x++ 在将值分配给变量后递增该值。
依此类推，在执行该行期间：

x++;

变量 x 仍将具有原始值 (7)，但在另一行上再次使用 x，例如

System.out.println(x + "");

将为您提供 8。

如果您想在您的代码上使用 x 的增量值赋值语句，使用

++x;

这会将 x 加 1，然后将该值赋给变量 x。

[编辑]
而不是 x = x++，它只是 x++；前者将 x 的原始值分配给自身，因此它实际上在那一行上不执行任何操作。

Answer 12

当 int x = 7; 时会发生什么？ x = x++;？

答-> x++表示先用x的值进行表达式，然后将其加1。
这就是你的情况发生的情况。将右侧 x 的值复制到左侧变量 x，然后将 x 的值加 1。

同样，++x 表示 -> code> 先将 x 的值加一，然后在表达式中使用。
因此，在您的情况下，如果您执行 x = ++x ; // 其中 x = 7
您将得到值 8。

为了更清楚地了解，请尝试找出有多少 printf 语句将执行以下代码

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

Answer 13

++x 是预递增 -> x 在使用之前递增
x++ 是后递增-> x 在使用之后递增

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

Answer 14

所以这意味着：
x++ 不等于 x = x+1

因为：

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

现在看起来有点奇怪：

int x = 7; x = x+=1;
x is 8

非常依赖编译器！

Answer 15

最简单的解释！

这是因为 ++ 在操作数使其后递增之后，意味着首先将值分配给变量 &然后递增。如果您期望 x 值为 8，那么您应该像下面提到的方式预先递增它：

Answer 16

x = x++；

这是后置自增运算符。应该理解为“使用操作数的值，然后递增操作数”。

如果您希望发生相反的情况，即“递增操作数，然后使用操作数的值”，则必须使用预递增运算符，如下所示。

x = ++x；

该运算符首先将 x 的值增加 1，然后将该值赋回 x。

Answer 17

我认为这个争议可以在不涉及代码和代码的情况下得到解决。只是想。

考虑 i++ & ++i 作为函数，例如 Func1 &功能2。

现在我=7；
Func1(i++) 返回 7，Func2(++i) 返回 8（每个人都知道这一点）。在内部，这两个函数都将 i 增加到 8 ，但它们返回不同的值。

所以 i = i++ 调用函数 Func1。在函数内部，i 递增到 8，但完成后函数返回 7。

因此最终 7 被分配给 i。 （所以最后，i = 7）

Answer 18

这是因为您使用了后递增运算符。
在下面的代码行中

x = x++;

，您将 x 的值分配给 x。 x++ 在将 x 的值赋给 x 后递增 x。这就是后自增运算符的工作原理。它们在执行语句后起作用。因此，在您的代码中，首先返回 x，然后再递增。

如果您这样做，

x = ++x;

答案将为 8，因为您使用了预自增运算符。在返回 x 的值之前，首先增加该值。