C Bitvis operatører: AND, OR, XOR, Shift & Komplement (med eksempel)

Hva er bitvise operatører?

BITWISE OPERATORS brukes til å manipulere data på bitnivå , også kalt bitnivåprogrammering . Bitwise opererer på ett eller flere bitmønstre eller binære tall på nivået med deres individuelle bits. De brukes i numeriske beregninger for å gjøre beregningsprosessen raskere.

Følgende er listen over bitvise operatører levert av 'C' programmeringsspråk:

Operatør	Betydning
&	Bitvis OG operatør
\|	Bitvis ELLER operatør
^	Bitvis eksklusiv ELLER operatør
~	Binary One's Complement Operator er en unary operatør
<<	Venstre skiftoperatør
>>	Høyre skiftoperatør

Bitvis operatorer kan ikke brukes direkte på primitive datatyper som float, double osv. Husk alltid en ting at bitvis operatorer mest brukes med datatypen for heltall på grunn av dens kompatibilitet.

De bitvise logiske operatørene jobber på dataene bit for bit, og starter fra den minst signifikante biten, dvs. LSB-biten som er den høyre biten, og jobber mot MSB (Most Significant Bit) som er den venstre biten.

Resultatet av beregningen av bitvise logiske operatorer er vist i tabellen nedenfor.

x	y	x & y	x \| y	x y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

I denne veiledningen vil du lære-

Hva er bitvise operatører?
Bitvis OG
Bitvis ELLER
Bitwise Exclusive ELLER
Bitvis skiftoperatører
Bitvis komplementoperatør

Bitvis OG

Dette er en av de mest brukte logiske bitvise operatørene. Den er representert med et enkelt tegn (&). To heltalluttrykk er skrevet på hver side av (&) operatoren.

Resultatet av bitvis AND-operasjon er 1 hvis begge bitene har verdien 1; Ellers er resultatet alltid 0.

La oss vurdere at vi har to variabler op1 og op2 med verdier som følger:

Op1 = 0000 1101Op2 = 0001 1001

Resultatet av AND-operasjonen på variablene op1 og op2 vil være

Result = 0000 1001

Som vi kan se, sammenlignes to variabler bit for bit. Når verdien av en bit i begge variablene er 1, blir resultatet 1 eller ellers 0.

Bitvis ELLER

Den er representert med et enkelt vertikalt strektegn (|). To heltalsuttrykk skrives på hver side av (|) operatoren.

Resultatet av bitvis ELLER-operasjon er 1 hvis minst ett av uttrykket har verdien 1; Ellers er resultatet alltid 0.

La oss vurdere at vi har to variabler op1 og op2 med verdier som følger:

Op1 = 0000 1101Op2 = 0001 1001

Resultatet av OR-operasjonen på variablene op1 og op2 vil være

Result = 0001 1101

Som vi kan se, sammenlignes to variabler bit for bit. Når verdien av en bit i en av variablene er 1, blir resultatet 1 eller ellers 0.

Bitwise Exclusive ELLER

Det er representert med et symbol (^). To heltalluttrykk skrives på hver side av (^) operatoren.

Resultatet av den bitvise eksklusive-ELLER-operasjonen er 1 hvis bare ett av uttrykket har verdien 1; Ellers er resultatet alltid 0.

La oss vurdere at vi har to variabler op1 og op2 med verdier som følger:

Op1 = 0000 1101Op2 = 0001 1001

Resultatet av OR-operasjonen på variablene op1 og op2 vil være

Result = 0001 0100

Som vi kan se, sammenlignes to variabler bit for bit. Når bare en variabel har verdien 1, blir resultatet 0, ellers vil 0 være resultatet.

La oss skrive et enkelt program som demonstrerer bitvise logiske operatorer.

#include 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();}

Produksjon:

AND - Value of c is 20OR - Value of c is 21Exclusive-OR - Value of c is 1

Bitvis skiftoperatører

De bitvise skiftoperatørene brukes til å flytte / skifte bitmønstrene enten til venstre eller høyre side. Venstre og høyre er to skiftoperatører levert av 'C' som er representert som følger:

Operand << n (Left Shift)Operand >> n (Right Shift)

Her,

en operand er et heltalluttrykk som vi må utføre skiftoperasjonen på.
'n' er det totale antall bitposisjoner som vi må skifte i heltalluttrykket.

Venstre skiftoperasjon vil skifte 'n' antall bits til venstre side. De venstre bitene i uttrykket vil poppes ut, og n biter med verdien 0 fylles på høyre side.

Høyre skiftoperasjon vil skifte 'n' antall bits til høyre side. De lengste 'n' biter i uttrykket vil bli poppet ut, og verdien 0 vil bli fylt på venstre side.

Eksempel: x er et heltalluttrykk med data 1111. Etter å ha utført skiftoperasjon blir resultatet:

x << 2 (left shift) = 1111<<2 = 1100x>>2 (right shift) = 1111>>2 = 0011

Skiftoperatører kan kombineres, så kan de brukes til å trekke ut dataene fra heltalsuttrykket. La oss skrive et program for å demonstrere bruken av bitvise skiftoperatører.

#include 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;}

Produksjon:

Left shift - Value of c is 80Right shift - Value of c is 5

Etter å ha utført venstre skiftoperasjon vil verdien bli 80 hvis binære ekvivalent er 101000.

Etter å ha utført riktig skiftoperasjon, blir verdien til 5 hvis binære ekvivalent er 000101.

Bitvis komplementoperatør

Bitvis komplement kalles også som ens komplementoperatør, siden det alltid bare tar en verdi eller en operand. Det er en unarisk operatør.

Når vi utfører komplement på noen biter, blir alle 1-tallet 0 og omvendt.

Hvis vi har et heltallsuttrykk som inneholder 0000 1111, blir verdien 1111 0000 etter å ha utført bitvis komplementoperasjon.

Bitvis komplementoperator er betegnet med symbol tilde (~).

La oss skrive et program som demonstrerer implementeringen av bitvis komplementoperatør.

#include int main() {int a = 10; /* 10 = 1010 */int c = 0;c = ~(a);printf("Complement - Value of c is %d\n", c );return 0;}

Produksjon:

Complement - Value of c is -11

Her er et annet program, med et eksempel på alle operatoene som er diskutert så langt:

#include 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; /*-61 = 1100 0011 */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 );}

Etter at vi har samlet og kjørt programmet, gir det følgende resultat:

Bitwise AND Operator - x & y = 0Bitwise OR Operator - x | y = 61Bitwise XOR Operator- x^y= 61Bitwise One's Complement Operator - ~x = -49Bitwise Left Shift Operator x << 2= 192Bitwise Right Shift Operator x >> 2= 12