UNIVERSIDAD NACIONAL DE INGENERIA
Instituto De Estudios Superiores
Programacion 2
Ficheros
Integrantes: Nicole Fernanda Robleto Fernández
Gloria Gabriela Mayorga Sánchez
Leonardo Emanuel Gadea
Grupo: 2T1-T
Docente: Ing. Gloria Del Carmen Munguía
Preguntas
1.¿Definición De Archivo?
Es un concepto lógico que puede aplicarse a muchas cosas desde archivos de
disco hasta terminales o una impresora. Se asocia una secuencia con un
archivo especifico realizando una operación de apertura. Una vez que el
archivo está abierto, la información puede ser intercambiada entre este y el
programa Un archivo binario es una secuencia de bytes que tienen una
correspondencia uno a uno con un dispositivo externo. Así que no tendrá lugar
ninguna traducción de caracteres. Además, el número de bytes escritos
(leídos) será el mismo que los encontrados en el dispositivo externo. Ejemplos
de estos archivos son Fotografías, imágenes, texto con formatos, archivos
ejecutables (aplicaciones), etc.
2.¿Definición De Archivo De Texto?
Un archivo de texto es una secuencia de caracteres organizados en líneas
terminadas por un carácter de nueva línea. En estos archivos se pueden
almacenar canciones, fuentes de programas, base de datos simples, etc. Los
archivos de texto se caracterizan por ser planos, es decir, todas las letras tienen
el mismo formato y no hay palabras subrayadas, en negrita, o letras de distinto
tamaño o ancho.
3.¿Cuál es la diferencia entre fichero de texto y ficheros binarios?
La diferencia entre fichero de texto y fichero binario es que :
En la operación de apertura se puede decidir si el fichero va a ser de
texto o binario, los primeros sirven para almacenar caracteres, los segundos
para almacenar cualquier tipo de dato.
Si deseamos leer un fichero como el autoexec.bat utilizaremos un
fichero de texto, si queremos leer y escribir registros (struct) usaremos un
fichero binario.
4. ¿Enumere y explique acceso secuencial y acceso aleatorio?
En el acceso secuencial las lecturas y escrituras en un fichero se realizan en la
posición en la que se encuentra el puntero del fichero. Al abrir el fichero el
puntero está antes del primer dato del mismo. Cada vez que se realiza una
operación de lectura o escritura el puntero se mueve hasta apuntar al dato y
después lo lee o escribe.
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:
La escritura de nuevos datos siempre se hace al final del archivo.
Para leer una zona concreta del archivo hay que avanzar siempre, si la zona
está antes de la zona actual de lectura, será necesario "rebobinar" el archivo.
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.
5. ¿Qué significa apertura y cierre de un archivo?
Se asocia una secuencia con un archivo especifico realizando una operación
de apertura. Una vez que el archivo está abierto, la información puede ser
intercambiada entre este y el programa.
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);
6.¿¿Cuál es el significado de área de bufer?
Esto se da más que nada cuando trabajamos con cadenas. Por
ejemplo, tenemos una cadena de 3 caracteres:
char cadena[3];
7 ¿Cuál es la instrucción que se utiliza para abrir y cerrar un archivo?
OPEN, CLOSE, FREEFILE. WRITE# Y INPUT#. EJEMPLOS.
Para manipular información de un fichero, por ejemplo guardar datos en él o leer datos
desde él, lo primero que hemos de hacer es abrir el fichero. El proceso a seguir es:
Abrir el fichero --> Manipular datos (extraer, guardar, modificar, etc.) --> Cerrar el fichero
(Open --> Manipular datos --> Close)
A su vez, cada vez que accedemos a un fichero usamos un número como identificador.
Podemos considerar que el identificador es una línea de teléfono o canal entre el ordenador
y el fichero. Así, para establecer una llamada (abrir un fichero) tenemos que buscar una
línea que esté libre. El número de líneas es grande, pero no infinito. Por tanto, podemos
abrir muchos archivos al mismo tiempo, pero no todos los que queramos.
8.¿Enumere y explique las funciones para el manejo de errores?
Las funciones o procedimientos de los programas son los encargados de detectar los errores
de ejecución, pero normalmente no saben qué hacer con ellos y deben notificar al programa o
función que los ha llamado sobre el problema, para que este pueda tomar las medidas
apropiadas. Existen cuatro mecanismos principales para lograrlo: valores de retorno
especiales, indicadores explícitos de resultado, uso de funciones para el manejo de errores y
excepciones
Valores retorno especiales
El uso de valores de retorno especiales es una de las técnicas más sencillas disponibles para el
manejo de errores. Al crear una función es necesario definir el rango de valores válidos que puede
regresar como resultado. Una vez que ese rango está definido, se desarrolla la función para que
regrese un valor fuera de ese rango para indicar un problema durante la ejecución. Por ejemplo, si
una función debe regresar la cantidad de clientes que han comprado en una tienda en un día
específico, sabemos que ese número nunca será negativo. El programador de la función puede
aprovechar ese hecho y regresar un valor negativo para indicar algún tipo de problema.
En el siguiente ejemplo el programa que invoca a la subrutina incorpora código para verificar el
valor regresado por la función y reportar un error si no corresponde al conjunto de valores válidos.
Indicadores explícitos de resultados
Cuando no es posible seleccionar un valor específico en el dominio del tipo de datos
regresado como resultado por la función, ya que todos los valores posibles son resultados
válidos, es común recurrir al uso de variables globales o parámetros especiales para indicar
el resultado de la operación. Una de las formas más comunes de implementar esta técnica
consiste en definir una variable global que la función invocada actualiza con valores
definidos previamente. Si el valor de la variable global después de la invocación
corresponde al código indicando una ejecución exitosa, el programa puede proceder con
normalidad y usar el resultado de la función. Si el valor corresponde a uno de los códigos
de error, el programa sabe que no puede usar el resultado y debe tomar las acciones
necesarias para corregir el problema o reportarlo al usuario
Manejadores de Errores
Algunos lenguajes permiten pasar referencias a funciones como parámetros. En estos
lenguajes se puede pasar una función dedicada a manejar errores que será invocada si la
rutina encuentra un problema durante la ejecución. El uso de esta estrategia impide que los
programadores ignoren u olviden verificar el resultado de las funciones que llaman si estas
usan alguna de las dos estrategias anteriores, ya que estas no obligan a verificar si hubieron
errores en la ejecución. La función debe identificar el problema y tratar de resolverlo. Si no
lo puede hacer, debe terminar el programa, regresar con alguna indicación de que se ha
producido un problema, indicar el error en alguna variable global o lanzar una excepción.
Explique la diferencia en el ejemplo de Agenda Telefónica y el
ejemplo de Fichero que les dejo en esta guía.
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
struct DIREC{
char nombre[35];
char tele[20];
};
FILE *pack(FILE *a);
void ordena(FILE *a);
void consulta2(FILE *a);
long busca_Clave2(FILE *a,char buscado[]);
void lee(FILE *a);
void imprime(FILE *a);
void main(){
char opcion;
FILE *archivo;
archivo=fopen ("TELE.txt","wb+"); /* usar opcion
"wb+" para crear el archivo .txt y
después cambiar a "rb+" */
while(1){
clrscr();
textattr(6+5*5);
clrscr();
textcolor(YELLOW);
cprintf(" DIRECTORIO TELEFONICO");
printf("\n\n");
cprintf(" N");
printf("uevo");
textcolor(YELLOW);
cprintf(" L");
printf("ista");
textcolor(YELLOW);
cprintf(" B");
printf("aja");
LENGUAJES DE PROGRAMACION
24
textcolor(YELLOW);
cprintf(" C");
printf("onsulta");
textcolor(YELLOW);
cprintf(" O");
printf("rdena");
textcolor(YELLOW);
cprintf(" S");
printf("alir");
gotoxy(1,25);
printf(" *** PRESIONE LA LETRA RESALTADA PARA ESCOGER LA
OPCION ***");
gotoxy(1,4);
opcion=toupper(getch());
if(opcion=='S')
break;
switch(opcion){
case 'N':{
lee(archivo);
break;
}
case 'L':{
imprime(archivo);
break;
}
case 'B':{
pack(archivo);
break;
}
case 'C':{
consulta2(archivo);
break;
}
case 'O':{
ordena(archivo);
break;
}
}
}
clrscr();
fclose (archivo);
normvideo();
clrscr();
Agenda Telefónica
La diferencia de este fichero a otro es que los otros almacenan y este Puede dar de alta,
baja, modificar registros, ordenar por nombre, apellidos, edad. Guarda los contenidos en un
archivo binario.
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<ctype.h>
void main(void)
{
/*CREACION DE LA ESTRUCTURA*/
typedef struct
{
char referencia[20];
long precio;
}registro;
/*DECLARACION DE VARIABLES*/
registro reg; /*reg es de tipo registro*/
int bytesreg=sizeof(reg); /*calcula el tamaño de un registro*/
FILE *pf;
char sprecio[10],respuesta;
pf=fopen("librito.txt","wb");/*ABRIR ARCHIVO DE MODO
BINARIO*/
system("cls");
/* ENTRADA DE DATOS */
printf("Pulse Ctrl + Z para finalizar (EN MAYUSCULA)\n\n"); /*CTRL+Z
indicador
de NULL*/
printf("Referencia: ");
while(gets(reg.referencia)!=NULL) /*si referencia es distinto de null*/
{
printf("Precio: "); gets(sprecio);reg.precio=atol(sprecio);
/*ESCRIBIR UN REGISTRO AL FICHERO*/
fwrite(&reg,bytesreg,1,pf);
printf("\nReferencia: ");
} /*fin while*/
fclose(pf); /*cierra el fichero*/
clearerr(stdin);/*desactiva el indicador eof de stdin*/
do
{
printf("¨Desea visualizar el fichero? (s/n)");
respuesta=tolower(getchar());
LENGUAJES DE PROGRAMACION
14
fflush(stdin);
}while((respuesta!='s')&&(respuesta!='n'));
/*SALIDA DE DATOS*/
if(respuesta=='s')
{
system("cls");
pf=(fopen("librito.txt","rb"));
fread(&reg,bytesreg,1,pf);
while(!feof(pf))
{
printf("Referencia: %s\n",reg.referencia);
printf("Precio: %ld\n",reg.precio);
/*leer el siguiente registro del fichero*/
fread(&reg,bytesreg,1,pf);
} /*fin while*/
} /*fin if*/
getch();
fclose(pf);
}/*fin main*/
En este programa tiene error ya que el programa de lenguaje no trabaja main(void) solo con
la función main y este pude registrar la referencia del usuario y los precios y los puede
almacenar apretar el botón ctrl + z para almacenar la información que utilizaron fclose para
que se pueda cerra el archivo y el fin main .
include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#define CIERTO 1
typedef struct{
int mes;
int dia;
int anio;
}fecha;
typedef struct{
char nombre[80];
char calle[80];
char ciudad[80];
int no_cuenta;
int tipo_cuenta;
float anteriorsaldo;
float nuevosaldo;
float pago;
fecha ultimopago;
}registro;
registro leerpantalla(registro cliente);/*función prototipo*/
void escribirarchivo(registro cliente);/*función prototipo*/
FILE *fpt; /*puntero a estructura*/
main()
{
int indicador=CIERTO;
registro cliente;
system("cls");
/*abrir el archivo en modo escritura*/
if((fpt=fopen("registro.txt","w"))==NULL)
{
printf("Error al abrir el archivo !!");
getch();
exit(0);
}
/*Introducir fecha y asignar valores iniciales*/
printf("SISTEMA DE FACTURACION DE CLIENTES - - INICIALIZACION\n\n ");
printf("Introduzca la fecha actual (mm/dd/aaaa): ");
scanf("%d %d
%d",&cliente.ultimopago.mes,&cliente.ultimopago.dia,&cliente.ultimopago.anio);
cliente.nuevosaldo=0;
cliente.pago=0;
cliente.tipo_cuenta='A';
/*Bucle principal*/
while(indicador){
/* introducir el nombre del cliente y escribirlo en el archivo*/
printf("\nNombre(introducir \'FIN\'para terminar):");
fflush(stdin);
scanf("%[^\n]",cliente.nombre);
fprintf(fpt,"\n%s\n",cliente.nombre);
/*comprobación de la condición de parada*/
if(strcmp(cliente.nombre,"FIN")==0)
break;
cliente=leerpantalla(cliente);
escribirarchivo(cliente);
}/*fin while*/
fclose(fpt);
}
registro leerpantalla(registro cliente)
/*leer el resto de los datos*/
{
printf("Calle: "); fflush(stdin);scanf("%[^\n]",cliente.calle);
printf("Ciudad: "); fflush(stdin);scanf("%[^\n]",cliente.ciudad);
printf("No de cuenta: "); fflush(stdin);scanf("%d",&cliente.no_cuenta);
printf("Saldo Actual: "); fflush(stdin);scanf("%f",&cliente.anteriorsaldo);
return(cliente);
} /*fin main*/
void escribirarchivo(registro cliente) /*escribir el resto de los datos en el archivo*/
{
fprintf(fpt,"%s\n",cliente.calle);
fprintf(fpt,"%s\n",cliente.ciudad);
fprintf(fpt,"%d\n",cliente.no_cuenta);
fprintf(fpt,"%c\n",cliente.tipo_cuenta);
fprintf(fpt,"%.2f\n",cliente.anteriorsaldo);
fprintf(fpt,"%.2f\n",cliente.nuevosaldo);
fprintf(fpt,"%.2f\n",cliente.pago);
fprintf(fpt,"%d/%d/%d\n",cliente.ultimopago.mes,cliente.ultimopago.dia,cliente.ultimopa
go.anio);
} /*fin main*/
La razón por la que este enfoque funcione con la mayoría de los compiladores es cuando
un char se compara con un int, el valor de char se convierte automáticamente en un valor
int equivalente. Al hacer esto, la mayoría de los compiladores asumen que el carácter es
signed y proporciona automáticamente un valor entero equivalente y que puede almacenar
los datos.while controla el proceso de entrada.Si compara esto con la versión original,puede
ver que esta es mucho mas eficiente. De hecho la capacidad para integrar este tipo de
operaciones es una de la razón en el que C es tan potente.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main()
{
FILE *pf;
char cadena[50];
clrscr();
pf = fopen("c:\\fichero.txt", "r"); /*abre el archivo en modo lectura*/
fscanf (pf, "%s", cadena); /*lee desde el fichero la primera palabra Este*/
printf ("Primera palabra: %s\n", cadena); /*Este*/
fseek (pf, 4, SEEK_CUR); /*el puntero apunta actualmente al inicio del archivo y
avanza 4 bytes a la derecha*/
fscanf (pf, "%s", cadena); /*captura la palabra y la guarda en cadena*/
printf ("Tercera palabra: %s\n", cadena); /*texto*/
fseek (pf, -7, SEEK_END); /**/
fscanf (pf, "%s", cadena);
printf ("Ultima palabra: %s\n", cadena); /*fichero*/
fseek (pf, 11, SEEK_SET);
fscanf (pf, "%s", cadena);
printf ("Cuarta palabra: %s\n", cadena); /*texto*/
getch();
fclose (pf);
getch();
}
Este programa un array de 50 elementos con números en punto flotantes los escribe en un
archivo y los vuelve a leer. Este programa escribe cada elemento del array por separado. El
archivo se debe abrir operaciones de letras y números puesto que se están escribiendo los
datos binarios utilizando formato interno.
#include<stdio.h>
#include<conio.h>
struct clientedatos{
int numcta;
char papellido[15];
char nombre[10];
int balance;
};
void main(void)
{
struct clientedatos cliente;
FILE *cfptr;
clrscr();
if((cfptr = fopen("credito.txt","w+")) == NULL)
{
printf("El archivo no pudo ser abierto");
getch();
}
else
{
printf("Introduzca número de cuenta (1 hasta 100, o 0 para salir)\n\n");
scanf("%d",&cliente.numcta);
while(cliente.numcta != 0)
{
printf("Introduzca Apellido, Nombre y Balance: \n");
scanf("%s %s
%d",&cliente.papellido,&cliente.nombre,&cliente.balance);
fseek(cfptr,(cliente.numcta - 1) * sizeof(struct clientedatos),
SEEK_SET);
fwrite(&cliente, sizeof(struct clientedatos), 1,cfptr);
printf("Introduzca número de cuenta(Para salir presione 0): \n");
scanf("%d",&cliente.numcta);
}
}
fclose(cfptr);
}
En el siguiente programa hace lo mismo que el primero pero aquí se utiliza una llamada a
fwrite y fread ya que se escribe todo el array en un solo paso, lo que es mucho mas
eficiente. Esté programa ayuda a ilustrar la potencia de su función y también utilizando
otras de la funciones del sistema de archivos de c, se puede acceder a cualquier lugar de
un archivo en cualquier momento. La función que permite hace esto y es la función fseek.
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
struct DIREC{
char nombre[35];
char tele[20];
};
FILE *pack(FILE *a);
void ordena(FILE *a);
void consulta2(FILE *a);
long busca_Clave2(FILE *a,char buscado[]);
void lee(FILE *a);
void imprime(FILE *a);
void main(){
char opcion;
FILE *archivo;
archivo=fopen ("TELE.txt","wb+"); /* usar opcion "wb+" para crear el archivo .txt y
después cambiar a "rb+" */
while(1){
clrscr();
textattr(6+5*5);
clrscr();
textcolor(YELLOW);
cprintf(" DIRECTORIO TELEFONICO");
printf("\n\n");
cprintf(" N");
printf("uevo");
textcolor(YELLOW);
cprintf(" L");
printf("ista");
textcolor(YELLOW);
cprintf(" B");
printf("aja");
textcolor(YELLOW);
cprintf(" C");
printf("onsulta");
textcolor(YELLOW);
cprintf(" O");
printf("rdena");
textcolor(YELLOW);
cprintf(" S");
printf("alir");
gotoxy(1,25);
printf(" *** PRESIONE LA LETRA RESALTADA PARA ESCOGER LA OPCION
***");
gotoxy(1,4);
opcion=toupper(getch());
if(opcion=='S')
break;
switch(opcion){
case 'N':{
lee(archivo);
break;
}
case 'L':{
imprime(archivo);
break;
}
case 'B':{
pack(archivo);
break;
}
case 'C':{
consulta2(archivo);
break;
}
case 'O':{
ordena(archivo);
break;
}
}
}
clrscr();
fclose (archivo);
normvideo();
clrscr();
}
/*********************************************************************/
void imprime(FILE *a){
int r,y=0,c=1;
struct DIREC reactivo;
clrscr();
textcolor(YELLOW);
cprintf("NOMBRE TELEFONO");
normvideo();
rewind(a);
while(1){
r=fread(&reactivo,sizeof(struct DIREC),1,a);
if(r==0)
break;
if((c%2)!=0){
textattr(6+5*5);
/* textcolor(LIGHTGRAY);*/
printf("\n");
cprintf("%d.- %-30s %16s",c,reactivo.nombre,reactivo.tele);
normvideo();
}
else{
textattr(6+5*4);
/* textcolor(WHITE);*/
printf("\n");
cprintf("%d.- %-30s %16s",c,reactivo.nombre,reactivo.tele);
normvideo();
}
if(y==23){
getch();
y=0;
}
y++;
c++;
}
getch();
}
/*********************************************************************/
void lee(FILE *a){
struct DIREC reactivo;
printf("\n\n");
fflush(stdin);
printf("Nombre : ");strupr(gets(reactivo.nombre)); /*convierte a mayúsculas*/
if(strlen(reactivo.nombre)<30){
if(busca_Clave2(a,reactivo.nombre)==0){
printf("Telefono : ");gets(reactivo.tele);
fseek(a,0,SEEK_END);
fwrite (&reactivo,sizeof(struct DIREC),1,a);
}
else{
printf("\n\nYa existen esos datos!!!");
getch();
}
}
else{
printf("\n\nMáximo 25 letras por nombre...");
printf("\n\nEl programa puede dañarse si repite este error!!!");
getch();
}
}
/*********************************************************************/
long busca_Clave2(FILE *a,char buscado[]){
long p;
struct DIREC r;
rewind(a);
while(1){
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,buscado)==0){
p=ftell(a)/sizeof(struct DIREC);
return(p);
}
}
return 0;
}
/*********************************************************************/
void consulta2(FILE *a){
char nombre[30];
long p;
struct DIREC r;
printf("\n\nDame el nombre a buscar: ");
strupr(gets(nombre));
p=busca_Clave2(a,nombre);
if(p!=0){
fseek(a,(p-1)*sizeof(struct DIREC),SEEK_SET);
fread(&r,sizeof(struct DIREC),1,a);
printf("\n\n\n");
textcolor(LIGHTGRAY);
cprintf("NOMBRE TELEFONO");
normvideo();
printf("\n%-20s %30s",r.nombre,r.tele);
getch();
}
else{
printf("\n\nLa información solicitada no existe ...");
getch();
}
}
/*********************************************************************/
void ordena(FILE *a){
int i=0,j=0,s,t;
struct DIREC r;
struct DIREC temp[100];
struct DIREC temporal;
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
temp[j]=r;
i++;
j++;
}
/*Metodo de la burbuja par a la busqueda*/
for(s=0;s<=1;s++){
temporal=temp[s];
temp[s]=temp[t];
temp[t]=temporal;
}
s=0;
i=0;
while(1){
if(s>=j)
break;
r=temp[s];
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
fwrite (&r,sizeof(struct DIREC),1,a);
s++;
i++;
}
printf("\n\nSus archivos han sido ordenados alfab‚ticamente...");
getch();
/*********************************************************************/
FILE *pack(FILE *a){
int i=0;
long p;
char clave[30];
struct DIREC r;
FILE *t;
t=fopen ("TMP.txt","wb");
printf("\n\nDame el nombre a dar de baja: ");
strupr(gets(clave));
p=busca_Clave2(a,clave);
if(p!=0){
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,clave)!=0){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
fwrite (&r,sizeof(struct DIREC),1,t);
}
i++;
}
fclose (t);
fclose (a);
remove("TELE.txt");
rename("TMP.txt","TELE.TXT");
t=fopen ("TELE.txt","rb+");
printf("\n\nLa informaci¢n solicitada ha sido dada de baja...");
getch();
return(t);
}
else{
printf("\n\nNo existe el nombre...");
getch();
}
return 0;
}
Este programa es un tipo de archivo que ayuda almacenar los nombres de las persona y
los números telefónico pero esto se deben a las funciones while y fseek para compiar los
contenidos del archivo. Y poderlos guardar y ponemos el bucle if,for y while para
condicionar el algoritmo
1. MENU DE OPCIONES CON FICHEROS
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
void escritura(void); /*función prototipo*/
void lectura(void); /*función prototipo*/
void main(void)
{
int opcion;
do
{
clrscr();
printf("Menú de Opciones: \n");
printf("1. Escritura de un Archivo.\n");
printf("2. Lectura de un Archivo.\n");
printf("3. Salida.\n");
printf("Elija su Opcion: ");
scanf("%d",&opcion);
switch(opcion)
{
case 1:
escritura();
break;
case 2:
lectura();
break;
case 3:
exit(1);
getch();
} /*cierre del switch*/
}while (opcion!=3);/*cierre del do*/
}
/****************FUNCION ESCRITURA ****************/
void escritura(void)
{
FILE *pf;
char nombre[10],texto[200],d,nombre_archivo;
int cont=0;
clrscr();
printf("Dame el nombre del archivo a CREAR: ");
fflush(stdin);
gets(nombre);
printf("Ingrese texto al fichero: "); gets(texto);
strcpy(nombre_archivo,"C:\\");
strcat(nombre_archivo,nombre);
strcat(nombre_archivo,".txt");
pf=fopen(nombre_archivo,"w");
while(texto[cont]!='\0')
{
fputc(texto[cont],pf);
cont++;
}
getch();
fclose(pf);
}
fwrite esta función está pensada para trabajar con registros de logintud constante y forma
con fread. Es capaz de escribir hacia un fichero uno o varios registros de la misma
longitud almacenados a partir de una dirección o memoria determinada. El valor de
retorno es el numero de registros escritos escrito. Y utilizamos el do while un bucle para
que pueda correr con mas potencia el programa.
