¿Qué son los operadores bit a bit?

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

Pregunta

Soy alguien que escribe código solo por diversión y realmente no he profundizado en él, ya sea en un entorno académico o profesional, así que cosas como estos operadores bit a bit realmente se me escapan.

Estaba leyendo un artículo sobre JavaScript, que aparentemente admite operaciones bit a bit. Sigo viendo esta operación mencionada en algunos lugares, y he intentado leer para averiguar qué es exactamente, pero parece que no lo entiendo en absoluto. Entonces, ¿qué son? ¡Ejemplos claros serían geniales! : D

Solo unas pocas preguntas más: ¿cuáles son algunas aplicaciones prácticas de operaciones bit a bit? ¿Cuándo podrías usarlos?

¿Fue útil?

Solución

Dado que nadie ha abordado el tema de por qué son útiles:

Utilizo mucho las operaciones bit a bit cuando trabajo con banderas. Por ejemplo, si desea pasar una serie de indicadores a una operación (por ejemplo, File.Open(), con el modo de lectura y el modo de escritura habilitados), puede pasarlos como un solo valor. Esto se logra asignando a cada posible indicador su propio bit en un conjunto de bits (byte, short, int o long). Por ejemplo: 

 Read: 00000001
Write: 00000010

Entonces, si desea pasar lectura Y escritura, pasaría (LEER | ESCRIBIR) que luego combina los dos en 

00000011

Que luego se puede descifrar en el otro extremo como: 

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

que verifica 

00000011 &
00000001

que devuelve 

00000001

que no es 0, por lo que el indicador especifica READ.

Puede usar XOR para alternar varios bits. Lo he usado cuando uso una bandera para especificar entradas direccionales (Arriba, Abajo, Izquierda, Derecha). Por ejemplo, si un sprite se mueve horizontalmente y quiero que gire: 

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

Simplemente XORO el valor actual con (IZQUIERDA | DERECHA) que apagará IZQUIERDA y DERECHA, en este caso.

Bit Shifting es útil en varios casos. 

x << y

es lo mismo que

  

x * 2 y

si necesita multiplicar rápidamente por una potencia de dos, pero tenga cuidado con el cambio de 1 bit al bit superior; esto hace que el número sea negativo a menos que no esté firmado. También es útil cuando se trata con diferentes tamaños de datos. Por ejemplo, leer un número entero de cuatro bytes: 

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

Suponiendo que A es el byte más significativo y D el menor. Terminaría como: 

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

Los colores a menudo se almacenan de esta manera (con el byte más significativo ignorado o utilizado como Alfa): 

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

Para encontrar los valores nuevamente, simplemente mueva los bits hacia la derecha hasta que esté en la parte inferior, luego oculte los bits restantes de orden superior: 

Int Alpha = Color >> 24
Int Red = Color >> 16 & 0xFF
Int Green = Color >> 8 & 0xFF
Int Blue = Color & 0xFF

0xFF es lo mismo que 11111111. Entonces, esencialmente, para Red, estaría haciendo esto: 

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)

Otros consejos

Vale la pena señalar que las tablas de verdad de un solo bit enumeradas como otras respuestas funcionan en uno o dos bits de entrada a la vez. Qué sucede cuando usa números enteros, como: 

int x = 5 & 6;

La respuesta está en la expansión binaria de cada entrada: 

  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

Cada par de bits en cada columna se ejecuta a través de & "; Y &"; función para dar el bit de salida correspondiente en la línea inferior. Entonces, la respuesta a la expresión anterior es 4. La CPU ha hecho (en este ejemplo) 8 & Quot; AND & Quot; operaciones en paralelo, una para cada columna.

Menciono esto porque todavía recuerdo haber tenido este " AHA! " momento en que me enteré de esto hace muchos años.

Los operadores bit a bit son operadores que trabajan en un bit a la vez.

AND es 1 solo si sus dos entradas son 1.

OR es 1 si una o más de sus entradas son 1.

XOR es 1 solo si exactamente una de sus entradas es 1.

NOT es 1 solo si su entrada es 0.

Estos pueden describirse mejor como tablas de verdad. Las posibilidades de entrada están en la parte superior e izquierda, el bit resultante es uno de los cuatro valores (dos en el caso de NOT ya que solo tiene una entrada) que se muestran en la intersección de las dos entradas. 

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 ejemplo es si solo desea los 4 bits más bajos de un entero, y Y con 15 (binario 1111), entonces: 

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

