C# Bitwise en Bit Shift Operators

In deze tutorial leren we in detail over bitwise en bit shift operators in C#. C# biedt 4 bitwise en 2 bit shift operators.

Bitwise en bit shift operators worden gebruikt om operaties op bitniveau uit te voeren op gehele getallen (int, long, etc.) en booleaanse data. Deze operators worden niet vaak in de praktijk gebruikt.

Als u geïnteresseerd bent in praktische toepassingen, bekijk dan praktische toepassingen van bitwise operaties.

De beschikbare bitwise en bit shift operators in C# zijn:

Bitwise OR

De Bitwise OR operator wordt voorgesteld door |. Het voert een bitwise OR operatie uit op de overeenkomende bits van twee operanden. Als een van de bits 1 is, is het resultaat 1. Anders is het resultaat 0.

Als de operanden van het type bool zijn, is de bitwise OR operatie equivalent aan een logische OR operatie tussen hen.

Voorbeeld:

14 = 00001110 (In Binair)
11 = 00001011 (In Binair)

Bitwise OR operatie tussen 14 en 11:

00001110
00001011
--------
00001111 = 15 (In Decimaal)

Voorbeeld 1: Bitwise OR

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);
        }
    }
}

Bij uitvoering:

14 | 11 = 15

Bitwise AND

De Bitwise AND operator wordt voorgesteld door &. Het voert een bitwise AND operatie uit op de overeenkomende bits van twee operanden. Als een van de bits 0 is, is het resultaat 0. Anders is het resultaat 1.

Bij bool operanden is dit equivalent aan logische AND.

Voorbeeld:

14 = 00001110 (In Binair)
11 = 00001011 (In Binair)

Bitwise AND operatie tussen 14 en 11:

00001110
00001011
--------
00001010 = 10 (In Decimaal)

Voorbeeld 2: Bitwise AND

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);
        }
    }
}

Bij uitvoering:

14 & 11 = 10

Bitwise XOR

De Bitwise XOR operator wordt voorgesteld door ^. Het voert een bitwise XOR operatie uit op de overeenkomende bits van twee operanden. Als de overeenkomende bits hetzelfde zijn, is het resultaat 0. Als ze verschillend zijn, is het resultaat 1.

Bij bool operanden is dit equivalent aan logische XOR.

Voorbeeld:

14 = 00001110 (In Binair)
11 = 00001011 (In Binair)

Bitwise XOR operatie tussen 14 en 11:

00001110
00001011
--------
00000101 = 5 (In Decimaal)

Meer over XOR toepassingen vindt u in "The Magic of XOR".

Voorbeeld 3: Bitwise XOR
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);
        }
    }
}
Bij uitvoering:
14 ^ 11 = 5



Bitwise Complement
De Bitwise Complement operator wordt voorgesteld door ~. Het is een unaire operator, d.w.z. het werkt op slechts één operand. De ~ operator inverteert elke bit: 1 wordt 0 en 0 wordt 1.
Voorbeeld:
26 = 00011010 (In Binair)
Bitwise Complement operatie op 26:
~ 00011010 = 11100101 = 229 (In Decimaal)

Voorbeeld 4: Bitwise Complement
using System;
namespace Operator {
    class BitWiseComplement {
        public static void Main(string[] args) {
            int number = 26, result;
            result = ~number;
            Console.WriteLine("~{0} = {1}", number, result);
        }
    }
}
Bij uitvoering:
~26 = -27
We kregen -27 als output terwijl we 229 verwachtten. Waarom?
Dit komt doordat de binaire waarde 11100101 (die we verwachten als 229) eigenlijk een 2's complement representatie is van -27. Negatieve getallen in computers worden voorgesteld in 2's complement.
Voor elk integer n, is de 2's complement van n gelijk aan -(n+1).


2's Complement

Decimaal
Binair
2's Complement


0
00000000
-(11111111 + 1) = -00000000 = -0
1
00000001
-(11111110 + 1) = -11111111 = -256
229
11100101
-(00011010 + 1) = -00011011 = -27


Overloopwaarden worden genegeerd in 2's complement.
De bitwise complement van 26 is 229 (decimaal) en de 2's complement van 229 is -27. Daarom is de output -27 in plaats van 229.



Bitwise Left Shift
De Bitwise left shift operator wordt voorgesteld door <<. De << operator verschuift een getal naar links met een opgegeven aantal bits. Nullen worden toegevoegd aan de minst significante bits.
In decimaal is dit equivalent aan:
num * 2^bits
Voorbeeld:
42 = 101010 (In Binair)
Bitwise Left Shift operatie op 42:
42 << 1 = 84 (In binair 1010100)
42 << 2 = 168 (In binair 10101000)
42 << 4 = 672 (In binair 1010100000)

Voorbeeld 5: Bitwise Left Shift
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);
        }
    }
}
Bij uitvoering:
42<<1 = 84
42<<2 = 168
42<<4 = 672



Bitwise Right Shift
De Bitwise right shift operator wordt voorgesteld door >>. De >> operator verschuift een getal naar rechts met een opgegeven aantal bits. De eerste operand wordt naar rechts verschoven met het aantal bits gespecificeerd door de tweede operand.
In decimaal is dit equivalent aan:
floor(num / 2^bits)
Voorbeeld:
42 = 101010 (In Binair)
Bitwise Right Shift operatie op 42:
42 >> 1 = 21 (In binair 010101)
42 >> 2 = 10 (In binair 001010)
42 >> 4 = 2 (In binair 000010)

Voorbeeld 6: Bitwise Right Shift
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);
        }
    }
}
Bij uitvoering:
42>>1 = 21
42>>2 = 10
42>>4 = 2