# Notes 4.5

Quelle: https://inf.zone/lectures/4.5-morememory/notes45/

**Entwurf** für die Vorlesung am 23. November. Nach der Vorlesung aktualisieren wir diese Seite, in der Regel ein bis zwei Tage später. Was sich geändert hat, steht dann hier.

*Sie können diese Seite ausdrucken oder mit einem PDF-Drucker in ein PDF umwandeln, um Ihre eigenen Notizen hinzuzufügen.*

*Zum Stoff dieser Vorlesung gibt es drei Shorts: [4.4 Dynamischer Speicher](https://inf.zone/lectures/4-memory/short-4-4-dynamischer-speicher/), [4.5 Call Stack](https://inf.zone/lectures/4-memory/short-4-5-call-stack/) und [4.6 File Pointer](https://inf.zone/lectures/4-memory/short-4-6-file-pointer/).*

In Vorlesung 4 haben Sie Pointer kennengelernt: Jede Variable liegt an einer Adresse, `&` liefert sie, `*` geht dorthin. Diese Vorlesung fragt, **wo** die Variablen eines Programms leben: die einer Funktion auf dem **Stack**, das, was `malloc` reserviert, auf dem **Heap**. Danach lesen und schreiben Sie **Dateien**, das brauchen Sie für Übung 6, und Sie lesen **Eingaben** mit `scanf` und `fgets` ein. Zwischendurch üben Sie noch einmal `&`, `*`, Pointerarithmetik und 2D-Arrays. Das Midterm am 7. Dezember prüft alles bis einschließlich dieser Vorlesung.

## Wiederholung: Wer ändert `x`?

Wählen Sie die Stufe, die Sie schaffen; alle drei sind gleich viel wert. Ohne Laptop, auf Papier. Gegeben sind drei Funktionen:

```c
void f(int a)
{
    a = 0;
    printf("a in f: %i\n", a);
}

void g(int *a)
{
    *a = 0;
}

void h(int *a)
{
    int b = 0;
    a = &b;
    *a = 1;
}
```

In `main` steht jeweils vorher `int x = 5;`.

1. **Stufe 1:** Welchen Wert hat `x` nach `f(x);`?
2. **Stufe 2:** Welchen Wert hat `x` nach `g(&x);`?
3. **Stufe 3:** Welchen Wert hat `x` nach `h(&x);`? Skizzieren Sie dazu `x`, `a` und `b` als Kästchen und eine Adresse als Pfeil, einmal vor und einmal nach `a = &b;`.

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

### Pointer-Syntax in Kürze

- **Adressoperator `&`:** Gibt die Speicheradresse einer Variable zurück
- **Dereferenzierungsoperator `*`:** Greift auf den Wert an einer Speicheradresse zu
- **Pointer-Deklaration:** `int *p = &n;` – p speichert die Adresse von n
- **Dereferenzierung:** `*p` gibt den Wert an der Adresse zurück (oder setzt ihn)
- **Array-Pointer-Äquivalenz:** `s[i]` ist identisch mit `*(s + i)`
- **Strings:** Ein `char*` zeigt auf das erste Zeichen; `\0` markiert das Ende

**Selbsttest:**

Was liefert in C der Operator `&` vor einer Variable?

**Antwort:**

Die **Speicheradresse** der Variable.

**Selbsttest:**

Was bewirkt der Operator `*` vor einem Pointer (Dereferenzierung)?

**Antwort:**

Er greift auf den **Wert an der Speicheradresse** zu, die im Pointer steht (lesen oder setzen).

**Selbsttest:**

Welcher Ausdruck mit Pointer-Arithmetik ist identisch mit `s[i]`?

**Antwort:**

`*(s + i)`

**Selbsttest:**

Worauf zeigt ein `char*`, der einen String darstellt?

**Antwort:**

Auf das **erste Zeichen** des Strings; das Ende markiert `\0`.

## Der Stack: ein Karton je Aufruf

Jeder Aufruf einer Funktion bekommt einen eigenen Bereich im Speicher für seine Parameter und lokalen Variablen, einen **Frame** (auch Stack-Frame). In der Vorlesung war das ein Karton: unten der türkise Karton von `main` mit `x = 1`, darauf der blaue Karton von `f` mit `a = 42`. Die Kartons stapeln sich, und dieser Bereich des Speichers heißt deshalb **Stack** (Stapel).

*Was nach `return` im Karton liegt, haben wir in der Vorlesung auf der Bühne gezeigt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

```c
#include <stdio.h>
#include <stdlib.h>

void f(void)
{
    int a = 42;
    printf("a in f: %p\n", &a);
}

void g(void)
{
    int b = 7;
    printf("b in g: %p\n", &b);
}

int main(void)
{
    int x = 1;
    printf("x in main: %p\n", &x);
    f();
    g();
    int *h = malloc(sizeof(int));
    if (h == NULL)
    {
        return 1;
    }
    printf("h zeigt auf: %p\n", h);
    free(h);
}
```

*Ob `a` und `b` dieselbe Adresse bekommen und wo `malloc` Speicher holt, haben wir in der Vorlesung vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

Wie groß darf ein Frame werden? `gross.c` legt 10 Millionen `int` als lokale Variable an, also 40 Millionen Bytes:

```c
#include <stdio.h>

int main(void)
{
    int zahlen[10000000];
    zahlen[0] = 1;
    printf("%i\n", zahlen[0]);
}
```

*Was dabei passiert, haben wir in der Vorlesung vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

### Frames im Detail

Wie die Frames im Speicher liegen, zeigt auch ein Programm mit mehreren Funktionen, die jeweils eine lokale Variable verwenden:

```c
#include <stdio.h>

void f(void)
{
    char s2[10] = "Hello";
    printf("%p %s (in f)\n", s2, s2);
}

int main(void)
{
    char s1[10] = "Hi";
    printf("%p %s (in main)\n", s1, s1);
    f();
}
```

Ausgabe:
```
0x7ffffffc4eb6 Hi (in main)
0x7ffffffc4e96 Hello (in f)
```

Die Adresse in `f` ist **kleiner** als in `main`! Man sagt: Der Stack „wächst nach unten“, also zu kleineren Adressen, wenn eine Funktion aufgerufen wird.

Fügen wir eine dritte Funktion hinzu, die von der zweiten aufgerufen wird:

```c
#include <stdio.h>

void g(void)
{
    char s3[10] = "World";
    printf("%p %s (in g)\n", s3, s3);
}

void f(void)
{
    char s2[10] = "Hello";
    printf("%p %s (in f)\n", s2, s2);
    g();  // f ruft g auf!
}

int main(void)
{
    char s1[10] = "Hi";
    printf("%p %s (in main)\n", s1, s1);
    f();
}
```

Ausgabe:
```
0x7ffffffc4eb6 Hi (in main)
0x7ffffffc4e96 Hello (in f)
0x7ffffffc4e76 World (in g)
```

In `g` hat der String eine noch kleinere Adresse – wie erwartet.

Jede Funktion bekommt ihren eigenen Bereich auf dem Stack – einen **Stack-Frame**. Die Adressen werden immer kleiner, je tiefer wir in die Funktionsaufrufe gehen.

### Stack-Wachstum bei verschachtelten Aufrufen

Schauen wir uns die zeitliche Abfolge an. Der Stack wächst zu niedrigeren Adressen („nach oben“ im Diagramm):

```
  (1) in main()       (2) in f()            (3) in g()

                                            ┌────────────────┐
                                            │ g(): "World"   │
                                            │ 0x...4e76      │
                      ┌────────────────┐    ├────────────────┤
                      │ f(): "Hello"   │    │ f(): "Hello"   │
                      │ 0x...4e96      │    │ 0x...4e96      │
┌────────────────┐    ├────────────────┤    ├────────────────┤
│ main(): "Hi"   │    │ main(): "Hi"   │    │ main(): "Hi"   │
│ 0x...4eb6      │    │ 0x...4eb6      │    │ 0x...4eb6      │
└────────────────┘    └────────────────┘    └────────────────┘
```

In Schritt (3) sind alle drei Stack-Frames gleichzeitig aktiv: `main()` hat `f()` aufgerufen, und `f()` hat `g()` aufgerufen.

Was passiert beim Zurückkehren?

```
  (4) nach g()        (5) nach f()
      zurück in f()       zurück in main()

┌────────────────┐
│ f(): "Hello"   │
│ 0x...4e96      │
├────────────────┤    ┌────────────────┐
│ main(): "Hi"   │    │ main(): "Hi"   │
│ 0x...4eb6      │    │ 0x...4eb6      │
└────────────────┘    └────────────────┘
```

Wenn `g()` zurückkehrt (Schritt 4), wird sein Stack-Frame „freigegeben“ – er wird nicht aktiv überschrieben, aber der Compiler weiß, dass dieser Speicherbereich nun wieder verfügbar ist. Wenn dann `f()` zurückkehrt (Schritt 5), wird auch dessen Frame freigegeben.

### Zwei Aufrufe nacheinander

Um das „Freigeben“ besser zu verstehen, ändern wir das Programm: Statt dass `f()` die Funktion `g()` aufruft, ruft nun `main()` beide Funktionen nacheinander auf:

```c
#include <stdio.h>

void g(void)
{
    char s3[10] = "World";
    printf("%p %s (in g)\n", s3, s3);
}

void f(void)
{
    char s2[10] = "Hello";
    printf("%p %s (in f)\n", s2, s2);
    // g() wird NICHT mehr von hier aufgerufen!
}

int main(void)
{
    char s1[10] = "Hi";
    printf("%p %s (in main)\n", s1, s1);
    f();   // f() wird aufgerufen und kehrt zurück
    g();   // DANN wird g() aufgerufen
}
```

**Selbsttest:**

Wie heißt der eigene Bereich auf dem Stack, den jede aufgerufene Funktion bekommt?

**Antwort:**

**Stack-Frame.**

**Selbsttest:**

Woran sieht man im Programm mit `main` und `f`, dass der Stack bei einem Funktionsaufruf zu kleineren Adressen wächst?

**Antwort:**

Die lokale Variable in `f` hat eine **kleinere Adresse** als die in `main`.

**Selbsttest:**

Was geschieht mit dem Stack-Frame einer Funktion, wenn sie zurückkehrt?

**Antwort:**

Er wird **freigegeben**: Der Bereich ist wieder verfügbar, die Bytes werden aber **nicht gelöscht**.

*Was dieses Programm ausgibt, haben wir in der Vorlesung vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

### Was speichert ein Stack-Frame?

Jeder Stack-Frame enthält u.a.:
- Lokale Variablen der Funktion
- Parameter, die der Funktion übergeben wurden (falls vorhanden)
- Rücksprungadresse (wo geht es im Programm weiter, wenn die Funktion endet oder `return` aufgerufen wird)

```
┌─────────────────────────┐
│   Rücksprungadresse     │
│   Parameter             │
│   Lokale Variablen      │
│   ...                   │
└─────────────────────────┘
```

- **Stack-Frame:** Jede Funktion bekommt einen eigenen Speicherbereich auf dem Stack
- **Wachstumsrichtung:** Stack wächst zu kleineren Adressen (nach oben im Diagramm)
- **Automatische Verwaltung:** Stack-Frames werden vom Compiler automatisch erstellt und freigegeben
- **Begrenzte Größe:** Zu viele ineinander geschachtelte Funktionsaufrufe (z.B. durch Rekursion) führen zu *Stack Overflow*

**Selbsttest:**

Ein Stack-Frame enthält u. a. lokale Variablen, Parameter und ???

**Antwort:**

Die **Rücksprungadresse**.

**Selbsttest:**

Was gibt die Rücksprungadresse in einem Stack-Frame an?

**Antwort:**

**Wo es im Programm weitergeht**, wenn die Funktion endet oder `return` ausgeführt wird.

**Selbsttest:**

Wozu führen zu viele ineinander geschachtelte Funktionsaufrufe, etwa durch Rekursion?

**Antwort:**

Zu einem **Stack Overflow**, weil der Stack nur begrenzt groß ist.

### Wie viel Speicher bekommt man?

Wir würden gerne einmal den Fall sehen, dass malloc NULL zurückgibt, weil es keinen Speicher mehr reservieren konnte. Können wir das provozieren, indem wir *sehr viel* Speicher anfordern?

```c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    // 1024^3 = 1 Gigabyte (GB)
    char *p = malloc(1024 * 1024 * 1024);
    if (p == NULL)
    {
        printf("Kein Speicher!\n");
        return 1;
    }
    printf("Speicher erhalten: %p\n", p);
}
```

Überraschenderweise funktioniert das oft auch dann, wenn mehr angefordert wird, als frei ist! Warum? Moderne Betriebssysteme verwenden *Memory Overcommit* – sie versprechen Speicher, der vielleicht gar nicht physisch existiert. Erst wenn man den Speicher tatsächlich benutzt, wird es problematisch.

**Selbsttest:**

Wie heißt es, wenn das Betriebssystem Speicher „verspricht“, der vielleicht gar nicht physisch existiert?

**Antwort:**

**Memory Overcommit.** Problematisch wird es erst, wenn man den Speicher tatsächlich benutzt.

*Weitere Selbsttests zu diesem Abschnitt stehen ab dem Tag nach der Vorlesung hier.*

## Übung: Pointer im Schnelldurchgang

In der Vorlesung haben Sie Pointer im Schnelldurchgang geübt: auf dem Handy kleine Programme, deren Ausgabe Sie vorhersagen. Davor stand diese Tabelle (auch auf dem Aufgabenblatt). Gegeben ist:

```c
int x = 3;
int *p = &x;
int werte[] = {40, 60, 80};
```

`x` liegt an der Adresse `0x04`, `werte` beginnt bei `0x08`. Füllen Sie Typ und Wert:

| Ausdruck | Typ | Wert |
|---|---|---|
| `x` | `int` | 3 |
| `&x` | `int *` | `0x04` |
| `p` | `int *` | `0x04` |
| `*p` | `int` | 3 |
| `werte` | ? | ? |
| `werte[1]` | ? | ? |
| `werte + 1` | ? | ? |
| `*(werte + 1)` | ? | ? |

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

**Drei Aufgaben aus dem Speedrun.** Was geben die Programmstücke aus?

1. Pointerarithmetik:

    ```c
    int a[] = {41, 52, 35, 24, 17};
    int *p = a + 2;
    printf("%i\n", *(p + 2));
    ```

2. Ein Array als Parameter:

    ```c
    void f(int a[])
    {
        a[2] = 61;
    }

    // in main:
    int werte[] = {12, 35, 38};
    f(werte);
    printf("%i\n", werte[2]);
    ```

3. Ein 2D-Array:

    ```c
    int bild[3][4] =
    {
        {39, 85, 23, 50},
        {13, 12, 93, 79},
        {11, 58, 97, 37}
    };
    printf("%i\n", bild[1][2]);
    ```

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

**Zwei Aufgaben zum Weiterüben** (aus dem Jahr 2025):

```c
int x = 3;
int y = 7;
int *p = &x;
int *q = &y;
*p = *q;
p = q;
*p = 10;
printf("x=%i, y=%i\n", x, y);
```

Was gibt das aus? Und welche Format-Strings und Argumente gehören in die Lücken, damit `CODE`, `D` (mit Array-Schreibweise) und `E` (mit Pointerarithmetik) erscheinen?

```c
char *s = "CODE";
printf("_____", _____);  // CODE
printf("_____", _____);  // D
printf("_____", _____);  // E
```

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

*Weitere Selbsttests zu diesem Abschnitt stehen ab dem Tag nach der Vorlesung hier.*

## Übung: Kopie oder nicht

Wählen Sie die Stufe, die Sie schaffen; alle drei sind gleich viel wert. Ohne Laptop, auf Papier. Die Eingabe ist jeweils `hi!`.

1. **Stufe 1:** Was gibt dieses Programmstück aus?

    ```c
    string s = get_string("s: ");
    string t = s;
    t[0] = 'H';
    printf("%s %s\n", s, t);
    ```

2. **Stufe 2:** Was gibt es jetzt aus, und wie viele Bytes holt `malloc`?

    ```c
    string s = get_string("s: ");
    char *t = malloc(strlen(s) + 1);
    if (t == NULL)
    {
        return 1;
    }
    strcpy(t, s);
    t[0] = 'H';
    printf("%s %s\n", s, t);
    free(t);
    ```

3. **Stufe 3:** In diesem Stück stecken zwei Fehler. Welche?

    ```c
    string s = get_string("s: ");
    char *t = malloc(strlen(s));
    if (t == NULL)
    {
        return 1;
    }
    strcpy(t, s);
    t[0] = 'H';
    printf("%s %s\n", s, t);
    ```

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

## String-Vergleich

- In Vorlesung 2 haben Sie zwei Strings mit `==` verglichen. Mit dem, was Sie jetzt wissen, lässt sich erklären, was dabei herauskam. Das folgende Programm vergleicht zwei Strings mit `==` und gibt danach ihre Adressen aus.

```c
#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = get_string("s: ");
    string t = get_string("t: ");

    if (s == t)
    {
        printf("Gleich\n");
    }
    else
    {
        printf("Verschieden\n");
    }

    printf("s: %p\n", s);
    printf("t: %p\n", t);
}
```

*Was dieses Programm ausgibt, haben wir in der Vorlesung vorhergesagt. Die Auflösung und wie man die Zeichen zweier Strings vergleicht, stehen ab dem Tag nach der Vorlesung hier.*

## Der Heap: Speicher, der bleibt

Das Regal aus Vorlesung 4 ist wieder der Speicher, jedes Fach ein Byte. Was `malloc` vergibt, bekommt ein Schild **BELEGT**; diese Fächer gehören zum **Heap**.

Eine Funktion `neu` ruft `char *t = malloc(4);` auf. `malloc` sucht vier Fächer am Stück, etwa `0x03` bis `0x06`, markiert sie als belegt und gibt **eine** Adresse zurück, die des ersten Fachs: `0x03`. Diese Adresse liegt in `t`, einer lokalen Variable von `neu`, also in deren Frame. Wie viele Fächer es sind, merkt sich `malloc` selbst.

Gibt `neu` mit `return t;` die Adresse zurück, verschwindet der Frame von `neu`, aber die vier Fächer bleiben belegt: **Der Heap überlebt `return`.** Deshalb holt eine Funktion, die etwas zurückgeben will, den Speicher mit `malloc`.

`free(t);` gibt die Fächer zurück, mehr nicht. `t` zeigt danach weiter auf `0x03`, nur gehört der Speicher dem Programm nicht mehr. `free` löscht nichts und garantiert auch nichts über den Inhalt; deshalb setzt man den Pointer danach auf `NULL`.

Kann `malloc` den Wunsch nicht erfüllen, etwa weil er viel zu groß ist, gibt es die Adresse `0x0` zurück: **`NULL`**. Das ist selten, aber prüfen Sie es nach jedem `malloc`.

Was passiert, wenn eine Funktion ein Array aus ihrem Frame zurückgibt?

```c
#include <stdio.h>

char *gruss(void)
{
    char s[] = "HI!";
    return s;
}

int main(void)
{
    char *t = gruss();
    printf("%s\n", t);
}
```

*Was `make` dazu sagt, haben wir in der Vorlesung gesehen. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

**Was bleiben soll, kommt auf den Heap.** Das Muster:

```c
char *t = malloc(4);
if (t == NULL)
{
    return 1;
}
// … t benutzen …
free(t);
```

Ihr `filter.c` aus Übung 5 macht es schon (Zeile 78 bis 85): `calloc` ist `malloc`, das die Bytes zusätzlich auf 0 setzt. Das Bild liegt auf dem Heap, weil es für den Stack zu groß werden kann und weil es leben muss, bis alle Filter fertig sind. Ganz am Ende steht `free(image);`.

```c
RGBTRIPLE(*image)[width] = calloc(height, width * sizeof(RGBTRIPLE));
if (image == NULL)
{
    printf("Not enough memory to store image.\n");
    fclose(outptr);
    fclose(inptr);
    return 7;
}
```

### Ein Array auf dem Heap

Früher haben wir Arrays immer mit fester Größe deklariert, die zur Compile-Zeit bekannt sein muss. Mit `malloc` können wir Speicher zur Laufzeit anfordern – das nennt man **dynamische Speicherallokation**.

Wir beginnen mit einer neuen Datei `testme.c`:

```c
#include <stdio.h>

int main(void)
{
    int numbers[4];
}
```

Das ist ein statisches Array – die Größe 4 ist fest im Code. Jetzt ändern wir es zu dynamischer Speicherallokation:

```c
#include <stdio.h>

int main(void)
{
    int *numbers = malloc(4 * sizeof(int));
}
```

Wenn wir das kompilieren, bekommen wir einen Fehler. Wir haben vergessen, die Standard-Library einzubinden:

```c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *numbers = malloc(4 * sizeof(int));
}
```

Jetzt weisen wir den Elementen Werte zu und geben sie aus:

```c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *numbers = malloc(4 * sizeof(int));
    numbers[0] = 1;
    numbers[1] = 2;
    numbers[2] = 3;
    for (int i = 0; i < 4; i++)
    {
        printf("%i ", numbers[i]);
    }
    printf("\n");
}
```

Ausgabe: `1 2 3 0`

Moment – woher kommt die `0`? Wir haben `numbers[3]` nie initialisiert! Der von `malloc` zurückgegebene Speicher enthält **Garbage-Werte** – was auch immer vorher an dieser Stelle im Speicher stand. In diesem Fall war es zufällig `0`, aber das kann jeder beliebige Wert sein – darauf darf man sich nie verlassen!

- **`malloc(size)`** reserviert zur Laufzeit `size` Bytes auf dem Heap und gibt einen Pointer zurück
- **`sizeof(typ)`** gibt die Größe eines Datentyps in Bytes zurück
- **Garbage-Werte:** `malloc` initialisiert den Speicher nicht!
- **`a[i]` ist `*(a + i)`:** Die eckigen Klammern rechnen mit der Adresse des ersten Elements. Ein Array ist deshalb noch kein Pointer (siehe `sizeof`).

**Selbsttest:**

Wie nennt man es, wenn ein Programm mit `malloc` Speicher erst zur Laufzeit anfordert?

**Antwort:**

**Dynamische Speicherallokation.** Bei Arrays mit fester Größe muss die Größe dagegen schon zur Compile-Zeit bekannt sein.

**Selbsttest:**

Was tut `malloc(size)`, und was gibt es zurück?

**Antwort:**

Es reserviert zur Laufzeit **`size` Bytes auf dem Heap** und gibt einen **Pointer** auf diesen Speicher zurück.

**Selbsttest:**

Welche Header-Datei muss man einbinden, um `malloc` zu verwenden?

**Antwort:**

`<stdlib.h>` (die Standard-Library).

**Selbsttest:**

Was steht in dem Speicher, den `malloc` zurückgibt, bevor man selbst etwas hineinschreibt?

**Antwort:**

**Garbage-Werte:** was vorher an dieser Stelle im Speicher stand. `malloc` initialisiert den Speicher nicht.

### Wo liegt "HI!"?

Was passiert, wenn wir zwei Pointer auf denselben String zeigen lassen? Wir programmieren:

```c
#include <stdio.h>

int main(void)
{
    char *s = "Hi";
    char *t;
    t = s;
    printf("%s %s\n", s, t);
}
```

Ausgabe: `Hi Hi`

Das ist zu erwarten – `t` zeigt auf dieselbe Speicheradresse wie `s`. Beide Pointer verweisen auf dasselbe String-Literal.

Was passiert wohl, wenn wir das zweite Zeichen in `s` ändern nachdem wir seinen Wert in `t` kopiert haben? Ändert sich dann auch `t` (wir erwarten: *nein*, um Strings zu kopieren braucht man bekanntlich `strcpy`). Probieren wir es also aus:

```c
#include <stdio.h>

int main(void)
{
    char *s = "Hi";
    char *t;
    t = s;
    s[1] = 'o';  // Aus "Hi" soll "Ho" werden
    printf("%s %s\n", s, t);
}
```

Kompiliert problemlos, aber bei der Ausführung:

```
Segmentation fault
```

**Warum?** `"Hi"` ist ein **String-Literal** (ein fester Wert). Initialisiert man einen char-Pointer mit einem String-Literal, legt der Compiler die Bytes des Literals in einem schreibgeschützten Speicherbereich ab. Der Pointer `s` (der wie jede lokale Variable auf dem *Stack* gespeichert wird – später dazu mehr!) zeigt dann auf diesen schreibgeschützten Speicherbereich. Dort dürfen wir nicht schreiben und beim Versuch, es doch zu tun, stürzt das Programm ab.

### Die Lösung: Stack-Array statt Pointer

Wenn wir den String verändern wollen, darf er nicht im schreibgeschützten Bereich liegen. Eine Möglichkeit: Wir legen ihn als Array auf dem Stack an. (Die andere lernen wir gleich kennen: Speicher mit *malloc* reservieren und den String dorthin kopieren. malloc liefert Pointer auf Speicher im *Heap*, wo viel mehr Platz ist als auf dem Stack.)

```c
#include <stdio.h>

int main(void)
{
    char s1[4] = "Hi!";  // Array auf dem Stack - veränderbar!
    char *s2 = "Hi!";    // Pointer auf Literal - nur lesen!
    printf("%s %s\n", s1, s2);
}
```

Ausgabe: `Hi! Hi!`

Beide sehen gleich aus, aber intern sind sie unterschiedlich. Wir können das mit `%p` sehen:

```c
#include <stdio.h>

int main(void)
{
    char s1[4] = "Hi!";
    char *s2 = "Hi!";
    printf("%s %s\n", s1, s2);
    printf("%p %p\n", s1, s2);
}
```

Die Adressen sind völlig unterschiedlich! `s1` liegt auf dem Stack, `s2` zeigt in den Nur-Lese-Bereich.

Jetzt können wir `s1` verändern:

```c
#include <stdio.h>

int main(void)
{
    char s1[4] = "Hi!";
    char *s2 = "Hi!";
    s1[1] = 'o';     // OK - s1 liegt auf dem Stack
    // s2[1] = 'o';  // CRASH - s2 in read-only memory
    printf("%s %s\n", s1, s2);
}
```

Ausgabe: `Ho! Hi!`

### strcpy – Strings kopieren

Wir wollen wieder einmal einen String kopieren. Dazu nutzen wir `strcpy` aus `<string.h>` – also programmieren wir schnell:

```c
#include <stdio.h>
#include <string.h>

int main(void)
{
    char s1[4] = "Hi!";
    char *t;
    strcpy(t, s1);
    printf("%s\n", t);
}
```

`make` bricht ab: `variable 't' is uninitialized when used here`. Der Compiler hat bemerkt: Wir haben vergessen, Speicher zu reservieren. Der Pointer `t` ist nicht initialisiert, er enthält einen *Garbage Value* – also das, was auch immer im Speicher steht, an dessen Stelle der Compiler diesen Pointer (auf dem Stack) speichert. Liefe das Programm trotzdem (etwa ohne die Compiler-Einstellungen der Kursumgebung), nähme `strcpy` diesen Wert als Adresse, an die `s1` kopiert werden soll. Beim Versuch, dorthin zu schreiben, fällt dem Betriebssystem der Fehler meist auf, und es lässt unser Programm mit einem Segmentation Fault abstürzen.

Wir müssen zuerst Speicher reservieren:

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char s1[4] = "Hi!";
    char t[4];  // Speicher auf dem Stack
    strcpy(t, s1);
    printf("%s %s\n", s1, t);
}
```

Ausgabe: `Hi! Hi!`

Jetzt haben wir zwei unabhängige Kopien – `t` ändern ändert `s1` nicht.

- **String-Literal (`char *s = "Hi"`):** Nur lesbar, liegt im geschützten Speicher
- **Stack-Array (`char s[4] = "Hi"`):** Veränderbar, liegt auf dem Stack
- **Segmentation Fault:** Betriebssystem hat Versuch erkannt, in geschützten Speicher zu schreiben
- **`strcpy(dest, src)`:** Kopiert String von `src` nach `dest` – Ziel muss genug Platz haben!

**Selbsttest:**

Warum stürzt `s[1] = 'o';` ab, wenn `s` mit `char *s = "Hi";` angelegt wurde?

**Antwort:**

`"Hi"` ist ein **String-Literal**; seine Bytes liegen in einem **schreibgeschützten Speicherbereich**, und dorthin darf das Programm nicht schreiben.

**Selbsttest:**

Was bedeutet ein „Segmentation Fault“?

**Antwort:**

Das **Betriebssystem** hat einen Zugriff auf Speicher erkannt, der nicht erlaubt ist (etwa einen Schreibversuch in geschützten Speicher), und das Programm beendet.

**Selbsttest:**

Warum darf man bei `char s1[4] = "Hi!";` einzelne Zeichen ändern, bei `char *s2 = "Hi!";` aber nicht?

**Antwort:**

`s1` ist ein **Array auf dem Stack** (veränderbar); `s2` zeigt auf das **String-Literal im Nur-Lese-Bereich**.

**Selbsttest:**

Was bewirkt `t = s;`, wenn `s` und `t` vom Typ `char *` sind?

**Antwort:**

`t` zeigt auf **dieselbe Speicheradresse** wie `s`; der String selbst wird **nicht kopiert** (dafür braucht man `strcpy`).

**Selbsttest:**

Mit welchem Platzhalter gibt `printf` eine Adresse aus?

**Antwort:**

`%p`

**Selbsttest:**

In welcher Reihenfolge erwartet `strcpy` Ziel und Quelle?

**Antwort:**

**Erst das Ziel, dann die Quelle:** `strcpy(dest, src)`.

**Selbsttest:**

Warum stürzt `strcpy(t, s1);` ab, wenn `t` nur als `char *t;` deklariert wurde?

**Antwort:**

`t` ist **nicht initialisiert** und enthält einen Garbage-Wert; `strcpy` benutzt ihn als Adresse und schreibt an eine Stelle, an der kein Speicher für uns reserviert ist.

**Selbsttest:**

Mit welcher Funktion kopieren Sie in C den Inhalt eines Strings in einen anderen Speicherbereich?

**Antwort:**

`strcpy` (aus `<string.h>`): `strcpy(dest, src)`.

### Stack oder Heap?

Wir haben gesehen, dass wir mit `strcpy` Strings kopieren können. Aber wohin kopieren wir? Es gibt zwei Möglichkeiten: Stack oder Heap.

### Heap-Allokation mit malloc

Wenn wir zur Laufzeit Speicher brauchen, verwenden wir `malloc`:

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char s1[10] = "Hi!";
    char *t = malloc(strlen(s1));
    strcpy(t, s1);
    printf("%s\n", t);
}
```

