Comment utiliser C ++ FStream

Le fléau Le terme signifie un flux de fichiers. Stream fait référence à une séquence de caractères passant du disque au programme C ++ ou du programme C + au disque. Les caractères déplacés d'un fichier en disque vers le programme saisissent. Les caractères déplacés du programme à un fichier du disque sortent. Entrée-file-stream abrégé comme ifstream est structuré par la classe de modèle, Basic_ifstream. Sortie-File-Stream Abréviée, OfStream est structurée par la classe de modèle, Basic_ofstream.

Il est possible que la saisie et la sortie se produisent en une seule session. Ceci est rendu possible par le modèle de classe, Basic_fstream. Maintenant, FStream est synonyme de Basic_Fstream. fstream, qui est toujours basique_fstream, utilise Basic_ifstream et OfStream pour fonctionner.

Afin de faire la saisie seule, de faire la sortie seule, ou des deux en une seule session, il suffit de démarrer le programme C ++ avec les incluses suivantes et les invocations de l'espace de noms:

#inclure
#inclure
Utilisation de Namespace Std;

Ce didacticiel a quatre sections principales: l'ouverture et la fermeture d'un flux de fichiers, un flux de fichiers de sortie, une ajout, un flux de fichiers d'entrée et l'édition d'un fichier. Édition d'un fichier signifie saisir et sortir un flux.

Contenu de l'article

• Ouverture et fermeture d'un flux de fichiers
• Fonctionnement du flux de fichiers de sortie
• Ajouter les caractères à un fichier
• Fonctionnement du flux de fichiers d'entrée
• Lire le fichier entier avec une fonction
• Lecture ligne par ligne
• Cherche dans le fichier
• Fonction Tellg ()

Ouverture et fermeture d'un flux de fichiers

Avant qu'un flux puisse être ouvert, un objet de flux doit être créé. L'ouverture d'un flux signifie établir un canal entre le programme C ++ et le fichier en disque. Ceci est accompli à travers lequel la séquence de caractères passera au fichier; ou à travers quelle séquence de caractères quittera le fichier et arrivera au programme; ou à travers quels personnages se déplaceront et.

Un flux est ouvert uniquement pour l'écriture (sortie), la lecture (entrée), ou les deux lecture et l'écriture. Il peut également être ouvert pour d'autres raisons.

Avant d'ouvrir un flux, l'objet Stream doit être construit. La façon la plus simple de l'exprimer est la suivante dans la fonction c ++ main ():

fstream strm;

Maintenant, avec l'objet STRM, le membre FStream fonctionne, Open () et Close () peut être utilisé, précédant chacun avec l'opérateur de points. La déclaration suivante peut être utilisée pour ouvrir un fstream pour la lecture:

void ouvert ("path / vers / et / le fichier", iOS_Base :: in);

La fonction du membre Open () renvoie vide.

Avec l'objet Stream, l'instruction serait:

strm.ouvrir("./ myFile ", iOS_Base :: in);

Étant donné que la fonction de membre Open () renvoie void, pour savoir si le fichier du disque a été ouvert avec succès, utilisez la fonction membre:

bool is_open () const;

Il renvoie zéro pour false si le fichier ne s'est pas ouvert et 1 pour true si le fichier s'est ouvert. Maintenant, notre programme ressemble à ceci jusqu'à présent:

#inclure
#inclure
Utilisation de Namespace Std;
int main()
fstream strm;
strm.ouvrir("./ myFile ", iOS_Base :: in);
si (strm.est ouvert())
couter << "Open success" << endl;

autre
couter << "Open failed" << endl;
retour 1;

retour 0;

Pour ouvrir un fichier pour l'écriture, utilisez ce drapeau:

strm.Open ("Path / vers / et / le fichier", iOS_Base :: out);

iOS_Base :: in signifie ouvert à la lecture et iOS_Base :: Out signifie ouvert à l'écriture. Pour ouvrir un fichier pour la lecture et l'écriture, utilisez:

strm.Open ("Path / To / et / The / File", iOS_Base :: in | iOS_Base :: out);

Remarque: la présence de «iOS_Base :: in | iOS_Base :: out ”, qui utilise logique ou pour combiner les deux drapeaux en tant qu'argument unique à la fonction.

