Notes 4.5
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. Geänderte und neue Absätze haben links einen Strich.
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, 4.5 Call Stack und 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:
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;.
- Stufe 1: Welchen Wert hat
xnachf(x);? - Stufe 2: Welchen Wert hat
xnachg(&x);? - Stufe 3: Welchen Wert hat
xnachh(&x);? Skizzieren Sie dazux,aundbals Kästchen und eine Adresse als Pfeil, einmal vor und einmal nacha = &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:
*pgibt 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;\0markiert das Ende
Was liefert in C der Operator & vor einer Variable?
Antwort
Die Speicheradresse der Variable.
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).
Welcher Ausdruck mit Pointer-Arithmetik ist identisch mit s[i]?
Antwort
*(s + i)
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.
#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:
#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:
#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:
#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:
#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
}Wie heißt der eigene Bereich auf dem Stack, den jede aufgerufene Funktion bekommt?
Antwort
Stack-Frame.
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.
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
returnaufgerufen 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
Ein Stack-Frame enthält u. a. lokale Variablen, Parameter und ???
Antwort
Die Rücksprungadresse.
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.
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?
#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.
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:
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?
Pointerarithmetik:
int a[] = {41, 52, 35, 24, 17}; int *p = a + 2; printf("%i\n", *(p + 2));Ein Array als Parameter:
void f(int a[]) { a[2] = 61; } // in main: int werte[] = {12, 35, 38}; f(werte); printf("%i\n", werte[2]);Ein 2D-Array:
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):
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?
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!.
Stufe 1: Was gibt dieses Programmstück aus?
string s = get_string("s: "); string t = s; t[0] = 'H'; printf("%s %s\n", s, t);Stufe 2: Was gibt es jetzt aus, und wie viele Bytes holt
malloc?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);Stufe 3: In diesem Stück stecken zwei Fehler. Welche?
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.
#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?
#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:
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);.
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:
#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:
#include <stdio.h>
int main(void)
{
int *numbers = malloc(4 * sizeof(int));
}Wenn wir das kompilierenProgramm, das Quellcode in Maschinencode übersetzt; diesen Vorgang nennt man kompilieren. Jedes C-Programm muss kompiliert werden, bevor es laufen kann. Glossar →, bekommen wir einen Fehler. Wir haben vergessen, die Standard-Library einzubinden:
#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:
#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 LaufzeitsizeBytes auf dem Heap und gibt einen Pointer zurücksizeof(typ)gibt die Größe eines Datentyps in Bytes zurück- Garbage-Werte:
mallocinitialisiert 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 (siehesizeof).
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.
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.
Welche Header-Datei muss man einbinden, um malloc zu verwenden?
Antwort
<stdlib.h> (die Standard-Library).
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:
#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:
#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 faultWarum? "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.)
#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:
#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:
#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:
#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:
#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 vonsrcnachdest– Ziel muss genug Platz haben!
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.
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.
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.
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).
Mit welchem Platzhalter gibt printf eine Adresse aus?
Antwort
%p
In welcher Reihenfolge erwartet strcpy Ziel und Quelle?
Antwort
Erst das Ziel, dann die Quelle: strcpy(dest, src).
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.
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:
#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:
#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 DebuggerWerkzeug, mit dem Sie ein Programm Zeile für Zeile ablaufen lassen und dabei die Werte der Variablen ansehen. In CS50 setzen Sie mit einem Klick links neben eine Zeilennummer einen Haltepunkt und starten dann mit debug50 ./programm den Debugger von VS Code. Glossar → 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:
#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= read (lesen erlaubt)w= write (schreiben erlaubt)x= execute (ausführen erlaubt)p= private (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 imr--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 (xfehlt) – 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
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.
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:
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.
#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
#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:
#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:
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:
#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,9876543210Dateimodi
| 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 LinuxEin Betriebssystem wie Windows oder macOS. Die CS50-Umgebung und die Prüfungslaptops laufen mit Linux. Glossar →/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.
Was gibt fopen zurück, wenn das Öffnen der Datei fehlschlägt?
Antwort
NULL. Deshalb prüft man nach fopen immer auf NULL.
Worin unterscheidet sich fprintf von printf?
Antwort
fprintf schreibt formatiert in eine Datei; es bekommt dazu einen FILE* als erstes Argument.
Mit welcher Funktion schließt man eine geöffnete Datei?
Antwort
fclose(file)
Was bewirkt der Modus "w" bei fopen?
Antwort
Schreiben: Die Datei wird erstellt oder überschrieben.
Was bewirkt der Modus "a" bei fopen?
Antwort
Anhängen: Geschriebenes wird am Ende der Datei hinzugefügt.
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.
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).
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:
#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
fgetsden Pointer auf den Buffer zurück (alsoline) - Am Dateiende (oder bei Fehler) gibt
fgetsNULLzurück
Das passt perfekt zu einer while-Schleife:
#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.
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.
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:
// 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 (vontypedefdefiniert)fopen(name, mode): Öffnet Datei, gibtNULLbei Fehler zurückfprintf(file, format, ...): Wieprintf, aber in eine Dateifread(buf, size, count, file): Liest binäre Datenfwrite(buf, size, count, file): Schreibt binäre Datenfclose(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:
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 & 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?
#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:
#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 CompilerProgramm, das Quellcode in Maschinencode übersetzt; diesen Vorgang nennt man kompilieren. Jedes C-Programm muss kompiliert werden, bevor es laufen kann. Glossar → 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).
Was gibt sizeof(typ) zurück?
Antwort
Die Größe des Datentyps in Bytes.
Wie nennt man eine Schreibweise wie numbers[i], die nur eine einfachere Form von *(numbers + i) ist?
Antwort
Syntaktischer Zucker (syntactic sugar).
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.
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).
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.
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].
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:
// 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]?
#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:
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&, etwafread(&b, 1, 1, datei)oderfread(&bf, …)infilter.c - Array: ohne
&, etwafread(puffer, 1, 4, datei)oderfread(image[i], …); ein Array wird als Argument zur Adresse seines ersten Elements - Pointer: ohne
&, etwafread(t, 1, 4, datei)mittausmalloc; 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:
#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:
freadgibt die Anzahl der erfolgreich gelesenen Elemente zurück- Am Dateiende gibt es weniger zurück als angefordert (oder 0)
#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):
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)
}Wie geht fread mit Zeilenumbrüchen um?
Antwort
Es ignoriert sie (hört dort nicht auf) und liest einfach die angegebene Anzahl Bytes.
Parameter von fread: wohin, wie groß ist ein Element, ???, woher
Antwort
Wie viele Elemente gelesen werden sollen: fread(buffer, size, count, datei).
Was gibt fread zurück?
Antwort
Die Anzahl der erfolgreich gelesenen Elemente; am Dateiende weniger als angefordert oder 0.
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.
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)
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:
#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 CodeVisual Studio Code, der kostenlose Code-Editor von Microsoft, in dem Sie im Kurs programmieren. Glossar → 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:
#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:
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:
MusterFunktion alle_muster[] = { muster_farbverlauf, muster_schachbrett, ... };Und dann eine Funktion über ihren Index aufrufen:
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:
- Kopieren Sie eine bestehende Muster-Funktion
- Benennen Sie sie um (z.B.
muster_meinname) - Ändern Sie die Berechnung von
*r,*g,*b - Fügen Sie den Funktionsnamen zum Array
alle_muster[]hinzu - Erhöhen Sie
ANZAHL_MUSTERum 1 - 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.
#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);
}$ 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.
#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:
#include <stdio.h>
int main(void)
{
char s[4];
printf("s: ");
fgets(s, sizeof(s), stdin);
printf("%s\n", s);
}$ make fgets
$ ./fgets
s: HALLO
HALfgets 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):
#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 TerminalFenster, in dem Sie dem Computer Befehle als Text eintippen statt zu klicken. In VS Code liegt es im unteren Bereich des Fensters. Glossar → zu Ende ist:
#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:
#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: 123Das 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).
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.
$ 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.Stufe 1: Was gibt
./nullen t.binaus, was steht also statt??Stufe 2: Füllen Sie die Lücken A bis D:
#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); }Stufe 3 (Midterm-Probe): Schreiben Sie
nullen.cganz, am Laptop, ohne Stufe 2 anzusehen. Die Testdatei erzeugen Sie mitprintf '\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 mitecho $?.
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?
#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:
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 (231 – 1 = 2.147.483.647) darstellen. Wieso 231 – 1 und nicht 232 – 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.
Als welcher Datentyp interpretiert der Compiler ein Zahlenliteral wie 1000000000?
Antwort
Als int (typischerweise 32 Bit).
Welche größte Zahl kann ein 32-Bit-int ungefähr darstellen?
Antwort
Etwa 2 Milliarden (genau 2.147.483.647).
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.
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
- Stack und Heap. Jeder Aufruf einer Funktion bekommt einen eigenen Frame auf dem Stack; nach
returnist 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 mitmallocauf den Heap und bleibt, bisfreees zurückgibt. Prüfen Sie aufNULL; valgrind findet, was Sie vergessen. - Dateien.
fopen(NULLprüfen), lesen und schreiben mitfreadundfwritein Blöcken,fclose.freadwill 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. - Eingaben.
scanf("%i", &n)mit Rückgabewert prüfen; Text nie mit%s, sondern mitfgetsund der Größe des Puffers (sizeofnur bei einem Array, nicht bei einem Pointer ausmalloc). 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.
Diese Seite als Markdown: ansehen herunterladen