bitShift right ()

Desplazamiento de bit a la derecha

Descripción

Hay dos operadores de desplazamiento de bits en C ++: el operador de desplazamiento a la izquierda << y el operador de desplazamiento a la derecha >>. Estos operadores hacen que los bits del operando de la izquierda se desplacen a la izquierda o hacia la derecha el número de posiciones especificadas por el operando de la derecha. Más sobre matemáticas a nivel de bits se pueden encontrar aquí.

Sintaxis
  
<< variable number_of_bits
>> variable number_of_bits


Parámetros


Variable - (byte, int, long) number_of_bits entero <= 32


Ejemplo:


   int a = 5;            // Binario: 0000000000000101 
   int b = a << 3;   // Binario: 0000000000101000, o 40 en decimal


   int c = b >> 3;   // Binario: 0000000000000101, o de nuevo a 5 como empezamos

Cuando se cambia un valor de por bits (x << y), los bits más a la izquierda de en se pierden, literalmente dejan de existir:

   int a = 5;              // Binario: 0000000000000101
   int b = a << 14;    // Binario: 0100000000000000 - el primer 1 en 101 se desechó


Si está seguro de que ninguno de los unos está en un valor se está desplazando, una forma sencilla de pensar en el operador de desplazamiento a la izquierda es que se multiplica el operando de la izquierda por 2 elevado a la potencia operando de la derecha. Por ejemplo, para generar potencias de 2,  se pueden emplear las siguientes expresiones:

   << 1 0 == 1
   1 << 1 2 ==
   1 2 << == 4
   1 << == 3 8
    ...
   1 << == 256 8
   1 << == 512 9
   1 << == 10 1024
   ...

Cuando se cambia por y derecha los bits (x >> y), y el bit más alto de es un 1, el comportamiento depende del tipo de datos exacto de x. Si es de tipo int, el bit más alto es el bit de signo, la determinación de si es negativo o no, como hemos comentado anteriormente. En ese caso, el bit de signo se copia en los bits inferiores, por razones históricas:

   int x = -16;        // Binario: 1111111111110000
   int y = x >> 3;   // Binario: 1111111111111110


Este comportamiento, denominado extensión de signo, a menudo no es el comportamiento que deseamos. En lugar de ello, es posible que deseemos los ceros que se arrastran de la izquierda. Resulta que las reglas de desplazamiento a la derecha son diferentes para las expresiones int sin signo, por lo que puede utilizar un cambio de tipo (typecast) para suprimir lo que se está copiando desde la izquierda:

   int x = -16;                                // Binario: 1111111111110000
   int y = (unsigned int) x >> 3;   // Binario: 0001111111111110


Si usted tiene cuidado para evitar la extensión de signo, se puede utilizar el operador de desplazamiento a la derecha >> como una manera de dividir por potencias de 2. Por ejemplo:

   int x = 1000;

   int y = x >> 3;  // División entera de 1000 por 8, haciendo que y = 125., haciendo que y = 125.




1 comentario: