ALMACENAMIENTO EXTERNO DE DATOS (FICHEROS)

OBJETIVOS
• Dar a conocer las diversas formas de almacenamiento externo
de datos en la computadora.
• Dar las pautas necesarias para el tratamiento de archivos.
• Proporcionar las diferentes estructuras Sintácticas de la
gramática del lenguaje C en el manejo de Archivos.

METAS
• El alumno obtendrá habilidades en el manejo de Archivos
• El alumno será capas de resolver diferentes problemas sobre
la temática con eficiencia y eficacia.

CAMPO DE APLICACION
Construcción de sistemas que manejen datos completos de
instituciones como ser, manejo de planillas de sueldos,
manejo de bibliotecas, listas de alumnos y notas,
recuperación de gráficos en sus diferentes formatos y otras
referente al manejo de volúmenes de información.
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 1 DE 34
Necesidad de las memorias secundarias.
• La Memoria Principal es rápida pero cara, de poca capacidad y generalmente
volátil.
• La Memoria Secundaria es lenta pero barata, de alta capacidad y no volátil.
Para el procesamiento es necesario transferir la información a memoria principal.

Pirámide de memorias en un ordenador.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 2 DE 34

 EVOLUCIÓN DE LOS SISTEMAS DE PROCESAMIENTO.
– Sistemas orientados al proceso:
• Datos integrados
• Ficheros secuenciales.
• Ficheros jerárquicos.
– Sistemas orientados a los datos:
• Sistemas de Gestión de Bases de Datos.
DEFINICIÓN DE FICHERO
Conjunto de información relacionada, tratada como una unidad de almacenamiento
en memoria secundaria y organizada de forma estructurada para facilitar la
búsqueda de datos individuales.
Un fichero está compuesto por registros homogéneos que contienen información
organizada en campos.
La idea más común del concepto de fichero es un
conjunto de posiciones de memoria situadas en un
disco de los dispositivos externos de
almacenamiento del sistema, en las cuales
podemos almacenar y recuperar información.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 3 DE 34

• Fichero: conjunto de datos almacenado en cualquier dispositivo informático.
• Datos: conjunto de registros.
• Registro: conjunto de campos.
• Campos: almacena un dato de un tipo concreto, información individual.
• Tipos de ficheros:
– aplicación (*.cpp, *.h, *.prj) – datos (*.dat, etc.)

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 4 DE 34

En un lenguaje de alto nivel, el fichero no es manejado directamente por el propio
programa, sino por el Sistema Operativo. Esto facilita que los programas sean
Transportables.

El lenguaje C nos proporciona un acceso secuencial y directo a los registros de un

fichero, pero no soporta el acceso indexado a un registro dado.
Los ficheros en C los podemos clasificar, según la información que contengan, en
dos grupos: ficheros de texto y ficheros binarios.
• Los ficheros de texto se caracterizan por estar compuestos por una serie de caracteres
organizados en líneas terminadas por un carácter de nueva línea (carácter '\n'). Esto nos
hace pensar en la idea de usar la impresora como si fuese un fichero de texto.
• Por otro lado, los ficheros binarios constan de una secuencia de bytes. Podemos decir
que cualquier fichero que no sea de texto, será binario.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 5 DE 34

A la hora de trabajar con ficheros, tendremos que especificar antes de usarlos, si
serán de texto o binarios.
Podemos establecer una segunda clasificación de los ficheros, atendiendo al modo
de acceso a su información. De este modo, distinguiremos entre ficheros
secuenciales y ficheros directos.
Los ficheros de acceso secuencial se basan en el hecho de que,
para acceder a una determinada posición de los mismos, hemos de
recorrer desde el principio todas las posiciones hasta llegar a la
deseada. Las impresoras son un claro ejemplo de acceso
secuencial, así como las cintas magnéticas.
DISPOSITIVOS DE ACCESO SECUENCIAL (CINTAS)
• Grabación. Se agrupan registros en bloques separados por marcas (,%*). Los
ficheros se almacenan en bloques contiguos y se separan también por marcas
((2)).
• Recuperación. Se leen bloques completos de forma secuencial.
• Ventajas. Baratos, robustos y compactos.
• Desventajas. Sólo admiten acceso secuencial.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 6 DE 34

 Con el uso de ficheros de acceso directo podemos acceder de
forma directa a la posición que queramos sin tener que pasar por
las posiciones anteriores. El dispositivo de acceso directo por
excelencia es el disco magnético.

DISPOSITIVOS DE ACCESO DIRECTO (DISCOS)

Grabación. Los registros se agrupan en bloques denominados “VHFWRUHV”, que
a su vez se agrupan en “SLVWDV” y “FLOLQGURV”. El acceso se efectúa de
forma directa. Recuperación. Acceso a un bloque arbitrario.
Ventajas. Acceso directo y rápido.
Desventajas. Alto coste.

La vida de todo fichero comienza cuando se crea y acaba cuando se borra.

Durante su vida se pueden realizar las siguientes operaciones básicas sobre el
fichero completo:
Creación,
Borrado o destrucción,
Copia,
Clasificación u ordenación,
Fusión o mezcla,
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 7 DE 34
Operaciones sobre los registros individuales del fichero (Realizadas mediante
primitivas por los programas).
• Operación de Apertura del fichero.
• Recuperación y Consulta de registros. (lectura)
• Actualización de registros. (escritura)
o Modificación de registros.
o Eliminación de registros.
o Inserción de nuevos registros.
• Operación de Cierre del fichero.

El formato de declaración de un fichero es el siguiente:

FILE * nom_ var_fich;
Su estructura sintáctica es :
FILE Nom_var_Fich ;
*
Nom_var_Fich ,
*
La estructura FILE se encuentra definida en el archivo de cabecera stdio.h, por tal
motivo es necesario incluirla en todos los programas que trabajen con ficheros
mediante la conocida directiva #include <stdio.h>
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 8 DE 34
 ACCESO SECUENCIAL A FICHEROS.
Las operaciones sobre un archivo de acceso secuencial (tipo texto) son las
siguientes:
1. Declaración del archivo tipo texto.
2. Apertura del archivo en un modo específico.
3. Tratamiento de los datos que tiene el archivo.
4. Cerrado del archivo.
La primera operación después de declarar un fichero y antes de
cualquier otra operación con él es abrirlo. Con la intrucción fopen
Formato:
<variable_fichero> = fopen (<nombre_fichero>, <modo acceso>);
Donde:
variable_fichero es la variable declarada de la forma: FILE *<variable_fichero>
nombre_fichero es el nombre que tendrá el fichero en el dispositivo usado. Podrá
ser variable o constante.
modo acceso es el modo de apertura del fichero, mediante el cual le diremos al
compilador si se trata de un fichero de texto o binario, y si vamos a leer o escribir
en el fichero.
Diagrama de Sintaxis:
variable nombre modo
fopen ( , ) ;
_fichero = _fichero acceso

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 9 DE 34

Los distintos modos de abrir un fichero son los siguientes:

Modo Significado
r Abre un archivo de texto para solo lectura. Si el archivo no existe, devuelve un error
w Abre el archivo de texto para solo escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
a Abre el archivo de texto para añadir al final. Si el fichero no existe, lo crea.
r+ Abre el archivo de texto para lectura/escritura. Si el fichero no existe, da un error
w+ Abre el archivo de texto para lectura/escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
a+ Abre el archivo de texto para añadir al final, con opción de lectura. Si el fichero no existe, lo crea.
rb Abre un archivo binario para solo lectura. Si el archivo no existe, devuelve un error
wb Abre el archivo binario para solo escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
ab Abre el archivo binario para añadir al final. Si el fichero no existe, lo crea.
rb + Abre el archivo binario para lectura/escritura. Si el fichero no existe, da un error
wb + Abre el archivo binario para lectura/escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
ab + Abre el archivo binario para añadir al final, con opción de lectura. Si el fichero no existe, lo crea.

