Que sont les opérateurs au niveau du bit ?

StackOverflow https://stackoverflow.com/questions/276706

Question

Je suis quelqu'un qui écrit du code juste pour le plaisir et qui ne s'y est pas vraiment plongé dans un cadre académique ou professionnel, donc des trucs 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 à certains endroits, et j'ai essayé de lire pour comprendre de quoi il s'agit exactement, mais je ne semble tout simplement pas comprendre du tout.Alors, quels sont-ils ?Des exemples clairs seraient formidables !:D

Encore quelques questions : quelles sont les applications pratiques des opérations au niveau du bit ?Quand pourriez-vous les utiliser ?

Était-ce utile?

La solution

Puisque personne n’a abordé le sujet de leur utilité :

J'utilise beaucoup les 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 sous la forme d'une valeur unique.Ceci est accompli en attribuant à chaque indicateur 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 la lecture ET l'écriture, vous passerez (READ | WRITE) qui combine ensuite les deux en 

00000011

Qui peut ensuite être déchiffré à l’autre bout comme :

if ((flag & Read) != 0) { //...

qui vérifie

00000011 &
00000001

qui renvoie

00000001

qui n'est pas 0, donc l'indicateur spécifie READ.

Vous pouvez utiliser XOR pour basculer entre différents bits.Je l'ai utilisé lors de l'utilisation d'un drapeau pour spécifier des entrées directionnelles (Haut, Bas, Gauche, Droite).Par exemple, si un sprite se déplace horizontalement et que je souhaite qu'il se retourne :

     Up: 00000001
   Down: 00000010
   Left: 00000100
  Right: 00001000
Current: 00000100

Je XOR simplement la valeur actuelle avec (LEFT | RIGHT), ce qui désactivera GAUCHE et DROITE, dans ce cas.

Le Bit Shifting est utile dans plusieurs cas.

x << y

est le même que

x * 2oui

si vous avez besoin de multiplier rapidement par une puissance de deux, mais faites attention au déplacement d'un bit de 1 vers le bit supérieur - cela rend le nombre négatif à moins qu'il ne soit non signé.C’est également utile lorsqu’il s’agit de données de différentes tailles.Par exemple, lire un entier sur quatre octets :

int val = (A << 24) | (B << 16) | (C << 8) | D;

En supposant que A est l'octet de poids fort et D le plus faible.Cela finirait par :

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 de poids fort étant soit ignoré, soit 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 d'ordre supérieur restants :

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)

Autres conseils

Il convient de noter que les tables de vérité à un bit répertoriées comme les 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 le développement 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 de chaque colonne est exécutée à travers le & "; AND &"; fonction pour donner le bit de sortie correspondant sur la dernière ligne. Donc, la réponse à l'expression ci-dessus est 4. La CPU a fait (dans cet exemple) 8 séparer & Quot; ET & Quot; opérations en parallèle, une pour chaque colonne.

Je mentionne cela parce que je me souviens encore de cela & "AHA! &"; moment où j’en ai entendu parler il ya plusieurs années.

Les opérateurs au niveau du bit sont des opérateurs qui travaillent un à un.

AND n’est égal à 1 que si ses deux entrées sont 1.

OU est 1 si une ou plusieurs de ses entrées sont 1.

XOR n’est égal à 1 que si exactement une de ses entrées est 1.

NOT est égal à 1 uniquement si son entrée est 0.

Celles-ci peuvent être décrites comme des tables de vérité. Les possibilités d’entrée 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 entrée) indiqué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: si vous ne voulez que les 4 bits inférieurs d’un entier, vous l’utilisez ET 15 (binaire 1111), donc: 

    203: 1100 1011
AND  15: 0000 1111
------------------
 IS  11: 0000 1011

