C++ Tutorial
Dateizugriffe
Text- und Binärdatei
Bevor auf die Bearbeitung von Dateien eingegangen werden kann, sind die Begriffe Textdatei und Binärdatei zu klären. Die Unterscheidung ist notwendig, da die Dateitypen unterschiedlich gehandhabt werden.
Textdatei
Textdateien sind Dateien die nur ASCII-Zeichen enthalten. Diese Dateien können mit jedem Texteditor bearbeitet werden. Numerische Daten sind in diesen Dateien ebenfalls als ASCII-Zeichen abgelegt.
Beispiel:
Eine Datei enthält den String "Emil Maier", den short-Wert 100 und den long-Wert 0x11223344:
Dateiinhalt:
Diese Dateiform ist die einzige Möglichkeit, Dateien zwischen unterschiedlichen Plattformen auszutauschen, da das Dateiformat der nachfolgenden Binärdatei nicht standardisiert ist.
Binärdatei
In Binärdateien sind die Daten in binärer Form abgelegt, also in der Form, wie sie im Speicher des Rechners liegen. Diese Daten können in der Regel nicht mit einem Texteditor bearbeitet werden, da diese nur Dateien mit ASCII-Zeichen sinnvoll darstellen können. Der Aufbau einer Binärdatei ist, wie erwähnt, nicht standardisiert, d.h., unterschiedliche Systeme können Daten unterschiedlich ablegen.
Die Ausgabe eines Textes in eine Binärdatei unterscheidet sich nicht von der Ausgabe in eine Textdatei. Der Unterschied wird erst bei der Ausgabe von numerischen Daten deutlich.
Beispiel:
Die Datei enthält ebenfalls den String "Emil Maier", den short-Wert 100 und den long-Wert 0x11223344.
Dateiinhalt:
Anwenden von Dateistreams
Für die Bearbeitung von Dateien werden ebenfalls Streams eingesetzt. Diese Dateistreams sind in der Header-Datei <fstream> definiert und liegen ebenfalls im Namensraum std.
Um mithilfe der Streams Dateien zu bearbeiten, sind folgende Schritte notwendig:
- Streamobjekt definieren
- Streamobjekt mit Datei verbinden
- Schreiben bzw. lesen der Daten
- Dateiverbindung mit dem Streamobjekt aufheben
- Streamobjekt löschen
Schreiben in Datei
Ausgabestream-Objekt definieren
Bevor Daten in eine Datei geschrieben werden können, ist zunächst ein Ausgabestream-Objekt zu definieren:
std::ofstream myFile;
ofstream ist der Stream, der für die Ausgabe in eine Datei verwendet wird, und myFile ein beliebiger Name des Streamobjekts.
Ausgabestream-Objekt mit Datei verbinden
Standardmäßig besitzt das Streamobjekt keine Verbindung zu einer Datei. Diese Verbindung erfolgt erst durch den Aufruf der ofstream-Methode
void open(const char *pFName[, OMODE mode]);
pFName ist der Zeiger auf den Namen der Datei, die mit dem Stream verbunden werden soll.
Der optionale zweite Parameter mode spezifiziert den Modus, in dem die Datei geöffnet werden soll. Er kann eine sinnvolle Kombination durch Veroderung aus folgenden Werten sein:
Wird beim Aufruf von open() der zweite Parameter nicht angegeben, wird die Datei für die Ausgabe im Textmodus geöffnet und der ursprüngliche Inhalt wird verworfen.
Wird der Modus explizit vorgegeben, ist immer der Modus std::ios::out mit anzugeben!
Es gibt eine zweite Form, ein Ausgabestream-Objekt zu definieren und dabei gleichzeitig mit einer Datei zu verbinden.
std::ofstream myFile(const char* pFName[, OMODE mode]);
Hier wird bei der Definition des Streamobjekts die zu öffnende Datei angegeben, gefolgt vom optionalen Modus.
1. Form
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Streamobjekt definieren
7: std::ofstream myFile;
8: // und anschliessend mit Textdatei verbinden
9: myFile.open ("d:\\tmp\\test.dat");
10: ...
11: }
2. Form
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Streamobjekt definieren und mit Binaerdatei verbinden
7: std::ofstream myFile ("d:/tmp/test.dat",
8: std::ios::out|std::ios::binary);
9: ...
10: }
Im ersten Fall wird zunächst das Streamobjekt definiert und anschließend mittels open() mit einer Datei verbunden. Bitte beachten Sie, dass vor dem Namen der Methode open() der Name des Streamobjekts steht und danach ein Punkt folgt. Dies ist die allgemeine Syntax für den Aufruf der Methode eines Objekts.
Im zweiten Fall wird das Streamobjekt bei seiner Definition mit einer Datei verbunden. Im Beispiel wird die Datei im Binärmodus geöffnet. Dabei ist zu beachten, dass hier der Modus std::ios::out mit anzugeben ist.
Da nicht ausgeschlossen werden kann, dass beim Öffnen einer Datei einmal etwas schief geht, sollte nach der Verbindung des Streams mit einer Datei stets eine Fehlerabfrage erfolgen. Wie ein solcher Fehler abgefangen wird, ist nachfolgende dargestellt.
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Streamobjekt definiere
7: std::ofstream myFile;
8: // Datei oeffnen und Fehler abfangen
9: myFile.open("d:/tmp/test.dat");
10: if (!myFile)
11: {
12: ... // Hier Fehlerbehandlung durchführen
13: }
14: }
Schreiben in Datei
Textdatei
Das Schreiben in eine Textdatei erfolgt prinzipiell gleich wie die Ausgabe auf die Standardausgabe. Lediglich bei den print()-Funktionen ist zusätzlich jetzt als erster Parameter das Streamobjekt anzugeben.
Beim Schreiben ist zu beachten, dass zwischen den zu schreibenden Daten mindestens ein Trennzeichen (Leerzeichen, Zeilenvorschub o.ä.) steht, da die Daten ansonsten später nicht mehr korrekt eingelesen werden können.
Im nachfolgenden Beispiel erzeugen alle drei Schreiboperationen die gleiche Ausgabe. Die Fehlerbehandlung beim Öffnen der Datei wurde der Übersichtlichkeit wegen weggelassen.
1: #include <fstream>
2: #include <format>
3: #include <print>
4:
5: int main()
6: {
7: // Beliebiges Datum definieren/initialisieren
8: int var = 11;
9: // Dateistream definieren und gleichzeitig
10: // mit einer Datei verbinden
11: std::ofstream myFile("c:/temp/xxx.txt");
12: // Alle nachfolgenden Schreiboperationen erzeugen
13: // die gleiche Ausgabe
14: // 1. Direktes Schreiben (langsamste Variante)
15: myFile << "Ein Test: " << var << '\n';
16: // 2. Schreiben mittels format()
17: myFile << std::format("Ein Test: {}\n",var);
18: // 3. Schreiben mittels println() (schnellste Variante)
19: std::println(myFile,"Ein Test: {}\n",var);
20: }
Binärdatei
Das Schreiben eines Bytes in eine Binärdatei erfolgt mit der Methode
std::ostream& write(const char *pBuffer, streamsize bytes);
wobei data das zu schreibende Byte enthält.
Sollen Daten, die aus mehreren Bytes bestehen (short, long usw.), in einer binären Datei abgelegt werden, ist hierfür die Methode
std::ostream& write(const char *pBuffer, streamsize bytes);
einzusetzen. pBuffer ist ein Zeiger auf den Beginn des zu schreibenden Datenblocks und bytes gibt die Anzahl der zu schreibenden Bytes an. Da die Methode einen const char-Zeiger erwartet, ist in der Regel eine Typkonvertierung vorzunehmen.
1: #include <fstream>
2:
3: // Variablen definieren
4: auto var1 = 10, var2 = 20;
5:
6: // main() Funktion
7: int main ()
8: {
9: // Streamobjekt definieren und mit Datei verbinden
10: std::ofstream myFile;
11: myFile.open ("d:/tmp/test.dat",
12: std::ios::out|std::ios::binary);
13: // Wenn Stream ohne Fehler mit Datei verbunden
14: if (myFile)
15: {
16: // Daten schreiben
17: myFile.write(reinterpret_cast<char*>(&var1),
18: sizeof var1);
19: myFile.write(reinterpret_cast<char*>(&var2),
20: sizeof var2);
21: // Datei schliessen
22: ...
23: }
24: }
Wenn Sie sich das Beispiel oben genauer ansehen, werden Sie bemerken, dass dort nur eine Typkonvertierung nach char* erfolgt und nicht nach const char*. Ein char* kann immer anstelle eines const char* übergeben werden, aber niemals umgekehrt! Das const char* bei der Signatur der Methode write() sagt nur aus, dass die Methode den Inhalt des übergebenen Puffers nicht verändert.
Beim Schreiben von Daten in Binärdateien können die Daten unmittelbar hintereinandergeschrieben werden, es sind keine Trennzeichen wie bei einer Textdatei notwendig, um später die Daten wieder einlesen zu können.
Dateiverbindung aufheben
Nachdem die Daten in die Datei übertragen wurden, ist die Verbindung des Streams zur Datei wieder aufzuheben. Hierbei gibt es wiederum zwei Möglichkeiten.
Im ersten Fall wird die Verbindung zur Datei durch den Aufruf der Methode
void close();
aufgehoben. Das Streamobjekt besteht danach weiter und kann durch erneuten Aufruf von open() mit einer weiteren Datei verbunden werden.
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Streamobjekt definieren und mit Datei verbinden
7: std::ofstream myFile;
8: myFile.open ("d:/tmp/test.dat");
9: ... // Datei bearbeiten
10: // Dateiverbindung aufheben
11: myFile.close();
12: // Stream erneut mit einer Datei verbinden
13: myFile.open("c:/anydir/anotherfile.dat);
14: ...
15: myFile.close();
16: }
Die zweite Möglichkeit, eine Verbindung zur Datei aufzuheben, besteht darin, das Streamobjekt zu löschen. Wenn ein Streamobjekt, wie im nachfolgenden Beispiel dargestellt, innerhalb eines Blocks {...} definiert ist, wird es am Blockende automatisch gelöscht und damit dessen Verbindung zur Datei aufgehoben. Mehr zu Blöcken innerhalb eines Programms und der Gültigkeit von Variablen und Objekt später im Kapitel Lebensdauer und Sichtbarkeit von Daten.
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Blockbegin
7: {
8: std::ofstream myFile("d:/tmp/test.dat");
9: ... // Datei bearbeiten
10: }
11: // Blockende, hier wird das Streamobjekt geloescht!
12: }
Einlesen aus Datei
Eingabestream-Objekt definieren
Ein Eingabestream-Objekt wird mit folgender Anweisung definiert:
std::ifstream myFile;
ifstream ist der Stream der für das Einlesen von Daten aus einer Datei und myFile der Name des Streamobjekts. Das so definierte Streamobjekt myFile besitzt ebenfalls noch keine Verbindung zu einer Datei.
Eingabestream-Objekt mit Datei verbinden
Nachdem das Streamobjekt erstellt wurde, kann es mit einer Datei verbunden werden. Dies erfolgt wiederum durch den Aufruf der Methode
void open(const char *pFName[, OMODE mode]);
Der Parameter pFName ist ein Zeiger auf den Namen der zu öffnenden Datei und der zweite optionale Parameter mode gibt an, in welchem Modus die Datei zu öffnen ist. Er ist eine sinnvolle Kombination aus folgenden Werten:
Wird beim Aufruf der Methode der zweite Parameter weggelassen, wird die Datei im Textmodus geöffnet.
Und auch hier besteht die Möglichkeit, ein Eingabestream-Objekt gleich bei seiner Definition mit einer Datei zu verbinden.
std::ifstream myFile(const char* pFName [, ios::openmode mode]);
1. Form
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Streamobjekt definieren
7: std::ifstream myFile;
8: // Datei oeffnen und Fehlerabfrage!
9: myFile.open ("d:/tmp/test.dat");
10: if (!myFile)
11: {
12: ... // Fehlerbehandlung
13: }
14: }
2. Form
1: #include <fstream>
2:
3: // main() Funktion
4: int main ()
5: {
6: // Streamobjekt definieren und mit Datei verbinden
7: std::ifstream myFile("d:/tmp/test.dat",
8: std::ios::in|std::ios::binary);
9: // Fehlerabfrage!
10: if (!myFile)
11: {
12: ... // Fehlerbehandlung
13: }
14: }
Und auch beim Öffnen einer Datei zum Lesen können Fehler auftreten. Prüfen Sie deshalb immer, ob der Stream erfolgreich mit der Datei verbunden werden konnte.
Lesen aus Datei
Textdatei
Das Lesen aus einer Textdatei erfolgt prinzipiell gleich wie das Einlesen von der Standard-Eingabe mittels cin. Anstelle des Streamobjekts cin steht hier der Name des Eingabestream-Objekts. Alle zu lesenden Daten werden ebenfalls mit dem Operator >> aus dem Stream ausgelesen.
1: #include <fstream>
2:
3: // Variablen definieren
4: int var1, var2;
5:
6: // main() Funktion
7: int main ()
8: {
9: // Streamobjekt definieren und mit Datei verbinden
10: std::ifstream myFile;
11: myFile.open ("d:/tmp/test.dat");
12: // Hier Fehler abfangen!
13: ...
14: // Daten lesen
15: myFile >> var1 >> var2;
16: // Datei schliessen
17: ...
18: }
Da sowohl cin wie auch ifstream die gleiche Basisklasse basic_istream besitzen, stehen für das Einlesen von Daten aus einer Datei dieselben Manipulatoren, wie z.B. std::hexoder std::oct, zur Verfügung.
Binärdatei
Das Lesen eines Bytes erfolgt mit der Methode
std::istream& get(char& data);
Das ausgelesene Byte ist nach der Ausführung der Methode in der Variable data abgelegt. Beachten Sie, dass nach dem Datentyp char der Operator & steht. Dies ist hier nicht der Adressoperator, sondern get() erhält eine Referenz auf die Variable, in die das eingelesene Byte abzulegen ist. Im Programm übergeben Sie einfach die einzulesende Variable an die Methode, also z.B.
myFile.get(charVar);
Sollen Daten, die aus mehreren Bytes bestehen (short, long usw.), aus einer Binärdatei eingelesen werden, ist hierfür die Methode
std::istream& read(char *pBuffer, streamsize bytes);
einzusetzen. pBuffer ist ein char-Zeiger auf den Beginn des Datenblocks, in dem die ausgelesenen Bytes abgelegt werden und bytes gibt die Anzahl der zu lesenden Bytes an. Da die Methode einen char-Zeiger erwartet, ist in der Regel ebenfalls eine Typkonvertierung erforderlich.
1: #include <fstream>
2:
3: // Variablen definieren
4: int var1, var2;
5:
6: // main() Funktion
7: int main ()
8: {
9: // Streamobjekt definieren und mit Datei verbinden
10: std::ifstream myFile;
11: myFile.open ("d:/tmp/test.dat",
12: std::ios::in|std::ios::binary);
13: // Hier Fehler abfangen!
14: ...
15: // Daten lesen
16: myFile.read(reinterpret_cast<char*>(&var1), sizeof var1);
17: myFile.read(reinterpret_cast<char*>(&var2), sizeof var2);
18: // Datei schliessen
19: ...
20: }
Dateiverbindung mit Eingabestream-Objekt aufheben
Das Aufheben der Verbindung mit der Datei und das Löschen des Streamobjekts erfolgt auf die gleiche Weise wie beim Schreiben in eine Datei.
Schreiben und Lesen
Und auch dies ist möglich: Eine Datei kann zum Schreiben und Lesen geöffnet werden. Hierzu wird ein Streamobjekt vom Typ fstream eingesetzt, das wie folgt definiert wird:
std::fstream myFile;
fstream ist der Stream für das Schreiben und Lesen von Daten aus einer Datei und myFile wieder der Name des Streamobjekts. Auch dieses Streamobjekt besitzt ebenfalls noch keine Verbindung zu einer Datei. Um das Streamobjekt mit einer Datei zu verbinden, wird entweder die Methode open() verwendet oder bei der Definition des Streamobjekts wird der Dateiname mit angegeben (genauso wie ifstream bzw. ofstream). Lediglich für den Parameter mode sind hier andere Kombinationen zugelassen:
Wird eine Datei zum Lesen und Schreiben geöffnet werden, ist der mode Parameter immer mit anzugeben.
Das Lesen und Schreiben der Daten sowie das Schließen der Datei erfolgt mit den in den vorherigen Abschnitten beschriebenen Methoden.
Sonstige Dateioperationen
eof() und clear() Methode
In der Praxis wird im Voraus nicht bekannt sein, wie viele Daten in einer Datei abgelegt sind. Die Abfrage, ob beim Einlesen das Dateiende erreicht ist, erfolgt mit der Methode
bool eof()
eof() liefert true zurück, wenn das Dateiende erreicht wurde. Damit eof() das Erreichen des Dateiendes feststellen kann, muss vorher ein Leseversuch stattgefunden haben.
1: // Streamobjekt definieren und mit Datei verbinden
2: std::ifstream myFile("d:/test.dat");
3: // Einlesen aus Datei
4: myFile >> data1 >> ...;
5: // Prüfen, ob Dateiende noch nicht erreicht
6: if (!myFile.eof())
7: {
8: ... // Weiter Daten aus Datei auswerten
9: }
Nach Erreichen des Dateiendes befindet sich der Dateistream in einem Fehlerzustand. Sollen danach weiter Schreib-/Leseoperationen erfolgen, ist die Methode
void clear();
aufzurufen, um den Fehlerzustand aufzuheben.
ignore() Methode
Die Methode ignore() wird zum Überspringen von Daten in einer Datei verwendet.
1: #include <fstream>
2: #include <print>
3:
4: // main() Funktion
5: int main()
6: {
7: // Feld zum Einlesen eines Strings
8: char array[100];
9:
10: // Streamobjekt definieren und mit Datei verbinden
11: std::ifstream infile("test.dat");
12: // Wenn Datei geöffnet werden konnte
13: if (infile)
14: {
15: // Erstes Wort einlesen
16: infile >> array;
17: std::println("1. Wort: {}", array);
18: // Rest der 1. Zeile
19: // (aber max. 100 Zeichen) überspringen
20: infile.ignore(100,'\n');
21: // Erstes Wort der 2. Zeile einlesen
22: infile >> array;
23: std::println("2. Wort: {}", array);
24: }
25: }
seek() Methoden
In Dateistreams lassen sich die internen Dateizeiger (genau genommen sind es Pufferzeiger) beeinflussen, um einen wahlfreien Zugriff auf die in der Datei abgelegten Daten zu erhalten. Hierzu werden die beiden Methoden
std::basic_istream& seekg (ios:off_type offset, DIR pdir);
std::basic_ostream& seekp (ios::off_type offset, DIR pdir);
eingesetzt. Die Methode seekg() dient zum Positionieren des Lesezeigers und die Methode seekp() zum Positionieren des Schreibzeigers. Beide Zeiger lassen sich unabhängig voneinander positionieren. offset gibt die Anzahl der Bytes an, um die der Dateizeiger von der Position pdiraus bewegt werden soll. Für pdir ist einer der folgenden Werte zulässig:
Dabei ist zu beachten, dass der Dateizeiger bei Angabe von std::ios::beg nur in positiver Richtung und bei Angabe von std::ios::end nur in negativer Richtung verschoben werden kann!
Im nachfolgenden, etwas längeren Beispiel werden zunächst die Werte 1...5 in eine Binärdatei geschrieben, die zum Lesen und Schreiben geöffnet ist. Anschließend werden mit Hilfe der erwähnten seek Methoden verschiedene Werte aus der Datei ausgelesen. Beachten Sie die Kommentare im Listing. Zum Schluss wird der vorletzte Wert verändert und dann alle Daten zur Kontrolle nochmals ausgegeben.
1: // Beispiel zu wahlfreiem Dateizugriff
2: #include <fstream>
3: #include <iostream>
4: #include <print>
5:
6: // Dateiname
7: auto const FILENAME = "test.dat";
8:
9: // main() Funktion
10: int main()
11: {
12: // Streamobjekt mit binärer Datei verbinden
13: std::fstream inOutFile(FILENAME, std::ios::binary |
14: std::ios::in | std::ios::out | std::ios::trunc);
15: // Fehler abfangen
16: if (!inOutFile)
17: {
18: std::println("Fehler beim Oeffnen der Datei {}", FILENAME);
19: exit(1);
20: }
21:
22: // Werte 1...5 in Datei schreiben
23: int var;
24: for (var=1; var<6; var++)
25: inOutFile.write(reinterpret_cast<char*>(&var), sizeof var);
26:
27: // Auf Dateianfang zurück
28: inOutFile.seekg(0, std::ios::beg);
29: // 1. Datum einlesen
30: inOutFile.read(reinterpret_cast<char*>(&var), sizeof var);
31: std::println("1. Wert: {}", var);
32: // Auf letzten Wert positionieren
33: inOutFile.seekg(sizeof var * -1, std::ios::end);
34: inOutFile.read(reinterpret_cast<char*>(&var), sizeof var);
35: std::println("Letzter Wert: {}", var);
36: // Auf vorletzten Wert positionieren
37: inOutFile.seekg(sizeof var * -2, std::ios::end);
38: inOutFile.read(reinterpret_cast < char*>(&var), sizeof var);
39: std::println("Vorletzter Wert: {}\n", var);
40: // Vorletzten Wert überschreiben
41: std::cout << "Ueberschreibe jetzt vorletzten Wert!\n";
42: var = -1;
43: inOutFile.seekp(sizeof var * -2, std::ios::end);
44: inOutFile.write(reinterpret_cast<char*>(&var), sizeof var);
45: // Und nun alle Werte auslesen
46: std::cout << "Datei enthaelt jetzt:\n";
47: // Lesezeiger zuerst auf Dateianfang
48: inOutFile.seekg(0, std::ios::beg);
49: // Nun alles wieder einlesen bis zum Dateiende
50: do
51: {
52: inOutFile.read(reinterpret_cast<char*>(&var), sizeof var);
53: // Wenn nicht Dateiende erreicht, Wert ausgeben
54: if (!inOutFile.eof())
55: std::print("{} ",var);
56: } while (!inOutFile.eof());
57: std::cout << '\n';
58: }
1. Wert: 1
Letzter Wert: 5
Vorletzter Wert: 4
Ueberschreibe jetzt vorletzten Wert!
Datei enthaelt jetzt:
1 2 3 -1 5
Copyright 2024 © Wolfgang Schröder
E-Mail mit Fragen oder Kommentaren zu dieser Website an: info@cpp-tutor.de
Impressum & Datenschutz