Decir que los ficheros de texto se pueden referenciar también como "rt", "wt", "at", "rt+",
"wt+" y "at+", pero para facilitar más las cosas, cuando no especificamos si queremos abrir
un fichero de texto o binario, por defecto se supone que es de texto, es por ello que los
modos "r", "w" y "a" se refieren a ficheros de texto.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 10 DE 34

PARA CERRAR EL FICHERO
fclose <valor> = fclose (<variable_fichero>);
Donde:
• valor es el valor que nos dirá si ha ocurrido algún error cerrando
el fichero. 0 indica que todo ha ido bien.
• variable_fichero es la variable declarada de la forma: FILE *<variable_fichero>
Cuando terminemos de trabajar con un fichero hemos de realizar la operación de cierre del
fichero. Si no lo hacemos podemos ocasionar la pérdida de todos los datos del mismo.
Su diagrama de Sintaxis es el siguiente:
= fclose ( Variable_fichero ) ;

Valor

Si se necesitan cerrar varios ficheros a la vez, nos podemos ahorrar varios fclose utilizando
la funcion fcloseall.
fcloseall <numero_ficheros> = fcloseall();
Donde:
• numero_ficheros es una variable entera que indica el
número de ficheros cerrados, o EOF si ha ocurrido un error.
Su diagrama de Sintaxis es el siguiente:

= fcloseall ( ) ;

Valor
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 11 DE 34
PARA REALIZAR EL TRATAMIENTO DE LA INFORMACIÓN.
Ahora veamos una serie de funciones para escribir y leer datos de un fichero de texto.
putc : Esta función escribe un carácter en un fichero de texto. Devuelve un entero si la
escritura es correcta. De otra forma devuelve el valor EOF que indica que ha habido un
error. Su formato es:
putc (<carácter>, <var_fich>);
Donde: carácter es el carácter que se desea escribir en el fichero.
var_fich es la variable declarada como FILE.
putc ( carácter , var fich ) ;

Ejemplos: putc ('a', f1); c = 'G'; putc (c, f1);

getc : Esta función lee un carácter de un fichero de texto abierto en modo lectura. Devuelve
un entero si la lectura es correcta. De otra forma devuelve el valor EOF que indica que
hemos llegado al final del fichero. Su formato es:
<carácter> = getc (<var_fich>);
Donde: carácter es la variable que contendrá el carácter leído del fichero.
var_fich es la variable declarada como FILE.

carácter = getc ( var fich ) ;

Ejemplos: c = getc (f1);

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 12 DE 34
#include <string.h>
void carta(void)
#include <stdio.h>
{
#include <conio.h>
char ch;
pf = fopen("DATOS.DAT",
void carta(void);
"w");
void mostrar(void);
FILE *pf; do
{ ch=getch();
putch(ch);
int main(void)
fputc(ch,pf);
{
}while(ch!='*');
clrscr();
fclose(pf);
carta();
} void mostrar(void)
mostrar();
return 0; {
} char ch;
pf = fopen("DATOS.DAT", "r");
do
{ ch = fgetc(pf);
putch(ch);
} while (ch != EOF);
fclose(pf);
}

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 13 DE 34

getw : Esta función devuelve un entero leído de un fichero binario. Su sintaxis es:
<num_entero> = getw (<var_fich>);
Donde: num_entero es la variable que contendrá el valor entero leído del fichero.
var_fich es la variable declarada como FILE.

Num_entero = getw ( var fich ) ;

Ejemplos:
i = getw (fich);
printf ("%d\n", getw (fich));

putw
Esta función escribe un entero en un fichero binario. Su sintaxis es:
putw (<num_entero>, <var_fich>);
Donde: num_entero es el valor entero que se escribirá en el fichero.
var_fich es la variable declarada como FILE.

putw ( Num_entero , var fich ) ;