*Was an diesem Programm nicht stimmt, ist Teil der Übung „Kopie oder nicht“. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

*Ein weiterer Weg zu einem Speicherleck steht ab dem Tag nach der Vorlesung hier.*

### Vier Strings, drei Gegenden

Hier ein Programm, das alle vier Varianten zeigt:

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char s1[4] = "Hi!";           // Stack-Array
    char *s2 = "Hi!";             // Pointer auf Literal (read-only)
    char *u = malloc(strlen(s1) + 1);  // Heap
    char t[4];                    // Stack-Array

    strcpy(t, s1);
    strcpy(u, s1);
    s1[1] = 'o';

    printf("%s %s %s %s\n", s1, s2, t, u);
    printf("s1=%p s2=%p t=%p u=%p\n", s1, s2, t, u);
}
```

*Welche Adressen dabei herauskommen, haben wir in der Vorlesung vorhergesagt; die Auflösung steht ab dem Tag nach der Vorlesung hier.*

### Exkurs: Speicherbereiche mit GDB inspizieren (Hintergrund)

In der Pause haben wir mit dem Debugger GDB experimentiert, um zu sehen, wie das Programm tatsächlich im Speicher liegt. GDB (GNU Debugger) ist ein mächtiges Werkzeug zum Analysieren von Programmen – die Details sind Hintergrund und helfen beim Verständnis des Speicherlayouts.

Zunächst ein Testprogramm, das drei verschiedene Speicherbereiche zeigt:

```c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char s1[4] = "Hi!";    // liegt auf dem Stack
    char *s2 = "Hi";       // zeigt auf String-Literal (schreibgeschützt)
    char *s3 = malloc(3);  // liegt auf dem Heap

    printf("%p\n%p\n%p", s1, s2, s3);
}
```

Ausgabe:
```
0x7fff397fb64c   ← s1 (Stack)
0x5e02afb66008   ← s2 (String-Literal, read-only)
0x5e02cd9be2a0   ← s3 (Heap, von malloc)
```

Mit `gdb ./testme`, dann `break main`, `run` und `info proc mappings` sehen wir alle Speicherbereiche:

```
(gdb) info proc mappings
Mapped address spaces:

      Start Addr           End Addr     Perms  objfile
  0x5f951484b000     0x5f951484c000     r--p   /workspaces/.../testme
  0x5f951484c000     0x5f951484d000     r-xp   /workspaces/.../testme  ← Code
  0x5f951484d000     0x5f951484e000     r--p   /workspaces/.../testme  ← Literale!
  0x5f951484f000     0x5f9514850000     rw-p   /workspaces/.../testme
  ...
  0x726da498b000     0x726da49b3000     r--p   /usr/lib/.../libc.so.6
  0x726da49b3000     0x726da4b3b000     r-xp   /usr/lib/.../libc.so.6  ← printf etc.
  ...
  0x726da4b90000     0x726da4b9d000     rw-p   ← anonym (gehört zu libc, nicht der Heap)
  ...
  0x7ffe6b40e000     0x7ffe6b42f000     rw-p   [stack]
