Dieses Tutorial ist eine Ergänzung zu Tutorial http://www.lima-city.de/community/tutorials.php?mode=show&id=626
Es gibt fünf weitere Operatoren in C/C++, die auf Bitebene arbeiten:
Leftshift: <<
Rightshift: >>
Binär AND: &
Binär OR: |
Binär XOR: ^
Einige Anmerkungen vorweg:
In einem Byte werden die acht vorhandenen Bits auf eine bestimmte Art und Weise identifiziert. In einer schematischen Darstellung sieht das ungefähr so aus:
BIT 7 | BIT 6 | BIT 5 | BIT 4 | BIT 3 | BIT 2 | BIT 1 | BIT 0
Das bedeutet, das das Bit welches den niedrigsten Zahlenwert (also 1) anzeigt ganz rechts ist. Wenn also eine ein Byte breite Variable den Wert 1 hat, sieht es im Speicher so aus: 00000001
Es wird dann nach links weiter hochgezählt:
2 = 00000010
3 = 00000011
4 = 00000100
u.s.w. Eigentlich genauso wie im Dezimalsystem, nur das wir hier immer nach Links mit 0 bis auf 8 Stellen auffüllen.
Wenn ihr Windows benutzt, findet ihr unter Zubehör das Programm Rechner. Startet das, stellt unter "Ansicht" um auf "Wissenschaftlich". Auf der linken Seite könnt ihr von einem Zahlensystem ins andere schalten (die Reihe "Hex" (Hexadezimalsystem) "Dec" (normales Dezimalsystem) "Oct" (Oktalsystem) "Bin" (Binärsystem). Wenn ihr das normale Zahlensystem eingeschaltet lasst, eine Zahl eingebt und dann auf ein anderes Zahlensystem umschaltet, wird die eingegebene Zahl umgewandelt. Beim Binärsystem müsst ihr in Gedanken auf der linken Seite Nullen auffüllen, bis ihr 8 Stellen habt, damit das genauso aussieht wie hier beschrieben.
Leftshift (<<):
-----------------
Hier werden die Bits von Bit 0 aus gesehen in Richtung Bit 7 geschoben.
Beispiel:
unsigned char x = 2; // x binär: 00000010
unsigned char ergebnis;
ergebnis = x << 1; // ergebnis nach zuweisung: 00000100 (dezimal: 4)
In diesem Fall wird der Wert von x eine um eine Stelle nach links verschoben und ergebnis zugewiesen. Bei "ergebnis = x << 2;" wäre der Wert von x um 2 Stellen nach links verschoben worden u.s.w. (ergebnis wäre dann binär: 00001000).
Bei einem Leftshift werden die Stellen, die rechts wieder aufgefüllt werden immer mit 0 gefüllt. Wenn Ziffern über das Bit 7 hinausgeschoben werden, verfallen sie einfach.
Beispiel:
unsigned char x = 201; // x binär: 11001001
unsigned char ergebnis;
ergebnis = x << 2; // ergebnis nach zuweisung: 00100100 (dezimal: 36)
Rightshift (>>):
-------------------
Der Rightshift funktioniert genauso wie der Leftshift, aber in die andere Richtung. Deshalb hier nur ein kurzes Beispiel.
Beispiel:
unsigned char x = 30; // x binär: 00011110
unsigned char ergebnis;
ergebnis = x >> 3; // ergebnis nach zuweisung: 00000011 (dezimal: 3)
Binäres AND (&):
---------------------
Der binäre AND Operator sieht zwei anderen Operatoren sehr ähnlich: dem booleschen AND Operator (&&) und dem Addressoperator (&). Der boolsche AND Operator && und der binäre Operator & arbeiten beide von der Logik her gleich, allerdings sind die Auswirkungen anders. Achtet also darauf, das ihr die beiden nicht verwechselt. Schaut bitte im Tutorial "Operatoren in C" nach, wenn ihr was zum booleschen Operator wissen wollt.
Der Addressoperator & und der binäre Operator & unterscheiden sich nur da drin, wo sie in einem Quelltext stehen.
Steht das Zeichen in einm Funktionskopf ("int rechne(int & x, int & y)"), so handelt es sich hier um den Addressoperator (in diesem Fall Referenzoperator genannt). Steht & zwischen zwei Variablen oder Konstanten, so handelt es sich um den binären AND Operator. In allen anderen Fällen handelt es sich um den Addressoperator.
Beispiele für binären AND Operator:
a = b & c;
a & b;
a = b & 1;
a = 2 & 3;
Beispiele für Addressoperator:
int rechne(int & x, int & y);
int * x = &y;
char string[12] = "hallo horst"; strcpy(name, &string[6]);
Für Erklärungen über den Addressoperator schaut bitte in Tutorials nach mit den Titeln nach, in denen das Wort "Zeiger" bzw. "Pointer" vorkommt.
Der binäre AND Operator vergleicht binär zwei Werte und liefert sozusagen die binäre Übereinstimmung der beiden Werte zurück.
Beispiel:
x = 2; // binär 00000010
y = 7; // binär 00000111
x & y; // binär 00000010
Nur an den Stellen, an denen bei beiden Werten 1 steht, kommt bei dem Ergebnis auch eine 1 hin.
Binäres OR (|):
-------------------
Der binäre OR Operator funktioniert ungefähr so wie der binäre AND Operator. Der Unterschied ist, das bei dem Ergebnis alle Stellen auf 1 gesetzt werden, die bei Wert eins und/oder bei Wert zwei auf 1 gesetzt sind.
Beispiel:
x = 57; // binär 00111001
y = 138; // binär 10001010
x & y; // binär 10111011
Binäres XOR (^):
----------------------
Der binäre XOR Operator funktioniert fast genauso wie der binäre OR Operator. Der Unterschied ist, das bei dem Ergebnis nur die Stellen auf 1 gesetzt werden, bei denen NUR EINER der Werte an der Stelle auf 1 gesetzt ist.
Beispiel:
x = 57; // binär 00111001
y = 138; // binär 10001010
x & y; // binär 10110011
Tabellarische Übersicht:
------------------------------
0 & 0 -> 0
1 & 0 -> 0
0 & 1 -> 0
1 & 1 -> 1
0 | 0 -> 0
1 | 0 -> 1
0 | 1 -> 1
1 | 1 -> 1
0 ^ 0 -> 0
1 ^ 0 -> 1
0 ^ 1 -> 1
1 ^ 1 -> 0
Wie bei den arithmetischen Operatoren, gibt es auch bei den binären Operatoren die Möglichkeit, den benutzten Operator mit einer gleichzeitigen Zuweisung zu benutzen:
&=
|=
^=