Datei-I/O in C meistern: Erstellen, Öffnen & Verwalten von Dateien

Das vorherige Kapitel erklärte Standard-Ein-/Ausgabe. Dieses Kapitel behandelt, wie C-Programmierer Text- oder Binärdateien erstellen, öffnen, schließen und für Datenspeicherung verwalten.

Eine Datei repräsentiert eine Folge von Bytes, unabhängig davon, ob es sich um eine Text- oder Binärdatei handelt. C bietet High-Level-Funktionen sowie Low-Level-Systemaufrufe (OS-Level) für Dateizugriff.

Dateien öffnen

Verwenden Sie fopen(), um eine neue Datei zu erstellen oder eine bestehende zu öffnen. Der Aufruf initialisiert ein Objekt vom Typ FILE, das alle Informationen zur Steuerung des Streams enthält. Prototyp:

FILE *fopen(const char *filename, const char *mode);

filename ist ein String-Literal für den Dateinamen. mode kann folgende Werte haben:

Nr.	Modus & Beschreibung
1	r – Öffnet existierende Textdatei zum Lesen.
2	w – Öffnet Textdatei zum Schreiben. Erstellt neue, falls nicht existent. Schreibt ab Dateianfang (trunciert).
3	a – Öffnet Textdatei zum Anhängen. Erstellt neue, falls nicht existent. Schreibt am Ende der Datei.
4	r+ – Öffnet Textdatei zum Lesen und Schreiben.
5	w+ – Öffnet zum Lesen/Schreiben. Trunciert existierende Datei oder erstellt neue.
6	a+ – Öffnet zum Lesen/Schreiben. Erstellt falls nicht existent. Lesen ab Anfang, Schreiben nur am Ende (Append).

Für Binärdateien verwenden Sie folgende Modi (mit b):

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

Datei schließen

Zum Schließen verwenden Sie fclose():

int fclose(FILE *fp);

Gibt 0 bei Erfolg zurück, EOF bei Fehler. Flushed Pufferdaten in die Datei, schließt sie und gibt Speicher frei. EOF ist in stdio.h definiert.

In Datei schreiben

Einzelnes Zeichen schreiben:

int fputc(int c, FILE *fp);

Gibt geschriebenes Zeichen zurück oder EOF bei Fehler.

Null-terminierten String schreiben:

int fputs(const char *s, FILE *fp);

Gibt nicht-negativen Wert bei Erfolg, EOF bei Fehler.

Formatiert schreiben (wie printf):

int fprintf(FILE *fp, const char *format, ...);

Beispiel: Datei schreiben

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("/tmp/test.txt", "w+");
    if (fp == NULL) {
        perror("Fehler beim Öffnen");
        return 1;
    }
    fprintf(fp, "Test für fprintf...\n");
    fputs("Test für fputs...\n", fp);
    fclose(fp);
    return 0;
}

Erstellt /tmp/test.txt mit zwei Zeilen.

Datei lesen

Einzelnes Zeichen lesen:

int fgetc(FILE *fp);

Gibt gelesenes Zeichen zurück oder EOF bei Fehler/Ende.

String (Zeile) lesen:

char *fgets(char *buf, int n, FILE *fp);

Liest bis zu n-1 Zeichen, kopiert in buf, hängt '\0' an. Bei Newline oder EOF vorher stoppt es inklusive Newline.

Formatiert lesen (wie scanf):

int fscanf(FILE *fp, const char *format, ...);

Stoppt bei erstem Whitespace.

Beispiel: Datei lesen

#include <stdio.h>

int main() {
    FILE *fp;
    char buff[255];
    
    fp = fopen("/tmp/test.txt", "r");
    if (fp == NULL) {
        perror("Fehler beim Öffnen");
        return 1;
    }
    
    fscanf(fp, "%s", buff);
    printf("1 (fscanf): %s\n", buff); // liest nur "Test"
    
    fgets(buff, 255, fp);
    printf("2 (fgets): %s", buff);    // Rest der Zeile
    
    fgets(buff, 255, fp);
    printf("3 (fgets): %s", buff);    // Zweite Zeile
    
    fclose(fp);
    return 0;
}

Ausgabe:

1 (fscanf): Test
2 (fgets): für fprintf...
3 (fgets): Test für fputs...

Erklärung: fscanf() liest nur „Test“ (stoppt bei Leerzeichen). Erster fgets() liest Rest der Zeile. Zweiter fgets() liest komplette zweite Zeile.

Binäre I/O-Funktionen

Für binäre Ein-/Ausgabe (Blöcke, Arrays, Strukturen):

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

Beide Funktionen lesen/schreiben Speicherblöcke – meist Arrays oder Strukturen.

Beispiel: Struktur in Binärdatei schreiben/lesen

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

struct Student {
    char name[50];
    int age;
    float gpa;
};

int main() {
    struct Student s1 = {"Anna", 20, 3.5};
    struct Student s2;
    FILE *fp;

    // Schreiben
    fp = fopen("student.dat", "wb");
    fwrite(&s1, sizeof(struct Student), 1, fp);
    fclose(fp);

    // Lesen
    fp = fopen("student.dat", "rb");
    fread(&s2, sizeof(struct Student), 1, fp);
    fclose(fp);

    printf("Name: %s, Alter: %d, GPA: %.1f\n", s2.name, s2.age, s2.gpa);
    return 0;
}

Zufälliger Dateizugriff

Mit fseek(), ftell(), rewind() können Sie in Dateien navigieren:

• fseek(fp, offset, whence) – Setzt Dateipositionszeiger. whence: SEEK_SET (Anfang), SEEK_CUR (aktuell), SEEK_END (Ende).
• ftell(fp) – Gibt aktuelle Position zurück.
• rewind(fp) – Setzt Position auf Anfang (wie fseek(fp, 0, SEEK_SET)).

Fehlerbehandlung

Prüfen Sie immer Rückgabewerte von Dateifunktionen. Nutzen Sie perror() oder strerror(errno) für Fehlermeldungen. ferror(fp) prüft Fehler-Flag, feof(fp) prüft EOF-Flag.