在这两种情况下，'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

关于++i和i++，不仅仅是循环和性能差异。++i返回一个l值，i++返回一个r值。基于此，可以对(++i)执行许多操作，但不能对(i++)执行许多操作。

1- It is illegal to take the address of post increment result. Compiler won't even allow you.
2- Only constant references to post increment can exist, i.e., of the form const T&.
3- You cannot apply another post increment or decrement to the result of i++, i.e., there is no such thing as I++++. This would be parsed as ( i ++ ) ++ which is illegal.
4- When overloading pre-/post-increment and decrement operators, programmers are encouraged to define post- increment/decrement operators like:

T& operator ++ ( )
{
   // logical increment
   return *this;
}

const T operator ++ ( int )
{
    T temp( *this );
    ++*this;
    return temp;
}

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#中调用++的结果没有被赋值给变量或用作复杂表达式的一部分，那么编译器会将++的前后版本简化为执行等效的代码。

问题是:

for循环中的++i和i++有区别吗?

答案是:不。

为什么每个答案都必须详细解释前增量和后增量，而这个问题甚至都没有问过?

这样的循环:

for (int i = 0; // Initialization
     i < 5;     // Condition
     i++)       // Increment
{
   Output(i);
}

在不使用循环的情况下转换为下面的代码:

int i = 0; // Initialization

loopStart:
if (i < 5) // Condition
{
   Output(i);

   i++ or ++i; // Increment

   goto loopStart;
}

现在你把i++还是++i作为增量有关系吗?不，它不会，因为增量操作的返回值是不重要的。i将在for循环体内的代码执行之后递增。

在这两种情况下，'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

在某些情况下，++i和i+1可能会给出不同的结果，-i, i - 1等也是如此。

这并不是因为递增和递减操作符的工作方式有缺陷，而是因为新程序员有时会忽略一个小事实。

根据经验，不要在数组的方括号内使用inc/dec。例如，我不会用arr[++ I]来代替arr[I + 1]。虽然两者得到的i值是一样的，但这里我们忽略了一些东西。

如果循环条件基于i的执行值，那么将arr[i + 1]替换为arr[++i]将导致错误。为什么?

假设i = 5，那么arr[i + 1]意味着arr[6]，而arr[++i]虽然意味着arr[6]，但也会将i的值改变为6，这可能不是我们想要做的事情。我们可能不想改变i的值，但由于一个简单的++/——操作符，我们改变了这个值。

所以在使用++/——操作符时要小心。

我希望我能使我的观点更容易理解。