在 C++ 的循环中，我通常会遇到使用++or的情况+=1，但我无法区分它们。例如，如果我有一个整数
int num = 0;
然后在一个循环中我这样做：
num ++;
或者
num += 1;
它们都增加了 的值num，但它们的区别是什么？我怀疑num++可以比 工作得更快num+=1，但是如何？这种差异是否足够微妙以至于可以忽略不计？
问问题
80641 次
10 回答
110
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因为它更短。
于 2012-10-20T11:53:24.973 回答
39
前缀和后缀操作是考试问题的完美候选。
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
+=operation 及其姐妹-=是更通用的解决方案，主要用于不同的数字。甚至可以说它们与 . 一起使用时是多余的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在movs 之后。这意味着您应该使用您喜欢的任何用户，并让编译器人员完成其余的工作。
最后，请注意表亲运算符*=并/=没有对应的后缀和前缀。
于 2012-10-20T17:25:26.220 回答
13
++前缀或后缀运算符更改变量值。
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
于 2012-10-20T11:52:54.857 回答
7
这两个运算符都将 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
于 2012-10-20T11:56:45.993 回答
3
这两个运算符可能看起来很相似，但它们却大不相同。
对于原始类型（指针、整数等），它们都将值加一。但是，对于 C++ 类，它们调用不同的运算符（operator+=vs. 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可能会导致与i++.
因此，虽然它们对于递增变量是相同的，但应该知道它们在所有情况下都不是完美的替代品。
于 2012-10-20T23:25:41.133 回答
2
它们通常是相同的，没有意义来澄清它们之间的区别。但是这两个语句的执行方式其实是不同的。例如，a+=1 编译成汇编是
add a,1
而 a++ 或 ++a 是
inc a
效率上可能会有一些轻微的差异，因为它们是两种不同的 CPU 操作。
于 2012-10-20T14:06:15.277 回答
2
你们中的一些人正在接近差异，但应该非常清楚地说明：
他们是非常不同的运营商。
preincrement 和 postincrement 运算符设计用于在表达式内部更改变量的值，无论是在变量的值用于包含它的任何表达式之前还是之后。当使用 postincrement 运算符时，变量的 OLD 值用于评估封闭表达式，并且只有在此之后变量才会递增。
例如：
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.
于 2012-10-20T14:51:23.910 回答
1
我很惊讶没有人提到至少对于旧的编译器/计算机（基本上是在 C 诞生时以及一两年后）+= 1会明显慢于++. ++是 CPU 很可能有一条指令的增量。+= 1需要将值 1 加载到寄存器中（可能会保存它的值......某处）并要求添加。我不能说当前的编译器是否优化了这一点，但我怀疑他们这样做了。
于 2012-10-20T15:03:39.567 回答
1
我是 Stackoverflow 的新手，但这是我的 2 便士。
如果问题是关于 += 而不是 +=1。张贴的声明是；
我通常会遇到使用 ++ 或 +=1 的情况，但我无法区分它们。
我认为 1 很容易成为另一个数字，或者写成 += 更好？
就结果而言，没有区别（使用海报值）。两者都将递增 1，但是，++ 只会递增 1，而 += 将递增 coder 指定的值，在 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，请使用 +=
希望这是有用的。
于 2012-10-20T22:48:53.537 回答
0
++ 用于将值增加 1，而使用 += 您可以增加另一个数量。
于 2012-10-20T11:56:27.270 回答