В цикле на С++ я обычно сталкиваюсь с ситуациями с использованием ++ или +=1, но я не могу сказать их разницы. Например, если у меня есть целое число
int num = 0;
а затем в цикле:
num ++;
или
num += 1;
они оба увеличивают значение num, но какова их разница? Я сомневаюсь, что num++ может работать быстрее, чем num+=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, потому что он короче.
префикс и постфиксные операции - идеальные кандидаты на экзаменационные вопросы.
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 s. Это означает, что вы должны использовать то, что вам нравится в качестве пользователя, и пусть ребята компилятора делают все остальное.
И, наконец, обратите внимание, что кузинные операторы *= и /= не имеют постфиксных и префиксных копий.
Операторы префикса ++ или постфикса изменяют значение переменной.
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
Это очень похоже на то, к чему приведет оператор pre-increment.
Второй случай с использованием оператора Pre-increment
int n=5;
new_var=++n;
print("%d",new_var);
Выход = 6
Они, как правило, одинаковы, и нет никакого смысла разъяснять разницу между ними. Но реализация этих двух заявлений на самом деле отличается.
Например,
a + = 1 компиляция для участников
добавить, 1
и ++ или ++ a - это, например,
Там может быть какая-то незначительная разница в эффективности, потому что это две разные операции с ЦП.
Некоторые из вас приближаются к разнице, но это должно быть указано очень четко:
ОНИ ОЧЕНЬ РАЗЛИЧНЫЕ ОПЕРАТОРЫ.
Операторы preincrement и postincrement предназначены для использования INSIDE EXPRESSIONS для изменения значения переменной либо до, либо после того, как значение переменной используется в любом выражении. При использовании оператора postincrement значение OLD переменной используется для оценки охватывающего выражения и только после этого увеличивается переменная.
Например:
i = 10;
j = i++; // This causes j to be 10 while i becomes 11.
Вот почему он называется оператором postincrement. Эта переменная увеличивается в 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.
Я удивлен, что никто не упоминает, что, по крайней мере, для старых компиляторов/компьютеров (в основном, когда C родился и через десять или два года после) += 1 будет значительно медленнее, чем ++. ++ - это приращение, для которого у CPU, скорее всего, есть одна команда. += 1 требует загрузки значения 1 в регистр (вероятно, с сохранением его значения... где-то) и призывая к добавлению. Я не могу сказать, оптимизируют ли нынешние компиляторы это, но я подозреваю, что они это делают.
Я новичок в 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, используйте + =
Надеюсь, что это полезно.
Эти два оператора могут казаться похожими, но они совершенно разные.
Для примитивных типов (указатели, целые числа и т.д.) они оба увеличивают значение на единицу. Но для классов С++ они называют разные операторы (operator+= vs. operator++); действительно, для некоторых классов, таких как list<T>::iterator, i += 1 не работает и i++ должен использоваться.
Кроме того, они производят разные значения. i += 1 создает i после увеличения (например, preincrement), а i++ производит i до приращения. Таким образом,
int a = 0, b = 0;
cout << (a+=1) << " " << b++ << endl;
выводит 1 0. Поскольку i += 1 эквивалентен преинкременту, в некоторых случаях i += 1 может привести к
Итак, хотя они одинаковы для приращения переменных, следует помнить, что они не являются идеальными заменителями во всех условиях.
++ используется для увеличения значения на 1, при использовании + = вы можете увеличивать на другую величину.