La fermeture d'un flux signifie la fermeture du canal par lequel les données peuvent être envoyées et pour le programme et le fichier. Plus de référence ne peut être envoyée dans les deux sens en utilisant ce canal. La fermeture du flux ne ferme pas l'objet Stream. Le même flux peut encore être utilisé pour ouvrir un nouveau canal, qui doit être fermé après une utilisation dans la transmission de données. Prenez l'habitude de fermer n'importe quel flux de fichiers, après avoir été ouvert. Lorsqu'un flux est fermé, toutes les données en mémoire qui devaient être dans le fichier sont envoyées au fichier avant de fermer réellement. Le prototype de fonction membre pour fermer FStream est:

void close ();

Il revient vide, malheureusement. Donc, pour savoir si la clôture a réussi, utilisez la fonction membre:

bool is_open () const;

Si la clôture était réussie, cela rendrait zéro, ce qui signifie que le flux n'est plus ouvert. Si la clôture échouait, elle reviendrait 1 et ce qui signifie que le flux ne pourrait pas être fermé.

Fonctionnement du flux de fichiers de sortie

Nous allons maintenant démontrer l'ouverture d'un fichier et leur donner un nouveau contenu de données. Pour ouvrir un flux de sortie avec fsream, utilisez simplement iOS_Base :: Out Seul dans la fonction de membre Open (). Le programme suivant ouvre un fichier, et il lui envoie le contenu d'une chaîne:

#inclure
#inclure
Utilisation de Namespace Std;
int main()
fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: out);
si (!strm.est ouvert())
couter << "File could not be opened!" << endl;
retour 1;

char str [] = "a: c'est la première ligne.\ n "
"B: c'est la deuxième ligne.\ n "
"C: C'est la troisième ligne.\ n ";
strm << str;
strm.fermer();
si (strm.est ouvert())
couter << "Stream could not close!" << endl;
retour 1;

couter << "Success, check file" << endl;
retour 0;

Le nom du fichier est doc1.TXT peut inclure un chemin complet ou un chemin relatif. Le nouveau contenu est identifié par STR dans le programme. À la fin du programme, le contenu de la chaîne aurait été inséré dans le flux et donc le fichier avec l'instruction:

strm << str;

Cout est un objet de sortie standard, et il est généralement utilisé pour la console. Il utilise l'opérateur d'extraction, << . L'opérateur d'extraction est également utilisé avec des flux de fichiers. L'objet de flux de fichiers ici est strm. Le caractère '\ n' à la fin de chaque devis ci-dessus est de s'assurer que la ligne suivante apparaît ci-dessous dans le fichier de sortie:

Au lieu d'envoyer du texte dans le fichier avec l'opérateur d'insertion, la fonction de membre écrite () peut être utilisée. Le code suivant illustre ceci:

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

Voici le code complet avec la fonction d'écriture utilisée:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()
fstream strm;
strm.ouvert ("Doc2.txt ", ios_base :: out);
si (!strm.est ouvert())
couter << "File could not be opened!" << endl;
retour 1;

char str [] = "a: c'est la première ligne.\ n "
"B: c'est la deuxième ligne.\ n "
"C: C'est la troisième ligne.\ n ";
strm.écrire (str, strlen (str));
strm.fermer();
si (strm.est ouvert())
couter << "Stream could not close!" << endl;
retour 1;

retour 0;

Le premier argument de la fonction écrite () est l'identifiant du tableau de caractères. Le deuxième argument est le nombre de caractères (sans \ 0) dans le tableau.

Les caractères en ajoutant dans un fichier

Pour ajouter le texte dans un fichier, utilisez «iOS_Base :: App» seul, au lieu de «iOS_Base :: Out» dans la fonction de membre Open (). Pourtant, utilisez l'opérateur d'insertion, <<, as follows:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()
fstream strm;
strm.ouvert ("Doc2.txt ", ios_base :: app);
si (!strm.est ouvert())
couter << "File could not be opened!" << endl;
retour 1;

Char Str [] = "D: c'est la quatrième ligne.\ n ";
strm << str;
strm.fermer();
si (strm.est ouvert())
couter << "Stream could not close!" << endl;
retour 1;

couter << "Success, check file" << endl;
retour 0;

Le fichier de sortie devrait maintenant avoir quatre lignes.

Fonctionnement du flux de fichiers d'entrée

Maintenant, nous allons démontrer la lecture d'un fichier caractère par caractère avec fstream. Pour lire un fichier avec fstream, utilisez iOS_Base :: in Comme le drapeau dans la fonction de membre Open (). Le programme suivant lit tout le contenu du fichier et l'affiche sur la console:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: in);
si (!strm.est ouvert())
couter << "Open file failed" << endl;
retour 1;

