I denne vejledning lærer du om forskellige bitvise operationer i Swift. Disse bruges til beregning af bitniveau i et udtryk.
En smule bruges til at betegne et binært ciffer. Et binært ciffer kan have to mulige værdier, enten 0 eller 1. Som begynderniveau-programmør behøver du ikke arbejde med operationer på bitniveau.
At arbejde med primitive datatyper som: heltal, float, boolsk, streng osv. Er nok. Du skal muligvis arbejde på bitniveau, når du har at gøre med programmering på lavt niveau.
Swift giver et rigt sæt operatører, bortset fra grundlæggende operatører, til at manipulere bits. Disse operatorer ligner de logiske operatorer, bortset fra at de arbejder på binære repræsentationer af data (bits).
Bitvis operatorer er operatorer, der bruges til at ændre individuelle bits i en operand. Operand er en variabel eller konstant, hvor operationen udføres.
Alle bitvise operatører, der er tilgængelige hurtigt, er angivet nedenfor:
1. Bitvis IKKE operatør
Det er repræsenteret med tilde- ~tegn og kan anvendes på en enkelt operand. Dette inverterer alle bits. dvs. ændrer 1 til 0 og 0 til 1.
Hvis x er en variabel / konstant, der har binær værdi, dvs. 0 eller 1. Den bitvise ikke-operation på x-variablen kan vises i nedenstående tabel:
IKKE| x | ~ x |
|---|---|
| 0 | 1 |
| 1 | 0 |
Eksempel 1: Bitvis IKKE operator for usigneret heltal
let initalNumber:UInt8 = 1 let invertedNumber = ~initalNumber print(invertedNumber)
Når du kører ovenstående program, vil output være:
254
I ovenstående program er udsagnet let initalNumber:UInt8 = 1af typen Unsigneret int af størrelse 8 bit. Så 1 i decimal kan repræsenteres som 00000001i binær.
Den bitvise ikke-operator ændrer hele biten af en variabel eller konstant, bit 0 ændres til 1 og 1 til 0. Så invertedNumber indeholder bits 11111110. Efter konvertering af det til decimal repræsenteres det som 254. Så udsagnet print(invertedNumber)udsender 254 på skærmen.
Du kan også udføre bitvis operator direkte i bits som:
Eksempel 2: Bitvis IKKE operator i bits
let initialBits: UInt8 = 0b11111111 let invertedBits = ~initialBits print(invertedBits)
Når du kører ovenstående program, vil output være:
0
initialBits indeholder binær værdi, 11111111der svarer til 255 i decimal. For at repræsentere tallet i binært har vi 0bsom præfiks i bogstavet. Uden 0bsom et præfiks behandles det som et normalt heltal, og du får en overløbsfejl (UInt8 kan kun gemme numre fra 0 til 255).
Da vi har brugt bitvis ikke operator, ændrer den alle 1 til 0. Så konstant invertedBits indeholder, 00000000hvilket svarer til 0 in UInt8.
Eksempel 3: Bitvis IKKE operator for underskrevet heltal
let initalNumber:Int = 1 let invertedNumber = ~initalNumber print(invertedNumber)
Når du kører ovenstående program, vil output være:
-2
I ovenstående program kan 1 i decimal repræsenteres som 00000001i binær. Den bitvise ikke-operator ændrer hele biten af en variabel eller konstant, bit 0 ændres til 1 og 1 til 0. Så invertedNumber indeholder bits 11111110. Dette skal output 254 på skærmen. Men returnerer i stedet -2. Mærkeligt, ikke? Lad os undersøge nedenfor, hvordan dette skete.
let initalNumber:Int = 1er et underskrevet int, der kan indeholde både positive og negative heltal. Derfor, når vi ikke anvendte operator for et signeret heltal, kan den returnerede binære også repræsentere et negativt tal.
Hvordan fortolkede kompilatoren -2 som 11111110 binær?
Compileren brugte Two's komplement til at repræsentere heltal. For at få de to komplement negative notation af et heltal, skal du først skrive tallet ud i binær, derefter vende cifrene og tilføje en til resultatet.
Trin til at finde ud af Two's supplement på -2 :
- Skriv 2 i binær form:
00000010 - Inverter cifrene. 0 bliver 1 og 1 bliver 0:
11111101 - Tilføj 1:
11111110
Sådan fortolker kompilator binært tal 1111110som -2decimal. Men der er et lille twist, som kompilatoren lavede, som vi ikke bemærkede. Det udledte også typen af inverteret nummer som Int8type.
Lad os se et eksempel nedenfor for at forstå dette:
print(Int8(bitPattern: 0b11111110)) print(0b11111110)
Når du kører ovenstående program, vil output være:
-2 254
I ovenstående eksempel behandlede kompilatoren det binære tal til -2 i decimal kun for det underskrevne 8-bit heltal. Derfor print(Int8(bitPattern: 0b11111110))udsender udsagn -2 på skærmen.
Men for den normale heltalstype, hvis størrelse er 32/64 bit og kan indeholde store værdier, fortolker den værdien som 254. Derfor print(0b11111110)udsender udsagn 254 på skærmen.
2. Bitvis OG operatør
Det er repræsenteret af &og kan anvendes på to operander. AND-operatoren sammenligner to bits og returnerer 1, hvis begge bits er 1, ellers returnerer 0.
Hvis x og y er variabel / konstant, der har binær værdi, dvs. 0 eller 1. Bitvis AND-operation på x og y kan repræsenteres i nedenstående tabel:
OG| x | y | x & y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
| 1 | 0 | 0 |
Eksempel 5: Bitvis OG drift
let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits & yBits print("Binary:",String(result, radix: 2)) print(result)
Når du kører ovenstående program, vil output være:
Binær: 10000011 131
I ovenstående program let result = xBits & yBitskombinerer udsagnet bits af to operander xBits og yBits. Det returnerer 1, det er begge bits 1, ellers returnerer det 0.
String(value , radix: )initializer bruges til at repræsentere nummer i forskellige nummersystemer. Hvis vi leverer radixværdi 2. Det konverterer tallet til binært talesystem. På samme måde kan vi bruge 16 til hex og 10 til decimal.
Erklæringen print("Binary:",String(result, radix: 2))udsender Binary: 10000011 på skærmen. 10000011svarer til 131 i decimal, udsagnet print(result)udsender 131 i konsollen.
3. Bitvis ELLER operatør
Det er repræsenteret som |og kan anvendes på to operander. Bitvis ELLER-operator sammenligner to bits og genererer et resultat på 1, hvis en eller flere af dens indgange er 1 ellers 0.
Hvis x og y er variabel / konstant, der har binær værdi, dvs. 0 eller 1. Bitvis ELLER-operation på x og y kan repræsenteres i nedenstående tabel:
ELLER| x | y | x | y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 1 |
| 1 | 0 | 1 |
Eksempel 6: Bitvis ELLER drift
let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits | yBits print("Binary:", String(result, radix: 2)) print(result)
Når du kører ovenstående program, vil output være:
Binær: 11111111 255
I ovenstående program let result = xBits | yBitskombinerer udsagnet bits af to konstanter xBits og yBits. Den returnerer 1, hvis nogen af bitene er 1, ellers returnerer den 0.
Erklæringen print("Binary:",String(result, radix: 2))udsender Binary: 11111111 på skærmen. Da 11111111det svarer til 255i decimal, print(result)udsender udsagnet 255 på skærmen.
4. Bitvis XOR-operatør
Det er repræsenteret som ^og kan anvendes på to operander. XOR-operatøren sammenligner to bits og genererer et resultat på 1, hvis nøjagtigt en af dens indgange er 1, ellers returnerer den 0.
Hvis x og y er variabel / konstant, der har binær værdi, dvs. 0 eller 1. Bitvis XOR-operationen på x og y kan repræsenteres i nedenstående tabel:
XOR| x | y | x y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 0 |
| 1 | 0 | 1 |
Eksempel 7: Bitvis XOR-drift
let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits yBits print("Binary:", String(result, radix: 2)) print(result)
Når du kører ovenstående program, vil output være:
Binær: 1111100 124
I ovenstående program let result = xBits yBitskombinerer udsagnet bits af to konstanter xBits og yBits. Det returnerer 1, hvis nøjagtigt et af bitene er 1, ellers returnerer det 0.
Erklæringen print("Binary:",String(result, radix: 2))udsender Binær: 1111100 (svarende til 01111100) på skærmen. Da 1111100det svarer til 124i decimal, print(result)udsender udsagnet 124 på skærmen.
5. Bitvis skiftoperatør
Denne operator bruges til at flytte alle bits i et tal til venstre eller højre et bestemt antal steder og kan anvendes på en enkelt operand. Det er repræsenteret som <<eller >>.
Der er to slags skiftoperatører:
Bitvis venstre skiftoperatør
- Betegnet som
<< - Det får bits til at blive skiftet til venstre angivet af antallet efterfulgt af
<<. - De bitpositioner, der er forladt af skiftoperationen, er udfyldt nul.
- At skifte et heltal bits til venstre med en position fordobler dens værdi
Eksempel 8: Bitvis venstre skiftoperatør
let someBits:UInt8 = 0b11000100 print(someBits << 1)
Når du kører ovenstående program, vil output være:
136
I ovenstående program har vi brugt venstre skiftoperatør. Brug af <<1 betyder at skifte bit med 1 til venstre. Cifrene flyttes til venstre med en position, og det sidste ciffer til højre udfyldes med et nul.
Du kan også se det ciffer, der skiftes "fra slutningen" fra venstre side, går tabt. Det ombrydes ikke igen fra højre. Ved at skifte den en bit til venstre fjernes 1 fra binæren og tilføjes 0 i højre for at udfylde den forskudte værdi, ligesom resten af de andre bits forskydes mod venstre position med 1.
Dette returnerer, 10001000hvilket svarer til 136in UInt8. Derfor print(someBits << 1)udsender udsagn 136 på skærmen.
Bitvis højre skiftoperatør
- Betegnet som
>> - Det får bits til at blive skiftet til højre af antallet efterfulgt af
>> - For ikke-underskrevne numre er bitpositionerne, der er fraflyttet af skiftoperationen, nulfyldte.
- For underskrevne numre (tal, der også kan være negative), bruges tegnbit til at udfylde de ledige bitpositioner. Med andre ord, hvis tallet er positivt, anvendes 0, og hvis tallet er negativt, bruges 1.
- Hvis du flytter den til højre med en position, halveres dens værdi.
Eksempel 9: Bitvis højre skiftoperator for usigneret heltal
let someBits: UInt8 = 4 print(someBits>> 1)
Når du kører ovenstående program, vil output være:
2
I ovenstående program har vi brugt højre skiftoperatør på et usigneret heltal. Brug af >>1 betyder at skifte bit med 1 til højre. De bitpositioner, der er forladt af skiftoperationen, udfyldes altid nul på et usigneret heltal.
Siden er 4 repræsenteret som 00000100i binær. Hvis du skifter det en smule til højre, returneres, 00000010hvilket svarer til 2in UInt8. Derfor print(someBits>> 1)udsender udsagn 2 på skærmen.
Eksempel 10: Bitvis højre skiftoperatør for underskrevet heltal
let someBits:Int = -4 print(someBits>> 1)
Når du kører ovenstående program, vil output være:
-2
I ovenstående program har vi brugt højre skiftoperatør på et usigneret heltal. I modsætning til positive tal bruges >>1 til at udfylde det ledige sted i stedet for 0 ved at bruge til negative tal.
Siden -4er repræsenteret som 11111100i binær. Shifting det én bit til højre og placere 1 i ledig stilling, returnerer 11111110hvilket svarer til -2for Int8type. Derfor print(someBits>> 1)udsender udsagn -2 på skærmen.