Ejemplos:
putw (5, fich);
i = 99; putw (i, fich);

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 14 DE 34

#include <stdio.h>
#include <stdlib.h> void crear(void)
#include<conio.h> {
pf = fopen("datos.dat", "wb");
FILE *pf; do {
int dato; scanf("%i",&dato);
putw(dato,pf);
void crear(void); }while(dato!=0);
void leer(void); fclose(pf);
}
int main(void)
{ void leer(void)
clrscr(); {
crear(); pf = fopen("datos.dat", "rb");
leer(); while (!feof(pf))
return 0; {
} dato = getw(pf);
printf("%i\t",dato);
}
fclose(pf);
}
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 15 DE 34
fputs : Esta función escribe una cadena de caracteres en un fichero de texto. Su formato es:
fputs (<cadena>, <var_fich>);
Donde: cadena es el cadena que se desea escribir en el fichero.
var_fich es la variable declarada como FILE.
fputs ( cadena , var fich ) ;

Ejemplos: fputs ("hola\n", f1);

strcpy (cad, "hola\n"); fputs (cad, f1);

fgets : Esta función lee un número de caracteres de un fichero almacenándolos en una

cadena. Si se encuentra el carácter de nueva línea ya no almacenará más caracteres. Su
formato es:
fgets (<cadena>, <num_caracteres>, <var_fich>);
Donde: cadena es la variable que almacenará la cadena leída del fichero.
num_caracteres es el número de caracteres que se desea leer.
var_fich es la variable declarada como FILE.

fgets ( cadena , Num caractere , var fich ) ;

Ejemplos: fgets (cad, 5, f1);

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 16 DE 34

#include<stdio.h> void crear(void)
#include<conio.h> { char nom[10];
#include<string.h> printf("Para terminar <*>\n");
pf=fopen("datos.dat","w");
FILE *pf; do {
void crear(void); gets(nom);
void mostrar(void); fputs(nom,pf);
} while (nom[0]!='*');
main() fclose(pf);
{ }
clrscr();
crear();
mostrar(); void mostrar(void)
return 0; { char nom[10];
} pf=fopen("datos.dat","r");
while (!feof(pf))
{
fgets(nom,10,pf);
printf("%s\n",nom);
}
fclose(pf);
}

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 17 DE 34

fscanf : Esta función trabaja de la misma manera que scanf, pero leyendo los datos
formateados de un fichero. Su sintaxis es:
fscanf (<var_fich>, <cadena_de_control>, <lista_variables>);
Donde: var_fich es la variable declarada como FILE.
cadena_de_control son las cadenas de control que se desean leer, %d, %s, %f, %x,
lista_variables son las variables que contendrán los valores de la lectura del fichero
que deben coincidir con sus respectivas cadenas de control.

fscanf ( , , ) ;
var fich cad de control lista variables

Ejemplos: fscanf (fich, "%s%d%f", nombre, &edad, &altura);

fprintf : Esta función trabaja de la misma manera que printf, pero

escribiendo los datos formateados sobre un fichero. Su sintaxis es:
fprintf (<var_fich>, <cadena_de_control>, <lista_variables>);
Donde: var_fich es la variable declarada como FILE.
cadena_de_control son las cadenas de control que se desean escribir, %d, %s, %f, %x,
lista_variables son las variables que contendrán los valores para la escritura en el
fichero que deben coincidir con sus respectivas cadenas de control.

fprintf ( , , ) ;
var fich cad de control lista variables

Ejemplos: fprintf (fich, "%s%d%f", nombre, edad, altura);

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 18 DE 34

#include<stdio.h> void crear(void)
#include<conio.h> { char nom[10];
#include<string.h> printf("Para terminar <*>\n");
pf=fopen("datos.dat","w");
FILE *pf; do {
void crear(void); gets(nom);
void mostrar(void); fprintf(pf,"%10s",nom);
} while (nom[0]!='*');
main() fclose(pf);
{ }
clrscr(); void mostrar(void)
crear(); { char nom[10];
mostrar(); pf=fopen("datos.dat","r");
return 0; while (!feof(pf))
} {
fscanf(pf,"%10s",nom);
printf("%s\n",nom);
}
fclose(pf);
}

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 19 DE 34

