Qual è la differenza tra gli operatori ++ e +=1?

Qual è la differenza tra gli operatori ++ e +=1?

num += 1 è piuttosto equivalente a ++num .

Tutte quelle espressioni (num += 1 , num++ e ++num ) incrementa il valore di num di uno, ma il valore di num++ è il valore num aveva prima è stato incrementato.

Illustrazione:

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

Usa quello che ti piace. Preferisco ++num a num += 1 perché è più breve.


prefisso e postfisso le operazioni sono candidati perfetti per le domande d'esame.

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

+= operazione e sua sorella -= sono soluzioni più generali per lo più destinate ad essere utilizzate con numeri diversi. Si potrebbe anche dire che sono ridondanti se usati con 1 . Se utilizzato con 1 agiscono principalmente come un prefisso operazione. Infatti sulla mia macchina producono lo stesso codice macchina. Puoi provarlo usando un programma di esempio come:

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

e smontaggio in gdb che darebbe:

primo caso (a++ ) (diverso)

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

secondo caso (++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.

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

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

Come puoi vedere producono lo stesso codice macchina anche senza le ottimizzazioni del compilatore attivate tranne il primo caso che ha addl dopo mov S. Ciò significa che dovresti usare quello che ti piace come utente e lasciare che i ragazzi del compilatore facciano il resto.

Infine, nota che gli operatori cugini *= e /= non avere postfisso e prefisso controparti.


Il ++ operatori di prefisso o suffisso cambia il valore della variabile.

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

O prefisso:

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

Se usati in questo modo, sono gli stessi:

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