manejo de bits
TRANSCRIPT
MANEJO DE BITS
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.
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.
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.
OPERADORES QUE VEREMOS
"&“
"|“
"^“
"~“
"<<"
">>"
& 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
¿CUÁL ES EL RESULTADO DE APLICAR EL
OPERADOR AND?
1 1 0 1 0 1
0 1 1 0 0 1
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:
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.
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;
}
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 valor1 = 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
USO PRÁCTICO
Si se requiere saber si un usuario posee permisos
de escritura, se aplica máscara AND con valor 2.
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.
¿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
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
/201
5
15
Mtl. L
ou
rdes C
ah
uic
h
| 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
^ 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
~ 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
PROCEDIMIENTO DE EJEMPLOvoid 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;
}
<< 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.
<< 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
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;
}
>> 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++)
PROCEDIMIENTO DE EJEMPLOvoid 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;
}