PDF de programación - Algoritmos y estructura de datos

Algoritmos y estructura
de datos


Asignatura anual, código 082021

MACHETE MODULO 3 Struct y FILE


Departamento de Ingeniería en Sistemas de Información
Universidad Tecnológica Nacional FRBA



UTN FRBA


Página 1

Tabla de contenido
Estructura de datos: Flujos y Registros ............................................................................................... 3

Estructura tipo Registro .................................................................................................................. 3

Estructura tipo Archivo ................................................................................................................... 3

Operaciones simples ................................................................................................................... 4

Template: read ............................................................................................................................ 4

Template: write ........................................................................................................................... 4

Template: seek ............................................................................................................................ 4

Template: fileSize ........................................................................................................................ 4

Template: filePos ......................................................................................................................... 5

Template: busquedaBinaria ........................................................................................................ 5

Ejemplos ...................................................................................................................................... 5

Lectura y Escritura en Archivos de Bloques a través de Flujos ....................................................... 7

Archivos de Bloques de Tamaño Constante ................................................................................ 7

C++ ifstream, ofstream y fstream ................................................................................................. 11

Abrir los ficheros ....................................................................................................................... 11

Leer y escribir en el fichero ....................................................................................................... 12

Cerrar los ficheros ..................................................................................................................... 12

Ejemplos Archivos de texto ....................................................................................................... 12

Ejemplo Archivo binario ............................................................................................................ 13

Acceso directo ........................................................................................................................... 13



UTN FRBA


Página 2




Estructura de datos: Flujos y Registros



1



int N;
double Y;



Tipo Identificador;
Tipo Identificador;


Estructura tipo Registro
struct NombreTipo {


}
struct TipoRegistro {


};
TipoRegistro Registro; //
Ejemplo de estructuras anidadas en C
struct TipoFecha {
int

D;
int M;


int
A;
};



struct TipoAlumno {



};
TipoAlumno Alumno;

Estructura tipo Archivo1

int
string
TipoFecha


Legajo;
Nombre;
Fecha
//



//

declara un tipo
define una variable

//

declara un tipo fecha

declara un tipo Alumno con un campo de tipo Fecha

FILE * F; asocia al identificador F que contiene información para procesar un archivo.

Modo Descripción
R
Rt
W
Wt
Rb
Wb
+

Reset Abre archivo de texto para lectura
Idem anterior,explicitando t:texto
Write Abre archivo de texto para escritura, si el archivo existe se descarta el contenido sin advertencia
Idem anterior,explicitando t:texto
Reset abre archivo binario para lectura
Write Abre archivo binario para escritura, si el archivo existe se descarta el contenido sin advertencia
Agrega la otra modalidad a la de apertura


1 En Algoritmos este año trabajaremos con estructuras FILE *

UTN FRBA


Página 3




Operaciones simples

Función
FILE *f;
f = fope arhio, ;
f = fropearhio, ;
fclose(f);
fflush(f);
reoearhio;
reaeiejo, ueo;
sizeof(tipo)
SEEK_CUR
SEEK_END
SEEK_SET
size_t fread(&r, tam,cant, f)
size_t fwrite(&r,tam,cant,f)
fgetpos(f, pos)
fsetpos(f,pos)
ftell(f)
fseek(f, cant, desde)

Descripción
Define f como puntero a FILE
Asocia f a un flujo
Similar anterior, si esta abierto antes lo cierra
Vacía el flujo y cierra el archivo asociado
Produce el vaciado de los flujos
El archivo ya no queda accesible
Renombra con nuevo el viejo nombre
Retorna el tamaño de un tipo o identificador
Constante asociada a fseek (lugar actual)
Constante asociada a fseek (desde el final)
Constante asociada a fseek (desde el inicio)
Lee cant bloques de tamaño tam del flujo f
Graba cant bloques de tamaño tam del flujo f
Almacena el valor actual del indicador de posicion
Define el indicador de posicion del archive en pos
El valor actual del indicador de posición del archivo
Define indicador de posicion a partir de una posicion.


Template: read

template <typename T> T read(FILE* f)
{
T buff;
fread(&buff,sizeof(T),1,f);
return buff;
}


