bitenkénti Operatorok C-ben: ÉS, VAGY, XOR, Shift & Kiegészítés
Benjamin walker
⚡ Okos összefoglaló
A C nyelvben a bitenkénti operátorok az adatokat bitenként manipulálják, ÉS, VAGY, XOR, komplementer és eltolás műveleteket használva egész operandusokon a gyorsabb számítások végrehajtásához, a jelzők csomagolásához és a hardver vezérléséhez alacsony szintű és beágyazott programozásban.
Mik azok a Bitwise Operators?
bitenkénti OperaA programozókat (tors) az adatok bit szintű manipulálására használják, más néven bitszintű programozásra. A bitenkénti műveletek egy vagy több bitmintán vagy bináris számon működnek az egyes bitek szintjén. Numerikus számításokban használják őket a számítási folyamat felgyorsítására.
Az alábbiakban a 'C' programozási nyelv által biztosított bitenkénti operátorok listája található:
| Operator | Jelentés |
|---|---|
| & | Bitenkénti ÉS operátor |
| | | Bitenkénti VAGY operátor |
| ^ | Bitenkénti kizárólagos VAGY operátor |
| ~ | A bináris egyes komplementere OperaA tor egy unáris operátor |
| << | Bal váltókezelő |
| >> | Jobb váltókezelő |
A bitenkénti operátorok nem alkalmazhatók közvetlenül primitív adattípusokra, mint például a float, double stb. Mindig emlékezz arra, hogy a bitenkénti operátorokat többnyire a következővel használják: egész adattípus a kompatibilitása miatt.
A bitenkénti logikai operátorok bitenként dolgoznak az adatokon, kezdve a legkisebb jelentőségű bittől, azaz az LSB bittől, amely a jobb szélső bit, és az MSB (Most Significant Bit) felé haladva, amely a bal szélső bit.
A bitenkénti logikai operátorok számításának eredményét az alábbi táblázat mutatja.
| x | y | x & y | x | és | x^y |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
Bitálisan ÉS
Ez az egyik leggyakrabban használt logikai bitenkénti operátor. Ezt egyetlen „és” jel (&) jelöli. Két egész kifejezést írunk az (&) operátor mindkét oldalára.
A bitenkénti ÉS művelet eredménye 1, ha mindkét bit értéke 1; egyébként az eredmény mindig 0.
Tekintsük, hogy van 2 op1 és op2 változónk a következő értékekkel:
Op1 = 0000 1101 Op2 = 0001 1001
Az AND művelet eredménye az op1 és op2 változókon lesz
Result = 0000 1001
Amint látjuk, két változót bitenként hasonlítanak össze. Ha a bit értéke mindkét változóban 1, akkor az eredmény 1 vagy 0 lesz.
Bitenként VAGY
Egyetlen függőleges oszlopjel (|) ábrázolja. Két egész kifejezést írunk a (|) operátor mindkét oldalára.
A bitenkénti VAGY művelet eredménye 1, ha legalább az egyik kifejezés értéke 1; egyébként az eredmény mindig 0.
Tekintsük, hogy van 2 op1 és op2 változónk a következő értékekkel:
Op1 = 0000 1101 Op2 = 0001 1001
Az op1 és op2 változókra vonatkozó VAGY művelet eredménye a következő lesz
Result = 0001 1101
Amint látjuk, két változót bitenként hasonlítanak össze. Ha az egyik változóban egy bit értéke 1, akkor az eredmény 1 vagy 0 lesz.
Bitenkénti exkluzív VAGY
Egy szimbólum (^) jelöli. Két egész kifejezést írunk a (^) operátor mindkét oldalára.
A bitenkénti Exclusive-OR művelet eredménye 1, ha csak az egyik kifejezés értéke 1; egyébként az eredmény mindig 0.
Tekintsük, hogy van 2 op1 és op2 változónk a következő értékekkel:
Op1 = 0000 1101 Op2 = 0001 1001
Az XOR művelet eredménye az op1 és op2 változókon lesz
Result = 0001 0100
Amint látjuk, két változót bitenként hasonlítanak össze. Ha csak egy változóban van 1, akkor az eredmény 0, különben 0 lesz az eredmény.
Írjunk egy egyszerű programot, amely bitenkénti logikai operátorokat mutat be.
#include <stdio.h> int main() { int a = 20; /* 20 = 010100 */ int b = 21; /* 21 = 010101 */ int c = 0; c = a & b; /* 20 = 010100 */ printf("AND - Value of c is %d\n", c ); c = a | b; /* 21 = 010101 */ printf("OR - Value of c is %d\n", c ); c = a ^ b; /* 1 = 0001 */ printf("Exclusive-OR - Value of c is %d\n", c ); getch(); }
output:
AND - Value of c is 20 OR - Value of c is 21 Exclusive-OR - Value of c is 1
Bitenkénti eltolási operátorok
A bitenkénti eltoló operátorok a bitminták balra vagy jobbra mozgatására/eltolására szolgálnak. A balra és jobbra két eltoló operátort a 'C' biztosít, amelyeket a következőképpen jelölünk:
Operand << n (Left Shift) Operand >> n (Right Shift)
Itt,
- az operandus egy egész kifejezés, amelyen el kell végeznünk a shift műveletet.
- Az 'n' azoknak a bithelyeknek a száma, amelyeket el kell tolnunk az egész kifejezésben.
A bal oldali eltolás művelet az 'n' számú bitet a bal oldalra tolja. A kifejezés bal szélső bitjei kiugrik, és n bit 0 értékű a jobb oldalon.
A jobb oldali eltolás művelet az 'n' számú bitet a jobb oldalra tolja. A kifejezés jobb szélső 'n' bitjei kiugrik, és a 0 érték a bal oldalon lesz kitöltve.
Példa: x egy egész kifejezés 1111 adattal. A shift művelet végrehajtása után az eredmény a következő lesz:
x << 2 (left shift) = 1111<<2 = 1100 x>>2 (right shift) = 1111>>2 = 0011
ShiftAz s operátorok kombinálhatók, majd felhasználhatók extract az egészértékű kifejezésből származó adatokat. Írjunk egy programot, amely bemutatja a bitenkénti eltolási operátorok használatát.
#include <stdio.h> int main() { int a = 20; /* 20 = 010100 */ int c = 0; c = a << 2; /* 80 = 101000 */ printf("Left shift - Value of c is %d\n", c ); c = a >> 2; /*05 = 000101 */ printf("Right shift - Value of c is %d\n", c ); return 0; }
output:
Left shift - Value of c is 80 Right shift - Value of c is 5
A balra eltolás művelet végrehajtása után az érték 80 lesz, melynek bináris megfelelője 101000.
A jobb eltolási művelet végrehajtása után az érték 5 lesz, amelynek bináris megfelelője 000101.
Bitenkénti komplement operátor
A bitenkénti kiegészítést komplement operátornak is nevezik, mivel mindig csak egy értéket vagy egy operandust vesz fel. Ez egy unáris operátor.
Ha bármely biten komplementet hajtunk végre, az 1-esek 0-vá válnak, és fordítva.
Ha van egy egész kifejezésünk, amely 0000 1111-et tartalmaz, akkor bitenkénti komplementművelet végrehajtása után az érték 1111 0000 lesz.
A bitenkénti komplement operátort tilde (~) szimbólum jelöli.
Írjunk egy programot, amely bemutatja a bitenkénti komplement operátor megvalósítását.
#include <stdio.h> int main() { int a = 10; /* 10 = 1010 */ int c = 0; c = ~(a); printf("Complement - Value of c is %d\n", c ); return 0; }
output:
Complement - Value of c is -11
Íme egy másik program, az eddig tárgyalt operátorok egy példájával:
#include <stdio.h> main() { unsigned int x = 48; /* 48 = 0011 0000 */ unsigned int y = 13; /* 13 = 0000 1101 */ int z = 0; z =x & y; /* 0 = 0000 0000 */ printf("Bitwise AND Operator - x & y = %d\n", z ); z = x | y; /* 61 = 0011 1101 */ printf("Bitwise OR Operator - x | y = %d\n", z ); z= x^y; /* 61 = 0011 1101 */ printf("Bitwise XOR Operator- x^y= %d\n", z); z = ~x; /*-49 = 11001111 */ printf("Bitwise One's Complement Operator - ~x = %d\n", z); z = x << 2; /* 192 = 1100 0000 */ printf("Bitwise Left Shift Operator x << 2= %d\n", z ); z= x >> 2; /* 12 = 0000 1100 */ printf ("Bitwise Right Shift Operator x >> 2= %d\n", z );}
A program összeállítása és futtatása után a következő eredményt adja:
Bitwise AND Operator - x & y = 0 Bitwise OR Operator - x | y = 61 Bitwise XOR Operator- x^y= 61 Bitwise One's Complement Operator - ~x = -49 Bitwise Left Shift Operator x << 2= 192 Bitwise Right Shift Operator x >> 2= 12
