C Language
Effets secondaires

Opérateurs avant / après incrémentation / décrémentation

En C, il y a deux opérateurs unaires - «++» et «-» qui sont une source de confusion très commune. L'opérateur ++ est appelé opérateur d'incrémentation et l'opérateur -- est appelé l' opérateur de décrémentation . Les deux peuvent être utilisés sous forme de préfixe ou de postfixe . La syntaxe pour la forme de préfixe pour l'opérateur ++ est l' ++operand et la syntaxe pour la forme postfixe est operand++ . Lorsqu'il est utilisé sous la forme de préfixe, l'opérande est incrémenté d'abord de 1 et la valeur résultante de l'opérande est utilisée dans l'évaluation de l'expression. Prenons l'exemple suivant:

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

Lorsqu'elle est utilisée dans le formulaire postfixe, la valeur actuelle de l'opérande est utilisée dans l'expression, puis la valeur de l'opérande est incrémentée de 1 . Prenons l'exemple suivant:

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

Le fonctionnement de l'opérateur de décrémentation -- peut être compris de la même manière.

Le code suivant montre ce que chacun fait

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

De ce qui précède , il est clair que les opérateurs de poste renvoient la valeur actuelle d'une variable, puis le modifier, mais avant les opérateurs modifient la variable puis retourner la valeur modifiée.

Dans toutes les versions de C, l'ordre d'évaluation des opérateurs pré et post n'est pas défini. Le code suivant peut donc renvoyer des sorties inattendues:

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

Notez que c'est également une bonne pratique d'utiliser des opérateurs pré-poste lorsqu'ils sont utilisés seuls dans une déclaration. Regardez le code ci-dessus pour cela.

Notez également que lorsqu'une fonction est appelée, tous les effets secondaires sur les arguments doivent avoir lieu avant l'exécution de la fonction.

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