Ein- und Ausgabe in Dateien

C-Programme beziehen ihre Daten aus unterschiedliche Datenströmen, z.B. von der Konsole, aus Dateien, oder aus Zeichenketten. Ein Datenstrom (stream) ist für ein Programm Quelle oder Ziel von Daten und besteht aus einer eine Folge von Zeilen; jede Zeile enthält null oder mehr Zeichen und ist mit '\n' abgeschlossen. Das Lesen und Schreiben von Daten in Datenströme geschieht mittels des Dateizeigers FILE *fp und verschiedener Funktionen der C-Standardbibliothek stdio.h:
fopen, fclose – Datei öffnen und schließen
fgets – Daten zeilenweise aus einem Stream (Konsole oder Datei) lesen,
fgetc, fputc – Daten zeichenweise aus einem Stream (Konsole oder Datei) lesen /schreiben,
fread, fwrite – Daten blockweise aus einem Stream (Konsole oder Datei) lesen / schreiben,
fprintf, fscanf – tabellenartig formatierte Daten in Datei schreiben bzw. aus Datei lesen,
fseek, feof, ferror - diverse Hilfsfunktionen zum Positionieren des Dateizeigers, für Fehler etc.

Es hängt von der Art der Daten ab, welche Funktionen zu verwenden sind. Bei strukturierten tabellenartigen Daten verwendet man die formatierte Eingabe mit scanf / fscanf / sscanf, um Texte zeilenweise einzulesen, fgets, um Daten blockweise einzulesen, fread. Um Texte zeichenweise einzulesen, verwendet man getchar / fgetc / fputc.

1 Datei öffnen / schließen

Der Zugriff auf eine Datei geschieht mit Hilfe des Zeigers FILE *fp und der Funktionen fopen (Datei öffnen) und fclose (Datei schließen). Die Funktion fopen öffnet eine Datei und erhält als Parameter den Dateizeiger fp, den Dateinamen und einen Zugriffsmodus ("r" – read, "a" – append, "w" – write). Die Funktion fclose() schließt eine geöffnete Datei. Es ist wichtig, eine geöffnete Datei auch wieder zu schließen, da ansonsten ggf. andere Programme nicht darauf zugreifen können.

#include <stdio.h>
int main(void) {
    char* filename = "daten.txt";
    FILE* fp = NULL; // (1)
    fopen_s(&fp, filename, "w"); // (2)
    if (fp == NULL) { // (3)
        printf("Fehler!\n");
        exit(1);
    }
    printf("Datei wurde geoeffnet!\n"); // Schreibe auf Konsole
    fprintf(fp, "Hallo zusammen!");   // Schreibe in Datei
    fprintf(fp, "Geht doch!");   // Schreibe in Datei
    fclose(fp); // (4)
}

2 Datei zeilenweise lesen

Textdateien mit Fließtext-Inhalt enthalten unstrukturierte Daten mit Zeilen, die unterschiedlich lang und unterschiedlich aufgebaut sind. In diesem Fall wird der Text zeilenweise mit fgets ausgelesen. Die Funktion char* fgets ( char * str, int num, FILE * stream ) liest num Zeichen aus dem Datenstrom stream in eine Zeichenkatte str. Bei Erfolg gibt fgets als Rückgabewert die Zeichenkette str zurück, die den eingelesenen Text enthält. Wenn beim Versuch, ein Zeichen zu lesen, das Dateiende erreicht wird, wird der EOF-Indikator gesetzt (feof). Wenn ein Lesefehler auftritt, wird der Fehlerindikator (ferror) gesetzt und ein Nullzeiger zurückgegeben.

Beispiel: Textdatei zeilenweise einlesen

In diesem Beispiel wird eine Textdatei myfile.txt mit unterschiedlich langen Zeilen zeilenweise in eine string-Variable zeile eingelesen, die Zeile selber und die Länge der Zeile werden ausgegeben, und es wird die Anzahl der Zeilen der Datei bestimmt.

Quellcode: Datei zeilenweise lesen

Verwendete Funktionen: fopen, fclose, fgets

#include <stdio.h>
#include <stdlib.h>
#define N 256 // Max. Anzahl der Bytes für eine Zeile
int main(void) {
    FILE* fp = NULL;
    fopen_s(&fp, "myfile.txt", "r");
    if (fp == NULL) {
        printf("Fehler!\n"); exit(1);
    }
    char zeile[N] = "";
    // Lese die Datei Zeile für Zeile aus
    int anzZeilen = 0;
    while (fgets(zeile, N, fp) != NULL){       
        zeile[strlen(zeile) - 1] = '\0';       
        printf("%d: %-30s ", anzZeilen, zeile); 
        printf("%d Zeichen\n", strlen(zeile));
        anzZeilen++;
    }
    printf("\nDer Text hat %d Zeilen.\n", anzZeilen);
    fclose(fp);
}

Erläuterung: Datei zeilenweise lesen

Test-Datei: myfile.txt

Die Datei myfile.txt enthält folgenden Text:

Hallo
zusammen!
Dies ist die dritte Zeile.

Bei Ausführung des Programms wird in der Konsole folgende Ausgabe angezeigt.

Implementierung
Zeile 5 - 9: Die Text-Datei wird zunächst im Lesemodus geöffnet.
Zeile 10: Die String-Variable zeile wird deklariert, sie wird die einzelnen Zeilen des Textes enthalten. Die maximale Länge einer Zeile beträgt 256 Zeichen / Bytes.
Zeile 11-18: Lese die Textdatei Zeile für Zeile aus. Der Funktionsaufruf fgets(zeile, N, fp) liest max. N Zeichen in das Array zeile. Falls fgets den NULL-Zeiger zurückgibt, bedeutet dies, dass das Ende der Datei erreicht wurde oder ein Fehler passiert ist und die Schleife wird abgebrochen.

