Beetjewise Operatoren in C: AND, OR, XOR, Shift & Complement

Wat zijn Bitwise Exploitanten?

Beetjewise Operators worden gebruikt voor het manipuleren van gegevens op bitniveau, ook wel bitniveauprogrammering genoemd. Beetjewise werkt op een of meer bitpatronen of binaire cijfers op het niveau van hun individuele bits. Ze worden gebruikt bij numerieke berekeningen om het rekenproces sneller te laten verlopen.

Following is de lijst met bitswise operatoren geleverd door programmeertaal 'C':

Operator Betekenis
& Beetjewise EN-operator
| Beetjewise OF-operator
^ Beetjewise exclusieve OR-operator
~ De complementoperator van Binary One is een unaire operator
<< Shift-operator links
>> Rechter shift operator

Beetjewise operatoren kunnen niet rechtstreeks worden toegepast op primitieve gegevenstypen zoals float, double, enz. Onthoud altijd één ding dat stukjewise operators worden meestal gebruikt met het gegevenstype geheel getal vanwege de compatibiliteit ervan.

Het stukjewise logische operatoren werken bit voor bit aan de gegevens, beginnend bij het minst significante bit, dwz het LSB-bit dat het meest rechtse bit is, en werken naar het MSB (Most Significant Bit) toe, dat het meest linkse bit is.

Het resultaat van de berekening van bitwise logische operatoren worden 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

Beetjewise EN

Dit is een van de meest gebruikte logische bitswise exploitanten. Het wordt weergegeven door een enkel ampersand-teken (&). Aan elke kant van de operator (&) worden twee integer-expressies geschreven.
Het resultaat van het bitwise AND-bewerking is 1 als beide bits de waarde 1 hebben; anderwise, het resultaat is 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 de 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.

Beetjewise OR

Het wordt weergegeven door een enkel verticaal staafteken (|). Aan elke kant van de operator (|) worden twee integer-expressies geschreven.

Het resultaat van het bitwise OF-bewerking is 1 als ten minste één van de expressies de waarde 1 heeft; anderwise, het resultaat is 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 OR-bewerking op de 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.

Beetjewise Exclusief of

Het wordt weergegeven door een symbool (^). Aan elke kant van de operator (^) worden twee integer-expressies geschreven.

Het resultaat van het bitwise De exclusieve OF-bewerking is 1 als slechts één van de expressies de waarde 1 heeft; anderwise, het resultaat is 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 de 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 bit demonstreertwise logische operatoren.

#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

Beetjewise ploegendiensten

Het stukjewise shift-operatoren worden gebruikt om de bitpatronen naar links of rechts te verplaatsen/verschuiven. Links en rechts zijn twee ploegenoperators geleverd door 'C', die als volgt worden weergegeven:

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

Hier

  • een operand is een geheeltallige uitdrukking waarop we de verschuivingsbewerking moeten uitvoeren.
  • 'n' is het totale aantal bitposities dat we moeten verschuiven in de integer-expressie.

De linkerverschuivingsbewerking verschuift het 'n'-aantal bits naar de linkerkant. De meest linkse bits in de uitdrukking worden eruit gehaald en n bits met de waarde 0 worden aan de rechterkant gevuld.

De rechterverschuivingsbewerking verschuift het 'n'-aantal bits naar de rechterkant. De meest rechtse 'n'-bits in de uitdrukking worden eruit gehaald en de waarde 0 wordt aan de linkerkant ingevuld.

Voorbeeld: x is een geheeltallige expressie 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

Shift-operatoren kunnen worden gecombineerd en vervolgens worden gebruikt om de gegevens uit de integer-expressie te extraheren. Laten we een programma schrijven om het gebruik van bit te demonstrerenwise exploitanten van ploegendiensten.

#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

Na het uitvoeren van de verschuiving naar links wordt de waarde 80, waarvan het binaire equivalent 101000 is.

Na het uitvoeren van de rechterverschuivingsbewerking wordt de waarde 5, waarvan het binaire equivalent 000101 is.

Beetjewise aanvulling operator

Het stukjewise complement wordt ook wel iemands complementoperator genoemd, omdat er altijd maar één waarde of een operand voor nodig is. Het is een unaire operator.

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

Als we een geheeltallige expressie hebben die 0000 1111 bevat, dan na het uitvoeren van bitwise aanvullingsbewerking wordt de waarde 1111 0000.

Beetjewise complementoperator wordt aangegeven met het symbool tilde (~).

Laten we een programma schrijven dat de implementatie van bit demonstreertwise aanvulling operator.

#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 operatoes:

#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 hebben gecompileerd en uitgevoerd, wordt het volgende bestand geproduceerd: following 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

Samengevat

  • Beetjewise operators zijn een speciale operatorset geleverd door 'C.'
  • Ze worden gebruikt bij het programmeren op bitniveau.
  • Deze operatoren worden gebruikt om bits van een geheeltallige expressie te manipuleren.
  • Logisch, shift en complement zijn drie soorten bitswise exploitanten.
  • Beetjewise complement-operator wordt gebruikt om de bits van een uitdrukking om te keren.