++i将增加i的值，然后返回增加后的值。 I = 1; J = ++i; (i = 2, j = 2) i++将增加I的值，但返回I被增加前的原始值。 I = 1; J = i++; (i = 2, j = 1)

对于For循环，两者都可以。++i似乎更常见，也许是因为这是K&R中使用的。

在任何情况下，遵循“优先选择++i而不是i++”的指导方针，您都不会出错。

这里有一些关于++i和i++的效率的评论。在任何非学生项目的编译器中，都不会有性能差异。您可以通过查看生成的代码来验证这一点，它们是相同的。

效率问题很有趣……以下是我试图回答的问题: 在C语言中i++和++i之间有性能差异吗?

正如@OnFreund指出的那样，对于c++对象是不同的，因为操作符++()是一个函数，编译器不知道优化掉一个临时对象的创建来保存中间值。

这种差异可以通过下面这段简单的c++代码来理解:

int i, j, k, l;
i = 1; //initialize int i with 1
j = i+1; //add 1 with i and set that as the value of j. i is still 1
k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1
l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l.
cout << i << ' ' << j << ' ' << k << ' '<< l << endl;
return 0;

主要的区别是 i++ Post(After Increment)和 ++i Pre(增量前) Post if I =1，循环增量为1,2,3,4,n 如果I =1，循环会增加2 3 4 5 n

预填充是指在同一行上的增量。后增量是指行执行后的增量。

int j = 0;
System.out.println(j); // 0
System.out.println(j++); // 0. post-increment. It means after this line executes j increments.

int k = 0;
System.out.println(k); // 0
System.out.println(++k); // 1. pre increment. It means it increments first and then the line executes

当它带有OR和AND操作符时，它变得更有趣。

int m = 0;
if((m == 0 || m++ == 0) && (m++ == 1)) { // False
    // In the OR condition, if the first line is already true
    // then the compiler doesn't check the rest. It is a
    // technique of compiler optimization
    System.out.println("post-increment " + m);
}

int n = 0;
if((n == 0 || n++ == 0) && (++n == 1)) { // True
    System.out.println("pre-increment " + n); // 1
}

在数组中

System.out.println("In Array");
int[] a = { 55, 11, 15, 20, 25 };
int ii, jj, kk = 1, mm;
ii = ++a[1]; // ii = 12. a[1] = a[1] + 1
System.out.println(a[1]); // 12

jj = a[1]++; // 12
System.out.println(a[1]); // a[1] = 13

mm = a[1]; // 13
System.out.printf("\n%d %d %d\n", ii, jj, mm); // 12, 12, 13

for (int val: a) {
     System.out.print(" " + val); // 55, 13, 15, 20, 25
}

在c++中，指针变量的后/前增量

#include <iostream>
using namespace std;

int main() {

    int x = 10;
    int* p = &x;

    std::cout << "address = " << p <<"\n"; // Prints the address of x
    std::cout << "address = " << p <<"\n"; // Prints (the address of x) + sizeof(int)
    std::cout << "address = " << &x <<"\n"; // Prints the address of x

    std::cout << "address = " << ++&x << "\n"; // Error. The reference can't reassign, because it is fixed (immutable).
}

我假设你现在已经理解了语义上的差异(尽管说实话我想知道为什么 人们会问“运算符X是什么意思”的问题，而不是阅读， 你知道的，一本书或网络教程之类的。

不管怎样，至于用哪个，忽略性能的问题 即使在c++中也不太重要。这是你做决定时应该遵循的原则 使用哪一种:

用代码表达你的意思。

如果语句中不需要value-before-increment，就不要使用这种形式的操作符。这是一个小问题，但除非你的风格指南禁止这样做 版本完全赞成其他的(又名愚蠢的风格指南)，你应该使用 最准确地表达你要做的事情的形式。

QED，使用预增量版本:

for (int i = 0; i != X; ++i) ...

++i可以比i++稍微快一点的原因是，i++可以在i的值被递增之前要求它的本地副本，而++i从不这样做。在某些情况下，一些编译器会尽可能地优化它……但这并不总是可能的，并不是所有编译器都这样做。

我尽量不太依赖编译器优化，所以我会遵循Ryan Fox的建议:当我可以使用两者时，我会使用++ I。