```

Die Adressen weichen von der Ausgabe oben ab: Bei jedem Start legt das Betriebssystem die Bereiche an zufällig gewählte Stellen (das erschwert Angriffe). Einen Heap sehen Sie hier noch nicht, denn er entsteht erst beim ersten `malloc`. Halten Sie mit `break 10` statt `break main` erst nach dem `malloc` an, erscheint direkt hinter den Bereichen von `testme` eine Zeile `[heap]` mit `rw-p`.

Die **Perms**-Spalte (Permissions) zeigt die Berechtigungen:
- `r` = **r**ead (lesen erlaubt)
- `w` = **w**rite (schreiben erlaubt)
- `x` = e**x**ecute (ausführen erlaubt)
- `p` = **p**rivate (privat für diesen Prozess)

**Wo liegt was?**

| Variable | Adresse (ca.) | Bereich | Perms | Bedeutung |
|----------|---------------|---------|-------|-----------|
| `s1` | `0x7fff...` | `[stack]` | `rw-p` | Stack: lesbar, schreibbar |
| `s2` | `0x5e02...` (niedrig) | `testme` | `r--p` | **Read-only!** Literale |
| `s3` | `0x5e02...` (Heap) | `[heap]` | `rw-p` | Heap: lesbar, schreibbar |

**Wichtige Erkenntnisse:**
- **String-Literale** (`"Hi"`) liegen im `r--p`-Bereich des Programms – **nur lesbar**, daher der Segmentation Fault beim Schreibversuch!
- Der **Heap** (malloc) ist der Bereich `[heap]` direkt hinter dem Programm, `rw-p` – lesbar und schreibbar
- Der **Stack** ist `rw-p`, aber **nicht ausführbar** (`x` fehlt) – das schützt vor Buffer-Overflow-Attacken
- Nur der **Code-Bereich** hat `x` (execute) – das Betriebssystem verhindert, dass andere Bereiche als Code ausgeführt werden

### Speicherverwaltungsfunktionen

| Funktion | Beschreibung |
|----------|--------------|
| `malloc(size)` | Reserviert `size` Bytes (nicht initialisiert) |
| `free(ptr)` | Gibt Speicher wieder frei |

*Dazu kommen `calloc` (reserviert und setzt alle Bytes auf 0; so holt `filter.c` den Platz für das Bild) und `realloc` (ändert die Größe eines reservierten Bereichs; mehr dazu in Vorlesung 5).*

- **Stack:** Schnell, automatisch, begrenzte Größe
- **Heap:** Flexibel, manuell, größerer Speicher verfügbar
- **`strlen(s) + 1`:** Immer den Null-Terminator berücksichtigen!
- **`free(ptr)`:** Heap-Speicher muss explizit freigegeben werden

**Selbsttest:**

Welche drei Eigenschaften hat der Stack im Vergleich zum Heap?

**Antwort:**

**Schnell, automatisch verwaltet, begrenzte Größe.** Der Heap ist dagegen flexibel und größer, wird aber manuell verwaltet.

*Weitere Selbsttests zu diesem Abschnitt stehen ab dem Tag nach der Vorlesung hier.*

## Speicherfehler finden: valgrind

Stufe 3 der Übung „Kopie oder nicht“ hat zwei Fehler. Das Programm übersetzt ohne Warnung und gibt bei der Eingabe `hi!` scheinbar richtig `hi! Hi!` aus. Fehler dieser Art findet **valgrind**: Es führt Ihr Programm aus und beobachtet dabei jeden Zugriff auf den Heap. Man startet es mit `valgrind ./programm`.

```c
string s = get_string("s: ");
char *t = malloc(strlen(s));
if (t == NULL)
{
    return 1;
}
strcpy(t, s);
t[0] = 'H';
printf("%s %s\n", s, t);
```

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

*Weitere Selbsttests zu diesem Abschnitt stehen ab dem Tag nach der Vorlesung hier.*

## Dateien: `fopen`, `fread`, `fclose`

Am Ende von Vorlesung 4 blieb eine Frage offen: Wie kommt das Bild aus der Datei `images/yard.bmp` in den Speicher, bevor Ihre Funktion es bekommt? In `filter.c` stehen dafür schon `fopen` und `fread`:

```c
FILE *inptr = fopen(infile, "r");            // Zeile 39
if (inptr == NULL)                           // Zeile 40
…
RGBTRIPLE(*image)[width] = calloc(…);        // Zeile 78
…
fread(image[i], sizeof(RGBTRIPLE), width, inptr);   // Zeile 94
…
free(image);                                 // Zeile 144
fclose(inptr);                               // Zeile 147
fclose(outptr);                              // Zeile 148
```

`fopen(infile, "r")` öffnet die Datei zum Lesen und gibt einen `FILE *` zurück, einen Pointer auf eine Verwaltungsstruktur für die Datei. Klappt das Öffnen nicht (die Datei gibt es nicht, keine Rechte), ist der Pointer `NULL`. Dann reserviert `calloc` Platz für das Bild auf dem Heap, `fread` liest Zeile für Zeile Pixel aus der Datei in `image`, und am Ende geben `free` und `fclose` Speicher und Datei zurück. Prüfen Sie ausdrücklich `if (datei == NULL)`: `if (datei)` hieße das Gegenteil, „wenn das Öffnen geklappt hat“.

Die ersten zwei Bytes einer Datei lesen: `zwei-bytes.c` öffnet `yard.bmp` (im selben Ordner), prüft auf `NULL` und schließt die Datei wieder. Dazwischen kommen drei Zeilen.

```c
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    FILE *bild = fopen("yard.bmp", "r");
    if (bild == NULL)
    {
        return 1;
    }
    uint8_t kopf[2];
    fread(kopf, 1, 2, bild);
    printf("%c%c\n", kopf[0], kopf[1]);
    printf("%x %x\n", kopf[0], kopf[1]);
    fclose(bild);
}
```

`fread(kopf, 1, 2, bild)` hat vier Argumente: **wohin** (die Adresse eines Puffers, hier das Array `kopf`), **wie groß ein Element** in Bytes (1), **wie viele Elemente** (2) und **aus welcher Datei** (`bild`).

*Was dieses Programm ausgibt, haben wir in der Vorlesung vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

**Modi und `fprintf`.** Das zweite Argument von `fopen` ist der Modus: `"r"` zum Lesen (die Datei muss es geben), `"w"` zum Schreiben (gibt es die Datei schon, ist sie danach leer), `"a"` zum Anhängen. `"rb"` geht auch; unter Linux und macOS ist es dasselbe wie `"r"`. `filter.c` und Wiederherstellung schreiben `"r"`. Text schreibt `fprintf(datei, "%i\n", n);` in eine Datei, genau wie `printf`, nur mit der Datei vorn.

Dateien sind eine wichtige Möglichkeit, Daten dauerhaft zu speichern. In C arbeiten wir mit `FILE`-Pointern.

### Eine Datei zum Schreiben öffnen

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("output.txt", "w");
}
```

`fopen` gibt einen Pointer auf eine `FILE`-Struktur zurück – oder `NULL`, wenn das Öffnen fehlschlägt:

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("output.txt", "w");
    if (file == NULL)
    {
        printf("Fehler beim Öffnen!\n");
        return 1;
    }
}
```

**Alternative Schreibweise:** Da `NULL` dem Wert `0` entspricht und `0` in C als `false` gilt, sind diese beiden Prüfungen äquivalent:

```c
if (file == NULL) { ... }  // Explizit
if (!file) { ... }         // Kürzer, weil NULL = 0 = false
```

Die kürzere Variante sieht man in der Praxis häufig. Wichtig ist nur, dass man überhaupt prüft!

### In eine Datei schreiben

Mit `fprintf` schreiben wir formatiert in eine Datei – genau wie `printf`, nur mit einem `FILE*` als erstem Argument:

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("phonebook.csv", "w");
    if (file == NULL)
    {
        printf("Fehler beim Öffnen!\n");
        return 1;
    }

    fprintf(file, "Name,Nummer\n");
    fprintf(file, "Alice,0123456789\n");
    fprintf(file, "Bob,9876543210\n");

    fclose(file);  // Datei schließen nicht vergessen!
}
```

Nach der Ausführung enthält `phonebook.csv`:
```
Name,Nummer
Alice,0123456789
Bob,9876543210
```

### Dateimodi

| Modus | Bedeutung |
|-------|-----------|
| `"r"` | Lesen (Datei muss existieren) |
| `"w"` | Schreiben (erstellt/überschreibt Datei) |
| `"a"` | Anhängen (fügt am Ende hinzu) |
| `"rb"` | Binär lesen |
| `"wb"` | Binär schreiben |

**Anmerkung zu Binärmodus:** Auf Linux/macOS (und im CS50-Codespace) macht das `b` keinen Unterschied – Dateien werden immer byteweise gelesen/geschrieben. Auf Windows hingegen übersetzt der Textmodus Zeilenumbrüche (`\n` ↔ `\r\n`), was bei Binärdateien (Bilder, Audio, etc.) zu Problemen führt. Wenn Sie Programme schreiben, die auch auf Windows laufen sollen, sollten Sie bei Binärdateien immer `"rb"`/`"wb"` verwenden.

**Selbsttest:**

Was gibt `fopen` zurück, wenn das Öffnen der Datei fehlschlägt?

**Antwort:**

`NULL`. Deshalb prüft man nach `fopen` immer auf `NULL`.

**Selbsttest:**

Worin unterscheidet sich `fprintf` von `printf`?

**Antwort:**

`fprintf` schreibt formatiert **in eine Datei**; es bekommt dazu einen **`FILE*` als erstes Argument**.

**Selbsttest:**

Mit welcher Funktion schließt man eine geöffnete Datei?

**Antwort:**

`fclose(file)`

**Selbsttest:**

Was bewirkt der Modus `"w"` bei `fopen`?

**Antwort:**

**Schreiben:** Die Datei wird **erstellt oder überschrieben**.

**Selbsttest:**

Was bewirkt der Modus `"a"` bei `fopen`?

**Antwort:**

**Anhängen:** Geschriebenes wird **am Ende** der Datei hinzugefügt.

**Selbsttest:**

Warum sollte man Binärdateien mit `"rb"`/`"wb"` öffnen, damit das Programm auch unter Windows funktioniert?

**Antwort:**

Unter Windows **übersetzt der Textmodus Zeilenumbrüche** (`\n` ↔ `\r\n`), was Binärdaten verfälscht.

**Selbsttest:**

Mit welcher Funktion öffnen Sie in C eine Datei, und was bekommen Sie zurück?

**Antwort:**

`fopen`, z. B. `fopen("output.txt", "w")`; sie gibt einen `FILE*` zurück (oder `NULL`).

**Selbsttest:**

Mit welcher Funktion schreiben Sie in C formatierten Text in eine geöffnete Datei?

**Antwort:**

`fprintf`, z. B. `fprintf(file, "Name,Nummer\n");`

