# Bitmanipulation in 16-Bit-Zahlen

Ein einzelnes Bit in einer 16-Bit-Zahl wird über eine **Maske** angesprochen. Die Bitverschiebung erzeugt die Maske, die logische Operation entscheidet, was mit dem Zielbit passiert.

---

## 1. Die Maske: Bitverschiebung

`1 << n` schiebt die 1 um `n` Stellen nach links. Es entsteht eine Maske, bei der genau Bit `n` gesetzt ist.

```
1           0000 0000 0000 0001
1 << 1      0000 0000 0000 0010
1 << 2      0000 0000 0000 0100
1 << 3      0000 0000 0000 1000
1 << 7      0000 0000 1000 0000
1 << 15     1000 0000 0000 0000
```

- Bit 0 = niederwertigstes Bit (LSB, rechts)
- Bit 15 = höchstwertigstes Bit (MSB, links)
- Jede Verschiebung um 1 nach links entspricht einer Multiplikation mit 2 → `1 << n` ist **2ⁿ**

---

## 2. Übersicht der Operationen

| Ziel | Operation | Ausdruck |
|------|-----------|----------|
| Bit setzen | OR | `zahl \|= (1 << n)` |
| Bit löschen | AND mit invertierter Maske | `zahl &= ~(1 << n)` |
| Bit abfragen | AND | `if (zahl & (1 << n))` |
| Bit umschalten | XOR | `zahl ^= (1 << n)` |

---

## 3. Beispiele

**Ausgangswert:** `zahl = 0000 0000 1010 0101` (0x00A5)

```
Bit:  15 14 13 12 | 11 10  9  8 |  7  6  5  4 |  3  2  1  0
       0  0  0  0 |  0  0  0  0 |  1  0  1  0 |  0  1  0  1
```

### 3.1 Bit setzen — OR (`|`)

```
zahl        0000 0000 1010 0101
1 << 3      0000 0000 0000 1000     |
                                    -----
Ergebnis    0000 0000 1010 1101
                            ^ neu 1
```

Wahrheitstabelle: `0|0=0`, `0|1=1`, `1|0=1`, `1|1=1`
→ Maske-0 lässt durch, Maske-1 erzwingt 1.

### 3.2 Bit löschen — AND mit `~` (`& ~`)

```
1 << 2      0000 0000 0000 0100
~(1 << 2)   1111 1111 1111 1011

zahl        0000 0000 1010 0101
~Maske      1111 1111 1111 1011     &
                                    -----
Ergebnis    0000 0000 1010 0001
                             ^ jetzt 0
```

Wahrheitstabelle: `1&1=1`, `1&0=0`, `0&x=0`
→ Maske-1 lässt durch, Maske-0 erzwingt 0.

### 3.3 Bit abfragen — AND (`&`)

Bit 5 ist gesetzt:

```
zahl        0000 0000 1010 0101
1 << 5      0000 0000 0010 0000     &
                                    -----
Ergebnis    0000 0000 0010 0000  != 0  -> Bit ist gesetzt
```

Bit 4 ist nicht gesetzt:

```
zahl        0000 0000 1010 0101
1 << 4      0000 0000 0001 0000     &
                                    -----
Ergebnis    0000 0000 0000 0000  == 0  -> Bit ist nicht gesetzt
```

### 3.4 Bit umschalten — XOR (`^`)

```
zahl        0000 0000 1010 0101
1 << 0      0000 0000 0000 0001     ^
                                    -----
Ergebnis    0000 0000 1010 0100
                               ^ 1 -> 0
```

Dieselbe Operation nochmal stellt den Ausgangswert wieder her:

```
            0000 0000 1010 0100
            0000 0000 0000 0001     ^
                                    -----
            0000 0000 1010 0101  -> Ausgangswert
```

Wahrheitstabelle: `0^0=0`, `0^1=1`, `1^0=1`, `1^1=0`
→ Maske-0 lässt durch, Maske-1 kippt.

---

## 4. Merksatz

> Die **Verschiebung** baut die Maske, die **logische Operation** bestimmt die Wirkung:
> OR zum Setzen, AND-mit-`~` zum Löschen, AND zum Prüfen, XOR zum Umschalten.