bitvis Operators i C: AND, OR, XOR, Shift & Komplement

Hva er Bitwise Operators?

bitvis OperaTorer brukes til å manipulere data på bitnivå, også kalt bitnivåprogrammering. Bitvis opererer på ett eller flere bitmønstre eller binære tall på nivået til deres individuelle biter. De brukes i numeriske beregninger for å gjøre beregningsprosessen raskere.

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

Bitvise operatorer kan ikke brukes direkte på primitive datatyper som float, double osv. Husk alltid én ting: bitvise operatorer brukes hovedsakelig med heltallsdatatype på grunn av kompatibiliteten.

De bitvise logiske operatorene arbeider på dataene bit for bit, med utgangspunkt i den minst signifikante biten, dvs. LSB-biten som er biten lengst til høyre, og jobber mot MSB (Most Significant Bit) som er biten lengst til venstre.

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

Bitvis OG

Dette er en av de mest brukte logiske bitvise operatorene. Det er representert med et enkelt og-tegn (&). To heltallsuttrykk er skrevet på hver side av (&)-operatoren.
Resultatet av den bitvise OG-operasjonen er 1 hvis begge bitene har verdien som 1; ellers er resultatet alltid 0.

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

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet av OG-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, vil resultatet være 1 eller 0.

Bitvis ELLER

Det er representert med et enkelt vertikalt strektegn (|). To heltallsuttrykk er skrevet på hver side av (|)-operatoren.

Resultatet av den bitvise ELLER-operasjonen er 1 hvis minst ett av uttrykkene har verdien som 1; ellers er resultatet alltid 0.

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

Op1 = 0000 1101
Op2 = 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, vil resultatet være 1 eller 0.

Bitwise Exclusive ELLER

Det er representert med et symbol (^). To heltallsuttrykk er skrevet på hver side av (^)-operatoren.

Resultatet av den bitvise Exclusive-OR-operasjonen er 1 hvis bare ett av uttrykkene har verdien som 1; ellers er resultatet alltid 0.

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

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet av XOR-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 én variabel har verdien 1, er resultatet 0, ellers vil 0 være resultatet.

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

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

Utgang:

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

Bitvise skiftoperatører

Bitvise skiftoperatorer brukes til å flytte/forskyve bitmønstrene enten til venstre eller høyre side. Venstre og høyre er to skiftoperatorer gitt av 'C', som er representert som følger:

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

Her

• en operand er et heltallsuttrykk som vi må utføre skiftoperasjonen på.
• 'n' er det totale antallet bitposisjoner som vi må skifte i heltallsuttrykket.

Venstre skiftoperasjon vil flytte 'n' antall biter til venstre side. Bitene lengst til venstre i uttrykket vil bli spratt ut, og n biter med verdien 0 vil fylles ut på høyre side.

Høyre skiftoperasjon vil flytte 'n' antall biter til høyre side. De 'n'-bitene lengst til høyre i uttrykket vil bli spratt ut, og verdien 0 vil fylles ut på venstre side.

Eksempel: x er et heltallsuttrykk med data 1111. Etter å ha utført skiftoperasjon vil resultatet være:

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

Shifts-operatorer kan kombineres, så kan de brukes til å f.eks.tract dataene fra heltallsuttrykket. La oss skrive et program som demonstrerer bruken av bitvise skiftoperatorer.

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

Utgang:

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

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

Etter å ha utført den riktige skiftoperasjonen, vil verdien bli 5 hvis binære ekvivalent er 000101.

Bitvis komplement operatør

Det bitvise komplementet kalles også ens komplementoperator siden det alltid bare tar en verdi eller en operand. Det er en unær operatør.

Når vi utfører komplement på en hvilken som helst bit, blir alle 1-ene 0-er og omvendt.

Hvis vi har et heltallsuttrykk som inneholder 0000 1111, vil verdien bli 1111 0000 etter å ha utført bitvis komplementeringsoperasjon.

Bitvis komplementoperator er angitt med symbol tilde (~).

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

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

Utgang:

Complement - Value of c is -11

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

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

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

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

Spørsmål og svar