### Aus einer Datei lesen

Für textbasiertes Lesen verwenden wir `fgets`. Zunächst lesen wir eine einzelne Zeile:

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("phonebook.csv", "r");
    if (file == NULL)
    {
        printf("Datei nicht gefunden!\n");
        return 1;
    }

    char line[100];
    fgets(line, 100, file);  // Liest eine Zeile (max. 99 Zeichen + \0)
    printf("Erste Zeile: %s", line);

    fclose(file);
}
```

**Wichtig:** `fgets` liest bis zu `n-1` Zeichen, aber **hört früher auf**, wenn ein Zeilenumbruch (`\n`) oder das Dateiende erreicht wird. Der Zeilenumbruch wird dabei mit in den Buffer übernommen! Das macht `fgets` ideal zum zeilenweisen Lesen von Textdateien oder Benutzereingaben von `stdin`.

Das funktioniert – aber was, wenn wir die ganze Datei lesen wollen? Wir könnten einen riesigen Buffer anlegen und hoffen, dass die Datei hineinpasst. Aber das ist unpraktisch: Wir wissen oft nicht im Voraus, wie groß die Datei ist, und ein Buffer von mehreren Megabytes wäre Speicherverschwendung.

Die Lösung: Wir lesen **in einer Schleife**, Zeile für Zeile. Dafür nutzen wir den Rückgabewert von `fgets`:

- Bei Erfolg gibt `fgets` den Pointer auf den Buffer zurück (also `line`)
- Am Dateiende (oder bei Fehler) gibt `fgets` `NULL` zurück

Das passt perfekt zu einer `while`-Schleife:

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("phonebook.csv", "r");
    if (file == NULL)
    {
        printf("Datei nicht gefunden!\n");
        return 1;
    }

    char line[100];
    while (fgets(line, 100, file) != NULL)
    {
        printf("Zeile: %s", line);
    }
    // Schleife endet automatisch, wenn fgets NULL zurückgibt (Dateiende)

    fclose(file);
}
```

Die Schleife läuft, solange `fgets` erfolgreich eine Zeile liest. Sobald das Dateiende erreicht ist, gibt `fgets` `NULL` zurück, die Bedingung ist falsch, und die Schleife endet.

**Selbsttest:**

Wann hört `fgets` vor dem Erreichen der angegebenen Größe mit dem Lesen auf?

**Antwort:**

Beim **Zeilenumbruch** (`\n`, der mit in den Buffer übernommen wird) oder am **Dateiende**.

**Selbsttest:**

Was gibt `fgets` am Dateiende zurück?

**Antwort:**

`NULL` (bei Erfolg dagegen den Pointer auf den Buffer).

### Was ist eigentlich ein FILE*? (Hintergrund)

`FILE` ist kein eingebauter Datentyp wie `int` oder `char` – es ist ein mit `typedef` definierter Struct-Typ. Was steht da drin? Das ist absichtlich vor uns verborgen (*opaque type*), aber konzeptionell enthält diese Struktur Informationen, die das Betriebssystem braucht:

- Welche Datei ist geöffnet (eine Art Referenznummer)
- An welcher Position in der Datei befinden wir uns gerade
- Puffer für effizienteres Lesen/Schreiben
- Fehlerstatus

Wenn wir `fopen` aufrufen, passiert im Betriebssystem einiges: Es prüft, ob die Datei existiert, ob wir Zugriffsrechte haben, und merkt sich in einer internen Tabelle, dass unser Programm diese Datei geöffnet hat. Der `FILE*`-Pointer, den wir zurückbekommen, ist unser „Ticket“ für alle weiteren Operationen mit dieser Datei.

**Ein Gedankenexperiment:** Wir könnten theoretisch den Speicher, auf den `FILE*` zeigt, Byte für Byte mit einem `char*` auslesen – schließlich ist alles im Speicher nur eine Folge von Bytes:

```c
// SINNLOS, ABER MÖGLICH: FILE-Struktur byteweise auslesen
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("test.txt", "w");
    if (file == NULL) return 1;

    // Hässlicher Cast: FILE* → char*
    char *raw = (char *)file;

    // sizeof(FILE) gibt die Größe der Struktur in Bytes
    printf("FILE struct ist %lu Bytes groß\n", sizeof(FILE));

    // Jedes Byte der FILE-Struktur als Hex ausgeben
    for (size_t i = 0; i < sizeof(FILE); i++)
    {
        printf("%02x ", (unsigned char)raw[i]);
        if ((i + 1) % 16 == 0) printf("\n");
    }

    fclose(file);
}
```

**Ausgabe (systemabhängig, bei mir ~216 Bytes Datenmüll):**
```
FILE struct ist 216 Bytes groß
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
...
```

Das funktioniert – aber was sehen wir? Nur Bytes ohne erkennbare Bedeutung. Die interne Struktur ist systemabhängig, und wir sollen sie nicht direkt manipulieren. Stattdessen nutzen wir die bereitgestellten Funktionen (`fread`, `fwrite`, `fclose`, ...), die wissen, wie man mit dieser Struktur umgeht.

- **`FILE *`:** Pointer auf eine Datei-Struktur (von `typedef` definiert)
- **`fopen(name, mode)`:** Öffnet Datei, gibt `NULL` bei Fehler zurück
- **`fprintf(file, format, ...)`:** Wie `printf`, aber in eine Datei
- **`fread(buf, size, count, file)`:** Liest binäre Daten
- **`fwrite(buf, size, count, file)`:** Schreibt binäre Daten
- **`fclose(file)`:** Schließt die Datei – **immer aufrufen!**

## Arrays, Pointer und `sizeof`

Vier echte Aufrufe von `fread`, oben aus `filter.c`, unten aus der Hilfestellung zu Lautstärke:

```c
fread(&bf, sizeof(BITMAPFILEHEADER), 1, inptr);
fread(image[i], sizeof(RGBTRIPLE), width, inptr);
fread(header, HEADER_SIZE, 1, input);
fread(&buffer, sizeof(int16_t), 1, input);
```

`fread(image[i], sizeof(RGBTRIPLE), width, inptr)` liest eine ganze Zeile des Bildes: `width` Pixel zu je 3 Bytes. Zurück kommt `width`, nicht `3 * width`: `fread` zählt Elemente. Nur zwei der vier Aufrufe haben ein `&`. Warum?

*Warum nur zwei der vier Aufrufe ein `&amp;` haben, haben wir in der Vorlesung am Regal geklärt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

**`sizeof`** liefert die Größe eines Typs oder einer Variable in Bytes: `sizeof(int)` ist 4, `sizeof(RGBTRIPLE)` ist 3. Für ein Array in der Funktion, die es anlegt, liefert `sizeof` die Größe des ganzen Arrays: `int noten[] = {2, 1, 3, 3};` hat `sizeof(noten)` 16. Ausgegeben wird `sizeof` mit `%zu`.

Und in einer Funktion, die das Array als Parameter bekommt?

```c
#include <stdio.h>

void f(int werte[])
{
    printf("in f: %zu\n", sizeof(werte));
}

int main(void)
{
    int noten[] = {2, 1, 3, 3};
    printf("in main: %zu\n", sizeof(noten));
    f(noten);
}
```

*Was `make` dazu sagt, haben wir in der Vorlesung gesehen. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

### Array-Notation vs. Zugriff mit Pointer-Arithmetik

Zurück zum Array auf dem Heap aus dem Abschnitt „Der Heap“: Die Array-Notation `numbers[i]`, die wir zuerst kennengelernt haben, ist nichts anderes als ein Dereferenzieren eines Pointers – sie sieht einfacher und übersichtlicher aus. Man sagt auch `numbers[i]` ist syntaktischer Zucker (*syntactic sugar*) für `*(numbers + i)`. Wir können das direkt zeigen:

```c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *numbers = malloc(4 * sizeof(int));
    numbers[0] = 1;
    numbers[1] = 2;
    numbers[2] = 3;
    for (int i = 0; i < 4; i++)
    {
        printf("%i ", *(numbers + i));
    }
    printf("\n");
}
```

Die Ausgabe ist identisch! Der Compiler weiß, dass `numbers` ein `int*` ist, also bedeutet `numbers + 1` in Wirklichkeit „ausgehend von der Adresse von *numbers* gehe um 4 Bytes“ weiter (die Größe eines `int`).

**Selbsttest:**

Was gibt `sizeof(typ)` zurück?

**Antwort:**

Die **Größe des Datentyps in Bytes**.

**Selbsttest:**

Wie nennt man eine Schreibweise wie `numbers[i]`, die nur eine einfachere Form von `*(numbers + i)` ist?

**Antwort:**

**Syntaktischer Zucker** (*syntactic sugar*).

**Selbsttest:**

Um wie viele Bytes geht `numbers + 1` weiter, wenn `numbers` ein `int*` ist?

**Antwort:**

Um **4 Bytes**, die Größe eines `int`. Der Compiler kennt den Typ des Pointers.

**Selbsttest:**

Womit ermitteln Sie in C, wie viele Bytes ein Datentyp wie `int` belegt?

**Antwort:**

`sizeof`, z. B. `sizeof(int)`.

### Zeilen eines 2D-Arrays

Ein 2D-Array ist ein Array aus Zeilen. Bei `int bild[3][4]` ist `bild[2]` die dritte Zeile, selbst ein Array aus 4 `int` (`sizeof(bild[2])` ist 16). Übergibt man eine Zeile, kommt wie bei jedem Array die Adresse ihres ersten Elements an. So liest `filter.c` ein Bild Zeile für Zeile: `fread(image[i], sizeof(RGBTRIPLE), width, inptr)`.

**Selbsttest:**

Gegeben ist `int bild[3][4]`. Was ist `bild[2]`?

**Antwort:**

Die **dritte Zeile**, ein Array aus 4 `int` (`sizeof(bild[2])` ist 16). Übergibt man sie, kommt die Adresse von `bild[2][0]` an.

**Selbsttest:**

Bezeichnen `&bild[1][2]` und `bild[1] + 2` dieselbe Adresse?

**Antwort:**

**Ja.** `bild[1]` ist die zweite Zeile, im Ausdruck die Adresse ihres ersten Elements. `+ 2` geht zwei `int` weiter, also zu `bild[1][2]`.

**Selbsttest:**

Welcher Aufruf liest Zeile `i` eines Bildes ganz aus einer Datei: `fread(image[i], sizeof(RGBTRIPLE), width, f)` oder `fread(&image[i], 1, width, f)`?

**Antwort:**

**Der erste.** Er liest `width` Elemente zu je `sizeof(RGBTRIPLE)` Bytes (3), also die ganze Zeile. Der zweite beginnt an derselben Adresse, liest aber nur `width` Bytes, ein Drittel der Zeile.

### size_t (Hintergrund)

Die Lösung ist der Datentyp `size_t` – ein unsigned Integer, der groß genug für jede Speichergröße ist:

```c
// FALSCH: Literale werden als int interpretiert (32-bit)
char *p = malloc(10 * 1000000000);  // make bricht ab (overflow in expression)

// RICHTIG: Expliziter Cast auf size_t (portabel auf allen Plattformen)
size_t size = (size_t)10 * 1000000000;
char *p = malloc(size);

// Alternativ mit ULL-Suffix (unsigned long long, mind. 64-bit):
char *p = malloc(10ULL * 1000000000ULL);
```

