Reference   Language (extended) | Libraries | Comparison | Changes

Desplazador de bits a la izquierda (<<), desplazador de bits a la derecha (>>)

Descripción

De The Bitmath Tutorial en el Playground

Hay dos operadores de desplazamiento en C++: el operador de desplazamiento izquierdo << y el operador de desplazamiento derecho >>. Estos operadores hacen que los bits del operando izquierdo sean desplazados a la izquierda o a la derecha el número de posiciones especificadas por el operando derecho.

Puedes encontrar más de matemática bit a bit aquí.

Sintaxis

variable << numero_de_bits

variable >> numero_de_bits

Parámetros

variable - (byte, int, long) numero_de_bits integer <= 32

Ejemplo:

    int a = 5;        // binario: 0000000000000101
    int b = a << 3;   // binario: 0000000000101000, o 40 en decimal
    int c = b >> 3;   // binario: 0000000000000101, o vuelta al 5 con el que habíamos empezado

Cuando desplazas un valor x, y bits (x << y), los bits más a la izquierda de x se pierden, literalmente desplazados de la existencia:

    int a = 5;        // binario: 0000000000000101
    int b = a << 14;  // binario: 0100000000000000, el primer 1 de 101 ha sido descartado

Si estás seguro de que ninguno de los unos de un valor estan siendo desplazados al olvido, una manera facil de entender como funciona el operador de desplazamiento a la izquierda es pensar que funciona multiplicando el operando izquierdo por dos elevado al valor del operando derecho. Por ejemplo, se pueden usar las siquientes expresiones para generar potencias de 2:

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

Cuando desplazas x a la derecha, y bits(x >> y), y el bit mas alto o mas significativo de x es un 1, el comportamiento depende de el tipo exacto de dato que es x. Si x es un entero (int), el bit mas significativo es el bit de signo, que determina si x es negativo o no, como hemos discutido anteriormente. En este caso, el bit de signo esta copiado en los bits más bajos, por razones históricamente esotéricas:

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

Este comportamiento,llamado extensión de signo, no siempre es el comportamiento que quieres. En su lugar, tu querrías que introdujera ceros desde la izquierda. Resulta que las normas de desplazamiento a la derecha son diferentes para las expresiones enteras sin signo, por lo que puedes usar un cambio de tipo de variable para impedir que los unos se copien desde la izquierda:

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

Si tienes cuidado de evitar la extensión de signo, puedes usar 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 entre 8, haciendo que y = 125.

Página principal Referencia

Correcciones, sugerencias, y nueva documentación deberán ser publicadas en el Foro (castellano) o en el Foro (inglés).

El texto de la referencia de Arduino está publicado bajo la licencia Creative Commons Reconocimiento-Compartir bajo la misma licencia 3.0. Los ejemplos de código de la referencia están liberados al dominio público.

Share