Dateien in C: fopen, fclose und zeilenweises Lesen

Alles, was ein Programm berechnet, verschwindet beim Beenden, sofern es das Ergebnis nicht aufschreibt. Cs Dateischnittstelle lebt in <stdio.h> - demselben Header wie printf - und sie ist bewusst ähnlich: Eine Datei ist ein Strom von Bytes, und die Funktionen, die auf dem Bildschirm arbeiten, haben Zwillinge, die ein Stromargument entgegennehmen.

Der Handle-Typ ist FILE *. Du siehst nie in ein FILE hinein; es ist ein undurchsichtiger Typ (siehe typedef), und du hältst immer nur einen Zeiger darauf.

Die drei Schritte

Jede Dateioperation hat dieselbe Form: öffnen, benutzen, schließen.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("greeting.txt", "w");
    if (fp == NULL) {
        fprintf(stderr, "Konnte die Datei nicht zum Schreiben oeffnen.\n");
        return 1;
    }

    fprintf(fp, "Hallo, Datei!\n");
    fprintf(fp, "Geschrieben von einem C-Programm.\n");

    fclose(fp);
    printf("greeting.txt geschrieben\n");
    return 0;
}

Die NULL-Prüfung ist keine optionale Paranoia. fopen schlägt fehl, wann immer die Datei nicht existiert (im Lesemodus), das Verzeichnis nicht beschreibbar ist, der Pfad falsch ist oder dem Prozess die Dateihandles ausgegangen sind - und jeder dieser Fälle liefert NULL. Ein NULL-Handle zu benutzen ist ein Segmentierungsfehler.

Den Fehler nach stderr statt nach stdout zu schicken ist die Konvention: Es ist ungepuffert und lässt sich getrennt von der eigentlichen Ausgabe umleiten.

fopen-Modi

Das zweite Argument ist eine kurze Moduszeichenkette. Sie falsch zu wählen ist der zerstörerischste Fehler in diesem ganzen Bereich, denn "w" leert eine vorhandene Datei stillschweigend.

Hänge an jeden davon ein b an ("rb", "wb", "ab+") für den Binärmodus - dazu mehr am Ende.

Zwei Regeln, die echten Datenverlust verhindern:

• Nimm "r", wenn du lesen willst. "r+" auf einem vertippten Dateinamen scheitert sicher; "w+" legt eine leere Datei an, und du hast nichts als Zeit verloren. "w" auf dem richtigen Dateinamen, wenn du "r" meintest, zerstört die Daten.
• Nimm "a" für Protokolle. Jedes fprintf landet am Ende, unabhängig davon, wo der Strom positioniert war, und genau das will ein Protokoll.

Schreiben und Lesen in einem Programm

Der Editor unten führt einen vollständigen Rundlauf aus - er legt eine Datei an, schreibt Datensätze hinein, schließt sie, öffnet sie erneut zum Lesen und gibt aus, was er findet.

#include <stdio.h>

int main(void) {
    const char *path = "scores.txt";

    /* --- schreiben --- */
    FILE *out = fopen(path, "w");
    if (out == NULL) {
        fprintf(stderr, "kann %s nicht zum Schreiben oeffnen\n", path);
        return 1;
    }
    fprintf(out, "Ada %d\n", 92);
    fprintf(out, "Grace %d\n", 105);
    fprintf(out, "Alan %d\n", 87);
    fclose(out);

    /* --- wieder einlesen --- */
    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "kann %s nicht zum Lesen oeffnen\n", path);
        return 1;
    }

    char name[32];
    int  score;
    int  total = 0, count = 0;

    while (fscanf(in, "%31s %d", name, &score) == 2) {
        printf("%-8s %3d\n", name, score);
        total += score;
        count++;
    }
    fclose(in);

    if (count > 0) {
        printf("Durchschnitt: %.1f\n", (double)total / count);
    }
    return 0;
}

fprintf und fscanf sind printf und scanf mit einem Strom als erstem Argument; alles an ihren Formatangaben ist identisch, einschließlich der Breite %31s, die name vor dem Überlaufen bewahrt.

