C Language
Effetti collaterali

Operatori di Pre / Post Increment / Decrement

In C ci sono due operatori unari - '++' e '-' che sono una fonte molto comune di confusione. L'operatore ++ è chiamato l' operatore di incremento e l'operatore -- è chiamato operatore di decremento . Possono essere utilizzati entrambi in forma di prefisso o postfix . La sintassi per il modulo prefisso per l'operatore ++ è l' ++operand e la sintassi per il modulo postfix è operand++ . Quando viene utilizzato nel modulo prefisso, l'operando viene incrementato per primo di 1 e il valore risultante dell'operando viene utilizzato nella valutazione dell'espressione. Considera il seguente esempio:

int n, x = 5;
n = ++x; /* x is incremented  by 1(x=6), and result is assigned to n(6) */
         /* this is a short form for two statements: */
         /* x = x + 1; */ 
         /* n = x ; */

Se utilizzato nel modulo postfix, il valore corrente dell'operando viene utilizzato nell'espressione e quindi il valore dell'operando viene incrementato di 1 . Considera il seguente esempio:

int n, x = 5;
n = x++; /* value of x(5) is assigned first to n(5), and then x is incremented by 1; x(6) */
         /* this is a short form for two statements: */
         /* n = x; */
         /* x = x + 1; */

Il funzionamento dell'operatore decremento -- può essere compresa in modo simile.

Il seguente codice dimostra cosa fa ognuno

    int main()
    {
        int a, b, x = 42;
        a = ++x; /* a and x are 43 */
        b = x++; /* b is 43, x is 44 */
        a = x--; /* a is is 44, x is 43 */
        b = --x; /* b and x are 42 */
        
        return 0;
    }

Da quanto sopra è chiaro che gli operatori postali restituiscono il valore corrente di una variabile e quindi la modificano, ma i pre operatori modificano la variabile e quindi restituiscono il valore modificato.

In tutte le versioni di C, l'ordine di valutazione degli operatori pre e post non è definito, quindi il codice seguente può restituire output non previsti:

    int main()
    {
        int a, x = 42;
        a = x++ + x; /* wrong */
        a = x + x; /* right */
        ++x;

        int ar[10];
        x = 0;
        ar[x] = x++; /* wrong */
        ar[x++] = x; /* wrong */
        ar[x] = x; /* right */
        ++x;
        return 0;
    }

Si noti che è anche una buona pratica usare gli operatori pre-post quando usati da soli in una dichiarazione. Guarda il codice sopra per questo.

Si noti inoltre che quando viene chiamata una funzione, tutti gli effetti collaterali sugli argomenti devono aver luogo prima dell'esecuzione della funzione.

    int foo(int x)
    {
        return x;
    }

    int main()
    {
        int a = 42;
        int b = foo(a++);  /* This returns 43, even if it seems like it should return 42 */
        return 0;
    }