En este módulo, aprenderemos cómo manejar archivos en C++. La capacidad de leer y escribir archivos es fundamental para muchas aplicaciones, desde el almacenamiento de datos hasta la configuración de programas. Este tema cubre los conceptos básicos de la entrada/salida de archivos en C++ utilizando las bibliotecas estándar.
Contenidos
Introducción a la Entrada/Salida de Archivos
En C++, la biblioteca estándar proporciona varias clases para manejar archivos, principalmente a través de las clases ifstream (entrada de archivo), ofstream (salida de archivo) y fstream (entrada/salida de archivo).
Clases de Archivo
ifstream: Utilizada para leer datos de un archivo.ofstream: Utilizada para escribir datos en un archivo.fstream: Utilizada para leer y escribir datos en un archivo.
Lectura de Archivos
Para leer un archivo en C++, utilizamos la clase ifstream. A continuación, se muestra un ejemplo básico de cómo leer un archivo línea por línea.
#include <iostream>
#include <fstream>
#include <string>
int main() {
std::ifstream inputFile("example.txt");
std::string line;
if (inputFile.is_open()) {
while (getline(inputFile, line)) {
std::cout << line << std::endl;
}
inputFile.close();
} else {
std::cerr << "No se pudo abrir el archivo." << std::endl;
}
return 0;
}Explicación del Código
- Incluir las Bibliotecas Necesarias:
#include <iostream>,#include <fstream>,#include <string>. - Abrir el Archivo:
std::ifstream inputFile("example.txt");. - Leer el Archivo Línea por Línea:
while (getline(inputFile, line)). - Cerrar el Archivo:
inputFile.close();.
Escritura de Archivos
Para escribir en un archivo, utilizamos la clase ofstream. Aquí hay un ejemplo básico de cómo escribir en un archivo.
#include <iostream>
#include <fstream>
int main() {
std::ofstream outputFile("output.txt");
if (outputFile.is_open()) {
outputFile << "Esta es una línea de texto." << std::endl;
outputFile << "Esta es otra línea de texto." << std::endl;
outputFile.close();
} else {
std::cerr << "No se pudo abrir el archivo." << std::endl;
}
return 0;
}Explicación del Código
- Abrir el Archivo:
std::ofstream outputFile("output.txt");. - Escribir en el Archivo:
outputFile << "Texto" << std::endl;. - Cerrar el Archivo:
outputFile.close();.
Apertura y Cierre de Archivos
Es importante abrir y cerrar archivos correctamente para evitar pérdidas de datos y liberar recursos del sistema.
Apertura de Archivos
- Modo de Lectura:
std::ifstream inputFile("example.txt"); - Modo de Escritura:
std::ofstream outputFile("output.txt"); - Modo de Lectura/Escritura:
std::fstream file("example.txt", std::ios::in | std::ios::out);
Cierre de Archivos
- Utilizar el método
close():inputFile.close();,outputFile.close();.
Modos de Apertura de Archivos
Los archivos pueden abrirse en diferentes modos, que se especifican utilizando las banderas de la biblioteca <fstream>.
| Modo | Descripción |
|---|---|
std::ios::in |
Abre el archivo para lectura. |
std::ios::out |
Abre el archivo para escritura. |
std::ios::app |
Añade los datos al final del archivo. |
std::ios::ate |
Mueve el puntero al final del archivo al abrirlo. |
std::ios::trunc |
Trunca el archivo si existe. |
std::ios::binary |
Abre el archivo en modo binario. |
Ejemplo de Uso de Modos
#include <iostream>
#include <fstream>
int main() {
std::ofstream outputFile("output.txt", std::ios::app);
if (outputFile.is_open()) {
outputFile << "Añadiendo una nueva línea al final del archivo." << std::endl;
outputFile.close();
} else {
std::cerr << "No se pudo abrir el archivo." << std::endl;
}
return 0;
}Ejercicios Prácticos
Ejercicio 1: Lectura de Archivo
Escribe un programa que lea un archivo llamado data.txt y muestre su contenido en la consola.
Ejercicio 2: Escritura de Archivo
Escribe un programa que solicite al usuario ingresar varias líneas de texto y las guarde en un archivo llamado user_input.txt.
Ejercicio 3: Copia de Archivo
Escribe un programa que copie el contenido de un archivo llamado source.txt a otro archivo llamado destination.txt.
Soluciones
Solución Ejercicio 1
#include <iostream>
#include <fstream>
#include <string>
int main() {
std::ifstream inputFile("data.txt");
std::string line;
if (inputFile.is_open()) {
while (getline(inputFile, line)) {
std::cout << line << std::endl;
}
inputFile.close();
} else {
std::cerr << "No se pudo abrir el archivo." << std::endl;
}
return 0;
}Solución Ejercicio 2
#include <iostream>
#include <fstream>
#include <string>
int main() {
std::ofstream outputFile("user_input.txt");
std::string line;
if (outputFile.is_open()) {
std::cout << "Ingrese líneas de texto (escriba 'exit' para terminar):" << std::endl;
while (true) {
std::getline(std::cin, line);
if (line == "exit") break;
outputFile << line << std::endl;
}
outputFile.close();
} else {
std::cerr << "No se pudo abrir el archivo." << std::endl;
}
return 0;
}Solución Ejercicio 3
#include <iostream>
#include <fstream>
#include <string>
int main() {
std::ifstream sourceFile("source.txt");
std::ofstream destinationFile("destination.txt");
std::string line;
if (sourceFile.is_open() && destinationFile.is_open()) {
while (getline(sourceFile, line)) {
destinationFile << line << std::endl;
}
sourceFile.close();
destinationFile.close();
} else {
std::cerr << "No se pudo abrir uno de los archivos." << std::endl;
}
return 0;
}Resumen
En este módulo, hemos aprendido cómo manejar archivos en C++ utilizando las clases ifstream, ofstream y fstream. Hemos cubierto cómo abrir, leer, escribir y cerrar archivos, así como los diferentes modos de apertura de archivos. Los ejercicios prácticos proporcionados te ayudarán a reforzar estos conceptos y a desarrollar tus habilidades en la manipulación de archivos en C++.
Curso de Programación en C++
Módulo 1: Introducción a C++
- Introducción a C++
- Configuración del Entorno de Desarrollo
- Sintaxis y Estructura Básica
- Variables y Tipos de Datos
- Entrada y Salida
Módulo 2: Estructuras de Control
Módulo 3: Funciones
- Introducción a las Funciones
- Parámetros de Función y Tipos de Retorno
- Sobrecarga de Funciones
- Recursión
Módulo 4: Arreglos y Cadenas
- Introducción a los Arreglos
- Arreglos Multidimensionales
- Introducción a las Cadenas
- Manipulación de Cadenas
Módulo 5: Punteros y Referencias
- Introducción a los Punteros
- Aritmética de Punteros
- Punteros y Arreglos
- Referencias
- Asignación Dinámica de Memoria
Módulo 6: Programación Orientada a Objetos
- Introducción a la POO
- Clases y Objetos
- Constructores y Destructores
- Herencia
- Polimorfismo
- Encapsulación y Abstracción
Módulo 7: Temas Avanzados
- Plantillas
- Manejo de Excepciones
- Entrada/Salida de Archivos
- Biblioteca Estándar de Plantillas (STL)
- Expresiones Lambda
- Multihilo