Este documento describe cómo trabajar con archivos de entrada y salida en C++. Explica que los archivos permiten almacenar datos de forma permanente en la memoria secundaria. Detalla los pasos para abrir, leer, grabar y cerrar archivos de texto usando la biblioteca fstream de C++.

2. Introducción
¿Qué es un archivo?
Archivos de texto
Operaciones asociadas a los archivos
Abrir
Leer y grabar datos
Cerrar
Biblioteca para archivos en C++

3. Vista General
Métodos para archivos de
entrada
Métodos para archivos de
salida
Programa de Aplicación
¿Cómo trabajar con archivos de
entrada ?
¿Cómo trabajar con archivos de
salida ?
Planteamiento del Problema

4. Hasta ahora, los datos de entrada
requeridos por un programa debían ser
introducidos a través del teclado, de tal
manera que cada vez que se ejecute el
programa, los datos deben ser
introducidos nuevamente.
• Los datos se mantienen en memoria
principal mientras se esta ejecutando el
programa, pero se pierden al terminar la
ejecución. Esto se debe, a que la
memoria principal es una memoria
temporal (volátil).

5. • La solución para no tener
que introducir los datos
por cada ejecución,
además de que los datos
no se pierdan, es
almacenarlos en memoria
secundaria (memoria
permanente) haciendo uso
de un archivo ó fichero.

6. • Es una estructura que facilita el
lenguaje, para almacenar los datos
en forma permanente (memoria
secundaria).
• La idea es que los datos sean
transferidos de la memoria principal
a una unidad de almacenamiento
secundario (memoria secundaria),
para posteriormente recuperarlos
y trabajar con ellos.

7. • Desde el punto de vista informático, un
archivo es una colección de datos que
están almacenamos en un soporte
magnético (disco duro, cd, pen drive,…),
para poder manipularlos en cualquier
momento.

8. Todo archivo tiene dos nombres:
nombre físico
nombre lógico
Nombre Físico: Es el nombre con el que se
identifica el archivo en el medio de
almacenamiento secundario (medio físico).
Este nombre es único.
Ejemplo: el nombre de una
persona en la partida de
nacimiento.

9. Nombre Lógico: Es el nombre con el que se
identifica el archivo dentro del programa que
trabajará con dicho archivo.
Un mismo archivo podría ser utilizado por
diferentes programas, y para cada programa
su nombre lógico podría ser distinto.
Ejemplo: Una persona puede tener diferentes
apodos, depende del sitio donde se encuentre
(en su casa, en su trabajo, con los amigos ...)
Desde el punto de vista informático es la
declaración de una variable tipo archivo.

10. Para C++
• ifstream: representa el tipo
de dato archivo de entrada
(i : input, f: file)
• ofstream: representa el tipo
de dato archivo de salida
(o : output, f: file)

11. • Uno de los tipos de archivos que soporta
C++ es el archivo de texto.
• Son aquellos archivos que
están expresados en formato
ASCII, no contienen
caracteres de control, por
tanto se puede ver su
información utilizando
comandos de sistema
operativo, cualquier editor o
procesador de textos.

12. • Los archivos de texto pueden utilizarse
para almacenamiento de datos que
posteriormente pueden ser manipulados
por otros programas, o también, salida de
resultados producidos por un programa
(reporte), que podrían ser enviados a una
impresora

13. • Entrada: Recuperan datos del archivo
para el programa (leer datos desde el
archivo)
• Salida: Envían datos del programa
hacia el archivo (escribir ó grabar datos
en el archivo)

14. • Abrir: Para que un programa pueda leer y/o
escribir datos en un archivo, este debe ser
abierto. Es la operación que relaciona el
nombre físico con el nombre lógico.
• Operación de Entrada: Leer datos desde el
archivo.
• Operación de Salida: Grabar datos en el
archivo.
• Cerrar: Cuando se haya terminado de
trabajar con el archivo, este debe ser cerrado.
Una vez que se haya cerrado no se podrá
seguir trabajando con él.

