В чем разница между операторами "++" и "+ = 1"?

В цикле на С++ я обычно сталкиваюсь с ситуациями с использованием ++ или +=1, но я не могу сказать их разницы. Например, если у меня есть целое число

int num = 0;

а затем в цикле:

num ++;

или

num += 1;

они оба увеличивают значение num, но какова их разница? Я сомневаюсь, что num++ может работать быстрее, чем num+=1, но как? Разве эта разница достаточно тонкая, чтобы ее можно было игнорировать?

Ответ 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, потому что он короче.

Ответ 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 s. Это означает, что вы должны использовать то, что вам нравится в качестве пользователя, и пусть ребята компилятора делают все остальное.

И, наконец, обратите внимание, что кузинные операторы *= и /= не имеют постфиксных и префиксных копий.

Ответ 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

Ответ 4

Оба оператора увеличивают значение 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

Ответ 5

Они, как правило, одинаковы, и нет никакого смысла разъяснять разницу между ними. Но реализация этих двух заявлений на самом деле отличается. Например, a + = 1 компиляция для участников

добавить, 1
и ++ или ++ a - это, например, Там может быть какая-то незначительная разница в эффективности, потому что это две разные операции с ЦП.

Ответ 6

Некоторые из вас приближаются к разнице, но это должно быть указано очень четко:

ОНИ ОЧЕНЬ РАЗЛИЧНЫЕ ОПЕРАТОРЫ.

Операторы 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.

Ответ 7

Я удивлен, что никто не упоминает, что, по крайней мере, для старых компиляторов/компьютеров (в основном, когда C родился и через десять или два года после) += 1 будет значительно медленнее, чем ++. ++ - это приращение, для которого у CPU, скорее всего, есть одна команда. += 1 требует загрузки значения 1 в регистр (вероятно, с сохранением его значения... где-то) и призывая к добавлению. Я не могу сказать, оптимизируют ли нынешние компиляторы это, но я подозреваю, что они это делают.

Ответ 8

Я новичок в 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, используйте + =

Надеюсь, что это полезно.

Ответ 9

Эти два оператора могут казаться похожими, но они совершенно разные.

Для примитивных типов (указатели, целые числа и т.д.) они оба увеличивают значение на единицу. Но для классов С++ они называют разные операторы (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 может привести к

Итак, хотя они одинаковы для приращения переменных, следует помнить, что они не являются идеальными заменителями во всех условиях.

Ответ 10

++ используется для увеличения значения на 1, при использовании + = вы можете увеличивать на другую величину.