Descripción de los operadores bitwise de C++

1. MANEJO DE BITS

2. INTRODUCCIÓN
 Una computadora sin software sólo tiene
capacidades para hacer operaciones aritméticas
simples (sumas, restas, multiplicación, etc.)
 El software se vale de estas simples operaciones
para crear interfaces como las que vemos en los
modernos sistemas operativos.
 Todos los lenguajes, desde los más altos como
“PHP”, hasta los más bajos como “Ensamblador”,
pasan por binario; cada vez que se mueve el ratón
se invocan procesamiento de datos binarios.

3. INTRODUCCIÓN
 Una de las razones por las que C y C++ se han
hecho tan populares es por que el lenguaje ofrece
muchos operadores de manipulación de bits a bajo
nivel.
 Los operadores de manipulación de bits (bitwise)
ejecutan operaciones lógicas sobre cada uno de
los bits de los operandos.
 Estas operaciones son comparables en eficiencia y
en velocidad a sus equivalentes en lenguaje
ensamblador.

4. INTRODUCCIÓN
 Cada operador de manipulación de bits realiza una
operación lógica, bit a bit, sobre datos internos.
 Los operadores de manipulación de bits se aplican
sólo a variables y constantes char, int y long, y no a
datos con punto flotante.
 Dado que los números binarios constan de 1’s y 0’s
(bits) estos 1 y 0 se manipulan para producir el
resultado deseado para cada uno de los
operadores.

5. OPERADORES QUE VEREMOS
 "&“
 "|“
 "^“
 "~“
 "<<"
 ">>"

6. & OPERADOR AND
 & operador AND de bits (sólo aplicables a variables de
tipo entero)
 El operador & (no confundir con el operador lógico &&) es un
operador lógico a nivel de bits.
 Compara un par de cadenas de bits por bit; el resultado para
cada comparación es 1 si los bits comparados son ambos 1, y
0 en otro caso.
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

7. ¿CUÁL ES EL RESULTADO DE APLICAR EL
OPERADOR AND?
1 1 0 1 0 1
0 1 1 0 0 1

8. OPERADOR &
 Con este operador & se puede ocultar un conjunto
de bits que no son relevantes en determinada
situación.
 Esto constituye una máscara de bits.
 Consideremos un pequeño problema y elaborar
una solución:

9. OPERADOR &
 En un ciclo controlado por la variable TAMANO, es
necesario imprimir el valor del contador sólo desde
0 hasta 15, y comenzar después en 0, aún cuando
TAMANO se siga incrementando.

10. PROCEDIMIENTO DE EJEMPLO ANDvoid operadorAND(void){
/*+++++++++++++++++++++++++++++++++++++++*
*Este procedimiento recibe un par de numeros *
*e imprime el resultado de aplicarles el *
*operador binario & *
*+++++++++++++++++++++++++++++++++++++++*/
int x;
int y;
int res;
cout << "nEste programa hace uso del operador binario &n";
cout << "nIntroduzca un entero: ";
cin >> x;
cout << "nIntroduzca un segundo entero: ";
cin >> y;
res = x&y;
cout << x <<" " << y << " " << res;
}

11. USO PRÁCTICO
 Tablas de estatus o permisos – se tiene un campo
“permisos” en la base de datos que corresponde a
un campo tipo integer, donde el valor
1 = lectura
2 = escritura Cada valor corresponde
4 = ejecución a un bit encendido
8 = otro permiso
Si se lee 3 significa lectura y
escritura.
6 = escritura y ejecución

12. USO PRÁCTICO
 Si se requiere saber si un usuario posee permisos
de escritura, se aplica máscara AND con valor 2.

13. EJEMPLO DE USO PRÁCTICO
 Investiga el valor binario de 1, 2 y 4
 Recuerda que 1 significa lectura, 2 significa
escritura y 4 significa ejecución.
 Para saber qué permisos tiene un usuario, se
aplica el permiso que uno busca con un operador
AND y el permiso que tiene el usuario.

14. ¿QUÉ PUEDE HACER CADA USUARIO?
 Permisos lectura 0 0 0 0 0 0 0 1
 Permisos escritura 0 0 0 0 0 0 1 0
 Permisos ejecución 0 0 0 0 0 1 0 0
 Permisos usuarioA 0 0 0 0 0 1 1 0
 Permisos usuarioB 0 0 0 0 0 0 1 1
 Permisos usuarioC 0 0 0 0 1 1 1 1

15. PROCEDIMIENTO DE EJEMPLO MÁSCARA/*+++++++++++++++++++++++++++++++++++++++++++++
* Este procedimiento imprime ciclicamente valores +
* de una variable por debajo de un limite, +
* por medio de una mascara de bits. +
* +++++++++++++++++++++++++++++++++++++++++++*/
#define TAMANO 200
#define LIMITE 15
//LIMITE funciona como una máscara que oculta los bits a la izquierda de
//último 1 a la izquierda.
…
void MASCARA (void){
int i = 0, mascara;
for (i = 0; i < TAMANO; i++)
{
mascara = i & LIMITE;
cout << mascara << "n";
}
}
07/09/2015
15
Mtl.LourdesCahuich