Ce sont les opérateurs au niveau du bit, tous supportés en JavaScript:

  • op1 & op2 - L'opérateur AND compare deux bits et génère un résultat égal à 1 si les deux bits sont à 1; sinon, il retourne 0.

  • op1 | op2 - L’opérateur OR compare deux bits et génère un résultat égal à 1 si les bits sont complémentaires; sinon, il retourne 0.

  • op1 ^ op2 - L'opérateur EXCLUSIVE-OR compare deux bits et renvoie 1 si l'un des bits est égal à 1 et renvoie 0 si les deux bits valent 0 ou 1.

  • ~op1 - L'opérateur COMPLEMENT est utilisé pour inverser tous les bits de l'opérande.

  • op1 << op2 - L'opérateur SHIFT LEFT déplace les bits vers la gauche, supprime le bit le plus à gauche et attribue la valeur 0 au bit le plus à droite. Chaque déplacement vers la gauche multiplie effectivement op1 par 2.

  • op1 >> op2 - L'opérateur SHIFT RIGHT déplace les bits vers la droite, supprime le bit tout à droite et attribue la valeur 0 au bit le plus à gauche. Chaque déplacement à droite divise effectivement op1 en deux. Le bit de signe le plus à gauche est conservé.

  • op1 >>> op2 - L'opérateur ZERO FILL - <=> déplace les bits vers la droite, supprime le bit d'extrême droite et attribue la valeur 0 au bit le plus à gauche. Chaque mouvement vers la droite divise effectivement op1 en deux. Le bit de signe le plus à gauche est supprimé.

Pour être un peu plus détaillé, cela a beaucoup à voir avec la représentation binaire de la valeur en question. 

For example (in decimal):
x = 8
y = 1

would come out to (in binary):
x = 1000
y = 0001

From there, you can do computational operations such as 'and' or 'or'; in this case:
x | y = 
1000 
0001 |
------
1001

or...9 in decimal

J'espère que ça aide.

Lorsque le terme " bitwise " est mentionné, il est parfois clair que ce n’est pas un & "Logique &"; opérateur.

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) ; Pendant ce temps, les opérateurs logiques sont généralement utilisés avec des valeurs booléennes (logiques) , mais peut travailler avec des types non booléens.

Prenez expr1 & amp; & amp; expr2 par exemple.

  

Retourne expr1 s'il peut être converti   à faux; sinon, renvoie expr2.   Ainsi, lorsqu'il est utilisé avec des valeurs booléennes,   & amp; & amp; renvoie vrai si les deux opérandes sont   vrai; sinon, renvoie false. 

a = "Cat" && "Dog"     // t && t returns Dog
a = 2 && 4     // t && t returns 4

Comme d'autres l'ont noté, 2 & amp; 4 est un bitwise AND, 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>
  

Dans la programmation informatique numérique, une opération au niveau des bits opère sur un ou plusieurs modèles de bits ou des nombres binaires au niveau de leurs bits individuels. Il s’agit d’une action rapide et primitive directement prise en charge par le processeur. Elle permet de manipuler les valeurs à des fins de comparaison et de calcul.

opérations :

  • ET au niveau du bit

  • OU au niveau du bit

  • PAS au niveau du bit

  • bit XOR

  • 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

Utilisations de l'opérateur binaire

  • Les opérateurs de décalage gauche et droit sont équivalents à la multiplication et à la division par x * 2 y , 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
  • Le & amp; 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
  • minimum de recherche rapide de x et y sans if else déclaration

Par exemple 

int min(int x, int y)
{
    return y ^ ((x ^ y) & - (x < y))
}
  • Décimal en binaire conversion

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 complexité et de son utilisation par le programmeur.
    • L'opérateur XOR au niveau du bit est l'opérateur le plus utile du point de vue de l'entrevue technique.

le décalage au niveau du bit fonctionne uniquement avec le numéro + ve

Il existe également un large éventail d'applications de la logique au niveau du bit

Cela pourrait aider de penser de cette façon. Voici comment AND (& Amp;) fonctionne:

En gros, il est indiqué que ces deux nombres sont identiques, ainsi, si vous avez deux nombres 5 et 3, ils seront convertis en binaires et l'ordinateur réfléchira

. 
         5: 00000101
         3: 00000011

sont 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 générer 1, pas les deux.

Je ne cessais d’entendre parler de la lenteur des opérateurs de bits JavaScript. J'ai effectué des tests pour mon dernier article de blog et a été trouvé. ils étaient 40 à 80% plus rapides que l’alternative arithmétique dans plusieurs tests. Ils ont peut-être l'habitude d'être lent. Dans les navigateurs modernes, je les aime.

J'ai un cas dans mon code qui sera plus rapide et plus facile à lire pour cette raison. Je vais garder les yeux ouverts pour plus d'informations.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top