UNIVERSIDAD TECNOLOGICA DE PANAMA

FACULTAD DE INGENIERIA DE SISTEMAS COMPUTACIONALES LICENCIATURA EN INGENIERIA DE SISTEMAS COMPUTACIONALES

INVESTIGACION DE PROGRAMACION APLICADA II

Nombres Cedula

Domínguez Vladimir 8-881-352

Serrano Oliver 4-797-1836

Méndez, Carlos 8-880-1146

Camaño, Giovanni

Durlin, Luis

Asignación # 1

Profesora: Addys C. de Lam

Grupo: 1-IL-123

Fecha de entrega: lunes 25 de agosto de 2014

Introducción

Índice

A. Archivos secuenciales A.1.DefiniciónA.2.Apertura y cierreA.3.CreaciónA.4.Leer datoA.5.Escribir los datosA.6.Ejemplos

B. Archivos AleatorioB.1. DefiniciónB.2.Apertura y cierreB.3. Leer datosB.4. Escribir datosB.5.Funciones de entrada/salidaB.6. Ejemplo programa

A. Archivos secuenciales

1. Definición

R: Es la forma básica de organizar un conjunto de registros, que forman un archivo, utilizando una organización secuencial. En un archivo organizado secuencialmente, lo registros quedan grabados consecutivamente cuando el archivo se utiliza como entrada. En la mayoría de los casos, los registros de un archivo secuencial quedan ordenados de acuerdo con el valor de algún campo de cada registro. Semejante archivo se dice que es un archivo ordenado; el campo, o los campos, cuyo valor se utiliza para determinar el ordenamiento es conocido como la llave del ordenamiento. Un archivo puede ordenarse ascendente o descendentemente con base en su llave de ordenamiento.

La forma más común de estructura de archivo es el archivo secuencial. En este tipo de archivo, un formato fijo es usado para los registros. Todos los registros tienen el mismo tamaño, constan del mismo número de campos de tamaño fijo en un orden particular. Como se conocen la longitud y la posición de cada campo, solamente los valores de los campos se necesitan almacenarse; el nombre del campo y longitud de cada campo son atributos de la estructura de archivos.

2. Apertura y cierre:

Abrir:

Usar un archivo desde un programa en C, tanto secuencial como directo, lo primero que hay que hacer es abrirlo. Esto crea un flujo que conecta nuestro programa con el archivo.

La función para abrir archivos es fopen(), que tiene esta sintaxis:

FILE *fopen(char *nombre_archivo, char *modo);

Cierre:

Cuando un archivo no va a usarse más, su flujo debe ser cerrado para liberar memoria. Aunque teóricamente todos los archivos abiertos por un programa se cierran automáticamente al finalizar dicho programa, el programador, por precaución, debe ocuparse de hacerlo dentro del código.

Para cerrar un archivo se usa la función fclose(), con esta sintaxis:

int fclose(FILE* puntero_file);

Fin de fichero: feof()

EOF es una constante definida en stdio.h. La función feof(), nos dice si hemos alcanzado el final de un archivo. Devuelve un 0 (falso) si aún no se ha llegado al final, y otro valor cuando se ha alcanzado. Es muy útil para saber si podemos seguir leyendo caracteres o ya los hemos leído todos. Su prototipo es:

int feof(FILE* puntero_a_archivo);

fscanf():

Lee los datos de un archivo, en lugar de hacerlo del flujo stdin (es decir, del teclado).

Los modos de apertura válidos son:

• Modo “r”: Abre el archivo existente para lectura en modo secuencial. El archivo debe existir previamente.

• Modo “w”: Crea un archivo nuevo para escritura en modo secuencial. ¡Cuidado! Si el archivo ya existe, se borrará y se creará uno nuevo.

• Modo “a”: Abre un archivo existente para escritura en modo secuencial, añadiendo los datos al final de los que haya. Si el archivo no existe, se

crea.

• Modo “r+”: Abre el archivo para lectura/escritura en modo directo. El archivo debe existir previamente. Se puede leer y escribir en cualquier posición del archivo.

• Modo “w+”: Crea un archivo para lectura/escritura en modo directo. Si el archivo ya existe, se elimina y se crea de nuevo. Se puede leer y escribir en cualquier posición del archivo.

