HOWTO · C
Comment comparer des bits en C
Cet article montre comment comparer des bits en C.
Sur cette page
Les opérations au niveau du bit sont fondamentales en programmation informatique, en particulier lorsque l’on travaille avec la manipulation de données de bas niveau. En C, il existe plusieurs méthodes pour comparer des bits individuels ou des groupes de bits.
Dans cet article, nous allons explorer différentes techniques accompagnées d’exemples de code pour démontrer chaque méthode.
Implémenter une fonction personnalisée à l’aide d’opérations XOR et AND au niveau du bit pour la comparaison de bits en C
L’opérateur AND au niveau du bit (&) est utilisé pour effectuer une comparaison bit à bit entre les bits correspondants de deux opérandes. Cette opération produit une nouvelle valeur dans laquelle chaque bit est défini si et seulement si les bits correspondants des deux opérandes sont définis.
Exemple de code :
#include <stdio.h>
int main() {
unsigned int num1 = 9; // Binary representation: 1001
unsigned int num2 = 6; // Binary representation: 0110
unsigned int result = num1 & num2;
printf("Result: %u\n", result); // Output: 0 (Binary: 0000)
return 0;
}
Sortie :
Result: 0
Dans cet exemple, num1 et num2 sont initialisés avec les valeurs 9 et 6, respectivement. Ces valeurs sont représentées en binaire par 1001 et 0110.
L’opération AND au niveau du bit entre num1 et num2 (num1 & num2) donne 0000 en binaire, soit 0 en décimal. Cela signifie qu’aucun bit correspondant n’est défini à la fois dans num1 et dans num2.
Par ailleurs, l’opérateur XOR au niveau du bit (^) est utilisé pour effectuer une comparaison bit à bit entre les bits correspondants de deux opérandes. Cette opération produit une nouvelle valeur dans laquelle chaque bit est défini si les bits correspondants dans les opérandes sont différents.
Exemple de code :
#include <stdio.h>
int main() {
unsigned int num1 = 9; // Binary representation: 1001
unsigned int num2 = 6; // Binary representation: 0110
unsigned int result = num1 ^ num2;
printf("Result: %u\n", result); // Output: 9 (Binary: 1001)
return 0;
}
Sortie :
Result: 15
Dans cet exemple, l’opération XOR au niveau du bit (num1 ^ num2) donne 1001 en binaire, soit 9 en décimal. Cela signifie que les bits correspondants dans num1 et num2 sont différents.
Généralement, la comparaison de bits implique d’accéder à des valeurs de bit unique et d’effectuer les opérations nécessaires, telles que l’implémentation d’un champ de bits en utilisant les mots-clés union et struct.
Cependant, les opérations au niveau du bit offrent une méthode plus efficace pour comparer les bits spécifiés dans les nombres. Dans ce cas, nous implémentons une fonction distincte adaptée au type u_int32_t, dont la largeur est garantie de 32 bits.
L’exemple de programme ci-dessous prend trois entiers comme arguments de ligne de commande, dont les deux premiers sont les nombres comparés, tandis que le troisième entier spécifie le n-ième bit. Notez que nous convertissons les éléments argv en utilisant strtol, perdant ainsi un peu de précision lors du stockage des valeurs de retour dans le type u_int32_t.
La fonction compareBits déclare deux variables locales stockant des valeurs intermédiaires - mask et tmp. Nous positionnons le n-ième bit dans le mask en décalant le 1 vers la gauche de nth - 1 positions.
Ensuite, les deux numéros d’entrée utilisateur sont soumis à un XOR pour obtenir les différences de bits dans chaque position, un bit défini dans le résultat indiquant des valeurs différentes. Enfin, nous devons extraire le bit de la n-ième position et vérifier si la valeur est 0.
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
bool compareBits(u_int32_t n1, u_int32_t n2, u_int32_t nth) {
u_int32_t mask, tmp;
mask = 1 << (nth - 1);
tmp = n1 ^ n2;
if ((tmp & mask) == 0)
return true;
else
return false;
}
int main(int argc, char *argv[]) {
u_int32_t num1, num2, bit;
if (argc != 4) {
fprintf(stderr, "Usage: %s integer1 integer2 nth_bit \n", argv[0]);
exit(EXIT_FAILURE);
}
num1 = strtol(argv[1], NULL, 0);
num2 = strtol(argv[2], NULL, 0);
bit = strtol(argv[3], NULL, 0);
compareBits(num1, num2, bit) ? printf("bits equal!\n")
: printf("bits not equal!\n");
exit(EXIT_SUCCESS);
}
Format du fichier d’exemple :
./main 1234 1231 1
Format du fichier d’entrée :
bits not equal!
À titre d’exemple, les entiers 1234 et 1231 sont représentés en binaire par 00000000000000000000010011010010 et 00000000000000000000010011001111, respectivement.
Ainsi, le XOR de ces deux nombres donne une représentation binaire 00000000000000000000000000011101, qui est finalement soumise à un AND avec le masque 00000000000000000000000000000010 pour extraire la valeur de position du bit unique. Si le résultat est entièrement composé de zéros, cela implique que les bits comparés sont égaux ; sinon, c’est le contraire.
Alternativement, nous pouvons toutefois raccourcir la fonction compareBits et déplacer les opérations XOR/AND dans l’instruction return, comme le montre l’exemple de code suivant. Notez que la fonction renvoie l’opposé logique des opérations XOR/AND au niveau du bit, car nous affichons les messages correspondants dans la fonction appelante à l’aide de l’instruction ternaire ? :.
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
bool compareBits(u_int32_t n1, u_int32_t n2, u_int32_t nth) {
u_int32_t mask;
mask = 1 << (nth - 1);
return !((n1 ^ n2) & mask);
}
int main(int argc, char *argv[]) {
u_int32_t num1, num2, bit;
if (argc != 4) {
fprintf(stderr, "Usage: %s integer1 integer2 nth_bit \n", argv[0]);
exit(EXIT_FAILURE);
}
num1 = strtol(argv[1], NULL, 0);
num2 = strtol(argv[2], NULL, 0);
bit = strtol(argv[3], NULL, 0);
compareBits(num1, num2, bit) ? printf("bits equal!\n")
: printf("bits not equal!\n");
exit(EXIT_SUCCESS);
}
Format du fichier d’exemple :
./main 1234 1231 2
Format du fichier d’entrée :
bits equal!
Utiliser l’opérateur OR (|) au niveau du bit pour la comparaison de bits en C
L’opérateur OR au niveau du bit (|) effectue une comparaison bit à bit entre les bits correspondants de deux opérandes. Le résultat de cette opération est une nouvelle valeur dans laquelle chaque bit est défini si au moins l’un des bits correspondants dans l’un ou l’autre des opérandes est défini.
Lorsqu’elle est appliquée à une paire de bits, l’opération OR suit cette logique :
| `0 | 0` |
| `0 | 1` |
| `1 | 0` |
| `1 | 1` |
Considérez l’exemple suivant pour illustrer l’opération OR au niveau du bit :
#include <stdio.h>
int main() {
unsigned int num1 = 9; // Binary representation: 1001
unsigned int num2 = 6; // Binary representation: 0110
unsigned int result = num1 | num2;
printf("Result: %u\n", result); // Output: 15 (Binary: 1111)
return 0;
}
Sortie :
Result: 15
Dans cet exemple, nous avons deux entiers non signés, num1 et num2 initialisés avec les valeurs 9 et 6, respectivement. Leurs représentations binaires sont 1001 et 0110.
Lorsque nous effectuons l’opération OR au niveau du bit (num1 | num2), le résultat est 1111 en binaire, soit 15 en décimal. Cela signifie qu’au moins l’un des bits correspondants dans num1 ou num2 est défini.
Utiliser l’opérateur NOT (~) au niveau du bit pour la comparaison de bits en C
L’opérateur NOT au niveau du bit (~) est un opérateur unaire, ce qui signifie qu’il opère sur un seul opérande. Lorsqu’il est appliqué à un nombre binaire, il inverse chaque bit, transformant les 0 en 1 et les 1 en 0.
Exemple de code :
#include <stdio.h>
int main() {
unsigned int num = 9; // Binary representation: 1001
unsigned int result = ~num;
printf(
"Result: %u\n",
result); // Output: 4294967286 (Binary: 11111111111111111111111111111010)
return 0;
}
Sortie :
Result: 4294967286
Dans cet exemple, nous déclarons une variable entière non signée num et l’initialisons avec la valeur 9. En binaire, cela est représenté par 1001.
Nous appliquons ensuite l’opérateur NOT au niveau du bit (~num). Cela inverse tous les bits, ce qui donne 11111111111111111111111111111010 en binaire.
Le résultat est affiché sur la console, soit 4294967286 en décimal.
NOT au niveau du bit pour comparer les bits
L’une des applications de l’opérateur NOT au niveau du bit est la comparaison de bits. En inversant les bits d’une variable, nous pouvons facilement vérifier si un bit particulier est défini ou non.
Exemple de code :
#include <stdio.h>
int main() {
unsigned int num = 9; // Binary representation: 1001
// Check if the 2nd bit is set
unsigned int mask = 1 << 1; // Shift 1 by 1 position to the left => 0002
unsigned int result = ~num & mask;
if (result == mask) {
printf("2nd bit is set.\n");
} else {
printf("2nd bit is not set.\n");
}
return 0;
}
Sortie :
2nd bit is set.
Dans cet exemple, nous voulons vérifier si le 2e bit de la variable num est défini.
Nous créons d’abord un masque en décalant le 1 de 1 position vers la gauche (1 << 1), ce qui donne 0002 en binaire. Nous appliquons ensuite l’opérateur NOT au niveau du bit à num, ce qui donne 11111111111111111111111111111010 en binaire.
Ensuite, nous effectuons une opération AND au niveau du bit entre le num inversé et le masque. Cela isole le 2e bit.
Si le résultat est égal au masque, cela signifie que le 2e bit est défini, et nous affichons un message correspondant. Sinon, nous affichons un message indiquant que le 2e bit n’est pas défini.
Conclusion
Dans cette exploration complète des opérateurs au niveau du bit en C, nous avons couvert des opérations fondamentales telles que AND, OR et NOT. Ces opérations sont inestimables pour les tâches impliquant une manipulation de données de bas niveau, telles que la compression de données, le chiffrement et la programmation de systèmes embarqués.
Plus précisément, nous nous sommes penchés sur l’utilisation de l’opérateur NOT (~) au niveau du bit pour comparer des bits individuels. En appliquant l’opérateur ~, nous pouvons facilement inverser les bits d’une variable, ce qui nous permet de vérifier si un bit particulier est défini ou non. Cette technique est essentielle dans les scénarios où une manipulation précise au niveau du bit est requise.
Comprendre et maîtriser les opérations au niveau du bit est crucial pour les programmeurs travaillant sur des tâches qui impliquent une interaction directe avec le matériel ou qui nécessitent des solutions optimisées pour des environnements aux ressources limitées. Grâce aux connaissances acquises dans cet article, vous êtes désormais en mesure d’exploiter ces outils puissants dans vos propres projets de programmation en C.