C Language
Bieffekter

Operatörer före / postökning / minskning

I C finns det två unära operatörer - '++' och '-' som är mycket vanliga källor till förvirring. Operatören ++ kallas inkrementoperatören och operatören -- kallas denkrementoperatören . Båda kan användas i antingen prefixform eller postfixform . Syntaxen för prefixformuläret för ++ operatör är ++operand och syntaxen för postfixformuläret är operand++ . När det används i prefixformen ökas operanden först med 1 och det resulterande värdet för operanden används vid utvärderingen av uttrycket. Tänk på följande exempel:

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 ; */

När det används i postfixformuläret används operandens aktuella värde i uttrycket och sedan ökas operandens värde med 1 . Tänk på följande exempel:

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; */

Funktionen hos dekrementoperatören -- kan förstås på liknande sätt.

Följande kod visar vad var och en gör

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

Av ovanstående är det tydligt att placera operatörer tillbaka det aktuella värdet på en variabel och sedan ändra det, men pre operatörerna ändrar variabel och sedan tillbaka det modifierade värdet.

I alla versioner av C definieras inte ordningen för utvärdering av pre- och postoperatörer, följaktligen kan följande kod returnera oväntade resultat:

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

Observera att det också är bra att använda pre-post-postoperatörer när de används ensamma i ett uttalande. Se ovanstående kod för detta.

Observera också att när en funktion anropas måste alla biverkningar på argument ske innan funktionen körs.

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