Estructura de Datos

BYTE COMO UNA

ESTRUCTURA DE
DATOS

Uso de un byte como una estructura de datos

Ahora el ser humano digitaliza su entorno, pero, qu significa digitalizar?
Digitalizar: Es traducir informacin como textos, imgenes o sonidos, a un
formato que puedan entender los microprocesadores, y stos slo estn capacitados
para manejar los valores unos y ceros.
En efecto, para tu microprocesador todo lo que ves en estos momentos en la
pantalla se maneja con unos o ceros. Esto es porque la computadora maneja un
sistema binario, que se llama as porque slo acepta dos valores (0 y 1).
Tal sencillez tiene su razn de ser:
Los microprocesadores son circuitos electrnicos plasmados en un material
llamado silicio (algo parecido al vidrio) que procesan diminutos impulsos elctricos,
el ms pequeo de los cuales es conocido por el nombre de bit. Como impulso
elctrico, el microprocesador slo puede detectar cuando un bit tiene carga elctrica
--su valor sera, en este caso, 1-- o cuando no la tienen --su valor sera 0 -.

Uso de un byte como una estructura de datos

En este ejemplo manejamos los valores unos y ceros de manera un
tanto arbitraria, ya que la presencia o ausencia de carga elctrica en un
bit puede ser interpretada como una gran diversidad de valores: cierto
y falso, hombre o mujer, si o no, etc.
La eficacia de las computadoras no se basa en la complejidad de su
fundamento lgico, que como vimos se reduce a manejar dos posibles
valores, sino de la velocidad con la que se aplica dicha lgica: los
microprocesadores actuales pueden procesar varios millones de bits en
un slo segundo.
Un bit puede representar solamente dos valores.
Dos bits, cuatro posibles valores y ocho bits 256 posibles
combinaciones de unos y ceros.

Operadores de manejo de bits

C++ dispone de 6 operadores para manejo de bits que realizan dos
tipos de operaciones. Son los siguientes:
~

Complemento a uno *.
<< Desplazamiento a izquierda .
>> Desplazamiento a derecha .
&
AND; compara dos bits *.
^
XOR (OR exclusivo); compara dos bits *.
|
OR inclusivo; compara dos bits *.
El primero es un operador unario, los restantes son binarios. Los tres
primeros realizan manipulaciones en los bits del operando. Los restantes
realizan comparaciones lgicas entre los bits de ambos operandos, similares
a las que realizan los operadores lgicos entre objetos booleanos.

Operadores de manejo de bits

~ Complemento a uno
Este operador unitario invierte cada bit del operando; 0 es
convertido en 1 y viceversa.
Sintaxis
~cast-expresion
Ejemplo:
signed int s1 = ~2;
// equivale a:
signed int s1 = compl 2;
signed int s2 = ~s1 + 2;

Operadores de manejo de bits

Para verificarlo, escribimos un pequeo programa:
#include <iostream.h>
short signed cero = 0, uno = 1, dos = 2;
int main (void) {
cout << "~0 == " << ~cero << endl;
cout << "~1 == " << ~uno << endl;
cout << "~2 == " << ~dos << endl;
}
Salida:
~0 == -1
~1 == -2
~2 == -3

Operadores de manejo de bits

<< Desplazamiento a izquierda
Este operador binario realiza un desplazamiento de bits a la izquierda. El bit ms significativo
(ms a la izquierda) se pierde, y se le asigna un 0 al menos significativo (el de la derecha). El
operando derecho indica el nmero de desplazamientos que se realizarn.
Recurdese 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 lgicos en contraposicin a los cclicos o rotacionales.
Sintaxis
expr-desplazada << expr-desplazamiento
Comentario
El patrn de bits de expr-desplazada sufre un desplazamiento izquierda del valor indicado por
la expr-desplazamiento. Ambos operandos deben ser nmeros enteros o enumeraciones. En caso
contrario, el compilador realiza una conversin automtica de tipo. El resultado es del tipo del
primer operando.