Der Cast `(size_t)` ist die sicherste Variante, weil `size_t` auf jeder Plattform die richtige Größe für Speicheradressen hat. Das `ULL`-Suffix steht für „unsigned long long“ und ist garantiert mindestens 64 Bit groß – im Gegensatz zu `UL` („unsigned long“), das auf Windows auch im 64-bit-Modus nur 32 Bit sein kann.

*Weitere Selbsttests zu diesem Abschnitt stehen ab dem Tag nach der Vorlesung hier.*

## In Blöcken lesen und schreiben

Eine Datei ist eine Folge von Bytes, wie eine Leine mit Karten. `text.txt` enthält die 10 Bytes `INFORMATIK` (ohne Zeilenende). Die geöffnete Datei merkt sich, wo sie gerade steht, in der Vorlesung eine Wäscheklammer: Jedes `fread` liest ab dort und schiebt die Position weiter.

`char puffer[4]` sind vier Kisten. `fread(puffer, 1, 4, f)` holt vier Bytes in den Puffer und gibt 4 zurück: 4 Elemente, hier je 1 Byte. `fwrite(puffer, 1, 4, stdout)` schreibt den Inhalt des Puffers aufs Terminal; `stdout` ist das Terminal als Datei, schon geöffnet, und `fwrite(…, stdout)` schreibt dorthin wie `printf`. Der erste Aufruf liest `INFO`, der zweite `RMAT`. Beim dritten sind nur noch zwei Bytes übrig: `I` und `K` landen in `puffer[0]` und `puffer[1]`, `fread` gibt 2 zurück. Was steht jetzt in `puffer[2]` und `puffer[3]`?

```c
#include <stdio.h>

int main(void)
{
    FILE *f = fopen("text.txt", "r");
    if (f == NULL)
    {
        return 1;
    }
    char puffer[4];
    int n;
    while ((n = fread(puffer, 1, 4, f)) > 0)
    {
        fwrite(puffer, 1, 4, stdout);
    }
    printf("\n");
    fclose(f);
}
```

Die Doppelklammer in `(n = fread(…)) > 0` speichert zuerst die Rückgabe in `n` und vergleicht dann; die Schleife läuft, bis `fread` 0 zurückgibt.

*Was `bloecke.c` ausgibt, hat der Saal an der Leine vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

**Ihre Übung 6.** Lautstärke liest den Kopf einer WAV-Datei und dann die Samples, ändert jedes und schreibt alles in eine neue Datei: lesen, ändern, schreiben. Wiederherstellung liest ein Abbild einer Speicherkarte in Blöcken. Die Warm-ups der Übung führen `fopen`, `fread`, `fwrite` und `scanf` in kleinen Schritten ein. Abgabe bis Sonntag, 6. Dezember.

### Binäre Daten mit fread/fwrite

Für binäre Dateien (wie Bilder) verwenden wir `fread` und `fwrite`. Im Gegensatz zu `fgets` ignoriert `fread` Zeilenumbrüche komplett – es liest einfach die angegebene Anzahl Elemente, egal welche Werte deren Bytes haben.

Die Signatur von `fread`:

```c
size_t fread(void *buffer, size_t size, size_t count, FILE *datei);
//           wohin?        wie groß     wie viele?    woher?
//                         ist ein      Elemente
//                         Element?
```

**Wann ein `&`?** `fread` will die Adresse, an die es schreiben soll:

- **Variable oder `struct`:** mit `&`, etwa `fread(&b, 1, 1, datei)` oder `fread(&bf, …)` in `filter.c`
- **Array:** ohne `&`, etwa `fread(puffer, 1, 4, datei)` oder `fread(image[i], …)`; ein Array wird als Argument zur Adresse seines ersten Elements
- **Pointer:** ohne `&`, etwa `fread(t, 1, 4, datei)` mit `t` aus `malloc`; er enthält schon eine Adresse

`fread` zählt dabei Elemente, nicht Bytes: `fread(image[i], sizeof(RGBTRIPLE), width, inptr)` in `filter.c` liest eine Zeile aus `width` Pixeln zu je 3 Bytes und gibt `width` zurück, nicht `3 * width`. `fwrite` hat dieselben vier Parameter. Als Datei geht dort auch `stdout`, das Terminal: Es ist schon geöffnet, `fwrite(puffer, 1, 4, stdout)` schreibt dorthin wie `printf` (mehr zu `stdin`, `stdout` und `stderr` im Abschnitt zu `scanf` und `fgets`).

Zunächst lesen wir einmalig 10 Bytes:

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("daten.bin", "rb");
    if (file == NULL)
    {
        return 1;
    }

    char buffer[10];
    int gelesen = fread(buffer, 1, 10, file);  // 10 Elemente à 1 Byte
    printf("Gelesen: %d Bytes\n", gelesen);

    fclose(file);
}
```

Auch hier stellt sich die Frage: Was, wenn die Datei größer ist als unser Buffer? Wir müssten die gesamte Dateigröße kennen und entsprechend viel Speicher reservieren – bei großen Dateien unpraktisch.

Die Lösung ist wieder eine Schleife. Der Rückgabewert von `fread` hilft uns dabei:

- `fread` gibt die Anzahl der **erfolgreich gelesenen Elemente** zurück
- Am Dateiende gibt es weniger zurück als angefordert (oder 0)

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("daten.bin", "rb");
    if (file == NULL)
    {
        return 1;
    }

    char c;
    while (fread(&c, 1, 1, file) == 1)  // Solange genau 1 Byte gelesen wird
    {
        printf("%02x ", (unsigned char)c);  // Byte als Hex ausgeben
    }
    // Schleife endet, wenn fread 0 zurückgibt (Dateiende)

    fclose(file);
}
```

**Format-String `%02x`:** Das `x` steht für Hexadezimal (Basis 16), die `2` bedeutet „mindestens 2 Stellen“, und die `0` davor bedeutet „mit führenden Nullen auffüllen“. So wird das Byte `0x0A` als `0a` ausgegeben statt nur `a`. Das ist praktisch, um Binärdaten übersichtlich darzustellen – jedes Byte nimmt genau 2 Zeichen ein.

Die Bedingung `fread(...) == 1` prüft: „Wurde genau 1 Element gelesen?“ Wenn das Dateiende erreicht ist, gibt `fread` 0 zurück, die Bedingung ist falsch, und die Schleife endet.

Für größere Blöcke (effizienter als Byte für Byte):

```c
char buffer[64];
int gelesen;
while ((gelesen = fread(buffer, 1, 64, file)) > 0)
{
    // gelesen enthält die tatsächliche Anzahl gelesener Bytes
    // (kann beim letzten Mal kleiner als 64 sein)
}
```

**Selbsttest:**

Wie geht `fread` mit Zeilenumbrüchen um?

**Antwort:**

Es **ignoriert** sie (hört dort nicht auf) und liest einfach die angegebene Anzahl Bytes.

**Selbsttest:**

Parameter von `fread`: wohin, wie groß ist ein Element, ???, woher

**Antwort:**

**Wie viele Elemente** gelesen werden sollen: `fread(buffer, size, count, datei)`.

**Selbsttest:**

Was gibt `fread` zurück?

**Antwort:**

Die **Anzahl der erfolgreich gelesenen Elemente**; am Dateiende weniger als angefordert oder 0.

**Selbsttest:**

Wofür steht die `0` im Format-String `%02x`?

**Antwort:**

**Mit führenden Nullen auffüllen**, so wird das Byte `0x0A` als `0a` ausgegeben statt nur `a`.

**Selbsttest:**

Mit welcher Funktion lesen Sie binäre Daten (eine angegebene Anzahl Bytes, ohne auf Zeilenumbrüche zu achten) aus einer Datei?

**Antwort:**

`fread(buffer, size, count, datei)`

**Selbsttest:**

Mit welcher Funktion schreiben Sie binäre Daten aus dem Speicher in eine Datei?

**Antwort:**

`fwrite(buf, size, count, file)`

### Text mit fread lesen

Wir wollen den gelesenen Inhalt einer Textdatei mit `printf("%s", buffer)` ausgeben. Ein erster Versuch:

```c
#include <stdio.h>

int main(void)
{
    FILE *file = fopen("phonebook.csv", "r");
    if (file == NULL) return 1;

    char buffer[10];
    while (fread(buffer, 1, 9, file) > 0)
    {
        printf("%s\n", buffer);
    }
    fclose(file);
}
```

*Was beim letzten Durchlauf im Puffer steht, haben wir in der Vorlesung vorhergesagt; die Auflösung steht ab dem Tag nach der Vorlesung hier.*

### Exkurs: BMP-Bild generieren (Hintergrund)

Mit unserem Wissen über File I/O können wir ein BMP-Bild komplett selbst erstellen – **generative Computerkunst**!

**Hinweis:** Das genaue BMP-Datenformat (Header-Struktur, Byte-Reihenfolge, Padding) ist Hintergrund. Es geht darum zu sehen, wie die File-I/O-Funktionen (`fopen`, `fwrite`, `fclose`) zusammenwirken, um eine echte Binärdatei zu erzeugen. Der Code enthält außerdem **Funktionspointer** – ein fortgeschrittenes Konzept, das wir hier nur kurz streifen (ebenfalls Hintergrund).

**Spielen erlaubt!** Ändern Sie die aufgerufene Muster-Funktion am Beginn der `main`-Funktion, schreiben Sie Ihre eigene Muster-Funktion und experimentieren Sie mit Farben und Formeln. Öffnen Sie die erzeugte `kunst.bmp`-Datei nach jedem Aufruf in einem Bildbetrachter oder einfach in VS Code durch Doppelklick oder Eingabe von `code kunst.bmp` und schauen Sie, was passiert!

Das folgende Programm `kunst.c` erzeugt ein 256×256 Pixel großes Bild mit verschiedenen Mustern:

