Sunteți pe pagina 1din 14

Ficheros en C

Ficheros en C Ficheros en C Entradas y salidas con ficheros 11/08/2009 [DEPARTEMENTO DE COMPUTACION FACULTAD

Ficheros en C

Entradas y salidas con ficheros

11/08/2009

[DEPARTEMENTO DE COMPUTACION FACULTAD DE CIENCIAS Y TECNOLOGIA]

.

Página 1

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

I-ENTRADA Y SALIDA POR ARCHIVOS

Contenido:

1. Flujos

2. Puntero FILE

3. Apertura de un Archivo

4. Creación de Archivos

5. Archivos binarios

6. Control del Buffer

7. Funciones para acceso Aleatorio

1. Flujos:

Un flujo (stream) es una abstracción que se refiere a un flujo o corriente de datos que fluyen entre un origen o fuente (productor ) y un destino o (consumidor). Entre el origen y el destino debe existir una conexión o canal (pipe) por la que circulan los datos. La apertura de un archivo supone establecer la conexión del programa con el dispositivo que contiene el archivo, por el canal que comunica el archivo con el programa van a fluir la secuencia de datos. Hay tres flujos o canales abiertos automáticamente cuando se ejecuta un programa. extern FILE *stdin extern FILE * stdout. Extern FILE * stderr.

Estas tres variables se inicializan al comenzar la ejecución del programa para admitir secuencias de caracteres, en modo texto su contenido es:

stdin

asocia al teclado(entrada estándar)

stdout

asocia a la pantalla (salida estándar)

stderr

asocia a la salida de mensajes de error(pantalla).

Ejemplo:

Cuando ejecutamos printf(“ Estamos en las Olimpiadas 2008”); esto se escribe en la pantalla (stdout) Si queremos leer una variables a través del teclado (stdin) usamos scanf(“%d”,&x);

El acceso a los archivos se hace con un buffer intermedio. Podemos pensar en él como un array donde se almacena los datos que van al archivo, o que salen del archivo; el buffer se vuelca cuando de una forma u otra se da la orden de vaciarlo. Ejemplo cuando estamos llamamos a una función para leer cadenas de carácter la función lee cuantos caracteres quepan en el buffer. Después se obtiene la cadena del buffer, este queda vacio y una llamada posterior a la función obtiene la siguiente cadena. El lenguaje C trabaja con archivos con buffer, y está diseñado para acceder a muchos dispositivos como una secuencia, pudiendo haber secuencias de caracteres (texto) y secuencia binarias(0 y1).

2. Puntero FILE.

Los archivos se guardan en dispositivos externos como Disco duro, cintas , Pendrive, etc. Y tienen un nombre y unas características. En el programa el archivo tiene un nombre interno que es un puntero a una estructura predefinida ( puntero a archivo). Esta estructura contiene información sobre el archivo, tal como la dirección del buffer, el último carácter que salió del buffer, modo de apertura, etc. El identificador de esta estructura es FILE y se encuentra declarado en el fichero de cabecera stdio.h

Typedef struct

{

short level; unsigned flags; char fd; unsigned char hold; short bsize; unsigned char * buffer, *curp;

Página 2

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

unsigned istemp; short token; } FILE; Esta estructura puede cambiar de un compilador a otro, pero al programador solo le interesa su uso como estructura FILE. Lo que nos indica que para cada fichero que abramos tenemos que definir FILE *p;(o sea un puntero a la estructura FILE).

Ejemplo:

FILE *pf; También la entrada estándar y salida estándar están asociada a esta estructura FILE * stdin,*stdout // estas están ya definida en stdio.h .

3. Apertura de un fichero:

Para procesar un Archivo en C ( y en todos los lenguajes de programación) 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 como va a ser tratado el archivo: binario, o de texto, etc. El programa accede a los archivos a través de un puntero a estructura FILE, la función de apertura devuelve dicho puntero. Esta función se denomina fopen() y su formato es

fopen(nombre_archivo, modo); Donde nombre_archivo es una cadena y modo también es otra cadena de carácter.

La función devuelve un puntero a FILE a través de dicho puntero el programa hace referencia al archivo.

Ejemplo:

FILE *pf;

pf=fopen(“Mi_archivo.dat”, “r”);

la función puede detectar error al abrir el archive, por ejemplo que este no exista, entonces la función retornara NULL.

Ejemplo:

Se desea abrir un fichero de nombre cuadernos.dat que se encuentra en la raíz del disco duro.

#include<stdio.h>

#include<stdlib.h>

FILE * pf; char Nom*+=”C:\cuadernos.dat”;

pf=fopen(Nom, “r”); if(pf==NULL)

{

puts(“error al abrir fichero para escribir”);

exit(1);

}

3.1 Modos de apertura de un fichero

Al abrir un archivo fopen() espera un segundo argumento que es el modo de apertura, esto es establecer si el archivo es de lectura, de escritura, o añadido; y si es de texto o es binario. Esto se establece aquí:

MODO

SIGNIFICADO

“r”

Abre para lectura

Página 3

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

“w”

Abre para escritura( si ya existe se pierden los datos)

“a”

Abre para añadir al final

“r+”

Abre archivo ya existente para modificar (leer /escribir)

“w+”

Crea un archivo para escribir/leer( si ya existe se pierden los datos)

“a+”

Abre el archivo para modificarlo (escribir /leer) al final. Si no existe es como w+

En estos modos no se ha establecido el tipo de archivo, de texto o binario. Siempre hay una opción por defecto y aunque depende del compilador utilizado suele ser de modo texto. Para no depender del entorno es mejor indicar si es texto o binario. Se utilizara t para texto y b para binario. Es decir:

“rt”, “wt”,”at”,”r+t”,”w+t”,”a+t” o bien “rb”, “wb”,”ab”,”r+b”,”w+b”,”a+b.

Ejemplo.

Se quiere abrir fichero de texto con nombre libros.txt y guardarlo como binario en recuerdo.dat (poner operaciones de apertura)

#include<stdio.h>

#include<stdlib.h>

main()

{

FILE *pf1, *pf2;

char primer*+=”C:\\libros.txt”; char segundo*+=”C:\\recuerdo.dat”;

pf1=fopen(primer, ”rt”); pf2=fopen(segundo, “wb”);

if(pf1==NULL ||pf2==NULL)

{

puts(“Error al Abrir Fichero “);

}

}

Exit(1);

3.2 Cerrar archivos.

Los archivos trabajan con una memoria intermedia, son con buffer. La entrada y salida se almacena en el buffer volcándose cuando está lleno. Al terminar el programa puede ser que todavía se encuentren datos en el buffer, esto podría quedar elementos sin actualizarse, para tal efecto y evitar estos problemas se tienen que cerrar estos archivos con lo que volcaría en el archivo lo que se encuentran en el buffer.

La función fclose(puntero _file) cierra el archivo asociado al puntero_file. Esta función retorno un EOF si ocurre un error al cerrar fichero.

Sintaxis

int fclose(FILE * pu);

4. La creación de un archivo secuencial

Una vez abierto un archivo para escribir datos hay que grabar los datos en el archivo. El lenguaje C proporciona muchas funciones de biblioteca para escribir datos en el archivo a través del puntero a FILE asociado.

Página 4

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

Estas funciones tienen mucho parecido a las funciones asociadas a los flujos( stdin y stdout) teclado scanf () y pantalla fprint() o bien a getchar(), putchar(), gets() y puts() cada una tiene su versión para archivo que inician con la letra f. Asi:

fprintf(), fscanf(),fgets() , fputs(), fgets().

4.1 Veamos ahora la función para guardar datos carácter a carácter funciones putc() y fputc()

Estas funciones son idénticas putc() está definida como macro, escribe un carácter asociado con el puntero a FILE. Devuelven el carácter escrito o un EOF si no se realizo la escritura para ambas el formato es:

fputc( c, puntero_File); putc(c, puntero_File);

Donde c es el carácter escrito.

Ejemplo:

Se creara un fichero de nombre salida.dat con los caracteres que se tecleen. #include<stdio.h> #include<stdlib.h>

int main()

{

char c; FILE *pf; char *salida=”Salida.dat”;

if((pf== fopen(Salida,”wt”) ==NULL)

{

puts(“ERROR EN OPERACION DE APERTURA “); return 1;

}

}

}

while((c=getchar()) !=EOF)

{

putc(c,pf);

//aquí se puede utilizar fputc(c, pf);

return 0;

Ahora veremos funciones para leer de un fichero carácter a carácter sean estas las funciones getc() y

fgetc()

estas funciones son iguales igual formato igual funcionalidad; pueden considerarse que son

reciprocas de putc() y fputc() . Estas funciones leen un carácter del archivo asociado con el puntero a

FILE.

Devuelve un el carácter leído o bien un EOF si no pudo leer.

Formato

c=getc(puntero_File);

c=fgetc(puntero_File);

Ejemplo en el ejemplo anterior se creó un archivo de nombre Salida.dat que está guardado en el disco realizaremos el programa que lea su contenido y lo muestre por pantalla y que cuente el número de líneas.

A continuación se presenta el programa para leer ese fichero haciendo uso de las funciones de lectura en ficheros carácter a carácter.

Página 5

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

#include<stdio.h>

#include<stdlib.h>

int main()

{

char c; int n=0; FILE *pf; char *nombre=”Salida.dat”;

if((pf== fopen(nombre,”rt”) ==NULL)
{

puts(“ERROR EN OPERACION DE APERTURA “); return 1;

}

while((c=getc(pf)) !=EOF) // aquí se puede sustituir por fgetc(pf)

{ if(c==`\n`)

{

n++; printf(“\n”);

}

else

putchar(c)

}

printf(“\número de Líneas del archivo :%d”, n);

fclose(pf);

return 0;

}

4.2 Funciones que escriben y Lee en fichero cadena a cadena funciones fputs() y fgets().

Estas funciones escriben /leen una cadena en el archivo asociado con el puntero FILE. La funciones fputs() y puts() escriben una cadena de carácter esta función devuelve un EOF si no pudo escribir la cadena y un valor positivo si escribió correctamente el formato es :

fputs(cadena, puntero_File);

La función fgets() lee una cadena de carácter del archivo. Termina la captación de la cadena hasta encontrar el carácter de fin de línea, o bien cuando ha leído n-1 caracteres, siendo n el argumento entero de la función. Esta función devuelve un puntero a la cadena devuelta, o un NULL si ha habido un

error. El formato es

El siguiente programa da lectura al archivo cartas.dat que tiene un texto al que se desea añadir nuevas líneas de longitud mínima de 30 carácter, desde el archivo primero.dat

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#define MX 121 #define MN 30

fgets(cadena, n, puntero_File);

void main()

{ FILE *in, *out;

char nomb1[]="Carta.dat"; char nomb2[]="Primero.dat"; char cad[MX];

}

in=fopen(nomb2, "rt"); out =fopen(nomb1 ,"at");

if(in==NULL ||out ==NULL)
{

puts("Error al abrir archivos ");

exit(1);
}

while(fgets(cad, MX, in))

if(strlen(cad)>=MN)

{

fputs(cad,out);

else

puts(cad);

}

fclose(in);

fclose(out);

Página 6

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

4.3 Las funciones fprintf() y fscanf()

Estas funciones permiten leer y escribir cualquier tipo de dato estándar, los códigos de formato (%d %s %f….) indican a C la transformación que deben realizar con la secuencias de caracteres al igual que lo realiza las funciones fprintf() y fscanf() ya estudiadas. Las funciones fprintf() y fscanf() tienen como primer argumento puntero_File.

El siguiente ejemplo nos crea un fichero de texto de nombre PERSONA.DAT cada línea del fichero tiene los registro de nombre de la persona, fecha de nacimiento día mes y año y además el mes de nacimiento en ASCII.

#include<stdio.h>

#include<malloc.h> #include<stdlib.h> #include<string.h> #include<ctype.h> // declaración de una estructura typedef struct
{

char * nm; int dia; short ms; int aa; char mes[11]; }PERSONA;

void entrada (PERSONA *p); char * mes_asci(short );

int main()

{ FILE *pff;

char nf[]="C:\\PERSONA.DAT";

char r='S'; if((pff=fopen(nf,"wt"))==NULL) {

}

puts("ERROR AL ABRIR FICHERO");

exit(-1);

while(toupper(r)=='S')
{

PERSONA pt; entrada(&pt);

printf("%s %d-%d-%d %s\n",pt.nm,pt.dia,pt.ms,pt.aa,pt.mes); fprintf(pff,"%s %d-%d-%d %s\n",pt.nm,pt.dia,pt.ms,pt.aa,pt.mes); printf("Otro Registro ?:"); scanf("%c%*c",&r);

}

}

fclose(pff);

return (0);

Página 7

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

// Aquí las funciones

void entrada(PERSONA *p)

{ char bf[81]; printf("Nombre "); gets(bf); p->nm=(char *)malloc((strlen(bf)+1)*sizeof(char)); strcpy(p->nm,bf); printf("Fecha de Nacimiento dia mes año"); scanf("%d %d %d%*c",&p->dia,&p->ms,&p->aa);

printf("\n%s",mes_asci(p->ms));

strcpy(p->mes,mes_asci(p->ms));

}

char * mes_asci(short n)
{

static char *mes[12]={"Enero","Febrero","Marzo","Abril","Mayo","Junio", "Julio","Agosto","Septiembre","Octubre", "Noviembre","Diciembre"};

if(n>=1 && n<=12) return mes[n-1]; else return "Error";

}

4.4 La función feof()

Como muchas de las funciones que se estudian devuelven un EOF cuando leen el carácter de fin de fichero, entonces para detectar que lo que se ha leído es el carácter de fin de fichero esta función feof() retorna un valor (verdadero) diferente de cero si se detecta el fin de fichero o bien (falso) valor 0 si no se detecta.

La función feof() es muy útil cuando se trabaja con ficheros binarios por que la marca de fin de fichero es también un entero binario valido. Ejemplo:

#include<stdio.h>

#include<stdlib.h>

int main()

{

char c; int n=0; FILE *pf; char *nombre=”Salida.dat”;

if((pf== fopen(nombre,”rt”) ==NULL)
{

puts(“ERROR EN OPERACION DE APERTURA “); return 1;

}

while(!feof(pf))
{

c=fgetc(pf);

if(c== `\n`)

{

}

n++;

printf(“\n”);

}

else

putchar(c)

}

printf(“\número de Líneas del archivo :%d”, n); fclose(pf); return 0;

Página 8

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

4.5 La función ferror()

Esta constituido como una macro que devuelve un valor distinto de cero si ha ocurrido un error en el flujo. Formato :

int ferror(FILE * pf); Ejemplo:

fputc(informacion, pf); If(ferror(pf)) printf(“Ha ocurrido un error “);

4.6 La función rewind()

Esta función reposiciona el puntero del fichero al comienzo del flujo. También inicializa los indicadores de error y de fin de fichero con el flujo. No devuelve ningún valor.

Ejemplo. void releer (FILE * pf)

{

// lee una vez

while(!feof(pf))

puchar(fgetc(pf));

rewind(pf); // leer otra vez

while(!feof(pf))

puchar(fgetc(pf));

}

5. Archivos binarios.

Para abrir un archivo modo binario hay que especificar la opción b en el modo de apertura. Los archivos binarios son secuencias de ceros y unos. Una de las características de los archivos binarios es que optimizan la memoria ocupada por un archivo, sobre todo con campos numéricos. Así , almacenar un entero en modo binario supone una ocupación de (2 bytes o de 4 bytes según el sistema un float son

primero a una cadena de carácter

4 bytes o bien 8 bytes , en modo texto el valor numérico se convierte (%d o %f) y después se escribe en el archivo.

Ejemplo

FILE *pfb;

pfb=fopen(“Comunicación”, “rb”); Fundamentalmente para trabajar con valores binarios el lenguaje C nos proporciona dos funciones especiales dirigidas a entradas y salidas a archivos binarios con buffer, son fread() y fwrite().

5.1 La función fwrite()

Esta función escribe un buffer de cualquier tipo de dato en un archivo binario. El formato de llamada es:

fwrite( direccon_buffe, tamaño, num_elementos, puntero_File);

Página 9

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

esta función devuelve el número de elementos escritos si este es menor que num_elementos es que ha ocurrido un error

Ejemplo:

En este ejemplo se abre el archivo en forma binario para escritura. Se escriben números reales en doble precisión en el bucle for. El buffer es la variable x, el tamaño lo devuelve el operador sizeof. // Trozo de programa FILE *fd;

double x;

fd=fopen(“reales”,”wb”); for(x=0.5; x>0.01; )

{

fwrite(&x, sizeof(double),1 fd); X=pow(x, 2);
}

Los archives binarios están indicados especialmente para guardar registros, estructuras en C el método habitual es la escritura sucesiva de estructuras en el archivo asociado al puntero, la lectura de estos archivo es similar.

5.2 Función de lectura fread()

Esta función lee un archivo n bloques de bytes y los almacena en un buffer. El numero de bytes de cada bloque (tamaño) se pasa como parámetro, al igual que el numero n bytes.

Formato de llamada

fread(direccon_buffe, tamaño, num_elementos, puntero_File);

Esta función devuelve el número de elementos actualmente leídos, que puede ser menor que num_elementos si ocurre un error.

Se tiene que utilizar las funciones ferror() o feof() para distinguir que se ha detectado la marca de fin de fichero.

Ejemplo:

FILE *pf;

char car, cadena[36];

………

fread(&car, sizeof(char), 1 , pf); fread(cadena, sizeof(cadena), 1, pf);

// Estas sentencias son equivalentes a las anteriores así:

car=fgetc(pf); fgets(cadena, 37,pf);

El siguiente ejemplo trabaja con una estructura de datos, y las funciones de fread y fwrite.

Ejemplo:

#include<stdio.h>

#include<stdlib.h>

typedef struct
{

char referencia[20];

long precio;

}registro;

void main()

{ registro reg;

int bytesreg=sizeof(reg); FILE *pf;

char sprecio[10], respuesta;

Página 10

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

/********Abrir el Fichero datos para escribir ********/

if((pf=fopen("datos","w"))== NULL)

{ puts(" El Fichero no se pudo abrir ");

exit(1);

}

/******** Entrada de los datos

*******/

printf(" Introduzca la marca de fin de fichero (EOF)para terminar Ctr +z \n\n");

printf(" Referencia :

");

while(gets(reg.referencia)!=NULL)
{

printf("Precio:

");

gets(sprecio); reg.precio=atol(sprecio);

/****** Aquí escribe el registro al fichero abierto ***/ fwrite(&reg, bytesreg, 1, pf);

if(ferror(pf))

{

perror("Error durante la escritura ");

exit(2);

}

printf(" Referencia :
}

");

fclose(pf); // cerrar fichero clearerr(stdin); // desactiva el indicador eof de stdin

do

{ printf(" Quiere visualizar el fichero guardado S/N \n"); respuesta=getchar(); fflush(stdin); }while(tolower(respuesta)!='s' && tolower(respuesta)!='n');

/*********Salida de Datos ******/

if(respuesta =='s')
{

/*******Aquí se abre el fichero datos para leer *****/

if((pf=fopen("datos","r"))==NULL) {

printf(" El Fichero no pudo abrirse \n");

exit(3);

}

/*******Leer el primer registro del Fichero********/

fread(&reg,bytesreg,1, pf); while(!ferror(pf) && !feof(pf))

{ printf("Referencia :

%s\n",reg.referencia); %ld\n\n", reg.precio);

printf("Precio :

/********* Ahora pasa a leer el otro registro ******/ fread(&reg, bytesreg,1,pf);
}

}

if(ferror(pf)) perror("Error durante la lectura "); fclose(pf);
}

Página 11

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

6. Control del buffer

Sabemos que, las funciones de entrad y salida utilizan un buffer para realizar las operaciones así son más eficientes, cada vez que se abre un fichero se le asocia un buffer. Este buffer es una área de datos de la memoria RAM asociado al fichero, cuando el fichero no tiene asociado un buffer la transferencia de datos se realiza leído o escrito es físicamente transferido al momento de la operación.

No así cuando tiene asociado un buffer que se transfiere físicamente se hace en múltiplos del tamaño del buffer, las funciones que veremos son para manipular los buffer.

6.1 setbuf

Esta función permite al usuario controlar la memoria intermedia asignada al fichero apuntado por pf. Esta función se deberá ejecutar después de abierto el ficher.

Sintaxis Void setbuf(FILE * pf, char *buffer);

6.2 setvbuf

Esta función permite decidir al usuario no trabajar con un buffer y el tamaño del mismo. También esta función se tiene que ejecutar después de abierto el fichero.

Sintaxis int setvbuf(FILE * pf, char *buffer, int tipo, size_t n);

buffer es un array de carácter de longitud n bytes desempeña la función de buffer o memoria intermedia.

Tipo

Significado

_IOFBF

Se utiliza buffer de tamaño n bytes

_IOLBF

Esto para MSDOS igual que anterior _OFBF

_IONBF

No utiliza Buffer

Esta función devuelve 0 si ocurrió un error y valor diferente de 0 en caso contrario.

7. Acceso aleatorio

Los programas que se han trabajado tiene acceso secuencial es decir desde el comienzo al final, el acceso aleatorio permite acceder a un registro sin tener que pasar por los antecesores. Las funciones que nos ayudan en esto son las siguientes.

7.1 fseek

La función fseek mueve el puntero de lectura y escritura asociado al fichero apuntado por pf, a una nueva localización desplazada desp bytes de la posición pos dada en el argumento, este desp puede ser positivo o negativo.

Sintaxis Int fseek(FILE *pf, long desp, int pos);

Página 12

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

Los argumentos pos pueden ser los siguientes.

pos

Definición

SEEK_SET

Principio dl fichero

SEEK_CUR

Posición Actual del puntero lectura escritura

SEEK_END

Final del Fichero

Esta función devuelve 0 si ocurre un error y un valor distinto de cero en caso contrario.

7.2 ftell

Esta función da como resultado la posición actual del puntero de lectura y escritura, del fichero apuntado por pf esta posición es relativa al principio del fichero.

Sintaxis

long ftell(FILE *pf); Esta función devuelve la posición actual del puntero L/E o un -1L (es -1 long) si ocurre un error.

Ejemplo

Long pos;

pos =ftell(pf);

Ejemplo:

#include<stdio.h>

#include<stdlib.h>

typedef struct
{

char referencia[20];

long precio;

}registro;

void main()

{ registro reg;

int bytesreg=sizeof(reg); FILE *pf;

int totalreg; int nreg; long desp; int c, respuesta; char sprecio[10];

/********Abrir fichero datos para leer y escribir ******/

if((pf=fopen("datos","r+"))==NULL)
{

printf("Error no se pudo abrir fichero ");

exit(1);

}

/***Calcular el número de registros existentes ******/

fseek(pf, 0L, SEEK_END);

totalreg=(int)ftell(pf)/bytesreg;

/************Presentar un registro en pantalla******/ do

{

printf("No de Registro entre 1 y %d (0 para salir) ; ",totalreg); c=scanf("%d",&nreg); fflush(stdin);

/******** Visualiza un registro ******/

if(c && (nreg>=1) && (nreg<= totalreg))

Página 13

Ficheros en C

Departamento de computación Fac. Ciencias y Tecnología UNAN-León

{

desp=(long)(nreg-1)*bytesreg;

fseek(pf,desp,SEEK_SET); fread(&reg,bytesreg, 1,pf); if(ferror(pf)) {

printf(" Error al leer un registro del fichero \n");

exit(2);

}

printf("\nReferencia:

printf("Precio:

%s\n",reg.referencia);

%ld\n\n",reg.precio);

/**************Modificar registro seleccionado ****/

do

{ printf(" Desea modificar este registro? S/N\n"); respuesta=getchar(); fflush(stdin); }while(tolower(respuesta !='s') && tolower(respuesta)!='n');

}

if(respuesta == 's')
{

printf("\nReferencia : "); gets(reg.referencia); printf("Precio : "); gets(sprecio);reg.precio=atol(sprecio);

/************Escribir el registro en el Fichero *****/ fseek(pf,-bytesreg, SEEK_CUR); fwrite(&reg, bytesreg, 1,pf); if(ferror(pf))

{

printf("Error al Escribir el registro en Fichero \n");

exit(3);

}

}

}

}while(nreg);

fclose(pf);

Bibliografía:

Curso de programación C /C++

Programación en C Luis Joyanes Aguilar /Ignacio Zahonero Martinez (Editorial MC Graw Hill)

Plan Docente Programación I y II Raúl Hermógenes Ruiz C.

Fco. Javier Ceballos Sierra (Editorial RAMA)