TEORIA:

ARCHIVOS SECUENCIALES EN C++.

C++ provee las siguientes clases para realizar operaciones de entrada y salida de caracteres hacia
o desde archivos:
 ofstream: El flujo para escribir archivos.
 iftream: El flujo para leer archivos.
 fstream: Flujo de lectura/escritura sobre archivos.
El uso de estas nuevas clases será exactamente al uso de cin y cout, con la única diferencia, de que
debemos asociar estos flujos a archivos físicos.
Lectura/escritura en archivos
Las funciones read y write se usan para leer y escribir en un descriptor de archivo que previamente
hayamos abierto. Sus prototipos son los siguientes:
arch.read( void *buf, size_t nbytes);
arch.write( void *buf, size_t num);

Cerrar el archive
Cuando terminemos de usar el archivo debemos cerrarlo, asi nuestro programa devolverá el
recurso al sistema operativo nuevamente. Para hacerlo nos valemos de la función miembro close()
esta función no toma parámetros y lo que hace es terminar de escribir todo lo que haya quedado
en los buffers y luego cerrar el archivo:
MiArchivo.close()

ARCHIVOS DE ACCESO DIRECTO O ALEATORIO.

Los archivos de acceso directo también llamados aleatorios se posicionan directamente en

EJEMPLO:
1. Crear y guardar archivo ejemplo txt.
Abrir el archivo guardado anteriormente.
Copiar el archivo de texto en otro.

#include <iostream>
#include <cstdlib>
#include <fstream>
using namespace std;

int main()
{
//ofstream miarchivo;
//miarchivo.open("ejemplo.txt");
//miarchivo <<"Primera linea"<<endl;
//miarchivo << "Segunda linea ejemplo"<<endl;
// miarchivo << "Fin de lineas"<<endl;
//miarchivo.close();

//fstream archivo("ejemplo.txt",ios::in);
// char linea [128];
// int contador=0;
//if(archivo.fail())
// cout<< "Error al Abrir el Archivo \n";
// else{
//while(!archivo.eof()){
//archivo.getline(linea,sizeof(linea));
// cout<<linea<<endl;
// if((++contador %24)==0){
// cout<< "Priosene una tecla para continuar";
// cin.get();
// }
// }
//}
// archivo.close();
ifstream origen("ejemplo.txt");
char linea[128];
if(origen.fail()){
cout<< "Error al abrir el archivo \n";
}
else {
ofstream destino("copia.txt",ios::out);
if (destino.fail())
cout<< "Error al Abrir archivo destino \n";
 else{
while(!origen.eof()){
origen.getline(linea,sizeof(linea));
if (origen.good())
if(origen.eof())
exit(1);
else
destino<< linea <<endl;
if(destino.fail()){
cout<< "Error en Escritura \n";
exit(1);
}
}
}
destino.close();
}
origen.close();
return 0;
}

2.Crear un archivo de registros que contengan el nombre y 4 datos de tipo entero. El programa
debe crear el archivo (una sola vez), insertar registros, mostrar uno o todos los registros y eliminar
un registro (borrado lógico).

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
class empleado{
public:
char nombre [20];
 float salario;
bool existe;
};
const int N=10;
empleado planilla[N];

int main()
{
ofstream archivo("arch.dat");
strcpy(planilla[0].nombre,"Jose Flores");
planilla[0].salario=1111.12;
planilla[0].existe=false;
strcpy(planilla[1].nombre,"Maria Cabrera");
planilla[1].salario=2222.12;
planilla[1].existe=true;
strcpy(planilla[2].nombre,"Carlos Castro");
planilla[2].salario=3333.12;
planilla[2].existe=true;
archivo.write((char *)planilla,N *sizeof(empleado));
cout<< "Archivo Creado"<<endl;
archivo.close();

ifstream salida("arch.dat");
salida.read((char *)planilla,N *sizeof(empleado));
cout<< "Los datos de Empleados"<<endl;
for(int i=0;i<3;i++){
if(planilla[i].existe)
cout<<planilla[i].nombre<< "Salario : "<<planilla[i].salario<<endl;
}
salida.close();
return 0;
}
 PROBLEMAS PROPUESTOS.

 Escribir una aplicación que permita crear un archivo directo con nombre “guía.dat”, con los
