Pre-increment ++i增加i的值，并计算为新的增量值。

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

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

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

在c++中，如果可以使用前递增，则通常是首选。

这是因为如果使用后增量，它可能要求编译器必须生成创建额外临时变量的代码。这是因为被递增的变量的前值和新值都需要保存在某个地方，因为它们可能在被求值的表达式的其他地方被需要。

因此，至少在c++中，可以有性能差异来指导您选择使用哪一种。

这主要只在被递增的变量是用户定义的具有重写++操作符的类型时才会出现问题。对于基本类型(int等)，没有性能差异。但是，作为指导原则，坚持使用前增量操作符是值得的，除非确实需要后增量操作符。

这里还有一些讨论。

In C++ if you're using STL, then you may be using for loops with iterators. These mainly have overridden ++ operators, so sticking to pre-increment is a good idea. Compilers get smarter all the time though, and newer ones may be able to perform optimizations that mean there's no performance difference - especially if the type being incremented is defined inline in header file (as STL implementations often are) so that the compiler can see how the method is implemented and can then know what optimizations are safe to perform. Even so, it's probably still worth sticking to pre-increment because loops get executed lots of times and this means a small performance penalty could soon get amplified.

在其他语言(如c#)中，c++操作符不能重载，在性能上没有区别。在循环中用于使循环变量前进，前增量操作符和后增量操作符是等效的。

更正:在c#中重载c++是允许的。不过，与c++相比，在c#中，你不能独立地重载前版本和后版本。因此，我假设在c#中调用++的结果没有被赋值给变量或用作复杂表达式的一部分，那么编译器会将++的前后版本简化为执行等效的代码。

我不知道其他语言，但在java++中，I是一个前缀增量，这意味着:将I增加1，然后在I所在的表达式中使用I的新值，i++是一个后缀增量，这意味着:在表达式中使用I的当前值，然后将其增加1。 例子:

public static void main(String [] args){

    int a = 3;
    int b = 5;
    System.out.println(++a);
    System.out.println(b++);
    System.out.println(b);

｝ 输出为:

4 5 6

是的，在for循环中，++i和i++之间是有区别的，尽管在不寻常的用例中;当在for块中或在循环测试表达式中使用带有递增/递减操作符的循环变量，或与其中一个循环变量一起使用时。不，这不仅仅是语法问题。

因为i在代码中表示对表达式i求值，而运算符并不表示求值，而只是一个操作;

++i表示将i的值增加1，然后对i求值， i++表示对I求值，然后将I的值增加1。

因此，从每两个表达式中得到的内容是不同的，因为在每个表达式中求值的内容是不同的。i和i都一样

例如;

let i = 0

i++ // evaluates to value of i, means evaluates to 0, later increments i by 1, i is now 1
0
i
1
++i // increments i by 1, i is now 2, later evaluates to value of i, means evaluates to 2
2
i
2

在不寻常的用例中，下一个例子听起来有用与否并不重要，它显示了差异

for(i=0, j=i; i<10; j=++i){
    console.log(j, i)
}

for(i=0, j=i; i<10; j=i++){
    console.log(j, i)
}

在这两种情况下，'i'将加1。

但是当你在表达式中使用它时，就有区别了，例如:

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

Pre-increment ++i增加i的值，并计算为新的增量值。

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

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

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

在c++中，如果可以使用前递增，则通常是首选。

这是因为如果使用后增量，它可能要求编译器必须生成创建额外临时变量的代码。这是因为被递增的变量的前值和新值都需要保存在某个地方，因为它们可能在被求值的表达式的其他地方被需要。

因此，至少在c++中，可以有性能差异来指导您选择使用哪一种。

这主要只在被递增的变量是用户定义的具有重写++操作符的类型时才会出现问题。对于基本类型(int等)，没有性能差异。但是，作为指导原则，坚持使用前增量操作符是值得的，除非确实需要后增量操作符。

这里还有一些讨论。

In C++ if you're using STL, then you may be using for loops with iterators. These mainly have overridden ++ operators, so sticking to pre-increment is a good idea. Compilers get smarter all the time though, and newer ones may be able to perform optimizations that mean there's no performance difference - especially if the type being incremented is defined inline in header file (as STL implementations often are) so that the compiler can see how the method is implemented and can then know what optimizations are safe to perform. Even so, it's probably still worth sticking to pre-increment because loops get executed lots of times and this means a small performance penalty could soon get amplified.

在其他语言(如c#)中，c++操作符不能重载，在性能上没有区别。在循环中用于使循环变量前进，前增量操作符和后增量操作符是等效的。

更正:在c#中重载c++是允许的。不过，与c++相比，在c#中，你不能独立地重载前版本和后版本。因此，我假设在c#中调用++的结果没有被赋值给变量或用作复杂表达式的一部分，那么编译器会将++的前后版本简化为执行等效的代码。

a++被称为后缀。

a加1，返回原来的值。

++a被称为前缀。

对a加1，返回新值。

C#:

string[] items = {"a","b","c","d"};
int i = 0;
foreach (string item in items)
{
    Console.WriteLine(++i);
}
Console.WriteLine("");

i = 0;
foreach (string item in items)
{
    Console.WriteLine(i++);
}

输出:

1
2
3
4

0
1
2
3

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); }

0, 1, 2, 3, 4 0, 1, 2, 3, 4

如果使用所计算的值，则增量类型变得显著:

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