Maîtriser les opérateurs d'incrémentation et décrémentation en C : Usage & meilleures pratiques

C - Opérateurs d'incrémentation et décrémentation

L'opérateur d'incrémentation (++) augmente la valeur d'une variable de 1, tandis que l'opérateur de décrémentation (--) la diminue de 1.

Les opérateurs d'incrémentation et décrémentation sont fréquemment utilisés dans la construction de boucles comptées en C (avec la boucle for). Ils trouvent aussi leur application dans le parcours de tableaux et l'arithmétique de pointeurs.

Les opérateurs ++ et -- are unaires et peuvent être utilisés en préfixe ou postfixe d'une variable.

Exemple d'opérateurs d'incrémentation et décrémentation

L'exemple suivant contient plusieurs instructions démontrant l'utilisation des opérateurs d'incrémentation et décrémentation avec différentes variations −

#include <stdio.h>
int main() {
    int a = 5, b = 5, c = 5, d = 5;
    a++; // incrémentation postfixe
    ++b; // incrémentation préfixe
    c--; // décrémentation postfixe
    --d; // décrémentation préfixe
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    printf("c = %d\n", c);
    printf("d = %d\n", d);
    return 0;
}

Sortie

Quand vous exécutez ce code, il produit la sortie suivante −

a = 6
b = 6
c = 4
d = 4

Explication de l'exemple

En d'autres termes, « a++ » a le même effet que « ++a », car les deux expressions incrémentent la valeur de la variable « a » de 1. De même, « a-- » a le même effet que « --a ».

L'expression « a++; » peut être traitée comme l'équivalent de l'instruction « a = a + 1; ». Ici, l'expression à droite ajoute 1 à « a » et le résultat est réaffecté à 1, augmentant ainsi la valeur de « a » de 1.

De même, « b--; » est équivalent à « b = b - 1; ».

Types d'opérateur d'incrémentation

Il existe deux types d'opérateurs d'incrémentation – pré-incrémentation et post-incrémentation.

Opérateur de pré-incrémentation (Préfixe)

Dans une expression, l'opérateur de pré-incrémentation augmente la valeur d'une variable de 1 avant l'utilisation de la valeur de la variable.

Syntaxe

++nom_variable;

Exemple

Dans l'exemple suivant, nous utilisons un opérateur de pré-incrémentation, où la valeur de « x » sera augmentée de 1, puis la valeur augmentée sera utilisée dans l'expression.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 10 + ++x;
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

Quand vous exécutez ce code, il produit la sortie suivante −

x = 11, y = 21

Opérateur de post-incrémentation (Postfixe)

Dans une expression, l'opérateur de post-incrémentation augmente la valeur d'une variable de 1 après l'utilisation de la valeur de la variable.

Syntaxe

nom_variable++;

Exemple

Dans l'exemple suivant, nous utilisons un opérateur de post-incrémentation, où la valeur de « x » sera utilisée dans l'expression puis augmentée de 1.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 10 + x++;
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

Quand vous exécutez ce code, il produit la sortie suivante −

x = 11, y = 20

Types d'opérateur de décrémentation

Il existe deux types d'opérateurs de décrémentation – pré-décrémentation et post-décrémentation.

Opérateur de pré-décrémentation (Préfixe)

Dans une expression, l'opérateur de pré-décrémentation diminue la valeur d'une variable de 1 avant l'utilisation de la valeur de la variable.

Syntaxe

--nom_variable;

Exemple

Dans l'exemple suivant, nous utilisons un opérateur de pré-décrémentation, où la valeur de « x » sera diminuée de 1, puis la valeur diminuée sera utilisée dans l'expression.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 10 + --x;
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

Quand vous exécutez ce code, il produit la sortie suivante −

x = 9, y = 19

Opérateur de post-décrémentation (Postfixe)

Dans une expression, l'opérateur de post-décrémentation diminue la valeur d'une variable de 1 après l'utilisation de la valeur de la variable.

Syntaxe

nom_variable--;

Exemple

Dans l'exemple suivant, nous utilisons un opérateur de post-décrémentation, où la valeur de « x » sera utilisée dans l'expression puis diminuée de 1.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 10 + x--;
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

Quand vous exécutez ce code, il produit la sortie suivante −

x = 9, y = 20

Autres exemples d'opérateurs d'incrémentation et décrémentation

Exemple 1

L'exemple suivant met en évidence l'utilisation de l'incrémentation/décrémentation préfixe/postfixe −

#include <stdio.h>
int main(){
    char a = 'a', b = 'M';
    int x = 5, y = 23;
    printf("a: %c b: %c\n", a, b);
    a++;
    printf("postfix increment a: %c\n", a);
    ++b;
    printf("prefix increment b: %c\n", b);
    printf("x: %d y: %d\n", x, y);
    x--;
    printf("postfix decrement x : %d\n", x);
    --y;
    printf("prefix decrement y : %d\n", y);
    return 0;
}

Sortie

Quand vous exécutez ce code, il produit la sortie suivante −

