So verwenden Sie C ++ Fstream

Der fstream Der Term steht für Dateistream. Stream bezieht sich auf eine Folge von Zeichen, die sich von der Festplatte zum C ++ - Programm oder vom C+ -Programm zur Festplatte bewegen. Das Verschieben von Zeichen von einer Datei in der Festplatte zum Programm gibt ein. Das Verschieben von Zeichen aus dem Programm in eine Datei in der Festplatte wird ausgegeben. Eingabe-File-Stream-Abkürzung, als ob Ifstream von der Vorlagenklasse strukturiert ist, Basic_ifstream. Ausgangs-File-Stream-Abkürzung, Ofstream wird von der Template-Klasse strukturiert, Basic_ofstream.

Es ist möglich, in einer Sitzung einzugeben und auszugeben,. Dies wird durch die Klassenvorlage ermöglicht, Basic_fstream. Jetzt ist FStream ein Synonym für Basic_fstream. FStream, das noch Basic_fstream ist, verwendet Basic_ifstream und Ofstream, um zu operieren.

Um Eingaben alleine zu machen, die Ausgabe alleine oder in einer Sitzung in einer Sitzung auszunutzen, genügt es, das C ++ - Programm mit den folgenden Einflüssen zu starten und zu namespace -Aufrufe zu starten:

#enthalten
#enthalten
Verwenden von Namespace STD;

Dieses Tutorial verfügt über vier Hauptabschnitte: Öffnen und Schließen eines Dateistroms, Ausgabedateistroms, Anhänge, Eingabedateistrom und Bearbeiten einer Datei. Bearbeiten einer Datei bedeutet, einen Stream einzugeben und auszugeben.

Artikelinhalt

• Öffnen und Schließen eines Dateistroms
• Ausgabedateistromvorgang
• Anhängen der Zeichen an eine Datei anhängen
• Eingabedatei -Stream -Betrieb
• Lesen Sie die gesamte Datei mit einer Funktion
• Lesezeile für Zeile
• Suchen in der Datei
• TellG () Funktion

Öffnen und Schließen eines Dateistroms

Bevor ein Stream geöffnet werden kann, muss ein Stream -Objekt erstellt werden. Das Öffnen eines Streams bedeutet, einen Kanal zwischen dem C ++ - Programm und der Datei in der Festplatte festzulegen. Dies wird erreicht, durch die die Reihenfolge der Zeichen zur Datei übergeht. oder durch die die Abfolge von Zeichen die Datei hinterlassen und zum Programm kommt; oder durch die Charaktere zu und fro bewegen.

Ein Stream wird nur zum Schreiben (Ausgabe), Lesen (Eingabe) oder sowohl Lesen als auch Schreiben geöffnet. Es kann auch aus anderen Gründen geöffnet werden.

Vor dem Öffnen eines Streams muss das Stream -Objekt konstruiert werden. Der einfachste Weg, es auszudrücken, ist wie folgt in der Funktion c ++ main ():

fstream strm;

Mit dem STRM -Objekt können nun die Fstream -Elementfunktionen, Open () und Close () verwendet werden, da sie jeweils mit dem Punktoperator vorhanden sind. Mit der folgenden Aussage kann ein Fstream zum Lesen geöffnet werden:

void open ("Pfad/to/und/die/Datei", ios_base :: in);

Die Open () -Mitglied -Funktion gibt ungültig zurück.

Mit dem Stream -Objekt wäre die Anweisung:

strm.offen("./myfile ", ios_base :: in);

Da die Open () -Mitglied -Funktion void zurückgibt, um zu wissen, ob die Datei in der Festplatte erfolgreich geöffnet wurde, verwenden Sie die Mitgliedsfunktion:

bool is_open () const;

Es gibt Null für False zurück, wenn die Datei nicht geöffnet wurde, und 1 für True, wenn die Datei geöffnet wurde. Jetzt sieht unser Programm bisher so aus:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()
fstream strm;
strm.offen("./myfile ", ios_base :: in);
if (strm.ist offen())
Cout << "Open success" << endl;

