What is the difference between ++i and i++?
在C语言中，使用
-
++i 将i 增量值，然后将incremented值。1
2
3i = 1;
j = ++i;
(i is 2, j is 2) -
i++ i 增量值将返回原来的值，但在这i incremented被举行。1
2
3i = 1;
j = i++;
(i is 2, j is 1)
本厂是
在任何的情况下，"我更愿意跟在
有一个关于这几对
效率的问题是有趣的……这是我的回答：一项.有性能之间的差异+和I C + +我的对吗？
弗氏完全佐剂(FCA)的在线笔记，这是一个C++的对象不同的是，由于
i++被称为后增量，而+i被称为前增量。
让我们看看下面的示例：
1 2 | int i = 1, j; j = i++; |
这里是
我们来看下面的例子：
1 2 | int i = 1, j; j = ++i; |
这里是
对于您的问题，应该在for循环的递增块中使用哪个？答案是，你可以用任何一个……没关系。它将执行相同次数的for循环。
1 2 |
和
1 2 |
两个循环将产生相同的输出。即
它只关系到你在哪里使用它。
1 2 |
在这种情况下，输出将是
请不要担心，"效率"(速度，其中一个是真的)。。。。。。。。这些天，我们有一个照顾者的这些东西。一个用以使义以较高者为准，而更多地基于显示你的意图。
它的微妙的差异。
如果使用的是
i++：-在这个场景中，首先分配值，然后发生增量。
++在这个场景中，首先完成增量，然后分配值
下面是图像可视化，这里还有一个很好的实用视频(http://www.youtube.com/watch)。v=lrtcfgbuxm4)，表示相同。
我试着不去依赖太多optimizations在线编译器，所以我跟瑞安福克斯的建议：当我可以使用一个
作为一个结果，无论是在相同的有效利用。在其他的话，将在环的两个实例中的相同的精确的事情。
在条款的有效率，可以在相关的问题上选择与I + + + +(在条款的语言规范，使用后应增加额外的运营商创建一个复制的值是在运营商的在线代理。这可能是额外的源操作。
然而，你应该考虑两个主要问题，与前面的逻辑。
现代编译器是伟大的。所有的编译器都意识到了这是一个智能的整型数是看到在环，它将两种方法的优化和高效的代码。如果在使用前后的增量增量实际上使你的程序有一个较慢的运行时间是可怕的，你使用的编译器。
运算时间复杂度而言，在这两个方法(即使是正在执行的副本实际上是等效的)。被执行的指令的数量应该dominate环内的数量显着增加的操作的操作。因此，在任何重大的环的大小的增量法，将造成大规模overshadowed由执行的循环体。在其他的话，你是我们的下worrying美妙优化代码中的循环，而不是增加。
在我看来，整个问题将下降到我们的风格偏好。如果你想增加更多的前一读，然后使用它。我个人的选择，但增后，可能是因为它是我知道我是在做关于优化为主。
这是一个典型的例子和问题过早的优化，这样有潜在的严重的问题，在distract达到设计中。它仍然是好的，但问的问题，因为有一个在使用中的一致性或"最佳实践"。
它们都会增加数字。++i等于i=i+1。
我和我非常相似，但不完全一样。这两者都会增加数值，但在计算当前表达式之前，++i会增加数值，而在计算表达式之后，++i会增加数值。
例子：
1 2 3 | int i = 1; int x = i++; //x is 1, i is 2 int y = ++i; //y is 3, i is 3 |
++i是预增量，另一个是后增量
i++：获取元素，然后将其递增。++i:递增i，然后返回元素
例子：
输出：
1 2 3 | i: 0 i++: 0 ++i: 2 |
++i(前缀操作)：递增然后赋值(例如)：int i=5，int b=++i在这种情况下，6首先分配给B，然后递增到7，依此类推。
I++(后缀操作)：分配然后增加值(例如)：int i=5，int b=i++在这种情况下，5首先分配给B，然后递增到6，依此类推。
在for循环中：通常使用i++是因为，在for循环中递增之前，通常使用i的起始值。但是，根据程序逻辑，它可能会有所不同。
这种差异可以通过以下简单的C++代码来理解：
1 2 3 4 5 6 7 | 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; |
The Main Difference is
- i++ Post(After Increment) and
++i Pre (Before Increment)
- post if
i =1 the loop increments like1,2,3,4,n - pre if
i =1 the loop increments like2,3,4,5,n
我假设你现在理解了语义上的差异(尽管老实说，我想知道为什么人们在堆栈溢出时问"operator x是什么意思"而不是阅读，你知道，一本书或是网络教程之类的。
但不管怎样，就使用哪一个而言，忽略性能问题，这是即使在C++中也不太重要。这是你在决定时应该使用的原则使用：
说出你在代码中的意思。
如果在语句中递增之前不需要该值，则不要使用该形式的运算符。这是一个小问题，但除非你正在使用禁止使用的样式指南完全支持另一个版本(又称骨头型指南)，您应该使用最准确地表达你想要做什么的形式。
QED，使用预增量版本：
1 | for (int i = 0; i != X; ++i) ... |
短期内：++如果你不在函数中编写它们，我和我++的工作原理是一样的。如果您使用函数(i++)或函数(++i)，您可以看到不同之处。
函数(++i)表示第一个增量i乘以1，然后将这个i放入具有新值的函数中。
函数(i++)表示将第一个i放入函数中，然后将该增量i增加1。
1 2 3 4 5 |
预修正是指同一条线上的增量。后增量是指行执行后的增量。
1 2 3 4 5 6 7 | 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 |
当它与或和运算符一起使用时，它会变得更有趣。
1 2 3 4 5 6 7 8 9 10 | int m=0; if((m == 0 || m++ == 0) && (m++ == 1)) { //false /* in OR condition if first line is already true then compiler doesn't check the rest. It is 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 } |
数组中
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | 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 (" %d %d %d ", ii, jj, mm ) ; //12, 12, 13 for (int val: a) { System.out.print("" +val); //55, 13, 15, 20, 25 } |
指针变量的C++后置/预增量
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #include <iostream> using namespace std; int main() { int x=10; int* p = &x; std::cout<<"address ="<<p<<" "; //prints address of x std::cout<<"address ="<<p<<" "; //prints (address of x) + sizeof(int) std::cout<<"address ="<<&x<<" "; //prints address of x std::cout<<"address ="<<++&x<<" "; //error. reference can't re-assign because it is fixed (immutable) } |
下面的C代码片段说明了前后递增和递减运算符之间的区别：
INTI；int j；
//递增运算符
i＝1；
j=++i；//我现在是2，j也是2
j=i++；//我现在是3，j是2
i++与++i
这个小代码可能有助于从一个不同的角度来可视化不同于已经发布的答案：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
结果是：
1 2 3 4 5 6 7 8 9 | //Remember that the values are i = 10, and j = 10 i is 10 i++ is 10 //Assigns (print out), then increments i is 11 j is 10 ++j is 11 //Increments, then assigns (print out) j is 11 |
注意前后情况。
for循环至于在for循环的增量块中应该使用哪一个，我认为我们可以做的最好的决定是使用一个好例子：
1 2 3 4 5 6 7 8 9 10 |
结果是：
1 2 | > iteration #0 > iteration #1 > iteration #2 > iteration #3 > iteration #0 > iteration #1 > iteration #2 > iteration #3 |
我不知道你的情况，但我看不出它的用法有什么不同，至少在for循环中是这样。
唯一的区别是变量增量和运算符返回值之间的操作顺序。
此代码及其输出解释了不同之处：
1 2 3 4 5 6 7 8 9 10 11 12 13 |
输出为：
1 2 | i before: 1; value returned by i++: 0, i after: 1 i before: 1; value returned by ++i: 1, i after: 1 |
因此，基本上，
另一个例子：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
输出：
1 2 3 4 | i=0, i++*2=0 i=0, ++i*2=2 i=0, (++i)*2=2 i=0, (++i)*2=2 |
很多时候没有区别
当返回值被分配给另一个变量时，或者当增量与应用了操作优先权的其他操作串联时(
1 | for(int i=0; i<10; i++) |
有同样的效果
1 | for(int i=0; i<10; ++i) |
要记住的规则
为了避免混淆这两个运算符，我采用了以下规则：
将运算符
换言之：
i 前的++ 表示在分配前必须进行递增；i 后的++ 表示在分配后必须进行递增：
您可以将其内部转换为多个语句；
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | // case 1 : i++; /* you can think as, * i; * i= i+1; */ // case 2 ++i; /* you can think as, * i = i+i; * i; */ |
a=i++表示a包含当前i值a=++i表示a包含递增的i值
以下是理解差异的示例
1 2 |
输出：
说明：打印