ARCHIVOS BINARIOS

La informacin contenida en el archivo no es

legible para el usuario.
El proceso de lectura y escritura es mas rpido,
ya que la grabacin en el archivo es directamente
a partir del contenido de la memoria (no es
necesario la conversin).
Un archivo binario ocupa menos espacio en el
disco que un archivo tipo texto.
Este tipo de archivo es menos vulnerable.
Todas las funciones vistas en archivo tipo texto es
valido en un archivo binario.
ARCHIVOS BINARIOS
Para abrir un archivo binario es usa el manipulador
binary en la funcin open.
Ejemplos:
ofstream file;
fstream arch;
file.open(costos.dat,ios:binary);
//Abre el archivo para salida en modo binario

arch.open(leyes.dat,ios::out | ios::in | ios::binary);
//Abre el archivo para entrada o salida en modo binario
LECTURA Y ESCRITURA
Lectura
<Nombre Objeto>.read(&variable,num);
Donde: num, es la cantidad de bytes que lee del archivo y lo
almacena en la variable.

#include <fstream.h>
int main()
{ ifstream f1; char c;
f1.open(Alfa.dat,ios::in | ios::binary);
f1.read(&c,sizeof(char));
}
LECTURA Y ESCRITURA
Escritura
<Nombre Objeto>.write(&variable,num);
Donde: num, es la cantidad de bytes que escribe en el
archivo el valor que se encuentra en la direccion de
memoria de la variable.

