Quels sont les opérateurs de bits ?

Question

Je suis quelqu'un qui écrit le code juste pour le plaisir et n'a pas vraiment penché sur qu'il soit académique ou professionnel, donc des trucs comme ces opérateurs au niveau du bit vraiment m'échappe. J'ai lu un article à propos de JavaScript, qui apparemment prend en charge les opérations bit à bit. Je continue à voir cette opération mentionnée dans les lieux et j'ai essayé de lire sur de comprendre ce que c'est exactement, mais je ne semblent tout simplement pas l'obtenir. Alors quels sont-ils? Des exemples clairs serait génial! :D

Edit: Juste un peu plus de questions - quelles sont les applications pratiques des opérations bit à bit? Quand pouvez-vous les utiliser?

Answer 1

Puisque personne n'a abordé le sujet de pourquoi ils sont utiles:

J'utilise des opérations bit à bit d'un lot lorsque l'on travaille avec des drapeaux. Par exemple, si vous voulez passer une série d'indicateurs pour une opération (par exemple, Fichier.Ouvrir, avec le mode de Lecture et le mode d'Écriture à la fois activée), vous pourriez passer comme une valeur unique. Ceci est accompli par l'affectation de chaque indicateur, il est peu propre à un bitset (byte, short, int ou long). Par exemple:

 Read: 00000001
Write: 00000010

Donc, si vous voulez passer à lire ET à écrire, vous devez passer (LECTURE | ÉCRITURE) qui combine les deux en

00000011

Qui peut alors être déchiffré à l'autre extrémité comme:

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

qui vérifie

00000011 &
00000001

qui renvoie

00000001

ce qui n'est pas 0, de sorte que le drapeau ne spécifiez LIRE.

Vous pouvez utiliser XOR pour alterner différents bits. J'ai utilisé ce lors de l'utilisation d'un indicateur pour préciser directionnelle entrées (Haut, Bas, Gauche, Droite). Par exemple, si un sprite se déplace horizontalement, et je veux qu'il à tourner autour de:

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

J'ai simplement XOR la valeur actuelle (GAUCHE | DROITE) qui va tourner à GAUCHE et à DROITE, dans ce cas.

Le Décalage de bits est utile dans plusieurs cas.

x << y

est le même que

x * 2^y

si vous avez besoin rapidement de la multiplier par une puissance de deux, mais regarder dehors pour le décalage de 1 bit vers le haut peu - cela rend le numéro de négatif, sauf si c'est non signé. Il est également utile lorsque vous traitez avec différentes tailles de données. Par exemple, la lecture d'un nombre 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. Ça finirait comme:

A = 01000000
B = 00000101
C = 00101011
D = 11100011
val = 01000000 00000101 00101011 11100011

Les couleurs sont souvent stockées de cette manière (avec l'octet le plus significatif soit ignoré, soit utilisé comme Alpha):

A = 255 = 11111111
R = 21 = 00010101
G = 255 = 11111111
B = 0 = 00000000
Color = 11111111 00010101 11111111 00000000

Pour trouver les valeurs de nouveau, juste décale les bits vers la droite jusqu'en bas, puis masque le restant d'ordre supérieur bits:

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 le Rouge, vous être en train de faire 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)

Answer 2

Il est intéressant de noter que le seul bit de la table de vérité répertoriés comme d'autres réponses de travail sur seulement un ou deux bits d'entrée à la fois. Ce qui se passe lorsque vous utilisez des nombres entiers, tels que:

int x = 5 & 6;

La réponse se trouve dans le binaire de l'expansion 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 est exécuté par le biais de la fonction "ET" pour donner le correspondant de bits de sortie sur la ligne de fond. Donc la réponse à l'expression ci-dessus est de 4. La CPU a fait (dans cet exemple) 8 distinct "ET" opérations en parallèle, un pour chaque colonne.

Je mentionne cela parce que je me souviens encore avoir cette "AHA!" moment quand je l'ai appris il y a plusieurs années.

Answer 3

Au niveau du bit les opérateurs sont des opérateurs qui travaillent sur un bit à la fois.

ET est 1 seulement si les deux entrées sont à 1.

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

XOR est de 1 seulement si exactement l'une de ses entrées sont à 1.

PAS est de 1 seulement si ses entrées sont à 0.

Ceux-ci peuvent être mieux décrits comme des tables de vérité. Entrées possibilités sont sur le haut et la gauche, la résultante de bits est l'un des quatre (deux dans le cas de ne PAS car il ne comporte qu'une entrée), les valeurs 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 voulez seulement le bas 4 bits d'un entier, vous ET avec 15 (binaire 1111) donc:

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

Answer 4

Ce sont les opérateurs au niveau du bit, le tout soutenu en JavaScript:

• op1 et op2 -- L'opérateur ET compare les deux bits et génère un résultat de 1 si les deux bits sont à 1; sinon, elle renvoie 0.

• op1 | op2 -- L'opérateur OU la comparaison de deux bits et génère un résultat de 1 si les bits sont complémentaires; sinon, elle renvoie 0.

• op1^ op2 -- L'opérateur OU EXCLUSIF compare deux bits et retourne 1 si les deux bits sont à 1, et qu'elle donne 0 si les deux bits sont à 0 ou 1.

• ~op1) -- L'opérateur de COMPLÉMENT qui est utilisé pour inverser tous les bits de l'opérande.

• op1 << op2 --, Le passage à GAUCHE de l'opérateur déplace les bits vers la gauche, les rejets de l'extrême-gauche bits, et affecte le plus à droite des bits d'une valeur de 0. Chacun se déplacer vers la gauche multiplie op1 par 2.

• op1 >> op2 -- Le DÉCALAGE à DROITE de l'opérateur déplace les bits vers la droite, les rejets de l'extrême-droite bits, et attribue le plus à gauche des bits d'une valeur de 0. Chacun se déplacer vers la droite permet de diviser op1 dans la moitié. Le plus à gauche le bit de signe est préservé.

• op1 >>> op2 -- Le DÉCALAGE à DROITE - ZÉRO de REMPLISSAGE opérateur déplace les bits vers la droite, les rejets de l'extrême-droite bits, et attribue le plus à gauche des bits d'une valeur de 0. Chacun se déplacer vers la droite permet de diviser op1 dans la moitié. Le plus à gauche le bit de signe est ignoré.

Answer 5

Pour décomposer un peu plus, il 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 a partir de là, vous pouvez faire des opérations de calculs tel que « et » ou « ou » ; dans ce cas : x | y = 1000 0001 | --- 1001 ou... 9 en décimal 

J’espère que cela aide.