Archivos

Es un conjunto de datos estructurados en una colección de entidades elementales o básicas

denominadas registros que son de igual tipo y constan a su vez de diferentes entidades de nivel más
bajos denominadas campos. Hay dos tipos de archivos, archivos de texto y archivos binarios.

Archivo de texto es una secuencia de caracteres organizadas en líneas terminadas por un carácter
de nueva línea. En estos archivos se pueden almacenar canciones, fuentes de programas, base de
datos simples, etc. Los archivos de texto se caracterizan por ser planos, es decir, todas las letras
tienen el mismo formato y no hay palabras subrayadas, en negrita, o letras de distinto tamaño o
ancho. Esto quiere decir, entre otras cosas, que toda la información almacenada en un archivo
de texto puede ser visualizada por un procesador de textos o un editor cualquiera

Archivo binario es una secuencia de bytes que tienen una correspondencia uno a uno con un
dispositivo externo. Así que no tendrá lugar ninguna traducción de caracteres. Además, el número
de bytes escritos (leídos) será el mismo que los encontrados en el dispositivo externo. Ejemplos de
estos archivos son Fotografías, imágenes, texto con formatos, archivos ejecutables (aplicaciones),
etc.

En C/C++ el manejo de ficheros es tan fácil de aplicar como si estuviéramos trabajando la entrada y
salida estándar (pantalla y teclado),
En el archivo de cabecera fstream.h se define las clases ifstream, ostream y fstream mediante
el uso de estas tendremos acceso a todas las funciones para manejo de archivo, operaciones de
lectura, escritura y lectura/escritura en archivos respectivamente.

 Para escribir en un fichero de texto (que se crearía automáticamente), utilizamos un fichero de

salida, ofstream y lo cerramos con close (al terminar)
 Para leer una línea de un fichero de texto (el archivo debe estar creado), utilizamos un fichero
de entrada, ifstream y lo cerramos con close (al terminar)
 Para comprobar si se ha podido abrir (y no intentar leer de un archivo inexistente) usaríamos
NULL. Para lo cual podríamos utilizar las siguientes validaciones.

if (fichero)

{ }

O la alternativa

if (fichero != NULL)

{ ... }

 Para leer todo el contenido del fichero, para comprobar si se ha podido abrir (y no intentar
leer de un fichero inexistente) usaríamos "eof", que típicamente usaremos dentro de un
bloque repetitivo "while" así:

while (! fichero.eof() )

{.. .}:
Ejemplo 1 (usando ofstream)

#include <conio.h>
#include <iostream>
#include <fstream>
using namespace std;

int main()
{
ofstream salida("TEXTO1.TXT"); // CREAR REFERENCIA AL ARCHIVO DE TEX
TO

if(salida == 0) // salida es igual cero cuando se produce un error,

por ejemplo, cuando se especifica una ruta que no existe
{
cout << "ERROR AL CREAR EL ARCHIVO.";
system("pause");
return 0;
}

// PARA ESCRIBIR EN UN ARCHIVO DE TEXTO SE HACE DE MANERA SIMILAR AL

COUT
salida << "Juan Lopez " << 4.56 << endl;
salida << "Carlos_Perez " << 3.38 << endl;
salida << "Maria_Jose "<< 4.27 << endl;

salida.close(); // FUNCION PARA CERRAR EL ARCHIVO DE TEXTO

cout<<"ARCHIVO CREADO";
getch();
return 0;
}

Ejemplo 2 (usando ifstream).

#include <conio.h>
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
char nombre[20];
float nota;

ifstream entrada("TEXTO1.TXT"); // ABRIR UN ARCHIVO DE TEXTO EN MODO

DE LECTURA

if(entrada == 0)
{
cout << "ERROR AL ABRIR EL ARCHIVO.";
getch();
return 0;
}
entrada >> nombre >> nota; // DEL ARCHIVO SE LEE DE MANERA SIMILAR
QUE CON EL CIN
 cout << nombre << " " << nota << endl;
entrada >> nombre >> nota;
cout << nombre << " " << nota << endl;
entrada >> nombre >> nota;
cout << nombre << " " << nota << endl;
getch();

entrada.close(); // CIERRA EL ARCHIVO

return 0;
}

Ejemplo 3 Programa que permite calcular el precio de venta de un producto y calcular la

inversión por producto y el inventario en existencia

#include <iostream>
#include <fstream>
#include <string.h>

using namespace std;

int main()
{
char op,descripcion[30];
long cu, inver, total=0;
int cant, tipo;

ofstream archivoS("venta.txt");
if(archivoS.fail()){
cout<<"Error al abrir archivo para crearlo"; system("pause");
exit(1);
}

do{
cout<<"Descripcion articulo: ";
fflush(stdin);gets(descripcion);
cout<<"Costo Unidad: $"; cin>>cu;
cout<<"Cantidad: "; cin>>cant;
inver = cu*cant;
archivoS<<descripcion <<";" <<cu <<";" <<cant <<";"<<inver
<<endl;
cout<<"Desea crear registro archivo: [S]i. [N]o ";
cin>>op;
}while(toupper(op) == 'S');
archivoS.close();

//abriendo el archivo
system("cls");
ifstream archivoE("venta.txt");
if(archivoE.fail()){
cout<<"Error al abrir archivo para abrirlo"; system("pause");
exit(1);
 }
int x=1;
cout<<"Descripcion \t Costo Unidad \t Cantidad \t Total Inversion
" <<endl;
archivoE>>descripcion;
while(!archivoE.eof()){
cout<<"Linea " <<x <<endl; x++;

cout<<descripcion <<endl;
total+=inver;
archivoE>>descripcion;

}
cout<<"Total Inventario $"<<total <<endl;
system("pause");
archivoE.close();
return 0;

QUE SUCEDE SI QUIERO CREAR MÁS QUE UNA SIMPLE SECUENCIA DE

CARACTERES EN UN ARCHIVO?
Usando los constructores ofstream e ifstream, al especificar la apertura de un archivo, el programa
sobreescribe cualquier archivo existente con el nombre del archivo que se indique, por ejemplo
texto1.txt o ventas.txt.

Dependiendo de la necesidad que se requiera del archivo, por ejemplo agregar datos a los ya
existentes en el archivo, es necesario especificar el modo de apertura del archivo incluyendo un
parámetro adicional en el constructor. A continuación los modos de apertura:

 ios::app Operaciones de añadidura.

 ios::ate Coloca el apuntador del archivo al final del mismo.
 ios::in Operaciones de lectura. Esta es la opción por defecto para objetos de la clase ifstream.
 ios::out Operaciones de escritura. Esta es la opción por defecto para objetos de la clase ofstream.
 ios::nocreate Si el archivo no existe se suspende la operación.
 ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operación se suspende.
 ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.
 ios::binary Operaciones binarias.

Si tomamos como referente el ejemplo 3, podemos modificar el modo de apertura del programa
ventas.cpp para que los datos del programa se concatenen en el archivo ventas.txt simplemente
escribiendo el constructor así: ofstream archivo("ventas.txt", ios::app);. Si deseamos que el
programa no sobreescriba un archivo existente especificamos el constructor de ésta manera:
ofstream archivo("ventas.txt", ios::noreplace);. Utilizando los especificadores de modo de
apertura se puede conseguir un mayor control en las operaciones de E/S en archivos.