anders
Cout << "Open failed" << endl;
Rückkehr 1;

Rückkehr 0;

Verwenden Sie dieses Flag, um eine Datei zum Schreiben zu öffnen:

strm.öffnen ("Pfad/to/und/die/Datei", ios_base :: out);

ios_base :: in bedeutet offen zum Lesen und ios_base :: out bedeutet offen für das Schreiben. Um eine Datei zum Lesen und Schreiben zu öffnen, verwenden Sie:

strm.öffnen ("Pfad/to/und/die/die Datei", ios_base :: in | ios_base :: out);

Hinweis: Das Vorhandensein von „iOS_Base :: in | ios_base :: out ”, das logisch verwendet oder beide Flags als einzelnes Argument für die Funktion kombinieren.

Das Schließen eines Streams bedeutet, den Kanal zu schließen, durch den Daten zwischen dem Programm und der Datei zum und nach der Datei gesendet werden können. Mit diesem Kanal kann kein Datum mehr in beide Richtungen gesendet werden. Das Schließen des Streams schließt das Stream -Objekt nicht. Der gleiche Stream kann weiterhin verwendet werden, um einen neuen Kanal zu öffnen, der nach der Verwendung bei der Übertragung von Daten geschlossen werden sollte. Machen Sie es sich zur Gewohnheit, einen Dateistrom zu schließen, nachdem er geöffnet wurde. Wenn ein Stream geschlossen ist. Der Member -Funktionsprototyp zum Schließen von FStream lautet:

void close ();

Es kehrt leider ungültig zurück. Um zu wissen, ob die Schließung erfolgreich war, verwenden Sie die Mitgliederfunktion:

bool is_open () const;

Wenn die Schließung erfolgreich wäre, würde dies Null zurückkehren, was bedeutet, dass der Stream nicht mehr geöffnet ist. Wenn die Schließung erfolglos wäre, würde er 1 zurückkehren und bedeutet, dass der Strom nicht geschlossen werden könnte.

Ausgabedateistromvorgang

Jetzt werden wir demonstrieren, dass das Öffnen einer Datei das Öffnen einer Datei und neue Dateninhalte geben. Um einen Ausgangsstrom mit FSReam zu öffnen, verwenden Sie einfach einfach ios_base :: out allein in der Open () Mitgliedsfunktion. Das folgende Programm öffnet eine Datei und sendet den Inhalt einer Zeichenfolge daran:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()
fstream strm;
strm.offen ("Doc1.txt ", ios_base :: out);
Wenn (!strm.ist offen())
Cout << "File could not be opened!" << endl;
Rückkehr 1;

char str [] = "a: Dies ist die erste Zeile.\N"
"B: Dies ist die zweite Zeile.\N"
"C: Dies ist die dritte Zeile.\N";
strm << str;
strm.schließen();
if (strm.ist offen())
Cout << "Stream could not close!" << endl;
Rückkehr 1;

Cout << "Success, check file" << endl;
Rückkehr 0;

Der Name der Datei ist DOC1.TXT kann einen vollständigen Pfad oder einen relativen Pfad enthalten. Der neue Inhalt wird durch STR im Programm identifiziert. Am Ende des Programms wäre der String -Inhalt in den Stream und damit die Datei mit der Anweisung eingefügt worden:

strm << str;

Cout ist ein Standardausgangsobjekt und wird normalerweise für die Konsole verwendet. Es verwendet den Extraktionsoperator, << . Der Extraktionsoperator wird auch mit Dateiströmen verwendet. Das Dateistromobjekt hier ist strm. Das '\ n' Zeichen am Ende jedes obigen Zitats soll sicherstellen, dass die nächste Zeile unten in der Ausgabedatei angezeigt wird:

Anstatt Text an die Datei mit dem Insertion -Operator zu senden, kann die Member -Funktion write () verwendet werden. Der folgende Code zeigt dies:

Basic_ostream & Write (const char_type* s, streamSize n)

Hier ist der vollständige Code mit der verwendeten Schreibfunktion:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()
fstream strm;
strm.offen ("Doc2.txt ", ios_base :: out);
Wenn (!strm.ist offen())
Cout << "File could not be opened!" << endl;
Rückkehr 1;

