C Datei-E/A meistern: Dateien erstellen, öffnen, lesen, schreiben und schließen

C Dateiverwaltung – Überblick

In C bietet die Standardbibliothek stdio.h eine umfassende Suite von Funktionen für die Arbeit mit persistenten Daten auf Datenträger. Durch das Beherrschen dieser Tools können Sie zuverlässig Dateien erstellen, lesen, schreiben und schließen, während Sie Datenintegrität und Programmstabilität gewährleisten.

Wichtige Datei-Handling-Funktionen

Funktion	Zweck
fopen()	Bestehende Datei öffnen oder neue erstellen.
fclose()	Offene Datei schließen und Ressourcen freigeben.
fprintf()	Formatierten Text in Datei schreiben.
fscanf()	Formatierte Daten aus Datei lesen.
getc()	Einzelnes Zeichen aus Datei lesen.
putc()	Einzelnes Zeichen in Datei schreiben.
fgets()	Gesamte Zeile in Puffer lesen.
fputs()	String in Datei schreiben ohne Formatierung.
fseek()	Dateizeiger an angegebene Position bewegen.
ftell()	Aktuelle Dateizeiger-Position abrufen.
rewind()	Dateizeiger auf Anfang zurücksetzen.

Dateimodi erklärt

Modus	Beschreibung
"r"	Zum Lesen öffnen; schlägt fehl, wenn Datei nicht existiert.
"w"	Zum Schreiben öffnen; existierende Datei kürzen oder neue erstellen.
"a"	Zum Anhängen öffnen; Schreibzugriffe werden ans Dateiende angefügt.
"r+"	Zum Lesen und Schreiben vom Anfang öffnen.
"w+"	Zum Lesen und Schreiben öffnen; existierende Datei kürzen.
"a+"	Zum Lesen und Schreiben öffnen; neue Daten anhängen.

Datei erstellen

Um eine Datei zu erstellen oder zu öffnen, deklarieren Sie zuerst einen Dateizeiger und rufen dann fopen() mit gewünschtem Dateinamen und Modus auf:

FILE *fp;
fp = fopen("data.txt", "w");

Falls die Datei nicht existiert, erstellt fopen() sie. Falls sie existiert, bestimmt der Modus, ob Inhalt beibehalten oder überschrieben wird.

Sie können auch einen absoluten Pfad angeben:

fp = fopen("D:/data.txt", "w");

Bilder zur Veranschaulichung der Dateierstellung:

Datei schließen

Nach Abschluss aller Dateioperationen rufen Sie immer fclose() auf, um den Dateideskriptor freizugeben und Puffer zu leeren:

fp = fopen("data.txt", "r");
...
fclose(fp);

Die Funktion gibt 0 bei Erfolg und EOF bei Fehler zurück. Obwohl das Betriebssystem Dateien beim Programmende automatisch schließt, gilt explizites Schließen als Best Practice.

In Datei schreiben

Beim Schreiben denken Sie daran, Newline-Zeichen (\n) explizit hinzuzufügen, wo Zeilenumbrüche gewünscht sind. Häufigste Schreibfunktionen:

• fputc(char, FILE*) – Einzelnes Zeichen schreiben.
• fputs(const char*, FILE*) – Null-terminierten String schreiben.
• fprintf(FILE*, const char*, …) – Formatierte Ausgabe schreiben.

Beispiel: fputc()

#include <stdio.h>
int main() {
    int i;
    FILE *fptr;
    const char *str = "Guru99 Rocks\n";
    fptr = fopen("fputc_test.txt", "w");
    for (i = 0; str[i] != '\n'; i++) {
        fputc(str[i], fptr);
    }
    fclose(fptr);
    return 0;
}

Ausgabedatei fputc_test.txt enthält den Text:

Beispiel: fputs()

#include <stdio.h>
int main() {
    FILE *fp = fopen("fputs_test.txt", "w+");
    fputs("This is Guru99 Tutorial on fputs,", fp);
    fputs("We don't need to use for loop\n", fp);
    fputs("Easier than fputc function\n", fp);
    fclose(fp);
    return 0;
}

Ergebnisdatei fputs_test.txt:

Beispiel: fprintf()

#include <stdio.h>
int main() {
    FILE *fptr = fopen("fprintf_test.txt", "w");
    fprintf(fptr, "Learning C with Guru99\n");
    fclose(fptr);
    return 0;
}

Ergebnisdatei fprintf_test.txt:

Aus Datei lesen

Drei primäre Funktionen lesen Daten:

• fgetc(FILE*) – Nächstes Zeichen zurückgeben.
• fgets(char*, int, FILE*) – Bis zu n-1 Zeichen in Puffer lesen.
• fscanf(FILE*, const char*, …) – Formatierte Eingabe parsen.

Unten eine vollständige Demonstration, die fprintf_test.txt mit allen drei Methoden liest:

#include <stdio.h>
int main() {
    FILE *fp;
    char buffer[50], c;
    fp = fopen("fprintf_test.txt", "r");
    printf("----read a line----\n");
    fgets(buffer, 50, fp);
    printf("%s\n", buffer);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----read and parse data----\n");
    char str1[10], str2[2], str3[20], str4[2];
    fscanf(fp, "%s %s %s %s", str1, str2, str3, str4);
    printf("Read String1 |%s|\n", str1);
    printf("Read String2 |%s|\n", str2);
    printf("Read String3 |%s|\n", str3);
    printf("Read String4 |%s|\n", str4);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----read the entire file----\n");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Programmausgabe:

----read a line----
Learning C with Guru99
----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

Interaktives Zeichen-für-Zeichen I/O mit getc und putc

Dieses minimale Beispiel demonstriert Benutzereingabe lesen, in Datei schreiben und zurücklesen:

#include <stdio.h>
int main() {
    FILE *fp;
    int c;
    printf("File Handling\n");
    fp = fopen("demo.txt", "w");
    while ((c = getchar()) != EOF) {
        putc(c, fp);
    }
    fclose(fp);
    printf("Data Entered:\n");
    fp = fopen("demo.txt", "r");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Beispiel-Ausführung:

Fazit

• Eine Datei ist persistenter Speicherplatz auf Datenträger.
• C-Standardbibliothek bietet fopen, fclose, fprintf, fscanf und verwandte Funktionen für zuverlässige Dateimanipulation.
• Datei immer im korrekten Modus öffnen, um Lesen, Schreiben oder Anhängen zu steuern.
• Dateien explizit schließen, um Puffer zu leeren und Systemressourcen freizugeben.
• Verwenden Sie fgetc und putc für einfache Zeichenströme, fgets / fscanf für zeilenbasierte oder formatierte Eingabe.
• Beim Schreiben Strings mit \n terminieren, wenn Zeilenumbrüche gewünscht sind.
• Richtige Fehlerbehandlung (NULL-Pointer und Rückgabewerte prüfen) ist essenziell für robuste Anwendungen.