ARCHIVOS EN C++

ESTRUCTURA DE DATOS AVANZADOS

ARCHIVOS EN C ++
I.

DEFINICIN

Es una coleccin de elementos lgicamente relacionados y almacenados en

memoria secundaria. A ms bajo nivel, un fichero es una secuencia de bits
almacenado en algn dispositivo externo (como por ejemplo uno de memoria
secundaria).
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 por espacios o retornos de carro. Los segundos almacenan bits de
forma directa (por lo que no se necesitan separadores) y se necesita usar la
direccin de una posicin de almacenamiento.
Una biblioteca en C++ que proporciona funciones y operadores para el manejo de
ficheros es la biblioteca fstream.
#include <fstream>
DEFINICIN, APERTURA Y CIERRE DE FICHEROS
Declaracin de Variables de tipo "Fichero":
ifstream descriptor; // Para ficheros de entrada
ofstream descriptor; // Para ficheros de salida
Apertura de Ficheros de Texto (supongamos TCadena nombre):
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
in.open(nombre,ios::in|ios:: out); // Apertura para Lectura y Escritura
out.open(nombre,ios::in|ios:: out); // Apertura para Lectura y Escritura
Apertura de Ficheros Binarios (supongamos TCadena nombre):
in.open(nombre,ios::binary); // Apertura para Lectura
out.open(nombre,ios::binary); /* Apertura para Escritura.
(borra el contenido si lo hubiera) */
out.open(nombre,ios::binary| ios::app); // Apertura para aadir datos al final
in.open(nombre, ios::binary |
ios::in | ios:: out);
// Apertura para Lectura y Escritura
out.open(nombre, ios::binary
ios::in | ios:: out);
// Apertura para Lectura y Escritura

ARCHIVOS EN C++

II.

ESTRUCTURA DE DATOS AVANZADOS

TIPOS DE ARHIVOS EN C/C++

En cuanto al tipo de acceso, en C y C++ podemos clasificar los archivos segn

varias categoras:
1. Dependiendo de la direccin del flujo de datos:
o

De entrada: los datos se leen por el programa desde el archivo.

De salida: los datos se escriben por el programa hacia el archivo.

De entrada/salida: los datos pueden se escritos o ledos.

2. Dependiendo del tipo de valores permitidos a cada byte:

o

De texto: slo estn permitidos ciertos rangos de valores para cada

byte. Algunos bytes tienen un significado especial, por ejemplo, el
valor hexadecimal 0x1A marca el fin de fichero. Si abrimos un
archivo en modo texto, no ser posible leer ms all de un byte con
ese valor, aunque el fichero sea ms largo.

Binarios: estn permitidos todos lo valores para cada byte. En estos

archivos el final del fichero se detecta de otro modo, dependiendo del
soporte y del sistema operativo. La mayora de las veces se hace
guardando la longitud del fichero. Cuando queramos almacenar
valores enteros, o en coma flotante, o imgenes, etc, deberemos
usar este tipo de archivos.

3. Segn el tipo de acceso:

o

Archivos secuenciales: imitan el modo de acceso de los antiguos

ficheros secuenciales almacenados en cintas magnticas y

Archivos de acceso aleatorio: permiten acceder a cualquier punto de

ellos para realizar lecturas y/o escrituras.

4. Segn la longitud de registro:

o

Longitud variable: en realidad, en este tipo de archivos no tiene

sentido hablar de longitud de registro, podemos considerar cada byte
como un registro. Tambin puede suceder que nuestra aplicacin
conozca el tipo y longitud de cada dato almacenado en el archivo, y
lea o escriba los bytes necesarios en cada ocasin. Otro caso es
cuando se usa una marca para el final de registro, por ejemplo, en
ficheros de texto se usa el carcter de retorno de lnea para eso. En
estos casos cada registro es de longitud diferente.

Longitud constante: en estos archivos los datos se almacenan en

forma de registro de tamao contante. En C usaremos estructuras
para definir los registros. C dispone de funciones de librera
adecuadas para manejar este tipo de ficheros.

ARCHIVOS EN C++