• Modo “a+”: Abre un archivo existente para lectura/escritura en modo directo. Si el archivo no existe, lo crea. La escritura sólo se podrá realizar al final del archivo (modo “añadir”), aunque se puede leer en cualquier posición.

A todos estos modos se les puede añadir la letra “b” si el archivo es binario, o “t” si es de texto.

3. Creación de archivos secuenciales.

La creación de un archivo secuencial se realiza agregando registros al final del archivo, no importa el medio de entrada de datos. El archivo secuencial puede ser almacenado en cintas o en discos magnéticos. Un archivo secuencial puede tener registros fijos o variables, la declaración del archivo y la definición del registro dependerá del lenguaje de programación que se vaya a usar.

Un archivo secuencial se puede crear de dos forma distintas. Una es crear el archivo directamente, usando un procesador de texto o un editor. La otra forma es escribir el programa que introduzca información en las computadoras y la escriba en un archivo. Los archivos sin formatos solo se pueden crearse con programas especialmente escritos para tal fin.

4. Leer datos:

Los archivos datos que contienen solo cadenas de cadena de caracteres pueden crearse y leerse más fácilmente con programas que utilizan funciones de la biblioteca especialmente orientados para cadena de caracteres. Algunas funciones de este tipo son gets, puts, fgets, fputs, las dos primeras leen o escriben cadenas de caracteres desde dispositivos de salidas, mientras que las otras las intercambias por archivos.

5. Escritura de los archivos secuenciales:

En estos archivos, la información sólo puede leerse y escribirse empezando desde el principio del archivo.

Los archivos secuenciales tienen algunas características que hay que tener en cuenta:

1. La escritura de nuevos datos siempre se hace al final del archivo.

2. Para leer un dato concreto del archivo hay que avanzar siempre hasta donde se encuentre dicho dato. Si el dato requerido se encuentra antes del dato en que está se está posicionado el archivo en un momento dado, será necesario regresar al comienzo del archivo y avanzar hasta el dato necesario.

Escribir datos en un archivo

Para escribir datos a un archivo se utilizan las instrucciones Write y WriteLn, como si se quisiera escribir a la pantalla, con la diferencia de que se especificará la variable de archivo ya declarada. Ejemplo:

WriteLn(VarArchivo, 'Prueba de archivos'); Esta sentencia grabaría el texto 'Prueba de archivos' en el archivo asignado a VarArchivo.

 

6. Programa ejemplo de archivo secuencial

#include <stdio.h>#include <conio.h>main( ){ int cuenta;char nombre[30];float saldo;FILE *cuentaPtr;if ((cuentaPtr = fopen("cliente.dat","w")) == NULL)printf("No se puede abrir el archivo\n");else{printf("Introduzca cuenta, nombre y saldo.\n");printf("Introduzca EOF para terminar.\n");printf("? ");scanf("%d%s%f", &cuenta, nombre, &saldo);while (!feof(stdin)){fprintf(cuentaPtr, "%d %s %.2f\n", cuenta, nombre,saldo);printf("? ");scanf("%d%s%f", &cuenta, nombre, &saldo);}fclose(cuentaPtr);}getch ( ); return 0;}

B. Archivos Aleatorios

1 Definición:

Es aquel en donde los datos se guardan en registros mediante una estructura definida de tipo Type.Los archivos de acceso aleatorio son más versátiles, permiten acceder a cualquier parte del fichero en cualquier momento, como si fueran arrays en memoria.Las operaciones de lectura y/o escritura pueden hacerse en cualquier punto del archivo.

2 Apertura de un archivo aleatorio

Para procesar un archivo en C la primera operación que hay que realizar es abrir el archivo. La apertura del archivo supone conectar el archivo externo con el programa, e indicar cómo va a ser tratado el archivo: binario, de caracteres, etc. El programa accede a los archivos a través de un puntero a la estructura FILE, la función de apertura devuelve dicho puntero. La función para abrir un archivo es fopen() y el formato de llamada es: fopen(nombre_archivo, modo);

