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

Hvad er Bitwise Operators?

bitvise OperaTorer bruges til at manipulere data på bitniveau, også kaldet bitniveauprogrammering. Bitvis opererer på et eller flere bitmønstre eller binære tal på niveauet af deres individuelle bits. De bruges i numeriske beregninger for at gøre beregningsprocessen hurtigere.

Følgende er listen over bitvise operatører leveret af programmeringssproget 'C':

Bitvise operatorer kan ikke anvendes direkte på primitive datatyper såsom float, double osv. Husk altid én ting, at bitvise operatorer oftest bruges med heltalsdatatype på grund af dens kompatibilitet.

De bitvise logiske operatorer arbejder på dataene bit for bit, startende fra den mindst signifikante bit, dvs. LSB bit, som er bit længst til højre, og arbejder hen imod MSB (Most Significant Bit), som er bit længst til venstre.

Resultatet af beregningen af ​​bitvise logiske operatorer er vist i tabellen nedenfor.

Bitvis OG

Dette er en af ​​de mest almindeligt anvendte logiske bitvise operatorer. Det er repræsenteret af et enkelt og-tegn (&). To heltalsudtryk er skrevet på hver side af (&) operatoren.
Resultatet af den bitvise OG-operation er 1, hvis begge bits har værdien 1; ellers er resultatet altid 0.

Lad os overveje, at vi har 2 variable op1 og op2 med værdier som følger:

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet af AND-operationen på variable op1 og op2 vil være

Result = 0000 1001

Som vi kan se, sammenlignes to variable bit for bit. Når værdien af ​​en bit i begge variabler er 1, vil resultatet være 1 eller 0.

Bitvis ELLER

Det er repræsenteret af et enkelt lodret stregtegn (|). To heltalsudtryk er skrevet på hver side af (|) operatoren.

Resultatet af den bitvise ELLER-operation er 1, hvis mindst et af udtrykkene har værdien 1; ellers er resultatet altid 0.

Lad os overveje, at vi har 2 variable op1 og op2 med værdier som følger:

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet af ELLER-operationen på variable op1 og op2 vil være

Result = 0001 1101

Som vi kan se, sammenlignes to variable bit for bit. Når værdien af ​​en bit i en af ​​variablerne er 1, vil resultatet være 1 eller 0.

Bitwise Exclusive ELLER

Det er repræsenteret ved et symbol (^). To heltalsudtryk er skrevet på hver side af (^) operatoren.

Resultatet af den bitvise Exclusive-OR operation er 1, hvis kun et af udtrykkene har værdien 1; ellers er resultatet altid 0.

Lad os overveje, at vi har 2 variable op1 og op2 med værdier som følger:

Op1 = 0000 1101
Op2 = 0001 1001

Resultatet af XOR-operationen på variable op1 og op2 vil være

Result = 0001 0100

Som vi kan se, sammenlignes to variable bit for bit. Når kun én variabel har værdien 1, er resultatet 0, ellers vil 0 være resultatet.

Lad os skrive et simpelt program, der demonstrerer 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();
}

Output:

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

Bitvise skiftoperatører

Bitvise skiftoperatorer bruges til at flytte/forskyde bitmønstrene enten til venstre eller højre. Venstre og højre er to skiftoperatorer angivet af 'C', som er repræsenteret som følger:

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

Her,

• en operand er et heltalsudtryk, som vi skal udføre skiftoperationen på.
• 'n' er det samlede antal bitpositioner, som vi skal flytte i heltalsudtrykket.

Den venstre skiftoperation vil flytte 'n' antallet af bits til venstre side. De bits længst til venstre i udtrykket vil blive poppet ud, og n bits med værdien 0 vil blive udfyldt på højre side.

Den højre shift-operation vil flytte 'n' antallet af bits til højre side. De 'n' bits længst til højre i udtrykket vil blive poppet ud, og værdien 0 vil blive udfyldt i venstre side.

Eksempel: x er et heltalsudtryk med data 1111. Efter udførelse af skiftoperation 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 bruges til f.eks.tract dataene fra heltalsudtrykket. Lad os skrive et program, der demonstrerer brugen af ​​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;
}

Output:

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

Efter at have udført venstreskiftoperationen bliver værdien 80, hvis binære ækvivalent er 101000.

Efter at have udført den rigtige skiftoperation, bliver værdien 5, hvis binære ækvivalent er 000101.

Bitvis komplement operatør

Det bitvise komplement kaldes også som ens komplementoperator, da det altid kun tager én værdi eller en operand. Det er en unær operatør.

Når vi udfører komplement på en hvilken som helst bit, bliver alle 1'erne til 0'er og omvendt.

Hvis vi har et heltalsudtryk, der indeholder 0000 1111, vil værdien blive 1111 0000 efter at have udført bitvise komplementeringsoperation.

Bitvis komplementoperator er angivet med symbol tilde (~).

Lad os skrive et program, der demonstrerer implementeringen af ​​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;
}

Output:

Complement - Value of c is -11

Her er et andet program med et eksempel på alle de operatorer, der er blevet diskuteret indtil videre:

#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 kompileret og kørt programmet, giver 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

Ofte Stillede Spørgsmål