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和前置自增的优先级高于加法:
b = 1
,b
初始化为1.
b++
,b
在等式中的当前值为1,则b
递增.
++b
,b
由于post-increment而递增,所以它是2。现在它由于预递增而再次递增,它在等式中的值为3。
1 + 3
是 4.
事情是,预递增 递增变量,然后 returns 它 因此在 ++1
中,值递增,然后返回, 计算结果为 2。使用 post 递增,返回 变量值,然后递增 。因此 1++
将评估为 1,然后在以后的引用中增加到 2。所以:
b++ + ++b
^^^
post-increment, evaluates to 1
1 + ++b
^^^
pre-increment, due to post-increment is 2, then pre-increments and evaluates to 3
1 + 3
^^^^^
evaluates to 4
这也适用于第一个和第三个示例。对于 a + ++a
,++a
具有更高的优先级。首先,计算 a
,此时为 1,然后计算 ++a
,因为它具有更高的优先级,其中 a
递增,然后值 returns 并计算到 2。然后,计算加法,如下所示:
a + ++a
^
nothing, evaluates to 1
1 + ++a
^^^
pre-increment, evaluates to 2
1 + 2
^^^^^
evaluates to 3
在第三个示例中,c++ + c
、c
是 post 递增的,因此它的计算结果为 1,然后递增。最后的 c
是 2,看起来像这样:
c++ + c
^^^
post-increment, evaluates to 1
1 + c
^
nothing, due to post-increment is 2 and evaluates to 2
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 + ++a
:a
加到 a
上加 1。这给了我们 1+2 (3).
b++ + ++b
: b
before 它的递增被添加到 b
在它被递增 b++
之后递增 ++b
。这给了我们 1+3 (4).
c++ + c
:c
在递增之前被添加到 c
在递增之后,给出 1+2 (3)。
考虑片段:
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和前置自增的优先级高于加法:
b = 1
,b
初始化为1.b++
,b
在等式中的当前值为1,则b
递增.++b
,b
由于post-increment而递增,所以它是2。现在它由于预递增而再次递增,它在等式中的值为3。1 + 3
是 4.
事情是,预递增 递增变量,然后 returns 它 因此在 ++1
中,值递增,然后返回, 计算结果为 2。使用 post 递增,返回 变量值,然后递增 。因此 1++
将评估为 1,然后在以后的引用中增加到 2。所以:
b++ + ++b ^^^ post-increment, evaluates to 1
1 + ++b ^^^ pre-increment, due to post-increment is 2, then pre-increments and evaluates to 3
1 + 3 ^^^^^ evaluates to 4
这也适用于第一个和第三个示例。对于 a + ++a
,++a
具有更高的优先级。首先,计算 a
,此时为 1,然后计算 ++a
,因为它具有更高的优先级,其中 a
递增,然后值 returns 并计算到 2。然后,计算加法,如下所示:
a + ++a ^ nothing, evaluates to 1
1 + ++a ^^^ pre-increment, evaluates to 2
1 + 2 ^^^^^ evaluates to 3
在第三个示例中,c++ + c
、c
是 post 递增的,因此它的计算结果为 1,然后递增。最后的 c
是 2,看起来像这样:
c++ + c ^^^ post-increment, evaluates to 1
1 + c ^ nothing, due to post-increment is 2 and evaluates to 2
1 + 2 ^^^^^ evaluates to 3
因此输出:
3
4
3
请注意,优先级并不决定评估顺序。优先级仅更改表达式的括号。 Java 中的求值顺序是 总是从左到右 和
我们知道,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 + ++a
:a
加到 a
上加 1。这给了我们 1+2 (3).
b++ + ++b
: b
before 它的递增被添加到 b
在它被递增 b++
之后递增 ++b
。这给了我们 1+3 (4).
c++ + c
:c
在递增之前被添加到 c
在递增之后,给出 1+2 (3)。