Bitgewise -Operatoren in C

In diesem Linux -Hinweis Artikel, alles über bitweise logische Operationen wird erklärt. Unter Verwendung eines praktischen Beispiels mit Bildcodefragmenten sehen wir jeden der in der C -Sprache verwendeten logischen Operatoren im Detail.

Außerdem werden wir erklären, wie man mit logischen Operationen eine Bitmaskierung durchführt, da dies etwas sehr nützliches in der Programmierung ist und vollständig mit dieser Art von Operatoren zusammenhängt.

Beschreibung der bitimen Operationen

Die bitweisen Vorgänge sind logisch und Schichtvorgänge werden einzeln auf jedes Bit einer Variablen angewendet. Wenn wir beispielsweise die Operation anwenden und zwischen den Variablen "A" und "B" anwenden, wird Bit 0 von "A" mit Bit 0 von "B" verknüpft, Bit 1 von "A" wird mit Bit 1 von 1 verknüpft "B" und so weiter.

Jedes Bit arbeitet und gibt sein eigenes Ergebnis zurück und hat keinen Einfluss auf das Ergebnis der angrenzenden Bits.

Diese Art des Betriebs ist sehr nützlich bei Maskieren von Bits bei der Verwendung von Steuerflags oder Indikatoren, die in ein einzelnes Datenelement wie eine Ganzzahl gruppiert sind.

Wie man einer Variablen in der C -Sprache einen binären Wert zuweist

Bevor wir anfangen zu erklären, worum es bei bitweisen logischen Operationen geht, sollten wir uns ansehen, wie Sie einer Variablen im Binärcode einen Wert zuweisen können viel praktischer und verständlicher. Zum Beispiel in Fällen, in denen die Bits Kontrollflags oder Indikatoren darstellen.

Um einer Variablen im Binärform einen Wert zuzuweisen, müssen wir die binäre Darstellung mit "0b" Präfix vorfixieren. Das folgende Ausschnitt weist dem Wert der Ganzzahl „A“ im Binärformat den Wert 131 oder 0B10000011 zu und zeigt dann seine Dezimalzahlung in der Befehlskonsole an.

#enthalten
void main ()
int a;
a = 0b10000011;
printf ("Die Dezimalstellen für 0B10000011 lautet: %i \ n", a);

Das folgende Bild zeigt das Ergebnis für diesen Code.

Die Darstellung von Binärwerten in bitweise und maskierenden Operationen macht die Programmierung viel flüssiger und verständlicher und vermeidet Fehler oder Umwandlungen, die die Zeit kosten.

Nicht Bediener

Der logische Operator für das Nicht ist das Symbol "~".

Die logische oder Negationsoperation ist die einfachste von allen, die nur einen Eingang und einen Ausgang haben.

Diese Operation kehrt in seiner Ausgabe zurück, den umgekehrten binären Wert seiner Eingabe.

Betrachten Sie den folgenden Ausdruck für die logische Operation nicht mit dem Eingang „A“

c = ~ a

Das Ergebnis in „C“ ist gleich 1, wenn „A“ gleich 0 ist und „C“ gleich 0 ist, wenn „A“ gleich 1 ist. Dieser Vorgang wird üblicherweise verwendet, um den komplementären Wert einer Variablen zu erhalten.

Lassen Sie uns als nächstes die Wahrheitstabelle für die Nichtoperation betrachten.

A	~	=	C
0	~	=	1
1	~	=	0

Beispiel:

In diesem Beispiel werden wir den Vorgang nicht auf die Variable A anwenden, um seine Ergänzung in „C“ zu erhalten

Dazu erstellen wir die Variable A vom nicht signierten Zeichen vom Typ, zuweisen ihm den Wert 131 und erstellen das Ergebnis in „C“. Wir verwenden dann die Funktion printf (), um das Ergebnis in der Befehlskonsole anzuzeigen. Im Folgenden können wir den Code für diesen Zweck sehen.

#enthalten
void main ()

nicht signiertes Char C;
nicht signiertes Zeichen A;
A = 0B01111100;
c = ~ a;
printf ("\ nDie Dezimalpräsentation für 0B10000011 ist: %i \ n", c);

In der folgenden Abbildung sehen wir das Ergebnis der Ergänzung von „A“ . In diesem Fall beträgt das Komplement oder die Umkehrung von 131 124 oder 01111100 in der binären Darstellung.

Logisch und Operator

Der logische Operator für den und Betrieb ist das Symbol „&“

Schauen wir uns den folgenden Ausdruck für logisch und operativ zwischen den Variablen A und B an

c = a & b.

Das Ergebnis in „C“ entspricht nur 1, wenn „A“ und „B“ gleich 1 sind. In allen anderen Fällen ist „C“ gleich 0.

Als nächstes schauen wir uns die Wahrheitstabelle für die Operation an und.