3 Strukturierte Daten lesen / schreiben

Als strukturierte oder formatierte Daten bezeichnet man tabellenartig aufgebaute Datensätze, wie sie in Excel oder Datenbanken gespeichert werden. Jede Zeile hat dieselbe Anzahl an Spalten, alle Werte einer Spalte haben denselben Datentyp. Für den Datenaustausch strukturierter Daten zwischen verschiedenen Anwendungen gibt es unterschiedliche Dateiformate: CSV, XML, JSON. Ein in der Industrie häufig verwendetes Dateiformat für den Datenaustausch zwischen Programmen und Datenbanken sind CSV-Dateien (Comma Separated Values). Das Dateiformat CSV beschreibt den Aufbau einer Textdatei, mit der strukturierte Daten gespeichert werden können. CSV-Dateien haben die Endung *.csv und werden von Excel automatisch als Tabellen angezeigt. Als Trennzeichen wird meist das Semikolon verwendet.

In C werden strukturierte Daten wie CSV-Dateien mittels fprintf und fscanf geschrieben bzw. gelesen.

Beispiel: CSV-Datei einlesen

In diesem Beispiel wird eine CSV-Datei messwerte.csv mit drei Spalten formatiert eingelesen. Jede Spalte wird in ein eigenes Array gespeichert, das dem Datentyp der Spalte entspricht.

Quellcode: Datei formatiert lesen

Verwendete Funktionen: fopen, fclose, fgets, fseek, fscanf, feop

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M 100 // Max. Anzahl Zeilen
#define N 256 // Max. Anzahl der Bytes für eine Zeile
int main(void) {
  double sp1[M], sp2[M]; char sp3[M]; char zeile[N];
  char* filename = "messwerte.csv";FILE* fp = NULL;
  fopen_s(&fp, filename, "r");
  if (fp == NULL) {
    printf("Fehler!\n"); exit(1);
  }
  int anzZeilen = 0;
  // (1) Bestimme Anzahl der Zeilen in der Datei
  while (fgets(zeile, N, fp))
		anzZeilen++;
  printf("Die Datei hat %d Zeilen\n", anzZeilen);
  // (2) Setze den Datei-Zeiger wieder auf Dateianfang
  int result = fseek(fp, 0L, SEEK_SET);
  int zIdx = 0; // Zeilen-Zähler
  // (3) Lese die Zeilen aus
  while (!feof(fp)) {
    fscanf_s(fp, "%lf;%lf;", &sp1[zIdx], &sp2[zIdx]);
    fscanf_s(fp, "%[^\n]", sp3, 20);
    printf("Zeile %d: %.2lf %.2lf %s\n",
      zIdx + 1, sp1[zIdx], sp2[zIdx], sp3);
    zIdx++;
  }
}

Erläuterung: Datei formatiert lesen

Test-Datei messwerte.csv

Die CSV-Datei messwerte.csv enthält Messwert-Daten, die in drei Spalten aufgebaut sind: Die erste Spalte stellt eine Feuchtigkeitsmessung dar, die zweite Spalte eine Temperaturmessung, die dritte Spalte eine Bewertung: Luftfeuchtigkeit 80% und Temperatur 23 Grad wird als "feucht" bewertet.

42;21;perfekt
45;19;perfekt
69;23;zu feucht
80;21;zu feucht
21;13;zu trocken
29;14;zu trocken

Konsolenausgabe bei Ausführung des Programms

Implementierung
Zeile 9 - 12: Die Text-Datei wird zunächst im Lesemodus geöffnet.
Zeile 13 - 17: Bestimme die Anzahl der Zeilen, die die Datei enthält.
Zeile 18 - 19: Setze mittels fseek-Funktion den Datei-Zeiger wieder auf Dateianfang.
Zeile 20 - 28: Lese die einzelnen Zeilen formatiert mittels fscanf aus.

Beim Einlesen formatierter Daten mit Hilfe der Funktionen fscanf bzw. fscanf_s sind einige Vorgaben zu beachten, das es ansonsten zu Fehlern kommt.
  Passenden Datenspeicher bereitstellen
Die Arrays, die die Spalten aufnehmen sollen, müssen in Datentyp und Speichergröße mit den Spalten den Datei abgestimmt werden. Falls die Datei n Spalten hat, und es nicht zu viele sind, kann man für jede Spalte ein Array deklarieren. Falls die Spalten alle denselben Datentyp haben, kann auch ein einziges 2D-Array als Datenspeicher verwendet werden. Bei größeren Dateien bietet es sich an, dynamische Speicherallokation zu verwenden. Dafür bestimmt man zunächst die Anzahl der Zeilen der Datei, und allokiert danach Speicher mit malloc oder calloc.
 Formatzeichen mit Formatierung der Datei abstimmen
Die Angabe der formatierenden Zeichenkette muss genau zu der Formatierung der CSV-Datei passen, Falls jede Zeile der Datei das Format 10.2;10;Text\n aufweist, ist die korrekte formatierende Zeichenkette für das Auslesen der Zahlen-Spalten"%lf;%lf;". Die letzte Spalte, die nur Zeichen enthält, wird mit fscanf_s(fp, "%[^\n]", sp3, 20); ausgelesen: "%[^\n]" bedeutet, lese alle Zeichen bis zum Zeilenumbruch, die 20 bedeutet, dass maximal 20 Zeichen gelesen werden.

Tools, Quellen und weiterführende Links