Fichiers en C++ : du débutant au pro en 20 minutes

Fichiers en C++ : du débutant au pro en 20 minutes

Imagine que ton programme est un excellent cuisinier. Il sait cuisiner, mais tous les ingrédients doivent être apportés à la main, et les recettes disparaissent après chaque utilisation. Ça ne semble pas très pratique, n'est-ce pas ? C'est exactement pourquoi tout développeur qui se respecte doit savoir travailler avec les fichiers et le système de fichiers. En C++, ce n'est pas simplement « possible » — c'est une base, sans laquelle tu te sentiras mal à l'aise en tant que programmeur.

Aujourd'hui, nous allons analyser le travail avec les fichiers en C++ de manière à ce que tu ne te contentes pas de copier le code, mais que tu comprennes réellement ce qui se passe sous le capot. Pas de cours ennuyeux, avec des exemples concrets et des conseils pratiques. C'est parti !

Les flux — la base du travail avec les fichiers en C++

En C++, le travail avec les fichiers repose sur les flux. Si tu connais déjà cout et cin, considère que la moitié du travail est faite. Les flux de fichiers fonctionnent sur le même principe, sauf qu'au lieu de l'écran ou du clavier, les données sont envoyées vers un fichier ou chargées depuis celui-ci.

Les principaux acteurs sur le terrain :

\n
• ifstream — pour la lecture depuis un fichier (input file stream).
\n
• ofstream — pour l'écriture dans un fichier (output file stream).
\n
• fstream — un flux universel pour la lecture et l'écriture.
\n

Toutes ces classes se trouvent dans le fichier d'en-tête <fstream>. N'oublie pas de l'inclure, sinon le compilateur te le reprochera.

Comment ouvrir un fichier sans perdre la tête

Ouvrir un fichier en C++, c'est comme ouvrir une porte : il faut savoir où aller et pourquoi. Regardons un exemple simple d'ouverture d'un fichier pour l'écriture :

#include <iostream>\n#include <fstream>\n#include <string>\n\nint main() {\n    std::ofstream outFile("example.txt"); // On ouvre le fichier pour l'écriture\n    \n    if (outFile.is_open()) {\n        outFile << "Bonjour, fichier !" << std::endl;\n        outFile << "Ceci est la deuxième ligne." << std::endl;\n        outFile.close(); // On ferme le fichier\n        std::cout << "Écriture réussie !" << std::endl;\n    } else {\n        std::cerr << "Impossible d'ouvrir le fichier !" << std::endl;\n    }\n    \n    return 0;\n}\n

Remarque : on vérifie toujours si le fichier s'est ouvert avec is_open(). Si le fichier n'existe pas, ofstream le créera automatiquement. Et si cela ne fonctionne pas (par exemple, pas de droits d'écriture), le programme ne plantera pas, mais signalera une erreur.

Modes d'ouverture : quand un seul ne suffit pas

Par défaut, ofstream écrase le fichier, tandis que ifstream ne fait que lire. Mais que faire si tu veux ajouter des données à la fin du fichier ? Ou ouvrir le fichier pour la lecture et l'écriture simultanément ? C'est là que les drapeaux de mode entrent en jeu :

\n
• std::ios::in — ouvrir pour la lecture.
\n
• std::ios::out — ouvrir pour l'écriture (par défaut pour ofstream).
\n
• std::ios::app — ajouter à la fin du fichier (append).
\n
• std::ios::ate — déplacer le curseur à la fin lors de l'ouverture.
\n
• std::ios::binary — ouvrir en mode binaire.
\n

Exemple d'utilisation des modes :

std::ofstream logFile("log.txt", std::ios::app); // On ajoute à la fin\nif (logFile.is_open()) {\n    logFile << "Nouvelle entrée dans le journal" << std::endl;\n    logFile.close();\n}\n

Et si tu as besoin à la fois de lire et d'écrire, utilise fstream avec des drapeaux combinés :

std::fstream file("data.txt", std::ios::in | std::ios::out);\n

Lecture depuis un fichier : mot par mot et ligne par ligne

La lecture depuis un fichier en C++ est un art à part entière. On peut lire mot par mot, ligne par ligne, caractère par caractère. Le choix dépend de la tâche.

Lecture ligne par ligne (la méthode la plus populaire)

#include <fstream>\n#include <iostream>\n#include <string>\n\nint main() {\n    std::