In questo tutorial apprenderemo in dettaglio gli operatori bit per bit e di spostamento di bit in C #. C # fornisce 4 operatori di spostamento bit per bit e 2 bit.
Gli operatori bit a bit e di spostamento di bit vengono utilizzati per eseguire operazioni a livello di bit su dati interi (int, long, ecc.) E booleani. Questi operatori non sono comunemente usati in situazioni di vita reale.
Se sei interessato a saperne di più, visita le applicazioni pratiche delle operazioni bit per bit.
Gli operatori bit per bit e di spostamento bit disponibili in C # sono elencati di seguito.
Elenco di operatori bit per bit C #| Operatore | Nome operatore |
|---|---|
| ~ | Bitwise Complement |
| & | Bitwise AND |
| | | OR bit per bit |
| ^ | OR esclusivo bit per bit (XOR) |
| << | Spostamento sinistro bit per bit |
| >> | Spostamento bit per bit destro |
OR bit per bit
L'operatore OR bit per bit è rappresentato da |. Esegue un'operazione OR bit per bit sui bit corrispondenti di due operandi. Se uno dei bit è 1, il risultato è 1. Altrimenti il risultato è 0.
Se gli operandi sono di tipo bool, l'operazione OR bit per bit è equivalente all'operazione OR logica tra di loro.
Per esempio,
14 = 00001110 (in binario) 11 = 00001011 (in binario)
OROperazione bit per bit tra 14 e 11:
00001110 00001011 -------- 00001111 = 15 (in decimale)
Esempio 1: OR bit per 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); ) ) )
Quando eseguiamo il programma, l'output sarà:
14 | 11 = 15
Bitwise AND
L'operatore AND bit per bit è rappresentato da &. Esegue un'operazione AND bit per bit sui bit corrispondenti di due operandi. Se uno dei bit è 0, il risultato è 0. Altrimenti il risultato è 1.
Se gli operandi sono di tipo bool, l'operazione AND bit per bit è equivalente all'operazione AND logica tra di loro.
Per esempio,
14 = 00001110 (in binario) 11 = 00001011 (in binario)
Operazione AND bit per bit tra 14 e 11:
00001110 00001011 -------- 00001010 = 10 (in decimali)
Esempio 2: AND bit per 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); ) ) )
Quando eseguiamo il programma, l'output sarà:
14 e 11 = 10
Bitwise XOR
L'operatore XOR bit per bit è rappresentato da ^. Esegue un'operazione XOR bit per bit sui bit corrispondenti di due operandi. Se i bit corrispondenti sono gli stessi , il risultato è 0. Se i bit corrispondenti sono diversi , il risultato è 1.
Se gli operandi sono di tipo bool, l'operazione XOR bit per bit è equivalente all'operazione XOR logica tra di loro.
Per esempio,
14 = 00001110 (in binario) 11 = 00001011 (in binario)
Operazione XOR bit per bit tra 14 e 11:
00001110 00001011 -------- 00000101 = 5 (in decimale)
Se vuoi saperne di più sull'utilizzo di Bitwise XOR, visita The Magic of XOR
Esempio 3: XOR bit per 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); ) ) )
Quando eseguiamo il programma, l'output sarà:
14 11 = 5
Bitwise Complement
L'operatore Bitwise Complement è rappresentato da ~. È un operatore unario, cioè opera su un solo operando. L' ~operatore inverte ogni bit, cioè cambia 1 in 0 e 0 in 1.
Per esempio,
26 = 00011010 (in binario)
Operazione Bitwise Complement il 26:
~ 00011010 = 11100101 = 229 (in decimale)
Esempio 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); ) ) )
Quando eseguiamo il programma, l'output sarà:
~ 26 = -27
Abbiamo ottenuto - 27come output quando ci aspettavamo 229. Perché è successo questo?
Succede perché il valore binario 11100101che ci aspettiamo 229sia in realtà una rappresentazione in complemento a 2 di -27. I numeri negativi nel computer sono rappresentati nella rappresentazione del complemento di 2.
Per ogni intero n, il complemento di 2 di nsarà -(n+1).
| Decimale | Binario | Complemento di 2 |
|---|---|---|
| 0 | 00000000 | - (11111111 + 1) = -00000000 = -0 (in decimale) |
| 1 | 00000001 | - (11111110 + 1) = -11111111 = -256 (in decimale) |
| 229 | 11100101 | - (00011010 + 1) = -00011011 = -27 |
I valori di overflow vengono ignorati nel complemento di 2.
Il complemento bit per bit di 26è 229 (in decimale) e il complemento a 2 di 229è -27. Quindi l'output è -27invece di 229.
Spostamento sinistro bit per bit
L'operatore di spostamento a sinistra bit per bit è rappresentato da <<. L' <<operatore sposta un numero a sinistra di un numero di bit specificato. Gli zeri vengono aggiunti ai bit meno significativi.
In decimale, è equivalente a
num * 2 bit
Per esempio,
42 = 101010 (in binario)
Operazione Lift Shift bit per bit su 42:
42 << 1 = 84 (In binario 1010100) 42 << 2 = 168 (In binario 10101000) 42 << 4 = 672 (In binario 1010100000)
Esempio 5: spostamento a sinistra bit per 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); ) ) )
Quando eseguiamo il programma, l'output sarà:
42 << 1 = 84 42 << 2 = 168 42 << 4 = 672
Spostamento bit per bit destro
L'operatore di spostamento a sinistra bit per bit è rappresentato da >>. L' >>operatore sposta un numero a destra di un numero di bit specificato. Il primo operando viene spostato a destra del numero di bit specificato dal secondo operando.
In decimale, è equivalente a
piano (num / 2 bit)
Per esempio,
42 = 101010 (in binario)
Operazione Lift Shift bit per bit su 42:
42 >> 1 = 21 (In binario 010101) 42 >> 2 = 10 (In binario 001010) 42 >> 4 = 2 (In binario 000010)
Esempio 6: spostamento a destra bit per 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); ) ) )
Quando eseguiamo il programma, l'output sarà:
42 >> 1 = 21 42 >> 2 = 10 42 >> 4 = 2
