HOWTO · C++
Comment lire un fichier ligne par ligne en C++
Dans cet article, nous explorerons quatre approches courantes pour lire un fichier ligne par ligne en C++ : l'utilisation d'ifstream avec getline(), la fonction getline() de la bibliothèque C, la fonction fgets() et istream_iterator.
Sur cette page
Lire un fichier ligne par ligne en C++ est une opération fondamentale dans de nombreuses tâches de programmation, telles que le traitement de données, l’analyse de texte et l’analyse de fichiers. Que vous travailliez avec de petits fichiers texte ou de grands ensembles de données, savoir comment accomplir cette tâche est important.
Dans cet article, nous explorerons quatre approches courantes pour lire un fichier ligne par ligne en C++ : l’utilisation d’ifstream avec getline(), la fonction getline() de la bibliothèque C, la fonction fgets() et istream_iterator.
Pourquoi lire un fichier ligne par ligne
Lire un fichier ligne par ligne est souvent préféré à le lire en une seule fois, en particulier lorsqu’il s’agit de fichiers volumineux. En traitant une ligne à la fois, vous pouvez gérer efficacement l’utilisation de la mémoire et manipuler des fichiers de pratiquement n’importe quelle taille.
Cette approche est particulièrement utile pour les tâches où vous devez traiter chaque ligne indépendamment, telles que l’analyse de fichiers CSV, le traitement de journaux ou l’analyse de texte.
Voici un exemple de fichier input.txt qui contient un texte d’exemple :
This is a sample input file.
It contains multiple lines of text.
Each line demonstrates a different scenario.
For example, this line contains numbers: 12345.
And this line has special characters: !@#$%^&*().
Utilisons ce fichier comme entrée pour tester les exemples de lecture de fichier dans les sections suivantes.
Comment lire un fichier ligne par ligne en C++ à l’aide d’ifstream avec la fonction getline()
Lorsqu’il s’agit de lire un fichier ligne par ligne en C++, l’une des méthodes les plus simples et les plus couramment utilisées consiste à utiliser la classe ifstream conjointement avec la fonction getline(). Cette approche offre simplicité et efficacité dans la gestion des entrées de fichier, ce qui en fait un choix privilégié pour de nombreux développeurs.
La fonction getline() fait partie de la bibliothèque standard C++ et est principalement utilisée pour lire des lignes à partir de flux d’entrée, tels que des fichiers ou l’entrée standard (cin).
Sa syntaxe est la suivante :
istream& getline(istream& is, string& str, char delim);
Où :
is: Flux d’entrée à partir duquel lire les caractères.str: Variable de chaîne dans laquelle les caractères extraits sont stockés.delim: Caractère délimiteur qui marque la fin de chaque ligne (la valeur par défaut est'\n').
La fonction getline() lit les caractères du flux d’entrée jusqu’à ce qu’elle rencontre le délimiteur spécifié ou atteigne la fin du flux. Elle stocke ensuite ces caractères dans la variable de chaîne fournie, en excluant le délimiteur lui-même.
Il est important de noter que getline() renvoie le flux d’entrée (is), ce qui permet d’enchaîner plusieurs opérations d’entrée.
Voyons maintenant un exemple démontrant comment lire un fichier ligne par ligne à l’aide d’ifstream avec getline() en C++ :
#include <fstream>
#include <iostream>
#include <string>
int main() {
std::ifstream file("input.txt");
if (!file.is_open()) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
std::string line;
while (std::getline(file, line)) {
std::cout << line << std::endl;
}
file.close();
return 0;
}
Dans cet exemple, nous commençons par inclure les fichiers d’en-tête nécessaires : <iostream>, <fstream> et <string>. Ceux-ci fournissent des fonctionnalités pour les entrées/sorties, le flux de fichiers et la manipulation de chaînes, respectivement.
Nous définissons ensuite la fonction main. À l’intérieur de la fonction main, une instance de std::ifstream nommée file est créée, qui représente le flux de fichier d’entrée.
Nous tentons ensuite d’ouvrir le fichier nommé "input.txt" à l’aide du constructeur du fichier. Si le fichier ne s’ouvre pas, un message d’erreur est imprimé sur le flux d’erreur standard (cerr), et le programme se termine avec un état non nul.
Ensuite, nous déclarons une variable de chaîne line pour stocker chaque ligne lue dans le fichier. Au sein de la boucle while, nous appelons de manière répétée std::getline() avec le flux de fichier (file) et la variable de chaîne (line) comme arguments.
Cette fonction lit une ligne du flux de fichier jusqu’à ce qu’elle atteigne la fin de la ligne ou la fin du fichier. Chaque ligne lue est ensuite imprimée sur le flux de sortie standard (cout).
Enfin, après avoir lu toutes les lignes du fichier, nous fermons le flux de fichier à l’aide de la méthode close() pour libérer les ressources système.
Sortie :
Cela démontre comment lire efficacement un fichier ligne par ligne en C++ à l’aide d’ifstream avec getline(), en fournissant une méthode claire et concise pour gérer les opérations d’entrée de fichier.
Comment lire un fichier ligne par ligne en C++ à l’aide de la fonction getline() de la bibliothèque C
En plus de la bibliothèque standard C++, les développeurs C++ peuvent également utiliser la fonction getline() fournie par la bibliothèque C pour lire un fichier ligne par ligne. Bien que cette fonction fonctionne légèrement différemment, elle offre une alternative viable pour gérer les opérations d’entrée de fichier.
La fonction getline() de la bibliothèque C est principalement utilisée pour lire des lignes à partir de flux d’entrée, de manière similaire à son homologue dans la bibliothèque standard C++. Sa syntaxe est la suivante :
ssize_t getline(char** lineptr, size_t* n, FILE* stream);
Ici,
lineptr: Un pointeur vers le tampon où la ligne sera stockée.n: Un pointeur vers la variable contenant la taille du tampon (qui sera redimensionnée si nécessaire).stream: Le flux de fichier à partir duquel lire la ligne.
Contrairement à la fonction getline() de la bibliothèque standard C++, la version de la bibliothèque C renvoie une valeur ssize_t indiquant le nombre de caractères lus ou -1 si une erreur se produit ou si la fin du fichier est atteinte.
Voyons un exemple démontrant comment lire un fichier ligne par ligne à l’aide de getline() de la bibliothèque C en C++ :
#include <cstdio>
#include <cstdlib>
#include <iostream>
int main() {
FILE* file = fopen("input.txt", "r");
if (!file) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
char* line = nullptr;
size_t len = 0;
ssize_t read;
while ((read = getline(&line, &len, file)) != -1) {
std::cout << line;
}
free(line);
fclose(file);
return 0;
}
En commençant par les fichiers d’en-tête nécessaires inclus : <iostream> pour les opérations d’entrée/sortie, <cstdio> pour les entrées/sorties de style C et <cstdlib> pour les fonctions d’allocation de mémoire.
Dans la fonction main, nous déclarons un pointeur FILE* nommé file et tentons d’ouvrir le fichier "input.txt" en mode lecture à l’aide de la fonction fopen(). Si le fichier ne s’ouvre pas, un message d’erreur est imprimé, et le programme se termine avec un état non nul.
Nous déclarons ensuite un pointeur de caractère line et une variable size_t len pour stocker chaque ligne lue dans le fichier et sa longueur, respectivement. Au sein de la boucle while, nous appelons de manière répétée getline() avec le flux de fichier (file), l’adresse du pointeur line et l’adresse de la variable len.
Cette fonction lit une ligne du flux de fichier, alloue dynamiquement de la mémoire si nécessaire et stocke la ligne dans le tampon pointé par line. Chaque ligne lue est ensuite imprimée sur le flux de sortie standard (cout).
Après avoir lu toutes les lignes du fichier, nous libérons la mémoire allouée dynamiquement pour le tampon line à l’aide de la fonction free() et fermons le flux de fichier à l’aide de la fonction fclose() pour libérer les ressources système.
Sortie :
Cela démontre une méthode alternative pour lire un fichier ligne par ligne en C++, en tirant parti de la fonction getline() de la bibliothèque C.
Comment lire un fichier ligne par ligne en C++ à l’aide de la fonction fgets()
Une autre méthode pour lire un fichier ligne par ligne en C++ consiste à utiliser la fonction fgets(), qui fait partie de la bibliothèque standard C. Bien que fgets() puisse sembler moins intuitive par rapport aux approches basées sur les flux en C++, elle offre simplicité et compatibilité avec les bases de code héritées ou les scénarios où les entrées/sorties de style C sont préférées.
La syntaxe de fgets() est la suivante :
char *fgets(char *str, int size, FILE *stream);
Ici,
str: Un pointeur vers le tableau de caractères (tampon) où la ligne sera stockée.size: Le nombre maximal de caractères à lire (y compris le terminateur nul).stream: Le flux de fichier à partir duquel lire la ligne.
La fonction renvoie str en cas de succès ou NULL si une erreur se produit ou si la fin du fichier est atteinte.
Poursuivons avec un exemple illustrant comment lire un fichier ligne par ligne à l’aide de fgets() en C++ :
#include <cstdio>
#include <iostream>
int main() {
FILE* file = fopen("input.txt", "r");
if (!file) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
char line[256];
while (fgets(line, sizeof(line), file) != NULL) {
std::cout << line;
}
fclose(file);
return 0;
}
Dans cet exemple, nous commençons par inclure les fichiers d’en-tête nécessaires : <iostream> pour les opérations d’entrée/sortie et <cstdio> pour les entrées/sorties de style C.
Au sein de la fonction main, nous déclarons un pointeur FILE* nommé file et tentons d’ouvrir le fichier "input.txt" en mode lecture à l’aide de la fonction fopen(). Si le fichier ne s’ouvre pas, un message d’erreur est imprimé, et le programme se termine avec un état non nul.
Nous définissons ensuite un tableau de caractères line d’une taille de 256 caractères pour stocker chaque ligne lue dans le fichier. Au sein de la boucle while, nous appelons de manière répétée fgets() avec le flux de fichier (file), l’adresse du tableau line et la taille du tableau.
Cette fonction lit une ligne du flux de fichier et la stocke dans le tampon line. Chaque ligne lue est ensuite imprimée sur le flux de sortie standard (cout).
Après avoir lu toutes les lignes du fichier, nous fermons le flux de fichier à l’aide de la fonction fclose() pour libérer les ressources système.
Sortie :
Cela présente une approche alternative pour lire un fichier ligne par ligne en C++. Bien que légèrement différente en syntaxe et en utilisation, fgets() fournit une option viable pour gérer les opérations d’entrée de fichier, offrant compatibilité et familiarité avec les paradigmes de programmation de style C.
Comment lire un fichier ligne par ligne en C++ à l’aide d’istream_iterator
Le istream_iterator fournit une manière élégante et moderne de lire des données à partir de flux d’entrée, y compris des fichiers, en traitant le flux comme une séquence d’éléments. Bien qu’il soit généralement utilisé pour lire des données formatées telles que des entiers ou des chaînes, il peut également être employé pour lire des lignes d’un fichier en traitant chaque ligne comme un élément de chaîne.
Cette approche offre concision et lisibilité dans le code, ce qui en fait un choix pratique pour de nombreux développeurs.
La syntaxe d’istream_iterator est la suivante :
istream_iterator<T> it(istream& is);
Ici,
T: Le type de données à lire.is: Le flux d’entrée à partir duquel lire les données.
Le constructeur d’istream_iterator initialise un itérateur (it) pour itérer sur les éléments extraits du flux d’entrée (is). Il est généralement utilisé en combinaison avec les opérateurs de déréférencement et d’incrémentation d’istream_iterator (*it et ++it, respectivement) pour accéder aux éléments du flux et avancer à travers eux.
Considérez l’exemple de code suivant démontrant comment lire un fichier ligne par ligne à l’aide d’istream_iterator en C++ :
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
int main() {
std::ifstream file("input.txt");
if (!file.is_open()) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
std::istream_iterator<std::string> it(file);
std::istream_iterator<std::string> end;
if (it == end) {
std::cerr << "Error: Empty file." << std::endl;
return 1;
}
std::cout << *it++;
while (it != end) {
std::cout << " " << *it++;
}
std::cout << std::endl;
file.close();
return 0;
}
En commençant par les fichiers d’en-tête nécessaires inclus : <iostream> pour les opérations d’entrée/sortie, <fstream> pour le flux de fichiers, <iterator> pour les opérations d’itérateur et <string> pour la manipulation de chaînes.
Dans la fonction main, nous déclarons un objet ifstream nommé file et tentons d’ouvrir le fichier "input.txt". Si le fichier ne s’ouvre pas, un message d’erreur est imprimé, et le programme se termine avec un état non nul.
Nous créons ensuite un istream_iterator nommé it, initialisé avec le flux de fichier file, pour lire des chaînes à partir du fichier. De plus, nous créons un itérateur de fin de flux nommé end pour désigner la fin du fichier.
Au sein de la boucle while, nous itérons sur le contenu du fichier à l’aide de l’itérateur it jusqu’à ce qu’il atteigne l’itérateur de fin de flux end. À chaque itération, nous déréférençons l’itérateur (*it) pour obtenir la ligne actuelle, nous l’affichons sur la console, puis nous avançons l’itérateur (++it).
Après avoir traité toutes les lignes du fichier, nous fermons le flux de fichier à l’aide de la méthode close() pour libérer les ressources système.
Sortie :
Cela démontre une méthode alternative pour lire un fichier ligne par ligne en C++, en tirant parti de l’istream_iterator pour traiter le contenu du fichier comme une séquence de chaînes. Cette approche fournit une solution moderne et concise pour gérer les opérations d’entrée de fichier, améliorant la lisibilité et la maintenabilité du code.
Conclusion
Nous avons exploré plusieurs méthodes pour lire un fichier ligne par ligne en C++, chacune offrant ses avantages et son adéquation en fonction des exigences et des préférences spécifiques du programmeur. Que ce soit en utilisant la fonction getline() de la bibliothèque standard C++, getline() de la bibliothèque C, fgets() ou istream_iterator, les développeurs disposent d’un éventail d’options parmi lesquelles choisir.
La fonction getline() dans les bibliothèques C++ et C fournit une approche simple, tandis que fgets() offre une compatibilité avec la programmation de style C. D’autre part, istream_iterator présente une solution moderne et concise pour itérer sur le contenu du fichier comme une séquence de chaînes.
Quel que soit la méthode choisie, l’objectif clé reste le même : lire efficacement et précisément le contenu d’un fichier ligne par ligne. En comprenant la syntaxe et la mécanique de chaque méthode, nous pouvons sélectionner l’approche la plus adaptée à nos projets, garantissant une gestion efficace des fichiers et une lisibilité optimale du code.