Selles õpetuses õpime üksikasjalikult biti- ja bitinihkeoperaatorite kohta C # -s. C # pakub 4 bitise ja 2 bitise nihkeoperaatorit.
Biti- ja bitinihkeoperaatoreid kasutatakse täisarvu (int, pikk jne) ja tõeväärtuse andmete bititaseme toimingute tegemiseks. Neid operaatoreid ei kasutata tavaliselt reaalses elus.
Kui soovite rohkem uurida, külastage bitipõhiste toimingute praktilisi rakendusi.
Allpool on loetletud C #-s saadaval olevad biti- ja bitinihkeoperaatorid.
C # bitipõhiste operaatorite loend| Operaator | Operaatori nimi |
|---|---|
| ~ | Bitipõhine täiendus |
| & | Pikkade kaupa JA |
| | | Piki VÕI |
| ^ | Bitipõhine eksklusiivne VÕI (XOR) |
| << | Nuppude kaupa vasakpoolne nihe |
| >> | Parempoolne nihe paremale |
Piki VÕI
Biti kaupa VÕI operaatorit tähistab |. See teostab kahe operandi vastavate bittide bittide kaupa VÕI operatsiooni. Kui üks neist on 1, on tulemus 1. Muidu on tulemus 0.
Kui operandid on tüüpi bool, on bitipõhine VÕI operatsioon samaväärne nende vahelise loogilise VÕI toiminguga.
Näiteks,
14 = 00001110 (binaarses vormingus) 11 = 00001011 (binaarses vormingus)
Piki liikumine ORvahemikus 14 kuni 11:
00001110 00001011 -------- 00001111 = 15 (kümnendkohaga)
Näide 1: bitipõhine VÕI
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); ) ) )
Programmi käivitamisel on väljund:
14 | 11 = 15
Pikkade kaupa JA
Biti kaupa AND-operaatorit tähistab &. See teostab kahe operandi vastavate bittide bitti ja operatsiooni. Kui üks neist on 0, on tulemus 0. Muidu on tulemus 1.
Kui operandid on tüüpi bool, on bitipõhine JA operatsioon samaväärne nende vahelise loogilise JA operatsiooniga.
Näiteks,
14 = 00001110 (binaarses vormingus) 11 = 00001011 (binaarses vormingus)
Piki kaupa JA toimimine vahemikus 14 kuni 11:
00001110 00001011 -------- 00001010 = 10 (kümnendkohaga)
Näide 2: bitipõhiselt JA
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); ) ) )
Programmi käivitamisel on väljund:
14 ja 11 = 10
Piki XOR
Operatsiooni Bitwise XOR tähistab ^. See teostab XOR-operatsiooni bitipidi kahe operandi vastavatel bittidel. Kui vastavad bitid on samad , on tulemus 0. Kui vastavad bitid on erinevad , on tulemus 1.
Kui operandid on tüüpi bool, on bitipõhine XOR-operatsioon samaväärne nende vahelise loogilise XOR-operatsiooniga.
Näiteks,
14 = 00001110 (binaarses vormingus) 11 = 00001011 (binaarses vormingus)
XOR-i toimimine bitipõhiselt vahemikus 14 kuni 11:
00001110 00001011 -------- 00000101 = 5 (kümnendkohaga)
Kui soovite Bitwise XOR-i kasutamise kohta lisateavet, külastage veebi The Magic of XOR
Näide 3: bitipõhine 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); ) ) )
Programmi käivitamisel on väljund:
14 11 = 5
Bitipõhine täiendus
Operaatorit Bitwise Complement tähistab ~. See on unaarne operaator, st opereerib ainult ühel operandil. ~Operaator pöörab iga bitti ehk muudab 1 kuni 0 ja 0 kuni 1.
Näiteks,
26 = 00011010 (binaarselt)
Bitipõhine täiendamine 26-ga:
~ 00011010 = 11100101 = 229 (kümnendkohaga)
Näide 4: täiendus bitipõhiselt
using System; namespace Operator ( class BitWiseComplement ( public static void Main(string() args) ( int number = 26, result; result = ~number; Console.WriteLine("~(0) = (1)", number, result); ) ) )
Programmi käivitamisel on väljund:
~ 26 = -27
Saime - 27väljundina, kui ootasime 229. Miks see juhtus?
See juhtub seetõttu, et binaarväärtus, 11100101mis me eeldame olevat, 229on tegelikult 2 komplemendi esitus -27. Negatiivsed arvud arvutis on esindatud 2 täiendina.
Iga täisarv n, 2 on täiendus non -(n+1).
| Kümnendkoht | Binaarne | 2 täiend |
|---|---|---|
| 0 | 00000000 | - (11111111 + 1) = -00000000 = -0 (kümnendkohaga) |
| 1 | 00000001 | - (11111110 + 1) = -11111111 = -256 (kümnendkohaga) |
| 229 | 11100101 | - (00011010 + 1) = -00011011 = -27 |
2 täiendis ignoreeritakse ülevoolu väärtusi.
Komplekti biti kaupa 26on 229 (kümnendkohaga) ja 2 komplemendiks 229on -27. Seega on väljund -27asemel 229.
Nuppude kaupa vasakpoolne nihe
Pikk vasakpoolse nihke operaatorit tähistab <<. <<Operaator nihutab numbri vasakule määratud bittide arv. Vähem olulistele bittidele lisatakse nullid.
Kümnendkohas on see samaväärne
num * 2bit
Näiteks,
42 = 101010 (binaarselt)
Tõste vahetuse toimimine bitipidi 42-ga:
42 << 1 = 84 (binaarse 1010100) 42 << 2 = 168 (binaarse 10101000) 42 << 4 = 672 (binaarse 1010100000)
Näide 5: vasakpoolne nihe bititi
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); ) ) )
Programmi käivitamisel on väljund:
42 << 1 = 84 42 << 2 = 168 42 << 4 = 672
Parempoolne nihe paremale
Pikk vasakpoolse nihke operaatorit tähistab >>. >>Operaator nihutab numbri paremalt poolt nimetatud arvu bitti. Esimene operand nihutatakse paremale teise operandi määratud bittide arvu võrra.
Kümnendkohas on see samaväärne
korrus (arv / 2bit)
Näiteks,
42 = 101010 (binaarselt)
Tõste vahetuse toimimine bitipidi 42-ga:
42 >> 1 = 21 (binaarses 010101) 42 >> 2 = 10 (binaarses 001010) 42 >> 4 = 2 (binaarses 000010)
Näide 6: parempoolne nihe paremale
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); ) ) )
Programmi käivitamisel on väljund:
42 >> 1 = 21 42 >> 2 = 10 42 >> 4 = 2
