Java中的方程"i++ + ++i"的计算顺序是什么?

What's the calculation order of the equation "i++ + ++i" in Java?

考虑片段:

int a = 1, b = 1, c = 1;
System.out.println(a + ++a);
System.out.println(b++ + ++b);
System.out.println(c++ + c);

输出为:

3
4
3

这是我认为正在发生的事情,但输出不匹配:

1. ++a -> +a -> 4 = 2 + 2
2. ++b -> +b -> 4 = 2 + 2
3. c -> +c -> 2 = 1 + 1

一元post和前置自增的优先级高于加法:

  1. b = 1,b初始化为1.
  2. b++,b在等式中的当前值为1,b递增.
  3. ++b,b由于post-increment而递增,所以它是2。现在它由于预递增而再次递增,它在等式中的值为3。
  4. 1 + 3 是 4.

事情是,预递增 递增变量,然后 returns 它 因此在 ++1 中,值递增,然后返回, 计算结果为 2。使用 post 递增,返回 变量值,然后递增 。因此 1++ 将评估为 1,然后在以后的引用中增加到 2。所以:

  1. b++ + ++b
    ^^^
    post-increment, evaluates to 1
    
  2. 1 + ++b
        ^^^
        pre-increment, due to post-increment is 2, then pre-increments and evaluates to 3
    
  3. 1 + 3
    ^^^^^
    evaluates to 4
    

这也适用于第一个和第三个示例。对于 a + ++a++a 具有更高的优先级。首先,计算 a,此时为 1,然后计算 ++a,因为它具有更高的优先级,其中 a 递增,然后值 returns 并计算到 2。然后,计算加法,如下所示:

  1. a + ++a
    ^
    nothing, evaluates to 1
    
  2. 1 + ++a
        ^^^
        pre-increment, evaluates to 2
    
  3. 1 + 2
    ^^^^^
    evaluates to 3
    

在第三个示例中,c++ + cc 是 post 递增的,因此它的计算结果为 1,然后递增。最后的 c 是 2,看起来像这样:

  1. c++ + c
    ^^^
    post-increment, evaluates to 1
    
  2. 1 + c
        ^
        nothing, due to post-increment is 2 and evaluates to 2
    
  3. 1 + 2
    ^^^^^
    evaluates to 3
    

因此输出:

3
4
3

请注意,优先级并不决定评估顺序。优先级仅更改表达式的括号。 Java 中的求值顺序是 总是从左到右 , unlike C/C++, see JLS 15.7.

我们知道,x++++x 做同样的事情,只是方式略有不同。 x++ returns 该值然后递增。 ++x 增加值然后 returns 它。

逻辑不错,但是你忘了一些东西。

首先,您取 a,即 1,并将其添加到 ++a。前面的 ++ 使它从一增加到二,现在等式是 1 + 2。那是三个。

你拿b++b 之前是 1,因为你把 ++ 放在后面,它给等式的其余部分初始值 1,然后将变量递增到 2。但是你忘记了,即使值我们从b++得到的是1,在内存中,b现在是2。由于b是2,下一部分,++b returns 3.

同样的错误发生在第三部分。 c returns 1,然后增加到 2。然后你将 1 加到 c,自从你递增后它现在是 2,你得到 3.

事情是这样的:

一个:1 + 2 = 3

b: 1 + 3 = 4

c: 1 + 2 = 3

a++ 的计算结果为 a,然后递增 a。 ++a 先递增 a,然后 returns a.

http://introcs.cs.princeton.edu/java/11precedence/ 的运算符优先级图表中,您可以看到加法是从左到右进行的。

查看您的每个示例,其中每个变量都从 1 开始:

a + ++aa 加到 a 上加 1。这给了我们 1+2 (3).

b++ + ++b: b before 它的递增被添加到 b 在它被递增 b++ 之后递增 ++b。这给了我们 1+3 (4).

c++ + cc 在递增之前被添加到 c 在递增之后,给出 1+2 (3)。