Ebben az oktatóanyagban részletesen megismerhetjük a C # bites és biteltolásos operátorait. A C # 4 bitenkénti és 2 bites váltás operátort biztosít.
A bitenkénti és a biteltolásos operátorokat az egész (int, hosszú stb.) És logikai adatok bitszintű műveleteinek végrehajtására használják. Ezeket az operátorokat nem szokták használni való életben.
Ha további információkra kíváncsi, keresse fel a bitenkénti műveletek gyakorlati alkalmazását.
Az alábbiakban felsoroljuk a C # -ben elérhető bitenkénti és biteltolásos operátorokat.
C # bitenkénti operátorok listája| Operátor | Operátor neve |
|---|---|
| ~ | Bitenkénti kiegészítés |
| & | Bitenkénti ÉS |
| | | Bitenként VAGY |
| ^ | Bitenként exkluzív VAGY (XOR) |
| << | Bitenkénti bal váltás |
| >> | Bitenkénti jobb váltás |
Bitenként VAGY
A bitenkénti VAGY operátort a |. Két operandus megfelelő bitjein végez bitenkénti VAGY műveletet. Ha bármelyik bit megvan 1, akkor az eredmény 1. Egyébként az eredmény az 0.
Ha az operandusok típusúak bool, akkor a bitenkénti VAGY művelet egyenértékű a köztük lévő logikai VAGY művelettel.
Például,
14 = 00001110 (bináris) 11 = 00001011 (bináris)
Bitenkénti ORműködés 14 és 11 között:
00001110 00001011 -------- 00001111 = 15 (tizedesjegyben)
1. példa: Bitenként vagy VAGY
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); ) ) )
A program futtatásakor a kimenet a következő lesz:
14. | 11 = 15
Bitenkénti ÉS
A bitenkénti ÉS operátort a &. Két operandus megfelelő bitjein végez bitenkénti ÉS műveletet. Ha bármelyik bit megvan 0, akkor az eredmény 0. Egyébként az eredmény az 1.
Ha az operandusok típusúak bool, a bitenkénti ÉS művelet egyenértékű a köztük lévő logikai ÉS művelettel.
Például,
14 = 00001110 (bináris) 11 = 00001011 (bináris)
Bitenkénti ÉS művelet 14 és 11 között:
00001110 00001011 -------- 00001010 = 10 (tizedesjegyben)
2. példa: Bitenkénti ÉS
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); ) ) )
A program futtatásakor a kimenet a következő lesz:
14 és 11 = 10
Bitenként XOR
A Bitwise XOR operátort a ^. Bitenként XOR műveletet hajt végre két operandus megfelelő bitjein. Ha a megfelelő bitek megegyeznek , az eredmény az 0. Ha a megfelelő bitek eltérnek , az eredmény az 1.
Ha az operandusok típusúak bool, a bitenkénti XOR művelet egyenértékű a köztük lévő logikai XOR művelettel.
Például,
14 = 00001110 (bináris) 11 = 00001011 (bináris)
Bitenkénti XOR működés 14 és 11 között:
00001110 00001011 -------- 00000101 = 5 (tizedesjegyben)
Ha többet szeretne megtudni a Bitwise XOR használatáról, keresse fel a The Magic of XOR oldalt
3. példa: Bitenként 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); ) ) )
A program futtatásakor a kimenet a következő lesz:
14 11 = 5
Bitenkénti kiegészítés
A Bitwise Complement operátort a ~. Ez unárikus operátor, azaz csak egy operanduson működik. Az ~operátor megfordítja az egyes biteket, azaz 1-ről 0-ra és 0-ra 1-re változik.
Például,
26 = 00011010 (bináris formátumban)
Bitenkénti kiegészítés művelet 26-on:
~ 00011010 = 11100101 = 229 (tizedesjegyben)
4. példa: Bitenkénti kiegészítés
using System; namespace Operator ( class BitWiseComplement ( public static void Main(string() args) ( int number = 26, result; result = ~number; Console.WriteLine("~(0) = (1)", number, result); ) ) )
A program futtatásakor a kimenet a következő lesz:
~ 26 = -27
Kimenetként kaptuk 27, amikor számítottunk rá 229. Miért történt ez?
Azért történik, mert a bináris érték, 11100101amelyre számítunk, 229valójában egy 2-es komplementer ábrázolása -27. A negatív számok a számítógépen a 2-es komplementer reprezentációban vannak ábrázolva.
Bármely n egész szám esetén a 2 komplementere nlesz -(n+1).
| Decimális | Bináris | 2. kiegészítése |
|---|---|---|
| 0 | 00000000 | - (11111111 + 1) = -00000000 = -0 (tizedesjegyben) |
| 1 | 00000001 | - (11111110 + 1) = -11111111 = -256 (tizedesjegyben) |
| 229 | 11100101 | - (00011010 + 1) = -00011011 = -27 |
A túlcsordulási értékeket a 2. kiegészítés figyelmen kívül hagyja.
A bitenkénti komplementje 26229 (tizedesjegyben), a 2 komplementje pedig 229az -27. Ezért a kimenet -27helyett 229.
Bitenkénti bal váltás
A bitenkénti bal váltás operátorát a <<. Az <<operátor egy számot balra tol egy megadott bitszámmal. A legkevésbé jelentős bitekhez nullákat adunk.
Tizedesjegyben ez egyenértékű
num * 2bit
Például,
42 = 101010 (bináris formátumban)
Bitenkénti emelés váltás művelet 42-nél:
42 << 1 = 84 (bináris 1010100-ban) 42 << 2 = 168 (bináris 10101000-ben) 42 << 4 = 672 (bináris 1010100000-ben)
5. példa: Balra váltás balra
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); ) ) )
A program futtatásakor a kimenet a következő lesz:
42 << 1 = 84 42 << 2 = 168 42 << 4 = 672
Bitenkénti jobb váltás
A bitenkénti bal váltás operátorát a >>. Az >>operátor egy számot jobbra tol egy megadott bitszámmal. Az első operandust jobbra tolja a második operandus által meghatározott bitek száma.
Tizedesjegyben ez egyenértékű
emelet (szám / 2bit)
Például,
42 = 101010 (bináris formátumban)
Bitenkénti emelés váltás művelet 42-nél:
42 >> 1 = 21 (bináris 010101) 42 >> 2 = 10 (bináris 001010) 42 >> 4 = 2 (000010 bináris)
6. példa: Bitenkénti jobbra eltolás
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); ) ) )
A program futtatásakor a kimenet a következő lesz:
42 >> 1 = 21 42 >> 2 = 10 42 >> 4 = 2
