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

Vad är Bitwise Operators?

bitvis OperaTorer används för att manipulera data på bitnivå, även kallad bitnivåprogrammering. Bitvis arbetar med ett eller flera bitmönster eller binära siffror på nivån för deras individuella bitar. De används i numeriska beräkningar för att göra beräkningsprocessen snabbare.

Följande är listan över bitvisa operatorer som tillhandahålls av programmeringsspråket 'C':

Bitvisa operatorer kan inte tillämpas direkt på primitiva datatyper som flyttal, dubbel etc. Kom alltid ihåg en sak, bitvisa operatorer används oftast med heltalsdatatyp på grund av dess kompatibilitet.

De bitvisa logiska operatorerna arbetar på datan bit för bit, med utgångspunkt från den minst signifikanta biten, dvs LSB-biten som är biten längst till höger, och arbetar mot MSB (Most Significant Bit) som är biten längst till vänster.

Resultatet av beräkningen av bitvisa logiska operatorer visas i tabellen nedan.

Bitvis OCH

Detta är en av de mest använda logiska bitvisa operatorerna. Det representeras av ett enda et-tecken (&). Två heltalsuttryck skrivs på varje sida av (&)-operatorn.
Resultatet av den bitvisa OCH-operationen är 1 om båda bitarna har värdet 1; annars är resultatet alltid 0.

Låt oss tänka på att vi har 2 variabler op1 och op2 med värden enligt följande:

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet av OCH-operationen på variablerna op1 och op2 blir

Result = 0000 1001

Som vi kan se jämförs två variabler bit för bit. När värdet på en bit i båda variablerna är 1, blir resultatet 1 eller 0.

Bitvis ELLER

Det representeras av ett enda vertikalt strecktecken (|). Två heltalsuttryck skrivs på var sida om operatorn (|).

Resultatet av den bitvisa ELLER-operationen är 1 om åtminstone ett av uttrycken har värdet 1; annars är resultatet alltid 0.

Låt oss tänka på att vi har 2 variabler op1 och op2 med värden enligt följande:

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet av ELLER-operationen på variablerna op1 och op2 blir

Result = 0001 1101

Som vi kan se jämförs två variabler bit för bit. När värdet på en bit i en av variablerna är 1, blir resultatet 1 eller 0.

Bitwise Exklusiv ELLER

Den representeras av en symbol (^). Två heltalsuttryck skrivs på var sida om operatorn (^).

Resultatet av den bitvisa Exclusive-OR-operationen är 1 om bara ett av uttrycken har värdet 1; annars är resultatet alltid 0.

Låt oss tänka på att vi har 2 variabler op1 och op2 med värden enligt följande:

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet av XOR-operationen på variablerna op1 och op2 blir

Result = 0001 0100

Som vi kan se jämförs två variabler bit för bit. När bara en variabel har värdet 1 så är resultatet 0 annars blir 0 resultatet.

Låt oss skriva ett enkelt program som visar bitvis logiska 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();
}

Produktion:

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

Bitvis skiftoperatorer

Bitvisa skiftoperatorer används för att flytta/skifta bitmönstren antingen åt vänster eller höger. Vänster och höger är två skiftoperatorer som tillhandahålls av 'C' och representeras enligt följande:

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

Här,

• en operand är ett heltalsuttryck som vi måste utföra skiftoperationen på.
• 'n' är det totala antalet bitpositioner som vi måste skifta i heltalsuttrycket.

Vänsterväxlingsoperationen kommer att flytta 'n' antalet bitar till vänster sida. Bitarna längst till vänster i uttrycket kommer att poppas ut, och n bitar med värdet 0 kommer att fyllas i på höger sida.

Den högra växlingsoperationen kommer att flytta "n" antalet bitar till höger sida. De 'n' bitarna längst till höger i uttrycket kommer att visas och värdet 0 kommer att fyllas i på vänster sida.

Exempel: x är ett heltalsuttryck med data 1111. Efter att ha utfört skiftoperationen blir resultatet:

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

Shifts-operatorer kan kombineras och sedan användas för att t.ex.tract data från heltalsuttrycket. Låt oss skriva ett program som demonstrerar användningen av bitvisa 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;
}

Produktion:

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

Efter att ha utfört vänsterväxlingsoperationen blir värdet 80 vars binära ekvivalent är 101000.

Efter att ha utfört rätt skiftoperation blir värdet 5 vars binära ekvivalent är 000101.

Bitvis komplementoperatör

Det bitvisa komplementet kallas också som ens komplementoperator eftersom det alltid bara tar ett värde eller en operand. Det är en unär operatör.

När vi utför komplement på vilka bitar som helst, blir alla 1:or 0:or och vice versa.

Om vi ​​har ett heltalsuttryck som innehåller 0000 1111 blir värdet 1111 0000 efter att ha utfört en bitvis komplementoperation.

Bitvis komplementoperator betecknas med symbolen tilde (~).

Låt oss skriva ett program som visar implementeringen av en bitvis komplementoperator.

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

Produktion:

Complement - Value of c is -11

Här är ett annat program, med ett exempel på alla operatorer som diskuterats hittills:

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

När vi har kompilerat och kört programmet ger det följande 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

Vanliga frågor