#include <fstream.h>
int main()
{ ifstream f1; char c;
f1.open(Alfa.dat,ios::out | ios::binary);
f1.write(&c,sizeof(char));
}
EJEMPLOS DE APLICACIN
//Programa para manejo de archivos Binarios
#include <fstream.h>
#include <iostream>
using namespace std;
const int Max=15;
int main()
{ int i,k;
char mFile[Max]="Prueba.dat";
char c;
ofstream F1; // Crea el objeto Archi para escritura
F1.open(mFile,ios::out|ios::binary); // Abre un archivo con un nombre externo
ifstream F2;
if(F1.fail())
{ cout<<"No dispone de suficiente espacio en Disco\n";
exit(1);
}
CONTINUACION...
else
{ cout<<"El archivo se abrio con exito para escritura\n";
for(i=1;i<=17;i++)
F1.write(&i,sizeof(int));
F1.close();
}
F2.open("Prueba.dat",ios::in|ios::binary); F2.read(&k,sizeof(int));
while(!F2.eof())
{ cout<<k<<" ";
F2.read(&k,sizeof(int));
}
cout<<endl;
F2.close();
}
APLICACIN DE NOTAS
//Programa que almacena los datos de N alumnos y luego lo muestra
#include <fstream.h>
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int M=15,N=25;
int main()
{ char mFile[M]="NotaBina.dat"; float n1,n2,n3,prom;
char cod[8],ApePat[N],ApeMat[N],Nom[N],obs[11];
ifstream F2; // Crea el objeto Archi para Lectura
ofstream F1; // Crea el objeto Archi para Escritura
F1.open(mFile,ios::out|ios::binary); // Abre un archivo
if(F1.fail())
{ cout<<"El Archivo no se puede abrir con exito\n"
<<"Verifique si el archivo existe"<<endl; exit(1);
}
CONTINUACION...
cout<<"El archivo se abrio con exito para Escritura\n";
cout<<"Codigo o Enter para finalizar..... ";gets(cod);
for(;strlen(cod)!=0;)
{ cout<<"Apellido Paterno:";gets(ApePat);
cout<<"Apellido Materno:";gets(ApeMat);
cout<<"Nombres :";gets(Nom);
cout<<"Nota 1 :";cin>>n1;
cout<<"Nota 2 :";cin>>n2;
cout<<"Nota 3 :";cin>>n3;
prom=(n1+n2+n3)/3;
if(prom>10.5)
strcpy(obs,"Aprobado");
else
strcpy(obs,"Desaprobado");
F1.write(&cod,sizeof(cod)); F1.write(&ApePat,sizeof(ApePat));
F1.write(&ApeMat,sizeof(ApeMat));
CONTINUACION...
F1.write(&Nom,sizeof(Nom));F1.write(&n1,sizeof(n1));
F1.write(&n2,sizeof(n2));F1.write(&n3,sizeof(n3));
F1.write(&prom,sizeof(prom));F1.write(&obs,sizeof(obs));
cout<<"Codigo o Enter para finalizar..... ";gets(cod);
}
//Cerrando el archivo
F1.close();
F2.open(mFile,ios::in|ios::binary);
cout<<"Codigo\tApellidos y
Nombres\tEvaluaciones\tPromedio\tObserv.\n";
F2.read(&cod,sizeof(cod));
while(!F2.eof())
{ F2.read(&ApePat,sizeof(ApePat));
F2.read(&ApeMat,sizeof(ApeMat));
F2.read(&Nom,sizeof(Nom));F2.read(&n1,sizeof(n1));
CONTINUACION...
F2.read(&n2,sizeof(n2));F2.read(&n3,sizeof(n3));

F2.read(&prom,sizeof(prom));F2.read(&obs,sizeof(ob
s));

cout<<cod<<"\t"<<ApePat<<"\t"<<ApeMat<<"\t"<<No
m<<"\t"<<n1<<"\t"
<<n2<<"\t"<<n3<<"\t"<<prom<<"\t"<<obs<<endl;
F2.read(&cod,sizeof(cod));
}
//Cerrando el archivo
F2.close();
OPERADOR REINTERPRET_CAST
C++ proporciona este operador para realizar
conversiones mediante cast no estandar o
conversion cast estandar.
La sintaxis es la siguiente:

reinterpret_cast <char *>(&variable), sizeof(Variable)
La misma es utilizada con las instrucciones read y
write en la nueva version del Dev C++.
PROBLEMAS DE APLICACION
#include <iostream>
#include <fstream>
#include <stdio.h>
#define T reinterpret_cast <char *>
using namespace std;
char A[]="RBina.txt";
class Fichero
{
private:
int n;
float *x;
public:
Fichero(){}
Fichero(int);
~Fichero();
void Read();
void VerLista();
void Escribir();
void Find();
};

CONTINUACION
int main()
{ int m;
cout<<"Tamao del Vector:";cin>>m;
// Fichero P;
Fichero Q=Fichero(m);
Q.Read();
Q.Escribir();
Q.VerLista();
Q.Find();
}

Fichero::Fichero(int a)
{
n=a;
x=new float [n];
}
CONTINUACION
Fichero::~Fichero()
{ cout<<"Arrego sera eliminado"<<endl;
delete []x;
}
void Fichero::Read()
{ int i; for(i=0;i<n;i++)
{cout<<"Ruido["<<i<<"]:"; cin>>x[i];
}
}
void Fichero::Escribir()
{ int i,k=1; ofstream F1;
F1.open(A,ios::out | ios::binary);
for(i=0;i<n;i++)
{ F1.write(T (&k),sizeof(k));
F1.write(T (&x[i]),sizeof(x[i])); k++;
}
F1.close();
}
CONTINUACION
void Fichero::VerLista()
{ int i,k;
float y;
ifstream F1;
F1.open(A,ios::in | ios::binary);
F1.read(T (&k),sizeof(k));
while(!F1.eof())
{F1.read(T (&y),sizeof(y));
cout<<k<<"\t"<<y<<endl;
F1.read(T (&k),sizeof(k));
}
F1.close();
}
CONTINUACION
void Fichero::Find()
{ int i,k;
float y,my;
bool t=false;
ifstream F1;
F1.open(A,ios::in | ios::binary);
cout<<"Ingrese dato a buscar:";cin>>my;
while(!F1.eof() && !t)
{ F1.read(T (&k),sizeof(k));
F1.read(T (&y),sizeof(y));
if(y==my)
{ cout<<k<<"\t"<<y<<endl;
t=true;
}
}
if(!t)
cout<<"Dato buscado no existe"<<endl;
F1.close();
}