Quelle est la différence entre les opérateurs "++" et "+= 1 " ?

Question

Dans une boucle en C++, je rencontre généralement des situations où il faut utiliser ++ o +=1 mais je n'arrive pas à faire la différence. Par exemple, si j'ai un entier

int num = 0;

et ensuite, dans une boucle, je fais :

num ++;

o

num += 1;

ils augmentent tous deux la valeur de num Mais quelle est leur différence ? Je doute num++ pourrait travailler plus rapidement que num+=1 mais comment ? Cette différence est-elle suffisamment subtile pour être ignorée ?

Answer 1

num += 1 est plutôt équivalent à ++num .

Toutes ces expressions ( num += 1 , num++ y ++num ) incrémente la valeur de num d'une unité, mais la valeur de num++ est la valeur num avait antes de il a été incrémenté.

Illustration :

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

Utilisez ce qui vous plaît. Je préfère ++num a num += 1 parce qu'il est plus court.

Answer 2

préfixe y postfixe sont des candidats parfaits pour les questions d'examen.

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

+= et sa sœur -= sont des solutions plus générales, principalement destinées à être utilisées avec différents numéros. On pourrait même dire qu'elles sont redondantes lorsqu'elles sont utilisées avec 1 . Lorsqu'il est utilisé avec 1 ils agissent principalement en tant que préfixe opération. En fait, sur ma machine, ils produisent le même code machine. Vous pouvez essayer en utilisant un programme d'exemple tel que :

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;
}

et le démontage en gdb ce qui donnerait :

premier cas ( a++ ) (différent)

(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.

deuxième cas ( ++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.

troisième cas ( 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.

quatrième cas ( 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.

Comme vous pouvez le voir, ils produisent le même code machine même sans que les optimisations du compilateur soient activées, à l'exception du premier cas qui a addl après mov s. Cela signifie que vous devriez utiliser celui que vous aimez en tant qu'utilisateur et laisser les compilateurs faire le reste.

Enfin, notez que les opérateurs cousins *= y /= n'ont pas postfixe y préfixe des contreparties.

Answer 3

Les ++ les opérateurs préfixes ou postfixes changer la valeur de la variable.

int a = 0;
int b = a++; // b is equal to 0, a is equal to 1

Ou préfixe :

int a = 0;
int b = ++a; // b = 1, a = 1

Utilisés de la sorte, ils sont identiques :

int a = 0;
++a; // 1
a++; // 2
a += 1; // 3

Answer 4

Les deux opérateurs augmentent la valeur de n de 1. La différence entre eux existe lorsque vous utilisez les opérateurs avec l'opérateur d'affectation.

Par exemple :

Premier cas --Opérateur post-incrément

int n=5;
int new_var;

new_var=n++;

print("%d",new_var);

Sortie=5

Deuxième cas

int n=5;
n+=1;
new_var=n;
print("%d",new_var);

Sortie =6

Ce résultat est très proche de celui qu'obtiendrait l'opérateur avant incrémentation.

Deuxième cas utilisant l'opérateur de pré-incrémentation

int n=5;

new_var=++n;
print("%d",new_var);

Sortie =6

Answer 5

Ils sont généralement identiques et il n'y a pas lieu de clarifier la différence entre eux. Mais la mise en œuvre de ces deux déclarations est en fait différente. Par exemple, a+=1 compilant en assembleur est
ajouter a,1
et a++ ou ++a est
inc a
Il peut y avoir une légère différence d'efficacité parce qu'il s'agit de deux CPU différents.