Archivos Archivos

 La biblioteca estándar de C++ define una jerarquía de clases

 En C++ los archivos son secuencias (flujos) de bytes para el tratamiento de E/S, tanto estándar como de archivos,
(caracteres) terminadas con la marca EOF (ctr-z para DOS, VMS
como flujo (stream) de bytes. Parte de esta jerarquía es:
y ctr-d para Unix, Mac). La función que determina si hemos
alcanzado el final del archivo (a diferencia de Pascal) devuelve
cierto una vez leída la marca EOF, aunque este valor una vez ios_base
leído no se puede usar.
istream ostream
 C++ no impone ninguna estructura a los archivos, por
tanto debemos gestionarlos en el programa. Los dos
mecanismos conocidos para esta gestión son: mediante ifstream iostream ofstream
archivos de acceso secuencial (ficheros de texto, datos de
longitud variable con formato) y mediante archivos de acceso
aleatorio (ficheros binarios de registros, datos de longitud fija).
fstream

1 2

E/S estándar
E/S estándar
 Incluyendo el archivo cabecera <iostream> tenemos acceso a
las clases istream, ostream e iostream, así como a las
variables cin y cout de tipos istream y ostream  El método getline(c-str, long, sep) lee en c-str long-1 caracteres o
hasta que encuentre el separador sep. Por ejemplo:
respectivamente, que se corresponden con la E/S estándar de la
consola.
char A[N];
cin.getline(A,M); // M<=N
 Las variables cin y cout (así como las de tipo archivo), contienen
un objeto de la correspondiente clase, que utilizaremos a través
de sus métodos y operadores. se leerán en A los M siguientes caracteres, salvo que se encuentre
antes EOF, o salto de línea (‘\n’, separador implícito).

 El operador de inserción << (cout<<expresión;) y el operador de  El método ignore(long, sep) es similar a getline, pero los caracteres
extracción >> (cin >> variable;), están definidos ambos para los no se almacenan.
tipos de datos fundamentales y son extensibles para los demás
datos mediante la sobrecarga.
 Otros operadores son: endl y flush.
3 4
 Archivos
Archivos
Ejemplo: copia de un fichero en aplicación de consola
 Además tenemos la función getline(istream&,string&), que lee
en el string los siguientes caracteres hasta el salto de línea (que // proyconsola.cpp "File/New/Console Wizard"
se consume pero no se guarda): getline(cin,s); //----------------------------------------------------
#pragma hdrstop
 Para detectar el final de archivo se dispone del método eof():
// importamos las cabeceras
if (cin.eof()) .....
#include <iostream> // entrada/salida estándar
#include <string> // de la biblioteca estándar
 Incluyendo el archivo cabecera <fstream> tenemos acceso a
las clases ifstream, ofstream y fstream para archivos de #include <fstream> // entrada/salida de archivos
entrada, salida y de entrada/salida, respectivamente. //-----------------------------------------------------
#pragma argsused
 Las clases “fstream” derivan de las correspondientes clases using namespace std;
“stream” y por tanto heredan todos sus métodos y operadores.
/* para nombrar los elementos importados sin cualificarlos con std:: */
Además la función getline admite parámetros de tipo ifstream
gracias al polimorfismo.
5 6

Lectura de archivos de texto

Archivos
int main(int argc, char* argv[]) { Pascal C++
string S;
cout << "Nombre del fichero a copiar \n";
cin >> S; var ent: text; ifstream ent; // o fstream
ifstream ent; ent.open(S.c_str()); // archivo de lectura assign(ent, “...”); ent.open(“...”); //ent.open(“...”,ios::in);
cout << "Nombre del fichero copia \n"; Reset(ent);
cin >> S;
ofstream sal; sal.open(S.c_str()); // archivo de escritura // eof(ent) // ent.eof()
while (getline(ent, S) ) // elimina el salto de línea Read(ent,var); ent>>var;
sal << S << endl; //... se añade Read(ent,v1,..,vk); ent>>v1>>...>>vk;
ent.close();
sal.close(); Readln(ent,string); getline(ent,string);
cout<<"copiado, adios"<<endl; // o ent.getline(c-str,long);
getline(cin,S); Close(ent); ent.close();
return 0;
}
7 8
 Archivos de lectura
Escritura en archivos de texto
#include <ifstream> // o <fstream>
using namespace std;
Pascal C++ ifstream ent; // o ifstream ent(“entrada.dat‘”);
ent.open(“entrada.dat”); // en cuyo caso esta instrucción sobra
if (!ent.fail()) {
var sal: text; ofstream sal; // o fstream int num;
assign(sal, “...”); sal.open(“...“); //sal.open(“...”,ios::out); while (ent >> num){ // tratamiento del dato leído en la variable num }
Rewrite(sal); ent.close();
// Append(sal); // sal.open(“...”,ios::out| ios::app); }
Write(sal,var); sal<<var;
Si la variable ent la declaramos de tipo fstream, entonces debemos
Writeln(sal,v1,..,vk); sal<<v1<<...<<vk<<endl; //'\n' indicar que la apertura es para lectura:
Close(ent); sal.close();
fstream ent;
ent.open(“entrada.dat”, ios::in);

9 10

Archivos de escritura
#include <ofstrem> // o <fstream>
Archivos de escritura
using namespace std;
ofstream sal; // o ofstream sal(“salida.dat”);
sal.open(“salida.dat”); // en cuyo caso esta instrucción sobra El modo de apertura out, destruye todo el contenido
if (!sal.fail()) { previo del archivo. Si queremos escribir añadiendo al final
int num; debemos indicar además el modo app:
while (darvalor(num)) sal << num; // Cuidado! sal<<num<< “ ”;
sal.close();
}
sal.open(“salida.dat”,ios::out|ios::app);

Si la variable sal la declaramos de tipo fstream, entonces debemos

indicar que la apertura es para escritura:

fstream sal;
sal.open(“salida.dat”, ios::out);
11 12
 Archivos Archivos
 Utilizando el cursor (en bytes):
 Prácticamente todos los métodos y operadores pueden usarse
como condiciones booleanas para determinar si han tenido éxito. int tellp(); // en modo escritura p de put
Además podemos preguntar con los métodos: eof(), fail(), bad() y
good(). int tellg(); // en modo lectura g de get

 Cuando el final del archivo se lee, el archivo queda en estado de como flujo de bytes, tell nos devuelve el lugar donde se
error, que podemos restaurar con el método clear(). encuentra el cursor.

 Lectura y escritura de bytes (char) mediante los métodos: seekp(numbytes,desde);

seekg(numbytes,desde);
read(arrayBytes,numBytes)
write(arrayBytes,numBytes) mueve el cursor numbytes bytes desde el principio
(desde==ios::beg), el final (desde==ios::end) o desde la posición
actual (desde==ios::cur).
13 14

Lectura de archivos binarios Escritura de archivos binarios

con tipo de tamaño fijo con tipo de tamaño fijo

Pascal C++ Pascal C++

var ent:file of tipo; ifstream ent; // o fstream var sal:file of tipo; ofstream sal; // o fstream
t: tipo tipo t; t: tipo tipo t;
assign(ent, “...”); ent.open(“...”, ios::binary); assign(sal, “...”); sal.open(“...”, ios::binary);
Reset(ent); Rewrite(sal);
// eof(ent) // ent.eof() Write(sal,t); sal.write( (char*)&t, sizeof(tipo) );
Read(ent,t); ent.read( (char*)&t, sizeof(tipo) ); Close(sal); sal.close();
Close(ent); ent.close();

15 16