Comment écrire dans un fichier en C++

Pour écrire du texte courant dans un fichier, utilisez std::ofstream avec l’opérateur d’insertion (<<). Ouvrez le fichier avec std::ios::app pour ajouter des données à la fin, ou avec std::ios::trunc pour remplacer son contenu. Si le nombre de caractères ou d’octets est connu, utilisez la fonction membre write d’un flux ; fwrite est l’alternative correspondante en C.

Comprendre les flux de fichiers en C++

Les flux de fichiers relient un programme C++ à un fichier nommé. Incluez <fstream> et créez un std::ofstream pour écrire ; utilisez std::fstream lorsque le même flux doit servir à la lecture et à l’écriture. L’opérateur d’insertion convient à l’écriture de texte formaté, et un caractère de nouvelle ligne dans la chaîne commence une nouvelle ligne dans le fichier. Vérifiez l’état du flux après l’ouverture et l’écriture : un chemin qui semble valide peut être inaccessible, ou l’espace de stockage peut manquer.

Exécutez cet exemple :

#include <fstream>
#include <iostream>

int main() {
    std::ofstream file("example.txt");
    if (!file) {
        std::cerr << "Could not open example.txt\n";
        return 1;
    }

    file << "Hello, C++!\n";
    file << "File output is ready.\n";
    file.close();
    if (!file) {
        std::cerr << "Could not finish writing example.txt\n";
        return 1;
    }

    std::cout << "Wrote example.txt\n";
    return 0;
}

Wrote example.txt

Le message est affiché dans la console ; les deux lignes écrites avec file sont enregistrées dans example.txt. Ouvrez ce fichier dans un éditeur de texte pour en examiner le contenu. Un std::ofstream ouvert en écriture seule crée le fichier si son répertoire parent existe et efface généralement le contenu précédent à l’ouverture.

Écrire dans des fichiers selon différents modes

Le mode d’ouverture détermine ce qu’il advient des données déjà présentes. std::ios::app place chaque écriture à la fin du fichier, ce qui convient aux journaux et aux enregistrements à conserver au fil du temps. Si le fichier n’existe pas, son ouverture en écriture peut le créer, sous réserve que le chemin et les permissions le permettent. L’exemple autonome suivant écrit une ligne en mode ajout ; il n’est pas nécessaire que example.txt existe déjà.

#include <fstream>
#include <iostream>

int main() {
    std::ofstream file("example.txt", std::ios::app);
    if (!file) {
        std::cerr << "Could not open example.txt\n";
        return 1;
    }

    file << "A new log entry\n";
    file.close();
    if (!file) {
        std::cerr << "Could not finish writing example.txt\n";
        return 1;
    }
    return 0;
}

Le cas d’exécution fourni s’est terminé avec succès et n’a produit aucune sortie dans la console. Le code écrit A new log entry suivi d’un caractère de nouvelle ligne ; si le fichier contient déjà des données, cette ligne vient après.

Écrire et remplacer le contenu d’un fichier avec ios::trunc

std::ios::trunc efface le contenu précédent d’un fichier à son ouverture. Ouvrir un std::ofstream en écriture sans std::ios::app produit généralement le même effet ; indiquez std::ios::trunc pour rendre ce choix explicite. N’utilisez aucune de ces options si les anciennes données doivent être conservées.

#include <fstream>
#include <iostream>

int main() {
    std::ofstream file("example.txt", std::ios::trunc);
    if (!file) {
        std::cerr << "Could not open example.txt\n";
        return 1;
    }

    file << "Current report\n";
    file.close();
    if (!file) {
        std::cerr << "Could not finish writing example.txt\n";
        return 1;
    }
    return 0;
}

Le cas d’exécution fourni s’est terminé avec succès et n’a produit aucune sortie dans la console. Le code écrit uniquement Current report suivi d’un caractère de nouvelle ligne dans example.txt, en remplaçant tout contenu antérieur.

Écrire dans un fichier avec fstream::write

Utilisez la fonction membre de flux write lorsque les données se trouvent déjà dans un tampon de caractères et que leur longueur est connue. Elle prend un pointeur vers des caractères et le nombre de caractères à écrire ; elle n’ajoute ni caractère de fin ni nouvelle ligne. Ce nombre est une taille de flux : passer data.size() écrit les caractères stockés dans la chaîne, sans inclure de caractère nul final. Vérifiez l’état du flux après l’appel pour détecter un échec d’écriture. Consultez la documentation cppreference de basic_ostream::write pour connaître son interface.

#include <fstream>
#include <iostream>
#include <string>