OTRAS INTRUCCIONES COMUNMENTE EMPLEADAS.

feof : Esta función nos devuelve un número positivo si hemos llegado al final de un fichero
binario. De otro modo, nos devuelve un cero. Su sintaxis es:
<valor> = feof (<var_fich>);
Donde: valor es el valor que nos indica si ha llegado a final de fichero.
var_fich es la variable declarada como FILE.

valor = feof ( var_fich ) ;

Ejemplos: while (!feof(f1)) { fread (....); }

Este bucle significa "mientras no sea final de fichero leer..."

ferror : Determina si una operación con archivos ha sido errónea o no. Si lo ha sido
devuelve un número positivo, y si no ha habido problema, devuelve un 0. Su sintaxis es:
<valor> = ferror (<var_fich>);
Donde: valor es el valor que nos indica si ha ocurrido un error.
var_fich es la variable declarada como FILE.

valor = ferror ( var_fich ) ;

Ejemplo:
fwrite (&dato, sizeof(dato), 1, fich);
if (ferror(fich)) printf ("Error de escritura\n");
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 20 DE 34
rewind : Esta función restablece el localizador de posición del archivo al comienzo del
mismo. Su sintaxis es:
rewind (<var_fich>);
Donde: var_fich es la variable declarada como FILE.

rewind ( var_fich ) ;

Por ejemplo, si estamos leyendo secuencialmente el fichero fich y vamos por el cuarto dato,
al hacer rewind(fich), volveríamos al principio del fichero y podríamos volver a leer el
primer dato, como si lo abriésemos de nuevo para lectura.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 21 DE 34

 ACCESO ALEATORIO O DIRECTO A UN FICHERO
Ya hemos visto como acceder secuencialmente a un fichero, sin embargo también se puede
hacer de forma directa.
Las operaciones sobre un archivo de acceso aleatorio (Archivo con tipo) son las
siguientes:
1. Declaración del archivo tipo texto.
2. Apertura del archivo en un modo específico.
3. Tratamiento de los datos que tiene el archivo.
4. Cerrado del archivo.
La operaciones 1,2,4 son básicamente las mismas que en los archivos secuenciales.

Supongamos que tenemos definido un fichero con la siguiente estructura de registro:

struct
{ int codigo;
char nomart[31];
float precio;
}articulo;

Es evidente que la longitud de cada registro es de 37 bytes (2+31+4 bytes). De esta forma,
la disposición de los registros dentro del fichero en disco se realiza en las siguientes
posiciones:

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 22 DE 34

El acceso directo consiste en indicar la posición a la que
queremos acceder en bytes. Por ejemplo, para acceder
directamente al registro 2, indicaremos que queremos ir al
byte 37, contando desde el principio del registro. La orden
que posibilita este acceso es la siguiente.
fseek :
<valor> = fseek (<var_fich>, <dirección>, <desde>);
Donde: valor es el valor que nos dirá si ha ocurrido un
error al desplazarnos por el fichero. 0 si todo
ha ido bien.
var_fich es el puntero al fichero que estamos utilizando.
dirección es el número de bytes que vamos a desplazarnos.
desde es el punto de partida del desplazamiento. Este punto admite tres
posibles valores:
Referencia Valor Desde
SEEK_SET 0 Principio de fichero
SEEK_CUR 1 Posición actual del fichero
SEEK_END 2 Final del fichero

valor = fseek ( var_fich , dirección , desde ) ;

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 23 DE 34

ftell : nos devuelve la posición en la que nos encontramos dentro del fichero
<posición> = ftell (<var_fich>);
Donde: posición es la variable que contendrá la posición en bytes en la que nos
encontramos en ese momento en el fichero.
var_fich es la variable declarada como FILE.