A	&	B	=	C
0	&	0	=	0
0	&	1	=	0
1	&	0	=	0
1	&	1	=	1

Die logische Operation und ist bei der Bitmaskierung sehr nützlich. Später sehen wir einen Abschnitt, der diese Technik genauer erläutert.

Beispiel:

Lassen Sie uns nun ein Beispiel sehen, in dem wir die logische und den Betrieb zwischen den Variablen "A" und "B" vom nicht signierten Zeichen vom Typ Typ ausführen und das Ergebnis in „C“ speichern, um es später in der Befehlskonsole anzuzeigen.

Wir weisen dem Wert 135 oder 10000111 der Variablen „A“ und 129 oder 1000001 der Variablen „B“ in der binären Darstellung zu. Dann werden wir den Bediener „&“ verwenden, um den Vorgang auszuführen. Als nächstes werden wir den Code dafür sehen.

#enthalten
void main ()

nicht signiertes char a = 0b10000111;
nicht signiertes char b = 0b10000001;
nicht signiertes Char C;
c = a & b;
printf ("\ nDie Ergebnis von A & B ist: %i \ n", c);

Das Bild zeigt das Ergebnis dieses Code 10000001 in binär.

Logisch oder operator

Der logische Operator für den oder Operationen ist das Symbol | | “.

Schauen wir uns den folgenden Ausdruck für die logische oder operation zwischen den Variablen A und B an

c = zu | B.

Das Ergebnis in „C“ entspricht nur 1, wenn „A“ oder „B“ oder „A“ und „B“ 1 gleich 1 sind, während es nur dann 0 entspricht, wenn „A“ und „B“ beide gleich 0 sind.

Lassen Sie uns als nächstes den Wahrheitstisch für die oder Operation betrachten.

Zu	|	B	=	C
0	|	0	=	0
0	|	1	=	1
1	|	0	=	1
1	|	1	=	1

Beispiel

In diesem Beispiel werden wir sehen, wie Sie den logischen Betrieb oder zwischen den Variablen "A" und "B" vom nicht signierten Zeichen vom Typ ausführen und das Ergebnis in „C“ speichern, um es später in der Befehlskonsole anzuzeigen.

Wir weisen den Wert 128 oder 10000000 der Variablen „A“ und 3 oder 00000011 der Variablen „B“ in der binären Darstellung zu. Dann verwenden wir den Bediener „|“, um den Vorgang auszuführen. Als nächstes sehen wir den Code für diesen Vorgang.

#enthalten
void main ()

nicht signiertes char a = 0b10000000;
nicht signiertes char b = 0b00000011;
nicht signiertes Char C;
c = zu | B;
printf ("\ nDie Ergebnis von a | b ist: %i \ n", c);

Im Bild unten sehen wir das Ergebnis der Operation C = A | B was in diesem Fall 131 oder 10000011 in binär.

Logischer Operator xor oder exklusiv oder

Der logische Operator für die XOR -Operation ist das Symbol " ^".

Schauen wir uns den folgenden Ausdruck für die logische XOR -Operation zwischen den Variablen A und B an

c = a ^ b.

Das Ergebnis in „C“ entspricht nur 1, wenn eines der Bits „A“ oder „B“ gleich 1 ist, aber es ist 0, wenn „A“ und „B“ beide gleich 1 oder gleich 0 sind.

Diese Operation ist bei Addingern von wesentlicher Bedeutung, da im binären System 1 + 0 = 1 oder 0 + 1 ebenfalls gleich 1 ist. Aber 1 + 1 = 0 mit Trag zum nächsten höheren Bit. In diesem Fall wird der Trage durch die Operation durchgeführt und.

Als nächstes schauen wir uns die Wahrheitstabelle für die XOR -Operation an.

A	^	B	=	C
0	^	0	=	0
0	^	1	=	1
1	^	0	=	1
1	^	1	=	0

Beispiel

Sehen wir uns nun ein Beispiel an, in dem wir den logischen XOR -Betrieb zwischen den Variablen "A" und "B" vom Typ vorgewiesenen Zeichen ausführen und das Ergebnis "C" speichern, um es später in der Befehlskonsole anzuzeigen.

Wir weisen dem Wert 135 oder 10000111 der Variablen „A“ und 3 oder 000011 der Variablen „B“ in Binärnotation zu. Dann verwenden wir den " ^" -Preiber, um den logischen Betrieb auszuführen. Als nächstes werden wir den Code dafür sehen.

#enthalten
void main ()

nicht signiertes char a = 0b10000111;
nicht signiertes char b = 0b00000011;
nicht signiertes Char C;
c = a ^ b;
printf ("\ nDie Ergebnis von a | b ist: %i \ n", c);

Wie wir im Bild sehen können, ist das Ergebnis 10000100 und die Bits, deren zwei Eingänge = 1 xor sind, führt zu 0.

