Comment lire à partir d'un fichier en C++ | Udacité (2024)

Au cours de votre parcours de programmation, il viendra un moment où vous souhaiterez commencer à travailler avec des données du monde réel. Ce type de données est généralement stocké dans des fichiers sur disque. Étant donné que la lecture de fichiers implique une interaction avec votre système d’exploitation, cela constitue une tâche plutôt complexe. Dans cet article, nous examinerons les flux C++, la gestion des fichiers et trois méthodes différentes pour lire les données d'un fichier dans un programme C++.

Si vous venez d'un langage de programmation de haut niveau commePython, lire un fichier dans un programme semble être une tâche assez simple. Vous ouvrez le fichier, lisez son contenu et fermez-le. Travailler avec un fichier peut occuper une ou deux lignes de votre code. DansC++,le flux de travail de lecture d'un fichier est un peu plus complexe : il y a l'étape supplémentaire de lecture vers ou depuis un objet flux. Pour comprendre comment nos programmes C++ interagissent avec les fichiers, examinons maintenant le concept de flux en C++.

Les flux C++ sont des interfaces permettant de traiter les entrées et sorties de type séquence. Si vous avez écrit un"Bonjour le monde"programme en C++ auparavant, alors vous avez travaillé avec des flux. Voyons brièvement à quoi cela ressemblerait :

std::cout << "Bonjour tout le monde !\n" ;

Dans cet exemple, nous diffusons notre objet chaîne dans le flux de sortie de caractères (« cout » en abrégé). cout fait partie duiostreambibliothèque et une instance de la classe plus générale de flux de sortie (« ostream »). La classe sœur d'ostream est « istream », une classe permettant de gérer les flux d'entrée.

Lorsque nous travaillons avec des fichiers, nous employons une autre sous-classe de flux : lefstreamLa classe (pour le flux de fichiers) se compose de ifstreams pour l'entrée et de ofstreams pour la sortie dans un fichier. Pour cet exemple, nous travaillerons avec ifstreams, car ils nous permettent de lire à partir d'un fichier.

Pour lire une séquence de caractères à partir d’un fichier texte, nous devrons effectuer les étapes suivantes :

1. Créez un objet flux.
2. Connectez-le à un fichier sur le disque.
3. Lisez le contenu du fichier dans notre objet stream.
4. Fermez le fichier.
   

Les étapes que nous examinons en détail ci-dessous, s’inscrivent sous l’action de « gestion des fichiers ». À chaque étape, notre objet stream peut occuper différents états, que nous pouvons vérifier à l'aide des fonctions membres suivantes :

• bad() renvoie True si une erreur s'est produite lors de la lecture ou de l'écriture dans un flux. Si un flux est « mauvais », aucune autre opération impliquant le flux n’est possible.
• fail() renvoie True si une erreur se produit, mais nous pouvons toujours opérer sur le flux.
• eof() renvoie True si la fin du fichier (EOF) est atteinte, False dans le cas contraire.
• good() renvoie True si chacun des trois autres états est faux, c'est-à-dire que le flux n'est ni mauvais ni en échec, et n'a pas non plus atteint la fin du fichier.

Une autre méthode importante est fournie par is_open(). Il est évalué à True si un objet flux est ouvert. Rassemblons maintenant enfin tous les composants et lisons dans un fichier en C++.

Supposons que nous ayons une liste de courses stockée dans un fichier .txt :

oeufshameggs et spamspam et oeufs

Notre objectif est d’imprimer le contenu de la liste sur la console. Avant de commencer à écrire notre programme, incluons les fichiers d'en-tête pertinents :

#include #include #include 

Nous sommes maintenant prêts à écrire notre fonction. Déclarons d'abord notre variable fstream et connectons-la à un objet stream en ouvrant le fichier :