Operadores de manejo de bits

Segn las premisas anteriores, los desplazamientos izquierda de valor unitario aplicados sobre los nmeros 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
Para comprobarlo, utilizamos una versin del programa anterior:
#include <iostream.h>
short signed cero = 0, uno = 1, dos = 2;
int main (void) {
cout << "0 << 1 == " << (cero << 1) << endl;
cout << "1 << 1 == " << (uno << 1) << endl;
cout << "2 << 1 == " << (dos << 1) << endl;
}
Salida:
0 << 1 == 0
1 << 1 == 2
2 << 1 == 4

Operadores de manejo de bits

>> Desplazamiento a derecha
Sintaxis
expr-desplazada >> expr-desplazamiento
Ejemplo:
unsigned long x = 10;
unsigned long z = x >> 2;
Comentario:
El patrn de bits de expr-desplazada sufre un desplazamiento derecho del valor
indicado por la expr-desplazamiento. Como en el caso anterior, ambos operandos
deben ser nmeros enteros o enumeraciones. En caso contrario, el compilador
realiza una conversin automtica de tipo. El resultado es del tipo del primer
operando.

Operadores de manejo de bits

Por lo dems, el comportamiento de este operador es anlogo al anterior (desplazamiento izquierda). Por ejemplo:
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++)

Para comprobar las relaciones anteriores, utilizamos una versin modificada del programa anterior:
#include <iostream.h>
short signed cero = 0, dos = 2, mdos = -2;
int main (void) {
cout << "0 >> 1 == " << (cero >> 1) << endl;
cout << "2 >> 1 == " << (dos >> 1) << endl;
cout << "-2 >> 1 == " << (mdos >> 1) << endl;
}
Salida:
0 >> 1 == 0
2 >> 1 == 1
-2 >> 1 == -1

Operadores de manejo de bits

& AND lgico (palabra clave bitand)
Este operador binario compara ambos operandos bit a bit, y como resultado devuelve
un valor construido de tal forma, que cada bits es 1 si los bits correspondientes de los
operandos estn a 1. En caso contrario, el bit es 0 (ver ejemplo).
Sintaxis
AND-expresion & equality-expresion
Ejemplo:
int x = 10, y = 20;
int z = x & y;
// equivale a: int z = x bitand y;
En este caso el resultado del AND lgico entre los enteros 10 y 20 se aplicara al
entero z.

Operadores de manejo de bits

Segn las reglas del enunciado, el operador & aplicado entre los valores 2 y -2 resultara:
2 == 0000 0010
-2 == 1111 1110
-----------------0000 0010 == 2
Comprobacin:
#include <iostream.h>
int main (void) {
cout << "2 & -2 == " << (2 & -2) << endl;
}
Salida:
2 & -2 == 2

Operadores de manejo de bits

^ XOR OR exclusivo (palabra clave xor)
El funcionamiento de este operador binario es parecido al AND lgico , 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.
Sintaxis
expr-OR-exclusiva ^ AND-expresion
Ejemplo:
int x = 10, y = 20;
int z = x ^ y;
// equivale a: int z = x xor y;

Operadores de manejo de bits

Segn el enunciado, el operador ^ aplicado entre los valores 7 y -2 resultara:
7 == 0000 0111
-2 == 1111 1110
-----------------1111 1001 == -7
Comprobacin:
#include <iostream.h>
int main (void) {
cout << "7 ^ -2 == " << (7 ^ -2) << endl;
}
Salida:
7 ^ -2 == -7

Operadores de manejo de bits

| 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).
Sintaxis
expr-OR-inclusiva | expr-OR-exclusiva
Ejemplo:
int x = 10, y = 20;
int z = x | y;
// equivale a:
int z = x bitor y;

Operadores de manejo de bits

Segn el enunciado, el operador | aplicado entre los valores 6 y 13 resultara:
6 == 0000 0110
13 == 0000 1101
-----------------0000 1111 == 15
Comprobacin:
#include <iostream.h>
int main (void) {
cout << "6 | 13 == " << (6 | 13) << endl;
}
Salida:
6 | 13 == 15

