Maîtriser les opérateurs bit à bit en C : ET, OU, XOR, décalages et complément

Que sont les opérateurs bit à bit ?

Les opérateurs bit à bit manipulent les bits individuels des valeurs entières. Contrairement aux opérateurs arithmétiques qui travaillent sur des nombres entiers, les opérateurs bit à bit agissent sur la représentation binaire, les rendant idéaux pour les tâches critiques en performance telles que les drapeaux, masques de bits et contrôle de périphériques bas niveau.

En C, les opérateurs bit à bit suivants sont disponibles :

Opérateur	Signification
&	ET bit à bit (Bitwise AND)
|	OU bit à bit (Bitwise OR)
^	XOR bit à bit (OU exclusif)
~	NON bit à bit (complément à un)
<<	Décalage à gauche (Left shift)
>>	Décalage à droite (Right shift)

Les opérateurs bit à bit sont définis uniquement pour les types entiers ; ils ne s'appliquent pas aux types à virgule flottante comme float ou double.

Les opérations commencent au bit de poids faible (LSB) et progressent vers le bit de poids fort (MSB). Le tableau de vérité suivant résume les résultats binaires :

Opérande x	Opérande y	x & y	x | y	x ^ y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

Dans les sections suivantes, nous approfondirons chaque opérateur avec des exemples.

ET bit à bit (&)

L'opérateur ET retourne 1 seulement quand les deux bits correspondants sont 1 ; sinon le résultat est 0. Il est couramment utilisé pour masquer les bits indésirables.

Op1 = 0000 1101
Op2 = 0001 1001
Result = 0000 1001

OU bit à bit (|)

L'opérateur OU retourne 1 si au moins un des bits est 1. Il est utile pour définir des bits spécifiques.

Op1 = 0000 1101
Op2 = 0001 1001
Result = 0001 1101

XOR bit à bit (^)

L'opérateur XOR retourne 1 seulement quand les bits diffèrent. Il est pratique pour basculer des bits.

Op1 = 0000 1101
Op2 = 0001 1001
Result = 0001 0100

Programme d'exemple :

#include <stdio.h>
int main() {
    int a = 20; /* 20 = 010100 */
    int b = 21; /* 21 = 010101 */
    int c = 0;
    c = a & b; /* 20 = 010100 */
    printf("AND - c = %d\n", c);
    c = a | b; /* 21 = 010101 */
    printf("OR - c = %d\n", c);
    c = a ^ b; /* 1 = 000001 */
    printf("XOR - c = %d\n", c);
    return 0;
}

Sortie :

AND - c = 20
OR - c = 21
XOR - c = 1

Opérateurs de décalage bit à bit (<< et >>)

Les opérateurs de décalage déplacent les bits vers la gauche ou la droite d'un nombre spécifié.

• operand << n – décale vers la gauche, insérant des zéros à droite.
• operand >> n – décale vers la droite, insérant des zéros à gauche.

Exemple avec un nombre 4 bits 1111 :

x << 2 → 1100
x >> 2 → 0011

Illustration par programme :

#include <stdio.h>
int main() {
    int a = 20; /* 20 = 010100 */
    int c = 0;
    c = a << 2; /* 80 = 101000 */
    printf("Left shift - c = %d\n", c);
    c = a >> 2; /* 5 = 000101 */
    printf("Right shift - c = %d\n", c);
    return 0;
}

Sortie :

Left shift - c = 80
Right shift - c = 5

Complément bit à bit (~)

L'opérateur de complément inverse chaque bit : 1 devient 0 et vice versa. C'est un opérateur unaire appliqué à un seul opérande.

0000 1111 → 1111 0000

Programme d'exemple :

#include <stdio.h>
int main() {
    int a = 10; /* 10 = 001010 */
    int c = ~a; /* -11 en complément à deux */
    printf("Complement - c = %d\n", c);
    return 0;
}

Sortie :

Complement - c = -11

Tous les opérateurs ensemble

Voici un programme concis qui démontre chaque opérateur bit à bit discuté.

#include <stdio.h>
int main() {
    unsigned int x = 48; /* 0011 0000 */
    unsigned int y = 13; /* 0000 1101 */
    int z = 0;
    z = x & y; /* 0 = 0000 0000 */
    printf("AND - x & y = %d\n", z);
    z = x | y; /* 61 = 0011 1101 */
    printf("OR - x | y = %d\n", z);
    z = x ^ y; /* 61 = 0011 1101 */
    printf("XOR - x ^ y = %d\n", z);
    z = ~x; /* -49 = 1111 0100 (complément à deux) */
    printf("NOT - ~x = %d\n", z);
    z = x << 2; /* 192 = 1100 0000 */
    printf("Left shift - x << 2 = %d\n", z);
    z = x >> 2; /* 12 = 0000 1100 */
    printf("Right shift - x >> 2 = %d\n", z);
    return 0;
}

Résultat :

AND - x & y = 0
OR - x | y = 61
XOR - x ^ y = 61
NOT - ~x = -49
Left shift - x << 2 = 192
Right shift - x >> 2 = 12

Points clés à retenir

• Les opérateurs bit à bit sont exclusifs aux types entiers et opèrent au niveau binaire.
• Ils incluent les opérations logiques (ET, OU, XOR), de décalage (gauche/droite) et de complément (~).
• Ces opérateurs sont indispensables pour la manipulation de drapeaux, E/S bas niveau et code critique en performance.