Estos son los operadores bit a bit, todos compatibles con JavaScript:

  • op1 & op2 - El operador AND compara dos bits y genera un resultado de 1 si ambos bits son 1; de lo contrario, devuelve 0.

  • op1 | op2 - El operador OR compara dos bits y genera un resultado de 1 si los bits son complementarios; de lo contrario, devuelve 0.

  • op1 ^ op2 - El operador EXCLUSIVE-OR compara dos bits y devuelve 1 si alguno de los bits es 1 y da 0 si ambos bits son 0 o 1.

  • ~op1 - El operador COMPLEMENT se usa para invertir todos los bits del operando.

  • op1 << op2 - El operador SHIFT LEFT mueve los bits hacia la izquierda, descarta el bit más a la izquierda y asigna al bit más a la derecha un valor de 0. Cada movimiento a la izquierda multiplica efectivamente op1 por 2.

  • op1 >> op2 - El operador SHIFT RIGHT mueve los bits hacia la derecha, descarta el bit más a la derecha y asigna al bit más a la izquierda un valor de 0. Cada movimiento hacia la derecha divide efectivamente a op1 por la mitad. El bit de signo más a la izquierda se conserva.

  • op1 >>> op2 - El operador ZERO FILL - <=> mueve los bits a la derecha, descarta el bit del extremo derecho y asigna al bit más a la izquierda un valor de 0. Cada movimiento a la derecha divide efectivamente op1 por la mitad. El bit de signo más a la izquierda se descarta.

Para desglosarlo un poco más, tiene mucho que ver con la representación binaria del valor en cuestión. 

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

Espero que esto ayude.

Cuando el término " bitwise " se menciona, a veces aclara que no es un & "; lógico &"; operador.

Por ejemplo, en JavaScript, los operadores bit a bit tratan sus operandos como una secuencia de 32 bits (ceros y unos) ; mientras tanto, los operadores lógicos se suelen utilizar con valores booleanos (lógicos) pero puede trabajar con tipos no booleanos.

Tome expr1 & amp; & amp; expr2 por ejemplo.

  

Devuelve expr1 si se puede convertir   a falso de lo contrario, devuelve expr2.   Por lo tanto, cuando se usa con valores booleanos,   & amp; & amp; devuelve verdadero si ambos operandos son   cierto; de lo contrario, devuelve falso. 

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

Como otros han notado, 2 & amp; 4 es un AND bit a bit, por lo que devolverá 0.

Puede copiar lo siguiente a test.html o algo y probar: 

<html>
<body>
<script>
    alert("\"Cat\" && \"Dog\" = " + ("Cat" && "Dog") + "\n"
        + "2 && 4 = " + (2 && 4) + "\n"
        + "2 & 4 = " + (2 & 4));
</script>
  

En la programación de computadora digital, una operación bit a bit opera en uno o más patrones de bits o números binarios al nivel de sus bits individuales. Es una acción rápida y primitiva directamente compatible con el procesador, y se utiliza para manipular valores para comparaciones y cálculos.

operaciones :

  • bit a bit Y

  • bit a bit O

  • bit a bit NO

  • XOR bit a bit

  • etc

Elemento de la lista 

    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

Ej. 

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

Usos del operador bit a bit

  • Los operadores de desplazamiento hacia la izquierda y hacia la derecha son equivalentes a la multiplicación y división por x * 2 y respectivamente.

Ej. 

int main()
{
     int x = 19;
     printf ("x << 1 = %d\n" , x <<1);
     printf ("x >> 1 = %d\n", x >>1);
     return 0;
}
// Output: 38 9
  • El amplificador &; El operador se puede utilizar para verificar rápidamente si un número es par o impar

Ej. 

int main()
{
    int x = 19;
    (x & 1)? printf("Odd"): printf("Even");
    return 0;
 }
// Output: Odd
  • Búsqueda mínima mínima de x e y sin if else declaración

Ej. 

int min(int x, int y)
{
    return y ^ ((x ^ y) & - (x < y))
}
  • Decimal a binario conversión

Ej. 

#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 ;
}
  • El cifrado de compuerta XOR es una técnica popular, debido a su complejidad y uso posterior por parte del programador.
    • el operador XOR bit a bit es el operador más útil desde la perspectiva de la entrevista técnica.
El

desplazamiento bit a bit solo funciona con + ve number

También hay una amplia gama de uso de lógica bit a bit

Podría ayudar pensarlo de esta manera. Así es como funciona AND (& Amp;):

Básicamente dice que son ambos números, así que si tienes dos números 5 y 3 se convertirán en binarios y la computadora pensará 

         5: 00000101
         3: 00000011

son ambos uno: 00000001 0 es falso, 1 es verdadero

Entonces el AND de 5 y 3 es uno. El operador OR (|) hace lo mismo, excepto que solo uno de los números debe ser uno para la salida 1, no ambos.

Seguí escuchando sobre lo lentos que eran los operadores de JavaScript a nivel de bits. Hice algunas pruebas para mi última publicación de blog y encontré En varias pruebas, fueron 40% a 80% más rápidos que la alternativa aritmética. Quizás solían ser lentos. En los navegadores modernos, los amo.

Tengo un caso en mi código que será más rápido y fácil de leer debido a esto. Mantendré mis ojos abiertos para más.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top