Exemple 1:
Le code commence ici en incluant le fichier d'en-tête « iostream ». Comme son nom l'indique, ce fichier d'en-tête est destiné aux fonctions d'entrée et de sortie telles que ces fonctions y sont déclarées. Ensuite, nous avons le « namespace std » dans lequel ces fonctions sont définies.
En dessous, nous appelons la méthode « main() ». On initialise la variable « x » de type « int » et on attribue « 10 » à ce « x ». Ensuite, nous avons une autre variable, « y », du type de données « int » et attribuons « 6 ». Après cela, nous initialisons « r » du type de données « int ». Ici, nous appliquons l'opération « XOR » sur les valeurs des variables « x » et « y » en plaçant l'opérateur « ^ » entre ces variables. Cet opérateur « XOR » convertit les valeurs entières en binaire, applique l'opération « XOR » sur les valeurs binaires et enregistre le résultat sous forme de valeur entière. Le résultat de cet opérateur « XOR » est désormais enregistré dans « r ».
Après cela, nous affichons les valeurs de ces variables séparément, puis affichons le résultat que nous obtenons après avoir appliqué l'opérateur « XOR » à l'aide de « cout ».
Codage 1 :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
int X = dix ;
int et = 6 ;
int r = X ^ et ;
cout << 'La valeur de x : ' << X << fin ;
cout << 'La valeur de y : ' << et << fin ;
cout << 'Le XOR x ^ y = ' << r << fin ;
retour 0 ;
}
Sortir:
Puisque la valeur binaire de « 10 » est « 1010 » et que la valeur binaire de « 6 » est « 0110 », il renvoie « 12 » après avoir appliqué l'opérateur « XOR » et « 1100 » est la valeur binaire de « 12 ». Cela montre qu'il renvoie « 1 » lorsque les deux entrées sont différentes et renvoie « 0 » lorsque les deux entrées sont identiques.
Exemple 2 :
Après avoir ajouté le fichier d'en-tête « iostream » et l'espace de noms « std », nous invoquons la méthode « main() ». Ensuite, nous initialisons deux variables, « X1 » et « X2 », et attribuons respectivement les valeurs entières « 21 » et « 35 » à ces variables. Ensuite, nous imprimons les valeurs des deux variables. Après cela, nous appliquons l'opérateur « XOR » à ces valeurs entières. Nous appliquons cette opération « XOR » à ces variables « X1 » et « X2 » à l'intérieur du « cout ». Ainsi, le résultat de ce « XOR » est également affiché comme résultat.
Code 2 :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
int X1 = vingt-et-un , X2 = 35 ;
cout << 'Valeur X1 = ' << X1 << fin ;
cout << 'Valeur X2 = ' << X2 << fin ;
cout << 'Le résultat XOR est : ' << fin ;
cout << 'X1 ^ X2 = ' << ( X1 ^ X2 ) << fin ;
retour 0 ;
}
Sortir:
La première valeur entière est « 21 » et la seconde est « 35 ». Après avoir appliqué l'opération « XOR », on obtient le résultat « 54 » qui s'affiche ici.
Exemple 3 :
Nous appelons la méthode « main() » après avoir ajouté le fichier d'en-tête « iostream » et l'espace de noms « std ». La variable « n1 » de type « int » est initialisée et « 29 » lui est affecté. Ensuite, nous attribuons « 75 » à une autre variable, « n2 », qui est du type de données « int ». Ensuite, nous initialisons la valeur de « r1 » ainsi que celle du type de données « int ».
Ensuite, nous appliquons l'opération « XOR » sur les valeurs des variables « n1 » et « n2 » en plaçant l'opérateur « ^ » entre elles. Les valeurs entières sont converties en binaire à l'aide de cet opérateur « XOR » qui applique ensuite l'opération « XOR » aux données binaires et enregistre le résultat sous forme de valeur entière. La variable « r1 » contient désormais le résultat de cette opération « XOR ». Les valeurs de chacune de ces variables sont ensuite affichées séparément. Nous montrons également le résultat de l'utilisation de l'opérateur « XOR » avec l'aide de l'opérateur « cout ».
Code 3 :
#includeen utilisant l'espace de noms std ;
int principal ( )
{
int n1 = 29 ;
int n2 = 75 ;
int r1 = n1 ^ n2 ;
cout << 'La première valeur : ' << n1 << fin ;
cout << 'La deuxième valeur : ' << n2 << fin ;
cout << 'Le résultat de l'opérateur XOR est : ' << r1 << fin ;
retour 0 ;
}
Sortir:
Les entiers d'entrée sont « 29 » et « 75 » qui sont convertis en binaire. Ensuite, l’opération « XOR » leur est appliquée. Après avoir appliqué « XOR », le résultat est « 86 ».
Exemple 4 :
Dans ce code, nous obtenons l'entrée de l'utilisateur, puis appliquons l'opération « XOR » aux valeurs d'entrée de l'utilisateur. Les trois variables sont déclarées ici avec les noms « Xvalue1 », « Xvalue2 » et « Xvalue3 ». Ensuite, nous plaçons le « cout » et affichons le message « Entrez deux valeurs ici ».
Après avoir affiché ce message, l'utilisateur saisit les valeurs que nous obtenons avec l'aide du cin. Nous plaçons donc « cin » en dessous. Les deux valeurs sont désormais stockées dans ces variables et sont également affichées ici. Maintenant, nous devons appliquer l'opération « XOR », nous insérons donc l'opérateur « ^ » entre les variables « Xvalue1 » et « Xvalue2 ».
Désormais, cette opération « XOR » est appliquée aux valeurs de ces variables. Le résultat de cet opérateur « XOR » est ensuite enregistré dans la variable « Xvalue3 ». Nous l'affichons également en utilisant la méthode « cout ».
Code 4 :
#includeen utilisant l'espace de noms std ;
int principal ( )
{
int Valeur X1 , Valeur X2 , Valeur X3 ;
cout << 'Entrez deux valeurs ici : ' << fin ;
cout << 'Valeur X1 : ' ;
manger >> Valeur X1 ;
cout << « Valeur X2 : » ;
manger >> Valeur X2 ;
Valeur X3 = Valeur X1 ^ Valeur X2 ;
cout << ' \n Maintenant, après avoir appliqué XOR sur les deux valeurs : ' << fin ;
cout << 'ValeurX1 ^ ValeurX2 = ' << Valeur X3 << fin ;
}
Sortir:
Lorsque nous exécutons ce code, il imprime un message pour saisir deux valeurs. Ainsi, nous saisissons « 14 » comme valeur de la variable « Xvalue1 » et « 45 » comme valeur de la variable « Xvalue2 ». Ensuite, nous appuyons sur « Entrée ». L'opération « XOR » est ensuite appliquée à ces valeurs qui convertit les deux valeurs en binaire puis affiche le résultat ici.
Exemple 5 :
Nous appliquons cette opération « XOR » aux données de caractères. Nous initialisons deux variables « char » avec les noms « ch_a » et « ch_b ». Nous attribuons respectivement « a » et « 8 » à ces variables. Ensuite, nous plaçons l'opérateur « ^ » entre « ch_a » et « ch_b » et l'attribuons à la variable « ch_result » qui est également le type de données « char ». Ces caractères sont convertis en binaire, et le résultat est enregistré dans la variable « ch_result ». Nous imprimons ensuite les deux variables et le résultat de cette opération « XOR ».
Code 5 :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
carboniser ch_a = 'un' ;
carboniser ch_b = '8' ;
carboniser ch_result = ch_a ^ ch_b ;
cout << 'Le premier caractère est : ' << ch_a << fin ;
cout << 'Le deuxième caractère est : ' << ch_b << fin ;
cout << 'Le résultat est : ' << ch_result << fin ;
}
Sortir:
Les caractères d'entrée sont « a » et « 8 » et le résultat de « XOR » est affiché sous la forme « Y » que nous obtenons après avoir appliqué l'opération « XOR » qui convertit « a » et « 8 » en binaire puis effectue le « opération « XOR ».
Conclusion
L'opération « XOR » est explorée en profondeur ici et nous avons expliqué qu'il s'agit d'une opération « au niveau du bit » car elle utilise les valeurs binaires. Nous avons expliqué que toutes les valeurs que nous avons saisies pour appliquer l'opération « XOR » sont converties en valeurs binaires, puis l'opération « XOR » est effectuée. Nous avons démontré plusieurs exemples et montré comment fonctionne l'opération « XOR » dans la programmation C++.