ESTRUCTURA DE DATOS AVANZADOS

Mixtos: en ocasiones pueden crearse archivos que combinen los dos

tipos de registros, por ejemplo, dBASE usa registros de longitud
constante, pero aade un registro especial de cabecera al principio
para definir, entre otras cosas, el tamao y el tipo de los registros.

Es posible crear archivos combinando cada una de estas categoras, por ejemplo:
archivos secuenciales de texto de longitud de registro variable, que son los tpicos
archivos de texto. Archivos de acceso aleatorio binarios de longitud de registro
constante, normalmente usados en bases de datos. Y tambin cualquier
combinacin menos corriente, como archivos secuenciales binarios de longitud de
registro constante, etc.
En cuanto a cmo se definen estas propiedades, hay dos casos. Si son binarios o de
texto o de entrada, salida o entrada/salida, se define al abrir el fichero, mediante la
funcin fopen en C o mediante el mtodo open de fstream en C++.
La funcin open usa dos parmetros. El primero es el nombre del fichero que
contiene el archivo. El segundo es em modo que es una cadena que indica el modo
en que se abrir el archivo: lectura o escritura, y el tipo de datos que contiene: de
texto o binarios.
En C, los ficheros admiten seis modos en cuanto a la direccin del flujo de datos:

r: slo lectura. El fichero debe existir.

w: se abre para escritura, se crea un fichero nuevo o se sobrescribe si ya

existe.

a: aadir, se abre para escritura, el cursor se situa al final del fichero. Si el

fichero no existe, se crea.

r+: lectura y escritura. El fichero debe existir.

w+: lectura y escritura, se crea un fichero nuevo o se sobrescribe si ya

existe.

a+: aadir, lectura y escritura, el cursor se situa al final del fichero. Si el

fichero no existe, se crea.

En cuanto a los valores permitidos para los bytes, se puede aadir otro carcter a la
cadena de modo:

t: modo texto. Normalmente es el modo por defecto. Se suele omitir.

b: modo binario.

En ciertos sistemas operativos no existe esta distincin, y todos los ficheros son
binarios.
En C++ es algo diferente, el constructor de las clases ifstream, ofstream y fstream
admite los parmetros para abrir el fichero directamente, y tambin disponemos del
mtodo open, para poder crear el stream sin asociarlo con un fichero concreto y
hacer esa asociacin ms tarde.

ARCHIVOS EN C++
III.

ESTRUCTURA DE DATOS AVANZADOS

TIPOS, FUNCIONES Y CLASES USADOS FRECUENTEMENTE CON

FICHEROS

Funciones y tipos C estndar:

Tipo FILE:
C define la estructura de datos FILE en el fichero de cabecera "stdio.h" para el
manejo de ficheros. Nosotros siempre usaremos punteros a estas estructuras.
La definicin de sta estructura depende del compilador, pero en general
mantienen un campo con la posicin actual de lectura/escritura, un buffer para
mejorar las prestaciones de acceso al fichero y algunos campos para uso interno.
Funcin fopen:
Sintaxis:
FILE *fopen(char *nombre, char *modo);
sta funcin sirve para abrir y crear ficheros en disco. El valor de retorno es un
puntero a una estructura FILE. Los parmetros de entrada son:
nombre: una cadena que contiene un nombre de fichero vlido, esto depende del
sistema operativo que estemos usando. El nombre puede incluir el camino
completo.
modo: especifica en tipo de fichero que se abrir o se crear y el tipo de datos que
puede contener, de texto o binarios:
r: slo lectura. El fichero debe existir.
w: se abre para escritura, se crea un fichero nuevo o se sobreescribe si ya existe.
a: aadir, se abre para escritura, el cursor se situa al final del fichero. Si el fichero
no existe, se crea.
r+: lectura y escritura. El fichero debe existir.
w+: lectura y escritura, se crea un fichero nuevo o se sobreescribe si ya existe.
a+: aadir, lectura y escritura, el cursor se situa al final del fichero. Si el fichero no
existe, se crea.
t: tipo texto, si no se especifica "t" ni "b", se asume por defecto que es "t"
b: tipo binario.
Funcin fclose:
Sintaxis:
int fclose(FILE *fichero);
Es importante cerrar los ficheros abiertos antes de abandonar la aplicacin. Esta
funcin sirve para eso. Cerrar un fichero almacena los datos que an estn en el
buffer de memoria, y actualiza algunos datos de la cabecera del fichero que
mantiene el sistema operativo. Adems permite que otros programas puedan abrir
el fichero para su uso. Muy a menudo, los ficheros no pueden ser compartidos por
varios programas.
Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha
habido algn error, el valor de retorno es la constante EOF. El parmetro es un
puntero a la estructura FILE del fichero que queremos cerrar.
Funcin fgetc:
Sintaxis:
int fgetc(FILE *fichero);
Esta funcin lee un carcter desde un fichero.

