Opérateurs du bit en C

Dans ce Indice de linux Article, tout sur les opérations logiques bitwise est expliquée. En utilisant un exemple pratique avec des fragments de code d'image, nous verrons en détail chacun des opérateurs logiques utilisés dans la langue C.

De plus, nous expliquerons comment effectuer un masquage de bits avec des opérations logiques, car c'est quelque chose de très utile dans la programmation et est complètement lié à ce type d'opérateurs.

Description des opérations bit

Les opérations sont bidireuses et les opérations de décalage sont appliquées individuellement à chaque bit d'une variable. Par exemple, si nous appliquons l'opération et entre les variables «A» et «B», le bit 0 de «A» sera lié au bit 0 de «B», le bit 1 de «A» sera lié au bit 1 de "B" ", et ainsi de suite.

Chaque bit fonctionne et renvoie son propre résultat et n'a aucune influence sur le résultat des bits adjacents.

Ce type d'opération est très utile dans les bits de masquage lors de l'utilisation de drapeaux de contrôle ou d'indicateurs regroupés en un seul élément de données tel qu'un entier.

Comment attribuer une valeur binaire à une variable dans la langue C

Avant de commencer à expliquer quelles sont les opérations logiques bit beaucoup plus pratique et compréhensible. Par exemple, dans les cas où les bits représentent des drapeaux ou des indicateurs de contrôle regroupés en une variable int, double ou autre.

Pour attribuer une valeur à une variable au format binaire, nous devons préfixer la représentation binaire avec «0b». L'extrait suivant attribue la valeur 131 ou 0b10000011 à l'integer «A» au format binaire, puis affiche sa représentation décimale dans la console de commande.

#inclure
void main ()
int a;
a = 0b10000011;
printf ("La représentation décimale de 0b10000011 est:% i \ n", a);

L'image ci-dessous montre le résultat de ce code.

Représenter les valeurs binaires dans les opérations de masquage et le masquage rend la programmation beaucoup plus fluide et compréhensible et évite les erreurs ou les conversions qui coûtent du temps.

Pas opérateur

L'opérateur logique pour le non est le symbole «~».

L'opération logique non ou négation est la plus simple de toutes, n'ayant qu'une seule entrée et une sortie.

Cette opération renvoie dans sa sortie la valeur binaire inversée de son entrée.

Considérez l'expression suivante pour l'opération logique et non avec l'entrée «A»

c = ~ a

Le résultat en «C» est égal à 1 si «a» est égal à 0 et «C» est égal à 0 si «a» est égal à 1. Cette opération est couramment utilisée pour obtenir la valeur complémentaire d'une variable.

Ensuite, regardons la table de vérité pour l'opération non.

un	~	=	c
0	~	=	1
1	~	=	0

Exemple:

Dans cet exemple, nous appliquerons l'opération non pas à la variable A pour obtenir son complément en «C»

Pour ce faire, nous créons la variable A de type de type non signé, attribuez-lui la valeur 131 et obtenons le résultat en «C». Nous utilisons ensuite la fonction printf () pour afficher le résultat dans la console de commande. Ci-dessous, nous pouvons voir le code à cet effet.

#inclure
vide main ()

Char non signé C;
Char non signé A;
a = 0B01111100;
c = ~ a;
printf («\ nthe décimal Représentation pour 0b10000011 est:% i \ n», c);

Dans la figure ci-dessous, nous voyons le résultat du complément de «A» . Dans ce cas, le complément ou l'inverse de 131 est de 124 ou 01111100 en représentation binaire.

Logique et opérateur

L'opérateur logique pour l'opération est le symbole «&»

Examinons l'expression suivante pour la logique et le fonctionnement entre les variables A et B

c = a & b.

Le résultat en «C» est égal à 1 uniquement si «A» et «B» sont égaux à 1. Dans tous les autres cas, «C» est égal à 0.

Ensuite, nous regardons la table de vérité pour l'opération et.

UN	&	b	=	c
0	&	0	=	0
0	&	1	=	0
1	&	0	=	0
1	&	1	=	1

Le fonctionnement logique et est très utile dans le masquage des bits. Plus tard, nous verrons une section expliquant cette technique plus en détail.

