Reference Language (extended) | Libraries | Comparison | Changes
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í.
variable << numero_de_bits
variable >> numero_de_bits
variable - (byte, int, long) numero_de_bits integer <= 32
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.
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.