```c
#include <stdio.h>
#include <math.h>  // Für sin(), cos()
// Kompilieren mit "make kunst" oder
// "clang -o kunst kunst.c -lm" ("m" ist die Math-Library)

// Bildgröße (globale Variable, damit alle Funktionen darauf zugreifen können)
int WIDTH = 256;
int HEIGHT = 256;

// ============================================================
// MUSTER-FUNKTIONEN
// Jede Funktion berechnet RGB für Position (x, y)
// Parameter: x, y, und Pointer auf r, g, b
// ============================================================

// Muster 1: Farbverlauf
void muster_farbverlauf(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    *r = x;           // Rot nimmt nach rechts zu
    *g = y;           // Grün nimmt nach oben zu
    *b = 128;         // Blau konstant
}

// Muster 2: Schachbrett
void muster_schachbrett(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    int feldgroesse = 32;
    if ((x / feldgroesse + y / feldgroesse) % 2 == 0)
    {
        *r = 255; *g = 255; *b = 255;  // Weiß
    }
    else
    {
        *r = 0; *g = 0; *b = 0;        // Schwarz
    }
}

// Muster 3: XOR-Fraktal (Sierpinski-Dreieck!)
void muster_xor_fraktal(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    int xor_wert = x ^ y;
    *r = xor_wert;
    *g = xor_wert * 2;
    *b = 255 - xor_wert;
}

// Muster 4: Konzentrische Kreise
void muster_kreise(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    int dx = x - WIDTH / 2;
    int dy = y - HEIGHT / 2;
    int distanz = dx * dx + dy * dy;  // Quadrat der Entfernung vom Zentrum

    *r = (distanz / 100) % 256;
    *g = (distanz / 50) % 256;
    *b = (distanz / 25) % 256;
}

// Muster 5: Diagonale Streifen
void muster_streifen(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    int streifen = (x + y) / 16;
    if (streifen % 2 == 0)
    {
        *r = 255; *g = 100; *b = 50;   // Orange
    }
    else
    {
        *r = 50; *g = 100; *b = 255;   // Blau
    }
}

// Muster 6: Plasma-Effekt (vereinfacht)
void muster_plasma(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    // Einfache Wellen-Kombination
    int wert1 = (x * x + y * y) / 100;
    int wert2 = x * y / 64;
    int wert3 = (x - y) * (x - y) / 100;

    *r = (wert1 + wert2) % 256;
    *g = (wert2 + wert3) % 256;
    *b = (wert1 + wert3) % 256;
}

// Muster 7: Multiplikationsmuster
void muster_multiplikation(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    *r = (x * y) % 256;
    *g = (x * y / 2) % 256;
    *b = (x * y / 4) % 256;
}

// Muster 8: Raster mit Farbverlauf
void muster_raster(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    // Dünne Linien alle 16 Pixel
    if (x % 16 == 0 || y % 16 == 0)
    {
        *r = 255; *g = 255; *b = 255;  // Weiße Linien
    }
    else
    {
        *r = x; *g = 0; *b = y;        // Farbverlauf dazwischen
    }
}

// Muster 9: Wellen mit sin/cos
void muster_wellen(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    // sin() erwartet Radiant, gibt Werte von -1 bis 1 zurück
    // Wir skalieren auf 0-255
    double welle1 = sin(x / 16.0) * 127 + 128;
    double welle2 = cos(y / 16.0) * 127 + 128;
    double welle3 = sin((x + y) / 20.0) * 127 + 128;

    *r = (unsigned char) welle1;
    *g = (unsigned char) welle2;
    *b = (unsigned char) welle3;
}

// Muster 10: Interferenz (überlappende Wellen)
void muster_interferenz(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    // Zwei Wellenzentren
    double dx1 = x - WIDTH / 4;
    double dy1 = y - HEIGHT / 4;
    double dist1 = sqrt(dx1 * dx1 + dy1 * dy1);

    double dx2 = x - 3 * WIDTH / 4;
    double dy2 = y - 3 * HEIGHT / 4;
    double dist2 = sqrt(dx2 * dx2 + dy2 * dy2);

    // Überlagerung der Wellen
    double wert = sin(dist1 / 8.0) + sin(dist2 / 8.0);
    unsigned char farbe = (unsigned char)((wert + 2) * 63);  // Skalieren auf 0-255

    *r = farbe;
    *g = 255 - farbe;
    *b = 128;
}

// Muster 11: Spirale
void muster_spirale(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    double dx = x - WIDTH / 2;
    double dy = y - HEIGHT / 2;
    double winkel = atan2(dy, dx);  // Winkel in Radiant (-π bis π)
    double distanz = sqrt(dx * dx + dy * dy);

    // Spirale: Farbe hängt von Winkel + Distanz ab
    double wert = sin(winkel * 5 + distanz / 10.0) * 127 + 128;

    *r = (unsigned char) wert;
    *g = (unsigned char) (255 - wert);
    *b = (unsigned char) ((winkel + 3.14159) / 6.28318 * 255);
}

// ============================================================
// EIGENES MUSTER HIER EINFÜGEN!
// ============================================================
void muster_eigenes(int x, int y, unsigned char *r, unsigned char *g, unsigned char *b)
{
    // TODO: Eigene Formel hier!
    *r = 128;
    *g = 128;
    *b = 128;
}

// ============================================================
// FUNKTIONSPOINTER-ARRAY
// Pointer können auch auf Funktionen zeigen!
// ============================================================

// Typ-Definition: Ein Pointer auf eine Muster-Funktion
typedef void (*MusterFunktion)(int, int, unsigned char*, unsigned char*, unsigned char*);

// Array aller Muster-Funktionen (Index = Muster-Nummer)
MusterFunktion alle_muster[] = {
    muster_eigenes,       // 0
    muster_farbverlauf,   // 1
    muster_schachbrett,   // 2
    muster_xor_fraktal,   // 3
    muster_kreise,        // 4
    muster_streifen,      // 5
    muster_plasma,        // 6
    muster_multiplikation,// 7
    muster_raster,        // 8
    muster_wellen,        // 9
    muster_interferenz,   // 10
    muster_spirale        // 11
};

int ANZAHL_MUSTER = 12;

// ============================================================
// HAUPTPROGRAMM
// ============================================================

int main(void)
{
    // *** HIER MUSTER AUSWÄHLEN (0-11) ***
    int muster = 1;

    // Sicherheitscheck
    if (muster < 0 || muster >= ANZAHL_MUSTER)
    {
        muster = 0;
    }

    // Datei öffnen
    FILE *file = fopen("kunst.bmp", "wb");
    if (file == NULL)
    {
        printf("Fehler beim Öffnen!\n");
        return 1;
    }

    // === BMP Header schreiben (54 Bytes) ===
    fprintf(file, "BM");
    int filesize = 54 + WIDTH * HEIGHT * 3;
    fwrite(&filesize, 4, 1, file);
    int zero = 0;
    fwrite(&zero, 4, 1, file);
    int offset = 54;
    fwrite(&offset, 4, 1, file);

    int headersize = 40;
    fwrite(&headersize, 4, 1, file);
    fwrite(&WIDTH, 4, 1, file);
    fwrite(&HEIGHT, 4, 1, file);
    short planes = 1;
    fwrite(&planes, 2, 1, file);
    short bitcount = 24;
    fwrite(&bitcount, 2, 1, file);
    for (int i = 0; i < 6; i++)
    {
        fwrite(&zero, 4, 1, file);
    }

    // === Pixel schreiben ===
    for (int y = 0; y < HEIGHT; y++)
    {
        for (int x = 0; x < WIDTH; x++)
        {
            unsigned char r, g, b;

            // Muster-Funktion über Array aufrufen - eine Zeile!
            alle_muster[muster](x, y, &r, &g, &b);

            // BMP speichert BGR (nicht RGB!)
            fputc(b, file);
            fputc(g, file);
            fputc(r, file);
        }
    }

    fclose(file);
    printf("kunst.bmp mit Muster %i erstellt!\n", muster);
    return 0;
}
```

#### Was sind Funktionspointer? (Hintergrund)

Im Code oben taucht eine ungewöhnliche Zeile auf:

```c
typedef void (*MusterFunktion)(int, int, unsigned char*, unsigned char*, unsigned char*);
```

Das definiert einen neuen Typ namens `MusterFunktion`. Eine Variable dieses Typs kann die **Adresse einer Funktion** speichern – genau wie ein `int*` die Adresse eines `int` speichert.

Warum ist das nützlich? Wir können ein Array von Funktionen anlegen:

```c
MusterFunktion alle_muster[] = { muster_farbverlauf, muster_schachbrett, ... };
```

Und dann eine Funktion über ihren Index aufrufen:

```c
alle_muster[muster](x, y, &r, &g, &b);  // Ruft die muster-te Funktion auf
```

So können wir zur Laufzeit entscheiden, welche Funktion ausgeführt wird – ohne lange `if-else`- oder `switch`-Ketten. Das ist ein mächtiges Konzept, das wir in Inf-Einf-B aber nicht mehr benötigen.

**So fügen Sie ein eigenes Muster hinzu:**
1. Kopieren Sie eine bestehende Muster-Funktion
2. Benennen Sie sie um (z.B. `muster_meinname`)
3. Ändern Sie die Berechnung von `*r`, `*g`, `*b`
4. Fügen Sie den Funktionsnamen zum Array `alle_muster[]` hinzu
5. Erhöhen Sie `ANZAHL_MUSTER` um 1
6. Kompilieren und testen!

**Ideen zum Experimentieren:**
- `*r = (x * x + y * y) / 200` – Radiale Helligkeit
- `*g = abs(x - y)` – Diagonale (braucht `#include <stdlib.h>`)
- `*b = (int)(sin(x / 10.0) * sin(y / 10.0) * 127) + 128` – Gitter aus Wellen
- Kombinieren Sie mehrere Muster!

*Weitere Selbsttests zu diesem Abschnitt stehen ab dem Tag nach der Vorlesung hier.*

## Eingaben: `scanf` und `fgets`

`get_int` und `get_string` stammen aus `cs50.h`. Ohne die Bibliothek liest `scanf` Werte von der Tastatur: `scanf("%i", …)` liest eine ganze Zahl, wie `printf` mit `%i` eine ausgibt. `scanf` soll die Zahl in eine Variable schreiben, also braucht es deren Adresse, wie `swap` und wie `fread(&b, …)`. Was `make` zu `scanf("%i", n);` sagt, also ohne `&`, haben wir in der Vorlesung vorhergesagt.

*Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

```c
#include <stdio.h>

int main(void)
{
    int n = 0;
    printf("n: ");
    if (scanf("%i", &n) != 1)
    {
        printf("Das war keine Zahl.\n");
        return 1;
    }
    printf("%i\n", n);
}
```

```text
$ make scanf-ok
$ ./scanf-ok
n: 21
21
$ ./scanf-ok
n: abc
Das war keine Zahl.
```

Mit `%s` liest `scanf` ein Wort. Kein `&`: `s` enthält schon die Adresse aus `malloc`, der dritte Fall der Regel aus dem Abschnitt zu `sizeof`.

```c
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char *s = malloc(4);
    if (s == NULL)
    {
        return 1;
    }
    printf("Name: ");
    scanf("%s", s);
    printf("Hallo, %s\n", s);
    free(s);
}
```

*Was bei der Eingabe `HALLO` passiert, haben wir in der Vorlesung vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

**Die Größe kennt nur, wer das Array sieht.** `%s` weiß nicht, wie groß Ihr Puffer ist. Was nicht hineinpasst, landet im Speicher daneben: ein **Buffer Overflow**. Text liest man deshalb mit `fgets`, das die Größe des Puffers mitbekommt:

```c
#include <stdio.h>

int main(void)
{
    char s[4];
    printf("s: ");
    fgets(s, sizeof(s), stdin);
    printf("%s\n", s);
}
```

```text
$ make fgets
$ ./fgets
s: HALLO
HAL
```

`fgets` liest höchstens `sizeof(s) - 1` = 3 Zeichen und hängt das `\0` an. `stdin` ist die Tastatur, schon geöffnet. `sizeof(s)` funktioniert hier, weil `s` ein Array ist; bei `char *s = malloc(4);` wäre `sizeof(s)` 8, die Größe des Pointers, und Sie schreiben die 4 selbst hin.

### Mehr zu `scanf`

`get_int` und `get_string` stammen aus der CS50-Bibliothek. Ohne sie liest man mit `scanf` Werte von der Standard-Eingabe ein. `scanf` erwartet einen Format-String wie `printf` und die Adresse im Speicher, an die es den eingelesenen Wert speichern soll. Bevor man `scanf` aufruft, muss man also den benötigten Speicher auf dem Stack oder Heap reservieren.

