Dominando operadores bit a bit y de desplazamiento en C#: Guía completa

Operadores bit a bit y de desplazamiento en C#

En este tutorial, aprenderemos en detalle sobre los operadores bit a bit y de desplazamiento en C#. C# proporciona 4 operadores bit a bit y 2 operadores de desplazamiento.

Estos operadores se utilizan para realizar operaciones a nivel de bit en datos enteros (int, long, etc.) y booleanos. No son comúnmente usados en situaciones cotidianas, pero son fundamentales para programación de bajo nivel, criptografía, compresión y optimización.

Lista de operadores bit a bit en C#

Operador	Nombre
~	Complemento bit a bit
&	AND bit a bit
|	OR bit a bit
^	XOR bit a bit (OR exclusivo)
<<	Desplazamiento a la izquierda
>>	Desplazamiento a la derecha

---

OR bit a bit (|)

El operador OR bit a bit se representa con |. Realiza la operación OR en los bits correspondientes de dos operandos. Si cualquiera de los bits es 1, el resultado es 1; en caso contrario, 0.

Si los operandos son de tipo bool, la operación OR bit a bit es equivalente a la operación OR lógica.

Ejemplo:

14 = 00001110 (en binario)
11 = 00001011 (en binario)

Operación OR bit a bit entre 14 y 11:

00001110
00001011
--------
00001111 = 15 (en decimal)

Ejemplo 1: OR bit a bit

using System;
namespace Operator {
    class BitWiseOR {
        public static void Main(string[] args) {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber | secondNumber;
            Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

Salida:

14 | 11 = 15

---

AND bit a bit (&)

El operador AND bit a bit se representa con &. Realiza la operación AND en los bits correspondientes. Si cualquiera de los bits es 0, el resultado es 0; en caso contrario, 1.

Para operandos bool, equivale a AND lógico.

Ejemplo con 14 y 11:

00001110
00001011
--------
00001010 = 10 (en decimal)

Ejemplo 2: AND bit a bit

using System;
namespace Operator {
    class BitWiseAND {
        public static void Main(string[] args) {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber & secondNumber;
            Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

Salida:

14 & 11 = 10

---

XOR bit a bit (^)

El operador XOR bit a bit se representa con ^. Si los bits correspondientes son iguales, el resultado es 0; si son diferentes, el resultado es 1.

Para bool, equivale a XOR lógico.

Ejemplo con 14 y 11:

00001110
00001011
--------
00000101 = 5 (en decimal)

Ejemplo 3: XOR bit a bit

using System;
namespace Operator {
    class BitWiseXOR {
        public static void Main(string[] args) {
            int firstNumber = 14, secondNumber = 11, result;
            result = firstNumber ^ secondNumber;
            Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);
        }
    }
}

Salida:

14 ^ 11 = 5

---

Complemento bit a bit (~)

El operador complemento bit a bit se representa con ~. Es un operador unario (opera sobre un solo operando). Invierte cada bit: cambia 1 a 0 y 0 a 1.

Ejemplo con 26:

26 = 00011010 (en binario)
~ 00011010 = 11100101

Ejemplo 4: Complemento bit a bit

using System;
namespace Operator {
    class BitWiseComplement {
        public static void Main(string[] args) {
            int number = 26, result;
            result = ~number;
            Console.WriteLine("~{0} = {1}", number, result);
        }
    }
}

Salida:

~26 = -27

Obtuvimos -27 en lugar del esperado 229. ¿Por qué?

Porque el valor binario 11100101 (229 en decimal sin signo) es en realidad la representación en complemento a dos de -27. Los números negativos en computadoras se representan en complemento a dos.

Para cualquier entero n, el complemento a dos de n es -(n+1).

Complemento a dos

Decimal	Binario	Complemento a dos
0	00000000	-(11111111 + 1) = -00000000 = 0
1	00000001	-(11111110 + 1) = -11111111 = -256
229	11100101	-(00011010 + 1) = -00011011 = -27

Los valores de desbordamiento se ignoran en complemento a dos. El complemento bit a bit de 26 es 229, y el complemento a dos de 229 es -27. Por eso la salida es -27.

---

Desplazamiento a la izquierda (<<)

El operador de desplazamiento a la izquierda << mueve los bits de un número hacia la izquierda un número especificado de posiciones. Se añaden ceros en los bits menos significativos.

En decimal, equivale a:

num * 2^bits

Ejemplo con 42 (101010 en binario):

42 << 1 = 84 (1010100)
42 << 2 = 168 (10101000)
42 << 4 = 672 (1010100000)

Ejemplo 5: Desplazamiento a la izquierda

using System;
namespace Operator {
    class LeftShift {
        public static void Main(string[] args) {
            int number = 42;
            Console.WriteLine("{0}<<1 = {1}", number, number << 1);
            Console.WriteLine("{0}<<2 = {1}", number, number << 2);
            Console.WriteLine("{0}<<4 = {1}", number, number << 4);
        }
    }
}

Salida:

42<<1 = 84
42<<2 = 168
42<<4 = 672

---

Desplazamiento a la derecha (>>)

El operador de desplazamiento a la derecha >> mueve los bits hacia la derecha. El primer operando se desplaza el número de bits especificado por el segundo operando.

En decimal, equivale a:

floor(num / 2^bits)

Ejemplo con 42:

42 >> 1 = 21 (010101)
42 >> 2 = 10 (001010)
42 >> 4 = 2 (000010)

Ejemplo 6: Desplazamiento a la derecha

using System;
namespace Operator {
    class RightShift {
        public static void Main(string[] args) {
            int number = 42;
            Console.WriteLine("{0}>>1 = {1}", number, number >> 1);
            Console.WriteLine("{0}>>2 = {1}", number, number >> 2);
            Console.WriteLine("{0}>>4 = {1}", number, number >> 4);
        }
    }
}

Salida:

42>>1 = 21
42>>2 = 10
42>>4 = 2