ARCHIVOS

ARCHIVOS : OPERACIONES
Operaciones para el manejo habitual de un
fichero:
1.- Crearlo (slo si no exista previamente)

2.- Abrirlo

3.- Operar sobre l
(lectura/escritura,insercin, borrado, etc.)

4.- Cerrarlo
ARCHIVOS : CLASIFICACION
Clasificacin de los ficheros segn la organizacin
de los registros en memoria:

Organizacin Secuencial: Registros almacenados
consecutivamente en memoria segn el orden lgico en que
se han ido insertando.

Organizacin Directa o Aleatoria: El orden fsico de
almacenamiento en memoria puede no coincidir con el orden
en que han sido insertados.

ARCHIVOS : CLASIFICACIN
Clasificacin de los ficheros segn el acceso a la informacin almacenada:
Acceso secuencial: Para acceder a un registro es necesario pasar por todos
los anteriores. Ej: Cinta de Casette. El tiempo de acceso depende de la
posicin del dato
Acceso directo o aleatorio: Se puede acceder a un registro sin pasar por
todos los anteriores. Ej: Disco Duro. El tiempo de acceso es constante (igual
que en arrays)


Clasificacin de los ficheros segn el tipo de la informacin almacenada:
Ficheros Binarios: Almacenan secuencias de dgitos binarios (ej: ficheros que
almacenan enteros, floats,)
Ficheros de Texto: Almacenan caracteres alfanumricos en un formato
estndar (ASCII, Unicode, UTF8, UTF16, etc.). Pueden ser ledos y/o
modificados por aplicaciones denominadas editores de
texto (Ej: Notepad, UltraEdit, Editplus, etc.).
ARCHIVOS C++
Streams
En C++, los archivos se manejan con un tipo
particular de stream. Un stream es una estructura
de datos que se utiliza para manejar un flujo de
caracteres y permitir poner o sacar de el tipos de
datos est andar o clases definidas por el usuario.

Por ejemplo, cout es un stream que nos permite
escribir caracteres en la consola.
ARCHIVOS C++:
Las clases que nos da C++ para el acceso a
ficheros de texto son
ifstream, ofstream y fstream

ifstream, : leer del fichero ( i de input, f de file y
stream).

ofstream para escribir (o de output, f de file y
stream).

fstream. vale para las dos cosas, lectura y
escritura.
ARCHIVOS C++:OPERACIONES
Abrir los ficheros

La apertura del fichero se puede hacer
1. pasando parmetros al declarar la variable de estos
tipos,

EJ : ifstream f ("fichero.txt", ifstream::in);


2.O bien declarando la variable sin parmetros y luego
llamando al mtodo open().
Variable
Tipo
Nombre Archivo
ARCHIVOS C++ : OPERACIONES
#include <iostream>
#include <fstream>


int main()
{

/* Fichero original, se abre para lectura pasando parmetros
en la declaracin de la variable */
ifstream f ("fichero.txt", ifstream::in);

/* Fichero nuevo para copiar, se abre despus de declararlo,
llamando a open() */

ofstream f2;

f2.open("fichero2.txt", ofstream::out);
}
Librera Archivos
ARCHIVOS C++:OPERACIONES
El primer parmetro es el nombre del
fichero. Path absoluto o relativo segn nos
interese.
Absoluto :c:\archivo.txt
Relativo : archivo.txt

