在C语言中，使用++i和i++有什么区别，在for循环的增量块中应该使用哪个？
本厂是for环。++i似乎更多的是常见的，可能是因为K是用在急症室。
在任何的情况下，"我更愿意跟在i++++i指南"，你不会走错的。
有一个关于这几对i++++i和高效率。在任何非项目的学生将有一个编译器，在性能差。你可以通过看这在生成的验证代码，这将是相同的。
效率的问题是有趣的……这是我的回答：一项.有性能之间的差异+和I C + +我的对吗？
弗氏完全佐剂(FCA)的在线笔记，这是一个C++的对象不同的是，由于operator++()是函数和编译器优化，不知道到创作对象的临时抱中间值。
i++被称为后增量，而+i被称为前增量。
i++
i++是后增量，因为它在操作结束后将i的值增加1。
让我们看看下面的示例：
这里是j = 1的值，但是i = 2的值。此处，i的值将首先分配给j，然后增加i。
++i
++i是预增量，因为它在操作前将i的值增加1。这意味着j = i;将在i++之后执行。
我们来看下面的例子：
这里是j = 2的值，但是i = 2的值。此处，i的值将在i递增后分配给j。同样，++i将在j=i;之前执行。
对于您的问题，应该在for循环的递增块中使用哪个？答案是，你可以用任何一个……没关系。它将执行相同次数的for循环。
1
2
| for(i=0; i<5; i++)
printf("%d",i); |
和
1
2
| for(i=0; i<5; ++i)
printf("%d",i); |
两个循环将产生相同的输出。即0 1 2 3 4。
它只关系到你在哪里使用它。
1
2
| for(i = 0; i<5;)
printf("%d",++i); |
在这种情况下，输出将是1 2 3 4 5。
请不要担心，"效率"(速度，其中一个是真的)。。。。。。。。这些天，我们有一个照顾者的这些东西。一个用以使义以较高者为准，而更多地基于显示你的意图。
++iincrements值，然后返回它。
i++收益值，然后increments它。
它的微妙的差异。
如果使用的是++i环，它的有点快。创建一个额外的副本将i++thrown就得到了。
i++：-在这个场景中，首先分配值，然后发生增量。
++在这个场景中，首先完成增量，然后分配值
下面是图像可视化，这里还有一个很好的实用视频(http://www.youtube.com/watch)。v=lrtcfgbuxm4)，表示相同。
++i可以稍快的原因是，比i++CAN现场i++需要一份的价值在incremented ++iIt Gets，而不看。在一些情况下，一些编译器可能会减少，如果它了……但它不是总是可能的，这不是所有的编译器。
我试着不去依赖太多optimizations在线编译器，所以我跟瑞安福克斯的建议：当我可以使用一个++i，使用。
作为一个结果，无论是在相同的有效利用。在其他的话，将在环的两个实例中的相同的精确的事情。
在条款的有效率，可以在相关的问题上选择与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
4
5
6
7
| int i = 0;
printf("i: %d
", i);
printf("i++: %d
", i++);
printf("++i: %d
", ++i); |
输出：
++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
我假设你现在理解了语义上的差异(尽管老实说，我想知道为什么人们在堆栈溢出时问"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
| int i=4;
printf("%d
",pow(++i,2));//it prints 25 and i is 5 now
i=4;
printf("%d",pow(i++,2));//it prints 16 i is 5 now |
预修正是指同一条线上的增量。后增量是指行执行后的增量。
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
| int i = 10, j = 10;
printf ("i is %i
", i);
printf ("i++ is %i
", i++);
printf ("i is %i
", i);
printf ("j is %i
", j);
printf ("++j is %i
", ++j);
printf ("j is %i
", j); |
结果是：
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
| int i, j;
for (i = 0; i <= 3; i++)
printf ("> iteration #%i", i);
printf ("
");
for (j = 0; j <= 3; ++j)
printf ("> iteration #%i", j); |
结果是：
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
| #include<stdio.h>
int main(int argc, char* argv[])
{
unsigned int i=0, a;
a = i++;
printf("i before: %d; value returned by i++: %d, i after: %d
", i, a, i);
i=0;
a = ++i;
printf("i before: %d; value returned by ++i: %d, i after: %d
", i, a, i);
} |
输出为：
1
2
| i before: 1; value returned by i++: 0, i after: 1
i before: 1; value returned by ++i: 1, i after: 1 |
因此，基本上，++i返回递增后的值，而++i返回递增前的值。最后，在这两种情况下，i的值都将增加。
另一个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| #include<stdio.h>
int main ()
int i=0;
int a = i++*2;
printf("i=0, i++*2=%d
", a);
i=0;
a = ++i * 2;
printf("i=0, ++i*2=%d
", a);
i=0;
a = (++i) * 2;
printf("i=0, (++i)*2=%d
", a);
i=0;
a = (++i) * 2;
printf("i=0, (++i)*2=%d
", a);
return 0;
} |
输出：
1
2
3
4
| i=0, i++*2=0
i=0, ++i*2=2
i=0, (++i)*2=2
i=0, (++i)*2=2 |
很多时候没有区别
当返回值被分配给另一个变量时，或者当增量与应用了操作优先权的其他操作串联时(i++*2不同于++i*2，但(i++)*2和(++i)*2返回相同的值)，在许多情况下，它们是可互换的。典型的例子是for循环语法：
有同样的效果
要记住的规则
为了避免混淆这两个运算符，我采用了以下规则：
将运算符++相对于变量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
| int i=10;
printf("%d %d",i++,++i); |
输出：10 12/11 11(取决于printf函数参数的评估顺序，不同的编译器和体系结构有所不同)
说明：打印i++->i，然后递增。(打印10，但i将变为11)++i->i值递增并打印该值。(印刷品12，i的价值也为12)
