For loop 循环中增量前和增量后之间的差异？

for

循环中的

++i

和

i++

是否存在差异？这仅仅是一个语法问题吗？

一个（++i）是前置增量，一个（i++）是后置增量。区别在于表达式立即返回的值

// Psuedocode
int i = 0;
print i++; // Prints 0
print i; // Prints 1
int j = 0;
print ++j; // Prints 1
print j; // Prints 1

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

class A {

     public static void main (String []args) {

     int j = 0 ;
     int k = 0 ;
     ++j;
     k++;
    System.out.println(k+" "+j);

}}

prints out :  1 1

编辑：Woops，完全忽略了事物的循环端。当for循环是“阶跃”部分（for（…；…））时，它与for循环没有实际区别，但在其他情况下，它可以发挥作用。

在C#中，在for循环中使用时没有区别

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

i++读取i的值，然后将其递增

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

++我增加值，然后读取它。

是的，有。差异在于返回值。“++i”的返回值将是i递增后的值。“i++”的返回值将是递增之前的值。这意味着代码如下所示：

int a = 0;
int b = ++a; // a is incremented and the result after incrementing is saved to b.
int c = a++; // a is incremented again and the result before incremening is saved to c.

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

因此，a是2，b和c分别是1

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

我可以这样重写代码：

int a = 0; 

// ++a;
a = a + 1; // incrementing first.
b = a; // setting second. 

// a++;
c = a; // setting first. 
a = a + 1; // incrementing second. 

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

在这两种情况下没有实际差异，“

i

”将增加1

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

但在表达式中使用它时会有一个区别，例如：

int i = 1;
int a = ++i;
// i is incremented by one and then assigned to a.
// Both i and a are now 2.
int b = i++;
// i is assigned to b and then incremented by one.
// b is now 2, and i is now 3

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

Pre increment++i递增i的值并计算为新的递增值

int i = 3;
int preIncrementResult = ++i;
Assert( preIncrementResult == 4 );
Assert( i == 4 );

int i = 3;
int postIncrementResult = i++;
Assert( postIncrementtResult == 3 );
Assert( i == 4 );

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

增量后i++增加i的值并计算为原始的非增量值

int i = 3;
int preIncrementResult = ++i;
Assert( preIncrementResult == 4 );
Assert( i == 4 );

int i = 3;
int postIncrementResult = i++;
Assert( postIncrementtResult == 3 );
Assert( i == 4 );

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

<>在C++中，通常使用优先增量，也可以使用./P>

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

这是因为如果使用post increment，可能需要编译器生成创建额外临时变量的代码。这是因为要递增的变量的先前值和新值都需要保留在某个位置，因为它们可能需要在要计算的表达式的其他位置

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

int i = 3;
int a = i++; // a = 3, i = 4
int b = ++a; // b = 4, a = 

<>所以，在C++中至少可以有一个性能差异来指导你选择使用哪个。

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

这主要只是当递增的变量是具有重写的++运算符的用户定义类型时的问题。对于基本类型（int等），没有性能差异。但是，除非绝对需要使用增量后操作符，否则还是值得坚持使用增量前操作符作为指导

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

还有一些讨论

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

在C++中，如果使用STL，那么可能会使用带有迭代器的循环。这些主要有重写的++操作符，所以坚持使用预增量是个好主意。不过，编译器一直在变得更智能，更新的编译器可能能够执行优化，这意味着没有性能差异——特别是如果递增的类型是在头文件中内联定义的（STL实现通常是这样的）这样编译器就可以看到该方法是如何实现的，然后就可以知道哪些优化是可以安全执行的。即使如此，可能仍然值得坚持使用预增量，因为循环执行了很多次，这意味着一个小的性能损失可能很快就会被放大

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

在C#等不能重载++运算符的其他语言中，没有性能差异。在循环中用于推进循环变量，增量前和增量后运算符是等效的

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

更正：允许在C#中重载+。不过，与C++相比，C语言中不能独立地加载前和后版本。因此，我假设，如果在C#中调用++的结果没有分配给变量或用作复杂表达式的一部分，那么编译器会将++的前版本和后版本缩减为同等执行的代码。

既然您询问循环中的差异，我猜您的意思是

for(int i=0; i<10; i++) 
    ...;

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

现在，有一个区别，因为正如其他人所指出的，

i++

表示增量，但计算到以前的值，但是

++i

表示增量，但计算到

i

（因此它将计算到新值）。在上述情况下，

a

被分配先前的值i，而i被递增

如前所述，for循环中没有区别

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

但是在

while

或

do…while

循环中，如果与

++i

或

i++

进行比较，您可能会发现一些差异

while(i++ < 10) { ... } //compare then increment

while(++i < 10) { ... } //increment then compare

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

while（i++<10）{…}//比较然后递增
而（++i<10）{…}//增量，然后比较

对于用户定义类型的

i

，这些运算符可以（但不应该）在循环索引的上下文中具有有意义的不同语义，这可能（但不应该）影响所描述的循环的行为

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

---

另外，在

c++

中，通常使用预增量形式（

++i

）是最安全的，因为它更容易优化。（斯科特·兰厄姆。诅咒你，斯科特）

a++被称为后缀。

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

将1添加到，返回旧值

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

++a称为前缀。

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

将1添加到，返回新值

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

C#：

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

输出：

1
2
3
4

0
1
2
3

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

foreach

和

while

循环取决于您使用的增量类型。对于下面这样的for循环，它没有任何区别，因为您没有使用i的返回值：

for (int i = 0; i < 5; i++) { Console.Write(i);}
Console.WriteLine("");
for (int i = 0; i < 5; ++i) { Console.Write(i); }

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

for（inti=0；i<5；i++）{Console.Write（i）；}
控制台。写线（“”）；
对于（inti=0；i<5；++i）{Console.Write（i）；}

01 2 3 4
01 2 3 4

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

如果使用评估的值，则增量类型变得重要：

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

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

int n=0；
对于（inti=0；n<5；n=i++）{

正如这段代码所示（请参见注释中被分解的MSIL），C#3编译器在for循环中不区分i++和++i。如果取i++或++i的值，肯定会有区别（这是在Visutal Studio 2008/Release Build中编译的）：

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
名称空间预目标增量
{
班级计划
{
静态int-SomethingToInc