Dateioperationen

Programme speichern ihre Informationen in Variablen. Leider bleiben diese immer nur bis zum nächsten Stromausfall oder Betriebssystemabsturz erhalten. Und wenn das Programm verlassen wird, ist ihr Inhalt ebenfalls Geschichte. Damit Sie auf Ihre Daten auch morgen noch kraftvoll zugreifen können, empfiehlt es sich, diese in einer Datei abzulegen. Dazu können Sie die Daten als Ausgabestrom in die Datei schreiben. Das Vorgehen entspricht dem bei der Bildschirmausgabe per cout. Diese Form wird sequenziell genannt, weil die Daten nacheinander in der Reihenfolge, wie sie geschrieben wurden, in der Datei landen. Sie können aber auch einen Datenblock an eine beliebige Stelle der Datei schreiben. Später können Sie diesen Datenblock wieder zurückholen, indem Sie den internen Dateizeiger an diese Stelle positionieren und den Datenblock wieder lesen. Diese Vorgehensweise ist typisch für Klassen, insbesondere, wenn sie in irgendeiner Form sortiert abgelegt werden sollen.

fstream

[Textausgabe in eine Datei]

#include <fstream>
using namespace std;

int main()
{
    fstream f;
    f.open("test.dat", ios::out);
    f << "Dieser Text geht in die Datei" << endl;
    f.close();
}

Öffnen und Schließen

Parameter von open()

fstream f("test.dat", ios::out);

Dateiname

Dateimodus

ios::app

ofstream und ifstream

binary

Schließen

Lesen und Schreiben

Datenstrom

fstream Datei(..., ios::out);
...
Datei << "Dies geht in eine Datei" << Variable << endl;

Natürlich können für die Dateiausgabe auch Manipulatoren zur Formatierung der Ausgabe verwendet werden. Das Lesen aus Dateien kann auf analoge Weise über den Eingabeoperator erfolgen.

Datei auslesen

Textzeile lesen

[Auslesen einer Datei]

#include <fstream>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
    fstream f;
    char cstring[256];
    f.open(argv[1], ios::in);
    while (!f.eof())
    {
        f.getline(cstring, sizeof(cstring));
        cout << cstring << endl;
    }
    f.close();
}

Daneben gibt es noch eine globale Funktion namens getline(), die ein Objekt vom Typ ifstream als ersten Parameter hat. Diese globale Funktion arbeitet auch mit der Standardklasse string und akzeptiert ein Objekt dieser Klasse als zweiten Parameter. Das Beispiel oben würde dann so aussehen:

[Auslesen einer Datei (getline.cpp)]

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main(int argc, char *argv[])
{
    ifstream f;  // Datei-Handle
    string s;
    f.open(argv[1], ios::in); // Öffne Datei aus Parameter
    while (!f.eof())          // Solange noch Daten vorliegen
    {
        getline(f, s);        // Lese eine Zeile
        cout << s << endl;    // Zeige sie auf dem Bildschirm

    }
    f.close();                // Datei wieder schließen
}

Datendateien

tDaten Daten;
fstream f(..., ios::out|ios::binary|ios::in);
f.write(&Daten, sizeof(Daten));
...
f.read(&Daten, sizeof(Daten));

Mit dem Aufruf von fwrite() wird das Objekt Daten in eine Datei ab der aktuellen Position geschrieben. Mit dem späteren Aufruf von read() wird aus der Datei in ein Objekt Daten gelesen.

Datenpuffer

Beispiel

[Test: Datenstruktur sichern (testfstr.cpp)]

#include <fstream>
#include <string>
using namespace std;
#include <string.h>

// Diese Klasse nimmt die Zeichenkette im klassischen
// char-Array auf und enthält damit die Daten.
class tDaten
{
public:
   void Set(char *para)
   {
        strncpy(data, para, sizeof(data));
        data[sizeof(data)-1] = 0;
   }
   void Show()
   {
       cout << data << endl;
   }
private:
    char data[255];
};

// Hier werden die C++-Strings verwendet. Allerdings enthält
// ein Objekt vom Typ string nicht die eigentlichen Daten.
class tStrDaten
{
public:
   void Set(char *para)
   {
       data = para;
   }
   void Show()
   {
       cout << data << endl;
   }
private:
    string data;
};