Asignaciones compuestas con operadores

de bits
Salvo el complemento a uno (~) que es unitario, los dems
operadores de menejo de bits pueden combinarse con la
asignacin simple (=) para dar lugar a una asignacin
compuesta.
Recuerde que:
x &= y; // equivale a: x = (x & y);
x ^= y; // equivale a: x = (x ^ y);
x |= y; // equivale a: x = (x | y);
x <<= y; // equivale a: x = (x << y);
x >>= y; // equivale a: x = (x >> y);

Asignaciones compuestas con operadores de bits

Ejemplo
#include <iostream.h>
int main() {
signed int x = 2, y = 7, z = 6, a = 2, b= -2;
x &= -2;
y ^= -2;
z |= 13;
a <<= 1;
b >>= 1;
cout << "Valor x = " << x << endl;
cout << "Valor y = " << y << endl;
cout << "Valor z = " << z << endl;
cout << "Valor a = " << a << endl;
cout << "Valor b = " << b << endl;
}
Salida:
Valor x = 2
Valor y = -7
Valor z = 15
Valor a = 4
Valor b = -1

Ejemplo de condicional y manejo de bits

//programa que convierte maysculas y minsculas, char a entero y entero a char

#include <iostream.h>
int main()
{
int entero;
char letra, letra2, letra3, letra4, opcion='s';
do
{
cout<<"dame una letra cualquiera: ";
cin>>letra;
if ( ! (letra >= 'a' && letra <= 'z') && ! (letra >= 'A' && letra <= 'Z') )
{
cout <<"caracter invalido"<<endl;
continue; //si no est entre (a...z) o entre (A...Z) reinicia el ciclo
}
//se probar nicamente el bit de las minsculas
if( letra & 0x20 ) cout <<"es minuscula"<<endl; // 0x20 hex = 00100000 bin
else cout <<"es mayuscula"<<endl;
//se invertir el bit de las minsculas
letra ^= 0x20;
cout <<"la letra invertida es: "<<letra<<endl<<endl;
cout <<"dame 2 letras minusculas y 2 letras mayusculas en cualquier orden"<<endl;
cin >> letra >> letra2 >> letra3 >> letra4;
letra |= 0x20; //convertir a minsculas
letra2 |= 0x20;
letra3 |= 0x20;
letra4 |= 0x20;
cout <<"convertidas a minusculas: "<< letra << letra2 << letra3 << letra4<<endl<<endl;
letra &= 0xDF; //convertir a maysculas
letra2 &= 0xDF;
letra3 &= 0xDF;
letra4 &= ~0x20; // tambien se pueden usar los complementos
cout <<"convertidas a mayusculas: "<< letra << letra2 << letra3 << letra4<<endl<<endl;
//convertir obtener el ASCII de un nmero
cout <<"dame un dgito (0-9): ";
cin >> letra;
entero = letra;
//comprobar el bit de paridad
cout <<endl<<"paridad: ";
(entero & 1)?cout<<"impar":cout<<"par";
cout <<endl;
cout <<"el codigo ASCII del digito " << letra << " es " <<entero<<endl;
//convertir caracter a nmero
entero &= 0x0F;
cout <<"caracter ingresado " << letra << " valor " <<entero<<endl;
// repetir ciclo
cout <<"repetir ciclo (S/N): ";
cin >> opcion;
}while(opcion=='s' ||opcion =='S');
cout << endl;
return 0;
}

Ejemplo de condicional y manejo de bits

Interpretacin

1. Nos dice si la letra es mayscula o minscula

2. Invierte el tipo
3. Convierte cuatro caracteres a minscula
4. Convierte cuatro caracteres a mayscula
5. Lee un dgito como carcter
6. Comprueba la paridad
7. Muestra el valor de ese dgito en ASCII
8. Se obtiene el valor de ese carcter al dgito que representa.
9. Pregunta si se repite el ciclo.