Que sont les opérateurs au niveau du bit?
Je suis quelqu'un qui écrit du code juste pour le plaisir et ne s'y est pas vraiment plongé dans un environnement académique ou professionnel, donc des choses comme ces opérateurs au niveau du bit m'échappent vraiment.
Je lisais un article sur JavaScript, qui prend apparemment en charge les opérations au niveau du bit. Je continue de voir cette opération mentionnée par endroits, et j'ai essayé de lire pour comprendre ce que c'est exactement, mais je ne semble tout simplement pas l'obtenir du tout. Alors, c'est quoi? Des exemples clairs seraient formidables! :RÉ
Encore quelques questions - quelles sont les applications pratiques des opérations au niveau du bit? Quand pourriez-vous les utiliser?
Puisque personne n'a abordé la question de savoir pourquoi elles sont utiles:
J'utilise beaucoup d'opérations au niveau du bit lorsque je travaille avec des drapeaux. Par exemple, si vous souhaitez transmettre une série d'indicateurs à une opération (par exemple, File.Open(), avec les modes Lecture et Écriture tous deux activés), vous pouvez les transmettre en tant que valeur unique. Ceci est accompli en affectant à chaque drapeau possible son propre bit dans un jeu de bits (octet, court, entier ou long). Par exemple:
Read: 00000001
Write: 00000010
Donc, si vous voulez passer en lecture ET en écriture, vous passeriez (LIRE | ÉCRIRE) qui combine ensuite les deux en
00000011
Qui peut ensuite être décrypté à l'autre bout comme:
if ((flag & Read) != 0) { //...
qui vérifie
00000011 &
00000001
qui revient
00000001
qui n'est pas 0, le drapeau spécifie donc READ.
Vous pouvez utiliser XOR pour basculer différents bits. Je l'ai utilisé lors de l'utilisation d'un indicateur pour spécifier des entrées directionnelles (Haut, Bas, Gauche, Droite). Par exemple, si un Sprite se déplace horizontalement , et je veux que ça se retourne:
Up: 00000001
Down: 00000010
Left: 00000100
Right: 00001000
Current: 00000100
J'ai simplement XOR la valeur actuelle avec (LEFT | RIGHT) qui éteindra LEFT et RIGHT ON, dans ce cas.
Le décalage de bits est utile dans plusieurs cas.
x << y
est le même que
x * 2y
si vous devez multiplier rapidement par une puissance de deux, mais faites attention au décalage d'un bit dans le bit supérieur - cela rend le nombre négatif à moins qu'il ne soit pas signé. Il est également utile lorsqu'il s'agit de différentes tailles de données. Par exemple, lire un entier de quatre octets:
int val = (A << 24) | (B << 16) | (C << 8) | D;
En supposant que A est l'octet le plus significatif et D le moins. Cela finirait comme:
A = 01000000
B = 00000101
C = 00101011
D = 11100011
val = 01000000 00000101 00101011 11100011
Les couleurs sont souvent stockées de cette façon (l'octet le plus significatif étant ignoré ou utilisé comme Alpha):
A = 255 = 11111111
R = 21 = 00010101
G = 255 = 11111111
B = 0 = 00000000
Color = 11111111 00010101 11111111 00000000
Pour retrouver les valeurs, déplacez simplement les bits vers la droite jusqu'à ce qu'ils soient en bas, puis masquez les bits restants d'ordre supérieur:
Int Alpha = Color >> 24
Int Red = Color >> 16 & 0xFF
Int Green = Color >> 8 & 0xFF
Int Blue = Color & 0xFF
0xFF est le même que 11111111. Donc, essentiellement, pour Red, vous feriez ceci:
Color >> 16 = (filled in 00000000 00000000)11111111 00010101 (removed 11111111 00000000)
00000000 00000000 11111111 00010101 &
00000000 00000000 00000000 11111111 =
00000000 00000000 00000000 00010101 (The original value)
Les opérateurs au niveau du bit sont des opérateurs qui travaillent sur un bit à la fois.
ET vaut 1 uniquement si ses deux entrées sont égales à 1.
OU vaut 1 si une ou plusieurs de ses entrées sont égales à 1.
XOR est 1 uniquement si exactement l'une de ses entrées est 1.
NOT vaut 1 uniquement si son entrée est 0.
Ceux-ci peuvent être mieux décrits comme des tables de vérité. Les possibilités d'entrées sont en haut et à gauche, le bit résultant est l'une des quatre valeurs (deux dans le cas de NOT car il n'a qu'une seule entrée) affichées à l'intersection des deux entrées.
AND|0 1 OR|0 1
---+---- ---+----
0|0 0 0|0 1
1|0 1 1|1 1
XOR|0 1 NOT|0 1
---+---- ---+---
0|0 1 |1 0
1|1 0
Un exemple est si vous ne voulez que les 4 bits inférieurs d'un entier, vous ET avec 15 (binaire 1111) donc:
203: 1100 1011
AND 15: 0000 1111
------------------
IS 11: 0000 1011
Il convient de noter que les tables de vérité à un bit répertoriées comme autres réponses ne fonctionnent que sur un ou deux bits d'entrée à la fois. Que se passe-t-il lorsque vous utilisez des entiers, tels que:
int x = 5 & 6;
La réponse réside dans l'expansion binaire de chaque entrée:
5 = 0 0 0 0 0 1 0 1
& 6 = 0 0 0 0 0 1 1 0
---------------------
0 0 0 0 0 1 0 0
Chaque paire de bits dans chaque colonne passe par la fonction "ET" pour donner le bit de sortie correspondant sur la ligne du bas. La réponse à l'expression ci-dessus est donc 4. Le processeur a effectué (dans cet exemple) 8 opérations "ET" distinctes en parallèle, une pour chaque colonne.
Je mentionne cela parce que je me souviens encore d'avoir ce "AHA!" moment où j'ai appris cela il y a de nombreuses années.
Ce sont les opérateurs au niveau du bit, tous pris en charge en JavaScript:
op1 & op2- L'opérateurANDcompare deux bits et génère un résultat de 1 si les deux bits sont à 1; sinon, il renvoie 0.op1 | op2- L'opérateurORcompare deux bits et génère un résultat de 1 si les bits sont complémentaires; sinon, il renvoie 0.op1 ^ op2- L'opérateurEXCLUSIVE-ORCompare deux bits et renvoie 1 si l'un des bits vaut 1 et donne 0 si les deux bits sont 0 ou 1.~op1- L'opérateurCOMPLEMENTest utilisé pour inverser tous les bits de l'opérande.op1 << op2- L'opérateurSHIFT LEFTDéplace les bits vers la gauche, rejette le bit le plus à gauche et attribue au bit le plus à droite une valeur de 0. Chaque déplacement vers la gauche multiplie effectivement op1 par 2.op1 >> op2- L'opérateurSHIFT RIGHTDéplace les bits vers la droite, rejette le bit le plus à droite et attribue au bit le plus à gauche une valeur de 0. Chaque déplacement vers la droite divise effectivement op1 en deux. Le bit de signe le plus à gauche est conservé.op1 >>> op2- L'opérateurSHIFT RIGHT-ZERO FILLDéplace les bits vers la droite, supprime le bit le plus à droite et attribue au bit le plus à gauche une valeur de 0. Chaque déplacement vers le droite divise effectivement op1 en deux. Le bit de signe le plus à gauche est ignoré.
Lorsque le terme "au niveau du bit" est mentionné, il est parfois clair qu'il ne s'agit pas d'un opérateur "logique".
Par exemple en JavaScript, les opérateurs au niveau du bit traitent leurs opérandes comme une séquence de 32 bits (zéros et uns) ; en attendant, les opérateurs logiques sont généralement utilisés avec des valeurs booléennes (logiques) mais peuvent fonctionner avec des types non booléens.
Prenons par exemple expr1 && expr2.
Renvoie expr1 s'il peut être converti en faux; sinon, renvoie expr2. Ainsi, lorsqu'il est utilisé avec des valeurs booléennes, && renvoie true si les deux opérandes sont vrais; sinon, renvoie false.
a = "Cat" && "Dog" // t && t returns Dog
a = 2 && 4 // t && t returns 4
Comme d'autres l'ont noté, 2 et 4 est un ET au niveau du bit, il retournera donc 0.
Vous pouvez copier ce qui suit dans test.html ou quelque chose et tester:
<html>
<body>
<script>
alert("\"Cat\" && \"Dog\" = " + ("Cat" && "Dog") + "\n"
+ "2 && 4 = " + (2 && 4) + "\n"
+ "2 & 4 = " + (2 & 4));
</script>
Pour le décomposer un peu plus, cela a beaucoup à voir avec la représentation binaire de la valeur en question.
Par exemple (en décimal): X = 8 Y = 1 Sortirait à (en binaire): x = 1000 y = 0001 À partir de là, vous pouvez effectuer des opérations de calcul telles que "et" ou "ou"; dans ce cas: x | y = 1000 0001 | ------ 1001 ou ... 9 en décimal
J'espère que cela t'aides.
Dans la programmation informatique numérique, une opération au niveau du bit fonctionne sur un ou plusieurs motifs de bits ou chiffres binaires au niveau de leurs bits individuels. Il s'agit d'une action rapide et primitive directement prise en charge par le processeur et utilisée pour manipuler des valeurs pour des comparaisons et des calculs.
opérations:
bit à bit ET
oU au niveau du bit
pas au niveau du bit
xOR au niveau du bit
etc
Élément de liste
AND|0 1 OR|0 1
---+---- ---+----
0|0 0 0|0 1
1|0 1 1|1 1
XOR|0 1 NOT|0 1
---+---- ---+---
0|0 1 |1 0
1|1 0
Par exemple.
203: 1100 1011
AND 15: 0000 1111
------------------
= 11: 0000 1011
tilise l'opérateur au niveau du bit
- Les opérateurs de décalage à gauche et à droite sont équivalents à la multiplication et à la division par x * 2y respectivement.
Par exemple.
int main()
{
int x = 19;
printf ("x << 1 = %d\n" , x <<1);
printf ("x >> 1 = %d\n", x >>1);
return 0;
}
// Output: 38 9
- L'opérateur & peut être utilisé pour vérifier rapidement si un nombre est pair ou impair
Par exemple.
int main()
{
int x = 19;
(x & 1)? printf("Odd"): printf("Even");
return 0;
}
// Output: Odd
- Recherche rapide minimum de x et y sans
if elsedéclaration
Par exemple.
int min(int x, int y)
{
return y ^ ((x ^ y) & - (x < y))
}
- Conversion décimale en binaire
Par exemple.
#include <stdio.h>
int main ()
{
int n , c , k ;
printf("Enter an integer in decimal number system\n " ) ;
scanf( "%d" , & n );
printf("%d in binary number
system is: \n " , n ) ;
for ( c = 31; c >= 0 ; c -- )
{
k = n >> c ;
if ( k & 1 )
printf("1" ) ;
else
printf("0" ) ;
}
printf(" \n " );
return 0 ;
}
- Le cryptage de la porte XOR est une technique populaire, en raison de sa complixblité et de sa réutilisation par le programmeur.
- bitwise XOR operator est l'opérateur le plus utile du point de vue de l'entretien technique.
le décalage au niveau du bit ne fonctionne qu'avec le nombre + ve
Il existe également un large éventail d'utilisation de la logique au niveau du bit
Il pourrait être utile d’y penser de cette façon. Voici comment fonctionne AND (&):
Il dit essentiellement que ce sont tous les deux des nombres, donc si vous avez deux nombres 5 et 3, ils seront convertis en binaire et l'ordinateur pensera
5: 00000101
3: 00000011
sont tous les deux un: 00000001 0 est faux, 1 est vrai
Donc le ET de 5 et 3 est un. L'opérateur OR (|) fait la même chose sauf qu'un seul des nombres doit être un pour sortir 1, pas les deux.