Exemple:

Maintenant, voyons un exemple où nous effectuons la logique et le fonctionnement entre les variables «A» et «B» de type non signé et stockent le résultat en «C» pour l'afficher plus tard dans la console de commande.

Nous attribuons la valeur 135 ou 10000111 à la variable «A» et 129 ou 1000001 à la variable «B» en représentation binaire. Ensuite, nous utiliserons l'opérateur «&» 'pour effectuer l'opération. Ensuite, nous verrons le code pour cela.

#inclure
vide main ()

Char non signé A = 0B10000111;
Char non signé B = 0B10000001;
Char non signé C;
c = a & b;
printf ("\ n le résultat de A&B est:% i \ n", c);

L'image montre le résultat de ce code où l'opération et l'opération entre «A» et «B» en résulte 129 ou 10000001 en binaire.

Logique ou opérateur

L'opérateur logique de l'opération OR est le symbole »| ".

Examinons l'expression suivante pour la logique ou le fonctionnement entre les variables A et B

C = à | b.

Le résultat en «C» ne sera égal 1 que si «a» ou «b» ou «a» et «b» égal 1, alors qu'il ne sera égal à 0 que si «a» et «b» égal à 0 0.

Ensuite, regardons la table de vérité pour l'opération ou.

pour	|	b	=	c
0	|	0	=	0
0	|	1	=	1
1	|	0	=	1
1	|	1	=	1

Exemple

Dans cet exemple, nous verrons comment effectuer le fonctionnement logique ou entre les variables «a» et «b» de type non signé et stocker le résultat en «C» pour l'afficher plus tard dans la console de commande.

Nous attribuons la valeur 128 ou 10000000 à la variable «A» et 3 ou 00000011 à la variable «B» en représentation binaire. Ensuite, nous utiliserons l'opérateur «|» pour effectuer l'opération. Ensuite, nous verrons le code de cette opération.

#inclure
vide main ()

Char non signé A = 0B10000000;
Char non signé B = 0B00000011;
Char non signé C;
C = à | B;
printf ("\ n le résultat de a | b est:% i \ n", c);

Dans l'image ci-dessous, nous voyons le résultat de l'opération C = A | B qui, dans ce cas, est 131 ou 10000011 en binaire.

Opérateur logique xor ou exclusif ou

L'opérateur logique de l'opération XOR est le symbole »^«.

Examinons l'expression suivante pour l'opération XOR logique entre les variables A et B

c = a ^ b.

Le résultat en «C» est égal à 1 uniquement si l'un des bits «A» ou «B» est égal à 1, mais il est 0 si «A» et «B» sont tous deux égaux à 1 ou égal à 0.

Cette opération est essentielle chez les additionnelles car dans le système binaire 1 + 0 = 1 ou 0 + 1 est également égal à 1. Mais 1 + 1 = 0 avec le transport vers le bit supérieur suivant. Dans ce cas, le portage est effectué par l'opération et.

Ensuite, nous regardons la table de vérité pour l'opération XOR.

un	^	b	=	c
0	^	0	=	0
0	^	1	=	1
1	^	0	=	1
1	^	1	=	0

Exemple

Maintenant, regardons un exemple où nous effectuons le fonctionnement logique XOR entre les variables «a» et «b» de type non signé et stockent le résultat en «C» pour l'afficher plus tard dans la console de commande.

Nous attribuons la valeur 135 ou 10000111 à la variable «A» et 3 ou 00000011 à la variable «B» en notation binaire. Ensuite, nous utiliserons l'opérateur «^» pour effectuer l'opération logique. Ensuite, nous verrons le code pour cela.

#inclure
vide main ()

Char non signé A = 0B10000111;
Char non signé B = 0B00000011;
Char non signé C;
c = a ^ b;
printf ("\ n le résultat de a | b est:% i \ n", c);

Comme nous pouvons le voir dans l'image, le résultat est 10000100 et les bits dont les deux entrées sont = 1 xOR Résultats en 0.

Opérateurs avec mission

Les opérateurs avec affectation effectuent les mêmes opérations logiques que nous avons vues auparavant, mais leur résultat est stocké dans l'opérande qui précède à l'opérateur.

