📁 Kapitel 7 · Unit 33 von 36

Dateiverwaltung
fopen · fclose · fprintf · fscanf · fgets

Dateien öffnen & schließen · Schreiben & Lesen · NULL-Check · Anhängen · Textdateien

33 / 36 Units
Ömer
Kapitel 7: Praxis & Fortgeschritten ~100 Min. Theorie + Simulator + Quiz + Spickzettel
Ömer
Ömer sagt:

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():

fopen_syntax.cC
FILE *datei = fopen("name.txt", "w");   // Datei öffnen
// ... Datei-Operationen ...
fclose(datei);                              // IMMER schließen!

Datei-Modi in der Übersicht:

ModusBedeutungDatei existiert?Datei fehlt?
"r"LesenWird geöffnetfopen gibt NULL zurück
"w"SchreibenWird überschrieben!Wird neu erstellt
"a"Anhängen (Append)Wird am Ende ergänztWird neu erstellt
"r+"Lesen + SchreibenWird geöffnetfopen 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:

null_check.cC
#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); – wie printf, aber Ausgabe geht in die Datei
  • fputs("Zeile\n", datei); – schreibt einen String direkt in die Datei
schreiben.cC
#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;
}
Konsolen-Ausgabe
Datei gespeichert!
Inhalt von zahlen.txt
10 20 30 40 50 Ende der Liste

Textdateien lesen: fscanf und fgets

Zum Lesen aus Dateien gibt es ebenfalls zwei wichtige Funktionen:

  • fscanf(datei, "%d", &zahl); – wie scanf, aber liest aus der Datei
  • fgets(puffer, groesse, datei); – liest eine ganze Zeile in einen String-Puffer
  • feof(datei) – gibt true zurück wenn das Dateiende erreicht wurde
lesen.cC
#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;
}
Ausgabe (zahlen.txt enthält 10,20,30,40,50)
Gelesen: 10 Gelesen: 20 Gelesen: 30 Gelesen: 40 Gelesen: 50 Summe: 150

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

noten_schreiben.cC
#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

noten_lesen.cC
#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", &note) == 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;
}
Ausgabe
Note 1: 1 Note 2: 2 Note 3: 3 Note 4: 1 Note 5: 2 Durchschnitt: 1.80

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:

logfile.cC
#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;
}
log.txt nach 3 Programmläufen
Programm gestartet - neuer Eintrag Programm gestartet - neuer Eintrag Programm gestartet - neuer Eintrag

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

FehlerFolgeLösung
NULL-Check nach fopen fehltAbsturz (Segmentation Fault) wenn Datei fehltImmer if (f == NULL) prüfen
fclose() nicht aufgerufenDaten 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/erstelltAbsoluten Pfad verwenden oder auf aktuelles Verzeichnis achten
Über Dateiende hinaus lesenFalsche Werte oder Endlosschleifefscanf-Rückgabewert prüfen oder feof() nutzen
Falscher Modus (z.B. "w" statt "r")Datei wird überschrieben oder Lesen schlägt fehlModus-Tabelle beachten

Code-Simulator

Schreibe C-Code links und führe ihn aus. Der Simulator zeigt printf-Ausgaben sofort:

Hinweis: Echter Datei-I/O ist im Browser nicht möglich. Das Programm simuliert, was in die Datei geschrieben werden würde – die Ausgabe ist mit entsprechenden Kommentaren versehen.
C Simulator – Unit 33: Dateiverwaltung
▶ Ausgabe
– Klicke auf AUSFÜHREN –
Ömer
Ömer sagt:

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

Frage 1
Welche Bibliothek wird für Dateioperationen in C benötigt?
Astdlib.h
Bstdio.h
Cstring.h
Dfile.h
Frage 2
Was gibt fopen() zurück wenn die Datei nicht geöffnet werden kann?
A0
B-1
CNULL
DEOF
Frage 3
Welcher Modus öffnet eine Datei nur zum Lesen?
A"w"
B"r"
C"a"
D"l"
Frage 4
Was passiert bei Modus "w" wenn die Datei bereits existiert?
Afopen gibt NULL zurück
BDer neue Inhalt wird angehängt
CDie Datei wird überschrieben
DEs gibt einen Compilerfehler
Frage 5
Wozu dient fclose()?
ADatei vom Dateisystem löschen
BDen FILE-Pointer auf NULL setzen
CPuffer leeren und Datei-Handle freigeben
DFehler in der Datei beheben
Frage 6
Welche Funktion schreibt formatiert in eine Datei (wie printf, aber in eine Datei)?
Afwrite
Bfprintf
Cfprint
Dprintfile
Frage 7
Was prüft feof(datei)?
AOb die Datei leer ist
BOb das Dateiende erreicht wurde
COb ein Schreibfehler aufgetreten ist
DOb die Datei geöffnet werden konnte
Frage 8
Was ist der Hauptunterschied zwischen Modus "w" und Modus "a"?
A"w" ist schneller als "a"
B"a" kann nicht mit fprintf verwendet werden
C"w" überschreibt die Datei, "a" hängt neuen Inhalt ans Ende an
D"a" erstellt immer eine neue Datei

Spickzettel – Dateiverwaltung

Datei-Modi
"r"Lesen (Datei muss existieren)
"w"Schreiben (überschreibt!)
"a"Anhängen (Append)
"r+"Lesen + Schreiben
Funktionen
fopen(pfad, modus)Datei öffnen → FILE*
fclose(f)Datei schließen
fprintf(f, fmt, ...)Formatiert schreiben
fscanf(f, fmt, ...)Formatiert lesen
fputs(str, f)String schreiben
fgets(buf, n, f)Zeile lesen
feof(f)Dateiende erreicht?
NULL-Check Muster
FILE *f = fopen(...);Datei öffnen
if (f == NULL) return 1;Immer prüfen!
/* ... arbeiten ... */Datei nutzen
fclose(f);Immer schließen!
Loop-Muster
while(fscanf(f,"%d",&n)==1)Zahlen lesen
fgets(buf, 256, f)Zeile lesen
!feof(f)Dateiende prüfen

Vollständiges Skelett: Datei öffnen – schreiben – schließen

skelett.cC
#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"