Char C;
alors que (!strm.eof ())
strm.obtenir (c);
couter << c;

strm.fermer();
retour 0;

Le eof () est une fonction membre, et il renvoie 1 lorsque la fin de fichier est atteinte et zéro sinon. Le programme lit les caractères du fichier, un par un, jusqu'à ce que la fin de fichier soit atteint. Il utilise la fonction de membre get (), mettant le caractère de lecture dans la variable C, qui a déjà été déclaré. cout envoie chaque personnage à la console. La sortie doit être:

R: C'est la première ligne.
B: Ceci est la deuxième ligne.
C: C'est la troisième ligne.

Lire le fichier entier avec une fonction

Le fichier entier peut être lu à l'aide de la fonction membre:

BASIC_ESTREAM & GET (char_type * s, streamSize n, char_type Delim);

Il copie les caractères du fichier et les met dans un tableau de caractères. Il le fait jusqu'à ce qu'il rencontre le délimiteur, l'EOF ou jusqu'à ce qu'il ait copié le caractère n - 1. Il conviendra au caractère null ('\ 0') comme le dernier caractère consécutif du tableau. Cela signifie que le nombre de caractères choisis pour le tableau devrait être estimé au moins le nombre de caractères de fichier (y compris n'importe quel \ n), plus un pour le caractère nul. Il ne copie pas le caractère délimiteur. Le code suivant copie l'ensemble du fichier de Doc1.txt, en utilisant cette fonction membre:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: in);
si (!strm.est ouvert())
couter << "Open file failed" << endl;
retour 1;

Char Arr [150];
strm.get (arr, 150, eof);
strm.fermer();
couter << arr << endl;
retour 0;

Lecture ligne par ligne

La fonction membre à utiliser pour la lecture d'un fichier avec FStream ligne par ligne est:

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

Il copie les caractères du fichier et les met dans un tableau de caractères. Il le fait jusqu'à ce qu'il rencontre le délimiteur (E.g. '\ n') ou jusqu'à ce qu'il ait copié le caractère n - 1. Il conviendra au caractère Nul ('\ 0') comme le dernier caractère consécutif du tableau. Cela signifie que le nombre de caractères choisis pour le tableau devrait être estimé au moins le nombre de caractères visibles, plus un pour le caractère nul. Il ne copie pas le caractère délimiteur. Le code suivant copie l'ensemble du fichier de Doc1.TXT ligne par ligne, en utilisant cette fonction membre:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: in);
si (!strm.est ouvert())
couter << "Open file failed" << endl;
retour 1;

Char Arr [100];
alors que (!strm.eof ())
strm.getline (arr, 100, '\ n');
couter << arr << endl;

strm.fermer();
retour 0;

Puisque '\ n' n'est pas copié lors de la copie d'une ligne, Endl doit être utilisé pour l'affichage de sortie. Notez que le nombre de caractères dans la variable de tableau et de streamSize, ont été faits. S'il est connu à l'avance que le délimiteur est «\ n», la fonction membre suivante peut être utilisée:

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

Cherche dans le fichier

Des caractères, y compris '\ n', ont leurs positions naturelles dans le fichier, à partir de 0, puis 1, 2, 3, etc. La fonction de membre Seekg (pos) pointerait le pointeur vers le caractère d'une position dans l'objet Stream. Ensuite, Get (C) peut être utilisé pour obtenir ce caractère. Le personnage du 27^e position du doc1 actuel.Le fichier txt est «b». Le code suivant lit et l'affiche:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: in);
si (!strm.est ouvert())
couter << "Open file failed" << endl;
retour 1;

Char C;
strm.chercher (27);
strm.obtenir (c);
couter << c << endl;
strm.fermer();
retour 0;

Si la position donnée est supérieure à celle du dernier caractère du fichier (moins 1), null est retourné.

Fonction Tellg ()

Au fur et à mesure qu'un fichier est lu, un pointeur interne pointe vers le caractère suivant à lire. La fonction de membre Tellg () peut obtenir le numéro de position du caractère que le pointeur pointe vers. Lorsque le fichier vient d'être ouvert, Tellg () retournera 0 pour le premier caractère. Après avoir lu la première ligne, Tellg () renvoie un nombre comme 27 dans l'exemple ci-dessous:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: in);
si (!strm.est ouvert())
couter << "Open file failed" << endl;
retour 1;

