bitvise Operators i C: AND, OR, XOR, Shift & Komplement
Benjamin rollator
Hvad er Bitwise Operators?
bitvise Operatorer bruges til at manipulere data på bitniveau, også kaldet bitniveauprogrammering. Bitwise opererer på et eller flere bitmønstre eller binære tal på niveau med deres individuelle bit. De bruges i numeriske beregninger for at gøre beregningsprocessen hurtigere.
Følgende er listen over bitvise operatører leveret af programmeringssproget 'C':
| OperaTor | Betydning |
|---|---|
| & | Bitvis OG operator |
| | | Bitvis ELLER-operator |
| ^ | Bitvis eksklusiv ELLER-operatør |
| ~ | Binært ens komplement Operator er en unær operatør |
| << | Venstreskifteoperatør |
| >> | Højreskifteoperatør |
Bitvise operatorer kan ikke anvendes direkte på primitive datatyper såsom float, double osv. Husk altid én ting, at bitvise operatorer for det meste bruges med heltalsdatatypen 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.
| x | y | x & y | x | der | x^y |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
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
De bitvise skiftoperatorer bruges til at flytte/skifte bitmønstrene enten til venstre eller højre side. Venstre og højre er to skiftoperatorer leveret 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 at udtrække data fra heltalsudtrykket. Lad os skrive et program for at demonstrere 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 operaer, der er 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
Resumé
- Bitvise operatorer er specielt operatorsæt leveret af 'C.'
- De bruges til programmering på bitniveau.
- Disse operatorer bruges til at manipulere bits af et heltalsudtryk.
- Logisk, skift og komplement er tre typer bitvise operatorer.
- Bitvis komplementoperator bruges til at vende bits af et udtryk.
