Opérateurs d'affectation en C

Bonjour à tous, futurs programmeurs ! Aujourd'hui, nous allons plonger dans le monde fascinant des opérateurs d'affectation en C. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code avant – je suis là pour vous guider à travers ce voyage étape par étape. À la fin de ce tutoriel, vous affecterez des valeurs comme un pro !

Qu'est-ce qu'un opérateur d'affectation ?

Avant de commencer, voyons ce qu'ont sont les opérateurs d'affectation. Pensez-y comme le signe égal (=) que vous avez utilisé en classe de mathématiques, mais avec des superpouvoirs ! Ils sont utilisés pour affecter des valeurs aux variables de vos programmes. Mais en C, ils peuvent faire beaucoup plus que des affectations simples.

Opérateur d'affectation simple (=)

Commençons par les bases – l'opérateur d'affectation simple. C'est la fondation de toutes les opérations d'affectation en C.

Comment cela fonctionne

L'opérateur d'affectation simple est représenté par le signe égal (=). Il prend la valeur de droite et l'affecte à la variable de gauche.

Voici un exemple simple :

int age;
age = 25;

Dans ce code, nous déclarons une variable entière appelée age, puis nous lui affectons la valeur 25. C'est aussi simple que ça !

Affectations multiples

Vous pouvez également chaîner les affectations. Regardons un exemple :

int x, y, z;
x = y = z = 10;

Ce code affecte la valeur 10 à toutes les trois variables : x, y et z. Il fonctionne de droite à gauche, donc d'abord z reçoit 10, puis y reçoit la valeur de z (qui est 10), et enfin x reçoit la valeur de y (qui est également 10).

Initialisation des variables

Vous pouvez également utiliser l'opérateur d'affectation lorsque vous déclarez des variables :

int hauteur = 180; // Déclarer et initialiser en une ligne
float pi = 3.14159;
char note = 'A';

C'est un excellent moyen de définir des valeurs initiales pour vos variables dès leur création.

Opérateurs d'affectation augmentés

Maintenant, augmentons notre niveau ! Les opérateurs d'affectation augmentés sont comme des raccourcis. Ils effectuent une opération et une affectation en un seul pas. Analysons-les un par un :

Affectation additionnelle (+=)

L'opérateur += ajoute l'opérande de droite à l'opérande de gauche et affecte le résultat à l'opérande de gauche.

int score = 10;
score += 5; // Équivalent à : score = score + 5;
printf("Score : %d\n", score); // Sortie : Score : 15

Affectation soustractive (-=)

L'opérateur -= soustrait l'opérande de droite de l'opérande de gauche et affecte le résultat à l'opérande de gauche.

int vies = 3;
vies -= 1; // Équivalent à : vies = vies - 1;
printf("Vies restantes : %d\n", vies); // Sortie : Vies restantes : 2

Affectation de multiplication (*=)

L'opérateur *= multiplie l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche.

int puissance = 2;
puissance *= 3; // Équivalent à : puissance = puissance * 3;
printf("Niveau de puissance : %d\n", puissance); // Sortie : Niveau de puissance : 6

Affectation de division (/=)

L'opérateur /= divise l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche.

float argent = 100.0;
argent /= 2; // Équivalent à : argent = argent / 2;
printf("Argent restant : %.2f\n", argent); // Sortie : Argent restant : 50.00

Affectation de modulo (%=)

L'opérateur %= calcule le reste de la division de l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche.

int cookies = 10;
cookies %= 3; // Équivalent à : cookies = cookies % 3;
printf("Cookies restants : %d\n", cookies); // Sortie : Cookies restants : 1

Affectation ET bit à bit (&=)

L'opérateur &= effectue une opération ET bit à bit et affecte le résultat à l'opérande de gauche.

int a = 5; // Binaire : 0101
a &= 3;    // Binaire : 0011
printf("Résultat : %d\n", a); // Sortie : Résultat : 1

Affectation OU bit à bit (|=)

L'opérateur |= effectue une opération OU bit à bit et affecte le résultat à l'opérande de gauche.

int b = 5; // Binaire : 0101
b |= 3;    // Binaire : 0011
printf("Résultat : %d\n", b); // Sortie : Résultat : 7

Affectation OU exclusif bit à bit (^=)

L'opérateur ^= effectue une opération OU exclusif bit à bit et affecte le résultat à l'opérande de gauche.

int c = 5; // Binaire : 0101
c ^= 3;    // Binaire : 0011
printf("Résultat : %d\n", c); // Sortie : Résultat : 6

Affectation de décalage à gauche (<<=)

L'opérateur <<= effectue un décalage à gauche et affecte le résultat à l'opérande de gauche.

int d = 5; // Binaire : 0101
d <<= 1;   // Décaler vers la gauche de 1
printf("Résultat : %d\n", d); // Sortie : Résultat : 10

Affectation de décalage à droite (>>=)

L'opérateur >>= effectue un décalage à droite et affecte le résultat à l'opérande de gauche.

int e = 8; // Binaire : 1000
e >>= 1;   // Décaler vers la droite de 1
printf("Résultat : %d\n", e); // Sortie : Résultat : 4

Tableau récapitulatif des opérateurs d'affectation

Voici un tableau pratique récapitulant tous les opérateurs d'affectation que nous avons couverts :

Opérateur	Description	Exemple	Équivalent à
=	Affectation simple	x = 5;	x = 5;
+=	Affectation additionnelle	x += 3;	x = x + 3;
-=	Affectation soustractive	x -= 3;	x = x - 3;
*=	Affectation de multiplication	x *= 3;	x = x * 3;
/=	Affectation de division	x /= 3;	x = x / 3;
%=	Affectation de modulo	x %= 3;	x = x % 3;
&=	Affectation ET bit à bit	x &= 3;	x = x & 3;
|=	Affectation OU bit à bit	x |= 3;	x = x | 3;
^=	Affectation OU exclusif bit à bit	x ^= 3;	x = x ^ 3;
<<=	Affectation de décalage à gauche	x <<= 2;	x = x << 2;
>>=	Affectation de décalage à droite	x >>= 2;	x = x >> 2;

Et voilà ! Vous venez de faire un grand tour des opérateurs d'affectation en C. Souvenez-vous, la pratique fait le maître. Essayez d'écrire du code en utilisant ces opérateurs, et vous verrez rapidement que vous les utiliserez sans effort.

Bon codage, futurs programmeurs en C !

Credits: Image by storyset