Char Arr [100];
int pos;
strm.getline (arr, 100, '\ n');
pos = strm.Tellg ();
strm.fermer();
couter << "Position in file is now: " << pos <retour 0;

La sortie est:

~ $ ./ t9
La position dans le fichier est maintenant: 27

La fonction équivalente pour la sortie est Tellp ().

chercher

Seekdir signifie chercher une direction. Ses constantes définies dans la bibliothèque iOS_BASE sont: Bound pour le début du fichier, Cur pour la position actuelle du fichier et se terminer pour la fin du fichier. La fonction Seekg () ci-dessus est surchargée pour le flux d'entrée comme:

BASIC_ISTREAM & SEECHG (OFF_TYPE, IOS_BASE :: SeekDir)

Donc, si le pointeur interne pointe vers le personnage en position 27 en comptant le début de 0, alors

strm.Seekg (0, iOS_Base :: Cur);

Maintiendra le pointeur à la position actuelle.

strm.Seekg (5, iOS_Base :: Cur);

Prendra le pointeur 5 places à l'avance pour pointer "i" dans le deuxième "this" du doc1.fichier txt.

strm.Seekg (-5, iOS_Base :: cur);

Prendra le pointeur 5 places derrière pour pointer «i» dans la première «ligne» du doc1.fichier txt. Notez que la position du caractère Newline '\ n', qui n'est pas affichée à la sortie, est comptée.

Maintenant, peu importe où le pointeur pourrait être,

strm.CHERCHG (0, iOS_Base :: Beg);

Prend et maintient le pointeur au début du fichier; Pour pointer vers le premier caractère du fichier, avec un décalage de 0. Dans ce cas, il indiquera «A».

strm.Seekg (5, iOS_Base :: Beg);

Prendra le pointeur au début avec un décalage de 5 places à l'avance; pointer «i» dans le premier «this» du doc1.fichier txt. Notez que l'espace unique est compté comme un seul personnage.

Un entier négatif dans la position de décalage pour «iOS_Base :: Beg» n'est pas utile.

Eh bien, peu importe où le pointeur pourrait être,

strm.Seekg (0, iOS_Base :: end);

Prendra et maintiendra le pointeur juste après la fin du fichier; ne signaler rien.

Un entier positif dans la position de décalage pour «ios_base :: end» n'est pas utile.

strm.Seekg (-5, iOS_Base :: end);

Prendra le pointeur à la fin avec un décalage de 5 places derrière; pointer "i" dans la dernière "ligne" du doc1.fichier txt. Notez que '\ n' et le point sont comptés comme un seul caractère.

Le code suivant illustre l'utilisation de la fonction, à la position actuelle, avec un décalage négatif et positif:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

fstream strm;
strm.ouvert ("Doc1.txt ", ios_base :: in);
si (!strm.est ouvert())
couter << "Open file failed" << endl;
retour 1;

Char C;
strm.chercher (27);
strm.Seekg (0, iOS_Base :: Cur);
strm.obtenir (c);
couter << c << endl;
strm.Seekg (-5, iOS_Base :: cur);
strm.obtenir (c);
couter << c << endl;
strm.SeekG (+10, iOS_Base :: Cur);
strm.obtenir (c);
strm.fermer();
retour 0;

La sortie est:

B
n

La fonction de membre get () déplace le pointeur une place à venir après son exécution.

La fonction équivalente pour la sortie est:

Basic_ostream& Seekp (off_type, iOS_Base :: SeekDir)

Notez le «P» dans Seekp pour put, par opposition à «G» dans Seekg pour obtenir.

Conclusion

La classe FStream traite des entrées d'un fichier à un programme C ++ et de la sortie du programme vers le fichier. Afin d'utiliser le C ++ FStream, un objet de la classe doit être instancié. L'objet Stream doit alors être ouvert pour l'entrée ou la sortie ou les deux. Pour ajouter du texte au fichier, le flux doit être ouvert pour ajouter. Prenez l'habitude de fermer toujours le ruisseau après avoir été ouvert et utilisé. Si le fichier est un fichier image, alors iOS_Base :: binaire devra être ORED en utilisant | , avec le deuxième argument de la fonction de membre Open (). Cet article, espérons-le, vous a aidé à utiliser le C ++ FStream.