C# bitsgewijze en bitverschuivingsoperatoren

In deze zelfstudie leren we in detail over bitsgewijze en bitverschuivingsoperatoren in C#. C# biedt 4 bitsgewijze en 2 bit shift-operators.

Bitsgewijze en bitverschuivingsoperatoren worden gebruikt om bewerkingen op bitniveau uit te voeren op integer (int, long, enz.) en booleaanse gegevens. Deze operators worden niet vaak gebruikt in echte situaties.

Als je meer wilt weten, bezoek dan praktische toepassingen van bitsgewijze bewerkingen.

De bitsgewijze en bitverschuiving-operators die beschikbaar zijn in C# staan ​​hieronder vermeld.

Bitsgewijze OF

Bitwise OR-operator wordt weergegeven door | . Het voert een bitsgewijze OF-bewerking uit op de overeenkomstige bits van twee operanden. Als een van de bits 1 . is , het resultaat is 1 . Anders is het resultaat 0 .

Als de operanden van het type bool . zijn , de bitsgewijze OF-bewerking is gelijk aan de logische OF-bewerking ertussen.

Bijvoorbeeld,

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

Bitwise OR bediening tussen 14 en 11:

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

Voorbeeld 1:Bitsgewijze OF

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

Wanneer we het programma uitvoeren, is de uitvoer:

14 | 11 = 15

Bitwise AND

Bitsgewijze AND-operator wordt weergegeven door & . Het voert een bitsgewijze EN-bewerking uit op de overeenkomstige bits van twee operanden. Als een van de bits 0 . is , het resultaat is 0 . Anders is het resultaat 1 .

Als de operanden van het type bool zijn , de bitsgewijze AND-bewerking is gelijk aan de logische AND-bewerking ertussen.

Bijvoorbeeld,

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

Bitsgewijze EN-bewerking tussen 14 en 11:

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

Voorbeeld 2:Bitsgewijze EN

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

Wanneer we het programma uitvoeren, is de uitvoer:

14 & 11 = 10

Bitwise XOR

Bitwise XOR-operator wordt weergegeven door ^ . Het voert een bitsgewijze XOR-bewerking uit op de overeenkomstige bits van twee operanden. Als de corresponderende bits hetzelfde zijn , het resultaat is 0 . Als de corresponderende bits verschillend zijn , het resultaat is 1 .

Als de operanden van het type bool . zijn , is de bitsgewijze XOR-bewerking gelijk aan de logische XOR-bewerking ertussen.

Bijvoorbeeld,

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

Bitsgewijze XOR-bewerking tussen 14 en 11:

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

Als je meer wilt weten over het gebruik van Bitwise XOR, ga dan naar 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);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

14 ^ 11 = 5

Bitsgewijze aanvulling

Bitwise Complement-operator wordt weergegeven door ~ . Het is een unaire operator, d.w.z. werkt op slechts één operand. De ~ operator inverteert elke bit, d.w.z. verandert 1 in 0 en 0 in 1.

Bijvoorbeeld,

26 = 00011010 (In Binary)

Bitwise Complement-bewerking op 26:

~ 00011010 = 11100101 = 229 (In Decimal)

Voorbeeld 4:Bitsgewijze aanvulling

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

Wanneer we het programma uitvoeren, is de uitvoer:

~26 = -27

We hebben -27 als output toen we 229 verwachtten . Waarom is dit gebeurd?

Het gebeurt omdat de binaire waarde 11100101 waarvan we verwachten 229 is eigenlijk een 2's complement-representatie van -27 . Negatieve getallen in de computer worden weergegeven in de complementrepresentatie van 2.

Voor elk geheel getal n, 2's complement van n wordt -(n+1) .

Overloopwaarden worden genegeerd in het complement van 2.

Het bitsgewijze complement van 26 is 229 (in decimaal) en het 2-complement van 229 is -27 . De output is dus -27 in plaats van 229 .

Bitsgewijze verschuiving naar links

De operator voor bitsgewijze linkerploeg wordt weergegeven door << . De << operator verschuift een getal met een bepaald aantal bits naar links. Nullen worden toegevoegd aan de minst significante bits.

In decimaal is het gelijk aan

num * 2bits

Bijvoorbeeld,

42 = 101010 (In Binary)

Bitwise Lift Shift-bediening op 42:

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

Voorbeeld 5:Bitsgewijze verschuiving naar links

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

Wanneer we het programma uitvoeren, is de uitvoer:

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

Bitsgewijze verschuiving naar rechts

De operator voor bitsgewijze linkerploeg wordt weergegeven door >> . De >> operator verschuift een getal met een bepaald aantal bits naar rechts. De eerste operand wordt naar rechts verschoven met het aantal bits gespecificeerd door de tweede operand.

In decimaal is het gelijk aan

floor(num / 2bits)

Bijvoorbeeld,

42 = 101010 (In Binary)

Bitwise Lift Shift-bediening op 42:

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

Voorbeeld 6:Bitsgewijze verschuiving naar rechts

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

Wanneer we het programma uitvoeren, is de uitvoer:

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