Programmiersprache C/C++

Dateiarbeit

  #include <stdio.h>

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

Der Parameter mode kann einen der folgenden Werte annehmen:

Wert	Beschreibung
--------------------------------------------------------------------------
r	Öffnung ausschließlich für Leseoperationen.
w	Erzeugung einer Datei für Schreiboperationen. Falls die Datei
        bereits existiert, wird sie überschrieben.
a	Öffnung für Schreiboperationen. Falls die Datei bereits 
        existiert, werden zusätzliche Informationen an das aktuelle 
        Dateiende angefügt, ansonsten wird sie automatisch erzeugt.
r+	öffnung einer Datei für Lese- und Schreiboperationen.
        Die Datei muß bereitsexistieren.
w+	Erzeugung einer neuen Datei für Lese- und Schreiboperationen.
        Falls die Datei bereits existiert, wird sie überschrieben.
a+	Öffnung einer Datei zum Lesen und Anhängen neuer Daten durch
        Schreiboperationen. Falls die Datei bereits existiert, bleibt
        ihr alter Inhalt erhalten - falls nicht, wird sie automatisch
        erzeugt.

• b Binärdatei (binary) (ANSI-C) oder
• t Textdatei (text) (manche C-Systeme)

Mit r+ und w+ erzeugte Dateien können sowohl gelesen als auch beschrieben werden:
Zwischen einem Wechsel von "Schreiben" nach "Lesen" muß allerdings ein Aufruf von fseek oder rewind stattfinden.
Zwischen einem Wechsel von "Lesen" nach "Schreiben" muß ebenfalls fseek oder rewind stattfinden, es sei denn, die Leseoperation hat das Dateiende erreicht.

Rückgabewert:
fopen liefert bei fehlerfreier Ausführung einen Zeiger auf den neu geöffneten Stream, im Falle eines Fehlers den Wert NULL zurück.

Hinweise:

• Es kann nur eine begrenzte Anzahl von Streams gleichzeitig geöffnet werden.
  ANSI-C sieht vor, daß dieser Wert über FOPEN_MAX vom Programm erfragt werden kann.
  Es muß gelten: FOPEN_MAX >= 8

     xlc unter AIX auf RS/6000: 2000
     

• Üblicherweise werden 3 vordefinierte Streams automatisch eröffnet:

     stdin       Standardeingabe (standard input)
     stdout      Standardausgabe (standard output)
     stderr      Diagnoseausgabe (standard error)
     

  Bemerkung: Die Deklaration lautet

     FILE *stdin, *stdout, *stderr;
     

  stdin, stdout, stderr sind bei der Ermittlung der Anzahl geöffneter Streams mitzuzählen !
• ANSI-C sieht vor, daß FILENAME_MAX über die (betriebssystemabhängige) maximale Länge des Dateinamens Auskunft gibt.

     xlc unter AIX auf RS/6000:  255
     gcc unter Solaris 2.3    : 1024
     

• Bei der Erstellung portabler Programme sind die unterschiedlichen Namenskonventionen verschiedener Betriebssysteme zu beachten.
  Das DOS-Namensschema 8.3 sollte von allen verbreiteten Betriebssystemen akzeptiert werden.
  Die Angabe von Zugriffspfaden sollte nach Möglichkeit vermieden werden !

  #include <stdio.h>

  int main(void)
  {
    FILE *f;

    f = fopen("binary.dat", "wb");
    fprintf(f, "Hello\nWorld\n");
    fclose(f);

    f = fopen("text.dat", "w");
    fprintf(f, "Hello\nWorld\n");
    fclose(f);

    return 0;
  }

  Hello
       World

  Hello
  World

freopen

  #include <stdio.h>

  int freopen(const char *filename, const char*mode, FILE *stream);

Der Parameterstring mode kann einen der folgenden Werte annehmen:

Wert	Beschreibung
---------------------------------------------------------------------------
r	Öffnung ausschließlich für Leseoperationen.
w	Erzeugung einer Datei für Schreiboperationen.
a	Öffnung für Schreiboperationen. Falls die Datei bereits
        existiert, werden zusätzliche Informationen an das aktuelle
        Dateiende angefügt, ansonsten wird sie automatisch erzeugt.
r+	Öffnung einer Datei für Lese- und Schreiboperationen.
        Die Datei muß bereits existieren.
w+	Erzeugung einer neuen Datei für Lese- und Schreiboperationen.
a+	Öffnung einer Datei zum Lesen und Anhängen neuer Daten durch
        Schreiboperationen. Falls die Datei bereits existiert, bleibt
        ihr alter Inhalt erhalten - falls nicht, wird sie automatisch
        erzeugt.

Rückgabewert:
freopen liefert bei fehlerfreier Ausführung das Argument stream, im Fehlerfall den Wert NULL zurück.

fclose

  #include <stdio.h>

  int fclose(FILE *stream);

