为什么在 for 循环的迭代部分将前置增量更改为后置增量不会产生影响？

Question

为什么

 int x = 2;
    for (int y =2; y>0;y--){
        System.out.println(x + " "+ y + " ");
        x++;
    }

打印出来的结果和这个一样？

 int x = 2;
        for (int y =2; y>0;--y){
            System.out.println(x + " "+ y + " ");
            x++;
        }

到目前为止，据我了解，后递增首先“按原样”使用，然后递增。都是先加后用预增量。为什么这不适用于 for 循环体？

Answer 1

该循环相当于：

int x = 2;
{
   int y = 2;
   while (y > 0)
   {
      System.out.println(x + " "+ y + " ");
      x++;
      y--; // or --y;
   }
}

正如您从阅读该代码中看到的那样，在 for 循环的第三部分中使用后递减运算符还是前递减运算符并不重要。

更一般地说，任何以下形式的 for 循环都

for (ForInit ; Expression ; ForUpdate)
    forLoopBody();

与 while 循环完全相同：

{
    ForInit;
    while (Expression) {
        forLoopBody();
        ForUpdate;
    }
}

for 循环更紧凑，因此更容易解析这种常见的习惯用法。

Answer 2

为了可视化这些内容，请将 for 循环扩展为 while 循环：

for (int i = 0; i < 5; ++i) {
    do_stuff(i);
}

扩展为：

int i = 0;
while (i < 5) {
    do_stuff(i);
    ++i;
}

对循环计数器进行后增量还是预增量并不重要，因为增量表达式的结果（之前或之后的值）增量）不在同一语句中使用。

Answer 3

如果您关心的话，性能方面没有区别。只有当您在增量期间使用它时，它才会被错误使用（因此对错误敏感）。

考虑：

for (int i = 0; i < 3;)
   System.out.print(++i + ".."); //prints 1..2..3


for (int i = 0; i < 3;)
   System.out.print(i++ + ".."); //prints 0..1..2

或者

for (int i = 0; i++ < 3;)
   System.out.print(i + ".."); //prints 1..2..3


for (int i = 0; ++i < 3;)
   System.out.print(i + ".."); //prints 1..2

然而，有趣的细节是，正常的习惯用法是在 for 语句的增量表达式中使用 i++，并且 Java 编译器将编译它，就像 使用++i。

Answer 4

++i 和 i++ 与赋值运算符（例如 int num = i++ 和 int num = ++i 或其他表达式）结合使用时会有所不同。
在上面的FOR循环中，只有递增条件，因为它不与任何其他表达式组合使用，所以没有任何区别。在这种情况下，它仅意味着 i = i + 1。

Answer 5

该循环与 while 循环相同：

int i = 0;
while(i < 5)
{
     // LOOP
     i++; // Or ++i
}

所以是的，它必须相同。

Answer 6

因为这个声明只是它自己的。增量的顺序在那里并不重要。

Answer 7

这两种情况是等效的，因为 i 的值是在增量语句完成后进行比较的。然而，如果你这样做了

if (i++ < 3) 

，

if (++i < 3)

你就必须担心事情的顺序。

如果你

i = ++i + i++;

这样做了，那你就是疯了。

Answer 8

因为您的示例中没有任何内容使用从前增量或后增量返回的值。尝试在 ++x 和 x++ 周围包裹一个 System.out.println() 以查看差异。

Answer 9

来自 Java 语言规范中有关 for 循环的章节< /a>:

基本语句：

 for ( ForInit ; 表达式 ; ForUpdate ) 语句

...如果 ForUpdate 部分存在，
表达式的计算结果为
从左到右的顺序； 他们的
值（如果有）将被丢弃。 ...
如果 ForUpdate 部分不存在，
未采取任何行动。

（亮点是我的）。

Answer 10

输出是相同的，因为“for（初始；比较；增量）”中的“增量”项不使用语句的结果，它仅依赖于方面 -语句的效果，在本例中是递增“i”，这在两种情况下是相同的。

Answer 11

因为y的值是在for语句中计算的，x的值是在它自己的行中计算的，但是在System中.out.println 它们仅被引用。

如果您在 System.out.println 内递减，您将得到不同的结果。

System.out.println(y--);
System.out.println(--y);

Answer 12

检查是在计算增量参数之前完成的。 “增量”操作是在循环结束时完成的，即使它是在循环开始时声明的。

Answer 13

试试这个例子：

int i = 6;
System.out.println(i++);
System.out.println(i);

i = 10;
System.out.println(++i);
System.out.println(i);

你应该能够从中弄清楚它的作用。

Answer 14

这里有很多好的答案，但以防万一这有帮助：

将 y-- 和 --y 视为具有副作用的表达式，或一个语句后跟一个表达式。 y-- 就像这样（将这些示例视为伪汇编）：

decrement y
return y

并且 --y 这样做：

store y into t
decrement y
load t
return t

在循环示例中，无论哪种方式，您都会丢弃返回的值，并且仅依赖于副作用（循环检查发生在递减语句执行之后；它不接收/检查递减返回的值）。

Answer 15

如果 for 循环使用表达式 i++ 或 ++i 的结果来执行某些操作，那么它就是 true，但事实并非如此，它的存在只是因为它的副作用。