char str [] = "a: Dies ist die erste Zeile.\N"
"B: Dies ist die zweite Zeile.\N"
"C: Dies ist die dritte Zeile.\N";
strm.Schreiben (str, strlen (str));
strm.schließen();
if (strm.ist offen())
Cout << "Stream could not close!" << endl;
Rückkehr 1;

Rückkehr 0;

Das erste Argument der Funktion write () ist die Kennung des Zeichenarrays. Das zweite Argument ist die Anzahl der Zeichen (ohne \ 0) im Array.

Zeichen an eine Datei anhängen

Verwenden Sie in der Funktion "IOS_Base :: Out" "ios_base :: App", um einen Text an eine Datei anzuhängen, "iOS_Base :: App". Verwenden Sie jedoch den Insertionsbetreiber, <<, as follows:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()
fstream strm;
strm.offen ("Doc2.txt ", ios_base :: App);
Wenn (!strm.ist offen())
Cout << "File could not be opened!" << endl;
Rückkehr 1;

char str [] = "D: Dies ist die vierte Zeile.\N";
strm << str;
strm.schließen();
if (strm.ist offen())
Cout << "Stream could not close!" << endl;
Rückkehr 1;

Cout << "Success, check file" << endl;
Rückkehr 0;

Die Ausgabedatei sollte jetzt vier Zeilen haben.

Eingabedatei -Stream -Betrieb

Jetzt werden wir demonstrieren. Verwenden Sie zum Lesen einer Datei mit FStream ios_base :: in als Flagge in der Open () Mitgliedsfunktion. Das folgende Programm liest alle Inhalte der Datei und zeigt sie an der Konsole an:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

fstream strm;
strm.offen ("Doc1.txt ", ios_base :: in);
Wenn (!strm.ist offen())
Cout << "Open file failed" << endl;
Rückkehr 1;

Char C;
während (!strm.eof ())
strm.bekommen (c);
Cout << c;

strm.schließen();
Rückkehr 0;

Die EOF () ist eine Mitgliedsfunktion und gibt 1 zurück, wenn das Dateiende erreicht ist und sonst Null null ist. Das Programm liest die Zeichen der Datei nacheinander, bis das Dateiende erreicht ist. Es verwendet die Get () -Mitglied -Funktion und stellt das Lesezeichen in die bereits deklarierte Variable C, die bereits deklariert wurde. Cout sendet jedes Zeichen an die Konsole. Die Ausgabe sollte sein:

A: Dies ist die erste Zeile.
B: Dies ist die zweite Zeile.
C: Dies ist die dritte Zeile.

Lesen Sie die gesamte Datei mit einer Funktion

Die gesamte Datei kann mit der Mitgliedsfunktion gelesen werden:

Basic_istream & get (char_type* s, streamSize n, char_type delim);

Es kopiert Zeichen aus der Datei und bringt sie in ein Zeichenarray ein. Dies geschieht, bis es den Trennzeichen, eof oder bis es den N - 1 -Zeichen kopiert hat. Es passt zum Null -Charakter ('\ 0') als den letzten aufeinanderfolgenden Charakter im Array. Dies bedeutet, dass die Anzahl der für das Array ausgewählten Zeichen auf mindestens die Anzahl der Dateizeichen (einschließlich eines beliebigen \ n) sowie eines für das Nullzeichen geschätzt werden sollte. Es kopiert den Trennzeichen nicht nicht. Der folgende Code kopiert die gesamte Datei von DOC1.TXT unter Verwendung dieser Mitgliedsfunktion:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

fstream strm;
strm.offen ("Doc1.txt ", ios_base :: in);
Wenn (!strm.ist offen())
Cout << "Open file failed" << endl;
Rückkehr 1;

char arr [150];
strm.Get (arr, 150, eof);
strm.schließen();
Cout << arr << endl;
Rückkehr 0;

Lesezeile für Zeile

Die Mitgliedsfunktion für das Lesen aus einer Datei mit FStream -Zeile nach Zeile ist:

Basic_istream& getline (char_type* s, streamSize n, char_type delim);

Es kopiert Zeichen aus der Datei und bringt sie in ein Zeichenarray ein. Dies geschieht, bis es den Trennzeichen (e) trifft.G. '\ n') oder bis es das N - 1 -Zeichen kopiert hat. Es passt zum NUL ('\ 0') -Scharakter als letzte aufeinanderfolgende Zeichen im Array. Dies bedeutet, dass die Anzahl der für das Array ausgewählten Zeichen auf mindestens die Anzahl der sichtbaren Zeichen sowie eine für den Nullzeichen geschätzt werden sollte. Es kopiert den Trennzeichen nicht nicht. Der folgende Code kopiert die gesamte Datei von DOC1.TXT -Zeile für Zeile mit dieser Mitgliedsfunktion:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

fstream strm;
strm.offen ("Doc1.txt ", ios_base :: in);
Wenn (!strm.ist offen())
Cout << "Open file failed" << endl;
Rückkehr 1;

char arr [100];
während (!strm.eof ())
strm.getline (arr, 100, '\ n');
Cout << arr << endl;

strm.schließen();
Rückkehr 0;

Da beim Kopieren einer Zeile '\ n' nicht kopiert wird, muss Endl für die Ausgangsanzeige verwendet werden. Beachten Sie, dass die Anzahl der Zeichen im Array- und StreamSize -Variablen gleich gemacht wurde. Wenn im Voraus bekannt ist, dass der Trennzeichen '\ n' ist, kann die folgende Elementfunktion verwendet werden:

Basic_istream& getline (char_type* s, streamSize n);

Suchen in der Datei

Zeichen einschließlich '\ n' haben ihre natürlichen Positionen in der Datei ab 0, dann 1, 2, 3 und so weiter. Die Suchg (POS) -Mitgliedsfunktion würde den Zeiger auf das Zeichen einer Position im Stream -Objekt verweisen. Dann kann (c) verwendet werden, um diesen Charakter zu erhalten. Der Charakter in der 27^th Position des aktuellen DOC1.TXT -Datei ist 'B'. Der folgende Code liest und zeigt es an:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

fstream strm;
strm.offen ("Doc1.txt ", ios_base :: in);
Wenn (!strm.ist offen())
Cout << "Open file failed" << endl;
Rückkehr 1;

Char C;
strm.suchg (27);
strm.bekommen (c);
Cout << c << endl;
strm.schließen();
Rückkehr 0;

Wenn die angegebene Position größer ist als die des letzten Zeichens in der Datei (minus 1), wird NULL zurückgegeben.

TellG () Funktion

Wenn eine Datei gelesen wird, verweist ein interner Zeiger auf den nächsten zu lesen. Die Member -Funktion von TellG () kann die Positionsnummer des Charakters erhalten, auf den der Zeiger zeigt. Wenn die Datei gerade geöffnet wird, gibt TellG () 0 für das erste Zeichen zurück. Nach dem Lesen der ersten Zeile würde TellG () eine Nummer wie 27 im folgenden Beispiel zurückgeben:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

fstream strm;
strm.offen ("Doc1.txt ", ios_base :: in);
Wenn (!strm.ist offen())
Cout << "Open file failed" << endl;
Rückkehr 1;

char arr [100];
int pos;
strm.getline (arr, 100, '\ n');
pos = strm.TellG ();
strm.schließen();
Cout << "Position in file is now: " << pos <Rückkehr 0;

Die Ausgabe ist:

~ $ ./t9
Position in der Datei ist jetzt: 27

Die äquivalente Funktion für die Ausgabe ist rateP ().

suchdir

Seekdir bedeutet, eine Richtung zu suchen. Die in der iOS_Base -Bibliothek definierten Konstanten sind: BEG für den Beginn der Datei, CUR für die aktuelle Position der Datei und das Ende der Datei zum Ende der Datei enden. Die obige Seekg () -Funktion ist für den Eingabestream überlastet wie:

