Ömer sagt:
Bitoperatoren klingen erstmal komisch – aber sobald du verstehst wie Bits funktionieren, öffnet sich eine ganz neue Welt! Embedded, Netzwerk, Grafik – überall stecken Bits dahinter. Los geht's!
Binär rechnen
AND / OR / XOR anwenden
Shift-Operatoren verstehen
Bit-Masken einsetzen
Flags in C programmieren
Übung 1 – Binär rechnen
Umrechnung und Bitoperationen per Hand
Rechne zuerst die Zahlen in Binär um, dann führe die Operationen durch:
| Dezimal | Binär (8 Bit) |
|---|
| 12 | |
| 7 | |
| 255 | |
Berechne nun die folgenden Ausdrücke – zuerst binär, dann als Dezimalzahl:
| Ausdruck | Binär-Rechnung | Ergebnis (dez.) |
|---|
| 12 & 7 | | |
| 12 | 7 | | |
| 12 ^ 7 | | |
Schreibe beide Zahlen untereinander und vergleiche Bit für Bit: AND = 1 nur wenn BEIDE 1 sind; OR = 1 wenn mind. eines 1 ist; XOR = 1 wenn genau eines 1 ist.
Übung 2 – Shift-Operatoren
Verschiebungen per Hand berechnen
Berechne die folgenden Shift-Ausdrücke. Schreibe auch das Muster das du erkennst:
| Ausdruck | Ergebnis | Entspricht |
|---|
| 3 << 2 | | |
| 16 >> 3 | | |
| 1 << 7 | | |
| 100 >> 2 | | |
Welches Muster erkennst du bei Links-Shift? Und bei Rechts-Shift?
Links-Shift um n = Multiplikation mit 2^n. Rechts-Shift um n = Integer-Division durch 2^n.
Übung 3 – Flags
Berechtigungsflags mit Bitoperatoren
Gegeben sind folgende Defines:
#define LESEN 1 // Bit 0
#define SCHREIBEN 2 // Bit 1
#define AUSFUEHREN 4 // Bit 2
Schreibe ein vollständiges Programm das:
- Eine Variable
rechte auf 0 setzt
- Alle drei Flags mit
|= setzt
- Jeden einzelnen Flag mit
& prüft und ausgibt ob er gesetzt ist
- SCHREIBEN mit
&= ~SCHREIBEN löscht
- Nochmal alle Flags prüft und ausgibt
#include <stdio.h>
#define LESEN 1
#define SCHREIBEN 2
#define AUSFUEHREN 4
int main() {
unsigned int rechte = 0;
/* 1. Alle Flags setzen */
/* 2. Flags prüfen und ausgeben */
printf("Lesen: %s\n", (rechte & LESEN) ? "JA" : "NEIN");
/* 3. SCHREIBEN löschen */
/* 4. Nochmal alle Flags ausgeben */
return 0;
}
Nach dem Setzen aller drei Flags hat rechte den Wert 7 (= 111 in binär). Nach dem Löschen von SCHREIBEN sollte es 5 (= 101) sein.
Übung 4 – Gerade/Ungerade
Funktion ist_gerade() mit Bitoperator
Schreibe die Funktion ist_gerade(int n) die nur den &-Operator verwendet (kein %!). Teste sie mit mindestens 10 verschiedenen Zahlen:
#include <stdio.h>
/* Gibt 1 zurück wenn n gerade, 0 wenn ungerade */
/* NUR &-Operator erlaubt! */
int ist_gerade(int n) {
}
int main() {
int zahlen[] = {0, 1, 2, 7, 8, 13, 100, 255, -4, -7};
int anzahl = 10;
for (int i = 0; i < anzahl; i++) {
printf("%4d ist %s\n",
zahlen[i],
ist_gerade(zahlen[i]) ? "gerade" : "ungerade");
}
return 0;
}
Das letzte Bit einer Zahl ist 1 wenn sie ungerade ist, 0 wenn sie gerade ist. Prüfe es mit n & 1.
Übung 5 – Programm
RGB-Farbmischer
Schreibe ein Programm das:
- R, G, B als
int-Werte (0–255) einliest
- Die drei Werte in einen einzigen
unsigned int packt: rgb = (r<<16) | (g<<8) | b
- Den Hex-Wert ausgibt (wie
#FF8000)
- Den Wert wieder entpackt und die drei Einzelwerte ausgibt zur Überprüfung
Rot (0-255): 255
Gruen (0-255): 128
Blau (0-255): 0
Farbe: #FF8000
Entpackt: R=255 G=128 B=0
#include <stdio.h>
int main() {
unsigned int r, g, b;
printf("Rot (0-255): "); scanf("%u", &r);
printf("Gruen (0-255): "); scanf("%u", &g);
printf("Blau (0-255): "); scanf("%u", &b);
/* Farbe packen */
unsigned int rgb = /* ? */;
/* Hex ausgeben */
printf("Farbe: #%06X\n", rgb);
/* Entpacken mit >> und & 0xFF */
unsigned int rot = /* ? */;
unsigned int gruen = /* ? */;
unsigned int blau = /* ? */;
printf("Entpackt: R=%u G=%u B=%u\n", rot, gruen, blau);
return 0;
}
Entpacken: (rgb >> 16) & 0xFF liefert den Rot-Anteil. 0xFF ist eine Maske für die untersten 8 Bits.
Bonus
Binärdarstellung ausgeben
Schreibe die Funktion drucke_binaer(unsigned int n) die eine beliebige Zahl in ihrer 32-Bit-Binärdarstellung ausgibt. Nutze nur Bit-Shifting und Masken (kein printf("%b") – das gibt es in Standard-C nicht!).
drucke_binaer(42):
00000000 00000000 00000000 00101010
drucke_binaer(255):
00000000 00000000 00000000 11111111
#include <stdio.h>
void drucke_binaer(unsigned int n) {
/* Schleife von Bit 31 bis Bit 0 */
for (int i = 31; i >= 0; i--) {
/* Bit i prüfen und '1' oder '0' ausgeben */
/* Nach jedem 8. Bit ein Leerzeichen */
if (i % 8 == 0 && i != 0) printf(" ");
}
printf("\n");
}
int main() {
printf("drucke_binaer(42):\n");
drucke_binaer(42);
printf("drucke_binaer(255):\n");
drucke_binaer(255);
printf("drucke_binaer(1 << 16):\n");
drucke_binaer(1 << 16);
return 0;
}
Prüfe Bit i mit (n >> i) & 1 – das verschiebt Bit i an Position 0 und maskiert alle anderen weg.