这就是为什么您还可以在那里放置一个 void 方法，而不仅仅是一个数字表达式。

Answer 16

增量作为独立语句执行。所以

你——；

和

--y；

彼此等价，并且都等价于

y = y - 1；

Answer 17

因为：

int x = 2;
for (int y =2; y>0; y--){
    System.out.println(x + " "+ y + " ");
    x++;
}

编译器有效地将其翻译为：

int x = 2;
int y = 2
while (y > 0){
    System.out.println(x + " "+ y + " ");
    x++;
    y--;
}

如您所见，使用 y-- 或 --y 不会产生任何差异。不过，如果您像这样编写循环，则会产生不同的结果：

int x = 2;
for (int y = 3; --y > 0;){
    System.out.println(x + " "+ y + " ");
    x++;
}

这将产生与循环的两个变体相同的结果，但从 --y 更改为 y--< /code> 这里会破坏你的程序。

Answer 18

这是一个品味问题。他们做同样的事情。

如果您查看 java 类的代码，您会看到带有后增量的 for 循环。

Answer 19

就你而言，它是相同的，没有任何区别。

Answer 20

你是对的。在本例中可以看出差异：

for(int i = 0; i < 5; )
       {
            System.out.println("i is : " + ++i);           
       }

Answer 21

是的，它是按顺序执行的。初始化，然后评估条件，如果为真则执行主体，然后递增。

仅当您使用增量/减量进行赋值操作时，前缀和后缀的差异才会明显。

Answer 22

没有区别，因为 for“参数”的每个部分都是单独的语句。

有趣的是，编译器可以决定用预增量替换简单的后增量，这不会改变代码。

Answer 23

他们的行为不一样。使用 i++ 的构造比使用 ++i 的构造稍慢，因为前者涉及返回 i 的旧值和新值。另一方面，后者只返回i的旧值。

然后，出于性能原因，编译器可能会施展一点魔法，将任何孤立的 i++ 更改为 ++i，但就原始算法而言，它们并不严格相同。

Answer 24

Stackoverflow 上有很多类似的帖子：

• Difference Between i++ and ++i in a循环？
• 有性能吗C# 中 ++i 和 i++ 之间的区别？
• C 中的 i++ 和 ++i 之间有性能差异吗？

但是，您的问题似乎更通用，因为它不特定于任何语言或编译器。上述大多数问题都涉及特定的语言/编译器。

以下是一个概要：

• 如果我们谈论 C/C++/Java（也可能是 C#）和现代编译器：
  • 如果i是一个整数（const int、int等）：
    • 那么编译器基本上会将 i++ 替换为 ++i，因为它们在语义上是相同的，因此不会改变输出。这可以通过检查生成的代码/字节码来验证（对于 Java，我使用 jclasslib 字节码查看器）。
  • 其他：
• 其他：
  • 所有的赌注都失败了，因为编译器无法保证它们在语义上相同，因此它不会尝试优化。

因此，如果 C++ 中有一个类重写了后缀和前缀运算符（例如 std::iterator），则这种优化很少（如果有的话）完成。

总结一下：

• 言出必行，言出必行。对于 for 循环的增量部分，您几乎总是需要前缀版本（即 ++i）。
• ++i 和 i++ 之间的编译器切换并不总是可以完成，但如果可以的话，它会尽力为您完成。

Answer 25

在循环中，首先初始化，然后条件检查，然后执行，然后递增/递减。所以前/后递增/递减不会影响程序代码。

Answer 26

关于 i++（后增量）与 ++i（前增量）@me：“在这两种情况下，都会对表达式进行求值，并且结果用于检查条件。在前增量的情况下，增量对于后增量，增量表达式也会增量变量，但它返回之前的值，因此，前增量与增量值进行比较，而后增量与增量值进行比较。原始值；在这两种情况下，检查条件时变量都会增加。” – tdammers

Answer 27

后增量和预增量运算符之间存在相当大的混淆，这可以从“算法，第四版 Robert Sedgewick 和 Kevin Wayne”的摘录中轻松理解

自增/自减运算符：i++ 与 i = i + 1 相同，并且具有值
我在一个表达式中。同样，i-- 与 i = i - 1 相同。代码 ++i 和
--i 相同，只是表达式值是在增量之后取的/
递减，而不是之前。

例如

x = 0; 
post increment:
x++;
step 1: 
assign the old value (0) value of the x back to x.So, here is x = 0.
step 2:
after assigning the old value of the x, increase the value of x by 1. So,
x = 1 now;

when try to print somthing like:
System.out.print(x++);
the result is x : 0. Because only step one is executed which is assigning 
old value of the x back and then print it.

But when, we do operation like this: 
i++;
System.out.print(i);
the result is x: 1. which is because of executing Step one at first 
statement and then step two at the second statement before printing  the 
value.

pre increment:
++x;
step 1: 
increase the value of x by 1. So, x = 1 now;
step 2:
assign the increased value back to x.

when try to print something like:
System.out.print(++1)  
the result is x : 1. Because the value of the x is raised by 1 and then 
printed. So, both steps are performed before print x value. Similarly, 
executing 
++i;
system.out.print(i);
Both steps are executed at statement one. At second statement, just the 
value of "i" is printed.