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 Sintcticas de la
gramtica 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 temtica con eficiencia y eficacia.
CAMPO DE APLICACION
Construccin de sistemas que manejen datos completos de
instituciones como ser, manejo de planillas de sueldos,
manejo de bibliotecas, listas de alumnos y notas,
recuperacin de grficos en sus diferentes formatos y otras
referente al manejo de volmenes de informacin.
SIS-1101

ING. CARLOS BALDERRAMA V.

PAG. 1

DE 34

Necesidad de las memorias secundarias.

La Memoria Principal es rpida pero cara, de poca capacidad y generalmente
voltil.
La Memoria Secundaria es lenta pero barata, de alta capacidad y no voltil.
Para el procesamiento es necesario transferir la informacin a memoria principal.

Pirmide de memorias en un ordenador.

SIS-1101

ING. CARLOS BALDERRAMA V.

PAG. 2

DE 34

EVOLUCIN DE LOS SISTEMAS DE PROCESAMIENTO.

Sistemas orientados al proceso:
Datos integrados
Ficheros secuenciales.
Ficheros jerrquicos.
Sistemas orientados a los datos:
Sistemas de Gestin de Bases de Datos.

DEFINICIN DE FICHERO
Conjunto de informacin relacionada, tratada como una unidad de almacenamiento
en memoria secundaria y organizada de forma estructurada para facilitar la
bsqueda de datos individuales.
Un fichero est compuesto por registros homogneos que contienen informacin
organizada en campos.
La idea ms comn 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 informacin.

SIS-1101

ING. CARLOS BALDERRAMA V.

PAG. 3

DE 34

 Fichero: conjunto de datos almacenado en cualquier dispositivo informtico.

Datos: conjunto de registros.
Registro: conjunto de campos.
Campos: almacena un dato de un tipo concreto, informacin individual.
Tipos de ficheros:
aplicacin (*.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, segn la informacin 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 lneas terminadas por un carcter de nueva lnea (carcter '\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

sern de texto o binarios.
Podemos establecer una segunda clasificacin de los ficheros, atendiendo al modo
de acceso a su informacin. 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 posicin 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 magnticas.
DISPOSITIVOS DE ACCESO SECUENCIAL (CINTAS)
Grabacin. Se agrupan registros en bloques separados por marcas (,%*). Los
ficheros se almacenan en bloques contiguos y se separan tambin por marcas
((2)).
Recuperacin. Se leen bloques completos de forma secuencial.
Ventajas. Baratos, robustos y compactos.
Desventajas. Slo 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 posicin que queramos sin tener que pasar por
las posiciones anteriores. El dispositivo de acceso directo por
excelencia es el disco magntico.
DISPOSITIVOS DE ACCESO DIRECTO (DISCOS)
Grabacin. Los registros se agrupan en bloques denominados VHFWRUHV, que
a su vez se agrupan en SLVWDV y FLOLQGURV. El acceso se efecta de
forma directa. Recuperacin. Acceso a un bloque arbitrario.
Ventajas. Acceso directo y rpido.
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 bsicas sobre el
fichero completo:
Creacin,
Borrado o destruccin,
Copia,
Clasificacin u ordenacin,
Fusin 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).
Operacin de Apertura del fichero.
Recuperacin y Consulta de registros. (lectura)
Actualizacin de registros. (escritura)
o Modificacin de registros.
o Eliminacin de registros.
o Insercin de nuevos registros.
Operacin de Cierre del fichero.
El formato de declaracin de un fichero es el siguiente:
FILE * nom_ var_fich;
Su estructura sintctica 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. Declaracin del archivo tipo texto.
2. Apertura del archivo en un modo especfico.
3. Tratamiento de los datos que tiene el archivo.
4. Cerrado del archivo.
La primera operacin despus de declarar un fichero y antes de
cualquier otra operacin con l es abrirlo. Con la intruccin 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
_fichero
SIS-1101

fopen

nombre
_fichero

ING. CARLOS BALDERRAMA V.

modo
acceso

)
PAG. 9

;
DE 34

Los distintos modos de abrir un fichero son los siguientes:

Modo
r
w
a
r+
w+
a+
rb
wb
ab
rb +
wb +
ab +

