Bitweise OperaToren in C: AND, OR, XOR, Shift & Ergänzen

Nachfolgend finden Sie eine Liste der in der Programmiersprache C verfügbaren Bitoperatoren:

OperaDo.	Bedeutung
&	Bitweiser UND-Operator
|	Bitweiser ODER-Operator
^	Bitweiser exklusiver ODER-Operator
~	Binäres Einserkomplement Operator ist ein unärer Operator
<<	Linker Shift-Operator
>>	Rechtsverschiebungsoperator

Bitweise Operatoren können nicht direkt auf primitive Datentypen wie Float, Double usw. angewendet werden. Denken Sie immer daran, dass bitweise Operatoren aufgrund der Kompatibilität hauptsächlich mit dem Datentyp Integer verwendet werden.

Die bitweisen logischen Operatoren verarbeiten die Daten Stück für Stück, beginnend mit dem niederwertigsten Bit, also dem LSB-Bit, das sich ganz rechts befindet, und arbeiten sich in Richtung MSB (Most Significant Bit), das sich ganz links befindet.

Das Ergebnis der Berechnung der bitweisen logischen Operatoren wird in der unten angegebenen Tabelle angezeigt.

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

Bitweises UND

Dies ist einer der am häufigsten verwendeten logischen Bitoperatoren. Er wird durch ein einzelnes Et-Zeichen (&) dargestellt. Auf jeder Seite des (&)-Operators werden zwei ganzzahlige Ausdrücke geschrieben.
Das Ergebnis der bitweisen UND-Operation ist 1, wenn beide Bits den Wert 1 haben, andernfalls ist das Ergebnis immer 0.

Nehmen wir an, wir haben zwei Variablen op2 und op1 mit den folgenden Werten:

Op1 = 0000 1101
Op2 = 0001 1001

Das Ergebnis der UND-Operation der Variablen op1 und op2 ist

Result = 0000 1001

Wie wir sehen können, werden zwei Variablen Stück für Stück verglichen. Immer wenn der Wert eines Bits in beiden Variablen 1 ist, ist das Ergebnis 1 oder 0.

Bitweises ODER

Es wird durch ein einzelnes senkrechtes Strichzeichen (|) dargestellt. Auf jeder Seite des Operators (|) werden zwei ganzzahlige Ausdrücke geschrieben.

Das Ergebnis der bitweisen ODER-Operation ist 1, wenn mindestens einer der Ausdrücke den Wert 1 hat, andernfalls ist das Ergebnis immer 0.

Nehmen wir an, wir haben zwei Variablen op2 und op1 mit den folgenden Werten:

Op1 = 0000 1101
Op2 = 0001 1001

Das Ergebnis der ODER-Operation der Variablen op1 und op2 ist

Result = 0001 1101

Wie wir sehen können, werden zwei Variablen Stück für Stück verglichen. Immer wenn der Wert eines Bits in einer der Variablen 1 ist, ist das Ergebnis 1 oder 0.

Bitweises Exklusiv-ODER

Es wird durch ein Symbol (^) dargestellt. Auf jeder Seite des (^)-Operators werden zwei ganzzahlige Ausdrücke geschrieben.

Das Ergebnis der bitweisen Exklusiv-ODER-Operation ist 1, wenn nur einer der Ausdrücke den Wert 1 hat; andernfalls ist das Ergebnis immer 0.

Nehmen wir an, wir haben zwei Variablen op2 und op1 mit den folgenden Werten:

Op1 = 0000 1101
Op2 = 0001 1001

Das Ergebnis der XOR-Operation auf den Variablen op1 und op2 ist

Result = 0001 0100

Wie wir sehen können, werden zwei Variablen Stück für Stück verglichen. Immer wenn nur eine Variable den Wert 1 enthält, ist das Ergebnis 0, andernfalls ist 0 das Ergebnis.

Schreiben wir ein einfaches Programm, das bitweise logische Operatoren demonstriert.

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

Ausgang:

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

Bitweise Verschiebungsoperatoren

Die bitweisen Verschiebeoperatoren werden verwendet, um die Bitmuster entweder nach links oder nach rechts zu verschieben. Links und rechts sind zwei Verschiebeoperatoren, die von ' bereitgestellt werden.C', die wie folgt dargestellt werden:

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

Dabei steht:

• Ein Operand ist ein ganzzahliger Ausdruck, auf den wir die Verschiebeoperation anwenden müssen.
• „n“ ist die Gesamtzahl der Bitpositionen, die wir im Ganzzahlausdruck verschieben müssen.

Die Linksverschiebung verschiebt die Anzahl 'n' Bits nach links. Die am weitesten links stehenden Bits im Ausdruck werden entfernt und n Bits mit dem Wert 0 werden auf der rechten Seite ausgefüllt.

Die Rechtsverschiebung verschiebt die Anzahl 'n' Bits nach rechts. Die am weitesten rechts stehenden 'n' Bits im Ausdruck werden entfernt und der Wert 0 wird auf der linken Seite eingetragen.

Beispiel: x ist ein ganzzahliger Ausdruck mit den Daten 1111. Nach der Durchführung der Verschiebeoperation lautet das Ergebnis:

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

Shifts-Operatoren können kombiniert werden, dann können sie verwendet werden, um die Daten aus dem ganzzahligen Ausdruck zu extrahieren. Lassen Sie uns ein Programm schreiben, um die Verwendung von bitweisen Verschiebungsoperatoren zu demonstrieren.

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

Ausgang:

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

Nach der Linksverschiebung beträgt der Wert 80, was binär 101000 entspricht.

Nach der Durchführung der Rechtsverschiebung wird der Wert zu 5, was binär 000101 entspricht.

Bitweiser Komplementoperator

Das bitweise Komplement wird auch Einerkomplementoperator genannt, da es immer nur einen Wert oder einen Operanden annimmt. Es ist ein unärer Operator.

Wenn wir beliebige Bits komplementieren, werden alle Einsen zu Nullen und umgekehrt.

Wenn wir einen ganzzahligen Ausdruck haben, der 0000 1111 enthält, dann wird der Wert nach der Ausführung der bitweisen Komplementoperation zu 1111 0000.

Der bitweise Komplementoperator wird durch das Symbol Tilde (~) gekennzeichnet.

Schreiben wir ein Programm, das die Implementierung des bitweisen Komplementoperators demonstriert.

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

Ausgang:

Complement - Value of c is -11

Hier ist ein weiteres Programm mit einem Beispiel aller bisher besprochenen Operationen:

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

Nachdem wir das Programm kompiliert und ausgeführt haben, erzeugt es das folgende Ergebnis:

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

Zusammenfassung

• Bitweise Operatoren sind ein spezieller Operatorsatz, der von „C“ bereitgestellt wird.
• Sie werden in der Bit-Level-Programmierung verwendet.
• Diese Operatoren werden verwendet, um Bits eines ganzzahligen Ausdrucks zu manipulieren.
• Logische Operatoren, Verschiebungsoperatoren und Komplementoperatoren sind drei Typen von bitweisen Operatoren.
• Der bitweise Komplementoperator wird verwendet, um die Bits eines Ausdrucks umzukehren.