C-Programmierung: Dateien

Aus Wikibooks
Zur Navigation springen Zur Suche springen

In diesem Kapitel geht es um das Thema Dateien. Aufgrund der einfachen API stellen wir zunächst die Funktionen rund um Streams vor, mit deren Hilfe Dateien geschrieben und gelesen werden können. Anschließend folgt eine kurze Beschreibung der Funktionen rund um Dateideskriptoren.

Streams[Bearbeiten]

Die Funktion fopen dient dazu, einen Datenstrom (Stream) zu öffnen. Datenströme sind Verallgemeinerungen von Dateien. Die Syntax dieser Funktion lautet:

 FILE *fopen (const char *Pfad, const char *Modus);

Der Pfad ist der Dateiname, der Modus darf wie folgt gesetzt werden:

  • r - Datei nur zum Lesen öffnen (READ)
  • w - Datei nur zum Schreiben öffnen (WRITE), löscht den Inhalt der Datei, wenn sie bereits existiert
  • a - Daten an das Ende der Datei anhängen (APPEND), die Datei wird nötigenfalls angelegt
  • r+ - Datei zum Lesen und Schreiben öffnen, die Datei muss bereits existieren
  • w+ - Datei zum Lesen und Schreiben öffnen, die Datei wird nötigenfalls angelegt
  • a+ - Datei zum Lesen und Schreiben öffnen, um Daten an das Ende der Datei anzuhängen, die Datei wird nötigenfalls angelegt

Es gibt noch einen weiteren Modus():

  • b - Binärmodus (anzuhängen an die obigen Modi, z.B. "rb" oder "w+b").

Ohne die Angabe von b werden die Daten im sog. Textmodus gelesen und geschrieben, was dazu führt, dass unter bestimmten Systemen bestimmte Zeichen bzw. Zeichenfolgen interpretiert werden. Unter Windows z.B. wird die Zeichenfolge "\r\n" als Zeilenumbruch übersetzt. Um dieses zu verhindern, muss die Datei im Binärmodus geöffnet werden. Unter Systemen, die keinen Unterschied zwischen Text- und Binärmodus machen (wie zum Beispiel bei Unix, GNU/Linux), hat das b keine Auswirkungen.

Die Funktion fopen gibt NULL zurück, wenn der Datenstrom nicht geöffnet werden konnte, ansonsten einen Zeiger vom Typ FILE auf den Datenstrom.


Die Funktion fclose dient dazu, die mit der Funktion fopen geöffneten Datenströme wieder zu schließen. Die Syntax dieser Funktion lautet:

int fclose (FILE *datei);

Alle nicht geschriebenen Daten des Stromes *datei werden gespeichert, alle ungelesenen Eingabepuffer geleert, der automatisch zugewiesene Puffer wird befreit und der Datenstrom *datei geschlossen. Der Rückgabewert der Funktion ist EOF, falls Fehler aufgetreten sind, ansonsten ist er 0 (Null).

Dateien zum Schreiben öffnen[Bearbeiten]

 1 #include <stdio.h>
 2 int main (void)
 3 {
 4   FILE *datei;
 5   datei = fopen ("testdatei.txt", "w");
 6   if (datei == NULL)
 7   {
 8     printf("Fehler beim oeffnen der Datei.");
 9     return 1;
10   }
11   fprintf (datei, "Hallo, Welt\n");
12   fclose (datei);
13   return 0;
14 }

Der Inhalt der Datei testdatei.txt ist nun:

Hallo, Welt

Die Funktion fprintf funktioniert genauso, wie die schon bekannte Funktion printf. Lediglich das erste Argument muss ein Zeiger auf den Dateistrom sein.

Dateien zum Lesen öffnen[Bearbeiten]

Nachdem wir nun etwas in eine Datei hineingeschrieben haben, versuchen wir in unserem zweiten Programm dieses einmal wieder herauszulesen:

 1 #include <stdio.h>
 2 
 3 int main()
 4 {
 5   FILE *datei;
 6   char text[100+1];
 7 
 8   datei = fopen("testdatei.txt", "r");
 9   if (datei != NULL) {
10     fscanf(datei, "%s", text);  // %c: einzelnes Zeichen %s: Zeichenkette
11     // String muss mit Nullbyte abgeschlossen sein
12     text[100] = '\0';
13     printf("%s\n", text);
14     fclose(datei);
15   }
16   return 0;
17 }

