3.4.4 Operadores a nivel de bit (bitwise operators)

En determinadas ocasiones nos puede interesar manipular datos a nivel de bit; por ejemplo activar o desactivar flags. Un flag es una ``variable'' que puede tomar 2 valores, por lo que se suele representar con un bit. Debido a que en C (y en la mayoría de lenguajes de programación) no existen tipos predefinidos de un bit, lo que se suele hacer es agrupar varios flags en una variable de tipo entero (``short int'', ``int'' o lo que queramos).

Para acceder a estos flags o simplemente para activarlos es necesario utilizar operadores a nivel de bit. Veámoslo en un ejemplo.

La llamada al sistema ``open'' (en POSIX) necesita que se le especifique que hacer con el fichero a abrir: crearlo si no existe, sobreescribirlo si existe, no sobreescribirlo, etc.

        int open(const char *path, int flags);
        //Donde:
        //   path  --> indica el path de donde se encuentra el fichero
        //   flags --> indica lo que queremos hacer con el fichero ...
        //
        //Flags puede ser:
        //   O_CREAT Si el fichero no existe, será creado.
        //   O_EXCL Cuando se combina con O_CREAT, se considerará un 
        //          error que el fichero ya exista.
        //   O_TRUNC Si el fichero ya existe, será truncado.
        //   O_APPEND El fichero se abrirá en modo de sólo-añadir.
        //   O_NONBLOCK El fichero se abre en modo no bloqueante.
        //   ...

Si queremos abrir el fichero ``/tmp/tutorial_c.txt'' en modo lectura y que se pueda escribir al final del mismo pondremos:

        int fd;

        fd = open ("/tmp/tutorial_c.txt", O_CREAT | O_APPEND );
        // también lo podríamos hacer "a pelo":
        //   open ("/tmp/tutorial_c.txt", 0x440)
        
        write(fd, "Hola mundo...\n", 14);

        close (fd);

Aunque normalmente no se suelen utilizar, es bueno conocer como actúan estos operadores y de cuales disponemos.

Tabla 3.5: Operadores a nivel de bit

Operador	Acción
&	AND a nivel de bit.
$\vert$	OR a nivel de bit.
$\wedge$	XOR a nivel de bit.
$\tilde{\ }$	Complemento.
$<<$	Desplazamiento a la izquierda.
$>>$	Desplazamiento a la derecha.

A continuación describiremos cada uno de estos operadores brevemente.

DEFINICIÓN: El operador AND (&): El operador AND compara dos bits; si los dos son 1 el resultado es 1, en otro caso el resultado será 0. Ejemplo:

        c1 = 0x45      --> 01000101
        c2 = 0x71      --> 01110001
        ---------------------------
        c1 & c2 = 0x41 --> 01000001

DEFINICIÓN: El operador OR ($\vert$): El operador OR compara dos bits; si cualquiera de los dos bits es 1, entonces el resultado es 1; en otro caso será 0. Ejemplo:

        i1 = 0x47      --> 01000111
        i2 = 0x53      --> 01010011
        ---------------------------
        i1 | i2 = 0x57 --> 01010111

DEFINICIÓN: El operador XOR ($\wedge$): El operador OR exclusivo o XOR, dará como resultado un 1 si cualquiera de los dos operandos es 1, pero no los dos a la vez. Ejemplo:

        i1 = 0x47      --> 01000111
        i2 = 0x53      --> 01010011
        ---------------------------
        i1 ^ i2 = 0x14 --> 00010100

DEFINICIÓN: El operador de complemento ($\tilde{\ }$): Este operador devuelve como resultado el complemento a uno del operando:

        c = 0x45  --> 01000101
        ----------------------
        ~c = 0xBA --> 10111010

DEFINICIÓN: Los operadores de desplazamiento a nivel de bit ($<<$ y $>>$): Desplazan a la izquierda o a la derecha un número especificado de bits. En un desplazamiento a la izquierda los bits que sobran por el lado izquierdo se descartan y se rellenan los nuevos espacios con ceros. De manera análoga pasa con los desplazamientos a la derecha. Veamos un ejemplo:

	c = 0x1C	00011100
c $<<$ 1	c = 0x38	00111000
c $>>$ 2	c = 0x07	00000111