15. # include <fstream>
File stream
(archivo de stream)

16. Especificaciones Generales
• En el archivo de texto, una línea mantiene
un solo dato.
• Están implementados los métodos para
trabajar con archivos tipo texto de entrada y
salida.
• Incluye la librería fstream.
• Todos los métodos requieren como
parámetro el nombre lógico del archivo.
• Sólo el método que permite abrir el archivo
requiere dos parámetros que son: el nombre
físico y el nombre lógico.

17. /* Lee el nombre físico del archivo a nivel de
teclado y si es necesario se puede incluir la
ruta donde se localiza el archivo */
mensaje
void LeerNombreArchivo(string msj,
char V[128])
nombre físico
NOTA: Este método se utiliza para cualquier
archivo sea de entrada o de salida

18. /* Abre el archivo para entrada de datos.
Retorna true si la operación fue exitosa (abrió
el archivo), en caso contrario retorna false
(hubo error al abrir el archivo) */
nombre lógico
bool AbrirArchivoEntrada(std::ifstream &archivo,
char nombarch [128]);
nombre físico

19. /* Lee una linea que contiene un dato de tipo
alfanumérico (string), el cual es retornado y
debe ser asignado a una variable de tipo
(string) */
string LeerLineaArchivo (std::ifstream &archivo);
nombre lógico

20. /* Lee una linea que contiene un dato de tipo
alfanumérico (char), el cual es retornado y debe
ser asignado a una variable de tipo (char) */
char LeerDatoCharArchivo(std::ifstream &archivo);
nombre lógico

21. /* Lee una linea que contiene un dato de tipo
numérico sin decimales, el cual es retornado y
debe ser asignado a una variable int ó long */
long LeerDatoNroArchivo(std::ifstream &archivo);
/* Lee una linea que contiene un dato de tipo
numérico con decimales, el cual es retornado y
debe ser asignado a una variable de tipo float ó
double */
double LeerDatoNroDecimalArchivo(std::ifstream
&archivo);

22. /* Chequea si el apuntador del archivo llego al final,
retornando un dato bool. TRUE indica que ya llego
al final y FALSE no ha llegado al final */
bool FinArchivo (std::ifstream &archivo);
// Cierra el archivo de entrada
void CerrarArchivoEntrada (std::ifstream &archivo);

23. /* Abre el archivo para salida. Retorna true si
la operación fue exitosa, en caso contrario
retorna false (hubo error al crear el archivo) */
nombre lógico
bool AbrirArchivoSalida(std::ofstream &archivo,
char nombarch [128]);
nombre físico

24. // Graba en el archivo una linea de caracteres
void GrabarLineaArchivo(std::ofstream &archivo,
string linea);
// Graba en el archivo una línea con un dato char
void GrabarDatoCharArchivo(std::ofstream &archivo,
char dato);
/* Graba en el archivo una línea con un dato
numérico sin decimales (int, long) */
void GrabarDatoNroArchivo(std::ofstream &archivo,
long nro);

25. /* Graba en el archivo una línea con un dato
numérico con decimales (float, double)*/
void GrabarDatoNroDecimalArchivo
(std::ofstream &archivo, double nro);
// Cierra el archivo de salida
void CerrarArchivoSalida (std::ofstream &archivo);

26. Crear el archivo de texto con los datos
haciendo uso de cualquier editor.
En el controlador, específicamente en el
método donde se trabajará con el archivo de
entrada se debe:
• Declarar una variable de tipo ifstream
(nombre lógico)
ifstream nombrelogico;
Declarar una variable tipo:
char nombre_de_la_variable [número]
(variable que almacena el nombre físico)
char nombrefisico[128];