Significado
Abre un archivo de texto para solo lectura. Si el archivo no existe, devuelve un error
Abre el archivo de texto para solo escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
Abre el archivo de texto para aadir al final. Si el fichero no existe, lo crea.
Abre el archivo de texto para lectura/escritura. Si el fichero no existe, da un error
Abre el archivo de texto para lectura/escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
Abre el archivo de texto para aadir al final, con opcin de lectura. Si el fichero no existe, lo crea.
Abre un archivo binario para solo lectura. Si el archivo no existe, devuelve un error
Abre el archivo binario para solo escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
Abre el archivo binario para aadir al final. Si el fichero no existe, lo crea.
Abre el archivo binario para lectura/escritura. Si el fichero no existe, da un error
Abre el archivo binario para lectura/escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
Abre el archivo binario para aadir al final, con opcin de lectura. Si el fichero no existe, lo crea.

Decir que los ficheros de texto se pueden referenciar tambin como "rt", "wt", "at", "rt+",
"wt+" y "at+", pero para facilitar ms 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 algn 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 operacin de cierre del
fichero. Si no lo hacemos podemos ocasionar la prdida 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
nmero 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 INFORMACIN.

Ahora veamos una serie de funciones para escribir y leer datos de un fichero de texto.
putc : Esta funcin escribe un carcter 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 (<carcter>, <var_fich>);
Donde: carcter es el carcter que se desea escribir en el fichero.
var_fich es la variable declarada como FILE.
putc
Ejemplos:

carcter

putc ('a', f1);

c = 'G';

var fich

putc (c, f1);

getc : Esta funcin lee un carcter 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:
<carcter> = getc (<var_fich>);
Donde: carcter es la variable que contendr el carcter ledo del fichero.
var_fich es la variable declarada como FILE.
carcter

getc

var fich

Ejemplos: c = getc (f1);

SIS-1101

ING. CARLOS BALDERRAMA V.

PAG. 12

DE 34

#include <string.h>
#include <stdio.h>
#include <conio.h>
void carta(void);
void mostrar(void);
FILE *pf;
int main(void)
{
clrscr();
carta();
mostrar();
return 0;
}

void carta(void)
{
char ch;
pf = fopen("DATOS.DAT",
"w");
do
{ ch=getch();
putch(ch);
fputc(ch,pf);
}while(ch!='*');
fclose(pf);
}
void mostrar(void)
{
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 funcin devuelve un entero ledo de un fichero binario. Su sintaxis es:
<num_entero> = getw (<var_fich>);
Donde:
num_entero es la variable que contendr el valor entero ledo 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 funcin 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>
#include<conio.h>
FILE *pf;
int dato;
void crear(void);
void leer(void);
int main(void)
{
clrscr();
crear();
leer();
return 0;
}

SIS-1101

void crear(void)
{
pf = fopen("datos.dat", "wb");
do {
scanf("%i",&dato);
putw(dato,pf);
}while(dato!=0);
fclose(pf);
}
void leer(void)
{
pf = fopen("datos.dat", "rb");
while (!feof(pf))
{
dato = getw(pf);
printf("%i\t",dato);
}
fclose(pf);
}
ING. CARLOS BALDERRAMA V.

PAG. 15

DE 34

fputs : Esta funcin 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 funcin lee un nmero de caracteres de un fichero almacenndolos en una
cadena. Si se encuentra el carcter de nueva lnea ya no almacenar ms caracteres. Su
formato es:
fgets (<cadena>, <num_caracteres>, <var_fich>);
Donde:
cadena es la variable que almacenar la cadena leda del fichero.
num_caracteres es el nmero de caracteres que se desea leer.
var_fich es la variable declarada como FILE.
fgets
Ejemplos:

SIS-1101

cadena

Num caractere

var fich

fgets (cad, 5, f1);

ING. CARLOS BALDERRAMA V.

PAG. 16

DE 34

#include<stdio.h>
#include<conio.h>
#include<string.h>
FILE *pf;
void crear(void);
void mostrar(void);
main()
{
clrscr();
crear();
mostrar();
return 0;
}

SIS-1101

void crear(void)
{ char nom[10];
printf("Para terminar <*>\n");
pf=fopen("datos.dat","w");
do {
gets(nom);
fputs(nom,pf);
} while (nom[0]!='*');
fclose(pf);
}

void mostrar(void)
{ char nom[10];
pf=fopen("datos.dat","r");
while (!feof(pf))
{
fgets(nom,10,pf);
printf("%s\n",nom);
}
fclose(pf);
}

ING. CARLOS BALDERRAMA V.

PAG. 17

DE 34

fscanf : Esta funcin 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 contendrn los valores de la lectura del fichero
que deben coincidir con sus respectivas cadenas de control.
fscanf

Ejemplos:

var fich

cad de control

lista variables

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

fprintf : Esta funcin 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 contendrn los valores para la escritura en el
fichero que deben coincidir con sus respectivas cadenas de control.
fprintf

Ejemplos:
SIS-1101

var fich

cad de control

lista variables

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

ING. CARLOS BALDERRAMA V.

PAG. 18

DE 34

#include<stdio.h>
#include<conio.h>
#include<string.h>
FILE *pf;
void crear(void);
void mostrar(void);
main()
{
clrscr();
crear();
mostrar();
return 0;
}

SIS-1101

void crear(void)
{ char nom[10];
printf("Para terminar <*>\n");
pf=fopen("datos.dat","w");
do {
gets(nom);
fprintf(pf,"%10s",nom);
} while (nom[0]!='*');
fclose(pf);
}
void mostrar(void)
{ char nom[10];
pf=fopen("datos.dat","r");
while (!feof(pf))
{
fscanf(pf,"%10s",nom);
printf("%s\n",nom);
}
fclose(pf);
}
ING. CARLOS BALDERRAMA V.

PAG. 19

DE 34

OTRAS INTRUCCIONES COMUNMENTE EMPLEADAS.

feof : Esta funcin nos devuelve un nmero 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 operacin con archivos ha sido errnea o no. Si lo ha sido
devuelve un nmero 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 funcin restablece el localizador de posicin 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), volveramos al principio del fichero y podramos volver a leer el
primer dato, como si lo abrisemos 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 tambin se puede
hacer de forma directa.

