Opérateurs d'incrémentation et de décrémentation Master C :utilisation et meilleures pratiques

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

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

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

Les opérateurs ++ et -- sont unaires et peuvent être utilisés comme préfixe ou posfixe d'une variable.

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

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

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

Sortie

Lorsque vous exécutez ce code, il produira le résultat suivant -

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

Exemple d'explication

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é comme l'équivalent de l'instruction "a =a + 1;". Ici, l'expression de droite ajoute 1 à "a" et le résultat est réattribué à 1, ainsi la valeur de "a" est incrémentée 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 incrément de publication .

Opérateur d'incrémentation pré (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

++variable_name;

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

Lorsque vous exécutez ce code, il produira le résultat suivant -

x = 11, y = 21

Opérateur d'incrémentation Post (Postfix)

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

Syntaxe

variable_name++;

Exemple

Dans l'exemple suivant, nous utilisons l'opérateur post-incrémentation, où la valeur de "x" sera utilisée dans l'expression puis elle sera 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;
}

Lorsque vous exécutez ce code, il produira le résultat suivant -

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 décrémentation pré (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

--variable_name;

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

Lorsque vous exécutez ce code, il produira le résultat suivant -

x = 9, y = 19

Opérateur de décrémentation Post (Postfix)

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

variable_name--;

Exemple

Dans l'exemple suivant, nous utilisons l'opérateur de post-décrémentation, où la valeur de "x" sera utilisée dans l'expression puis elle sera 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;
}

Lorsque vous exécutez ce code, il produira le résultat suivant -

x = 9, y = 20

Plus d'exemples d'opérateurs d'incrémentation et de 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

Lorsque vous exécutez ce code, il produira le résultat suivant -

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, lorsque ces opérateurs "++" ou "--" apparaissent avec les autres opérateurs dans une expression, ils se comportent différemment.

Exemple 2

Dans le code suivant, les valeurs initiales des variables "a" et "b" 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() imprime la valeur de "x" puis incrémente sa valeur. Dans le deuxième cas, l'opérateur d'incrémentation est exécuté en premier, la fonction printf() utilise la valeur incrémentée pour l'impression.

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

Il existe un certain nombre d'opérateurs en C. Lorsque 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 de décrémentation se comportent différemment lorsqu'ils sont utilisés avec d'autres opérateurs.

Lorsqu'une expression est constituée d'opérateurs d'incrémentation ou de décrémentation aux côtés d'autres opérateurs, les opérations d'incrémentation et de décrémentation sont effectuées en premier. Les opérateurs d'incrémentation et de décrémentation Postfix ont une priorité plus élevée que les opérateurs d'incrémentation et de décrémentation de préfixe.

À lire aussi : Priorité des opérateurs en C

Exemple 1

Jetez un oeil à 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 attendez à ce que "z" soit également 6. Cependant, le résultat indique "z" comme 5. En effet, l'opérateur d'affectation a une priorité plus élevée sur l'opérateur d'incrémentation postfixe. Par conséquent, la valeur existante de "x" est affectée à "z", avant d'incrémenter "x".

Exemple 2

Jetez un œil à 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

Lorsque vous exécutez ce code, il produira le résultat suivant -

y: 5
y: 6 z: 6

Le résultat peut prêter à confusion, car la valeur de "y" ainsi que de "z" est désormais 6. La raison en est que l'opérateur d'incrémentation de préfixe a une priorité plus élevée que l'opérateur d'affectation. Par conséquent, "y" est d'abord incrémenté puis sa nouvelle valeur est affectée à "z".

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

Exemple 3

Dans cet exemple, l'expression d'affectation contient à la fois les opérateurs préfixe et suffixe.

#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 à effectuer est "y++" ("y" devient 6). Deuxièmement, l'opérateur "+" ajoute "x" (qui vaut 5) et "y", le résultat attribué à "z" comme 11, puis "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 d'une boucle for est la suivante -

for (init_val; final_val; increment) {
 statement(s);
}

Exemple

Le corps de boucle est exécuté pour toutes les valeurs d'une variable entre les valeurs initiales et finales, 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

Lorsque vous exécutez ce code, il produira le résultat suivant -

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