C Language
Nebenwirkungen

Operatoren vor / nach Inkrementieren / Verringern

In C gibt es zwei unäre Operatoren - '++' und '-', die sehr häufig zu Verwirrung führen. Der Operator ++ wird als Inkrementoperator und der Operator -- als Dekrementoperator bezeichnet . Beide können entweder als Präfix oder als Postfix verwendet werden. Die Syntax für das Präfix-Formular für den Operator ++ ist ++operand und die Syntax für das Postfix-Formular ist operand++ . Bei Verwendung in der Präfixform wird der Operand zuerst um 1 inkrementiert und der resultierende Wert des Operanden wird bei der Auswertung des Ausdrucks verwendet. Betrachten Sie das folgende Beispiel:

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

Bei Verwendung im Postfix-Formular wird der aktuelle Wert des Operanden im Ausdruck verwendet, und der Wert des Operanden wird um 1 erhöht. Betrachten Sie das folgende Beispiel:

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

Die Funktionsweise des Dekrementoperator -- kann in ähnlicher Weise verstanden werden.

Der folgende Code veranschaulicht, was jeder tut

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

Aus dem oben Gesagten ist klar , dass Postbetreiber den aktuellen Wert einer Variablen zurückgeben und es dann ändern, aber vor Operatoren die Variable ändern und dann den geänderten Wert zurück.

In allen Versionen von C ist die Reihenfolge der Auswertung von Vor- und Nachoperatoren nicht definiert. Daher kann der folgende Code unerwartete Ausgaben zurückgeben:

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

Beachten Sie, dass es auch empfehlenswert ist, Pre-Post-Operatoren zu verwenden, wenn sie alleine in einer Anweisung verwendet werden. Sehen Sie sich dazu den obigen Code an.

Beachten Sie außerdem, dass beim Aufruf einer Funktion alle Nebeneffekte auf Argumente auftreten müssen, bevor die Funktion ausgeführt wird.

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