Rückgabewert:
fclose liefert bei fehlerfreier Ausführung den Wert 0, im Fehlerfall den Wert EOF zurück.

fflush

  #include <stdio.h>

  int fflush(FILE *stream);

Rückgabewert:
Bei fehlerfreier Ausführung liefert fflush den Wert 0, im Fehlerfall den Wert EOF zurück.

Hinweis:
Wird ein Programm illegal beendet (z.B. Rechnerausfall), so gehen Daten, die vom Programm zwar ausgegeben wurden, sich aber noch im Ausgabepuffer befinden, verloren.
Der Ausgabepuffer ermöglicht ein effektiveres Arbeiten, birgt aber das Risiko eines möglichen Datenverlusts in sich. Nach der Ausgabe sehr wichtiger Daten kann durch einen sofort nachfolgenden Aufruf von fflush dieses Risiko beseitigt werden.

rewind

  #include <stdio.h>

  void rewind(FILE *stream);

Rückgabewert: keiner

fseek

  #include <stdio.h>

  long int fseek(FILE *stream, long int offset, int wherefrom);

  SEEK_SET       Dateianfang
  SEEK_CUR       aktuelle Position des Dateizeigers
  SEEK_END       Dateiende

  #include <stdio.h>

  long filesize(FILE *stream)
  {
    long curpos, length;

    curpos = ftell(stream);
    fseek(stream, 0L, SEEK_END);
    length = ftell(stream);
    fseek(stream, curpos, SEEK_SET);
    return length;
  }

  int main(void)
  {
    FILE *stream;

    stream = fopen("test.txt", "w+");
    fprintf(stream, "Dies ist ein Test");
    printf("Laenge von test.txt : %ld Byte\n", filesize(stream));
    fclose(stream);
    return 0;
  }

ftell

  #include <stdio.h>

  long int ftell(FILE *stream);

Rückgabewert:
ftell liefert bei fehlerfreier Ausführung die aktuelle Position des Dateizeigers zurück. Im Fehlerfall ist der Rückgabewert -1L und die globale Variable errno wird auf einen der beiden folgenden Werte gesetzt:

  EBADF     Ungültiger Dateizeiger
  EINVAL    Suche auf diesem Gerät nicht möglich

  #include <stdio.h>

  int main(void)
  {
    FILE *stream;

    stream = fopen("test.txt", "w+");
    fprintf(stream, "Dies ist ein Test");
    printf("Der Dateizeiger ist auf Byte %ld\n", ftell(stream));
    fclose(stream);

    return 0;
  }

ferror

  #include <stdio.h>

  int ferror(FILE *stream);

Rückgabewert: ferror liefert einen Wert ungleich Null zurück, wenn das Fehler-Flag des angegebenen stream gesetzt ist, sonst den Wert 0.

clearerr

  #include <stdio.h>

  void clearerr(FILE *stream);

Rückgabewert: Keiner

setbuf

  #include <stdio.h>

  void setbuf(FILE *stream, char *buf);

Die Pufferung von Ein- und Ausgaben bedeutet: Ausgaben werden zeichenweise zwischengespeichert und blockweise geschrieben; Eingaben werden blockweise von der Datei bzw. dem Gerät gelesen und danach zeichenweise aus dem Puffer gelesen.
setbuf darf nur direkt nach dem Öffnen (oder direkt nach einem fseek-Aufruf) auf einen Stream angewendet werden, da die Ergebnisse ansonsten unvorhersehbar sind. Die Anwendung dieser Funktion auf ungepufferte Dateien ist dagegen problemlos und jederzeit möglich. Für buf kann eine lokale Variable verwendet werden. Man sollte allerdings in diesem Fall streng darauf achten, die Datei vor dem Ende der entsprechenden Funktion wieder zu schließen.

Rückgabewert: keiner

setvbuf

  #include <stdio.h>

  int setvbuf(FILE *stream, char *buf, int type, size_t size);

Der Parameter type muß den Wert einer der drei folgenden Konstanten enthalten:

  _IOFBF   Die Datei wird vollständig gepuffert. 
           Wenn der Puffer leer ist, versucht der nächste Eingabebefehl, 
           den Puffer komplett mit Daten zu füllen (liest also size Bytes).
           Bei Ausgaben wird zunächst der Puffer gefüllt, erst danach
           wird der komplette Pufferinhalt geschrieben.
  _IOLBF   Ausgaben werden zeilenweise gepuffert: der Pufferinhalt wird
           nach jeder Ausgabe eines Zeilenvorschubs physikalisch
           geschrieben. Eingaben arbeiten dagegen genauso wie bei
           vollständiger Pufferung.
  _IONBF   Die Datei ist ungepuffert. Die Parameter buf und size werden
           ignoriert. Jeder Eingabebefehl liest direkt von der Datei,
           jeder Ausgabebefehl hat eine sofortige Schreibaktion zur Folge.