ARCHIVOS EN C++

ESTRUCTURA DE DATOS AVANZADOS

El valor de retorno es el carcter ledo como un unsigned char convertido a int. Si

no hay ningn carcter disponible, el valor de retorno es EOF. El parmetro es un
puntero a una estructura FILE del fichero del que se har la lectura.
Funcin fputc:
Sintaxis:
int fputc(int caracter, FILE *fichero);
Esta funcin escribe un carcter a un fichero.
El valor de retorno es el carcter escrito, si la operacin fue completada con xito,
en caso contrario ser EOF. Los parmetros de entrada son el carcter a escribir,
convertido a int y un puntero a una estructura FILE del fichero en el que se har la
escritura.
Funcin feof:
Sintaxis:
int feof(FILE *fichero);
Esta funcin sirve para comprobar si se ha alcanzado el final del fichero. Muy
frecuentemente deberemos trabajar con todos los valores almacenados en un
archivo de forma secuencial, la forma que suelen tener los bucles para leer todos
los datos de un archivo es permanecer leyendo mientras no se detecte el fin de
fichero. Esta funcin suele usarse como prueba para verificar si se ha alcanzado o
no ese punto.
El valor de retorno es distinto de cero slo si no se ha alcanzado el fin de fichero. El
parmetro es un puntero a la estructura FILE del fichero que queremos verificar.
Funcin rewind:
Sintaxis:
void rewind(FILE *fichero)
Es una funcin heredada de los tiempos de las cintas magnticas. Literalmente
significa "rebobinar", y hace referencia a que para volver al principio de un archivo
almacenado en cinta, haba que rebobinarla. Eso es lo que hace sta funcin, sita
el cursor de lectura/escritura al principio del archivo.
El parmetro es un puntero a la estructura FILE del fichero que queremos
rebobinar.
Ejemplos:
// ejemplo1.c: Muestra un fichero dos veces.
#include <stdio.h>
int main()
{
FILE *fichero;
fichero = fopen("ejemplo1.c", "r");
while(!feof(fichero)) fputc(fgetc(fichero), stdout);
rewind(fichero);
while(!feof(fichero)) fputc(fgetc(fichero), stdout);
fclose(fichero);
getchar();
return 0;

ARCHIVOS EN C++

ESTRUCTURA DE DATOS AVANZADOS

}
Funcin fgets:
Sintaxis:
char *fgets(char *cadena, int n, FILE *fichero);
Esta funcin est diseada para leer cadenas de caracteres. Leer hasta n-1
caracteres o hasta que lea un retorno de lnea. En este ltimo caso, el carcter de
retorno de lnea tambin es ledo.
El parmetro n nos permite limitar la lectura para evitar derbordar el espacio
disponible en la cadena.
El valor de retorno es un puntero a la cadena leda, si se ley con xito, y es NULL
si se detecta el final del fichero o si hay un error. Los parmetros son: la cadena a
leer, el nmero de caracteres mximo a leer y un puntero a una estructura FILE del
fichero del que se leer.
Funcin fputs:
Sintaxis:
int fputs(const char *cadena, FILE *stream);
La funcin fputs escribe una cadena en un fichero. No se aade el carcter de
retorno de lnea ni el carcter nulo final.
El valor de retorno es un nmero no negativo o EOF en caso de error. Los
parmetros de entrada son la cadena a escribir y un puntero a la estructura FILE
del fichero donde se realizar la escritura.
Funcin fread:
Sintaxis:
size_t fread(void *puntero, size_t tamao, size_t nregistros, FILE *fichero);
Esta funcin est pensada para trabajar con registros de longitud constante. Es
capaz de leer desde un fichero uno o varios registros de la misma longitud y a
partir de una direccin de memoria determinada. El usuario es responsable de
asegurarse de que hay espacio suficiente para contener la informacin leda.
El valor de retorno es el nmero de registros ledos, no el nmero de bytes. Los
parmetros son: un puntero a la zona de memoria donde se almacenarn los datos
ledos, el tamao de cada registro, el nmero de registros a leer y un puntero a la
estructura FILE del fichero del que se har la lectura.
Funcin fwrite:
Sintaxis:
size_t fwrite(void *puntero, size_t tamao, size_t nregistros, FILE *fichero);
Esta funcin tambin est pensada para trabajar con registros de longitud
constante y forma pareja con fread. Es capaz de escribir hacia un fichero uno o
varios registros de la misma longitud almacenados a partir de una direccin de
memoria determinada.
El valor de retorno es el nmero de registros escritos, no el nmero de bytes. Los
parmetros son: un puntero a la zona de memoria donde se almacenarn los datos
ledos, el tamao de cada registro, el nmero de registros a leer y un puntero a la
estructura FILE del fichero del que se har la lectura.
Ejemplo:

ARCHIVOS EN C++

ESTRUCTURA DE DATOS AVANZADOS

// copia.c: Copia de ficheros

// Uso: copia <fichero_origen> <fichero_destino>
#include <stdio.h>
int main(int argc, char **argv) {
FILE *fe, *fs;
unsigned char buffer[2048]; // Buffer de 2 Kbytes
int bytesLeidos;
if(argc != 3) {
printf("Usar: copia <fichero_origen> <fichero_destino>\n");
return 1;
}
// Abrir el fichero de entrada en lectura y binario
fe = fopen(argv[1], "rb");
if(!fe) {
printf("El fichero %s no existe o no puede ser abierto.\n", argv[1]);
return 1;
}
// Crear o sobreescribir el fichero de salida en binario
fs = fopen(argv[2], "wb");
if(!fs) {
printf("El fichero %s no puede ser creado.\n", argv[2]);
fclose(fe);
return 1;
}
// Bucle de copia:
while((bytesLeidos = fread(buffer, 1, 2048, fe)))
fwrite(buffer, 1, bytesLeidos, fs);
// Cerrar ficheros:
fclose(fe);
fclose(fs);
return 0;

}
Funcin fprintf:
Sintaxis:

int fprintf(FILE *fichero, const char *formato, ...);

La funcin fprintf funciona igual que printf en cuanto a parmetros, pero la salida
se dirige a un fichero en lugar de a la pantalla.
Funcin fscanf:
Sintaxis:
int fscanf(FILE *fichero, const char *formato, ...);
La funcin fscanf funciona igual que scanf en cuanto a parmetros, pero la entrada
se toma de un fichero en lugar del teclado.
Funcin fflush:
Sintaxis:
int fflush(FILE *fichero);
Esta funcin fuerza la salida de los datos acumulados en el buffer de salida del
fichero. Para mejorar las prestaciones del manejo de ficheros se utilizan buffers,

ARCHIVOS EN C++

ESTRUCTURA DE DATOS AVANZADOS

almacenes temporales de datos en memoria, las operaciones de salida se hacen a

travs del buffer, y slo cuando el buffer se llena se realiza la escritura en el disco y
se vaca el buffer. En ocasiones nos hace falta vaciar ese buffer de un modo
manual, para eso sirve sta funcin.
El valor de retorno es cero si la funcin se ejecut con xito, y EOF si hubo algn
error. El parmetro de entrada es un puntero a la estructura FILE del fichero del
que se quiere vaciar el buffer. Si es NULL se har el vaciado de todos los ficheros
abiertos.