Gestion de fichiers en C++ : Maîtriser l'ouverture, lecture, écriture et fermeture

Qu'est-ce que la gestion de fichiers en C++ ?

La gestion de fichiers permet de persister les données du programme sur des dispositifs de stockage. En dirigeant la sortie du programme vers un fichier, vous pouvez effectuer des manipulations, analyses ou archivages ultérieurs sur ces données.

Un flux (stream) est une abstraction qui représente une source ou destination continue de caractères. C++ fournit une bibliothèque fstream robuste qui offre des classes et fonctions pour travailler aisément avec les fichiers.

Dans ce tutoriel, vous apprendrez :

• Définition de la gestion de fichiers en C++
• La bibliothèque fstream et ses classes
• Ouverture de fichiers dans divers modes
• Fermeture sécurisée des fichiers
• Écriture de données dans les fichiers
• Lecture de données depuis les fichiers

La bibliothèque fstream

La bibliothèque fstream fournit trois classes principales :

• ofstream – un flux de sortie pour créer et écrire des fichiers.
• ifstream – un flux d'entrée pour lire des fichiers existants.
• fstream – un flux combiné qui supporte à la fois les opérations d'entrée et de sortie.

Voici une référence visuelle rapide :

Pour utiliser ces classes, incluez l'en-tête fstream et, si vous souhaitez afficher sur la console, iostream également.

Comment ouvrir des fichiers

Avant toute opération sur fichier, le fichier doit être ouvert. Utilisez ofstream pour l'accès en écriture seule, ifstream pour la lecture seule, et fstream pour les deux. Chaque classe fournit un membre open() :

open(nom_fichier, mode);

• nom_fichier – le chemin ou le nom du fichier cible.
• mode – optionnel ; spécifie le type d'accès. Drapeaux courants :

Valeur	Description
ios::app	Mode ajout – les écritures sont ajoutées à la fin du fichier.
ios::ate	Ouvrir et chercher immédiatement à la fin.
ios::in	Ouvrir pour lecture.
ios::out	Ouvrir pour écriture.
ios::trunc	Tronquer un fichier existant à longueur zéro.

Plusieurs drapeaux peuvent être combinés en utilisant l'opérateur OR bit à bit (|).

Exemple 1 : Création d'un fichier

#include <iostream>
#include <fstream>
using namespace std;
int main() {
    fstream my_file;
    my_file.open("my_file", ios::out);
    if (!my_file) {
        cout << "File not created!";
    } else {
        cout << "File created successfully!";
        my_file.close();
    }
    return 0;
}

Sortie :

Capture d'écran du programme en cours d'exécution :

Parcours du code :

1. Inclure iostream pour les E/S console.
2. Inclure fstream pour les flux de fichiers.
3. Utiliser l'espace de noms std pour la brièveté.
4. Instancier un objet fstream nommé my_file.
5. Ouvrir le fichier en mode écriture (ios::out).
6. Vérifier l'ouverture réussie ; sinon signaler l'échec.
7. En cas de succès, afficher la confirmation et fermer le fichier.
8. Retourner 0 pour indiquer une terminaison normale.

Comment fermer des fichiers

Bien que C++ vide et ferme automatiquement les flux à la sortie du programme, fermer explicitement un fichier après sa dernière opération est considéré comme une bonne pratique.

Le membre close() est disponible sur fstream, ofstream et ifstream :

void close();

Comment écrire dans des fichiers

Les opérations d'écriture utilisent l'opérateur d'insertion de flux (<<). Le texte à stocker doit être entre guillemets ou passé directement en flux.

Exemple 2 : Écriture de texte

#include <iostream>
#include <fstream>
using namespace std;
int main() {
    fstream my_file;
    my_file.open("my_file.txt", ios::out);
    if (!my_file) {
        cout << "File not created!";
    } else {
        cout << "File created successfully!";
        my_file << "Guru99";
        my_file.close();
    }
    return 0;
}

Sortie :

Capture d'écran du code :

Parcours du code :

1. Inclure les en-têtes nécessaires.
2. Créer un objet fstream.
3. Ouvrir le fichier cible en mode écriture.
4. Valider le flux de fichier.
5. Insérer la chaîne "Guru99" dans le fichier.
6. Fermer le flux.
7. Retourner 0.

Comment lire depuis des fichiers

La lecture utilise l'opérateur d'extraction de flux (>>) comme cin. Les données sont lues dans des variables de types appropriés.

Exemple 3 : Lecture de caractères

#include <iostream>
#include <fstream>
using namespace std;
int main() {
    fstream my_file;
    my_file.open("my_file.txt", ios::in);
    if (!my_file) {
        cout << "No such file";
    } else {
        char ch;
        while (1) {
            my_file >> ch;
            if (my_file.eof()) break;
            cout << ch;
        }
    }
    my_file.close();
    return 0;
}

Sortie :

Capture d'écran du code en cours d'exécution :

Parcours du code :

1. Inclure iostream et fstream.
2. Ouvrir le fichier pour lecture (ios::in).
3. Vérifier l'existence ; si absent, notifier l'utilisateur.
4. Lire les caractères un par un jusqu'à EOF.
5. Afficher chaque caractère sur la console.
6. Fermer le flux.
7. Retourner 0.

Résumé

• La gestion de fichiers persiste la sortie du programme vers un stockage durable.
• Les flux abstraient les périphériques d'entrée et de sortie.
• La bibliothèque fstream fournit des classes pour toutes les opérations de fichiers courantes.
• Incluez toujours <fstream> (et <iostream> si nécessaire) au début de votre source.
• Ouvrez les fichiers avec les modes appropriés, effectuez les actions souhaitées, puis fermez les flux.