L'expression suivante effectue la logique et le fonctionnement entre la variable «A» et la variable ou la valeur attribuée après l'opérateur et le résultat est renvoyé en «A».

a & = 55;

Opérateurs de rotation

Les opérateurs de rotation sont «< > ".

Ces opérateurs déplacent les données d'une variable par des bits «n» vers la gauche ou la droite, respectivement.

Dans l'expression suivante, l'opérateur déplace les données stockées en «A» 5 bits à gauche.

a = a < < 5

Exemple

Dans cet exemple, nous attribuerons la valeur 0B000001 à la variable «A», puis déplacerons 1 bit à gauche dans A pour une boucle et sortir la valeur résultante dans la console de commande. Ce cycle est répété 8 fois

#inclure
vide main ()

Char non signé A = 0B00000001;
Char non signé C;
pour (int bit = 0; bit!= 8; bit ++)
printf ("% i \ n", a);
a = a<<1;

Dans l'image suivante, nous voyons le résultat avec les valeurs décimales correspondant à chaque position des bits dans un caractère non signé.

Masquage

Dans certains cas, comme lorsque nous définissons plusieurs indicateurs de contrôle regroupés dans un seul registre, nous avons seulement besoin de connaître ou de modifier la valeur d'un ou plusieurs bits, pas le registre entier.

Pour obtenir le statut d'un ou plusieurs bits spécifiques, nous devons définir un masque qui ne définit que les bits des éléments dont nous voulons connaître la valeur et appliquer l'opération et.

Par exemple, si nous voulons obtenir la valeur des bits 0 et 2 de la variable «A», nous devons définir le masque suivant et effectuer l'opération et l'opération.

00000101

Dans ce cas, seul le statut des bits 0 et 2 sera renvoyé en conséquence, les bits restants auront la valeur = 0, quelle que soit la valeur qu'ils ont «A».

Pour modifier la valeur, nous devons appliquer l'OR ou un fonctionnement entre le masque avec les bits que nous voulons définir sur 1 et la variable que nous voulons modifier. Si nous voulons le régler sur 0, nous devons inverser le masque comme indiqué ci-dessous et appliquer l'opération.

11111010

Exemple

Dans cet exemple, nous utilisons le masquage de bits pour créer un convertisseur simple et pratique des nombres décimaux à une chaîne avec sa représentation binaire.

Pour cette conversation, nous utiliserons 8 masques, un pour chaque bit, mais pour rendre la programmation plus pratique et plus claire, nous utiliserons d'abord le masque 10000000, puis nous déplacerons à droite dans chaque cycle de la boucle. De cette façon, nous obtiendrons les 8 masques suivants dont nous avons besoin.

10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001

Le convertisseur se compose d'une boucle pour 8 cycles, dans chacun desquelles, il interroge l'état du bit correspondant. Ceci est fait par A et l'opération entre les données à convertir et le masque correspondant.

Si le résultat de l'opération en «C» est 0, émettez cette valeur avec la fonction printf (). Sinon, si la valeur du bit est 1, elle sera imprimée dans la console de commande.

Vous trouverez ci-dessous le code de ce convertisseur pratique.

#inclure
void main ()
Char non signé A = 143;
Char non signé B = 0B10000000;
Char non signé C;
printf ("\ n la représentation binaire de A est:");
pour (int bit = 0; bit!= 8; bit ++)
c = a & b;
if (c == 0)
printf ("0");
autre
printf ("1");
b = b >> 1;
c = 0;

printf ("\ n \ n");

Dans l'image suivante, nous voyons ci-dessous le résultat de la conversion pour le numéro 143.

Conclusion

Dans ce Indice de linux Article, nous avons expliqué chacun des opérateurs logiques et de rotation que le langage C fournit pour le traitement bit. Pour chacun de ces opérateurs, nous avons créé une section montrant le symbole utilisé pour cette description de l'opérateur et un exemple pratique avec des extraits de code et des images pour chaque. Nous avons également inclus une section traitant du masquage des bits et ce qui est un ajout, qui est entièrement lié aux opérations logiques de ce type.