Schauen wir uns erst einmal an, wie man mit scanf eine Zahl einliest (so ähnlich wie `get_int` aus `cs50.h`):

```c
#include <stdio.h>

int main(void)
{
    int n = 0;
    if (scanf("%i", &n) != 1)
    {
        printf("Das war keine Zahl.\n");
        return 1;
    }
    printf("n = %i\n", n);
}
```

Mit `%i` schreibt `scanf` höchstens einen `int` (4 Bytes), über das Ziel hinaus schreibt es also nie. Ob überhaupt eine Zahl kam, sagt der Rückgabewert: 1 heißt, ein Wert wurde gelesen; bei `abc` ist er 0, und `n` bliebe ohne die Prüfung unverändert. Eine Zahl, die nicht in einen `int` passt, liest `scanf` aber nicht verlässlich: In der Kursumgebung wird aus `99999999999` ohne jede Meldung `1215752191`. Und `%i` liest die Schreibweise mit: `010` wird zu 8 (eine führende 0 heißt oktal), `0x10` zu 16. Wer nur Dezimalzahlen will, nimmt `%d`.

Dieselbe Regel wie bei `fread`: Eine Variable bekommt ein `&` (`scanf("%i", &n)`); ein Array oder ein Pointer nicht, die sind schon Adressen. Deshalb steht in `scanf("%s", s)` mit `char *s = malloc(4)` kein `&`. Was dabei schiefgehen kann, zeigt der nächste Abschnitt.

### scanf mit %s

Mit `%s` liest `scanf` Text, und zwar beliebig viele Zeichen – eben bis die Eingabe im Terminal zu Ende ist:

```c
#include <stdio.h>

int main(void)
{
    char s1[10] = "Hello";
    printf("%s\n", s1);
}
```

Ausgabe: `Hello` – soweit alles gut.

Jetzt fügen wir `scanf` hinzu:

```c
#include <stdio.h>

int main(void)
{
    char s1[10] = "Hello";
    printf("s1 vorher: %s\n", s1);
    scanf("%s", s1);
    printf("s1 nachher: %s\n", s1);
}
```

Wenn wir „123“ eingeben:
```
s1 vorher: Hello
123
s1 nachher: 123
```

Das sieht wie erwartet aus: `scanf` hat die drei Zeichen „123“ eingelesen und noch einen NUL-Terminator (`\0`) dahinter in den Buffer `s1` geschrieben. `printf` hört das Lesen dort auf.

Nach dem NUL-Zeichen steht in `s1` natürlich noch das `o` von „Hello“ im Speicher – scanf hat es nicht überschrieben. Diesen Teil des Strings „sieht“ `printf` aber nicht, weil es beim ersten NUL-Zeichen ab der Startadresse des Strings zu lesen aufhört.

*Was bei einer zu langen Eingabe passiert, haben wir in der Vorlesung vorhergesagt; die Auflösung steht ab dem Tag nach der Vorlesung hier.*

## Übung im Midterm-Format: Nullen zählen

Diese Übung hat das Format des Midterms: eine Spezifikation, eine Beispieldatei und Aufrufe mit genauer Ausgabe. Im Midterm am 7. Dezember lösen Sie in 75 Minuten kleine Programmieraufgaben in C, Stoff ist alles bis einschließlich dieser Vorlesung (Pointer, dynamischer Speicher, Dateien; Datenstrukturen gehören nicht dazu). Hilfsmittel sind das CS50-Handbuch und VS Code mit Debugger, kein Spickzettel, keine KI. Anmelden müssen Sie sich bis Donnerstag, 26. November (siehe [Prüfung](https://inf.zone/extras/exam/#midterm)).

Schreiben Sie `nullen.c`. Das Programm bekommt einen Dateinamen als Kommandozeilenargument, liest die Datei Byte für Byte und gibt aus, wie viele Bytes den Wert 0 haben. Ohne genau ein Argument gibt es `Usage: ./nullen datei` aus und gibt 1 zurück. Lässt sich die Datei nicht öffnen, gibt es `Kann <name> nicht öffnen.` aus und gibt 1 zurück.

```text
$ hexdump -C t.bin
00000000  00 41 00 00 ff 00 42                              |.A....B|
00000007
$ ./nullen t.bin
?
$ ./nullen
Usage: ./nullen datei
$ ./nullen gibtsnicht.bin
Kann gibtsnicht.bin nicht öffnen.
```

1. **Stufe 1:** Was gibt `./nullen t.bin` aus, was steht also statt `?`?
2. **Stufe 2:** Füllen Sie die Lücken A bis D:

    ```c
    #include <stdint.h>
    #include <stdio.h>

    int main(int argc, char *argv[])
    {
        if (argc != 2)
        {
            printf("Usage: ./nullen datei\n");
            return 1;
        }
        FILE *datei = fopen(___A___, ___B___);
        if (___C___)
        {
            printf("Kann %s nicht öffnen.\n", argv[1]);
            return 1;
        }
        uint8_t b;
        int anzahl = 0;
        while (fread(___D___, 1, 1, datei) == 1)
        {
            if (b == 0)
            {
                anzahl++;
            }
        }
        fclose(datei);
        printf("%i\n", anzahl);
    }
    ```

3. **Stufe 3 (Midterm-Probe):** Schreiben Sie `nullen.c` ganz, am Laptop, ohne Stufe 2 anzusehen. Die Testdatei erzeugen Sie mit `printf '\x00\x41\x00\x00\xff\x00\x42' > t.bin` (sie liegt auch im Zip zu dieser Vorlesung). Prüfen Sie alle drei Aufrufe und danach jeweils den Rückgabewert mit `echo $?`.

*Die Lösungen stehen ab dem Tag nach der Vorlesung hier.*

## Rechnen mit `BYTE`

Ein `BYTE` (`uint8_t`, aus `bmp.h` in Übung 5) fasst die Werte 0 bis 255. Was gibt `byte.c` aus?

```c
#include <stdint.h>
#include <stdio.h>

typedef uint8_t BYTE;

int main(void)
{
    BYTE hell = 200;
    hell = hell + 100;
    printf("%i\n", hell);
}
```

*Was dieses Programm ausgibt, haben wir in der Vorlesung vorhergesagt. Die Auflösung steht ab dem Tag nach der Vorlesung hier.*

### Auch `int` hat eine Grenze

Auch ein `int` hat eine Grenze. Moderne Computer haben oft 16, 32 oder sogar 64 GB RAM. Angenommen, wir wollen 10 GB auf einmal reservieren:

```c
char *p = malloc(10 * 1000000000);  // 10 GB?
```

Das funktioniert nicht wie erwartet! Das Problem: Zahlenliterale wie `1000000000` werden vom Compiler als `int` interpretiert. Ein `int` ist typischerweise 32 Bit und kann maximal die Zahl 2 Milliarden (2<sup>31</sup> – 1 = 2.147.483.647) darstellen. Wieso 2<sup>31</sup> – 1 und nicht 2<sup>32</sup> – 1? Weil `int` ein vorzeichenbehafteter Datentyp ist (*signed*); ein Bit von den 32 Bit wird benötigt, um das Vorzeichen zu speichern; der Wertebereich geht von –2.147.483.648 bis +2.147.483.647 geht).

Was passiert bei `10 * 1000000000`? Das Ergebnis (10 Milliarden) passt nicht in einen `int`: ein **Integer Overflow**. Bei `int` (mit Vorzeichen) ist das in C undefiniertes Verhalten. Steht die Rechnung wie hier aus festen Zahlen im Code, merkt es der Compiler, und `make` bricht ab: `overflow in expression; result is 1'410'065'408 with type 'int'`. Rechnet das Programm erst zur Laufzeit mit Eingaben, merkt es niemand.

**Selbsttest:**

Als welcher Datentyp interpretiert der Compiler ein Zahlenliteral wie `1000000000`?

**Antwort:**

Als **`int`** (typischerweise 32 Bit).

**Selbsttest:**

Welche größte Zahl kann ein 32-Bit-`int` ungefähr darstellen?

**Antwort:**

Etwa **2 Milliarden** (genau 2.147.483.647).

**Selbsttest:**

Warum reicht ein 32-Bit-`int` nur bis etwa 2 Milliarden und nicht bis etwa 4 Milliarden?

**Antwort:**

`int` ist **vorzeichenbehaftet** (*signed*): Ein Bit wird für das Vorzeichen gebraucht.

**Selbsttest:**

Wie heißt es, wenn das Ergebnis einer Rechnung nicht mehr in den Datentyp passt, etwa `10 * 1000000000` in einen `int`?

**Antwort:**

**Integer Overflow.** Bei `int` (mit Vorzeichen) ist das in C undefiniertes Verhalten.

## Zusammenfassung

1. **Stack und Heap.** Jeder Aufruf einer Funktion bekommt einen eigenen Frame auf dem Stack; nach `return` ist er weg (der Speicher wird nicht geputzt, nur wiederverwendet). Der Stack ist klein (etwa 8 MB). Was länger leben soll oder groß ist, kommt mit `malloc` auf den Heap und bleibt, bis `free` es zurückgibt. Prüfen Sie auf `NULL`; valgrind findet, was Sie vergessen.
2. **Dateien.** `fopen` (`NULL` prüfen), lesen und schreiben mit `fread` und `fwrite` in Blöcken, `fclose`. `fread` will eine Adresse: eine Variable mit `&`, ein Array oder ein Pointer ohne, die sind schon Adressen. Es gibt zurück, wie viele Elemente es gelesen hat; 0 heißt: nichts mehr (Dateiende oder Fehler). Schreiben Sie genau so viel, wie gelesen wurde.
3. **Eingaben.** `scanf("%i", &n)` mit Rückgabewert prüfen; Text nie mit `%s`, sondern mit `fgets` und der Größe des Puffers (`sizeof` nur bei einem Array, nicht bei einem Pointer aus `malloc`). Was nicht hineinpasst, läuft über: beim Puffer in den Speicher daneben, bei einer Zahl fängt sie wieder bei 0 an (`BYTE`: 200 + 100 = 300 − 256 = 44).

Außerdem: `int werte[]` und `int *werte` sind nur im Parameter dasselbe; ein Array ist kein Pointer, wird als Argument aber zur Adresse seines ersten Elements. `p + 1` springt ein Element weiter, so weit wie `sizeof` des Typs. Ein 2D-Array ist ein Array aus Zeilen; `image[i]` ist eine Zeile.

Das brauchen Sie in Übung 6 (Lautstärke und Wiederherstellung, Abgabe bis 6. Dezember) und im Midterm am 7. Dezember. In Vorlesung 5 geht es weiter mit Datenstrukturen: Was tun, wenn ein Array wachsen muss?

*Die Fragen zum Selbsttest helfen beim aktiven Lesen. Sie sind kein Vorgeschmack auf die Prüfung: Fragen und Antworten auswendig zu lernen reicht nicht zum Bestehen und ist vermutlich auch keine sinnvolle Vorbereitung. Was hilft: [Wie Sie Inf-Einf-B bewältigen](https://inf.zone/extras/lernen/#was-funktioniert--und-was-nicht-funktioniert).*

