ARCHIVOS

ARCHIVOS : OPERACIONES

Operaciones para el manejo habitual de unfichero: 1.- Crearlo (sólo si no existía previamente)

2.- Abrirlo

3.- Operar sobre él (lectura/escritura,inserción, borrado, etc.)

4.- Cerrarlo

ARCHIVOS : CLASIFICACION

Clasificación de los ficheros según la organización

de los registros en memoria:

Organización Secuencial: Registros almacenados consecutivamente en memoria según el orden lógico en que se han ido insertando.

Organización Directa o Aleatoria: El orden físico de almacenamiento en memoria puede no coincidir con el orden en que han sido insertados.

ARCHIVOS : CLASIFICACIÓN Clasificación de los ficheros según el acceso a la información

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 posición 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)

Clasificación de los ficheros según el tipo de la información almacenada:

Ficheros Binarios: Almacenan secuencias de dígitos binarios (ej: ficheros que almacenan enteros, floats,…)

Ficheros de Texto: Almacenan caracteres alfanuméricos en un formato estándar (ASCII, Unicode, UTF8, UTF16, etc.). Pueden ser leídos 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 parámetros al declarar la variable de

estos tipos,

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

2.O bien declarando la variable sin parámetros y luego llamando al método open().

Variable

Tipo Nombre Archivo

ARCHIVOS C++ : OPERACIONES#include <iostream>#include <fstream>

int main(){

   /* Fichero original, se abre para lectura pasando parámetros en la declaración de la variable */   ifstream f ("fichero.txt", ifstream::in);

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

   ofstream f2;

   f2.open("fichero2.txt", ofstream::out); }

Librería Archivos

ARCHIVOS C++:OPERACIONES

El primer parámetro es el nombre del fichero. Path absoluto o relativo según nos interese. Absoluto :”c:\archivo.txt”Relativo : “archivo.txt”

El segundo parámetros son unos flags para indicar cómo queremos abrir el fichero. Estos flags están en la clase ios_base::openmode y pueden ser los siguientes

ARCHIVOS C++:OPERACIONES app (append) Para añadir al final del fichero. Todas las

escrituras que hagamos se iran al final del fichero. Si nos movemos por el fichero a una posición concreta (con el método seekp()) y luego escribimos, también se escribirá al final del fichero, ignorando la posición actual en la que nos situemos con seekp().

ate (at end). Para añadir al final del fichero. Sin embargo, si nos movemos a otra posición del fichero (con seekp()) y escribimos, la escritura se hará en la posición 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 más cómoda es usar el operator ! que tienen definidas estas clases. Sería de esta manera

if (!f){   cout << "fallo" << endl;   return -1;}

!f devuelve true si ha habido algún problema de apertura del fichero

ARCHIVO C++: OPERACIONES

Lectura y escritura/* Declaramos un array con suficiente tamaño para leer las líneas */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 hiciéramos mediante el operador >> sólo leeríamos parte de la cadena: fe.getline(cadena, 128); cout << cadena << endl; return 0; }

Cierra archiv

o

Lee caden

a

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 algún archivo. Para realizar esta vinculación, tenemos dos métodos:

Dar el nombre del archivo al declarar la variable O utilizar el método 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 apertur

a

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 línea de texto" << endl;    archivo << "Segunda línea de texto" << endl;    archivo << "Última línea 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 línea */   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 después 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 línea */

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 : Declaración - Apertura

Declaración 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 Lecturaout.open(nombre); /* Apertura para Escritura.

(borra el contenido si lo hubiera) */out.open(nombre,ios::app); // Apertura para añadir datos al final

Archivos : Funciones

Detección 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 función eof() devuelva un valor de verdad.

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

bad() devuelve true si el flujo está corrupto.

good() que devuelve true si no existe un error en una operación 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 estándar

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 ficherofichout << "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 estándar

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 carácter ‘.’

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