Las operaciones sobre un archivo de acceso aleatorio (Archivo con tipo) son las
siguientes:
1. Declaracin del archivo tipo texto.
2. Apertura del archivo en un modo especfico.
3. Tratamiento de los datos que tiene el archivo.
4. Cerrado del archivo.
La operaciones 1,2,4 son bsicamente 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 disposicin 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 posicin 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>, <direccin>, <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.
direccin es el nmero 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
Posicin actual del fichero
SEEK_END 2
Final del fichero
valor

SIS-1101

fseek

var_fich

direccin

ING. CARLOS BALDERRAMA V.

desde

PAG. 23

DE 34

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

ftell

var_fich

Esta funcin se suele usar, a parte de para saber la situacin 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 tamao de %ld bytes\n", l);
printf ("Y un total de %ld registros\n", l/sizeof(reg));
/* donde reg sera la estructura o el dato simple contenido en el fichero */
...
SIS-1101

ING. CARLOS BALDERRAMA V.

PAG. 24

DE 34

fsetpos : Esta funcin pone el puntero del archivo en la posicin deseada.

fsetpos(<puntero_del_fichero>,<posicion>);
Donde :

puntero_del_fichero es el puntero del fichero.

posicin nueva posicin a la que apunta el puntero

fsetpos

puntero_del_fichero

posicion

La funcin fsetpos devuelve cero si no ocurre un error y un valor distinto a cero, en caso
contrario.
fgetpos : Esta funcin devuelve la posicin de un determinado registro en el archivo.
fgetpos ( <puntero_fichero>,<posicin>);
Donde :

puntero_fichero es el puntero al fichero.

Posicin es la variable en la que se devuelve la posicin del registro.
fgetpos

puntero_del_fichero

posicion

La funcin 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 funcin permite escribir uno o ms 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 direccin de memoria mediante el operador "&".
num_bytes es el nmero de bytes que se van a escribir. Lo ms corriente es
usar para este argumento el operador sizeof sobre el dato a escribir.
cont es el nmero 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 funcin permite leer uno o ms 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 guardarn los datos ledos del fichero. Hemos de
indicar su direccin por tratarse de un puntero.
num_bytes es el nmero de bytes que se van a leer del fichero. Lo ms
corriente es usar para este argumento el operador sizeof.
cont es el nmero de datos, de num_bytes cada uno que se van a leer.
var_fich es el puntero al fichero binario usado.
fwrite

