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

Wat zijn Bitwise OperaTorens?

bitsgewijze OperaBitwise-bewerkingen worden gebruikt voor het manipuleren van gegevens op bitniveau, ook wel bitprogrammering genoemd. Bitwise-bewerkingen werken op een of meer bitpatronen of binaire getallen op het niveau van hun individuele bits. Ze worden gebruikt in numerieke berekeningen om het rekenproces te versnellen.

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

Bitwise-operatoren kunnen niet rechtstreeks worden toegepast op primitieve gegevenstypen zoals float, double, enz. Onthoud altijd dat bitwise-operatoren meestal worden gebruikt met... gegevenstype integer vanwege de compatibiliteit.

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.

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 bitverschuivingsoperatoren worden gebruikt om bitpatronen naar links of rechts te verplaatsen. Links en rechts zijn twee verschuivingsoperatoren die door 'C' worden aangeboden en 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

ShiftAls de operatoren gecombineerd kunnen worden, kan dit gebruikt worden om bijvoorbeeld...tract de gegevens uit de integer-expressie. 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 volgt nog een programma, met een voorbeeld van alle tot nu toe besproken operatoren:

#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

Veelgestelde vragen