posición = ftell ( var_fich ) ;

Esta función se suele usar, a parte de para saber la situación exacta en el fichero, para
obtener la longitud del mismo. Veamos un ejemplo:
...
if ((f=fopen("articul.dat", "rb")) == NULL)
{
printf ("Imposible crear fichero\n");
exit (1);
}
fseek (f, 0, 2); /* tambien puede ser fseek (f, 2, SEEK_END); */
l = ftell(f);
printf ("El fichero tiene un tamaño de %ld bytes\n", l);
printf ("Y un total de %ld registros\n", l/sizeof(reg));
/* donde reg sería la estructura o el dato simple contenido en el fichero */
...

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 24 DE 34

fsetpos : Esta función pone el puntero del archivo en la posición deseada.
fsetpos(<puntero_del_fichero>,<posicion>);

Donde : puntero_del_fichero es el puntero del fichero.

posición nueva posición a la que apunta el puntero

fsetpos ( puntero_del_fichero , posicion ) ;

La función fsetpos devuelve cero si no ocurre un error y un valor distinto a cero, en caso
contrario.

fgetpos : Esta función devuelve la posición de un determinado registro en el archivo.

fgetpos ( <puntero_fichero>,<posición>);

Donde : puntero_fichero es el puntero al fichero.

Posición es la variable en la que se devuelve la posición del registro.

fgetpos ( puntero_del_fichero , posicion ) ;

La función fgetpos devuelve cero si no ocurre un error y un valor distinto de cero, en caso
contrario.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 25 DE 34

fwrite : Esta función permite escribir uno o más datos o bloques de datos binarios en un
fichero. Su formato es el siguiente:
fwrite (<dato>, <num_bytes>, <cont>, <var_fich>);
Donde: dato es el dato o datos que se van a escribir en el fichero. Hemos de
especificar su dirección de memoria mediante el operador "&".
num_bytes es el número de bytes que se van a escribir. Lo más corriente es
usar para este argumento el operador sizeof sobre el dato a escribir.
cont es el número de datos, de num_bytes cada uno que se van a escribir.
var_fich es el puntero al fichero binario usado.
fwrite ( , num bytes , , ) ;
Dato cont Var fich
fread : Esta función permite leer uno o más datos o bloques de datos de un fichero binario.
Su formato es:
fread (<dato>, <num_bytes>, <cont>, <var_fich>);
Donde: dato es la variable donde se guardarán los datos leídos del fichero. Hemos de
indicar su dirección por tratarse de un puntero.
num_bytes es el número de bytes que se van a leer del fichero. Lo más
corriente es usar para este argumento el operador sizeof.
cont es el número de datos, de num_bytes cada uno que se van a leer.
var_fich es el puntero al fichero binario usado.

fwrite ( , num bytes , , ) ;

Dato cont Var fich

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 26 DE 34

#include<stdio.h>
#include<conio.h> void leeremp(void)
#include<ctype.h> {
struct empleado { clrscr();
char nom[10],app[10],apm[10]; printf("Nombre = ");
int edad,fono; gets(emp.nom);
float esta; printf("Ap. Paterno = ");
} emp; gets(emp.app);
FILE *pf; printf("Ap. Materno = ");
void leeremp(void); gets(emp.apm);
void mostraremp(void); printf("Edad = ");
void crear(void); scanf("%d",&emp.edad);
void mostrar(void); printf("Telefono = ");
void truco(void); scanf("%d",&emp.fono);
printf("Estatura = ");
main() scanf("%f%*c",&emp.esta);
{ clrscr(); }
truco();
crear();
mostrar();
return 0;
}

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 27 DE 34

void crear(void) void mostraremp(void)
{ char op; {
pf=fopen("datos.dat","w"); clrscr();
do { printf("Nombre = %s\n",emp.nom);
leeremp(); printf("Ap. Paterno = %s\n",emp.app);
fwrite(&emp,sizeof(struct empleado),1,pf); printf("Ap. Materno = %s\n",emp.apm);
printf("\n\nMas datos <s/n>"); printf("Edad = %d\n",emp.edad);
scanf("%c%*c",&op); printf("Telefono = %d\n",emp.fono);
} while (tolower(op)!='n'); printf("esta = %f\n",emp.esta);
fclose(pf); getch();
} }

