bitsgewijze Operators in C: AND, OR, XOR, Shift & Aanvulling

Hieronder volgt een lijst met bitgewijze operatoren die door de programmeertaal 'C' worden geleverd:

Operator	Betekenis
&	Bitgewijze AND-operator
|	Bitgewijze OF-operator
^	Bitgewijze exclusieve OF-operator
~	Het complement van binaire één Operator is een unaire operator
<<	Linker shift operator
>>	Rechter shift operator

Bitgewijze operatoren kunnen niet rechtstreeks worden toegepast op primitieve gegevenstypen zoals float, double, etc. Houd er altijd rekening mee dat bitgewijze operatoren vooral worden gebruikt bij het gegevenstype integer vanwege de compatibiliteit ervan.

De bitsgewijze logische operatoren bewerken de gegevens bit voor bit, beginnend bij de minst significante bit, oftewel de LSB-bit (de meest rechtse bit), en werkend naar de MSB (Most Significant Bit), de meest linkse bit.

Het resultaat van de berekening van bitgewijze logische operatoren wordt weergegeven in de onderstaande tabel.

x	y	x & y	x | ja	x^y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

Bitwise EN

Dit is een van de meest gebruikte logische bitwise operatoren. Het wordt weergegeven door een enkel ampersand-teken (&). Twee gehele getallen worden aan elke kant van de (&) operator geschreven.
Het resultaat van de bitsgewijze AND-bewerking is 1 als beide bits de waarde 1 hebben. Anders is het resultaat altijd 0.

Laten we bedenken dat we twee variabelen op2 en op1 hebben met de volgende waarden:

Op1 = 0000 1101
Op2 = 0001 1001

Het resultaat van de AND-bewerking op variabelen op1 en op2 zal zijn:

Result = 0000 1001

Zoals we kunnen zien, worden twee variabelen beetje bij beetje vergeleken. Wanneer de waarde van een bit in beide variabelen 1 is, is het resultaat 1 of anders 0.

Bitsgewijs OF

Het wordt weergegeven door een enkel verticaal balkje (|). Aan elke kant van de (|) operator worden twee gehele getallen geschreven.

Het resultaat van de bitsgewijze OF-bewerking is 1 als ten minste één van de expressies de waarde 1 heeft. Anders is het resultaat altijd 0.

Laten we bedenken dat we twee variabelen op2 en op1 hebben met de volgende waarden:

Op1 = 0000 1101
Op2 = 0001 1001

Het resultaat van de OF-bewerking op variabelen op1 en op2 zal zijn:

Result = 0001 1101

Zoals we kunnen zien, worden twee variabelen beetje bij beetje vergeleken. Wanneer de waarde van een bit in een van de variabelen 1 is, dan is het resultaat 1 of anders 0.

Bitwise Exclusief OF

Het wordt weergegeven door een symbool (^). Aan elke kant van de (^) operator worden twee gehele getallen geschreven.

Het resultaat van de bitsgewijze Exclusive-OR-bewerking is 1 als slechts één van de expressies de waarde 1 heeft; anders is het resultaat altijd 0.

Laten we bedenken dat we twee variabelen op2 en op1 hebben met de volgende waarden:

Op1 = 0000 1101
Op2 = 0001 1001

Het resultaat van de XOR-bewerking op variabelen op1 en op2 zal zijn:

Result = 0001 0100

Zoals we kunnen zien, worden twee variabelen beetje bij beetje vergeleken. Wanneer slechts één variabele de waarde 1 heeft, is het resultaat 0, anders is 0 het resultaat.

Laten we een eenvoudig programma schrijven dat bitgewijze logische operatoren demonstreert.

#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

Bitgewijze verschuivingsoperatoren

De bitwise shift-operatoren worden gebruikt om de bitpatronen naar links of rechts te verplaatsen/verschuiven. Left en right zijn twee shift-operatoren die worden geleverd door 'C', die als volgt worden weergegeven:

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

Hier

• Een operand is een geheel getal waarop we de verschuivingsbewerking moeten uitvoeren.
• 'n' is het totale aantal bitposities dat we moeten verschuiven in de gehele getallenexpressie.

De left shift-bewerking verschuift het 'n'-aantal bits naar de linkerkant. De meest linkse bits in de expressie worden eruit gepopt en n bits met de waarde 0 worden aan de rechterkant ingevuld.

De rechtse shift-bewerking verschuift het 'n'-aantal bits naar de rechterkant. De meest rechtse 'n'-bits in de expressie worden eruit gepopt en de waarde 0 wordt aan de linkerkant ingevuld.

Voorbeeld: x is een geheel getal met gegevens 1111. Na het uitvoeren van de shift-bewerking is het resultaat:

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

Shifts operatoren kunnen worden gecombineerd, dan kan het worden gebruikt om de data uit de integer expressie te halen. Laten we een programma schrijven om het gebruik van bitwise shift operatoren te demonstreren.

#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

Nadat de linker verschuiving is uitgevoerd, wordt de waarde 80, waarvan het binaire equivalent 101000 is.

Nadat de verschuiving naar rechts is uitgevoerd, wordt de waarde 5, waarvan het binaire equivalent 000101 is.

Bitgewijze complementaire operator

De bitwise complement wordt ook wel one's complement operator genoemd, omdat deze altijd maar één waarde of een operand aanneemt. Het is een unaire operator.

Wanneer we complement uitvoeren op bits, worden alle enen nullen en omgekeerd.

Als we een gehele expressie hebben die 0000 1111 bevat, dan wordt de waarde na het uitvoeren van de bitgewijze complementbewerking 1111 0000.

De bitgewijze complement-operator wordt aangegeven met het symbool tilde (~).

Laten we een programma schrijven dat de implementatie van de bitgewijze complement-operator demonstreert.

#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

Hier is nog een programma, met een voorbeeld van alle tot nu toe besproken operaties:

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

Nadat we het programma compileren en uitvoeren, produceert het het volgende resultaat:

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

Samenvatting

• Bitgewijze operatoren zijn speciale operatorensets die door 'C' worden aangeleverd.
• Ze worden gebruikt bij het programmeren op bitniveau.
• Deze operatoren worden gebruikt om delen van een gehele getallenexpressie te manipuleren.
• Logisch, shift en complement zijn drie soorten bitgewijze operatoren.
• De bitgewijze complementoperator wordt gebruikt om de bits van een expressie om te draaien.