Operatoren mit Zuordnung

Die Operatoren mit Zuordnung führen die gleichen logischen Operationen aus, die wir zuvor gesehen haben, aber ihr Ergebnis wird im Operanden gespeichert, das dem Bediener vorausgeht.

Der folgende Ausdruck führt die logische und den Betrieb zwischen der Variablen „A“ und der nach dem Bediener zugewiesenen Variablen oder dem Wert aus, und das Ergebnis wird in „A“ zurückgegeben.

A & = 55;

Rotationsoperatoren

Die Rotationsoperatoren sind “< > “.

Diese Operatoren verschieben die Daten einer Variablen durch „N“ -Bits nach links bzw. nach rechts.

Im folgenden Ausdruck verschiebt der Bediener die in „A“ 5 Bit gespeicherten Daten nach links.

a = a < < 5

Beispiel

In diesem Beispiel werden wir der Variablen „A“ den Wert 0b000001 zuweisen und dann 1 Bit nach links in a for Loop verschieben und den resultierenden Wert in der Befehlskonsole ausgeben. Dieser Zyklus wird 8 Mal wiederholt

#enthalten
void main ()

nicht signiertes char a = 0b00000001;
nicht signiertes Char C;
für (int bit = 0; bit!= 8; Bit ++)
printf ("%i \ n", a);
a = a<<1;

Im folgenden Bild sehen wir das Ergebnis mit den Dezimalwerten, die jeder Position der Bits in einem nicht signierten Zeichen entsprechen.

Bitmaskierung

In bestimmten Fällen, z. B. wenn wir mehrere in einem einzelnen Register gruppierte Kontrollflags definieren, müssen wir nur den Wert eines oder mehrerer Bits kennen oder ändern, nicht das gesamte Register.

Um den Status einer oder mehrerer spezifischer Bit.

Wenn wir beispielsweise den Wert von Bits 0 und 2 der Variablen „A“ erhalten möchten, müssen wir die folgende Maske definieren und die und den Betrieb ausführen.

00000101

In diesem Fall wird nur der Status von Bits 0 und 2 zurückgegeben. Die verbleibenden Bits haben den Wert = 0, unabhängig davon, welcher Wert sie haben, "a", haben sie.

Um den Wert zu ändern, müssen wir die oder den Betrieb zwischen der Maske mit den Bits anwenden, die wir auf 1 und die Variable festlegen möchten, die wir ändern möchten. Wenn wir es auf 0 einstellen wollen, müssen wir die Maske wie unten gezeigt umkehren und die und den Betrieb anwenden.

11111010

Beispiel

In diesem Beispiel verwenden wir eine Bitmaskierung, um einen einfachen und praktischen Konverter von Dezimalzahlen zu einer Zeichenfolge mit seiner binären Darstellung zu erstellen.

Für dieses Gespräch werden wir 8 Masken für jedes Stück verwenden, aber um die Programmierung praktischer und klarer zu gestalten, werden wir zuerst die Maske 10000000 verwenden und dann in jedem Zyklus der Schleife ein Bit nach rechts bewegen. Auf diese Weise erhalten wir die folgenden 8 Masken, die wir brauchen.

10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001

Der Konverter besteht aus einer für Schleife mit 8 Zyklen, in denen jeder den Status des entsprechenden Bits abfragt. Dies erfolgt durch A und den Betrieb zwischen den zu konvertierten Daten und der entsprechenden Maske.

Wenn das Ergebnis des Vorgangs in „C“ 0 ist, geben Sie diesen Wert mit der FRINCE () -Funktion aus. Andernfalls wird der Wert des Bits 1 in der Befehlskonsole gedruckt.

Unten finden Sie den Code für diesen praktischen Konverter.

#enthalten
void main ()
nicht signiertes Zeichen A = 143;
nicht signiertes char b = 0b10000000;
nicht signiertes Char C;
printf ("\ n die binäre Darstellung von a ist:");
für (int bit = 0; bit!= 8; Bit ++)
c = a & b;
if (c == 0)
printf ("0");
anders
printf ("1");
B = B >> 1;
c = 0;

printf ("\ n \ n");

Im folgenden Bild sehen wir unten das Ergebnis der Konvertierung für die Nummer 143.

Abschluss

In diesem Linux -Hinweis Artikel, wir haben jeden der logischen und Rotationsoperatoren erklärt, dass die C -Sprache eine bitweise Verarbeitung bietet. Für jeden dieser Operatoren haben wir einen Abschnitt erstellt, der das für diese Operatoron -Beschreibung verwendete Symbol und ein praktisches Beispiel mit Code -Ausschnitten und -bildern für jeden zeigt. Wir haben auch einen Abschnitt mit Bitmaskierung und einem Zusatz beigefügt, der vollständig mit logischen Operationen dieser Art zusammenhängt.