Operadores de bitwise en C++

Los operadores de bits y bytes en C++ permiten manipular datos a nivel de bits individuales o grupos de bits en una variable.

A diferencia de los operadores aritméticos comunes, que operan sobre valores completos, los operadores de bit manipulan cada bit en la representación binaria de un número.

C++ proporciona varios operadores bitwise, cada uno con su propia funcionalidad específica. Aquí tenéis una tabla de resumen.

Tipos de operadores bitwise en C++

Operador AND (&)

El operador AND bitwise realiza una operación lógica AND entre cada par de bits correspondientes de dos operandos. El resultado es 1 solo si ambos bits son 1, de lo contrario el resultado es 0.

int a = 6;   // Binario: 00000110
int b = 3;   // Binario: 00000011

int result = a & b; // Binario: 00000010 (solo los bits comunes)

En este ejemplo, la operación a & b compara cada bit en los números a y b. Solo el tercer bit de la derecha es 1 en ambos, por lo que el resultado es 00000010, que equivale a 2 en decimal.

Operador OR (|)

El operador OR bitwise realiza una operación lógica OR entre cada par de bits correspondientes de dos operandos. El resultado es 1 si al menos uno de los bits es 1, de lo contrario el resultado es 0.

int a = 6;   // Binario: 00000110
int b = 3;   // Binario: 00000011

int result = a | b; // Binario: 00000111 (si algún bit es 1)

Aquí, la operación a | b establece cada bit en 1 si al menos uno de los bits correspondientes en a o b es 1. El resultado es 00000111, que es 7 en decimal.

Operador XOR (^)

int a = 6;   // Binario: 00000110
int b = 3;   // Binario: 00000011

int result = a ^ b; // Binario: 00000101 (solo si los bits son diferentes)
}

En este caso, a ^ b devuelve 1 solo si los bits correspondientes en a y b son diferentes. El resultado 00000101 equivale a 5.

Operador NOT (~)

El operador NOT bitwise realiza una negación bitwise de su operando, invirtiendo cada bit del operando (los 0 se convierten en 1 y viceversa).

int a = 6;    // Binario: 00000110

int result = ~a; // Binario: 11111001 en una representación de 8 bits
}

Desplazamiento a la Izquierda

El operador << desplaza todos los bits hacia la izquierda. En el ejemplo, 3 << 2 es 00001100, lo cual equivale a 12.

int a = 3;   // Binario: 00000011
int result = a << 2; // Desplaza dos bits a la izquierda
// Resultado: 12 (00001100)
}

Este desplazamiento es similar a multiplicar el número por potencias de 2 (en este caso, 3 * 2^2 = 12).

Desplazamiento a la Derecha

El operador >> desplaza los bits hacia la derecha. En el ejemplo, 12 >> 2 es 00000011, que equivale a 3.

int a = 12;  // Binario: 00001100
int result = a >> 2; // Desplaza dos bits a la derecha

// Resultado: 3 (00000011)

Este desplazamiento es similar a dividir el número por potencias de 2 (12 / 2^2 = 3).

Aplicaciones de los operadores de bit

Manipulación de Bits para Aplicar Máscaras

El uso de máscaras nos permite manipular bits específicos sin afectar a los demás. Por ejemplo, para establecer en 1 el tercer bit de un número:

int number = 5;     // Binario: 00000101
int mask = 1 << 2;  // Máscara: 00000100
    
number = number | mask;  // Aplicamos OR bitwise para establecer el bit
// Resultado: 7 (00000111)

Verificación de Bits

Para comprobar si un bit específico está establecido (por ejemplo, el tercer bit):

int number = 5;         // Binario: 00000101
int mask = 1 << 2;      // Máscara: 00000100

bool isThirdHigh = number & mask   // Verifica si el tercer bit está en 1
}

Uso de operadores de bits y bytes

Supongamos que queremos activar el tercer bit de una variable y desactivar el cuarto bit. Podríamos usar los operadores de bits de la siguiente manera:

int valor = 12;  // Representación binaria: 1100

valor |= (1 << 2);  // Activar tercer bit (contando desde 0)
valor &= ~(1 << 3); // Desactivar cuarto bit
}

En este ejemplo, estamos utilizando operadores de bits para realizar operaciones precisas en el tercer y cuarto bit de la variable valor.