Opérateurs de décalage de bits et de bits C #

Les opérateurs de bits et de décalage de bits sont utilisés pour effectuer des opérations au niveau des bits sur des données entières (int, long, etc.) et booléennes. Ces opérateurs ne sont pas couramment utilisés dans des situations réelles.

Si vous souhaitez en savoir plus, visitez les applications pratiques des opérations au niveau du bit.

Les opérateurs de bits et de décalage de bits disponibles en C # sont répertoriés ci-dessous.

Liste des opérateurs binaires C #
Opérateur Nom de l’opérateur
~ Complément au niveau du bit
& ET au niveau du bit
| OU au niveau du bit
^ OU exclusif au niveau du bit (XOR)
<< Décalage gauche au niveau du bit
>> Décalage vers la droite au niveau du bit

OU au niveau du bit

L’opérateur OR au niveau du bit est représenté par | . Il effectue une opération OU au niveau du bit sur les bits correspondants de deux opérandes. Si l’un des bits est 1 , le résultat est 1 . Sinon, le résultat est 0 .

Si les opérandes sont de type bool , l’opération OR au niveau du bit équivaut à l’opération OR logique entre eux.

Par exemple,

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

Bitwise OR fonctionnement entre 14 et 11:

00001110
00001011
--------
00001111 = 15 (en décimal)

Exemple 1: OU au niveau du 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);
		}
	}
}
 

Lorsque nous exécutons le programme, la sortie sera:

14 | 11 = 15

ET au niveau du bit

L’opérateur AND au niveau du bit est représenté par & . Il effectue une opération ET au niveau du bit sur les bits correspondants de deux opérandes. Si l’un des bits est 0 , le résultat est 0 . Sinon, le résultat est 1 .

Si les opérandes sont de type bool , l’opération ET au niveau du bit équivaut à l’opération ET logique entre eux.

Par exemple,

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

Opération ET au niveau du bit entre 14 et 11:

00001110
00001011
--------
00001010 = 10 (en décimal)

Exemple 2: ET au niveau du 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);
		}
	}
}
 

Lorsque nous exécutons le programme, la sortie sera:

14 & 11 = 10

XOR au niveau du bit

L’opérateur XOR au niveau du bit est représenté par ^ . Il effectue une opération XOR au niveau du bit sur les bits correspondants de deux opérandes. Si les bits correspondants sontmême, le résultat est 0 . Si les bits correspondants sontdifférent, le résultat est 1 .

Si les opérandes sont de type bool , l’opération XOR au niveau du bit est équivalente à l’opération XOR logique entre eux.

Par exemple,

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

Opération XOR au niveau du bit entre 14 et 11:

00001110
00001011
--------
00000101 = 5 (en décimal)

Si vous voulez en savoir plus sur l’utilisation de Bitwise XOR, visitez The Magic of XOR

Exemple 3: XOR au niveau du 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);
		}
	}
}
 

Lorsque nous exécutons le programme, la sortie sera:

14 ^ 11 = 5

Complément au niveau du bit

L’opérateur Complément au niveau du bit est représenté par ~ . C’est un opérateur unaire, c’est-à-dire qu’il n’opère que sur un seul opérande. le ~ opérateurinversechaque bit, c’est-à-dire change 1 en 0 et 0 en 1.

Par exemple,

26 = 00011010 (en binaire)

Opération de complément au niveau du bit sur 26:

~ 00011010 = 11100101 = 229 (en décimal)

Exemple 4: Complément au niveau du 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);
		}
	}
}
 

Lorsque nous exécutons le programme, la sortie sera:

~26 = -27

Nous avons – 27 comme sortie quand on attendait 229 . Pourquoi est-ce arrivé?

Cela arrive parce que la valeur binaire 11100101 ce que nous attendons d’être 229 est en fait une représentation complémentaire de 2 de -27 . Les nombres négatifs en informatique sont représentés dans la représentation du complément à 2.

Pour tout entier n, le complément de 2 de n sera -(n+1) .

Complément de 2
Décimal Binaire Complément 2
0 00000000 – (11111111 + 1) = -00000000 = -0 (en décimal)
1 00000001 – (11111110 + 1) = -11111111 = -256 (en décimal)
229 11100101 -(00011010 + 1) = -00011011 = -27

Les valeurs de débordement sont ignorées dans le complément de 2.

Le complément bit à bit de 26 est 229 (en décimal) et le complément à 2 de 229 est -27 . Par conséquent, la sortie est -27 au lieu de 229 .


Décalage gauche au niveau du bit

L’opérateur de décalage gauche au niveau du bit est représenté par << . le << L’opérateur décale un nombre vers la gauche d’un nombre spécifié de bits. Des zéros sont ajoutés aux bits les moins significatifs.

En décimal, il équivaut à

num * 2bits

Par exemple,

42 = 101010 (en binaire)

Opération Bitwise Lift Shift sur 42:

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

Exemple 5: Décalage gauche au niveau du bit

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

Lorsque nous exécutons le programme, la sortie sera:

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

Décalage vers la droite au niveau du bit

L’opérateur de décalage gauche au niveau du bit est représenté par >> . le >> L’opérateur décale un nombre vers la droite d’un nombre spécifié de bits. Le premier opérande est décalé vers la droite du nombre de bits spécifié par le second opérande.

En décimal, il équivaut à

étage (nombre / 2 bits)

Par exemple,

42 = 101010 (en binaire)

Opération de décalage de levage au niveau du bit sur 42:

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

Exemple 6: décalage vers la droite au niveau du bit

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