capitulo 9

Programación de Computadores
9 Archivos
Prof. Javier Cañas R.
Universidad Técnica Federico Santa María
Departamento de Informática
Contenido
1 Introducción
2 Tipos de Archivos
3 La Interfaz con el HW y el Sistema Operativo
4 Flujos de Información
5 Nombres Lógicos y Físicos
Javier Cañas 2000
2
1
1 Introducción
• Las estructuras de datos vistas: arreglos y
estructuras; permiten almacenar información en
forma temporal, es decir, cuando el programa
termina, se libera la memoria y se pierde el valor
de todas las variables
• Los archivos son estructuras que permiten
almacenar información en forma permanente.
Para esto se utilizan dispositivos de
almacenamiento secundario (Discos Duros).
Javier Cañas 2000
3
...Introducción
• Un archivo es una estructura de datos formada
por una secuencia de componentes del mismo
tipo de datos.
Javier Cañas 2000
4
2
2 Tipos de Archivos
• Dependiendo de el tipo de información
almacenada, los archivos se pueden
clasificar en: archivos de texto y archivos
binarios
• Los archivos de texto contienen sólo
caracteres ASCII, por ejemplo: documentos y
programas fuentes.
• Los archivos binarios contienen secuencias
arbitrarias de bits: gráficos, archivos
ejecutables, fotos, música etc...
Javier Cañas 2000
5
Archivos de acceso secuencial y acceso
aleatorio
• Los programas pueden accesar la
información contenida en un archivo en dos
modos diferentes: secuencial y aleatorio.
• En un archivo secuencial la información se
accesa en el mismo orden que fue
almacenada. El modelo de un archivo
secuencial es una cinta que se debe
rebobinar y recorrer en forma secuencial para
ubicar información almacenada.
Javier Cañas 2000
6
3
Archivos secuenciales
• Un archivo de acceso aleatorio permite
almacenar y recuperar información sin
necesidad de recorrer el archivo completo. El
modelo de un archivo de acceso aleatorio es
una memoria RAM o un arreglo que permite
almacenar en cualquier posición en forma
arbitraria.
• Sólo veremos archivos secuenciales
Javier Cañas 2000
7
3 Interfaz con el HW y el SO
• Los archivos son objetos persistentes
(su valor permanece cuando termina el
proceso) que se almacenan en distintos
medios físicos.
• La mayor interacción se produce con el
Sistema Operativo quién es el único
con permiso para manejar medios
físicos
Javier Cañas 2000
8
4
Archivos y Medios Físicos
En el HD
residen los
archivos
Red
CTC
Javier Cañas 2000
9
Archivos y Procesamiento de la
Información
• Formas de Procesamiento de Información
son:
– Interactivo: se interactúa con los usuarios
– Batch: La información está en archivos en
disco
• Ejemplo de Sistemas Batch son sistemas de
remuneraciones, contabilidad, notas etc..
• Ejemplo de Sistemas Interactivos son:
Imagen, Sistemas bancarios etc..
Javier Cañas 2000
10
5
4 Flujos de Información
• C++ maneja los archivos como flujos de
información (streams)
• La interacción vía cin y cout con los
operadores >> y << es un caso
particular de streams en el cual el
archivo es el teclado (entrada) o el
terminal de video (salida). Esto es
posible gracias al Sistema Operativo
Javier Cañas 2000
11
Jerarquía de clases stream
ios
get()
put()
getline()
write()
read()
istream
ostream
<<
>>
ifstream
iostream
ofstream
fstream.h
fstream
Javier Cañas 2000
12
6
Ejemplo: Entrada y Salida de string con
Archivos
// Poner strings en un archivo
#include <fstream.h >
void main ( )
{ ofstream outfile (“Test.txt”);
/*se crea archivo*/
outfile <<“Trabajar con archivos \n”
outfile <<“ en C++, es más \n”;
outfile << “ fácil que en C.\n” }
Javier Cañas 2000
13
Entrada y Salida de string con Archivos
• Se definió un objeto llamado outfile, miembro
de la clase ofstream
• El destructor de la clase cierra
automáticamente el archivo al terminar
Javier Cañas 2000
14
7
Ejemplo: Lectura de strings
// se leen strings desde un archivo
# include <fstream.h>
void main ( )
{const int MAX = 80; // tamaño buf.
char buffer[MAX];
ifstream infile(“Test.txt” );
while(infile) //hasta end-of-file
{infile.getline (buffer, MAX);
cout << buffer << endl;}}
Javier Cañas 2000
15
Observación
• infile toma el valor cero al detectar EOF (End
Of File)
• EOF es un marcador especial que reconoce
el Sistema Operativo y significa fin de archivo
• Por lo tanto la variable infile es del tipo bool
(lógica)
Javier Cañas 2000
16
8
Ejemplo: Entrada y Salida de Caracteres
• put y get son funciones miembros de las
clases ostream y istream respectivamente
/*programa que escribe un string a
un archivode un carácter a la
vez*/
#include <fstream.h >
#include < string.h >
Javier Cañas 2000
17
...Entrada y Salida de Caracteres
void main ( )
{char str [ ]= “ Que entretenido es
manejar archivos en C++”;
ofstream outfile ( “ Test.txt”);
for(int j=0; j< strlen(str); j++)
outfile.put(str[j]);
}
Javier Cañas 2000
18
9
Ejemplo: Lectura de Carateres
#include <fstream.h>
void main ( )
{char ch;
ifstream infile (“ Test.txt”);
while (infile )
{infile.get(ch);cout << ch;}
}
Javier Cañas 2000
19
Entrada y Salida de Objetos
• C++ es orientado a objetos. Se debe
permitir leer y escribir objetos a disco
Javier Cañas 2000
20
10
...Ejemplo de Entrada y Salida de Objetos
#include <fstream.h>
class persona
{protected:
char nombre[40]; int edad;
public: void get Dato (void )
{ cout <<“Ingrese nombre:”; cin >>
nombre;
cout <<“Ingrese edad:”
cin >> edad; }
};
Javier Cañas 2000
21
...Entrada y Salida de Objetos
void main (void )
{persona fulano; fulano.getDato();
ofstream outfile (“Person.dat”);
outfile.write((char*)& fulano,
sizeof (fulano));
}
Javier Cañas 2000
22
11
Observación
• write necesita dos argumentos: un
puntero a char y el tamaño del objeto.
write trabaja con valores binarios
(secuencia de bytes )
Javier Cañas 2000
23
Entrada y Salida de Objetos
// lectura de objetos desde disco
#include <fstream.h>
class persona
{
%
};
Javier Cañas 2000
24
12
...Entrada y Salida de Objetos
void main ( void )
{
persona p;
ifstream infile (“Person.dat”);
infile.read((char *) & p,sizeop(p ));
P.show Dato ( );
}
Javier Cañas 2000
25
5 Nombres lógicos y nombres físicos
• El nombre físico de un archivo es el nombre
a través del cual el sistema operativo
reconoce el archivo, es decir, corresponde al
nombre que aparece en el directorio.
Ejemplos de nombres físicos:
tarea1.cpp
Mis apuntes.doc
Curso C++.ppt
Javier Cañas 2000
26
13
... Nombres lógicos y nombres físicos
• El nombre lógico corresponde a una variable
tipo archivo definida por el programador.
• Para manipular un archivo desde un
programa se debe asociar el nombre lógico
con el nombre físico. Esta asociación se hace
usando la función open. Al terminar de usar
el archivo se corta esta asociación mediante
la función close
Javier Cañas 2000
27
Apertura y cierre de archivos
• En forma independiente del tipo y forma de
acceso, antes de utilizar un archivo es
necesario abrirlo y después de utilizarlo se
debe cerrar
• La función open permite abrir un archivo.
Abrir significa informar al sistema operativo
(windows) que el programa hará acceso al
archivo físico cuyo nombre se especifica en
open
Javier Cañas 2000
28
14
Apertura y cierre de archivos
• La función close permite cerrar el archivo
físico. Cerrar significa informar al sistema
operativo que el archivo ya no será usado por
el programa
Javier Cañas 2000
29
Apertura de Archivos: open()
• La función open tiene la siguiente estructura:
fstream f; //escritura
f.open("nombrearchivo",ios::out);
f es el nómbre lógico del archivo. Por este
nombre lo conoce el programa
nombrearchivo es el nombre físico. Este
nombre tiene el archivo en el Directorio del
Sistema Operativo
ios::out es el modo de apertura
Javier Cañas 2000
30
15
Opciones de apertura
in Abrir en modo lectura
out Abrir en modo escritura
app Abrir para agregar al final
binary Abrir en modo binario
Abre para entrada y
ios::in|ios::out
salida
Abre para salida
• ios::out|ios::binary
binaria
Abre para salida
• ios::in|ios::binary
binaria
•
•
•
•
•
Javier Cañas 2000
31
Ejemplo de uso de archivos de texto
#include <fstream.h>
ofstream fp; //escritura
ifstream fi; //lectura
fp.open("nombres.dat", ios::out);
fp<<"La programación muy
entretenida \n";
Javier Cañas 2000
32
16
Ejemplo de uso de archivos de texto
fp.close();
//ahora viene la lectura
char car;
fi.open("nombres.dat", ios::in);
if(!fi) cout <<"no existe archivo";
while(fi.get(car)) cout<<car;
fi.close();
Javier Cañas 2000
33
Ejemplo de uso de archivos binarios
// Crea un archivo binario. Lo
escribe y
// posteriormente lo lee
#include <iostream.h>
#include <fstream.h>
fstream fen; // archivo de entrada
fstream fsal; // archivo de salida
fsal.open("datos.dat",ios::out|ios::b
inary);
Javier Cañas 2000
34
17
Ejemplo de uso de archivos binarios
fsal.open("datos.dat",ios::out|ios::b
inary);
if(!fsal) {cout<< "Error al
abrir"<<endl;};
float x=-3.4e-4;
fsal.write((char*) &x, sizeof(x));
fsal.close();
//Abrir para lectura
Javier Cañas 2000
35
Ejemplo de uso de archivos binarios
//Abrir para lectura
fen.open("datos.dat",
ios::in|ios::binary);
if (!fen) {cout<<"Error en
apertura"<<endl;}
float y;
fen.read((char*) &y, sizeof(y));
Javier Cañas 2000
36
18
FIN
Archivos
19