a: a b: M
postfix increment a: b
prefix increment b: N
x: 5 y: 23
postfix decrement x: 4
prefix decrement y: 22

L'exemple ci-dessus montre que les opérateurs préfixe et postfixe ont le même effet sur la valeur de la variable opérande. Cependant, quand ces opérateurs « ++ » ou « -- » apparaissent avec d'autres opérateurs dans une expression, ils se comportent différemment.

Exemple 2

Dans le code suivant, les valeurs initiales des variables « x » et « y » sont les mêmes, mais la fonction printf() affiche des valeurs différentes −

#include <stdio.h>
int main(){
    int x = 5, y = 5;
    printf("x: %d y: %d\n", x,y);
    printf("postfix increment x: %d\n", x++);
    printf("prefix increment y: %d\n", ++y);
    return 0;
}

Sortie

Exécutez le code et vérifiez sa sortie −

x: 5 y: 5
postfix increment x: 5
prefix increment y: 6

Dans le premier cas, la fonction printf() affiche la valeur de « x » puis incrémente sa valeur. Dans le second cas, l'opérateur d'incrémentation est exécuté en premier, la fonction printf() utilise la valeur incrémentée pour l'affichage.

Priorité des opérateurs d'incrémentation et décrémentation

Il y a un certain nombre d'opérateurs en C. Quand plusieurs opérateurs sont utilisés dans une expression, ils sont exécutés selon leur ordre de priorité. Les opérateurs d'incrémentation et décrémentation se comportent différemment quand ils sont utilisés avec d'autres opérateurs.

Quand une expression consiste en opérateurs d'incrémentation ou décrémentation aux côtés d'autres opérateurs, les opérations d'incrémentation et décrémentation sont effectuées en premier. Les opérateurs d'incrémentation et décrémentation postfixes ont une priorité plus haute que les opérateurs préfixes.

Lisez aussi : Priorité des opérateurs en C

Exemple 1

Regardez l'exemple suivant −

#include <stdio.h>
int main(){
    int x = 5, z;
    printf("x: %d \n", x);
    z = x++;
    printf("x: %d z: %d\n", x, z);
    return 0;
}

Sortie

Exécutez le code et vérifiez sa sortie −

x: 5
x: 6 z: 5

Puisque « x++ » incrémente la valeur de « x » à 6, vous vous attendriez à ce que « z » soit 6 aussi. Cependant, le résultat montre « z » comme 5. C'est parce que l'opérateur d'affectation a une priorité plus haute que l'opérateur d'incrémentation postfixe. Donc, la valeur existante de « x » est affectée à « z », avant d'incrémenter « x ».

Exemple 2

Regardez un autre exemple ci-dessous −

#include <stdio.h>
int main(){
    int x = 5, y = 5, z;
    printf("x: %d y: %d\n", x,y);
    z = ++y;
    printf("y: %d z: %d\n", y ,z);
    return 0;
}

Sortie

Quand vous exécutez ce code, il produit la sortie suivante −

y: 5
y: 6 z: 6

Le résultat peut être déroutant, car la valeur de « y » ainsi que « z » est maintenant 6. La raison est que l'opérateur d'incrémentation préfixe a une priorité plus haute que l'opérateur d'affectation. Donc, « y » est incrémenté en premier et ensuite sa nouvelle valeur est affectée à « z ».

L'associativité des opérateurs joue aussi un rôle important. Pour les opérateurs d'incrémentation et décrémentation, l'associativité est de gauche à droite. Donc, s'il y a plusieurs opérateurs d'incrémentation ou décrémentation dans une seule expression, l'opérateur le plus à gauche sera exécuté en premier, en avançant vers la droite.

Exemple 3

Dans cet exemple, l'expression d'affectation contient à la fois l'opérateur préfixe et postfixe.

#include <stdio.h>
int main(){
    int x = 5, y = 5, z;
    z = x++ + ++y;
    printf("x: %d y: %d z: %d\n", x,y,z);
    return 0;
}

Sortie

Exécutez le code et vérifiez sa sortie −

x: 6 y: 6 z: 11

Dans cet exemple, la première opération à faire est « ++y » (« y » devient 6). Ensuite l'opérateur « + » additionne « x » (qui est 5) et « y », le résultat affecté à « z » comme 11, et ensuite « x++ » incrémente « x » à 6.

Utilisation de l'opérateur d'incrémentation dans une boucle

En C, la syntaxe la plus couramment utilisée pour une boucle for est la suivante −

for (valeur_init; valeur_finale; incrémentation) {
    instruction(s);
}

Exemple

Le corps de la boucle est exécuté pour toutes les valeurs d'une variable entre la valeur initiale et la finale, en l'incrémentant après chaque tour.

#include <stdio.h>
int main(){
    int x;
    for (x = 1; x <= 5; x++){
        printf("x: %d\n", x);
    }
    return 0;
}

Sortie

Quand vous exécutez ce code, il produit la sortie suivante −

x: 1
x: 2
x: 3
x: 4
x: 5