Cómo añadir texto a un archivo en C++

Trabajar con archivos es una tarea común en la programación, y C++ proporciona herramientas potentes para la manipulación de archivos. Una operación común es añadir texto a un archivo existente.

Este artículo explora múltiples métodos para lograrlo, ofreciendo ejemplos de código y explicaciones que le ayudarán a comprender el proceso a fondo.

Añadir texto a un archivo en C++ usando ofstream con el indicador std::ios::app

En C++, la clase std::ofstream forma parte de la Standard Template Library (STL) y se utiliza para escribir en archivos. Es una excelente opción cuando desea crear, abrir, escribir o añadir datos a archivos de texto.

Además, el indicador std::ios::app es un componente importante de std::ofstream. Cuando se utiliza, indica al flujo que abra el archivo en modo de adición, lo que significa que cualquier dato que escriba en el flujo se añadirá al final del contenido existente del archivo.

Si el archivo no existe, se creará.

Ahora bien, para añadir texto a un archivo en C++ utilizando std::ofstream con el indicador std::ios::app, puede seguir estos pasos:

Aquí tiene un ejemplo:

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

En este ejemplo, primero abrimos el archivo example.txt en modo de adición utilizando std::ios::app. Si el archivo no existe, se creará.

A continuación, añadimos el texto especificado al archivo utilizando el operador << y, por último, cerramos el archivo.

Asegúrese de comprobar si hay errores al abrir el archivo, como se muestra en el ejemplo, para manejar los casos en los que el archivo no se puede abrir.

Añadir texto a un archivo en C++ usando fstream con el indicador std::ios::app

Al igual que con el enfoque de ofstream, puede utilizar std::fstream con el indicador std::ios::app para abrir un archivo tanto para lectura como para adición.

En C++, la clase std::fstream forma parte de la Standard Template Library (STL) y se utiliza para la entrada y salida de archivos. También es una excelente opción cuando necesita crear, abrir, escribir o añadir datos a archivos de texto.

El indicador std::ios::app es un componente vital de std::fstream. Cuando se aplica, indica al flujo que abra el archivo en modo de adición.

En este modo, cualquier dato escrito en el flujo se añadirá al final del contenido existente del archivo. Si el archivo no existe, se creará.

Para añadir texto a un archivo en C++ utilizando std::fstream con el indicador std::ios::app, puede seguir estos pasos:

Aquí está el ejemplo 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á el archivo en modo de adición, añadirá el texto especificado y luego cerrará el archivo.

Si el archivo no existe, se creará. Si existe, el nuevo contenido se añadirá al final del archivo sin sobrescribir el contenido existente.

Añadir texto a un archivo en C++ usando std::ofstream sin indicadores

Ahora, si desea crear un archivo nuevo o sobrescribir el contenido existente, puede utilizar std::ofstream sin ningún indicador. Si el archivo ya existe, esto borrará efectivamente su contenido y empezará con una pizarra en blanco.

Aquí tiene un ejemplo 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;
}

En este fragmento de código, primero creamos un objeto std::ofstream llamado outputFile y especificamos el archivo con el que queremos trabajar, en este caso, example.txt.

Añadir texto a un archivo en C++ usando std::fstream y el método write()

Otro método para resolver este problema es llamar explícitamente a la función miembro write desde el objeto fstream en lugar de usar el operador << como hemos hecho en los ejemplos anteriores. Este método debería ser más rápido para la mayoría de los escenarios, pero siempre perfila tu código y compara los tiempos si tienes requisitos de rendimiento estrictos.

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

En el código anterior, abrimos el archivo en modo de adición (std::ios_base::app) utilizando el método open() del objeto fstream. También hemos comprobado si el archivo se abrió correctamente utilizando file.is_open().

A continuación, utilizamos el método write() para escribir el texto como datos binarios en el archivo. Como podemos ver, este método toma dos argumentos: un puntero a los datos y el número de bytes a escribir.

Por último, imprimimos Done! para indicar que la operación se había completado.

Conclusión

Cada método presentado en este artículo ofrece un enfoque único para añadir texto a un archivo. La elección del método depende de sus requisitos específicos y de su estilo de programación.