Como anexar texto a um arquivo em C++

Trabalhar com arquivos é uma tarefa comum em programação, e o C++ fornece ferramentas poderosas para a manipulação de arquivos. Uma operação comum é anexar texto a um arquivo existente.

Este artigo explora vários métodos para fazer isso, oferecendo exemplos de código e explicações para ajudá-lo a entender o processo a fundo.

Utilize ofstream com a flag std::ios::app para anexar texto a um arquivo em C++

Em C++, a classe std::ofstream faz parte da Standard Template Library (STL) e é usada para escrever em arquivos. É uma excelente escolha quando você deseja criar, abrir, escrever ou anexar dados a arquivos de texto.

Além disso, a flag std::ios::app é um componente importante de std::ofstream. Quando usada, ela instrui o fluxo a abrir o arquivo em modo de anexação, o que significa que quaisquer dados que você escrever no fluxo serão adicionados ao final do conteúdo existente do arquivo.

Se o arquivo não existir, ele será criado.

Agora, para anexar texto a um arquivo em C++ utilizando std::ofstream com a flag std::ios::app, você pode seguir estes passos:

Aqui está um exemplo:

#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;
}

Neste exemplo, primeiro abrimos o arquivo example.txt em modo de anexação utilizando std::ios::app. Se o arquivo não existir, ele será criado.

Em seguida, anexamos o texto especificado ao arquivo utilizando o operador << e, por fim, fechamos o arquivo.

Certifique-se de verificar erros ao abrir o arquivo, como mostrado no exemplo, para lidar com os casos em que o arquivo não pode ser aberto.

Utilize fstream com a flag std::ios::app para anexar texto a um arquivo em C++

Semelhante à abordagem ofstream, você pode utilizar std::fstream com a flag std::ios::app para abrir um arquivo tanto para leitura quanto para anexação.

Em C++, a classe std::fstream faz parte da Standard Template Library (STL) e é usada para entrada e saída de arquivos. Também é uma excelente escolha quando você precisa criar, abrir, escrever ou anexar dados a arquivos de texto.

A flag std::ios::app é um componente vital de std::fstream. Quando aplicada, ela direciona o fluxo a abrir o arquivo em modo de anexação.

Neste modo, quaisquer dados escritos no fluxo serão adicionados ao final do conteúdo existente do arquivo. Se o arquivo não existir, ele será criado.

Para anexar texto a um arquivo em C++ utilizando std::fstream com a flag std::ios::app, você pode seguir estes passos:

Aqui está o exemplo completo:

#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;
}

Este código abrirá o arquivo em modo de anexação, anexará o texto especificado e, em seguida, fechará o arquivo.

Se o arquivo não existir, ele será criado. Se existir, o novo conteúdo será adicionado ao final do arquivo sem sobrescrever o conteúdo existente.

Utilize std::ofstream sem flags para anexar texto a um arquivo em C++

Agora, se você quiser criar um novo arquivo ou sobrescrever o conteúdo existente, pode utilizar std::ofstream sem nenhuma flag. Se o arquivo já existir, isso efetivamente limpará seu conteúdo e começará do zero.

Aqui está um exemplo básico:

#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;
}

Neste trecho de código, primeiro criamos um objeto std::ofstream chamado outputFile e especificamos o arquivo com o qual queremos trabalhar, neste caso, example.txt.

Utilize std::fstream e o método write() para anexar texto a um arquivo em C++

Outro método para resolver este problema é chamar explicitamente a função write do objeto fstream, em vez de utilizar o operador << como fizemos nos exemplos anteriores. Este método deve ser mais rápido para a maioria dos cenários, mas sempre trace um perfil de seu código e compare os tempos se você tiver requisitos rígidos de desempenho.

#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;
}

No código acima, abrimos o arquivo em modo de anexação (std::ios_base::app) utilizando o método open() do objeto fstream. Também verificamos se o arquivo foi aberto com sucesso utilizando file.is_open().

Em seguida, utilizamos o método write() para escrever o texto como dados binários no arquivo. Como podemos ver, este método recebe dois argumentos: um ponteiro para os dados e o número de bytes a serem escritos.

Por fim, imprimimos Done! para indicar que a operação foi concluída.

Conclusão

Cada método apresentado neste artigo oferece uma abordagem única para anexar texto a um arquivo. A escolha do método depende de seus requisitos específicos e de seu estilo de codificação.