int main(int argc, char**argv)
{
  // tStrDaten Daten; // Damit funktioniert es nicht!
  tDaten Daten;       // Damit funktioniert es!

  // Eine Datein namens testdatei wird geöffnet
  fstream f("testdatei", ios::out|ios::binary|ios::in);

  // Wurde ein Parameter beim Aufruf übergeben?
  if (argc>=2)
  {
      Daten.Set(argv[1]); // In Daten ablegen
      // Objekt in Datei speichern
      f.write((char *)&Daten, sizeof(Daten));
  }
  // Kein Argument? Dann Datei auslesen!
  if (argc==1)
  {
      // Dateiinhalt in Objekt lesen
      f.read((char *)&Daten, sizeof(Daten));
      Daten.Show(); // ... und anzeigen
  }
}

Versionen

Positionsbestimmung

Puffer leeren

Zustandsbeobachtung

good()

fstream Datei;
...
if (Datei.good())
{
    // Alles super
...
if (Datei)
{
    // Auch gut

Das folgende Programm öffnet eine Datei, schreibt einen Datensatz hinein, geht wieder an den Anfang der Datei zurück und liest dann den zuvor geschriebenen Satz. Dabei prüft es jeden Schritt direkt nach seiner Ausführung.

fstream f("test.dat", ios::out|ios::binary|ios::in);
if (!f.good())
{
  cerr << "Fehler beim Öffnen von test.dat" << endl;
}
f.write(&Daten, sizeof(Daten));
if (!f.good())
{
  cerr <<"Fehler beim Schreiben von test.dat"<< endl;
}
f.seekg(0, ios::beg);
f.read(&Daten, sizeof(Daten));
if (!f.good())
{
  cerr << "Fehler beim Lesen von test.dat" << endl;
}

Dateiende

while (!f.eof())
{
    f.read(&Daten, sizeof(Daten));
}
f.clear();

f.exceptions(ios::failbit|ios::badbit);

Dateizugriffe nach ANSI-C

• Die Operationen werden auf Typsicherheit überprüft.
• Sie können eine Ausnahmebehandlung verwenden.
• Wenn Sie ostream und istream verwenden, kann bereits beim Kompilieren sichergestellt werden, dass nicht versehentlich in Dateien geschrieben wird, die nur zum Lesen geöffnet wurden.

Handles

[Dateibehandlung]

#include <stdio.h>

int main()
{
FILE *f;

    f = fopen("test.dat", "rwb");
    if (f)
    {
        fwrite(puffer, sizeof(puffer), 1, f);
        fseek(f, 0, SEEK_SET);
        fread(puffer, sizeof(puffer), 1, f);
        fclose(f);
    }
}

Öffnen und schließen

FILE *fopen(const char* DateiName, const char* Modus);
int fclose(FILE *DateiHandle);

Der erste Parameter von fopen() ist der Dateiname. Der zweite Parameter ist der Öffnungsmodus, der als Zeichenkette eines oder mehrerer Buchstaben übergeben wird. Tabelle (tabfilemodus) zeigt eine Übersicht. [Öffnungsmodi bei fopen()]

Zeichen	Bedeutung
r	Zum Lesen öffnen
w	Datei leeren und zum Schreiben öffnen
a	Daten werden angehängt
r+	Neben dem Lesen auch das Schreiben zulassen
w+	Datei leeren und zum Schreiben und Lesen öffnen
b	Binärdatei (keine Konvertierung der Zeilenendezeichen)

Lesen und schreiben

size_t fread(void *Puffer, size_t Groesse, size_t n, FILE *f);
size_t fwrite(void *Puffer, size_t Groesse, size_t n, FILE *f);

Parameter

Textdateien

char *fgets(char *Puffer, int Groesse, FILE *f);
char *fputs(char *Puffer, FILE *f);

Mit der Funktion fprintf() ist es möglich, die Daten formatiert in eine Datei zu schreiben. Abgesehen von dem Datei-Handle entsprechen die Parameter exakt der Funktion printf().

char *fprintf(FILE *f, char *Format, ...);

Positionieren

int fseek(FILE *f, long Offset, int RelPos);

Der erste Parameter ist das Datei-Handle, der zweite ist der Abstand, und der dritte ist eine Konstante, die beschreibt, worauf sich der Abstand bezieht.

[fseek(): relative Position]

Konstante	Bedeutung
SEEK_SET	Ab dem Anfang der Datei
SEEK_CUR	Ab der aktuellen Position
SEEK_END	Ab dem Ende der Datei

End Of File

int feof(FILE *f);

Dateisystemkommandos

Datei löschen: remove

#include <stdio.h>
int remove(const char *dateiname);

Die globale Variable errno

Umbenennen: rename

#include <stdio.h>
int rename(const char *dateiname, const char *neuname);

Die Funktion gibt 0 bei Erfolg und --1 bei einem Fehler zurück. Die Fehlerursache steht in der Variablen errno.

Weitere Funktionen

Verzeichnis

[Auslesen eines Verzeichnisses (dir.cpp)]

#include <dirent.h>
#include <iostream>
using namespace std;

int main()
{
    DIR *hdir;
    struct dirent *entry;

    hdir = opendir(".");
    do
    {
        entry = readdir(hdir);
        if (entry)
        {
            cout << entry->d_name << endl;
        }
    } while (entry);
    closedir(hdir);
}

Der Zeiger auf DIR ist das benötigte Handle auf das Verzeichnis. Die Funktion opendir() erhält als Parameter den Verzeichnisnamen. Bei manchen Compilern gab es Schwierigkeiten, andere Verzeichnisse als das aktuelle Verzeichnis auszulesen. Das sollten Sie bei Ihrem Compiler testen. Nach dem Eröffnen des Verzeichnisses liefert die Funktion readdir() entweder einen Zeiger auf eine Variable der Verzeichniseintragsstruktur dirent oder eine 0, wenn kein weiterer Eintrag im Verzeichnis existiert. Zu guter Letzt wird das Verzeichnis wieder geschlossen. Das einzige im POSIX-Standard garantierte Element von dirent ist der Dateiname unter d_name. Das ist allerdings auch ausreichend, denn über den Namen lassen sich beispielsweise mit der Funktion stat() weitere Informationen ermitteln.

Datei-Eigenschaften ermitteln

#include <sys/types.h>
#include <sys/stat.h>
int  stat(char *dateiname,   struct stat *puffer);

Die Ergebnisse stehen in der Variablen von Typ stat, auf die der Parameter puffer zeigt. Die Definition der Struktur beinhaltet die folgenden Elemente:

struct stat {
  dev_t  st_dev     /* (P) Device, auf dem die Datei liegt */
  ushort st_ino     /* (P) i-node-Nummer */
  ushort st_mode    /* (P) Dateityp  */
  short  st_nlink   /* (P) Anzahl der Links der Datei  */
  ushort st_uid     /* (P) Eigentuemer-User-ID (uid)  */
  ushort st_gid     /* (P) Gruppen-ID (gid)  */
  dev_t  st_rdev    /* Major- und Minornumber, falls Device */
  off_t  st_size    /* (P) Größe in Byte  */
  time_t st_atime   /* (P) Zeitpunkt letzter Zugriffs  */
  time_t st_mtime   /* (P) Zeitpunkt letzte Änderung  */
  time_t st_ctime   /* (P) Zeitpunkt letzte Statusänderung */
};

Die Bestandteile dieser Struktur können sich je nach System unterscheiden. Die mit (P) gekennzeichneten Elemente sind aber unter UNIX zwingend von POSIX vorgeschrieben.

st_dev und st_ino

Unter UNIX beschreiben st_dev und st_ino eindeutig den Ort einer Datei. st_dev ist das Device, bei Festplatten also die Partition. st_ino bezeichnet den i-node, eine unter UNIX eindeutige Kennnummer für Dateien einer Partition. Unter Windows wird in st_dev die Nummer des Laufwerks hinterlegt. st_ino ist immer 0.

st_mode

Die rechten zwölf Bits von st_mode beschreiben, ob das Programm die Datei schreiben, lesen oder ausführen kann. Unter UNIX können mit diesen Informationen die Rechte für Benutzer, Gruppen und den Rest der Welt unterschieden werden. Tabelle beschreibt, wie die rechten neun Bits von st_mode die Rechte kodieren. [4] [Rechte für eine Datei]

	Benutzer	Gruppe	Welt
Lesen	4	4	4
Schreiben	2	2	2
Ausführen	1	1	1

Unter Windows können die Benutzerrechte ausgewertet werden. Sie geben Auskunft, ob die Datei geschrieben und gelesen werden kann. Über die Dateierweiterung ermittelt Windows, ob die Datei ausführbar ist, und stellt diese Information in st_mode zur Verfügung. In den nächsten vier Bits wird codiert, welchen Typ die Datei hat. Um beides zu trennen, gibt es die Konstante S_IFMT. Mit ihr können Sie eine Maske über diese Bits setzen. Anschließend können Sie den Wert mit folgenden Konstanten vergleichen: [Konstanten für den Dateityp]

Konstante	Dateityp
S_IFSOCK	Sockets
S_IFLNK	Symbolische Links
S_IFREG	Reguläre Dateien
S_IFBLK	Block-Devices
S_IFDIR	Verzeichnisse
S_IFCHR	Char-Devices
S_IFIFO	FIFOs

Das folgende Beispielprogramm ermittelt für die als ersten Parameter übergebene Datei die Rechte und stellt anschließend fest, ob es sich um eine Datei, einen symbolischen Link (Symbolische Links sind eine Besonderheit der Dateisysteme von UNIX, die es unter MS-Windows nicht gibt.) oder ein Verzeichnis handelt.

[Dateityp und Rechte bestimmen]

#include <sys/types.h>
#include <sys/stat.h>

int main(int argc, char **argv)
{
   struct stat Status;
   int Dateityp;
   stat(argv[1], &Status);
   printf("Dateirechte: %o \n", Status.st_mode & ~S_IFMT);
   Dateityp = Status.st_mode & S_IFMT;
   switch (Dateityp) {
     case S_IFREG: puts("Datei"); break;
     case S_IFLNK: puts("Symbolischer Link"); break;
     case S_IFDIR: puts("Verzeichnis"); break;
     default: puts("Sonstiges");
   }
}

Die Konstanten S_IFREG (reguläre Dateien) und S_IFDIR (Verzeichnisse) werden auch unter Windows unterstützt. Damit können also Dateien und Verzeichnisse unterschieden werden. Die anderen Dateitypen sind unter Windows unbekannt.

st_nlink

In st_nlink steht, wie viele harte Links auf die Datei zeigen. Da Windows keine Links anlegen kann, ist dieser Wert dort immer 1.

st_uid und st_gid

Mit st_uid und st_gid werden der Besitzer und die Besitzergruppe ermittelt. Der Wert ist eine Zahl, nämlich die, die in der Datei /etc/passwd bzw. in /etc/group festgelegt wird. Unter Windows steht hier immer 0.

st_rdev

In st_rdev ist die Major- und Minornummer codiert, sofern es sich bei der Datei um ein Device handelt. Unter Windows steht hier die Laufwerksnummer.

st_size

Sofern es sich bei der Datei um eine reguläre Datei handelt, finden Sie in st_size die Größe in Bytes.

st_atime, st_mtime und st_ctime

Jeder lesende oder schreibende Zugriff auf die Datei aktualisiert den Wert st_atime. Jede Veränderung des Dateiinhalts wird in st_mtime notiert. Der Zeitpunkt der Änderungen des Benutzers, der Rechte, der Linkzahl oder von Ähnlichem (also von allem, was nicht den Inhalt betrifft) wird in st_ctime festgehalten.

[1]

Ein Prozess ist ein gestartetes Programm. Wird ein Programm mehrfach gestartet, laufen mehrere Prozesse desselben Programms.

[2]

POSIX (Portable Operating System Interface) ist eine Familie von Standards für die UNIX-Schnittstellen, die vom IEEE (Institute for Electrical und Electronic Engineers) verbindlich festgelegt wurden.

[3]

Unter Visual C++ heißt auch die Struktur _stat.

[4]

Die fehlenden Bits sind extrem UNIX-spezifisch.