Comprendre l'opérateur XOR binaire en C#

Introduction à XOR

Tim commence la vidéo en mentionnant qu'elle fait partie de sa série Comprendre le binaire en C#, et plus précisément de la leçon numéro neuf. Il prépare le terrain en expliquant que dans cette session, il enseignera le fonctionnement de l'opérateur OU exclusif (XOR) et comment il peut être utile dans divers scénarios.

Syntaxe de l'opérateur XOR et explication de base

Tim introduit deux valeurs, 1 et 2, et les imprime sur la console pour référence. Il supprime la représentation en 32 bits pour se concentrer sur la représentation binaire standard en 8 bits.

À 0:31, il explique que XOR est représenté par le symbole du caret (^) en C#. Il rappelle aux téléspectateurs que :

• L'opérateur AND (&) exige que les deux bits soient à 1 pour renvoyer 1.
• L'opérateur OR (|) renvoie 1 si au moins un des bits vaut 1.
• L'opérateur XOR (^) ne renvoie 1 que si l'un des deux bits est à 1, mais pas les deux.

Tim explique plus en détail la règle pour chaque comparaison de bits :

-1 XOR 0 = 1

• 0 XOR 1 = 1
• 1 XOR 1 = 0
• 0 XOR 0 = 0

Cela signifie que XOR agit comme un détecteur de différence entre deux valeurs.

Démonstration de XOR en code C

Tim passe à un exemple pratique en définissant une variable uint qui contient le résultat de l'opération XOR de deux valeurs :

// Define two sample values
uint val1 = 0b0001;  // 1 in decimal
uint val2 = 0b0010;  // 2 in decimal

// Perform XOR operation between val1 and val2
uint result = val1 ^ val2;

// Print the resultant binary value of XOR operation
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

// Define two sample values
uint val1 = 0b0001;  // 1 in decimal
uint val2 = 0b0010;  // 2 in decimal

// Perform XOR operation between val1 and val2
uint result = val1 ^ val2;

// Print the resultant binary value of XOR operation
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

Il imprime ensuite le résultat sur la console et le note :

0000 0011

Ce résultat montre que le XOR ne préserve que les bits dont l'une des valeurs d'origine contient un 1, mais pas les deux.

Utilisation de XOR pour la comparaison de valeurs

Tim démontre maintenant une utilisation pratique de XOR : vérifier si deux valeurs sont identiques.

À 3:00, il modifie les valeurs pour que val1 et val2 soient exactement les mêmes :

// Initialize val1 and val2 to the same value
uint val1 = 0b10011001;
uint val2 = 0b10011001;

// Perform XOR operation to check for identical values
uint result = val1 ^ val2;

// Output will be zero if both values are identical
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

// Initialize val1 and val2 to the same value
uint val1 = 0b10011001;
uint val2 = 0b10011001;

// Perform XOR operation to check for identical values
uint result = val1 ^ val2;

// Output will be zero if both values are identical
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

Lorsqu'il exécute l'opération XOR, le résultat est le suivant :

0000 0000

Tim explique qu'un résultat XOR de 0 signifie que les valeurs sont identiques. XOR est donc un moyen rapide de comparer deux nombres pour en vérifier l'égalité.

XOR pour identifier les différences

À 4:00, Tim montre un autre cas où val1 et val2 ont de légères différences. Cette fois, XOR produit un résultat non nul, indiquant une différence entre les valeurs.

Cette approche est utile pour comparer efficacement de grandes valeurs binaires, car XOR peut mettre en évidence les différences en une seule étape.

XOR pour échanger deux variables sans variable temporaire

Tim présente une astuce de programmation classique : échanger deux nombres sans utiliser de variable temporaire.

À 5:40, il met au défi les spectateurs d'échanger val1 et val2 sans déclarer de variable supplémentaire. La solution utilise trois fois XOR :

// Original values
uint val1 = 0b0010; // 2 in decimal
uint val2 = 0b0100; // 4 in decimal

// Swap the values using XOR
val1 = val1 ^ val2;
val2 = val1 ^ val2;
val1 = val1 ^ val2;

// After swap: val1 = 4, val2 = 2
Console.WriteLine($"val1: {val1}, val2: {val2}");

// Original values
uint val1 = 0b0010; // 2 in decimal
uint val2 = 0b0100; // 4 in decimal

// Swap the values using XOR
val1 = val1 ^ val2;
val2 = val1 ^ val2;
val1 = val1 ^ val2;

// After swap: val1 = 4, val2 = 2
Console.WriteLine($"val1: {val1}, val2: {val2}");

Il explique le processus :

1. val1 stocke val1 ^ val2, ce qui signifie qu'il contient maintenant un mélange des deux valeurs.
2. val2 est mis à jour en appliquant XOR avec val1 à nouveau, ne laissant que la valeur originale val1.
3. val1 est à nouveau soumis au XOR, ne laissant que la valeur originale val2.

À 7:30, Tim imprime les valeurs échangées et confirme que val1 et val2 ont correctement échangé leurs valeurs.

Comprendre le XOR en représentation binaire

Pour renforcer la compréhension, Tim exécute une version binaire de l'opération de permutation, en montrant comment chaque étape XOR affecte les bits. Il souligne que chaque bit n'est inversé que lorsque c'est nécessaire, ce qui fait du XOR un moyen efficace d'échanger des valeurs.

Conclusion

Tim conclut en renforçant les points essentiels à retenir :

• XOR renvoie 1 uniquement lorsque l'un des bits est 1.
• Il peut être utilisé pour comparer des valeurs efficacement.
• Il permet de changer deux valeurs sans une troisième variable, ce qui en fait une astuce pratique dans les défis de codage.

Il encourage les spectateurs à expérimenter avec XOR et à l'appliquer à des problèmes du monde réel afin d'acquérir une compréhension plus approfondie.

Conclusion

La vidéo de Tim Corey fournit une excellente analyse concise de XOR en C#. En parcourant des exemples étape par étape, il démontre l'utilité de l'opérateur dans les comparaisons, les différences et même l'échange de valeurs.

Si vous vous intéressez aux opérations binaires ou aux astuces bitwise, il s'agit d'une vidéo à regarder absolument pour renforcer votre compréhension de la manipulation binaire en C#.