siguientes campos carnet del tipo int, apellidos del tipo char[25], nombres del tipo char[25] y fono
del tipo int. Esta aplicación debe permitir almacenar información y visualizar toda su información.

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
const int N=3;
class Registro
{
public:
int carnet;
char apellidos[25];
char nombres[25];
int fono;
};
int main()
{
ofstream archivo("guía.dat",ios::binary);
Registro planilla[N];
planilla[0].carnet=12345;
strcpy(planilla[0].apellidos,"Flores");
strcpy(planilla[0].nombres,"Jose");
 planilla[0].fono=11111111;
planilla[1].carnet=67890;
strcpy(planilla[1].apellidos,"Cabrera");
strcpy(planilla[1].nombres,"Maria");
planilla[1].fono=22222222;
planilla[2].carnet=54321;
strcpy(planilla[2].apellidos,"Castro");
strcpy(planilla[2].nombres,"Carlos");
planilla[2].fono=33333333;
archivo.write(reinterpret_cast<char*>(planilla),N *sizeof(Registro));
cout<<"Archivo Creado"<<endl;
archivo.close();
ifstream salida("guía.dat",ios::binary);
salida.read(reinterpret_cast<char*>(planilla),N *sizeof(Registro));
cout<<"Los datos de la guia"<<endl;
for(int i=0;i<N;i++)
{
cout<<"Carnet: "<<planilla[i].carnet<<endl;
cout<<"Apellido: "<<planilla[i].apellidos<<endl;
cout<<"Nombre: "<<planilla[i].nombres<<endl;
cout<<"Telefono: "<<planilla[i].fono<<endl;
cout<<endl;
}
salida.close();
return 0;
}
 Escribir una aplicación que permita crear un archivo directo con nombre “alumno.dat”, con los
siguientes campos matricula del tipo int, apellido del tipo char[25], nombres del tipo char[25] y
carrera del tipo char[15]. Esta aplicación debe permitir almacenar información y visualizar toda
su información además el registro que uno desee, mostrar un listado por carrera.

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
const int registros=3;
class Alumno
{
public:
int matricula;
char apellido[25];
char nombres[25];
char carrera[15];
};
int main()
{
ofstream archivo("alumno.dat",ios::binary);
 Alumno alumnos[registros];
alumnos[0].matricula=12345;
strcpy(alumnos[0].apellido,"Flores");
strcpy(alumnos[0].nombres,"Jose");
strcpy(alumnos[0].carrera,"Ing. Industrial");
alumnos[1].matricula=67890;
strcpy(alumnos[1].apellido,"Cabrera");
strcpy(alumnos[1].nombres,"Maria");
strcpy(alumnos[1].carrera,"Ing. Mecatronica");
alumnos[2].matricula=54321;
strcpy(alumnos[2].apellido,"Castro");
strcpy(alumnos[2].nombres,"Carlos");
strcpy(alumnos[2].carrera,"Ing. Civil");
archivo.write(reinterpret_cast<char*>(&alumnos),registros *sizeof(Alumno));
cout<<"Archivo Creado"<<endl;
archivo.close();
ifstream entrada("alumno.dat", ios::binary);
entrada.read(reinterpret_cast<char*>(&alumnos),registros *sizeof(Alumno));
cout<<"Los datos de los alumnos"<<endl;
for (int i=0;i<registros;i++)
{
cout<<"Matricula: "<<alumnos[i].matricula<<endl;
cout<<"Apellido: "<<alumnos[i].apellido<<endl;
cout<<"Nombre: "<<alumnos[i].nombres<<endl;
cout<<"Carrera: "<<alumnos[i].carrera<<endl;
cout<<endl;
}
entrada.close();
return 0;
}