在C ++中的循环，我通常遇到的情况下使用++或+=1 ，但我不能告诉它们的差。 举例来说，如果我有一个整数
int num = 0;
然后在一个循环中我做的：
num ++;
要么
num += 1;
他们都增加值num ，但他们的区别是什么？ 我怀疑num++可以工作的速度比num+=1 ，但如何？ 这种差异足够细微到可以忽略？
Answer 1:
num += 1相当相当于++num 。
所有这些表达式（ num += 1 ， num++和++num ）递增的值num通过一个，但值num++是值num有它得到递增之前 。
插图：
int a = 0;
int b = a++; // now b == 0 and a == 1
int c = ++a; // now c == 2 and a == 2
int d = (a += 1); // now d == 3 and a == 3
使用任何取悦你。 我喜欢++num到num += 1 ，因为它是更短。
Answer 2:
前缀和后缀操作是考题完美的候选人。
a = 0;
b = a++; // use the value and then increment --> a: 1, b: 0
a = 0;
b = ++a; // increment and then use the value --> a: 1, b: 1
+=操作和它的姊妹-=大多是旨在与不同数量的使用更普遍的解决方案。 人们甚至可以说与使用时是多余的1 。 当使用1它们大多作为前缀操作。 事实上我的机器上，他们产生相同的机器代码。 您可以通过使用一个示例程序，如试试这个：
void foo() {
int a, b;
a = 0;
// use one of these four at a time
b = a++; // first case (different)
b = ++a; // second case
b = (a += 1); // third case
b = (a = a + 1); // fourth case
}
int main() {
foo();
return 0;
}
在拆卸gdb这将使：
第一种情况下（ a++ ）（不同的）
(gdb) disassemble foo
Dump of assembler code for function foo:
0x00000000004004b4 <+0>: push %rbp
0x00000000004004b5 <+1>: mov %rsp,%rbp
0x00000000004004b8 <+4>: movl $0x0,-0x8(%rbp)
0x00000000004004bf <+11>: mov -0x8(%rbp),%eax
0x00000000004004c2 <+14>: mov %eax,-0x4(%rbp)
0x00000000004004c5 <+17>: addl $0x1,-0x8(%rbp)
0x00000000004004c9 <+21>: pop %rbp
0x00000000004004ca <+22>: retq
End of assembler dump.
第二种情况（ ++a ）
(gdb) disassemble foo
Dump of assembler code for function foo:
0x00000000004004b4 <+0>: push %rbp
0x00000000004004b5 <+1>: mov %rsp,%rbp
0x00000000004004b8 <+4>: movl $0x0,-0x8(%rbp)
0x00000000004004bf <+11>: addl $0x1,-0x8(%rbp)
0x00000000004004c3 <+15>: mov -0x8(%rbp),%eax
0x00000000004004c6 <+18>: mov %eax,-0x4(%rbp)
0x00000000004004c9 <+21>: pop %rbp
0x00000000004004ca <+22>: retq
End of assembler dump.
第三种情况（ a += 1 ）
(gdb) disassemble foo
Dump of assembler code for function foo:
0x00000000004004b4 <+0>: push %rbp
0x00000000004004b5 <+1>: mov %rsp,%rbp
0x00000000004004b8 <+4>: movl $0x0,-0x8(%rbp)
0x00000000004004bf <+11>: addl $0x1,-0x8(%rbp)
0x00000000004004c3 <+15>: mov -0x8(%rbp),%eax
0x00000000004004c6 <+18>: mov %eax,-0x4(%rbp)
0x00000000004004c9 <+21>: pop %rbp
0x00000000004004ca <+22>: retq
End of assembler dump.
第四种情况（ a = a + 1 ）
(gdb) disassemble foo
Dump of assembler code for function foo:
0x00000000004004b4 <+0>: push %rbp
0x00000000004004b5 <+1>: mov %rsp,%rbp
0x00000000004004b8 <+4>: movl $0x0,-0x8(%rbp)
0x00000000004004bf <+11>: addl $0x1,-0x8(%rbp)
0x00000000004004c3 <+15>: mov -0x8(%rbp),%eax
0x00000000004004c6 <+18>: mov %eax,-0x4(%rbp)
0x00000000004004c9 <+21>: pop %rbp
0x00000000004004ca <+22>: retq
End of assembler dump.
正如你可以看到他们生产的，即使没有编译器优化开启，除了具有第一种情况下在同一台机器代码addl后mov秒。 这意味着你应该使用哪个你喜欢作为一个用户，让编译器的家伙做休息。
最后，注意，表妹运营商*=和/=没有后缀和前缀同行。
Answer 3:
所述++前缀或后缀运算符改变变量值。
int a = 0;
int b = a++; // b is equal to 0, a is equal to 1
或前缀：
int a = 0;
int b = ++a; // b = 1, a = 1
如果使用这样的，它们是相同的：
int a = 0;
++a; // 1
a++; // 2
a += 1; // 3
Answer 4:
无论是运营商增加1 n的值，当您使用运营商提供的赋值运算符以及它们之间的差异存在。
例如：
第一种情况 --Post递增运算符
int n=5;
int new_var;
new_var=n++;
print("%d",new_var);
输出= 5
第二个案例
int n=5;
n+=1;
new_var=n;
print("%d",new_var);
输出= 6
这非常类似于预增操作符会导致英寸
使用预增运算符二案
int n=5;
new_var=++n;
print("%d",new_var);
输出= 6
Answer 5:
他们一般都是相同的，没有意义的澄清它们之间的区别。 但是这两个语句的执行实际上不同。 例如，一个+ = 1编译为装配台是
加1
和一个++或++ a是
INC一
可能有一些效率轻度的区别，因为它们是两个不同的CPU运行。
Answer 6:
你们有些人正在接近差异，但应该非常明确提出：
他们是非常不同的运营商。
的增量和后增量运营商正在设计用于内的表达式来改变变量值之前或之后的变量的值是在任何使用的表达包围它。 当使用后置运算符的变量的旧值是用来评价包封表达，之后才是是递增的变量。
例如：
i = 10;
j = i++; // This causes j to be 10 while i becomes 11.
这就是为什么它被称为后置运算符。 变量递增POST（AFTER）它的值是在更大的表达（这里赋值表达式）使用。
但是，如果你这样做：
i = 10;
j = ++i; // Now both i and j will be 11 because the increment
// of i occurs PRE (BEFORE) its value is used in the greater expression.
Answer 7:
这两家运营商可能看起来相似，但它们是完全不同的。
基本类型（指针，整数等）它们都通过一个递增的值。 但是，对于C ++类，他们称之为不同运营商（ operator+=对operator++ ）; 的确，对于某些类，像list<T>::iterator ， i += 1不工作， i++必须使用。
此外，它们产生不同的值。 i += 1产生i递增（如前递增）之后，而i++产生i递增之前。 从而，
int a = 0, b = 0;
cout << (a+=1) << " " << b++ << endl;
印刷品1 0 。 因为i += 1相当于一个预增量，在某些情况下， i += 1可能会导致
所以，虽然他们是递增的变量相同，应该意识到，他们不是在所有条件下的完全替代品。
Answer 8:
我很惊讶没有人提到，至少对于旧的编译器/计算机（基本上当C出生和一，二十年后） += 1会比显著慢++ 。 ++是其中CPU最有可能具有用于单个指令的增量。 += 1 ，需要装载值1到寄存器（可能是保存它的价值...某处），并呼吁加法。 我不能说当前的编译器优化是否这一点，但我怀疑他们这样做。
Answer 9:
我是新来的StackOverflow，但这里是我的2便士。
如果问题是关于+ =，而不是+ = 1。 发布的声明是;
我经常遇到这样的情况使用++或+ = 1，但我不能告诉他们的区别。
我认为，1个可能只是很容易被其他号码或也许更好写为+ =？
在结果方面没有差别（使用海报值）。 两者都将递增一，然而，++将仅增加1而+ =将由编码器指定的值递增，在ederman的示例中，这恰好是1对于实施例：
// Example 1:
num = 0;
num = ++;
// the result of num will be 1
// Example 2:
num = 0;
num = += 1;
// the result of num will be 1 the same as example 1
// Example 3:
num = 0;
num = += 2;
// the result of num will be 2.
// Example 4:
num = 0;
num = ++ 2;
// this would not compile as ++ will not except any value for the increment step it is assumed
// you will always want to increment by the value of 1
所以，如果你只想递增1的值，我会用++，但如果你需要来增加更多的采用1 + =
希望是非常有用的。
Answer 10:
++使用由1，递增值，同时使用+ =则可以通过另一个量递增。
文章来源: What is the difference between “++” and “+= 1 ” operators?
