Un jeu peut se relancer à l’identique, une application retrouver ses réglages et un outil conserver ses résultats grâce à une opération discrète : écrire des données sur le disque. En C++, les flux de fichiers rendent cette tâche accessible. Avec fstream, ifstream et ofstream, lecture et écriture s’organisent autour d’un même principe : un flux qui relie le programme au fichier.
L’article en bref
Les flux de fichiers permettent de conserver des données au-delà de l’exécution d’un programme. Ce guide explique comment choisir la bonne classe, ouvrir un fichier et vérifier les opérations.
- Choisir la bonne classe : ifstream lit, ofstream écrit, fstream combine les deux
- Préparer l’ouverture : définir chemin, usage et mode avant chaque accès
- Manipuler les données : lire ou écrire selon leur format et besoin
- Éviter les mauvaises surprises : contrôler les erreurs et fermer proprement le flux
Maîtriser ces bases, c’est donner à un programme une mémoire qui survit à sa fermeture.
Fstream en C++ : à quoi sert un flux de fichiers ?
Une variable en mémoire vive disparaît généralement lorsque le programme s’arrête. Pour conserver une configuration, un score ou un inventaire de jeu, il faut donc enregistrer ces informations dans un fichier : c’est là qu’intervient le flux de fichiers.
En C++, les flux font le lien entre le programme et une source ou une destination de données. L’en-tête <fstream> fournit trois classes courantes : ifstream pour lire, ofstream pour écrire et fstream pour effectuer les deux opérations. Un flux joue en quelque sorte le rôle d’un canal : le code envoie ou reçoit des données sans avoir à gérer directement les détails du disque.
Imaginons un petit jeu qui sauvegarde le nom du personnage et son niveau. Au prochain lancement, le programme relit ces valeurs depuis le fichier au lieu de repartir de zéro. L’idée essentielle est simple : les flux rendent les données persistantes, à condition de choisir le bon mode et de vérifier chaque étape.
ifstream, ofstream et fstream : choisir la classe adaptée
Les trois classes ont des rôles proches, mais leurs usages ne sont pas interchangeables. Choisir la plus adaptée rend le code plus lisible et évite certaines erreurs, comme ouvrir par mégarde un fichier à écrire alors qu’il fallait seulement le consulter.
| Classe | Usage principal | Exemple courant |
|---|---|---|
| std::ifstream | Lecture de fichiers | Charger une configuration existante |
| std::ofstream | Écriture de fichiers | Enregistrer un résultat ou un journal |
| std::fstream | Lecture et écriture | Consulter puis mettre à jour un fichier |
Le nom donne un bon indice : « i » renvoie à l’entrée, « o » à la sortie, et « f » à un fichier. Ces classes s’appuient sur les mécanismes de flux d’entrée et de sortie de la bibliothèque standard, adaptés ici aux fichiers du disque.
Pour une sauvegarde simple, ofstream suffit souvent à enregistrer les nouvelles données. Si le programme doit d’abord lire un fichier, puis le modifier, fstream peut convenir, à condition de bien choisir ses modes d’ouverture.
Ouverture de fichier en C++ : chemin et modes
Avant toute opération, le programme doit ouvrir le fichier. Il faut connaître son chemin, relatif ou absolu, et décider si l’objectif est la lecture, l’écriture ou les deux. Un chemin relatif dépend du répertoire depuis lequel le programme est lancé ; une différence qui explique bien des fichiers « introuvables ».
L’ouverture peut se faire au moment de construire le flux ou ensuite avec sa méthode open(). Par exemple, un objet de type ifstream peut être associé à « sauvegarde.txt » dès sa création. La forme générale de l’appel est le nom du fichier suivi d’un ou plusieurs modes d’ouverture.
Les modes les plus utiles sont les suivants :
- ios::in : ouvre le fichier pour la lecture.
- ios::out : ouvre le fichier pour l’écriture ; un fichier existant peut être remplacé selon le mode utilisé.
- ios::app : ajoute les nouvelles données à la fin du fichier.
- ios::ate : positionne le flux à la fin après l’ouverture, tout en permettant de se déplacer ensuite.
- ios::trunc : efface le contenu existant à l’ouverture.
- ios::binary : ouvre le fichier en mode binaire, utile pour des données non textuelles.
Les modes peuvent être combinés, par exemple avec l’opérateur « | ». Attention : ios::trunc remplace le contenu, tandis que ios::app le préserve et ajoute à la suite. Pour conserver une sauvegarde, ce choix compte autant que le nom du fichier.
Un flux fstream ouvert en lecture et écriture ne garantit pas à lui seul la création du fichier dans toutes les configurations. Pour créer un fichier neuf sans ambiguïté, il est souvent plus clair d’utiliser ofstream, puis de le rouvrir pour la lecture si nécessaire.
Lecture de fichiers et écriture de fichiers avec C++
Pour du texte, les opérateurs de flux rendent les premières manipulations très directes. Avec ofstream, l’opérateur d’insertion envoie des valeurs vers le fichier ; avec ifstream, l’opérateur d’extraction récupère des valeurs. Une sauvegarde contenant un nom et un niveau peut ainsi être écrite puis relue en quelques opérations.
La lecture avec l’opérateur d’extraction découpe habituellement le contenu selon les espaces. Pour récupérer une ligne complète, une fonction comme getline est plus adaptée : elle permet de conserver les espaces d’un nom ou d’un commentaire. Le format choisi à l’écriture doit donc correspondre à la méthode de lecture.
Pour les données binaires ou les blocs de taille connue, les fonctions read() et write() transfèrent des séquences d’octets. Les fonctions get() et put() servent respectivement à lire et écrire un caractère. Elles sont utiles dans des cas précis, mais les fichiers binaires demandent une attention particulière à la représentation des données et à leur compatibilité.
Dans l’exemple du jeu, une sauvegarde texte est facile à inspecter et à corriger à la main. Un format binaire peut être plus compact, mais il est moins lisible : mieux vaut choisir selon le besoin, pas seulement pour faire « plus technique ».
Quel que soit le format, le flux est généralement tamponné : les données peuvent transiter par une mémoire intermédiaire avant d’être effectivement écrites. Cette étape améliore les échanges, mais rappelle pourquoi il faut laisser le flux se terminer correctement.
Fermeture de fichier et gestion des erreurs
Un fichier est généralement fermé automatiquement lorsque son flux est détruit ou que le programme se termine. Appeler close() explicitement reste toutefois utile pour signaler clairement la fin des opérations et libérer la ressource plus tôt, notamment avant de rouvrir le même fichier.
La gestion des erreurs commence dès l’ouverture. Un chemin incorrect, des droits insuffisants ou un fichier absent peuvent empêcher l’opération ; il faut donc tester l’état du flux avant de lire ou d’écrire. Après l’écriture, vérifier aussi son état permet de repérer un disque plein ou un problème survenu pendant le transfert.
Quelques réflexes réduisent les risques lors de la manipulation des fichiers :
- Vérifier que l’ouverture a réussi avant de traiter le contenu.
- Éviter ios::trunc si les anciennes données doivent être conservées.
- Contrôler la lecture et l’écriture, surtout pour les sauvegardes importantes.
- Fermer explicitement le flux lorsque la tâche est terminée.
Pour un fichier critique, écrire directement par-dessus l’unique sauvegarde est risqué. Une stratégie plus robuste consiste à écrire dans un fichier temporaire, vérifier que l’opération a réussi, puis remplacer l’ancienne version.
Questions pratiques sur fstream en C++
Quelques précisions aident à éviter les erreurs fréquentes lorsqu’un programme commence à lire et modifier des fichiers.
Quelle différence entre fstream et ofstream ?
ofstream sert principalement à écrire dans un fichier. fstream permet d’associer lecture et écriture au même flux, selon les modes d’ouverture choisis.
Comment créer un fichier avec ofstream ?
Construisez un objet std::ofstream en lui passant le chemin du fichier, ou appelez open(). Vérifiez ensuite l’état du flux avant d’écrire.
ios::app et ios::ate font-ils la même chose ?
Non. ios::app force chaque écriture à la fin du fichier. ios::ate place le flux à la fin à l’ouverture, mais permet ensuite de changer sa position.
Faut-il toujours appeler close() ?
Le flux ferme automatiquement le fichier lorsqu’il est détruit. Appeler close() explicitement reste une bonne pratique lorsque les opérations sont terminées ou que le fichier doit être rouvert.