Die Ausgabe des Programmes ist wie erwartet

Hallo, Welt

fscanf ist das Pendant zu scanf.

Positionen innerhalb von Dateien[Bearbeiten]

Stellen wir uns einmal eine Datei vor, die viele Datensätze eines bestimmten Types beinhaltet, z.B. eine Adressdatei. Wollen wir nun die 4. Adresse ausgeben, so ist es praktisch, an den Ort der 4. Adresse innerhalb der Datei zu springen und diesen auszulesen. Um das folgende Beispiel nicht zu lang werden zu lassen, beschränken wir uns auf Name und Postleitzahl.

 1 #include <stdio.h>
 2 #include <string.h>
 3 
 4 /* Die Adressen-Datenstruktur */
 5 typedef struct _adresse
 6 {
 7   char name[100];
 8   int plz; /* Postleitzahl */
 9 } adresse;
10 
11 /* Erzeuge ein Adressen-Record */
12 void mache_adresse (adresse *a, const char *name, const int plz)
13 {
14   sprintf(a->name, "%.99s", name);
15   a->plz = plz;
16 }
17 
18 int main (void)
19 {
20   FILE *datei;
21   adresse addr;
22  
23   /* Datei erzeugen im Binärmodus, ansonsten kann es Probleme 
24      unter Windows geben, siehe Anmerkungen bei '''fopen()''' */
25   datei = fopen ("testdatei.dat", "wb");
26   if (datei != NULL)
27     {
28       mache_adresse (&addr, "Erika Mustermann", 12345);
29       fwrite (&addr, sizeof (adresse), 1, datei);
30       mache_adresse (&addr, "Hans Müller", 54321);
31       fwrite (&addr, sizeof (adresse), 1, datei);
32       mache_adresse (&addr, "Secret Services", 700);
33       fwrite (&addr, sizeof (adresse), 1, datei);
34       mache_adresse (&addr, "Peter Mustermann", 12345);
35       fwrite (&addr, sizeof (adresse), 1, datei);
36       mache_adresse (&addr, "Wikibook Nutzer", 99999);
37       fwrite (&addr, sizeof (adresse), 1, datei);
38       fclose (datei);
39     }
40 
41   /* Datei zum Lesen öffnen - Binärmodus */
42   datei = fopen ("testdatei.dat", "rb");
43   if (datei != NULL)
44     {
45       /* Hole den 4. Datensatz */
46       fseek(datei, 3 * sizeof (adresse), SEEK_SET);
47       fread (&addr, sizeof (adresse), 1, datei);
48       printf ("Name: %s (%d)\n", addr.name, addr.plz);
49       fclose (datei);
50     }
51   return 0;
52 }

Um einen Datensatz zu speichern bzw. zu lesen, bedienen wir uns der Funktionen fwrite und fread, welche die folgende Syntax haben:

size_t fread  (void *daten, size_t groesse, size_t anzahl, FILE *datei);
size_t fwrite (const void *daten, size_t groesse, size_t anzahl, FILE *datei);

Beide Funktionen geben die Anzahl der geschriebenen / gelesenen Zeichen zurück. Die groesse ist jeweils die Größe eines einzelnen Datensatzes. Es können anzahl Datensätze auf einmal geschrieben werden. Beachten Sie, dass sich der Zeiger auf den Dateistrom bei beiden Funktionen am Ende der Argumentenliste befindet.

Um nun an den 4. Datensatz zu gelangen, benutzen wir die Funktion fseek:

int fseek (FILE *datei, long offset, int von_wo);

Diese Funktion gibt 0 zurück, wenn es zu keinem Fehler kommt. Der Offset ist der Ort, dessen Position angefahren werden soll. Diese Position kann mit dem Parameter von_wo beeinflusst werden:

  • SEEK_SET - Positioniere relativ zum Dateianfang,
  • SEEK_CUR - Positioniere relativ zur aktuellen Dateiposition und
  • SEEK_END - Positioniere relativ zum Dateiende.

Man sollte jedoch beachten: wenn man mit dieser Funktion eine Position in einem Textstrom anfahren will, so muss man als Offset 0 oder einen Rückgabewert der Funktion ftell angeben (in diesem Fall muss der Wert von von_wo SEEK_SET sein).

Besondere Streams[Bearbeiten]