Die Schleifenbedingung lautet == 2, die Anzahl der Elemente, nach denen das Format fragt. Stattdessen gegen EOF zu prüfen ist ein klassischer Bug: Eine fehlerhafte Zeile lässt fscanf 0 liefern, nicht EOF, und die Schleife dreht sich ewig über einer Eingabe, die sie nicht verbrauchen kann.

Zeilenweises Lesen mit fgets

fscanf ist bequem für streng formatierte Daten. Für Textdateien - Konfiguration, Protokolle, CSV, alles, was ein Mensch geschrieben hat - lies ganze Zeilen. Diese Schleife ist die kanonische:

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

int main(void) {
    const char *path = "notes.txt";

    FILE *out = fopen(path, "w");
    if (out == NULL) { return 1; }
    fprintf(out, "erste Zeile\n");
    fprintf(out, "zweite Zeile\n");
    fprintf(out, "dritte Zeile\n");
    fclose(out);

    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "kann %s nicht oeffnen\n", path);
        return 1;
    }

    char line[256];
    int  lineno = 0;

    while (fgets(line, sizeof line, in) != NULL) {
        line[strcspn(line, "\n")] = '\0';    /* den Zeilenumbruch abschneiden */
        lineno++;
        printf("%3d: [%s] (%zu Zeichen)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

Was fgets zur richtigen Voreinstellung macht:

• Es nimmt die Puffergröße entgegen, kann also nicht überlaufen. Übergib sizeof line, und der Aufruf bleibt korrekt, wenn du das Array vergrößerst.
• Es liefert am Dateiende NULL oder bei einem Fehler, was eine saubere Schleifenbedingung ist.
• Es behält den Zeilenumbruch, wenn die Zeile in den Puffer passte. Das ist nützlich - kein '\n' im Erhaltenen bedeutet, dass die Zeile länger als dein Puffer war und der Rest noch wartet. strcspn(line, "\n") findet den Index des Zeilenumbruchs (oder die Länge der Zeichenkette, wenn es keinen gibt), dort '\0' zuzuweisen schneidet ihn also in beiden Fällen ab.

Um ein echtes Dateiende von einem Fehler zu unterscheiden, frage nach der Schleife:

if (ferror(in)) {
    fprintf(stderr, "Lesefehler\n");
} else if (feof(in)) {
    /* normales Ende */
}

Schreibe nicht while (!feof(fp)) als Schleifenbedingung. feof wird erst wahr, nachdem ein Lesezugriff bereits fehlgeschlagen ist, diese Schleife verarbeitet also den letzten Pufferinhalt ein zusätzliches Mal. Prüfe stattdessen den Rückgabewert der Lesefunktion - wie es beide Schleifen oben tun.

Zeichen für Zeichen: fgetc und fputc

Für Arbeit auf Byteebene - Zeichen zählen, eine Datei umformen, kopieren - behandeln fgetc und fputc ein Zeichen pro Aufruf.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *src = "mixed.txt";
    const char *dst = "upper.txt";

    FILE *out = fopen(src, "w");
    if (out == NULL) { return 1; }
    fputs("Hallo, C-Programmierer!\n", out);
    fclose(out);

    FILE *in = fopen(src, "r");
    FILE *up = fopen(dst, "w");
    if (in == NULL || up == NULL) {
        if (in) fclose(in);
        if (up) fclose(up);
        return 1;
    }

    int c;
    int letters = 0, lines = 0;

    while ((c = fgetc(in)) != EOF) {
        if (isalpha(c)) letters++;
        if (c == '\n')  lines++;
        fputc(toupper(c), up);
    }

    fclose(in);
    fclose(up);

    printf("%d Buchstaben, %d Zeilen\n", letters, lines);

    /* das Ergebnis zeigen */
    FILE *check = fopen(dst, "r");
    if (check != NULL) {
        char line[128];
        while (fgets(line, sizeof line, check) != NULL) {
            printf("%s", line);
        }
        fclose(check);
    }
    return 0;
}

Ein Detail, auf das es ankommt: c ist als int deklariert, nicht als char. fgetc liefert ein int, damit es jeden möglichen Bytewert und den eigenständigen Wächter EOF (der -1 ist) zurückgeben kann. Es in einem char zu speichern macht den Vergleich gegen EOF entweder immer falsch oder fälschlich wahr für das Byte 0xFF, je nachdem, ob char auf deiner Plattform vorzeichenbehaftet ist. Das ist eine der ältesten Fallen in C.

Fehler richtig prüfen

Ein produktionsreifer Lesezugriff sieht so aus:

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main(void) {
    FILE *fp = fopen("does-not-exist.txt", "r");
    if (fp == NULL) {
        fprintf(stderr, "Oeffnen fehlgeschlagen: %s\n", strerror(errno));
        perror("perror sagt");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno hält einen Code, der den letzten Fehlschlag beschreibt, und strerror macht daraus einen Satz; perror gibt deine Meldung plus diesen Satz in einem Aufruf aus. Beide brauchen <errno.h> beziehungsweise <string.h>.

Auch fclose kann fehlschlagen - es leert gepufferte Daten, und der Schreibzugriff passt womöglich nicht auf die Platte -, prüfe es also bei allem Wichtigen:

if (fclose(fp) != 0) {
    fprintf(stderr, "Leeren und Schließen fehlgeschlagen\n");
}

Der Binärmodus in einem Absatz

Der Textmodus darf Zeilenenden umsetzen (unter Windows wird \n beim Schreiben zu \r\n und beim Lesen zurück) und darf bestimmte Bytes besonders behandeln. Für Daten, die kein Text sind - ein Bild, eine wörtlich abgelegte Struktur, ein komprimierter Klumpen -, öffne mit b und benutze fread/fwrite, die rohe Bytes bewegen:

#include <stdio.h>

struct Record {
    int    id;
    double value;
};

int main(void) {
    struct Record out[2] = {{1, 3.5}, {2, 7.25}};

    FILE *fp = fopen("records.bin", "wb");
    if (fp == NULL) { return 1; }
    fwrite(out, sizeof out[0], 2, fp);
    fclose(fp);

    struct Record in[2];
    fp = fopen("records.bin", "rb");
    if (fp == NULL) { return 1; }
    size_t got = fread(in, sizeof in[0], 2, fp);
    fclose(fp);

    printf("%zu Datensaetze gelesen\n", got);
    for (size_t i = 0; i < got; i++) {
        printf("id=%d value=%.2f\n", in[i].id, in[i].value);
    }
    return 0;
}

fwrite(ptr, size, count, fp) schreibt count Elemente von je size Bytes und liefert, wie viele es geschafft hat; fread spiegelt das. Sei dir bewusst, dass eine so geschriebene Datei an die Maschine gebunden ist, die sie schrieb - Füllbytes der Struktur, Ganzzahlgröße und Byte-Reihenfolge sickern alle in die Bytes -, sie taugt also für einen Zwischenspeicher oder eine Arbeitsdatei und ist falsch für ein Format, das andere Programme lesen müssen.

Häufige Fehler

• fopen nicht auf NULL prüfen. Der folgende Absturz wird dem Lesen angelastet, nicht dem Öffnen.
• Mit "w" öffnen, wenn du "r" meintest. Die Datei ist geleert, bevor du es merkst.
• fclose vergessen. Gepufferte Ausgabe geht verloren, und jede nicht geschlossene Datei leckt ein Handle.
• while (!feof(fp)). Verarbeitet die letzte Zeile zweimal. Prüfe stattdessen den Leseaufruf.
• char c = fgetc(fp). Zerstört den EOF-Vergleich. Nimm int.
• fscanf("%s", buf) ohne Breite. Derselbe Pufferüberlauf wie bei scanf über die Tastatur.
• Relative Pfade. fopen("data.txt", "r") sucht im Arbeitsverzeichnis, nicht neben der ausführbaren Datei. Wenn eine Datei „verschwindet", liegt es meist daran.