BASIC_ISTREAM & SEWING (OFF_TYPE, IOS_BASE :: SEWENDIR)

Wenn der interne Zeiger also auf die Figur an Position 27 zeigt, indem der Anfang von 0 zählt, dann

strm.suchg (0, ios_base :: cur);

Behält den Zeiger an der aktuellen Position bei.

strm.suchg (5, ios_base :: cur);

Nehmen Sie den Zeiger 5 Stellen im zweiten "this" des DOC1 auf "I" auf "I" zu zeigen.TXT -Datei.

strm.suchg (-5, ios_base :: cur);

Nehmen Sie den Zeiger 5 Plätze hinter sich, um in der ersten „Linie“ des DOC1 auf „I“ zu zeigen.TXT -Datei. Beachten Sie, dass die Position des Newline -Zeichens '\ n', der nicht am Ausgang angezeigt wird, gezählt wird.

Nun, egal wo der Zeiger sein könnte,

strm.suchg (0, ios_base :: bett);

Nimmt und verwaltet den Zeiger am Anfang der Datei; auf das erste Zeichen der Datei mit einem Offset von 0 verweisen. In diesem Fall wird es auf „A“ hinweisen.

strm.suchg (5, ios_base :: bett);

Nehmen Sie den Zeiger mit einem Versatz von 5 Plätzen vor sich; Zeigen Sie auf "I" im ersten "This" des DOC1.TXT -Datei. Beachten Sie, dass der einzelne Raum als ein Zeichen gezählt wird.

Eine negative Ganzzahl in der Offset -Position für „iOS_Base :: Beg“ ist nicht nützlich.

Nun, egal wo der Zeiger sein könnte,

strm.suchg (0, ios_base :: end);

Nimmt den Zeiger kurz nach dem Ende der Datei; auf nichts hinweisen.

Eine positive Ganzzahl in der Offset -Position für „iOS_Base :: End“ ist nicht nützlich.

strm.suchg (-5, ios_base :: end);

Nehmen Sie den Zeiger mit einem Versatz von 5 Stellen dahinter; Zeigen Sie auf "I" in der letzten "Zeile" des DOC1.TXT -Datei. Beachten Sie, dass '\ n' und der Punkt jeweils als ein Zeichen gezählt werden.

Der folgende Code zeigt die Verwendung der Funktion an der aktuellen Position mit einem negativen und positiven Versatz:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

fstream strm;
strm.offen ("Doc1.txt ", ios_base :: in);
Wenn (!strm.ist offen())
Cout << "Open file failed" << endl;
Rückkehr 1;

Char C;
strm.suchg (27);
strm.suchg (0, ios_base :: cur);
strm.bekommen (c);
Cout << c << endl;
strm.suchg (-5, ios_base :: cur);
strm.bekommen (c);
Cout << c << endl;
strm.suchg (+10, ios_base :: cur);
strm.bekommen (c);
strm.schließen();
Rückkehr 0;

Die Ausgabe ist:

B
N

Die Get () -Mitglied -Funktion verschiebt den Zeiger nach seiner Ausführung einen Platz vorne.

Die äquivalente Funktion für die Ausgabe ist:

Basic_ostream& suchp (off_type, ios_base :: seeeddir)

Beachten.

Abschluss

Die FStream -Klasse befasst sich mit Eingaben von einer Datei zu einem C ++ - Programm und Ausgabe des Programms zur Datei. Um den C ++ - Fstream zu verwenden, muss ein Objekt aus der Klasse instanziiert werden. Das Stream -Objekt muss dann für Eingabe oder Ausgabe geöffnet werden oder beides. Um Text an die Datei anzuhängen, muss der Stream zum Anhängen geöffnet werden. Machen Sie es sich zur Gewohnheit, den Strom immer zu schließen, nachdem er geöffnet und verwendet wurde. Wenn die Datei eine Bilddatei ist, dann iOS_Base :: Binary muss | mit | ored werden mit dem zweiten Argument der Open () -Mitglied -Funktion. Dieser Artikel half Ihnen hoffentlich bei der Verwendung des C ++ - Fstream.