int main () {std::ifstream monfichier ; monfichier.open("shopping_list.txt");

À proprement parler, nous aurions pu effectuer cette action sur une seule ligne, en utilisant le constructeur de classe pour ouvrir le fichier directement lors de l'initialisation de l'objet stream :

int main () {std::ifstream monfichier ("shopping_list.txt"); // ceci est équivalent à la méthode ci-dessus

Avant de pouvoir lire le contenu du fichier dans notre flux, il ne nous reste plus qu'à déclarer une variable chaîne pouvant contenir le contenu :

std :: chaîne ma chaîne ;

Lire un fichier en C++ à l'aide de l'opérateur >>

Pour commencer, utilisons l'opérateur d'entrée de flux >> pour lire notre liste à partir du fichier.

if ( myfile.is_open() ) { // vérifie toujours si le fichier est openmyfile >> mystring; // redirige le contenu du fichier vers streamstd::cout << mystring; // redirige le contenu du flux vers la sortie standard}

Notez que le destructeur ifstream ferme automatiquement notre fichier, ce qui est l'un des avantages de l'utilisation de cette classe. Si nous le voulions, nous aurions pu ajouter une commande infile.close() à la fin du programme. Ceci est considéré comme une bonne pratique, mais cela n’apporte pas vraiment de valeur ajoutée.

Lorsque nous exécutons cette fonction, voici le résultat que nous obtenons à l’écran :

œufs

Ce n’est pas ce à quoi nous nous attendions. Notre fonction n'imprimait que le premier élément de notre liste de courses. En effet, l'opérateur >> lit une chaîne uniquement jusqu'à ce qu'elle rencontre un caractère d'espace blanc (comme un espace ou un saut de ligne). Pour lire le fichier en entier, nous pouvons placer la ligne dans une boucle while :

if ( monfichier.is_open() ) { while ( monfichier.good() ) {monfichier >> machaîne;std::cout << machaîne;} }

Une fois que nous atteignons la fin du fichier, myfile.good() est évalué à False, provoquant la fin de la boucle while. Nous pouvons abréger la condition comme suit :

while ( monfichier ) {

Cela revient à demander si notre fichier est bon. Comment notre code fonctionne-t-il maintenant ?

œufshonteœufssandspamspamamandeœufsœufs

Deux choses se sont produites ici : tous nos articles d'achat ont été enchaînés, le dernier article étant imprimé deux fois. Bien que ce dernier concerne la manière dont C++ gère les données mises en mémoire tampon et sorte du cadre de ce didacticiel, le premier était à prévoir. Après tout, >> ignore les espaces, ce qui signifie que tous les caractères d'espace et de nouvelle ligne sont perdus. Comment pouvons-nous inclure ces informations dans le résultat ? La réponse à cette question réside dans la fonction get().

Lire un fichier en C++ à l'aide de get()

Nous remplacerons >> par get(), une fonction membre de notre classe fstream qui lit un caractère à la fois. L’avantage de get() est qu’il n’ignore pas les espaces blancs et les traite plutôt comme une série de caractères ordinaires. Pour lire le contenu du fichier dans son intégralité, nous nous en tiendrons à notre boucle while :

if ( monfichier.is_open() ) {char monchar;while ( monfichier ) {monchar = monfichier.get();std::cout << monchar;}}

À quoi ressemble maintenant le résultat de notre petit script ?

oeufshameggs et spamspam et oeufs

Succès! Toute notre liste de courses a été imprimée sur la console. Pour démontrer que cette fonction diffuse réellement chaque caractère un par un, ajoutons une petite fonctionnalité qui nous indique la position du pointeur du flux après chaque sortie.

std::cout << ": " << monfichier.tellg() << ", " ;

Le nom de la fonction tellg() est l’abréviation de « tell get ». Il renvoie la position actuelle du pointeur lorsqu'il se déplace dans le flux d'entrée. Une fois le fichier entier parcouru, tellg() renvoie la valeur -1.

Regardons uniquement les deux premières lignes du résultat après avoir exécuté le code modifié :

e : 2, g : 3, g : 4, s : 5, : 6, h : 7, a : 8, m : 9,

Pour chaque action get(), la sortie standard affiche la lettre de l'entrée et la position du pointeur. Nous pouvons voir que chaque caractère a en effet été traité individuellement, ce qui amène le code à évaluer la position du pointeur après chaque caractère, qu'il s'agisse d'une lettre ou d'un espace blanc.

Lire un fichier en C++ à l'aide de getline()

Pour notre cas d’utilisation, cela ne sert à rien de traiter chaque caractère séparément – ​​après tout, nous voulons imprimer chaque ligne de notre liste de courses à l’écran une par une. Cela appelle getline(), une autre fonction membre, qui lit le texte jusqu'à ce qu'il rencontre un saut de ligne. Voici comment nous modifierions notre code :

std::string ma ligne;if ( monfichier.is_open() ) {while ( monfichier ) {std::getline (monfichier, ma ligne);std::cout << ma ligne << ": " << monfichier.tellg() < < '\n';}}

Et voici le résultat :

œufs : 5jambon : 9œufs et spam : 23spam et œufs : 37

La position du pointeur est désormais évaluée après chaque ligne lue par notre flux de fichiers.

Pour conclure, voici la version finale de notre script de lecture d'un fichier en C++ ligne par ligne :

#include #include #include int main (){std::ifstream myfile;myfile.open("shopping_list.txt");std::string myline;if ( myfile.is_open() ) {while ( monfichier ) { // équivalent à monfichier.good()std::getline (monfichier, ma ligne);std::cout << ma ligne << '\n';}}else {std::cout << "Impossible d'ouvrir le fichier\n";}renvoie 0 ; }

Ajouter une condition else, comme nous l'avons fait à la fin de ce script, est une bonne idée si vous rencontrez un fichier problématique. Au lieu de simplement se terminer sans un mot, le script vous dira qu'il n'a pas pu ouvrir le fichier.

Comme pour de nombreux aspects du langage C++, nous avons une autre classe pour lire et écrire dans des fichiers qui est un vestige du C, son prédécesseur. Les flux de style C sont codés dansDÉPOSERobjets de la bibliothèque cstdio. stdin et stdout sont des expressions de type FILE* pour gérer respectivement les flux d'entrée et de sortie.

Avec la lecture de fichiers de style C, la différence la plus importante par rapport à la classe fstream est que les objets FILE* ne ferment pas les fichiers à votre place : si vous oubliez de fermer votre fichier, il restera ouvert. C’est pourquoi les partisans de la classe fstream soutiennent qu’elle est plus sûre à utiliser.

Apprendre à lire les données d’un fichier dans votre programme est une étape importante pour tout aspirant programmeur C++. Mais ce n’est qu’une partie de l’équation.

Commencer à apprendre