Opérateurs de bits et de décalage de bits C#
Opérateurs C# au niveau du bit et de décalage de bit
Dans ce didacticiel, nous apprendrons en détail les opérateurs de décalage de bit et de bit en C#. C# fournit 4 opérateurs de décalage au niveau du bit et 2 bits.
Les opérateurs de bit à bit et de décalage de bit sont utilisés pour effectuer des opérations au niveau du bit 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, consultez les applications pratiques des opérations au niveau du bit.
Les opérateurs de bit à bit et de décalage de bit disponibles en C# sont répertoriés ci-dessous.
| Opérateur | Nom de l'opérateur |
|---|---|
| ~ | Complément binaire |
| & | ET au niveau du bit |
| | | OU au niveau du bit |
| ^ | OU exclusif bit à bit (XOR) |
| < | Décalage bit à gauche |
| >> | Décalage au niveau du bit vers la droite |
OU au niveau du bit
L'opérateur OU 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 OU au niveau du bit est équivalente à l'opération OU logique entre eux.
Par exemple,
14 = 00001110 (In Binary) 11 = 00001011 (In Binary)
OR au niveau du bit opération entre 14 et 11 :
00001110 00001011 -------- 00001111 = 15 (In Decimal)
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 ET 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 est équivalente à l'opération ET logique entre eux.
Par exemple,
14 = 00001110 (In Binary) 11 = 00001011 (In Binary)
Opération ET au niveau du bit entre 14 et 11 :
00001110 00001011 -------- 00001010 = 10 (In Decimal)
Exemple 2 :AND 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 sont identiques , le résultat est 0 . Si les bits correspondants sont différents , le résultat est 1 .
Si les opérandes sont de type bool , l'opération XOR au niveau du bit est équivalente à une opération XOR logique entre eux.
Par exemple,
14 = 00001110 (In Binary) 11 = 00001011 (In Binary)
Opération XOR au niveau du bit entre 14 et 11 :
00001110 00001011 -------- 00000101 = 5 (In Decimal)
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 binaire
L'opérateur Bitwise Complement est représenté par ~ . C'est un opérateur unaire, c'est-à-dire qu'il n'agit que sur un seul opérande. Le ~ l'opérateur inverse chaque bit, c'est-à-dire change de 1 à 0 et de 0 à 1.
Par exemple,
26 = 00011010 (In Binary)
Opération de complément au niveau du bit sur 26 :
~ 00011010 = 11100101 = 229 (In Decimal)
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 en sortie alors que nous attendions n . Pourquoi est-ce arrivé ?
Cela arrive parce que la valeur binaire 11100101 que nous prévoyons être n est en fait une représentation en complément à 2 de -27 . Les nombres négatifs dans l'ordinateur sont représentés dans la représentation du complément à 2.
Pour tout entier n, complément à 2 de n sera -(n+1) .
| 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épassement sont ignorées en complément à 2.
Le complément au niveau du 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 bit à gauche
L'opérateur de décalage à gauche au niveau du bit est représenté par << . Le << 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, cela équivaut à
num * 2bits
Par exemple,
42 = 101010 (In Binary)
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 vers la 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 bit à droite
L'opérateur de décalage vers la gauche au niveau du bit est représenté par >> . Le >> 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 deuxième opérande.
En décimal, cela équivaut à
floor(num / 2bits)
Par exemple,
42 = 101010 (In Binary)
Opération Bitwise Lift Shift 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);
}
}
}
Lorsque nous exécutons le programme, la sortie sera :
42>>1 = 21 42>>2 = 10 42>>4 = 2
Langue C