Rückgabewert:
setvbuf liefert bei fehlerfreier Ausführung den Wert 0. Ungültige Werte für type oder size, fehlender Speicherplatz für malloc oder die Anwendung auf eine nicht geöffnete Datei erzeugen ein Funktionsergebnis ungleich Null.

fprintf

  #include <stdio.h>

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

fscanf

  #include <stdio.h>

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

fwrite

  #include <stdio.h>

  size_t fwrite(void *ptr, size_t element_size, size_t count, FILE *stream);

Rückgabewert:
fwrite liefert die Anzahl der erfolgreich geschriebenen Datensätze zurück, d.h. bei erfolgreicher Ausgabe ist der Rückgabewert identisch mit count.

fread

  #include <stdio.h>

  size_t fread(void *ptr, size_t element_size, size_t count, FILE *stream);

Rückgabewert:
fread liefert die Anzahl der erfolgreich gelesenen Datensätze zurück, d.h. bei erfolgreicher Eingabe ist der Rückgabewert identisch mit count.

Beispiel:

  #include <stdio.h>
  
  #define FILENAME "test.dat"
  
  int main(void)
  {
    FILE *f;
    int i;
    typedef struct {
      char name[20];
      char vorname[20];
      int alter;
      float konto;
    } person;
    person p[3], pp[3];
  
    strcpy(p[0].name, "Meier"); strcpy(p[0].vorname, "Otto");
    p[0].alter = 66; p[0].konto = 4444.44;
    strcpy(p[1].name, "Meier"); strcpy(p[1].vorname, "Ottolie");
    p[1].alter = 66; p[1].konto = 444444.44;
    strcpy(p[2].name, "Krause"); strcpy(p[2].vorname, "Wilhelm");
    p[2].alter = 53; p[2].konto = 5555.55;
  
    if ( ! ( f = fopen(FILENAME, "wb") ) ) {
      fprintf(stderr, "%s kann nicht erstellt werden\n", FILENAME);
      exit(1);
    }
  
    fwrite(p, sizeof(person), 3, f);
  
    if ( ! freopen(FILENAME, "rb", f) ) {
      fprintf(stderr, "%s kann nicht gelesen werden\n", FILENAME);
      exit(2);
    }
  
    fread(pp, sizeof(person), 3, f);
  
    for ( i=0; i<3; i++ ) 
      printf("%-20s %-20s %3d %12.2f\n", pp[i].vorname, pp[i].name, pp[i].alter,
             pp[i].konto);
  
    return 0;
  }

fgetc

  #include <stdio.h>

  int fgetc(FILE *stream);

Rückgabewert:
fgetc liefert den Ordinalwert des eingelesenen Zeichens.
Wurde das Dateiende erreicht, so wird EOF zurückgeliefert.

Hinweis:
Wird aus einer Binärdatei gelesen, so liefert EOF keine sichere Aussage darüber, ob wirklich das Dateiende erreicht wurde. Dies ist nur mit Hilfe der Funktion feof feststellbar.

getc

  #include <stdio.h>

  int getc(FILE *stream);

fputc

  #include <stdio.h>

  int fputc(FILE *stream);

Rückgabewert:
Bei erfolgreicher Ausgabe liefert fputc den Ordinalwert des ausgegebenen Zeichens zurück, im Fehlerfall den Wert EOF.

putc

  #include <stdio.h>

  int putc(FILE *stream);

ungetc

  #include <stdio.h>

  int unget(int ch, FILE *stream);

feof

  #include <stdio.h>

  int feof(FILE *stream);

Rückgabewert:
Der Rückgabewert ist gleich Null, wenn das Dateiende noch nicht erreicht wurde, ansonsten ist er von Null verschieden.

tmpnam

  #include <stdio.h>

  char *tmpnam(char *buf);

Der Aufbau des generierten Namens ist systemspezifisch. Es kann gegebenenfalls ein vollständiger Pfadname sein, der auf ein speziell für temporäre Dateien vorgesehenes Verzeichnis verweist.

Beispiel:

  #include <stdio.h>

  int main(void)
  {
    int i;
    char buf[FILENAME_MAX];

    for (i=0; i<20; i++)
      printf("%2d: %s\n", i, tmpnam(buf));

    return 0;
  }

tmpfile

  #include <stdio.h>

  FILE *tmpFILE(void);

Rückgabewert:
Der Rückgabewert ist NULL, wenn die temporäre Datei nicht angelegt werden kann, ansonsten ist er von NULL verschieden.

Beispiel:

  #include <stdio.h>

  #define n 50

  int main(void)
  {
    FILE *f;
    char buf[n];

    f = tmpfile();               /* Temporaere Datei anlegen */
    fprintf(f, "Das wird in eine temporaere Datei geschrieben\n");
    rewind(f);
    fgets(buf, n, f);            /* Lesen aus der temporaeren Datei */
    printf("%s", buf);

    return 0;
  }

Zurück zum Menü

Zurück zur vorigen Seite

Weiter zur nächsten Seite