Dominando operadores bitwise en C: AND, OR, XOR, desplazamientos y complemento

¿Qué son los operadores bitwise?

Los operadores bitwise manipulan bits individuales de valores enteros. A diferencia de los operadores aritméticos que trabajan con números completos, los operadores bitwise actúan sobre la representación binaria, lo que los hace ideales para tareas críticas de rendimiento como banderas, máscaras de bits y control de dispositivos de bajo nivel.

En C, están disponibles los siguientes operadores bitwise:

Operador	Significado
&	AND bit a bit
|	OR bit a bit
^	XOR bit a bit (OR exclusivo)
~	NOT bit a bit (complemento a uno)
<<	Desplazamiento a la izquierda
>>	Desplazamiento a la derecha

Los operadores bitwise están definidos solo para tipos enteros; no son aplicables a tipos de punto flotante como float o double.

Las operaciones comienzan en el bit menos significativo (LSB) y avanzan hacia el bit más significativo (MSB). La siguiente tabla de verdad resume los resultados binarios:

Operando x	Operando y	x & y	x | y	x ^ y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

En las siguientes secciones profundizaremos en cada operador con ejemplos.

AND bitwise (&)

El operador AND devuelve 1 solo cuando ambos bits correspondientes son 1; de lo contrario, el resultado es 0. Se usa comúnmente para enmascarar bits no deseados.

 Op1 = 0000 1101 Op2 = 0001 1001 Resultado = 0000 1001 

OR bitwise (|)

El operador OR devuelve 1 si al menos uno de los bits es 1. Es útil para establecer bits específicos.

 Op1 = 0000 1101 Op2 = 0001 1001 Resultado = 0001 1101 

XOR bitwise (^)

El operador XOR devuelve 1 solo cuando los bits difieren. Es útil para alternar bits.

 Op1 = 0000 1101 Op2 = 0001 1001 Resultado = 0001 0100 

Programa de ejemplo:

#include <stdio.h> int main() { int a = 20; /* 20 = 010100 */ int b = 21; /* 21 = 010101 */ int c = 0; c = a & b; /* 20 = 010100 */ printf("AND - c = %d\n", c); c = a | b; /* 21 = 010101 */ printf("OR - c = %d\n", c); c = a ^ b; /* 1 = 000001 */ printf("XOR - c = %d\n", c); return 0; } 

Salida:

 AND - c = 20 OR - c = 21 XOR - c = 1 

Operadores de desplazamiento bitwise (<< y >>)

Los operadores de desplazamiento mueven bits a la izquierda o derecha por una cuenta especificada.

• operando << n – desplaza a la izquierda, insertando ceros a la derecha.
• operando >> n – desplaza a la derecha, insertando ceros a la izquierda.

Ejemplo con un número de 4 bits 1111:

 x << 2 → 1100 x >> 2 → 0011 

Ilustración del programa:

#include <stdio.h> int main() { int a = 20; /* 20 = 010100 */ int c = 0; c = a << 2; /* 80 = 101000 */ printf("Desplazamiento izquierda - c = %d\n", c); c = a >> 2; /* 5 = 000101 */ printf("Desplazamiento derecha - c = %d\n", c); return 0; } 

Salida:

 Desplazamiento izquierda - c = 80 Desplazamiento derecha - c = 5 

Complemento bitwise (~)

El operador complemento invierte cada bit: 1 se vuelve 0 y viceversa. Es un operador unario aplicado a un solo operando.

 0000 1111 → 1111 0000 

Programa de ejemplo:

#include <stdio.h> int main() { int a = 10; /* 10 = 001010 */ int c = ~a; /* -11 en complemento a dos */ printf("Complemento - c = %d\n", c); return 0; } 

Salida:

 Complemento - c = -11 

Todos los operadores juntos

A continuación se muestra un programa conciso que demuestra cada operador bitwise discutido.

#include <stdio.h> int main() { unsigned int x = 48; /* 0011 0000 */ unsigned int y = 13; /* 0000 1101 */ int z = 0; z = x & y; /* 0 = 0000 0000 */ printf("AND - x & y = %d\n", z); z = x | y; /* 61 = 0011 1101 */ printf("OR - x | y = %d\n", z); z = x ^ y; /* 61 = 0011 1101 */ printf("XOR - x ^ y = %d\n", z); z = ~x; /* -49 = 1111 0100 (complemento a dos) */ printf("NOT - ~x = %d\n", z); z = x << 2; /* 192 = 1100 0000 */ printf("Desplazamiento izq - x << 2 = %d\n", z); z = x >> 2; /* 12 = 0000 1100 */ printf("Desplazamiento der - x >> 2 = %d\n", z); return 0; } 

Resultado:

 AND - x & y = 0 OR - x | y = 61 XOR - x ^ y = 61 NOT - ~x = -49 Desplazamiento izq - x << 2 = 192 Desplazamiento der - x >> 2 = 12 

Conclusiones clave

• Los operadores bitwise son exclusivos para tipos enteros y operan a nivel binario.
• Incluyen operaciones lógicas (AND, OR, XOR), de desplazamiento (izquierda/derecha) y complemento (~).
• Estos operadores son indispensables para tareas como manipulación de banderas, E/S de bajo nivel y código crítico de rendimiento.