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:

Hex-Darstellung
ASCII-Darstellung
45 6D 69 6C 20 4D 61 69 65 72
Emil Maier
0x31 0x30 0x30
100
0x32 0x38 0x37 0x34 0x35 0x34 0x30 0x32 0x30
287454020

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:

Hex-Darstellung
ASCII-Darstellung
45 6D 69 6C 20 4D 61 69 65 72
Emil Maier
0x64 0x00
d.
0x44 0x33 0x22 0x11
D3".

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:

OMODE
Bedeutung
std::ios::out
Öffnen einer Datei zum Schreiben (default).
std::ios::trunc
Öffnen einer Datei, wobei der ursprüngliche Inhalt verworfen wird (default).
std::ios::ate
Öffnen einer Datei und positionieren des Schreibzeigers auf das Dateiende. Der Schreibzeiger kann bei Bedarf neu positioniert werden (seekp()) und die Daten werden an der aktuellen Position eingefügt.
std::ios::app
Öffnen einer Datei und positionieren des Schreibzeigers auf das Dateiende. Die neuen Daten werden immer am Ende der Datei eingefügt, unabhängig davon, ob der Schreibzeiger inzwischen neu positioniert wurde.
std::ios::binary
Öffnen einer Datei im Binärmodus.

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& put(char data);

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:

OMODE
Bedeutung
std::ios::in
Öffnen einer Datei zum Lesen (default)
std::ios::binary
Öffnen einer Datei im Binärmodus.

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:

OMODE
Bedeutung
std::ios:out
Öffnen einer Datei zum Schreiben.
std::ios:in
Öffnen einer Datei zum Lesen.
std::ios::binary
Öffnen einer Datei im Binärmodus. Ohne diese Angabe wird die Datei als Textdatei interpretiert.
std::ios:app
Öffnen einer Datei und positionieren des Schreibzeigers auf das Dateiende. Neue Daten werden immer ans Ende der Datei eingefügt.
std::ios::ate
Öffnen einer Datei und positionieren des Schreibzeigers auf das Dateiende. Der Schreibzeiger kann bei Bedarf neu positioniert werden (seekp()) und die Daten werden dann an der neuen Position eingefügt.
std::ios::trunc
Öffnen einer Datei, wobei der ursprüngliche Inhalt verworfen wird.

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:

DIR
Bedeutung
std::ios::cur
Dateizeiger ab der aktuellen Position verschieben.
std::ios::beg
Dateizeiger ab Dateianfang verschieben.
std::ios::end
Dateizeiger ab Dateiende verschieben.

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