C Bitvisa operatörer: AND, OR, XOR, Shift & Komplement (med exempel)

Vad är bitvisa operatörer?

BITWISE OPERATORS används för att manipulera data på bitnivå, även kallad bitnivåprogrammering. Bitwise arbetar på ett eller flera bitmönster eller binära siffror på nivån för deras enskilda bitar. De används i numeriska beräkningar för att göra beräkningen snabbare.

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

Operatör	Menande
&	Bitvis OCH operatör
\|	Bitvis ELLER operatör
^	Bitvis exklusiv ELLER operatör
~	Binary One's Complement Operator är en unary operatör
<<	Vänster skiftoperatör
>>	Höger skiftoperatör

Bitvisa operatorer kan inte tillämpas direkt på primitiva datatyper som float, double, etc. Kom alltid ihåg en sak som bitvis operatorer oftast används med heltaldatatypen på grund av dess kompatibilitet.

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

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

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 den här handledningen lär du dig-

Vad är bitvisa operatörer?
Bitvis OCH
Bitvis ELLER
Bitvis exklusivt ELLER
Bitvisa skiftoperatörer
Bitvis komplementoperatör

Bitvis OCH

Detta är en av de mest använda logiska bitvisa operatörerna. Det representeras av ett enda tecken & (&). Två heltaluttryck skrivs på vardera sidan av (&) operatören.

Resultatet av bitvis OCH-operation är 1 om båda bitarna har värdet 1; annars är resultatet alltid 0.

Låt oss överväga att vi har två variabler op1 och op2 med värden enligt följande:

Op1 = 0000 1101Op2 = 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ärhelst värdet på en bit i båda variablerna är 1, blir resultatet 1 eller annars 0.

Bitvis ELLER

Det representeras av ett enda vertikalt stapeltecken (|). Två heltaluttryck skrivs på vardera sidan av (|) operatören.

Resultatet av bitvis ELLER-operation är 1 om minst ett av uttrycket har värdet 1; annars är resultatet alltid 0.

Låt oss överväga att vi har två variabler op1 och op2 med värden enligt följande:

Op1 = 0000 1101Op2 = 0001 1001

Resultatet av operationen ELLER på variablerna op1 och op2 blir

Result = 0001 1101

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

Bitvis exklusivt ELLER

Den representeras av en symbol (^). Två heltaluttryck skrivs på vardera sidan av (^) operatören.

Resultatet av den bitvisa Exklusiva-ELLER-operationen är 1 om bara ett av uttrycket har värdet 1; annars är resultatet alltid 0.

Låt oss överväga att vi har två variabler op1 och op2 med värden enligt följande:

Op1 = 0000 1101Op2 = 0001 1001

Resultatet av operationen ELLER 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å blir resultatet 0 annars blir 0 resultatet.

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

Produktion:

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

Bitvisa skiftoperatörer

Bitvisa skiftoperatörer används för att flytta / flytta bitmönstret antingen till vänster eller höger sida. Vänster och höger är två skiftoperatörer tillhandahållna av 'C' som representeras enligt följande:

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

Här,

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

Vänsterförskjutningsoperationen flyttar 'n' antal bitar till vänster sida. De vänstra bitarna i uttrycket kommer att poppas ut och n bitar med värdet 0 kommer att fyllas på höger sida.

Högerförskjutningsoperationen kommer att flytta 'n' antal bitar till höger sida. De n-bitarna längst till höger i uttrycket kommer att poppas ut och värdet 0 fylls på vänster sida.

Exempel: x är ett heltaluttryck med data 1111. Efter utförande av skiftoperation blir resultatet:

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

Skiftoperatörer kan kombineras och sedan användas för att extrahera data från heluttrycket. Låt oss skriva ett program för att demonstrera användningen av bitvisa 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;}

Produktion:

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

Efter att ha utfört vänster skiftoperation 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 komplementoperatör eftersom det alltid bara tar ett värde eller en operand. Det är en unary operatör.

När vi utför komplement på alla bitar blir alla 1-tal 0 och vice versa.

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

Bitvis komplementoperator betecknas med symbolen tilde (~).

Låt oss skriva ett program som visar 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;}

Produktion:

Complement - Value of c is -11

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

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

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