Maîtriser les opérateurs bit à bit et de décalage en C# : Guide complet

Opérateurs bit à bit et de décalage en C#

Dans ce tutoriel, nous allons apprendre en détail les opérateurs bit à bit et de décalage en C#. C# fournit 4 opérateurs bit à bit et 2 opérateurs de décalage.

Les opérateurs bit à bit et de décalage sont utilisés pour effectuer des opérations au niveau des bits sur des données entières (int, long, etc.) et booléennes. Ces opérateurs ne sont pas couramment utilisés dans les situations réelles.

Si vous souhaitez explorer davantage, consultez les applications pratiques des opérations bit à bit.

Les opérateurs bit à bit et de décalage disponibles en C# sont listés ci-dessous.

Liste des opérateurs bit à bit C#

Opérateur	Nom de l'opérateur
~	Complément bit à bit
&	ET bit à bit
|	OU bit à bit
^	OU exclusif bit à bit (XOR)
<<	Décalage bit à bit vers la gauche
>>	Décalage bit à bit vers la droite

---

OU bit à bit

L'opérateur OU bit à bit est représenté par |. Il effectue une opération OU bit à bit sur les bits correspondants de deux opérandes. Si l'un des bits est 1, le résultat est 1. Sinon, le résultat est 0.

Si les opérandes sont de type bool, l'opération OU bit à bit est équivalente à une opération OU logique entre eux.

Par exemple,

14 = 00001110 (en binaire)
11 = 00001011 (en binaire)

Opération OU bit à bit entre 14 et 11 :

00001110
00001011
--------
00001111 = 15 (en décimal)

Exemple 1 : OU bit à bit

using System;
namespace Operator {
    class BitWiseOR {
        public static void Main(string[] args) {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber | secondNumber;
            Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

14 | 11 = 15

---

ET bit à bit

L'opérateur ET bit à bit est représenté par &. Il effectue une opération ET bit à bit sur les bits correspondants de deux opérandes. Si l'un des bits est 0, le résultat est 0. Sinon, le résultat est 1.

Si les opérandes sont de type bool, l'opération ET bit à bit est équivalente à une opération ET logique entre eux.

Par exemple,

14 = 00001110 (en binaire)
11 = 00001011 (en binaire)

Opération ET bit à bit entre 14 et 11 :

00001110
00001011
--------
00001010 = 10 (en décimal)

Exemple 2 : ET bit à bit

using System;
namespace Operator {
    class BitWiseAND {
        public static void Main(string[] args) {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber & secondNumber;
            Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

14 & 11 = 10

---

OU exclusif bit à bit (XOR)

L'opérateur OU exclusif bit à bit est représenté par ^. Il effectue une opération XOR bit à bit sur les bits correspondants de deux opérandes. Si les bits correspondants sont identiques, le résultat est 0. S'ils sont différents, le résultat est 1.

Si les opérandes sont de type bool, l'opération XOR bit à bit est équivalente à une opération XOR logique entre eux.

Par exemple,

14 = 00001110 (en binaire)
11 = 00001011 (en binaire)

Opération XOR bit à bit entre 14 et 11 :

00001110
00001011
--------
00000101 = 5 (en décimal)

Si vous voulez en savoir plus sur l'utilisation du XOR bit à bit, consultez La magie du XOR.

Exemple 3 : OU exclusif bit à bit

using System;
namespace Operator {
    class BitWiseXOR {
        public static void Main(string[] args) {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber ^ secondNumber;
            Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

14 ^ 11 = 5

---

Complément bit à bit

L'opérateur de complément bit à bit est représenté par ~. C'est un opérateur unaire, c'est-à-dire qu'il opère sur un seul opérande. L'opérateur ~ inverse chaque bit, c'est-à-dire qu'il change 1 en 0 et 0 en 1.

Par exemple,

26 = 00011010 (en binaire)

Opération de complément bit à bit sur 26 :

~ 00011010 = 11100101 = 229 (en décimal)

Exemple 4 : Complément bit à bit

using System;
namespace Operator {
    class BitWiseComplement {
        public static void Main(string[] args) {
            int number = 26, result;
            result = ~number;
            Console.WriteLine("~{0} = {1}", number, result);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

~26 = -27

Nous avons obtenu -27 comme sortie alors que nous attendions 229. Pourquoi cela s'est-il produit ?

Cela se produit parce que la valeur binaire 11100101 que nous attendions être 229 est en fait une représentation en complément à 2 de -27. Les nombres négatifs dans les ordinateurs sont représentés en complément à 2.

Pour tout entier n, le complément à 2 de n sera -(n+1).

Complément à 2

Décimal	Binaire	Complément à 2
0	00000000	-(11111111 + 1) = -00000000 = -0 (en décimal)
1	00000001	-(11111110 + 1) = -11111111 = -256 (en décimal)
229	11100101	-(00011010 + 1) = -00011011 = -27

Les valeurs de débordement sont ignorées dans le complément à 2.

Le complément bit à bit de 26 est 229 (en décimal) et le complément à 2 de 229 est -27. Donc la sortie est -27 au lieu de 229.

---

Décalage bit à bit vers la gauche

L'opérateur de décalage bit à bit vers la gauche est représenté par <<. L'opérateur << décale un nombre vers la gauche d'un nombre spécifié de bits. Des zéros sont ajoutés aux bits de poids faible.

En décimal, cela équivaut à

num * 2^bits

Par exemple,

42 = 101010 (en binaire)

Opération de décalage vers la gauche sur 42 :

42 << 1 = 84 (en binaire 1010100)
42 << 2 = 168 (en binaire 10101000)
42 << 4 = 672 (en binaire 1010100000)

Exemple 5 : Décalage bit à bit vers la gauche

using System;
namespace Operator {
    class LeftShift {
        public static void Main(string[] args) {
            int number = 42;
            Console.WriteLine("{0}<<1 = {1}", number, number << 1);
            Console.WriteLine("{0}<<2 = {1}", number, number << 2);
            Console.WriteLine("{0}<<4 = {1}", number, number << 4);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

42<<1 = 84
42<<2 = 168
42<<4 = 672

---

Décalage bit à bit vers la droite

L'opérateur de décalage bit à bit vers la droite est représenté par >>. L'opérateur >> décale un nombre vers la droite d'un nombre spécifié de bits. Le premier opérande est décalé vers la droite du nombre de bits spécifié par le second opérande.

En décimal, cela équivaut à

floor(num / 2^bits)

Par exemple,

42 = 101010 (en binaire)

Opération de décalage vers la droite sur 42 :

42 >> 1 = 21 (en binaire 010101)
42 >> 2 = 10 (en binaire 001010)
42 >> 4 = 2 (en binaire 000010)

Exemple 6 : Décalage bit à bit vers la droite

using System;
namespace Operator {
    class RightShift {
        public static void Main(string[] args) {
            int number = 42;
            Console.WriteLine("{0}>>1 = {1}", number, number >> 1);
            Console.WriteLine("{0}>>2 = {1}", number, number >> 2);
            Console.WriteLine("{0}>>4 = {1}", number, number >> 4);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

42>>1 = 21
42>>2 = 10
42>>4 = 2