int main() {
    const std::string data = "C++ buffer data\n";
    std::fstream file("buffer.txt", std::ios::out | std::ios::trunc);
    if (!file) {
        std::cerr << "Could not open buffer.txt\n";
        return 1;
    }

    file.write(data.data(), static_cast<std::streamsize>(data.size()));
    if (!file) {
        std::cerr << "Could not write buffer.txt\n";
        return 1;
    }
    file.close();
    if (!file) {
        std::cerr << "Could not finish writing buffer.txt\n";
        return 1;
    }
    return 0;
}

Le cas d’exécution fourni s’est terminé avec succès et n’a produit aucune sortie dans la console. Il écrit les caractères de data dans buffer.txt ; la nouvelle ligne fait partie de la chaîne, tandis qu’aucun caractère nul final n’est écrit.

L’écriture de caractères et l’écriture d’octets se distinguent par le fait que les données sont ou non mises en forme. L’opérateur d’insertion convertit les valeurs en texte, tandis que write et fwrite copient les octets du tampon sans les mettre en forme. Copier les octets ne suffit pas à garantir qu’ils parviennent inchangés dans le fichier : un flux ouvert en mode texte peut encore traduire les caractères de nouvelle ligne sur les plateformes qui utilisent une fin de ligne différente, comme Windows, qui convertit \n en \r\n à l’écriture. Lorsque les octets exacts comptent, ouvrez le flux en mode binaire, par exemple avec std::ios::out | std::ios::binary | std::ios::trunc, ou passez "wb" au lieu de "w" à fopen, afin qu’aucune traduction n’ait lieu.

Écrire dans un fichier avec la fonction C fwrite

Pour les entrées-sorties de style C, fwrite prend un pointeur, la taille d’un élément, le nombre d’éléments et un FILE*. Sa valeur de retour indique le nombre d’éléments écrits, et non le nombre d’octets, sauf si chaque élément a une taille de un. Vérifiez ce nombre, puis fermez le fichier et vérifiez aussi le résultat de fclose : des erreurs d’écriture tamponnée peuvent apparaître lors de la fermeture.

#include <cstdio>
#include <cstring>
#include <iostream>

int main() {
    const char data[] = "C file output\n";
    const std::size_t size = std::strlen(data);
    std::FILE* file = std::fopen("c-output.txt", "w");
    if (file == nullptr) {
        std::cerr << "Could not open c-output.txt\n";
        return 1;
    }

    const std::size_t written = std::fwrite(data, 1, size, file);
    const int close_status = std::fclose(file);
    if (written != size || close_status != 0) {
        std::cerr << "Could not finish writing c-output.txt\n";
        return 1;
    }
    return 0;
}

Le cas d’exécution fourni s’est terminé avec succès et n’a produit aucune sortie dans la console. Le code écrit les caractères de data, y compris sa nouvelle ligne, dans c-output.txt ; le mode "w" crée le fichier ou efface son contenu antérieur.

Conclusion

Pour du texte courant, utilisez std::ofstream et <<. Choisissez std::ios::app pour conserver le contenu existant et ajouter les nouvelles données à la fin, ou std::ios::trunc pour le remplacer. Utilisez write pour un tampon de longueur connue, et fwrite si vous travaillez avec les entrées-sorties de style C. Vérifiez l’ouverture et l’écriture, ainsi que les erreurs de fermeture lorsque le programme doit s’assurer que les données ont bien été écrites.

FAQ

1. Comment savoir si un fichier s’est ouvert ? Vérifiez directement le flux (if (!file)) ou appelez is_open() juste après l’ouverture. Traitez l’échec avant toute écriture.

2. Comment ajouter des données sans remplacer le contenu existant ? Ouvrez un flux de sortie avec std::ios::app. Chaque écriture est alors dirigée vers la fin du fichier.

3. C++ peut-il créer un fichier qui n’existe pas ? Les flux de sortie et fopen en mode "w" peuvent le créer si le répertoire parent existe et si le processus en a la permission. L’ouverture échoue si le répertoire parent manque ou si les permissions sont insuffisantes.

4. Comment écrire plusieurs lignes ? Insérez des caractères de nouvelle ligne avec <<, ou incluez-les dans le tampon passé à write. Ni write ni fwrite n’ajoute automatiquement de fin de ligne.

5. Faut-il fermer le fichier ? Un flux de fichier se ferme lors de sa destruction, mais appeler explicitement close() peut clarifier le moment où l’écriture est terminée. Si la réussite complète de l’écriture est importante, vérifiez l’état du flux après la fermeture. Pour un FILE* en C, appelez fclose et vérifiez sa valeur de retour.