Logische Operatoren

 In den hier gezeigten Beispielen gehen wir mal von folgenden Situationen aus..
Wir nutzen die Variablen x = 5, y = 4, z = 0;

+ Addierungs Operator   (x + y oder x+=y)
- Subtrahierungs Operator  (x - y oder x-=y)
* Multiplikations Operator  (x * y oder x*=y)
/ Divisions Operator  (x / y oder x/=y)
 
Hier muss ich nicht weiter drauf eingehen (glaube ich!)..
 
Hier mal die Übersicht einiger Operatoren die in der Programmiersprache "C" wieder zu finden sind.

Der UND Operator 

0b11110000
0b10001111
&--------------------
0b10000000 // Ergebnis

Wie man sieht, müssen zwei gleiche Zustände oder Bits ("0" oder "1") gleich sein
damit man im Ergebnis auch eine "1" setzen kann. Ist dies nicht der Fall, wird eine
"0" gesetzt.

 

Der ODER Operator 

0b11110001
0b00001111
|--------------------
0b11111111 // Ergebnis

Auf dem ersten Blick erkennen wir, dass mit dem ODER Operator jedes Bit in einem Byte gesetzt werden kann,
unabhängig vom vorherigem Zustand.
  

Der XOR(EXKLUSIV ODER) Operator 

0b10101010
0b01010101
^--------------------
0b11111111 // Ergebnis (bsp. 1)
  
0b10101111
0b01010101
^--------------------
0b11111010 // Ergebnis (bsp. 2)

Der "^" Operator ist das Gegenteil vom "|" Operanten. Hier müssen sich die Zustände unterscheiden, damit ein Bit gesetzt werden kann.

Der NEGATIONS Operator 

0b00000000
~--------------------
0b11111111 // Ergebnis

Der "~" Operator dreht einfach die Werte "um". Ist es vorher eine "1" so ist es nach dem ausführen des Operators eine "0". Es werden die Zustände einfach umgedreht.

Es folgen Scripts zur dynamischen Berechnung!

----------------------------------------------------------------------------

Um bei einer Variablen ein Bit zu setzen gibt es mehrere Möglichkeiten. Hier stelle ich mal einige davon vor..

uint8_t tmp = 0; // eine einfache variable, bestehend aus 8 Bit (1 Byte)
Bits schieben  -> tmp = (1<<7)
Hexadezimal    -> tmp = 0x80
Dezimal        -> tmp = 128 
Binär          -> tmp = 0b10000000

Mit jeder dieser Schreibweisen, kann man zum gleichen Ergebnis kommen. Es wird jeweils das 7 Bit in einem Byte (in diesem Fall "tmp") gesetzt. Die anderen bleiben "0"

Nun haben wir in der Variablen das 7 Bit gesetzt. Wie bekommen wir ein weiteres Bit gesetzt ohne das andere mit überschrieben werden? Das kann passieren! Vorsicht! Dort hatte ich am Anfang auch meine Probleme.

Hier gibt es auch wieder verschiedene Möglichkeiten..

Bits schieben -> tmp |= (1<<6)
Hexadezimal   -> tmp |= 0x40
Dezimal       -> tmp |= 64
Binär         -> tmp |= 0b01000000

In diesem Beispiel wurde der "|" Operator eingesetzt. Damit haben wir, im Endeffekt ein Bit hinzugefügt. Es gibt auch noch andere Schreibweisen. Das ist Geschmackssache. Ich empfehle für den Anfang die "Binär" Schreibweise.

Wie aber lösche ich jetzt ein Bit ohne die anderen in Mitleidenschaft gezogen werden?

Bits schieben  -> tmp &= ~(1<<6)
Hexadezimal    -> tmp &= ~(0x40)
Dezimal        -> tmp &= ~(64)
Binär          -> tmp &= ~(0b01000000)

Hier kommen gleich zwei Operatoren ins Spiel. Einmal der "&" Operator und der "~" Operator.
Als erstes wird das ganze Byte "maskiert". Das bedeutet eigentlich nur das die anderen Bits nicht mit in die Rechnung einbezogen werden, bis auf das was hinter dem "=" Zeichen steht. Das nennt man "maskieren". Das Bit wird jetzt mit der aktuellen Variablen "tmp" verundet (tmp&=..). Da vorher in der Variablen "tmp" das Bit gesetzt war und jetzt auch wieder gesetzt ist (1<<6) bekommen wir in diesem ersten Teilergebnis eine "1" (jetzt mal in Binärer Schreibweise 0bx1xxxxxx). Hinter dem "=" kommt dann direkt der nächste Operator. Hier wird das Bit einfach umgedreht. Das bedeutet im Endeffekt eigentlich nur das wir aus der Logischen "1" eine "0" gemacht haben.

In der Variablen "tmp" steht jetzt folgender Wert ->

tmp = 0b10000000.

Das "6" Bit (1<<6) haben wir maskiert und negiert ohne das die Vorherigen Bits in diesem Fall das "7" Bit (1<<7) gelöscht oder überschrieben wurde.

Ich hoffe das war ein wenig Verständlich?

 

 

Kommentar schreiben

Loading