Template: write

template <typename T> void write(FILE* f, T v)
{
fwrite(&v,sizeof(T),1,f);
return;
}


Template: seek

template <typename T> void seek(FILE* arch, int n)
{
// SEEK_SET indica que la posicion n es absoluta respecto del inicio del archivo
fseek(arch, n*sizeof(T),SEEK_SET);
}


Template: fileSize

template <typename T> long fileSize(FILE* f)
{
// tomo la posicion actual

UTN FRBA


Página 4

long curr=ftell(f);
// muevo el puntero al final del archivo
fseek(f,0,SEEK_END); // SEEK_END hace referencia al final del archivo
// tomo la posicion actual (ubicado al final)
long ultimo=ftell(f);
// vuelvo a donde estaba al principio
fseek(f,curr,SEEK_SET);

return ultimo/sizeof(T);
}


Template: filePos

template <typename T> long filePos(FILE* arch)
{
return ftell(arch)/sizeof(T);
}


Template: busquedaBinaria
El algoritmo de la búsqueda binaria puede aplicarse perfectamente para emprender búsquedas

sobre los registros de un archivo siempre y cuando estos se encuentren ordenados.

template <typename T, typename K>
int busquedaBinaria(FILE* f, K v, int (*criterio)(T,K))
{ // indice que apunta al primer registro
int i = 0;
// indice que apunta al ultimo registro
int j = fileSize<T>(f)-1;
// calculo el indice promedio y posiciono el indicador de posicion
int k = (i+j)/2;
seek<T>(f,k);
// leo el registro que se ubica en el medio, entre i y j
T r = leerArchivo<T>(f);

while( i<=j && criterio(r,v)!=0 )
{
// si lo que encontre es mayor que lo que busco...
if( criterio(r,v)>0 )
{
j = k-1;
}
else
{
// si lo que encontre es menor que lo que busco...
if( criterio(r,v)<0 )
{
i=k+1;
}
}
// vuelvo a calcular el indice promedio entre i y j
k = (i+j)/2;
// posiciono y leo el registro indicado por k
seek<T>(f,k);
// leo el registro que se ubica en la posicion k
r = leerArchivo<T>(f);
}
// si no se cruzaron los indices => encontre lo que busco en la posicion k
return i<=j?k:-1;
}



Ejemplos

UTN FRBA


Página 5

Leer un archivo de registros usando el template read.


f = fopen("PERSONAS.DAT","r+b");
// leo el primer registro
Persona p = read<Persona>(f);
while( !feof(f) )
{
cout << p.dni<<", "<<p.nombre<<", "<<p.altura << endl;
p = read<Persona>(f);
}

fclose(f);

Escribir registros en un archivo usando el template write.


f = fopen("PERSONAS.DAT","w+b");
// armo el registro
Persona p;
p.dni = 10;
strcpy(p.nombre,"Juan");
p.altura = 1.70;
// escribo el registro
write<Persona>(f,p);
fclose(f);

Acceso directo a los registros de un archivo usando los templates fileSize, seek y read.


f = fopen("PERSONAS.DAT","r+b");
// cantidad de registros del archivo
long cant = fileSize<Persona>(f);

for(int i=cant-1; i>=0; i--)
{
// acceso directo al i-esimo registro del archivo
seek<Persona>(f,i);

Persona p = read<Persona>(f);

cout << p.dni<<", "<<r.nombre<<", "<< r.altura << endl;
}

fclose(f);



UTN FRBA


Página 6



Introducción a Streams en C++



2



Lectura y Escritura en Archivos de Bloques a través de Flujos

El lenguaje C++ y su biblioteca estándar proveen abstracciones para el manejo de flujos (streams)

que se conectan a archivos (files). El encabezado que declara estas abstracciones es <fstream>, de

file-stream.

Esta sección presenta como

Leer y escribir a través de un flujo

 Crear un flujo desde o hacia un archivo.

 Manejar los indicadores de posición de lectura y escritura de un flujo
 Cerrar un flujo

Archivos de Bloques de Tamaño Constante
Una de las formas de almacenar datos en archivos es mediante una sec