16. | OR INCLUSIVO (PALABRA CLAVE BITOR)
 Este operador binario tiene un funcionamiento parecido
a los anteriores (AND y XOR), salvo que en este caso el
resultado es 1 si alguno de ellos está a 1. En caso
contrario devuelve 0 (ver ejemplo).
 Ejemplo:
int x = 10, y = 20;
int z = x | y; // equivale a:
int z = x bitor y;
 Según el enunciado, el operador | aplicado entre los
valores 6 y 13 resultaría:
6 == 0000 0110
13 == 0000 1101
------------------
0000 1111 == 15

17. ^ XOR OR EXCLUSIVO (PALABRA CLAVE
XOR)
 El funcionamiento de este operador binario es parecido
al AND lógico , salvo que en este caso el resultado es 1
si ambos bits son complementarios (uno es 0 y el otro
1). En caso contrario devuelve 0.
 Ejemplo:
int x = 10, y = 20;
int z = x ^ y; // equivale a: int z = x xor y;
Según el enunciado, el operador ^ aplicado entre los
valores 7 y -2 resultaría:
7 == 0000 0111
-2 == 1111 1110
------------------
1111 1001 == -7

18. ~ COMPLEMENTO A UNO
(PALABRA CLAVE COMPL)
 Este operador unitario invierte cada bit del operando; 0
es convertido en 1 y viceversa.
 La representación binaria de los complementos a uno de
los decimales 0, 1 y 2 son los que se expresan (para
simplificar los representamos como un octeto):
0 == 0000 0000 ~ 0 == 1111 1111
1 == 0000 0001 ~ 1 == 1111 1110
2 == 0000 0010 ~ 2 == 1111 1101

19. PROCEDIMIENTO DE EJEMPLO
void complementoAuno(void){
/*+++++++++++++++++++++++++++++++++++++++++++++
* Este procedimiento cambia un numero sin sigo a +
* su complemento a uno a nivel de bits +
* ++++++++++++++++++++++++++++++++++++++++++*/
short signed cero = 0, uno = 1, dos = 2;
cout << "~0 == " << ~cero << endl;
cout << "~1 == " << ~uno << endl;
cout << "~2 == " << ~dos << endl;
}

20. << DESPLAZAMIENTO A IZQUIERDA
 Este operador binario realiza un desplazamiento de
bits a la izquierda. El bit más significativo (más a la
izquierda) se pierde, y se le asigna un 0 al menos
significativo (el de la derecha). El operando
derecho indica el número de desplazamientos que
se realizarán.
 Recuerde que los desplazamientos no son
rotaciones; los bits que salen por la izquierda se
pierden, los que entran por la derecha se rellenan
con ceros. Este tipo de desplazamientos se
denominan lógicos en contraposición a los cíclicos
o rotacionales.

21. << DESPLAZAMIENTO A IZQUIERDA
unsigned long x = 10;
int y = 2;
unsigned long z = x << y;
 Según las premisas anteriores, los
desplazamientos izquierda de valor unitario
aplicados sobre los números 0, 1, 2 y -3, producen
los siguientes resultados:
0 == 0000 0000 0 << 1 == 0000 0000 == 0
1 == 0000 0001 1 << 1 == 0000 0010 == 2
2 == 0000 0010 2 << 1 == 0000 0100 == 4
-3 == 1111 1101 -3 << 1 == 1111 1010 == - 6

22. PROCEDIMIENTO DE EJEMPLO
void desplazamientoAIzquierda(void){
int x = 1;
// Los operadores de bits solo se aplican a variables
unsigned
cout << "nEl tamanio de una variable int es: " <<
sizeof(int) << endl;
cout << "nEl valor inicial de x: " << x << endl;
for (unsigned i = 1; i <= 8; i++)
{
unsigned desplazado = x << i;
cout << "nEl numero: " << desplazado << endl;
}
cout << "nEl valor final de x: " << x << endl;
}

23. >> DESPLAZAMIENTO A DERECHA
 Igual que el desplazamiento a la izquierda, pero el
desplazamiento de bits es, obviamente, a la
derecha.
 Sintaxis
expr-desplazada >> expr-desplazamiento
0 == 0000 0000 0 >> 1 == 0000 0000 == 0
2 == 0000 0010 2 >> 1 == 0000 0001 == 1
-2 == 1111 1110 -2 >> 1 == 1111 1111 == -1
(C++Builder & GNU-C++)
-16 == 1111 0000 -16 >> 2 == 1111 1100 == -4
(C++Builder & GNU-C++)

24. PROCEDIMIENTO DE EJEMPLO
void desplazamientoADerecha(void){
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
* Este procedimiento hace uso de el operador de desplazamiento *
* hacia la derecha >> *
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int x = 128;
cout << "nEl tamanio de una variable int es: " << sizeof(int) << endl;
cout << "nEl valor inicial de x: " << x << endl;
for (unsigned i = 1; i <= 8; i++)
{
unsigned desplazado = x >> i;
cout << "nEl numero: " << desplazado << endl;
}
cout << "nEl valor final de x: " << x << endl;
}