El segundo parmetros son unos flags para
indicar cmo queremos abrir el fichero.
Estos flags estn en la clase
ios_base::openmode y pueden ser los
siguientes
ARCHIVOS C++:OPERACIONES
app (append) Para aadir al final del fichero. Todas las
escrituras que hagamos se iran al final del fichero. Si nos
movemos por el fichero a una posicin concreta (con el
mtodo seekp()) y luego escribimos, tambin se escribir al
final del fichero, ignorando la posicin actual en la que nos
situemos con seekp().
ate (at end). Para aadir al final del fichero. Sin embargo, si
nos movemos a otra posicin del fichero (con seekp()) y
escribimos, la escritura se har en la posicin en la que nos
pongamos, y no al final como en el caso anterior.
binary (binary) Se abre el fichero como fichero binario. Por
defecto se abre como fichero de texto.
in (input) El fichero se abre para lectura.
out (output) El fichero se abre para escritura
trunc (truncate) Si el fichero existe, se ignora su contenido y
se empieza como si estuviera vacio. Posiblemente perdamos
el contenido anterior si escribimos en l.
ARCHIVOS C++:OPERACIONES
Si queremos abrir el fichero con varias de estas
opciones, tenemos que componerlas con un OR (el
caracter | ),
f2.open("fichero2.txt", ofstream::out | ofstream::trunc);
ARCHIVOS C++: METODOS
Hay varias formas de comprobar si ha habido o no
un error en la apertura del fichero. La ms cmoda
es usar el operator ! que tienen definidas estas
clases. Sera de esta manera
if (!f)
{
cout << "fallo" << endl;
return -1;
}
!f devuelve true si ha habido algn problema de apertura del fichero
ARCHIVO C++: OPERACIONES
Lectura y escritura
/* Declaramos un array con suficiente tamao
para leer las lneas */
char cadena[100];
...
/* Leemos */
f >> cadena;
...
/* y escribimos */
f2 << cadena;
Nombre
variable
arch
Lee y guarda el
valor en la
variable cadena
ARCHIVOS C++ : EJEMPLO
Vamos a crear un fichero mediante un objeto de la clase ofstream, y
posteriormente lo leeremos mediante un objeto de la clase ifstream
#include <iostream>
#include <fstream>
int main() {
char cadena[128];
// Crea un fichero de salida
ofstream fs("nombre.txt");
// Enviamos una cadena al fichero de salida:
fs << "Hola, mundo" << endl;
// Cerrar el fichero, para luego poder
abrirlo para lectura:
fs.close();
// Abre un fichero de entrada
ifstream fe("nombre.txt");
// Leeremos mediante getline, si lo hiciramos
mediante el operador >> slo leeramos parte de
la cadena:
fe.getline(cadena, 128);
cout << cadena << endl;
return 0; }
Cierra
archivo
Lee
cadena
Escribe
archivo
ARCHIVO C++: OPERACIONES-ENTRADA
Para abrir un archivo para lectura, utilizamos un
ifstream. Para eso, tenemos que definir una
variable de ese tipo y vincularla a algn archivo.
Para realizar esta vinculacin, tenemos dos
mtodos:

Dar el nombre del archivo al declarar la variable
O utilizar el mtodo open.

Ambos producen el mismo resultado.
ARCHIVO C++: OPERACIONES-ENTRADA
#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>
main()
{
ifstream entrada("Hola.txt");
char c;

if (entrada.good())
cout << "El archivo Hola.txt fue abierto correctamente";
else
cout << "El archivo Hola.txt no pudo ser abierto
correctamente";
cout << endl;

entrada >> c;
entrada.close();
cout<<c<< endl;
system("pause");
}
Valida
apertura
Leo y
guardo
en C
ARCHIVO C++: OPERACIONES -SALIDA
#include <fstream.h>

int main()
{
ofstream archivo; // objeto de la clase ofstream

archivo.open("datos.txt");

archivo << "Primera lnea de texto" << endl;
archivo << "Segunda lnea de texto" << endl;
archivo << "ltima lnea de texto" << endl;

archivo.close();
return 0;
}

Otra forma apertuta
ofstream archivo("datos.txt"); // constructora de ofstream
ARCHIVO C++: OPERACIONES -SALIDA
Para manejar un archivo de salida, utilizamos un
ofstream
#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>
main()
{
ofstream salida("Hola.txt");
char c;
cout<<"Ingrese un caracter"<<endl;
cin >> c;
salida << c;
salida.close();

}
Escibe el valor de c
en el archivo
ARCHIVO C++: OPERACIONES -BUCLES
/* Hacemos una primera lectura */
f >> cadena;

while (!f.eof())
{
/* Escribimos el resultado */
f2 << cadena << endl;
/* Leemos la siguiente lnea */
f >> cadena;
}
Mientras no sea fin
de archivo
#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>

