V tej vadnici bomo podrobno izvedeli o bitnih in bitnih premikih v C #. C # ponuja 4 bitne in 2 bitne operaterje premika.
Operatorji bitnih in bitnih premikov se uporabljajo za izvajanje operacij bitne ravni na celoštevilnih (int, long itd.) In logičnih podatkih. Ti operaterji se pogosto ne uporabljajo v resničnih življenjskih situacijah.
Če želite raziskati več, obiščite praktične aplikacije bitnih operacij.
Operatorji bitnega in bitnega premika, ki so na voljo v jeziku C #, so navedeni spodaj.
Seznam bitnih operaterjev C #| Operater | Ime operaterja |
|---|---|
| ~ | Bitno dopolnilo |
| & | Bitovno AND |
| | | Bitovno ALI |
| ^ | Bitno izključno ALI (XOR) |
| << | Bitwise Left Shift |
| >> | Bit-Right Shift |
Bitovno ALI
Bitni operater OR predstavlja |. Izvaja bitno ALI operacijo na ustreznih bitih dveh operandov. Če je kateri od bitov 1, je rezultat 1. V nasprotnem primeru je rezultat 0.
Če so operandi tipa bool, je bitna operacija OR enakovredna logični operaciji ALI med njima.
Na primer,
14 = 00001110 (v binarni obliki) 11 = 00001011 (v binarni obliki)
Bitno ORdelovanje med 14 in 11:
00001110 00001011 -------- 00001111 = 15 (v decimalni obliki)
Primer 1: Bitno ALI
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); ) ) )
Ko zaženemo program, bo rezultat:
14 | 11 = 15
Bitovno AND
Bitni operater AND predstavlja &. Izvaja bitno operacijo AND na ustreznih bitih dveh operandov. Če je kateri od bitov 0, je rezultat 0. V nasprotnem primeru je rezultat 1.
Če so operandi tipa bool, je bitna operacija AND enakovredna logični operaciji AND med njimi.
Na primer,
14 = 00001110 (v binarni obliki) 11 = 00001011 (v binarni obliki)
Bitno delovanje AND med 14 in 11:
00001110 00001011 -------- 00001010 = 10 (v decimalni obliki)
Primer 2: Bitno 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); ) ) )
Ko zaženemo program, bo rezultat:
14 in 11 = 10
Bitno XOR
Bitno XOR operator predstavlja ^. Izvaja bitno operacijo XOR na ustreznih bitih dveh operandov. Če so ustrezni biti enaki , je rezultat 0. Če so ustrezni biti drugačni , je rezultat 1.
Če so operandi tipa bool, je bitna operacija XOR enakovredna logični operaciji XOR med njimi.
Na primer,
14 = 00001110 (v binarni obliki) 11 = 00001011 (v binarni obliki)
Bitno XOR delovanje med 14 in 11:
00001110 00001011 -------- 00000101 = 5 (v decimalni obliki)
Če želite več o uporabi Bitwise XOR, obiščite The Magic of XOR
Primer 3: Bitni 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); ) ) )
Ko zaženemo program, bo rezultat:
14 11 = 5
Bitno dopolnilo
Operator bitnega komplementa predstavlja ~. Je unarni operater, torej deluje samo na enem operandu. ~Operator obrne vsak bitov pravi spremembe 1-0 in 0 do 1.
Na primer,
26 = 00011010 (v binarni obliki)
Postopek bitnega komplementa na 26:
~ 00011010 = 11100101 = 229 (v decimalni obliki)
Primer 4: Bitno dopolnilo
using System; namespace Operator ( class BitWiseComplement ( public static void Main(string() args) ( int number = 26, result; result = ~number; Console.WriteLine("~(0) = (1)", number, result); ) ) )
Ko zaženemo program, bo rezultat:
~ 26 = -27
Dobili smo - 27kot rezultat, ko smo pričakovali 229. Zakaj se je to zgodilo?
To se zgodi zato, ker je binarna vrednost, za 11100101katero pričakujemo, da 229je dejansko predstavitev komplementa 2 -27. Negativne številke v računalniku so predstavljene v predstavitvi komplementa 2.
Za vsako celo število n, 2 je dopolnilo nbo -(n+1).
| Decimalno | Binarno | Dopolnilo 2 |
|---|---|---|
| 0 | 00000000 | - (11111111 + 1) = -00000000 = -0 (v decimalnem) |
| 1. | 00000001 | - (11111110 + 1) = -11111111 = -256 (v decimalnih številkah) |
| 229 | 11100101 | - (00011010 + 1) = -00011011 = -27 |
Vrednosti prelivanja so v dodatku 2 prezrte.
Bitno dopolnilo 26je 229 (v decimalni številki), dopolnilo 2 pa 229je -27. Zato je rezultat -27namesto 229.
Bitwise Left Shift
Bitni levi premik je predstavljen z <<. <<Operater premiki število na po določenem številu bitov v levo. Ničle se dodajo najmanj pomembnim bitom.
V decimalki je enakovredno
število * 2bita
Na primer,
42 = 101010 (v binarni obliki)
Delovanje premika v bitovni smeri na 42:
42 << 1 = 84 (v binarni 1010100) 42 << 2 = 168 (v binarni 10101000) 42 << 4 = 672 (v binarni 1010100000)
Primer 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); ) ) )
Ko zaženemo program, bo rezultat:
42 << 1 = 84 42 << 2 = 168 42 << 4 = 672
Bit-Right Shift
Bitni levi premik je predstavljen z >>. >>Operater premakne številko v desno za določeno število bitov. Prvi operand se premakne v desno za število bitov, ki ga določi drugi operand.
V decimalki je enakovredno
nadstropje (število / 2 bita)
Na primer,
42 = 101010 (v binarni obliki)
Delovanje premika v bitovni smeri na 42:
42 >> 1 = 21 (v binarni 010101) 42 >> 2 = 10 (v binarni 001010) 42 >> 4 = 2 (v binarni 000010)
Primer 6: Bit-premik v desno
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); ) ) )
Ko zaženemo program, bo rezultat:
42 >> 1 = 21 42 >> 2 = 10 42 >> 4 = 2
