DE
FICHEROS
Contenido
___________________________________________________________________________
9.1.- Introduccin .
9.2.- Archivos C++.
9.2.1.- Apertura de ficheros.
9.2.2.- Cierre de ficheros.
9.2.3.- Deteccin de fin de fichero y otras funciones.
9.2.4.- Comprobacin de apertura correcta.
9.3.- Lectura/Escritura en ficheros de texto.
9.3.1.- Avance del cursor.
9.3.2.- Ficheros de texto.
9.4.- Ficheros binarios.
9.4.1.- Utilidad de los ficheros binarios.
9.4.2.- Lectura/Escritura byte a byte.
9.4.3.- Lectura/Escritura por bloques de bytes.
9.5.- Acceso aleatorio a ficheros.
9.6.- Ficheros pasados como argumentos.
9.7.- Ejemplos de utilizacin de ficheros binarios y de texto.
Ejercicios.
___________________________________________________________________________
En este captulo vamos a tratar la gestin bsica de ficheros (tambin llamados archivos) en C++
y lo haremos a partir del concepto de flujo.
Vamos a estudiar cmo declarar los identificadores que establecen el modo de flujos de los
ficheros (de entrada o salida bsicamente) y procuraremos no entrar en el concepto de clase de
manera que la gestin de ficheros resulte asimilable por el alumno con los conceptos aprendidos
hasta el momento.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 1
9.1.- INTRODUCCION.
En este tema se vern las caractersticas bsicas que nos permitirn trabajar con ficheros
(tambin llamados archivos).
Todos los programas vistos hasta ahora trabajaban con informacin almacenada en
memoria principal, no obstante, hay situaciones en que esto no es apropiado. Algunas de esas
situaciones podran ser:
* Los datos con los que necesita trabajar el programa son demasiado grandes (ocupan
mucha memoria) para que entren en la memoria principal.
Definicin de Fichero:
En los temas anteriores hemos visto que los datos de entrada o salida en un programa
C++ son obtenidos o enviados directamente a travs de lo que llamamos flujos de entrada o
salida. Hasta hora hemos manejado los flujos estndares cin y cout, y una serie de operadores
(<< y >>) y funciones (como get o getline por ejemplo) disponibles a partir de la biblioteca
iostream y que son tiles para la entrada/salida de la informacin.
En C++ un fichero es simplemente un flujo externo que se puede abrir para entrada
(dando lugar a un flujo de archivo de entrada que, para simplificar, llamaremos simplemente
archivo o fichero de entrada), para salida (dando lugar a un flujo de archivo de salida que,
para simplificar, llamaremos simplemente archivo o fichero de salida) o para entrada-salida
(archivo o fichero de entrada-salida o archivo de E/S).
C++ soporta dos tipos de archivos: de texto y binarios. Los primeros almacenan datos
como cdigos ASCII. Los valores simples, tales como nmeros y caracteres estn separados
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 2
por espacios. Los segundos almacenan bits de forma directa y se necesita usar la direccin de
una posicin de almacenamiento.
#include <fstream.h>
Antes de que un programa pueda manipular un fichero para leer o escribir informacin se
debe abrir (o crear si es necesario) el fichero para identificar la posicin del mismo en el
programa (o sea, la direccin de memoria a partir de la cual almacenaremos o leeremos el
contenido del fichero). Ya hemos indicado anteriormente que los archivos son tratados como
flujos de entrada/salida por lo que, al igual que sucede con los flujos estndares y por defecto
cin y cout, la informacin debe ser transferida en una sola direccin por lo que, salvo en
ciertos casos, los ficheros deben abrirse bien para entrada o bien para salida.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 3
En ambos casos descriptor es una variable que se asocia al fichero cuyo nombre es
nombre.extensin.
Comentario:
Observe que a partir de la apertura de un fichero, el descriptor del fichero ser utilizado en
todas las operaciones que se realicen sobre el fichero (OJO! no utilizamos el nombre
original del fichero).
Otra forma de abrir un fichero para operar sobre l consiste en crear primero el flujo de
entrada asociado al mismo, o sea, en asociar una variable descriptor a un fichero en una
forma similar a como se declara una variable en C++, es decir, mediante una sentencia tal
como
y, posteriormente, abrir el fichero (en el modo deseado: de entrada o salida por ejemplo)
mediante el uso de la funcin open aplicada a ese flujo de entrada, o sea en la forma
descriptor.open(nombre.extensin,int modo);
donde la variable modo indica el modo de apertura del fichero y los modos de apertura,
posiblemente combinados mediante el smbolo | como veremos a continuacin, pueden ser:
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 4
1. Modo salida, usando ios::out. En este caso todos los datos en el fichero se
descartan (o sea, se borra el contenido del fichero si existe previamente).
Naturalmente si el fichero no existe lo crea. En ambos casos el cursor del fichero (o
sea, la cabeza de lectura/escritura del mismo) se posiciona al principio del fichero.
Este es el modo por defecto de apertura de un fichero de salida.
2. Modo aadir, usando ios::app. En este caso los datos adicionales se aaden a
partir del final del fichero (o sea, el cursor se sita al final del fichero y es ah a
partir de donde se empieza a realizar la escritura).
Tambin se pueden combinar las dos formas anteriormente vistas de forma que el descriptor
de fichero es declarado a la vez que el fichero es abierto. Para ello empleamos las siguientes
declaraciones (segn el fichero se abra para entrada o para salida):
Ejemplo 1:
Las dos lneas siguientes abren el fichero mio.txt como fichero de entrada (para lectura) y
lo asocian al descriptor in.
Ejemplo 2:
Para abrir el fichero salida.dat en modo salida (si el fichero no existe lo crea, y si existe
borra su contenido) asocindolo al descriptor out podemos usar la siguiente sentencia;
ofstream out("salida.dat");
o la siguiente
o tambin
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 5
ofstream out;
out.open("salida.dat");
Un fichero puede ser tambin abierto para entrada-salida. En este caso emplearemos una
declaracin fstream combinada con la operacin de apertura correspondiente, o sea:
fstream descriptor;
descriptor.open(nombrefichero.ext, ios::in | ios::out)
La declaracin fstream puede ser usada arbitrariamente tanto sobre archivos de escritura
como sobre archivos de lectura, aunque recomendamos que para archivos de solo-lectura se
use ifstream y para aquellos de solo-escritura se use ofstream.
Comentario:
Cuando un fichero de E/S se declara con fstream, abrirlo con open debemos especificar el
modo de apertura que queremos (entrada, salida o bien entrada.salida).
Ejemplo 3:
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 6
// Abrimos el fichero binario.dat para entrada-salida binaria y le asociamos el
// descriptor ejemplo.
fstream ejemplo ("binario.dat", ios::in | ios:: out | ios::binary);
Un fichero anteriormente abierto y con un descriptor asociado a l debe ser cerrado con
el fin de liberar los recursos asociado a l de la siguiente forma:
descriptor.close()
Descriptor.funcin();
La funcin eof() que devuelve "true" si se ha alcanzado el final del fichero y falso
en cualquier otro caso.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 7
funciones es muy sutil. En realidad un flujo puede estar en un estado de fallo (i.e.,
fail) pero no en un estado errneo (i.e. bad) en el caso de que el flujo no se
considere corrupto ya que no se han perdido los caracteres que provienen del
flujo (en un estado errneo, esto puede no ocurrir). Recomendamos un vistazo a
algn manual de C++ para aclarar las diferencias tan sutiles.
if (descriptor) if (! descriptor)
{ {
//Buen estado. Continuamos // Mal estado. Escribimos un mensaje
// operando sobre el fichero // a la salida estndar
..... cout << Error en la apertura
} .....
}
o mejor aun, utilizando las funciones good y bad (o fail) vistas anteriormente, o sea:
Ejemplo 4:
ifstream in("F1.dat");
if (!in) // O bien, if (in.bad() )
{
cout << endl <<"Incapaz de crear o abrir el fichero " << endl;
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 8
// salida estndar
cout << " para entrada " << endl;
}
else
{
. // Se opera sobre el fichero
}
Tanto para los ficheros de texto como para los ficheros binarios existe lo que se
denomina el cursor o apuntador del fichero que es un ndice que direcciona una posicin
relativa del fichero. El cursor marca en todo momento la posicin actual del fichero a partir
de la cual va a tener lugar la siguiente operacin de entrada-salida a ejecutar sobre el mismo
(bien sea una operacin de lectura o una de escritura). Cada vez que se realiza una operacin
de entrada o salida, el cursor del fichero avanza automticamente el nmero de bytes ledos o
escritos.
Ejemplo 5:
int main(){
ofstream fichout("EJEMPLO5.TXT",ios::out);
if (!fichout)
{
cout << endl << "Incapaz de crear este o abrir el fichero " << endl;
}
else
{
fichout << 1 << " " << 5.0 << " APROBADO" << endl;
// Escritura en el fichero
fichout << 2 << " " << 1.1 << " SUSPENSO" << endl;
fichout << 3 << " " << 8.0 << " NOTABLE " << endl;
fichout.close();
}
} // Fin del main
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 9
Comentario:
El operador >> omite los espacios en blanco al igual que ocurra en la entrada estndar.
Ejemplo 6:
int main(){
int i;
float r;
TCadena cad;
Comentarios:
(1) Observe en el ejemplo anterior que ha sido necesario realizar una lectura adelantada
previamente al chequeo del fin de fichero. Si no se realiza de esta forma podriamos tener
problemas.
(2) Observe tambin que no es necesario realizar una lectura para saltarse los espacios en
blanco que fueron introducidos en el fichero EJEMPLO5.TXT en el ejemplo 5. Esto es
debido a que, como ya se coment anteriormente, el operador >> omite los espacios en
blanco
(3) No olvide cerrar los ficheros!!
Hasta ahora hemos trabajado con ficheros de texto, stos pueden ser vistos como una serie de
caracteres que pertenecen a un determinado cdigo de entrada/salida, en nuestro caso al
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 10
cdigo ASCII. Tambin hemos visto cmo se abre un fichero binario. En esta seccin vamos
a ver cmo podemos leer y escribir datos en binario.
En esta seccin explicamos la diferencia de los ficheros binarios con los de texto y lo
hacemos a partir de un ejemplo sencillo..
ofstream fich("F1.dat",ios::out);
if (!fich)
{
cout << endl << "Incapaz de crear este o abrir el fichero ";
cout << " para salida " << endl;
}
else
{
fich << "HOLA ADIOS"; // Escribe la cadena en el fichero
// "F1.dat"
fich.close();
}
F1.dat ser un fichero que contiene 10 bytes, donde cada uno ser el cdigo ASCII
correspondiente a cada uno de los caracteres que hemos escrito en el fichero (un carcter
ocupa un byte). Esta caracterstica hace que un fichero de texto pueda ser usado por otros
programas que supongan que el contenido del fichero es un conjunto de caracteres del cdigo
ASCII.
Sabemos que los datos se almacenan en memoria segn las caractersticas del tipo con
que han sido declarados. As, para:
char C;
unsigned N;
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 11
variable N no basta con grabar directamente los dos bytes en el fichero (Ejemplo, si N
contiene el nmero 13864, para almacenarlo en el fichero se requieren 5 caracteres- o sea, 5
bytes-, mientras que en memoria la variable N ocupa cuatro bytes). As pues, una instruccin
fich << N;
Hay situaciones en las que en lugar de convertir los valores a escribir en el fichero en una
serie de caracteres, puede resultar til efectuar la grabacin en el fichero directamente a partir
contenido de la memoria. A los ficheros creados de esta forma se les llama ficheros binarios.
No podrn ser usados por programas de carcter general. Por ejemplo, si intento
usar la orden TYPE (de MS-DOS) o la orden cat (de UNIX) con un fichero
binario, la informacin que obtengo por pantalla no es legible.
Puesto que no hay que distinguir entre diferentes formatos para diferentes tipos de datos,
slo se necesitan instrucciones que lean y escriban un cierto nmero de bytes por lo que en
realidad slo necesitamos un tipo de instruccin para lectura y un tipo de instruccin para
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 12
escritura. An as veremos dos formas diferentes de leer y escribir desde y en ficheros
binarios.
9.4.2.1.- Lectura.
Para leer un carcter (es decir un byte) desde un fichero usamos la funcin get aplicada sobre
el descriptor del mismo de la siguiente manera
descriptor.get(ch);
Esta instruccin extrae un nico carcter del flujo de entrada, incluyendo el espacio en blanco
y lo almacena en la variable ch (que debe ser declarada de tipo carcter). Esta funcin avanza
adems un byte la posicin del cursor del archivo identificado por la variable descriptor.
Ejemplo 7:
El siguiente programa lee (byte a byte) un fichero binario que contiene caracteres y visualiza
su contenido en el monitor.
int main()
{
char c;
ifstream fichin("F1.dat",ios::in | ios::binary);
if (!fichin)
{
cout << endl <<"Incapaz de Abrir el fichero ";
}
else
{
fichin.get(c); // LECTURA ADELANTADA!!
while (fichin) // Tambien vale 'while (!fichin.eof())'
{ cout << c;
fichin.get(c);
};
fichin.close();
} // Fin del else
9.4.2.2.- Escritura.
Para escribir o mandar un carcter (es decir un byte) a un archivo de de salida usamos la
funcin put aplicada al descriptor de fichero del archivo de la siguiente manera
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 13
descriptor.put(ch);
Ejemplo 8:
#include <fstream.h>
#include <iostream.h>
int main(){
if (!fichout)
{
cout << endl << "Incapaz de Crear o Abrir el fichero ";
}
else
{
for (int i=0;i<=16;i++)
{ fichout.put(cad[i]); // Escritura en el fichero
}
fichout.close();
} // Fin del else
} // Fin del main
Otra manera alternativa de leer y escribir en ficheros binarios consiste en utilizar las
funciones read() y write().
9.4.3.1.- Lectura.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 14
descriptor.read(&c, num);
donde c es una variable de un tipo arbitrario (por ejemplo de un tipo TElemento), pasada por
referencia, y num es un entero o una variable de tipo entero, ejecuta una lectura (a partir de la
posicin actual del cursor del fichero asociado a la variable descriptor) de num bytes del
fichero y los coloca en la variable c. En definitiva la llamada lee num bytes del fichero y los
coloca en la variable c. Esta funcin puede extraer caracteres hasta alcanzar el fin del fichero.
9.4.3.2.- Escritura.
Asumiendo que c es una variable de un tipo arbitrario (por ejemplo de un tipo TElemento)
pasada por referencia, que num es un entero o una variable conteniendo un entero que
descriptor esta asociado a un fichero, una llamada de la forma
Descriptor.write(&c, num);
Se puede observar que en el segundo parmetro hay que indicar el nmero de bytes que
ocupa el valor que se desea escribir. Para conocer ste dato de una forma fcil, podremos usar
la funcin sizeof.
Ejemplo 9:
El siguiente programa declara el fichero F.dat para entrada-salida, graba en dicho fichero el
valor 1234.86 en binario y despus los veinte primeros enteros. Posteriormente, lee el fichero
visualizando su informacin en la salida estndar (el monitor).
#include <fstream.h>
#include <iostream.h>
#include <stdlib.h>
int main(){
float R=1234.86;
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 15
int i,N;
fichbin.close();
Observa que la apertura y el cierre de ficheros binarios se puede efectuar con las mismas
operaciones estudiadas para ficheros de texto.
Supongamos que deseamos acceder a informacin situada cerca del final del fichero.
Segn lo visto hasta ahora, debemos leer previamente toda la informacin que le precede con
objeto de ir avanzando el puntero de lectura/escritura progresivamente. Puesto que
conocemos la situacin de la informacin que queremos leer escribir, parece ms
conveniente poder situar el puntero de lectura/escritura directamente en dicha posicin. Para
gestionar ste tipo de comportamiento disponemos de una serie de funciones.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 16
vemos a continuacin.
9.5.1.- Lectura.
Las funciones de acceso aleatorio para lectura son seekg y tellg.
seekg(pos) mueve la posicin del cursor del fichero a la posicin relativa del fichero
indicada por pos, donde pos es un entero (o variable conteniendo un entero).
tellg() devuelve la posicin relativa actual del cursor asociado al fichero de entrada y
devuelve un 1 en caso de existir algn error.
9.5.2.- Escritura.
Las funciones de acceso aleatorio equivalentes para escritura on seekp y tellp.
seekp(pos) mueve la posicin del cursor del fichero a la posicin absoluta del fichero
indicada por pos.
tellp() devuelve la posicin absoluta actual del cursor asociado al fichero de salida y
devuelve un 1 en caso de existir algn error.
Ejemplo 10:
El siguiente programa almacena en un fichero los 10 primeros enteros, luego muestra por
pantalla el quinto entero (o sea el 5), posteriormente lo reemplaza por el valor 100, y al final
visualiza en el monitor el contenido del fichero.
#include <fstream.h>
#include <iostream.h>
#include <stdlib.h>
int main(){
int i,N;
fichbin.seekp(4*sizeof(int));
// se posiciona al principio del quinto entero
fichbin.seekp(4*sizeof(int));
// se posiciona de nuevo al principio del quinto entero
// pues el cursor haba avanzado.
i=100;
fichbin.write(&i,sizeof(int));
// Modifica el valor 5 por el valor 100;
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 17
fichbin.seekp(0*sizeof(int));
// se posiciona de nuevo al principio del fichero
for (i=1;i<=10;i++)
{ fichbin.read(&N,sizeof(int));
cout <<endl << i << "= " << N << endl;
// Se visualiza el contenido en pantalla
}
fichbin.close();
system("PAUSE");
return 0;
} // Fin del main
Ejemplo 11:
#include <fstream.h>
int main(){
fstream out("poesia.txt",ios::app);
escribir_hola(out);
out.close();
} // Fin del main
En esta seccin mostramos dos ejemplos de cmo podemos leer/escribir datos desde/a
ficheros binarios o de texto.
Comentario:
Observe que en la apertura de ficheros binarios ES NECESARIO, en algunos compiladores
como es el caso del DEV-C++) especificar el modo de apertura (in, out, app, ...,etc) a pesar
de que este sea el modo por defecto. Si no se especifica entonces podemos tener problemas
en la lectura de los datos.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 18
Ejemplo 12:
El siguiente programa lee, desde teclado una informacin relativa a una serie de empleados
de una empresa. Los datos a leer son el nombre, un cdigo formado por cuatro enteros - ojo,
no por cuatro dgitos- y una cantidad correspondiente al sueldo mensual. Entonces, toda la
informacin recogida es grabada en dos ficheros (uno de texto y otro binario) para ser
posteriormente leda desde los mismos y visualizada en pantalla.
#include <iostream.h>
#include <stdlib.h>
#include <fstream.h>
//CONSTANTES
const int MAXCAD = 40;
const int MAXVECT = 4;
const char ENTER = '\n';
//TIPOS
typedef int TVector[MAXVECT];
typedef char TCadena[MAXCAD+1];
struct TPersona{
TCadena nombre;
TVector codigo; // exactamente cuatro cifras
float sueldo;
};
void VisualizaPersonasFichero(TCadena nombreFichero,int numempleados);
void EscribePersonaFichero(TCadena nombreFichero, TPersona p);
void VisualizaPersonasFicheroBin(TCadena nombreFichero,int numempleados);
void EscribePersonaFicheroBin(TCadena nombreFichero, TPersona p);
void pintaVector(TVector v);
void pintaPersona(TPersona p);
void leePersona(TPersona &p);
int main(){
TPersona per;
TVector cod;
int i,N;
system("PAUSE");
return 0;
} // Fin del main
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 19
// Este proc. visualiza la informacin almacenada en el fichero de texto
void VisualizaPersonasFichero(TCadena nombreFichero, int numempleados)
{ ifstream in;
int i,j;
TPersona p;
in.open(nombreFichero);
if (in.bad()) // Comprobamos el estado de la apertura
{
cout << "Error al abrir el fichero: " << nombreFichero << endl;
}
else
{
for (i=1;i<=numempleados; i++)
{ in.getline(p.nombre,MAXCAD+1,ENTER); //USO DE getline en el fichero
for (j=0;j<MAXVECT;j++)
{ in >> p.codigo[j];
}
in >> p.sueldo;
pintaPersona(p);
in.ignore(); // Uso de ignore() sobre el descriptor
}
in.close();
}
} // Fin VisualizaPersonasFichero
out.open(nombreFichero,ios::app);
if (out.bad())
{
cout << "Error al abrir el fichero: " << nombreFichero << endl;
}
else
{
out << p.nombre << endl;
for(i=0;i<MAXVECT;++i)
{ out << p.codigo[i] << ' '; // Ojo, incluimos un espacio en medio!!
}
if (in.bad())
{
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 20
cout << "Error al abrir el fichero: " << nombreFichero << endl;
}
else
{
for (i=1;i<=numempleados;i++)
{
in.read(&p,sizeof(TPersona)); // Se lee toda la informacin !!
pintaPersona(p);
}
in.close();
}
} // Fin VisualizaPersonasFicheros
if (out.bad())
{
cout << "Error al abrir el fichero: " << nombreFichero << endl;
}
else
{
out.write(&p,sizeof(TPersona));
out.close();
}
} // Fin EscribePersonaFicheroBin
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 21
cout << endl << "Sueldo (euros) ?";
cin >> p.sueldo;
}
Comentarios:
Ejemplo 13:
El siguiente programa escribe el vector que contiene la informacin {0,1,2,3,....,8,9} tanto en
un fichero binario como en uno de texto.
#include <iostream.h>
#include <stdlib.h>
#include <fstream.h>
//CONSTANTES
const int MAXCAD = 20;
const int MAXVECT = 10;
//TIPOS
typedef int TVector[MAXVECT];
typedef char TCadena[MAXCAD+1];
int main()
{ TVector v;
int i;
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 22
LeeVectorFichero("vector.txt",v);
pintaVector(v);
system("PAUSE");
return 0;
}
in.open(nombreFichero);
if (in.bad()) // Comprobamos el estado de la apertura
{ cout << "Error al abrir el fichero: "
<< nombreFichero << endl;
}
else
{ for(i=0;i<MAXVECT;++i)
{ in >> v[i];
}
in.close();
}
}
out.open(nombreFichero);
if (out.bad())
{ cout << "Error al abrir el fichero: "
<< nombreFichero << endl;
}
else
{ for(i=0;i<MAXVECT;++i)
{ out << v[i] << " ";
}
out.close();
}
}
in.open(nombreFichero);
if (in.bad())
{ cout << "Error al abrir el fichero: "
<< nombreFichero << endl;
}
else
{ in.read(v,sizeof(TVector));
in.close();
}
}
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 23
// Escribe un vector a un fichero binario
void EscribeVectorFicheroBin(TCadena nombreFichero, TVector v)
{ ofstream out;
out.open(nombreFichero);
if (out.bad())
{ cout << "Error al abrir el fichero: "
<< nombreFichero << endl;
}
else
{ out.write(v,sizeof(TVector));
out.close();
}
}
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 24
EJERCICIOS
Nombre: De 1 a 30 caracteres.
Edad CARDINAL.
Sexo CHAR (M/F).
Arte CHAR (S/N).
Deporte CHAR (S/N).
Libros CHAR (S/N).
MsicaCHAR (S/N).
3.- Ample el programa que procesa clientes de una agencia matrimonial para que tome
los datos de todos los candidatos a estudiar del fichero PERSONAS.DAT del ejercicio
anterior, lea el cliente del teclado y finalmente genere como resultado un listado por pantalla
con los nombres de los candidatos aceptados y un fichero llamado ACEPTADOS.DAT con
toda la informacin correspondiente a los candidatos aceptados. Una persona del fichero
PERSONAS.DAT se considerar aceptable como candidato si tiene diferente sexo y por lo
menos tres aficiones comunes con respecto al aspirante introducido por pantalla. (El
programa debe ser capaz de trabajar con cualquier nmero de personas en el fichero
PERSONAS.DAT).
4.- Codifique un programa que cree un fichero para contener los datos relativos a los
artculos de un almacn. Para cada artculo habr de guardar la siguiente informacin:
5.- Escriba un programa que dados dos ficheros generados por el programa anterior y
ordenados genere un tercer fichero que sea el resultado de mezclar de formar ordenada los
dos primeros.
6.- Escriba un programa que tome como entrada el fichero del ejercicio 4 y una condicin
sobre los campos Existencias actuales o Precio. La condicin podr ser:
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 25
<campo> [<,<=,>,>=, != ] <nmero>
Este programa debe generar como salida un fichero llamado "salida.dat" que contenga todos
aquellos artculos para los que se cumple la condicin de entrada.
7.- Escriba un programa que tenga como entrada un fichero que contenga un texto y d
como resultado una estadstica de las palabras que hay de cada longitud, as como de los
caracteres especiales (",", ".", ":", ";").
8.- Escribir un programa que genere a partir de un fichero de entrada que contiene una
tabla de nmeros reales otro fichero de salida <nombre>.BIN grabado en formato binario.
___________________________________________________________________________
Laboratorio de Programacin GESTION BASICA DE FICHEROS Pg 26