
Endlich Dateiverwaltung! Bis jetzt waren alle Daten weg wenn das Programm endete. Mit fopen, fprintf und fscanf speicherst du Daten dauerhaft auf der Festplatte. Das ist einer der mächtigsten Schritte in der C-Programmierung!
Warum Dateien?
Bisher hast du alle Variablen im RAM gespeichert. Sobald das Programm endet, sind alle Daten verloren. Dateien lösen dieses Problem:
Problem: RAM ist flüchtig
- Daten existieren nur während das Programm läuft
- Programm endet → alles weg
- Kein Datenaustausch zwischen Programmläufen möglich
Lösung: Dateien auf der Festplatte
- Daten bleiben dauerhaft gespeichert
- Beim nächsten Programmstart wieder lesbar
- Andere Programme können dieselben Daten nutzen
Typische Anwendungen:
- Konfigurationen speichern (Einstellungen, Preferences)
- Log-Dateien schreiben (Fehlermeldungen, Ereignisse)
- Ergebnisse sichern (Testergebnisse, Berechnungen)
- CSV-Dateien verarbeiten (Tabellendaten, Noten, Listen)
Wichtig: #include <stdio.h>
Alle Datei-Funktionen sind in <stdio.h> definiert. Dort ist auch der Typ FILE* deklariert – ein Zeiger auf eine Datei-Struktur, die der Betriebssystem-Kernel verwaltet.
fopen und fclose – Datei öffnen und schließen
Jede Datei-Operation beginnt mit fopen() und endet mit fclose():
FILE *datei = fopen("name.txt", "w"); // Datei öffnen // ... Datei-Operationen ... fclose(datei); // IMMER schließen!
Datei-Modi in der Übersicht:
| Modus | Bedeutung | Datei existiert? | Datei fehlt? |
|---|---|---|---|
| "r" | Lesen | Wird geöffnet | fopen gibt NULL zurück |
| "w" | Schreiben | Wird überschrieben! | Wird neu erstellt |
| "a" | Anhängen (Append) | Wird am Ende ergänzt | Wird neu erstellt |
| "r+" | Lesen + Schreiben | Wird geöffnet | fopen gibt NULL zurück |
Warum fclose() unverzichtbar ist
- Puffer leeren: Geschriebene Daten liegen zunächst im Speicher-Puffer – erst
fclose()schreibt sie wirklich auf die Festplatte - Handle freigeben: Das Betriebssystem hat nur begrenzt viele Datei-Handles – vergisst du
fclose(), gehen sie irgendwann aus - Datei entsperren: Manche Systeme sperren offene Dateien für andere Programme
NULL-Check – unverzichtbar!
fopen() gibt NULL zurück wenn die Datei nicht geöffnet werden kann (z.B. Datei nicht gefunden, keine Schreibrechte). Ohne Prüfung droht ein Absturz:
#include <stdio.h> int main() { FILE *f = fopen("test.txt", "r"); if (f == NULL) { printf("Fehler: Datei nicht gefunden!\n"); return 1; // Programm mit Fehlercode beenden } // Hier: sicher mit f arbeiten fclose(f); return 0; }
Regel: Immer zuerst NULL prüfen!
Jedes fopen() braucht direkt danach einen if (datei == NULL)-Check. Das ist in der C-Programmierung eine absolute Pflicht – ohne diesen Check riskierst du Segmentation Faults.
Textdateien schreiben: fprintf und fputs
Um in eine Datei zu schreiben gibt es zwei Hauptfunktionen:
fprintf(datei, "Hallo %s!\n", name);– wieprintf, aber Ausgabe geht in die Dateifputs("Zeile\n", datei);– schreibt einen String direkt in die Datei
#include <stdio.h> int main() { FILE *f = fopen("zahlen.txt", "w"); if (f == NULL) { printf("Fehler!\n"); return 1; } // 5 Zahlen in die Datei schreiben for (int i = 1; i <= 5; i++) { fprintf(f, "%d\n", i * 10); } fputs("Ende der Liste\n", f); fclose(f); printf("Datei gespeichert!\n"); return 0; }
Textdateien lesen: fscanf und fgets
Zum Lesen aus Dateien gibt es ebenfalls zwei wichtige Funktionen:
fscanf(datei, "%d", &zahl);– wiescanf, aber liest aus der Dateifgets(puffer, groesse, datei);– liest eine ganze Zeile in einen String-Pufferfeof(datei)– gibt true zurück wenn das Dateiende erreicht wurde
#include <stdio.h> int main() { FILE *f = fopen("zahlen.txt", "r"); if (f == NULL) { printf("Fehler!\n"); return 1; } int n, summe = 0; // Loop: solange fscanf eine Zahl lesen kann (gibt 1 zurück) while (fscanf(f, "%d", &n) == 1) { summe += n; printf("Gelesen: %d\n", n); } printf("Summe: %d\n", summe); fclose(f); return 0; }
Loop-Muster mit fscanf
Das Muster while (fscanf(f, "%d", &n) == 1) ist der klassische Weg Zahlen aus einer Datei zu lesen. fscanf gibt die Anzahl erfolgreich gelesener Werte zurück – bei Dateiende oder Fehler gibt es 0 oder EOF zurück.
Vollständiges Beispiel: Noten-Datei
Ein realistisches Beispiel: Noten schreiben und wieder einlesen.
Schritt 1: Noten speichern
#include <stdio.h> int main() { int noten[] = {1, 2, 3, 1, 2}; int anzahl = 5; FILE *f = fopen("noten.txt", "w"); if (f == NULL) { printf("Fehler!\n"); return 1; } for (int i = 0; i < anzahl; i++) { fprintf(f, "%d\n", noten[i]); } fclose(f); printf("%d Noten in noten.txt gespeichert.\n", anzahl); return 0; }
Schritt 2: Noten lesen und Durchschnitt berechnen
#include <stdio.h> int main() { FILE *f = fopen("noten.txt", "r"); if (f == NULL) { printf("Fehler!\n"); return 1; } int note, summe = 0, anzahl = 0; while (fscanf(f, "%d", ¬e) == 1) { printf("Note %d: %d\n", anzahl + 1, note); summe += note; anzahl++; } fclose(f); if (anzahl > 0) { printf("Durchschnitt: %.2f\n", (float)summe / anzahl); } return 0; }
Anhängen: Modus "a"
Mit dem Modus "a" (Append) werden neue Daten ans Ende der Datei geschrieben, ohne den bestehenden Inhalt zu löschen. Ideal für Log-Dateien:
#include <stdio.h> int main() { FILE *log = fopen("log.txt", "a"); // Anhängen! if (log == NULL) { printf("Fehler!\n"); return 1; } fprintf(log, "Programm gestartet - neuer Eintrag\n"); fclose(log); printf("Log-Eintrag geschrieben.\n"); return 0; }
Unterschied: "w" vs. "a"
"w"– überschreibt die Datei komplett bei jedem Programmstart"a"– hängt neue Daten am Ende an, vorhandene Daten bleiben erhalten
Häufige Fehler
| Fehler | Folge | Lösung |
|---|---|---|
| NULL-Check nach fopen fehlt | Absturz (Segmentation Fault) wenn Datei fehlt | Immer if (f == NULL) prüfen |
| fclose() nicht aufgerufen | Daten werden ggf. nicht auf Festplatte geschrieben (Puffer nicht geleert) | Immer am Ende fclose() aufrufen |
| Falscher Pfad (relativ vs. absolut) | Datei wird im falschen Verzeichnis gesucht/erstellt | Absoluten Pfad verwenden oder auf aktuelles Verzeichnis achten |
| Über Dateiende hinaus lesen | Falsche Werte oder Endlosschleife | fscanf-Rückgabewert prüfen oder feof() nutzen |
| Falscher Modus (z.B. "w" statt "r") | Datei wird überschrieben oder Lesen schlägt fehl | Modus-Tabelle beachten |
Code-Simulator
Schreibe C-Code links und führe ihn aus. Der Simulator zeigt printf-Ausgaben sofort:

Im Simulator können wir echte Dateien nicht schreiben – aber du siehst genau was fprintf in die Datei schreiben würde. Probiere das Programm zu Hause mit einem echten C-Compiler aus!
Wissens-Quiz
Spickzettel – Dateiverwaltung
Vollständiges Skelett: Datei öffnen – schreiben – schließen
#include <stdio.h> int main() { // 1. Datei öffnen FILE *f = fopen("datei.txt", "w"); // 2. NULL-Check – IMMER! if (f == NULL) { printf("Fehler beim Öffnen!\n"); return 1; } // 3. Schreiben fprintf(f, "Hallo Datei!\n"); fprintf(f, "Zahl: %d\n", 42); // 4. Datei schließen – IMMER! fclose(f); return 0; }
Checkliste Unit 33
- Ich weiß warum Dateien wichtig sind (Daten dauerhaft speichern)
- Ich kenne alle 4 Datei-Modi und wann ich welchen verwende
- Ich prüfe immer den Rückgabewert von fopen() auf NULL
- Ich rufe immer fclose() auf – damit der Puffer geleert wird
- Ich kann mit fprintf in eine Datei schreiben
- Ich kann mit fscanf und fgets aus einer Datei lesen
- Ich kenne den Unterschied zwischen Modus "w" und "a"