“++”和“+ = 1”运算符有什么区别？
在C ++的循环中，我通常会遇到使用++或+=1 ，但是我不能说出它们的区别。 例如，如果我有一个整数
int num = 0;
然后在一个循环中我做：
num ++;
要么
num += 1;
他们都增加了数量的价值，但他们的区别是什么？ 我怀疑num++可以比num+=1更快的工作，但是如何？ 这种差异是否微妙可以忽略？
num += 1相当于++num 。
所有这些expression式（ num += 1 ， num++和++num ）都将++num的值加1，但是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因为它更短。
前缀和后缀操作是考试问题的最佳候选人。
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
+=操作和它的姐姐-=是更一般的解决scheme，主要是用于不同的数字。 有人甚至可以说，与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.
正如你所看到的，即使没有开启编译器优化，它们也会产生相同的机器码，除了第一种在mov s之后有addl的情况。 这意味着你应该使用你喜欢的任何一个用户，然后让编译器完成剩下的工作。
最后，注意表亲运算符*=和/=没有后缀和前缀对应。
++前缀或后缀运算符更改变量值。
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
这两个运算符都将n的值增加1.它们之间的差异存在于与赋值运算符一起使用运算符时。
例如：
第一种情况 – 增量运算符
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
它们通常是一样的，澄清它们之间的区别是没有意义的。 但是这两个声明的实施其实是有区别的。 例如，一个+ = 1的编译来build立是
加一个，1
和一个++或++ a是
公司
效率可能有些微的差别，因为它们是两种不同的CPU操作。
你们中的一些人正在接近差别，但应该说得很清楚：
他们是非常不同的经营者。
preincrement和postincrement操作符被devise为使用INSIDE EXPRESSIONS来改变variables的值，无论是BEFORE还是在variables的值被用在包含它的expression式中。 当使用postincrement运算符时，variables的OLD值用于计算包含expression式，并且仅在该variables之后是variables递增。
例如：
i = 10; j = i++; // This causes j to be 10 while i becomes 11.
这就是为什么它被称为后增量操作符。 该variables递增POST（AFTER）它的值用于更大的expression式（这里是一个赋值expression式）。
但是，如果你这样做：
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.
我很惊讶没有人提到，至less对于旧的编译器/计算机（基本上当C出生，十年或二十年后） += 1将显着慢于++ 。 ++是CPU最有可能拥有单个指令的增量。 += 1要求将值1加载到一个寄存器（可能保存它的值…某处）并要求添加。 我不能说目前的编译器是否对此进行了优化，但是我怀疑他们这么做了。
这两个运营商可能看起来是相似的，但是它们是完全不同的。
对于原始types（指针，整数等），它们都将值递增1。 但是，对于C ++类，他们调用不同的操作符（ operator+= vs. operator++ ）; 确实，对于一些类，比如list<T>::iterator ， i += 1不起作用， i++必须使用i++ 。
此外，他们产生不同的价值。 i += 1在递增之后产生i （像preincrement），而i++在递增之前产生i 。 从而，
int a = 0, b = 0; cout << (a+=1) << " " << b++ << endl;
打印1 0 。 因为i += 1相当于一个预增量，在某些情况下， i += 1可能会导致
所以，虽然增量variables是相同的，但应该意识到，在所有条件下它们并不是完美的替代品。
我是新来的Stackoverflow，但这是我的2便士价值。
如果问题是关于+ =而不是+ = 1。 发表的声明是;
我通常遇到使用++或+ = 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，而使用+ =可以增加另一个值。