void mostrar(void)
{ char nom[10];
//lectura de reales en estructuras pf=fopen("datos.dat","r");
void truco(void) while (!feof(pf))
{ float q,*s; {
s=&q; fread(&emp,sizeof(struct empleado),1,pf);
q=*s; mostraremp();
} }
fclose(pf);
}
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 28 DE 34
 OPERACIONES QUE SE REALIZAN CON LOS DATOS

• La forma de dar de alta registros es igual que para el acceso secuencial. Se hará un
recorrido hasta llegar al final del fichero para comprobar que no existe el código del
registro a dar de alta, y en ese caso, se procede a hacer fwrite. Abriremos para ello el
fichero en modo añadir.
• Las bajas consisten en localizar el registro según un código, y escribir un registro vacío
en tal posición. Para ello tendremos que abrir el fichero en modo lectura/escritura, o
sea, "r+".
• Las modificaciones, de forma similar a las bajas pero escribiendo en el lugar
correspondiente el registro modificado que reemplace al actual.
• Las consultas no son otra cosa que un acceso directo al código indicado.
• Y por último los listados, que consisten en un recorrido secuencial desde el primer
registro hasta el último.

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 29 DE 34

#include<stdio.h>
#include<string.h>
#include<conio.h> void creadic(void)
struct dicc{ {
char palabra[10],signif[50]; int op;
}pal; dicio=fopen("diciona.dat","w");
FILE *dicio; do {
FILE *cart; printf("\npalabra ");
int error=0,buenas=0; gets(pal.palabra);
void creadic(void); printf("significado ");
void creacarta(void); gets(pal.signif);
void buscar(char ccc[10]): fwrite(&pal, sizeof(pal),1,dicio);
void corregir(void) printf("Mas datos s/n ");
main() op=getch();
{/* creadic(); }while(op!='n');
clrscr(); creacarta();*/ fclose(dicio);
clrscr(); }
corregir();
clrscr();
printf("Palabras Correctas %d\n",buenas);
printf("Palabras Incorrectas %d\n",error);
getch();
return 0;
}
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 30 DE 34
 int buscar(char ccc[10]) void corregir(void)
{ int sw=1; {
dicio=fopen("diciona.dat","r"); char c=' ';
fseek(dicio,0,SEEK_SET); char palabra[20]="",aux[20];
do { cart=fopen("carta.dat","r");
fread(&pal,sizeof(pal),1,dicio); while (!feof(cart))
if (strcmp(pal.palabra,ccc)==0) {
{ sw=0; break;} c=fgetc(cart);
} while (!feof(dicio)); if (c!= ' ' && c!='\n')
fclose(dicio); { strcpy(aux,palabra);
return sw; sprintf(palabra, "%s%c",aux,c);
} }
else
{ if(buscar(palabra)==1) error++;
void creacarta(void) else buenas ++;
{ strcpy(palabra,"");
char c; }
cart=fopen("carta.dat","w"); }
printf("Introduzca datos <.> fclose(cart);
Para terminar \n"); }
do {
scanf("%c",&c);
fputc(c,cart);
} while(c!='.');
fclose(cart);
}
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 31 DE 34
 OPERACIONES CON LOS ARCHIVOS
remove : Esta función borra fisicamente el archivo que se especifique. Devuelve un 0 si
todo ha salido correctamente o un -1 si ha ocurrido un error. Su sintaxis es:
<valor> = remove (<nombre_archivo>);
Donde: valor es el valor que nos dirá si ha ocurrido un error al borrar el fichero.
nombre_archivo es el nombre del fichero que se desea borrar, o sea, que se
refiere a una cadena de caracteres y no al identificador del fichero.
valor = remove ( nombre_archivo ) ;
Ejemplos: remove ("datos.dat"); strcpy (nombre, "texto.txt"); remove (nombre);
rename : Esta función renombra un fichero especificado. Devuelve 0 si el cambio de
nombre ha sido correcto, y -1 si no lo ha sido. Su sintaxis es:
<valor> = rename (<nombre_actual>, <nuevo_nombre>);
Donde: valor es el valor que nos dirá si ha ocurrido un error al renombrar el fichero.
nombre_actual es el nombre actual del fichero que se desea renombrar. Se
refiere a una cadena, y no al identificador del fichero.
nuevo_nombre es el nuevo nombre que se le desea asignar al fichero. Se
refiere a una cadena, y no al identificador del fichero.

valor = rename ( nombre_actual , nuevo_nombre ) ;

Ejemplos: strcpy (viejo, "clientes.xxx\0"); strcpy (nuevo, "clientes.dat\0);

rename (viejo, nuevo);
SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 32 DE 34
#include<conio.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
void leer_archi(char *nombre);

void main(void)
{
int driver,modo;
detectgraph(&driver,&modo);
initgraph(&driver,&modo,"e:\\borlandc\\bgi");
leer_archi("splash.bmp");
getch();
closegraph();
}

SIS-1101 ING. CARLOS BALDERRAMA V. PAG. 33 DE 34

void leer_archi(char *nombre)
{ case 0x80008000: colores[i]=MAGENTA; break;
FILE *archi;
unsigned int anchoc,ancho,alto,i,j;
unsigned long ver_color;
unsigned char colores[16],carac;
archi = fopen(nombre,"r+");
fseek(archi,18, SEEK_SET);
/* Lectura del ancho del bitmap */
fread(&ancho,sizeof(unsigned int),1,archi);
fseek(archi, 2, SEEK_CUR);
/* Lectura del alto del bitmap */
fread(&alto ,sizeof(unsigned int),1,archi);
/* printf("%02d %02d",ancho,alto);*/
fseek(archi,29,SEEK_CUR);
/* Lectura de los colores definidos en el
bitmap */
for(i=0;i<16;i++)
{ fread(&ver_color ,sizeof(unsigned
long),1,archi);
switch(ver_color)
{ case 0x00000000: colores[i]=BLACK;
break;
case 0x80000000: colores[i]=RED;
break;
case 0x00800000: colores[i]=GREEN;
break;
case 0x80800000: colores[i]=BROWN;
break;
SIS-1101 ING. CARLOS BALDERRAMA V.
case 0x00008000: colores[i]=BLUE; break;
case 0x00808000: colores[i]=CYAN; break;
case 0xC0C0C000: colores[i]=LIGHTGRAY; break;
case 0x80808000: colores[i]=DARKGRAY; break;
case 0xFF000000: colores[i]=LIGHTRED; break;
case 0x00FF0000: colores[i]=LIGHTGREEN;break;
case 0xFFFF0000: colores[i]=YELLOW ; break;
case 0x0000FF00: colores[i]=LIGHTBLUE; break;
case 0xFF00FF00: colores[i]=LIGHTMAGENTA;
break;
case 0x00FFFF00: colores[i]=LIGHTCYAN; break;
case 0xFFFFFF00: colores[i]=WHITE; break;
default : colores[i]=WHITE;
}
}
fread(&colores ,sizeof(unsigned char),1,archi);
/* Lectura del bitmap codificado en colores */
if(ancho % 8) anchoc = (ancho / 8 +1) * 4 ;
else anchoc = ancho / 2;
for(i=0;i<alto;i++)
{ for(j=0;j<anchoc;j++)
{ fread(&carac ,sizeof(unsigned char),1,archi);
putpixel(j*2,getmaxy()-i,colores[carac>>4]);
putpixel(j*2+1,getmaxy()-i,colores[carac & 0x0f]);
}
}
fclose(archi);
}
PAG. 34 DE 34