Neben den Streams, die Sie selbst erzeugen können, gibt es schon vordefinierte:

  • stdin - Die Standardeingabe (typischerweise die Tastatur)
  • stdout - Standardausgabe (typischerweise der Bildschirm)
  • stderr - Standardfehlerkanal (typischerweise ebenfalls Bildschirm)

Diese Streams brauchen nicht geöffnet oder geschlossen zu werden. Sie sind "einfach schon da".

...
fprintf (stderr, "Fehler: Etwas schlimmes ist passiert\n");
...

Wir hätten also auch unsere obigen Beispiele statt mit printf mit fprintf schreiben können.

Echte Dateien[Bearbeiten]

Mit "echten Dateien" bezeichnen wir die API rund um Dateideskriptoren. Hier passiert ein physischer Zugriff auf Geräte. Diese API eignet sich auch dazu, Informationen über angeschlossene Netzwerke zu übermitteln.

Dateiausdruck[Bearbeiten]

Das folgende Beispiel erzeugt eine Datei und gibt anschließend den Dateiinhalt oktal, dezimal, hexadezimal und als Zeichen wieder aus. Es soll Ihnen einen Überblick verschaffen über die typischen Dateioperationen: öffnen, lesen, schreiben und schließen.

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <fcntl.h>
 6 #include <unistd.h>
 7 #include <string.h>
 8  
 9 int main (void)
10 {
11   int fd;
12   char ret;
13   const char *s = "Test-Text 0123\n"; 
14 
15   /* Zum Schreiben öffnen */
16   fd = open ("testfile.txt", O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
17   if (fd == -1)
18     exit (-1);
19   write (fd, s, strlen (s));
20   close (fd); 
21 
22   /* Zum Lesen öffnen */
23   fd = open ("testfile.txt", O_RDONLY);
24   if (fd == -1)
25      exit (-1);
26  
27   printf ("Oktal\tDezimal\tHexadezimal\tZeichen\n");
28   while (read (fd, &ret, sizeof (char)) > 0)
29     printf ("%o\t%u\t%x\t\t%c\n", ret, ret, ret, ret);
30   close (fd);
31 
32  return 0;
33 }

Die Ausgabe des Programms ist wie folgt:

Oktal   Dezimal Hexadezimal     Zeichen
124     84      54                    T
145     101     65                    e
163     115     73                    s
164     116     74                    t
55      45      2d                    -
124     84      54                    T
145     101     65                    e
170     120     78                    x
164     116     74                    t
40      32      20
60      48      30                    0
61      49      31                    1
62      50      32                    2
63      51      33                    3
12      10      a

Mit open erzeugen (O_CREAT) wir zuerst eine Datei zum Schreiben (O_WRONLY). Wenn diese Datei schon existiert, so soll sie geleert werden (O_TRUNC). Derjenige Benutzer, der diese Datei anlegt, soll sie lesen (S_IRUSR) und beschreiben (S_IWUSR) dürfen. Der Rückgabewert dieser Funktion ist der Dateideskriptor, eine positive ganze Zahl, wenn das Öffnen erfolgreich war. Sonst ist der Rückgabewert -1.

In diese so erzeugte Datei können wir schreiben:

ssize_t write (int dateideskriptor, const void *buffer, size_t groesse);

Diese Funktion gibt die Anzahl der geschriebenen Zeichen zurück. Sie erwartet den Dateideskriptor, einen Zeiger auf einen zu schreibenden Speicherbereich und die Anzahl der zu schreibenden Zeichen.

Der zweite Aufruf von open öffnet die Datei zum Lesen (O_RDONLY). Bitte beachten Sie, dass der dritte Parameter der open-Funktion hier weggelassen werden darf.

Die Funktion read erledigt für uns das Lesen:

ssize_t read (int dateideskriptor, void *buffer, size_t groesse);

Die Parameter sind dieselben wie bei der Funktion write. read gibt die Anzahl der gelesenen Zeichen zurück.

Streams und Dateien[Bearbeiten]

In einigen Fällen kommt es vor, dass man - was im allgemeinen keine gute Idee ist - die API der Dateideskriptoren mit der von Streams mischen muss. Hierzu dient die Funktion:

FILE *fdopen (int dateideskriptor, const char * Modus);

fdopen öffnet eine Datei als Stream, sofern ihr Dateideskriptor vorliegt und der Modus zu den bei open angegebenen Modi kompatibel ist.


<< Präprozessor | Inhaltsverzeichnis | Rekursion >>