27. …en el método del controlador donde se
trabajará con el archivo de entrada se debe…
Leer el nombre físico del archivo, usando
el método LeerNombreArchivo(…) de
vista general
vista.LeerNombreArchivo(" nn Nombre
del archivo de Entrada: ",nombrefisico);
NOTA: Si el archivo de datos NO se encuentra en
la misma carpeta donde se esta ejecutando el
programa (carpeta Debug), DEBE indicarse la ruta
de su ubicación por ejemplo C:proydatos.txt en
caso contrario no hace falta.

28. …en el método del controlador donde se trabajará
con el archivo de entrada se debe…
Abrir el archivo, para ello debe invocar el
método de vista general que realiza esa
tarea. Ese método retorna un bool que sirve
para saber si la operación de apertura fue
exitosa o no.
if (!vista.AbrirArchivoEntrada(nombrelogico,nombrefisico))
{
vista.ImprimirMensaje("n ERROR:
No existe el archivo n");
vista.Pausa ();
return;
}

29. …en el método del controlador donde se
trabajará con el archivo de entrada se
debe…
Crear un ciclo que leerá los datos
del archivo, la condición de fin la
ejecuta el método
FinArchivo(nombrelogico)
de VGeneral.
while (!vista.FinArchivo (nombrelógico))
NOTA: Debemos declarar las variables que
recibirán los datos del archivo.

30. …en el método del controlador donde se
trabajará con el archivo de entrada en el
ciclo…
variable1= vista.LeerLineaArchivo(nombrelogico);
while (!vista.FinArchivo (nombrelógico))
{ /* Leer los datos del archivo que se corresponde con
la instancia del objeto */
::::::::::
variablen=vista.LeerDatoNroArchivo(nombrelogico);
/* … proceso que se requiere con los datos del archivo*/
variable1= vista.LeerLineaArchivo(nombrelógico);
} // fin del ciclo

31. …en el método del controlador donde se
trabajará con el archivo de entrada se debe…
Al finalizar el ciclo debemos cerrar el
archivo. La operación de cerrar la ejecuta el
método
CerrarArchivoEntrada(nombrelogico)
de VGeneral.
vista.CerrarArchivoEntrada(nombrelogico);
En este momento hemos culminado el trabajo
con el archivo de entrada.

32. En el controlador, específicamente en el
método donde se trabajará con el archivo de
salida se debe:
•Declarar una variable de tipo ofstream,
que representa el (nombre lógico)
ofstream nombrelogico;
Declarar una variable tipo:
char nombre_de_la_variable [número]
(variable que almacena el nombre físico)
char nombrefisico[128];

33. …en el método del controlador donde se
trabajará con el archivo de salida se debe…
Leer el nombre físico del archivo, usando
el método LeerNombreArchivo(…) de
vista general.
vista.LeerNombreArchivo(" nn Nombre
del archivo de Salida: ",nombrefisico);
NOTA: Si se requiere que el archivo se grabe en
un sitio distinto de donde se encuentra el
ejecutable del programa (carpeta Debug), se
DEBE indicar la ruta por ejemplo C:proysalida.txt
en caso contrario no hace falta.

34. …en el método del controlador donde se trabajará
con el archivo de salida se debe…
• Abrir el archivo, para ello debe invocar el
método de vista general que realiza esa
tarea. Ese método retorna un bool que sirve
para saber si la operación de apertura fue
exitosa o no.
if (!vista.AbrirArchivoSalida(nombrelogico,nombrefisico))
{
vista.ImprimirMensaje("n ERROR:
No se puede crear el archivo n");
vista.Pausa ();
return;
}

35. …en el método del controlador donde se
trabajará con el archivo de salida se debe…
Crear un ciclo donde se grabarán los datos
en el archivo.
do
{
/*proceso para obtener los datos que se grabarán
en el archivo */
::::::::::
vista.GrabarLineaArchivo(nombrelogico,variable1);
::::::::::
vista.GrabarDatoNroArchivo…..
} while (….);

36. …en el método del controlador donde se
trabajará con el archivo de salida se debe…
Al finalizar el ciclo debemos cerrar el
archivo. La operación de cerrar la ejecuta
el método
CerrarArchivoSalida(nombrelogico)
de VGeneral.
vista.CerrarArchivoSalida(nombrelogico);
En este momento hemos culminado el
trabajo con el archivo de salida.