Comment ajouter du texte à un fichier en C++

Travailler avec des fichiers est une tâche courante en programmation, et C++ fournit des outils puissants pour la manipulation de fichiers. Une opération courante consiste à ajouter du texte à un fichier existant.

Cet article explore plusieurs méthodes pour y parvenir, en proposant des exemples de code et des explications pour vous aider à bien comprendre le processus.

Ajouter du texte à un fichier en C++ à l’aide de ofstream avec l’indicateur std::ios::app

En C++, la classe std::ofstream fait partie de la Standard Template Library (STL) et est utilisée pour écrire dans des fichiers. C’est un excellent choix lorsque vous souhaitez créer, ouvrir, écrire ou ajouter des données dans des fichiers texte.

De plus, l’indicateur std::ios::app est un composant important de std::ofstream. Lorsqu’il est utilisé, il indique au flux d’ouvrir le fichier en mode ajout, ce qui signifie que toutes les données que vous écrivez dans le flux seront ajoutées à la fin du contenu existant du fichier.

Si le fichier n’existe pas, il sera créé.

Maintenant, pour ajouter du texte à un fichier en C++ à l’aide de std::ofstream avec l’indicateur std::ios::app, vous pouvez suivre ces étapes :

Voici un exemple :

#include <fstream>
#include <iostream>

int main() {
  // File path
  std::string filePath = "example.txt";

  // Open the file in append mode
  std::ofstream outputFile(filePath, std::ios::app);

  if (!outputFile) {
    std::cerr << "Failed to open the file for appending." << std::endl;
    return 1;
  }

  // Text to append to the file
  std::string textToAppend = "This is some appended text.";

  // Append the text to the file
  outputFile << textToAppend << std::endl;

  // Close the file
  outputFile.close();

  std::cout << "Text appended to the file successfully." << std::endl;

  return 0;
}

Dans cet exemple, nous avons d’abord ouvert le fichier example.txt en mode ajout à l’aide de std::ios::app. Si le fichier n’existe pas, il sera créé.

Nous avons ensuite ajouté le texte spécifié au fichier à l’aide de l’opérateur <<, puis nous avons fermé le fichier.

Veillez à vérifier les erreurs lors de l’ouverture du fichier, comme le montre l’exemple, afin de gérer les cas où le fichier ne peut pas être ouvert.

Ajouter du texte à un fichier en C++ à l’aide de fstream avec l’indicateur std::ios::app

Comme avec l’approche ofstream, vous pouvez utiliser std::fstream avec l’indicateur std::ios::app pour ouvrir un fichier à la fois en lecture et en ajout.

En C++, la classe std::fstream fait partie de la Standard Template Library (STL) et est utilisée pour les entrées et sorties de fichiers. C’est également un excellent choix lorsque vous devez créer, ouvrir, écrire ou ajouter des données dans des fichiers texte.

L’indicateur std::ios::app est un composant essentiel de std::fstream. Lorsqu’il est appliqué, il indique au flux d’ouvrir le fichier en mode ajout.

Dans ce mode, toutes les données écrites dans le flux seront ajoutées à la fin du contenu existant du fichier. Si le fichier n’existe pas, il sera créé.

Pour ajouter du texte à un fichier en C++ à l’aide de std::fstream avec l’indicateur std::ios::app, vous pouvez suivre ces étapes :

Voici l’exemple complet :

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

int main() {
  // Open the file in append mode
  std::fstream file("example.txt", std::ios::app);

  // Check if the file is opened successfully
  if (!file.is_open()) {
    std::cerr << "Error opening the file!" << std::endl;
    return 1;  // Exit with an error code
  }

  // Text to append
  std::string textToAppend = "This is the text to append.";

  // Append text to the file
  file << textToAppend << std::endl;

  // Close the file
  file.close();

  return 0;
}

Ce code ouvrira le fichier en mode ajout, ajoutera le texte spécifié, puis fermera le fichier.

Si le fichier n’existe pas, il sera créé. S’il existe, le nouveau contenu sera ajouté à la fin du fichier sans écraser le contenu existant.

Ajouter du texte à un fichier en C++ à l’aide de std::ofstream sans indicateurs

Maintenant, si vous souhaitez créer un nouveau fichier ou écraser le contenu existant, vous pouvez utiliser std::ofstream sans aucun indicateur. Si le fichier existe déjà, cela effacera effectivement son contenu et vous repartirez d’une page blanche.

Voici un exemple de base :

#include <fstream>
#include <iostream>

int main() {
  // Creating a new file or overwriting existing content
  std::ofstream outputFile("example.txt");

  // Checking if the file is successfully opened
  if (outputFile.is_open()) {
    outputFile << "This will overwrite existing content.\n";
    outputFile.close();  // Always close the file when done
  } else {
    std::cerr << "Unable to open the file.\n";
  }

  return 0;
}

Dans cet extrait de code, nous avons d’abord créé un objet std::ofstream nommé outputFile et spécifié le fichier avec lequel nous voulons travailler, dans ce cas, example.txt.

Ajouter du texte à un fichier en C++ à l’aide de std::fstream et de la méthode write()

Une autre méthode pour résoudre ce problème consiste à appeler explicitement la fonction membre write à partir de l’objet fstream plutôt que d’utiliser l’opérateur << comme nous l’avons fait dans les exemples précédents. Cette méthode devrait être plus rapide pour la plupart des scénarios, mais il faut toujours profiler votre code et comparer les temps si vous avez des exigences strictes en matière de performances.

#include <fstream>
#include <iostream>

using std::cout;
using std::endl;
using std::fstream;
using std::string;

int main() {
  string text("Some huge text to be appended");
  string filename("tmp.txt");
  fstream file;

  file.open(filename, std::ios_base::app);
  if (file.is_open()) file.write(text.data(), text.size());
  cout << "Done!" << endl;

  return EXIT_SUCCESS;
}

Dans le code ci-dessus, nous avons ouvert le fichier en mode ajout (std::ios_base::app) à l’aide de la méthode open() de l’objet fstream. Nous avons également vérifié si le fichier a été ouvert avec succès à l’aide de file.is_open().

Ensuite, nous avons utilisé la méthode write() pour écrire le texte sous forme de données binaires dans le fichier. Comme nous pouvons le voir, cette méthode prend deux arguments : un pointeur vers les données et le nombre d’octets à écrire.

Enfin, nous avons affiché Done! pour indiquer que l’opération était terminée.

Conclusion

Chaque méthode présentée dans cet article offre une approche unique pour ajouter du texte à un fichier. Le choix de la méthode dépend de vos besoins spécifiques et de votre style de codage.