main()
{
ifstream f("Hola.txt");
/* Fichero nuevo para copiar, se abre despus de declararlo, llamando a open() */
ofstream f2;
f2.open("fichero2.txt", ofstream::out);
char cadena[100];
if (f.good())
cout << "El archivo Hola.txt fue abierto correctamente";
else
cout << "El archivo Hola.txt no pudo ser abierto correctamente";
/* Hacemos una primera lectura */
f >> cadena;
while (!f.eof())
{
/* Escribimos el resultado */
f2 << cadena << endl;
/* Leemos la siguiente lnea */
f >> cadena;
}
cout << endl;
f.close();
f2.close();
system("pause");
}
BUCLES
ARCHIVO C++:OPERACIONES -
ENTRADA
#include <fstream.h>
#include <iostream.h>
main(){
ifstream archivo("datos.txt");
char linea[128];
long contador =0;
if (archivo.fail())
cout<<"Error abriendo el arcihvo";
else
while(!archivo.eof())
{ archivo.getline(linea , sizeof(linea));
cout<<linea<<endl;
if((++contador%24)==0)
{cout<<"CONTINUA...";
cin.get();
}
}
archivo.close();
system("pause");}
Mientras no sea fin
de archivo
Operadores
Operador >>
Igual como se suele usar con el stream estandar cin, el
operador de flujo de salida >> se puede usar con streams
de entrada cuando trabajos con archivos

Operador<<
Lo mismo sucede con este operador, se puede usar con
streams de salidas cuando trabajamos con archivos.

La Funcion close();
Cierra el stream liberando asi los recursos asociados
Archivos : Declaracin - Apertura
Declaracin de Variables de tipo "Fichero":



Apertura de Ficheros de Texto (supongamos
TCadena nombre):
ifstream descriptor; // Para ficheros de entrada
ofstream descriptor; // Para ficheros de salida

in.open(nombre); // Apertura para Lectura
out.open(nombre); /* Apertura para Escritura.
(borra el contenido si lo hubiera) */
out.open(nombre,ios::app); // Apertura para aadir datos al final
Archivos : Funciones
Deteccin de fin de fichero y otras funciones.
eof() devuelve true si se ha alcanzado el final del fichero y
falso en cualquier otro caso. REQUIERE LECTURA
ADELANTADA: Para que la funcin eof() devuelva un valor
de verdad.

fail() devuelve true si existe un error en una operacin de
flujo asociada al fichero

bad() devuelve true si el flujo est corrupto.

good() que devuelve true si no existe un error en una
operacin de flujo y false en caso contrario.
Ejemplo Escritura
#include <fstream.h> // Biblioteca para el manejo de ficheros
#include <iostream.h> // Biblioteca para la entrada-salida estndar

main()
{
ofstream fichout;
fichout.open("EJEMPLO.TXT");
if (fichout.bad())
{
cout << "\n Incapaz de crear este o abrir el fichero \n";
}
else
{ // Escritura en el fichero
fichout << "Alumno1" << " " << 5.0 << " APROBADO" << endl;
fichout << "Alumno2" << " " << 1.1 << " SUSPENSO" << endl;
fichout << "Alumno3" << " " << 7.0 << " NOTABLE " << endl;
fichout.close();
}
} // Fin del main
#include <fstream.h> // Biblioteca para el manejo de ficheros
#include <iostream.h> // Biblioteca para la entrada-salida estndar
typedef char TCadena[30];
main()
{
ifstream fichin; // declaracion del fichero
char i[50];
float r;
TCadena cad;
fichin.open("EJEMPLO5.TXT");
if (fichin.bad())
cout << "Incapaz de crear o abrir el fichero " << endl;
else
{
fichin >> i; // Observese la lectura adelantada!!!
while (!fichin.eof())
{
cout << i << " ";
fichin >> r; // Lectura de valores en el fichero
cout << r << " ";
fichin >> cad; // Lectura de valores en el fichero
cout << cad << endl;
fichin >> i; // Lectura de valores en el fichero
}
}
fichin.close();
system("pause");
}
Ejemplo Lectura
#include <fstream.h>
#include <string.h>
#include <iostream.h>

main()
{
char nombre[80],filename[80];
int edad;
cout << "Nombre del fichero a grabar:";
cin >> filename;
ofstream fout(filename,ios::app); //abrir el fichero
if (!fout) { cerr << "Error.."; return -1; }
fout.fill('.'); //seteo el relleno con el carcter .
while(true){
cout << "Nombre (salir-termina):";
cin >> nombre;
if ( strcmp(nombre,"salir") == 0) break;
cout << "Edad:"; cin >> edad;
fout.width(15);//seteo el ancho en 15
fout.setf(ios::left);//seteo el texto a la izquierda
fout << nombre; //escribe datos a disco
fout.unsetf(ios::left);
fout.width(4);
fout << edad << endl; //escribe datos a disco
}
fout.close();
}
Ejemplo Formato
Pido el nombre
del archivo