bitShift left (<<)

Desplazamiento de bit a la izquierda

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 x por y bits (x << y), los bits más a la izquierda de y en x 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 x por y derecha los bits (x >> y), y el bit más alto de x es un 1, el comportamiento depende del tipo de datos exacto de x. Si x es de tipo int, el bit más alto es el bit de signo, la determinación de si x 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.



No hay comentarios:

Publicar un comentario