SIS-1101

Dato

num bytes

ING. CARLOS BALDERRAMA V.

cont

Var fich
PAG. 26

DE 34

#include<stdio.h>
#include<conio.h>
#include<ctype.h>
struct empleado {
char nom[10],app[10],apm[10];
int edad,fono;
float esta;
} emp;
FILE *pf;
void leeremp(void);
void mostraremp(void);
void crear(void);
void mostrar(void);
void truco(void);
main()
{ clrscr();
truco();
crear();
mostrar();
return 0;
}

SIS-1101

void leeremp(void)
{
clrscr();
printf("Nombre = ");
gets(emp.nom);
printf("Ap. Paterno = ");
gets(emp.app);
printf("Ap. Materno = ");
gets(emp.apm);
printf("Edad = ");
scanf("%d",&emp.edad);
printf("Telefono = ");
scanf("%d",&emp.fono);
printf("Estatura = ");
scanf("%f%*c",&emp.esta);
}

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();
}
}

//lectura de reales en estructuras

void truco(void)
{ float q,*s;
s=&q;
q=*s;
}

SIS-1101

void mostrar(void)
{ char nom[10];
pf=fopen("datos.dat","r");
while (!feof(pf))
{
fread(&emp,sizeof(struct empleado),1,pf);
mostraremp();
}
fclose(pf);
}

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 cdigo del
registro a dar de alta, y en ese caso, se procede a hacer fwrite. Abriremos para ello el
fichero en modo aadir.
Las bajas consisten en localizar el registro segn un cdigo, y escribir un registro vaco
en tal posicin. 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 cdigo 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>
void creadic(void)
#include<conio.h>
{
struct dicc{
int op;
char palabra[10],signif[50];
dicio=fopen("diciona.dat","w");
}pal;
do {
FILE *dicio;
printf("\npalabra ");
FILE *cart;
gets(pal.palabra);
int error=0,buenas=0;
printf("significado ");
void creadic(void);
gets(pal.signif);
void creacarta(void);
fwrite(&pal, sizeof(pal),1,dicio);
void buscar(char ccc[10]):
printf("Mas datos s/n ");
void corregir(void)
op=getch();
main()
}while(op!='n');
{/* creadic();
fclose(dicio);
clrscr(); creacarta();*/
}
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])

{ int sw=1;
dicio=fopen("diciona.dat","r");
fseek(dicio,0,SEEK_SET);
do {
fread(&pal,sizeof(pal),1,dicio);
if (strcmp(pal.palabra,ccc)==0)
{ sw=0; break;}
} while (!feof(dicio));
fclose(dicio);
return sw;
}
void creacarta(void)
{
char c;
cart=fopen("carta.dat","w");
printf("Introduzca datos <.>
Para terminar \n");
do {
scanf("%c",&c);
fputc(c,cart);
} while(c!='.');
fclose(cart);
}
SIS-1101

void corregir(void)
{
char c=' ';
char palabra[20]="",aux[20];
cart=fopen("carta.dat","r");
while (!feof(cart))
{
c=fgetc(cart);
if (c!= ' ' && c!='\n')
{ strcpy(aux,palabra);
sprintf(palabra, "%s%c",aux,c);
}
else
{ if(buscar(palabra)==1) error++;
else buenas ++;
strcpy(palabra,"");
}
}
fclose(cart);
}

ING. CARLOS BALDERRAMA V.

PAG. 31

DE 34

OPERACIONES CON LOS ARCHIVOS

remove : Esta funcin 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.
nombre_archivo
=
remove
(
)
;
Ejemplos: remove ("datos.dat");
strcpy (nombre, "texto.txt"); remove (nombre);
rename : Esta funcin 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

valor

rename

nombre_actual

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

rename (viejo, nuevo);
SIS-1101

nuevo_nombre

strcpy (nuevo, "clientes.dat\0);

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)

{
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

case 0x00008000: colores[i]=BLUE; break;

case 0x80008000: colores[i]=MAGENTA; 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);
}

ING. CARLOS BALDERRAMA V.

PAG. 34

DE 34