Donde nombre_archivo es un puntero a una cadena de caracteres que representan un nombre válido del archivo y puede incluir una especificación del directorio. La cadena a la que apunta modo determina como se abre el archivo. La función devuelve un puntero a FILE, a través de dicho puntero el programa hace referencia al archivo. La llamada fopen() se debe hacer de tal forma que el valor que devuelve se asigne a una variable puntero a FILE, para así después referirse a dicha variable. El siguiente ejemplo declara una variable de tipo puntero a FILE y posteriormente se utiliza una sentencia se apertura de archivo. FILE* pf;pf = fopen(nombre_archivo, modo);  A continuación se muestra una tabla conteniendo los modos permitidos para abrir un archivo así como su significado. Modo Significador Abre un archivo de texto para lectura.w Crea un archivo de texto para escritura.a Abre un archivo de texto para añadir.rb Abre un archivo binario para lectura.

wb Crea un archivo binario para escritura.ab Abre un archivo binario para añadir.r+ Abre un archivo de texto para lectura / escritura.w+ Crea un archivo de texto para lectura / escritura.a+ Añade o crea un archivo de texto para lectura / escritura.r+b Abre un archivo binario para lectura / escritura.w+b Crea un archivo binario para lectura / escritura.a+b Añade o crea un archivo binario para lectura / escritura.

Cierre de un archivo aleatorio

La función fclose() cierra una secuencia que fue abierta mediante una llamada a fopen(). Escribe toda la información que todavía se encuentre en el buffer en el disco y realiza un cierre formal del archivo a nivel del sistema operativo. Un error en el cierre de una secuencia puede generar todo tipo de problemas, incluyendo la pérdida de datos, destrucción de archivos y posibles errores intermitentes en el programa. El prototipo de esta función es:

int fclose(FILE *F);

Donde F es el puntero al archivo devuelto por la llamada a fopen(). Si se devuelve un valor cero significa que la operación de cierre ha tenido éxito si ha habido algún error, el valor de retorno es la constante EOF.

3 Lectura de datos

fgetcEsta función lee un caracter a la vez del archivo que esta siendo señalado con el puntero *archivo. En caso de que la lectura sea exitosa devuelve el caracter leído y en caso de que no lo sea o de encontrar el final del archivo devuelve EOF.El prototipo correspondiente de fgetc es:

char fgetc(FILE *archivo);

Esta función se usa generalmente para recorrer archivos de texto.

fgets

Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un cambio de línea '\n' o un final de archivo EOF. En este último caso, el carácter de cambio de línea '\n' también es leído.El prototipo correspondiente de fgets es:

char *fgets(char *buffer, int tamaño, FILE *archivo);

El primer parámetro buffer lo hemos llamado así porque es un puntero a un espacio de memoria del tipo char (podríamos usar un arreglo de char). El segundo parámetro es tamaño que es el limite en cantidad de caracteres a leer para la funcion fgets. Y por ultimo el puntero del archivo por supuesto que es la forma en que fgets sabra a que archivo debe leer.

 freadsize_t fread ( void * ptr, size_t size, size_t count, FILE * stream );Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de un arreglo de elementos "count", cada uno de los cuales tiene un tamaño definido por "size". Luego los guarda en el bloque de memoria especificado por "ptr". El indicador de posición de la cadena de caracteres avanza hasta leer la totalidad de bytes. Si esto es exitoso la cantidad de bytes leídos es (size*count).

PARAMETROS:ptr : Puntero a un bloque de memoria con un tamaño mínimo de (size*count) bytes.size : Tamaño en bytes de cada elemento (de los que voy a leer).count : Número de elementos, los cuales tienen un tamaño "size".stream: Puntero a objetos FILE, que especifica la cadena de entrada.

fscanfLa función fscanf funciona igual que scanf en cuanto a parámetros, pero la entrada se toma de un fichero en lugar del teclado.El prototipo correspondiente de fscanf es:

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

4. Escritura de datos

fputcEsta función escribe un carácter a la vez del archivo que esta siendo señalado con el puntero *archivo. El valor de retorno es el carácter escrito, si la operación fue completada con éxito, en caso contrario será EOF.El prototipo correspondiente de fputc es:

int fputc(int carácter, FILE *archivo);

fputsLa función fputs escribe una cadena en un fichero. No se añade el carácter de retorno de línea ni el carácter nulo final. El valor de retorno es un número no negativo o EOF en caso de error. Los parámetros de entrada son la cadena a escribir y un puntero a la estructura FILE del fichero donde se realizará la escritura.El prototipo correspondiente de fputs es:

int fputs(const char *buffer, FILE *archivo);

fwriteEsta función 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 dirección de memoria determinada. El valor de retorno es el número de registros escritos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria de donde se obtendrán los datos a escribir, el tamaño de cada registro, el número de registros a escribir y un puntero a la estructura FILE del fichero al que se hará la escritura.El prototipo correspondiente de fwrite es:

size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);fprintfLa función fprintf funciona igual que printf en cuanto a parámetros, pero la salida se dirige a un archivo en lugar de a la pantalla.El prototipo correspondiente de fprintf es:

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

5. Funciones para la lectura y escritura de cadenas en archivosY ejemplos de programas.

Función fgets: Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un retorno de línea. En este último caso, el carácter de retorno de línea también es leído. El parámetro n nos permite limitar la lectura para evitar desbordar el espacio disponible en la cadena. El valor de retorno es un puntero a la cadena leída, si se leyó con éxito, y es NULL si se detecta el final del archivo o si hay un error. Los parámetros son: la cadena a leer, el número de caracteres máximo a leer y un puntero a una estructura FILE del arcvhivo del que se leerá. Sintáxis:

char *fgets(char *cadena, int n, FILE *fichero); Función fputs: La función fputs escribe una cadena en un archivo. No se añade el carácter de retorno de línea ni el carácter nulo final. El valor de retorno es un número no negativo o EOF en caso de error. Los parámetros de entrada son la cadena a escribir y un puntero a la estructura FILE del archivo donde se realizará la escritura. Sintáxis:int fputs(const char *cadena, FILE *stream);

Funciones para la lectura y escritura en registros de longitud fija

Función fread: Esta función está pensada para trabajar con registros de longitud constante. Es capaz de leer desde un archivo uno o varios registros de la misma longitud y a partir de una dirección de memoria determinada. El usuario es responsable de asegurarse de que hay espacio suficiente para contener la información leída. El valor de retorno es el número de registros leídos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria donde se almacenarán los datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura. Sintáxis: size_t fread(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero); Función fwrite: Esta función también está pensada para trabajar con registros de longitud constante y forma pareja con fread. Es capaz de escribir hacia un archivo uno o varios registros de la misma longitud almacenados a partir de una dirección de memoria determinada. El valor de retorno es el número de registros escritos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria donde se almacenarán los

datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura. Sintáxis: size_t fwrite(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

Funciones 'c' específicas para archivos de acceso aleatorio Función fseek: Esta función sirve para situar el cursor del archivo para leer o escribir en el lugar deseado. El valor de retorno es cero si la función tuvo éxito, y un valor distinto de cero si hubo algún error. Los parámetros de entrada son: un puntero a una estructura FILE del fichero en el que queremos cambiar el cursor de lectura/escritura, el valor del desplazamiento y el punto de origen desde el que se calculará el desplazamiento. El parámetro origen puede tener tres posibles valores:o SEEK_SET: el desplazamiento se cuenta desde el principio del fichero. El primer byte del fichero tiene un desplazamiento cero. o SEEK_CUR: el desplazamiento se cuenta desde la posición actual del cursor. o SEEK_END: el desplazamiento se cuenta desde el final del fichero. Sintaxis: int fseek(FILE *fichero, long int desplazamiento, int origen); Función ftell: La función ftell sirve para averiguar la posición actual del cursor de lectura/excritura de un archivo. El valor de retorno será esa posición, o -1 si hay algún error. El parámetro de entrada es un puntero a una estructura FILE del fichero del que queremos leer la posición del cursor de lectura/escritura. Sintaxis: long int ftell(FILE *fichero);

6. programa ejemplo

#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt; struct stRegistro { char valido; // Campo que indica si el registro es válido S->Válido, N->Inválido char nombre[34]; int dato[4];};

int Menu();void Leer(struct stRegistro *reg);void Mostrar(struct stRegistro *reg);void Listar(long n, struct stRegistro *reg);long LeeNumero();void Empaquetar(FILE **fa); int main(){ struct stRegistro reg; FILE *fa; int opcion; long numero; fa = fopen("alea.dat", "r+b"); // Este modo permite leer y escribir if(!fa) fa = fopen("alea.dat", "w+b"); // si el fichero no existe, lo crea. do { opcion = Menu(); switch(opcion) { case '1': // Añadir registro Leer(&amp;reg); // Insertar al final: fseek(fa, 0, SEEK_END); fwrite(&amp;reg, sizeof(struct stRegistro), 1, fa); break; case '2': // Mostrar registro system("cls"); printf("Mostrar registro: "); numero = LeeNumero(); fseek(fa, numero*sizeof(struct stRegistro), SEEK_SET); fread(&amp;reg, sizeof(struct stRegistro), 1, fa); Mostrar(&amp;reg); break; case '3': // Eliminar registro system("cls"); printf("Eliminar registro: "); numero = LeeNumero(); fseek(fa, numero*sizeof(struct stRegistro), SEEK_SET); fread(&amp;reg, sizeof(struct stRegistro), 1, fa); reg.valido = 'N'; fseek(fa, numero*sizeof(struct stRegistro), SEEK_SET); fwrite(&amp;reg, sizeof(struct stRegistro), 1, fa); break; case '4': // Mostrar todo rewind(fa); numero = 0; system("cls");

printf("Nombre Datos\n"); while(fread(&amp;reg, sizeof(struct stRegistro), 1, fa)) Listar(numero++, &amp;reg); system("PAUSE"); break; case '5': // Eliminar marcados Empaquetar(&amp;fa); break; } } while(opcion != '0'); fclose(fa); return 0;} // Muestra un menú con las opciones disponibles y captura una opción del usuarioint Menu(){ char resp[20]; do { system("cls"); printf("MENU PRINCIPAL\n"); printf("--------------\n\n"); printf("1- Insertar registro\n"); printf("2- Mostrar registro\n"); printf("3- Eliminar registro\n"); printf("4- Mostrar todo\n"); printf("5- Eliminar registros marcados\n"); printf("0- Salir\n"); fgets(resp, 20, stdin); } while(resp[0] &lt; '0' &amp;&amp; resp[0] &gt; '5'); return resp[0];} // Permite que el usuario introduzca un registro por pantallavoid Leer(struct stRegistro *reg){ int i; char numero[6]; system("cls"); printf("Leer registro:\n\n"); reg-&gt;valido = 'S'; printf("Nombre: "); fgets(reg-&gt;nombre, 34, stdin); // la función fgets captura el retorno de línea, hay que eliminarlo: for(i = strlen(reg-&gt;nombre)-1; i &amp;&amp; reg->nombre[i] &lt; ' '; i--) reg-&gt;nombre[i] = 0; for(i = 0; i &lt; 4; i++) { printf("Dato[%1d]: ", i); fgets(numero, 6, stdin); reg-&gt;dato[i] = atoi(numero); }} // Muestra un registro en pantalla, si no está marcado como borradovoid Mostrar(struct stRegistro *reg){

int i; system("cls"); if(reg-&gt;valido == 'S') { printf("Nombre: %s\n", reg-&gt;nombre); for(i = 0; i &lt; 4; i++) printf("Dato[%1d]: %d\n", i, reg-&gt;dato[i]); } system("PAUSE");} // Muestra un registro por pantalla en forma de listado,// si no está marcado como borradovoid Listar(long n, struct stRegistro *reg){ int i; if(reg-&gt;valido == 'S') { printf("[%6ld] %-34s", n, reg-&gt;nombre); for(i = 0; i &lt; 4; i++) printf(", %4d", reg-&gt;dato[i]); printf("\n"); }} // Lee un número suministrado por el usuariolong LeeNumero(){ char numero[6]; fgets(numero, 6, stdin); return atoi(numero);} // Elimina los registros marcados como borradosvoid Empaquetar(FILE **fa){ FILE *ftemp; struct stRegistro reg;

ftemp = fopen("alea.tmp", "wb"); rewind(*fa); while(fread(&amp;reg, sizeof(struct stRegistro), 1, *fa)) if(reg.valido == 'S') fwrite(&amp;reg, sizeof(struct stRegistro), 1, ftemp); fclose(ftemp); fclose(*fa); remove("alea.bak"); rename("alea.dat", "alea.bak"); rename("alea.tmp", "alea.dat"); *fa = fopen("alea.dat", "r+b");

Conclusión