Opérateurs Bit à Bit en C

Bonjour à tous, futurs sorciers de la programmation ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des opérateurs bit à bit en C. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je serai votre guide amical, expliquant tout étape par étape. Alors, mettez votre chapeau d'apprentissage et plongeons-y !

Qu'est-ce qu'un Opérateur Bit à Bit ?

Avant de commencer, comprenons ce qu'est un opérateur bit à bit. Imaginez que vous avez un tas de interrupteurs. Les opérateurs bit à bit sont comme des outils spéciaux qui vous permettent de contrôler ces interrupteurs de manière intéressante - en les activant ou en les désactivant, voire même en changeant leur état. Dans le monde des ordinateurs, ces "interrupteurs" sont en réalité des bits (0 et 1) qui composent nos données.

Maintenant, explorons chaque opérateur bit à bit un par un.

Opérateur ET Bit à Bit (&) en C

L'opérateur ET bit à bit est comme un ami exigeant qui dit "oui" uniquement lorsque les deux entrées s'entendent. Il compare chaque bit de deux nombres et renvoie 1 uniquement si les deux bits sont à 1. Sinon, il renvoie 0.

Voyons un exemple :

#include <stdio.h>

int main() {
unsigned int a = 60;  // 60 = 0011 1100 en binaire
unsigned int b = 13;  // 13 = 0000 1101 en binaire

printf("a & b = %d\n", a & b);

return 0;
}

Sortie :

a & b = 12

Que se passe-t-il ici ? Analysons cela :

0011 1100  (60 en binaire)
& 0000 1101  (13 en binaire)
----------
0000 1100  (12 en décimal)

Voyez comment il ne garde que les 1 où les deux nombres ont des 1 ? C'est la magie de l'ET bit à bit !

Opérateur OU (|) Bit à Bit

L'opérateur OU bit à bit est comme un ami généreux qui dit "oui" si l'une des entrées s'entend. Il renvoie 1 si au moins un des bits correspondants est à 1.

Voici un exemple :

#include <stdio.h>

int main() {
unsigned int a = 60;  // 60 = 0011 1100 en binaire
unsigned int b = 13;  // 13 = 0000 1101 en binaire

printf("a | b = %d\n", a | b);

return 0;
}

Sortie :

a | b = 61

Analysons cela :

0011 1100  (60 en binaire)
| 0000 1101  (13 en binaire)
----------
0011 1101  (61 en décimal)

Voyez comment il garde un 1 partout où l'un des nombres a un 1 ? C'est l'OU bit à bit pour vous !

Opérateur OU Exclusif (^) Bit à Bit

L'opérateur OU exclusif est comme un ami excentrique qui aime que les choses soient différentes. Il renvoie 1 si les bits sont différents et 0 s'ils sont les mêmes.

Voyons cela en action :

#include <stdio.h>

int main() {
unsigned int a = 60;  // 60 = 0011 1100 en binaire
unsigned int b = 13;  // 13 = 0000 1101 en binaire

printf("a ^ b = %d\n", a ^ b);

return 0;
}

Sortie :

a ^ b = 49

Voici ce qui se passe :

0011 1100  (60 en binaire)
^ 0000 1101  (13 en binaire)
----------
0011 0001  (49 en décimal)

L'OU exclusif est souvent utilisé en cryptographie parce qu'il est facile à inverser. Si vous faites un OU exclusif d'un nombre deux fois avec la même valeur, vous obtenez le nombre original. Cool, non ?

L'Opérateur de Décalage à Gauche (<<)

L'opérateur de décalage à gauche est comme un tapis roulant déplaçant les bits vers la gauche. Il décale chaque bit vers la gauche d'un nombre spécifié de positions.

Voici comment cela fonctionne :

#include <stdio.h>

int main() {
unsigned int a = 60;  // 60 = 0011 1100 en binaire

printf("a << 2 = %d\n", a << 2);

return 0;
}

Sortie :

a << 2 = 240

Analysons cela :

0011 1100  (60 en binaire)
<<2 (décalage vers la gauche par 2)
----------
1111 0000  (240 en décimal)

Notez comment les bits se déplacent vers la gauche et des nouveaux 0 remplissent à droite ? Aussi, décaler vers la gauche de 1 est la même chose que multiplier par 2. Donc, décaler vers la gauche de 2 est comme multiplier par 4 !

L'Opérateur de Décalage à Droite (>>)

L'opérateur de décalage à droite est comme l'opposé jumeau de celui de gauche. Il déplace les bits vers la droite.

Voici un exemple :

#include <stdio.h>

int main() {
unsigned int a = 60;  // 60 = 0011 1100 en binaire

printf("a >> 2 = %d\n", a >> 2);

return 0;
}

Sortie :

a >> 2 = 15

Voici ce qui se passe :

0011 1100  (60 en binaire)
>>2 (décalage vers la droite par 2)
----------
0000 1111  (15 en décimal)

Les bits se déplacent vers la droite et de nouveaux 0 remplissent à gauche. Décaler vers la droite de 1 est comme diviser par 2 (en ignorant les restes).

L'Opérateur de Complément à 1 (~)

L'opérateur de complément à 1 est comme un miroir pour les bits. Il inverse chaque bit de 0 en 1 et vice versa.

Voici comment cela fonctionne :

#include <stdio.h>

int main() {
unsigned int a = 60;  // 60 = 0011 1100 en binaire

printf("~a = %u\n", ~a);

return 0;
}

Sortie :

~a = 4294967235

Que s'est-il passé ici ? Analysons cela :

0000 0000 0000 0000 0000 0000 0011 1100  (60 en binaire 32 bits)
~(complément à 1)
----------------------------------------
1111 1111 1111 1111 1111 1111 1100 0011  (4294967235 en décimal)

Chaque 0 est devenu 1 et chaque 1 est devenu 0. Le résultat semble grand parce que nous utilisons un unsigned int, qui interprète tous ces 1 comme un nombre positif.

Conclusion

Et voilà, les amis ! Nous avons exploré la terre des opérateurs bit à bit en C. Ces outils puissants peuvent sembler un peu délicats au début, mais avec de la pratique, vous découvrirez qu'ils sont extrêmement utiles pour des tâches comme travailler avec le matériel, optimiser le code ou même quelques tours de magie sympas (si vos fêtes impliquent des mathématiques binaires, c'est-à-dire).

N'oubliez pas, la clé pour maîtriser ces opérateurs est la pratique. Essayez d'écrire vos propres programmes utilisant ces opérateurs. Expérimentez avec différents nombres et voyez quels résultats vous obtenez. Avant que vous ne le sachiez, vous serez en train de twiddler les bits avec les meilleurs !

Bon codage, et que les bits soient toujours en votre faveur !

Opérateur	Symbole	Description
ET	&	Renvoie 1 si les deux bits sont à 1, sinon 0
OU	|	Renvoie 1 si au moins un bit est à 1, sinon 0
OU Exclusif	^	Renvoie 1 si les bits sont différents, 0 si identiques
Décalage à Gauche	<<	Décale les bits vers la gauche par un nombre spécifié de positions
Décalage à Droite	>>	Décale les bits vers la droite par un nombre spécifié de positions
Complément à 1	~	Inverse tous les bits (0 devient 1, 1 devient 0)

Credits: Image by storyset