Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Archivos

No description
by

Gabriel Chaldu

on 18 May 2016

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Archivos

La estructura FILE
Las funciones utilizan un puntero a la estructura FILE.
typedef struct {
int level;
unsigned flags;
char fd;
unsigned char hold;
int bsize;
unsigned char _FAR *buffer;
unsigned char _FAR *curp;
unsigned istemp;
short token;
}
FILE
;
Concepto de Archivos
Todos los programas que se ejecutaron hasta el momento
requerían de ingreso de datos
para realizar determinadas tareas y luego mostrar resultados. Tales programas tienen un gran defecto y es que los datos que se cargan desaparecen cuando el programa
termina, por lo tanto cada vez que se corra el programa hay que cargar los datos nuevamente.
ARCHIVOS
La Solución
Trabajo sobre archivos
En C, todas las operaciones que se realizan sobre archivos son hechas a través de funciones.
Archivos de Texto
Es una secuencia de caracteres organizadas 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.
Archivos Binarios
Organiza datos de cualquier tipo de bloque de información (registro). Normalmente los usaremos para almacenar datos de tipo struct.
MANEJO DE ARCHIVOS
Gabriel Chaldu

EL PROBLEMA
Guardar los datos en un archivo.
Ej. de manejo de Archivo
Lo primero que se debe hacer es abrirlo:

FILE *
fopen
(const char * Nombre_de_archivo , const char * Modo) ;
Valor retornado:
EN CASO DE EXITO la función devuelve
un puntero a la estructura FILE asociada al archivo
.
EN CASO DE ERROR devuelve
NULL.
Modo Detalle
r Abre un archivo de texto para operaciones de lectura.
w Abre un archivo de texto para operaciones de escritura.
a Abre un archivo de texto para añadir datos al final del mismo.
+ Símbolo utilizado para abrir el fichero para lectura y escritura.
b El fichero es de tipo binario.
t El fichero es de tipo texto. Si no se pone ni b ni t el fichero es de tipo texto.
Ej. 1- Hacer una función que agregue un elemento al final de un archivo.
void agregaElementoAlFinalDelArchivo(char nombre_archivo[], int dato)
{
FILE *archi;

archi=
fopen
(nombre_archivo, "a+b");

if(archi!=NULL)
{

fwrite
(&dato, sizeof(int), 1, archi);

fclose
(archi);
}
}
int main()
{
char archivoDatosSimples[]=
{"datossimples.bin"};
int i, numero;
printf("INGRESE UN NUMERO ENTERO");
scanf("%d", &numero);
agregaElementoAlFinalDelArchivo(archivoDatosSimples, numero);
}
Abre un archivo binario para añadir datos.
2- Hacer una función que muestre por pantalla el contenido de un archivo.
void mostrarArchivoBinario(char nombre_archivo[])
{

FILE *archi;
archi=
fopen
(nombre_archivo,"rb");
int aux;
if(archi!=NULL)
{
printf("\nContenido del archivo:\n\n");
while(
fread(
&aux, sizeof(int),1,archi)>0)
{
printf("%d ", aux);
}

fclose
(archi);
}
}
int main()
{
char archivoDatosSimples[]= {
"datossimples.bin"
};
int i;
/
/ esto es para generar un numero aleatorio...
srand(time(NULL)); // la funcion srand() inicializa el generador
int numero=rand(); // la funcion rand() genera un n° aleatorio

agregaElementoAlFinalDelArchivo(archivoDatosSimples, numero);


mostrarArchivoBinario(archivoDatosSimples);
Abre un archivo binario para operaciones de lectura.
Utilizar buffer significa que no tienen acceso directo al archivo y que las operaciones (lectura o escritura) se realizan en el buffer.
ALGUNAS FUNCIONES
fopen ( )
ABRE UN ARCHIVO
fclose ( )
CIERRA UN ARCHIVO (0 EXITO -1 NO-CERRO)
fcloseall ( )
CIERRA TODOS LOS ARCHIVOS ABIERTOS POR LA APLICACION
fread ( )
LEER ARCHIVO
fwrite( )
ESCRIBIR ARCHIVO
feof( )
DEVUELVE VERDADERO SI LLEGA A
EOF
fseek ( )
BUSCA UN BYTE ESPECIFICO DE UN ARCHIVO
rewind ( )
COLOCA EL LOCALIZADOR DE POSICION DEL ARCHIVO AL PRINCIPIO
El puntero a un Archivo
Cuando se trabaja con archivos:
Abrir un Archivo
Cada vez que se necesita trabajar con un archivo es necesario abrirlo.
Abrir un Archivo
Modo escritura
(w – wb – w+b – w+)
Abrir un Archivo
Modo lectura
(r – rb – r+b – r+)
Abrir un Archivo
Modo append
(a – ab – a+b – a+)
Archivos
Donde archi es el puntero a la estructura FILE asociada con el archivo que se desea cerrar.
Valor retornado por la función:

Cierre con éxito: devuelve cero.

Cierre con error: devuelve -1

Archivos
Fin de un archivo

La función
feof()
sirve para detectar el fin de un archivo.

int feof(FILE *archi)

Retorna un valor diferente de cero si ha ocurrido un fin de archivo.

Valor retornado por la función:

Cierre con éxito: devuelve cero.

Cierre con error: devuelve -1

Archivos
Funciones de archivo binario

Para trabajar con archivos binarios se usan las funciones:

int fread
(void *buffer, int num_bytes, int cuenta, FILE *fp)

int fwrite
(void *buffer, int num_bytes, int cuenta, FILE *fp)

int fseek
(FILE *fp, long num_bytes, int origen)

long ftell
(FILE *fp)

rewind
(FILE *fp)
Valor retornado por la función:

Cierre con éxito: devuelve cero.

Cierre con error: devuelve -1

FUNCIONES DE ARCHIVO BINARIO
int fread
(
void *buffer
,
int num_bytes
,
int cuenta
,
FILE *fp
)

fread
(
direcc_dato
,
tamaño_dato
,

numero_datos
,
punt_fichero
);

Lee de un archivo n bloques de bytes y lo almacena en un buffer

Retorno:
Cantidad de bytes leídos. Generalmente es un número igual a num_bytes * cuenta. Pero puede ser menor.

int fread
(void *buffer, int num_bytes, int cuenta, FILE *fp)

buffer:
Dirección del bloque de datos.
Puntero a la información
que va a ser escrita en el archivo.
num_bytes:
Tamaño del bloque de datos. Se usa la instrucción sizeof().
cuenta:
Número de bloques a transferir. En caso de transferir un arreglo, la cantidad de celdas a copiar en el archivo.
fp:
Puntero al archivo.

int fwrite
(void *buffer, int num_bytes, int cuenta, FILE *fp)

La funcion fwrite escribe un buffer de cualquier tipo de dato en un archivo binario

Retorno:
El valor de retorno es el número de registros escritos, no el número de bytes

fwrite
int fwrite
(void *buffer, int num_bytes, int cuenta, FILE *fp)

buffer:
Dirección del bloque de datos. Puntero en donde se copia la información leída desde el archivo.

num_bytes:
Tamaño del bloque de datos (tamaño del registro). Se usa la instrucción sizeof().

cuenta:
Número de bloques a transferir. En caso de copiar varios registros a la vez (sobre un arreglo).

fp:
Puntero al archivo.


fwrite
int fseek
(FILE *fp, long desplazamiento, int origen)

Con la función fseek() se puede tratar un archivo como un array que es una estructura de datos de acceso aleatorio. fseek() sitúa el puntero del archivo en una posición aleatoria dependiendo del desplazamiento y el origen relativo que se pasan como argumentos.

Retorno:
En caso de éxito devuelve 0 (cero)

int fseek
(FILE *fp, long desplazamiento, int origen)

fp:
Puntero al buffer asociado con el archivo.

desplazamiento:
Cantidad de bytes que se desplazará el indicador de posición a partir de origen.

origen:
Constante que determina el punto de referencia a partir del cual se realiza el desplazamiento.
SEEK_SET ó 0: a partir del comienzo del archivo
SEEK_CUR ó 1: a partir de la posición actual del arch.
SEEK_END ó 2: a partir del final del archivo.

long ftell
(FILE *fp)

Devuelve la posición actual del indicador de posición.

Retorno: Si la operación es exitosa devuelve la cantidad de bytes que hay desde el comienzo del archivo hasta el lugar en que se encuentra el indicador de posición del archivo, en caso contrario devuelve -1L (-1 como long).

void rewind
(FILE *archi);

Se utiliza para rebobinar un archivo.

La función rewind() inicializa el indicador de posición al principio del archivo.





Para averiguar la cantidad de bytes que ocupa un archivo debemos llevar el apuntador hacia el final y luego retornar la posición del apuntador en bytes:

fseek(fp, 0,2);
c = ftell(fp);

c es una variable de tipo long.



NOTA: Los modos anteriores se combinan para conseguir abrir el fichero en el modo adecuado. Por ejemplo, para abrir un fichero binario ya existente para lectura y escritura el modo será "rb+ "; si el fichero no existe, o aun existiendo se desea crear, el modo será " wb+ ". Si deseamos añadir datos al final de un fichero de texto bastará con poner "a", etc.
Archivos Y Struct
Todos los programas que se ejecutaron hasta el momento requerían de ingreso de datos para realizar determinadas tareas y luego mostrar resultados. Tales programas tienen un gran defecto y es que los datos que se cargan desaparecen cuando el programatermina, por lo tanto cada vez que se corra el programa hay que cargar los datos nuevamente.
void cargaAlumnos(char nombre_archivo[])
{
int cont =0;
alumno a;
FILE * archi;


archi=fopen(nombre_archivo,"r+b");
if(archi==NULL)
{

archi=fopen(nombre_archivo,"w+b");
}
if(archi!=NULL)
{
printf("Ingreso de alumnos: \n");
while(cont<5)
{
printf("\n Ingrese legajo: ");
scanf("%d", &a.legajo);
printf("\n Ingrese nombre y apellido: ");
fflush(stdin);
gets(a.nya);
printf("\n Ingrese edad: ");
scanf("%d", &a.edad);

fwrite(
&a
,sizeof(alumno),
1
,
archi)
;

cont++;
}
fclose(archi);
}
}
typedef struct
{
int legajo;
char nya [30]; //nombreYapellido
int edad;

} alumno;
fwrite (
direcc_dato,
tamaño_dato,

numero_datos,
punt_fichero
);
Crear una función que retorne la cantidad de registros que tiene el archivo. Usar fseek y ftell.
int cuentaRegistroArchivo(char nombre_archivo[])
{
int cantidad =0;
FILE * archi;

archi =
fopen
(nombre_archivo,"rb");
if(archi!=NULL)
{

// me posiciono al final del archivo

fseek
(archi,0,SEEK_END);


// divido la cantidad de bytes del archivo por la cantidad de
// bytes de un registro de alumnos
cantidad =
ftell
(archi)/sizeof(alumno);
fclose(archi);
}

return cantidad;
}

Hacer una función que muestre el contenido de un registro, cuya posición se pase por parámetro.
void muestraAlumnoAEleccion(char archivo[], int pos)
{
FILE * archi;
alumno a;

archi=
fopen
(archivo, "rb");
int i=0;


// tener en cuenta que para leer el registro n°1 del archivo
// tenemos que posicionarnos en 0 (cero)

if(archi!=NULL)
{

fseek
(archi, sizeof(alumno)*(pos-1), SEEK_SET);


fread
(&a,sizeof(alumno),1,archi);


fclose
(archi);

puts("\nEl alumno que se encuentra en el registro es:");

mostrarAlumno(a);
}
}

int
main()
{
char archivoAlumnos[]={
"alumnos.dat"
};
muestraAlumnoAEleccion(archivoAlumnos,
5
);
}

void mostrarAlumno(alumno a)
{
puts("\n---------------------------------------");
printf("\n Legajo: %d", a.legajo);
printf("\nNombre y Apellido: %s", a.nya);
printf("\n Edad: %d", a.edad);
printf("\n Año: %d", a.anio);
puts("\n---------------------------------------");
}
Existen 2 tipos de archivos que son los de
texto
y
binarios
. Esta clasificación hace referencia a la forma en la cuál se
interpretan los datos.
Todos los archivos tienen al final una marca que indica el final del archivo. Dicha marca se conoce como
EOF
(End Of File).
No pueden visualizarse con un procesador de texto.
Se pueden guardar datos de distinto tipo
, siempre y cuando estén
dentro de una estructura de datos
. Por ejemplo, mezclar caracteres, enteros, float, etc.
Los datos se escriben en binario
dentro del archivo.
Por ejemplo: Si escribimos el número entero 4567 en el archivo, el programa lo definirá como un entero y escribirá en binario.
Existen 2 categorias de funciones:
Las que usan “buffer” (NOSOTROS USAMOS ESTA CATEGORIA).
Las que acceden directamente al archivo.
Cuando el buffer se llena o se vacía se actualiza el archivo.
¿Qué significa utilizar el buffer?
El área de memoria se establece escribiendo:
FILE
*archi;
El primer paso es establecer un área de buffer, donde la información se almacena temporalmente mientras se está transfiriendo entre la memoria y el archivo de datos.
Nota: El tipo de estructura FILE está definido en stdio.h.
Variable Puntero al que indica el comienzo del buffer
Tipo de estructura que establece el área del buffer
FILE *archi =
fopen

(

nombre-archivo
,

modo
)
La siguiente tabla muestra los valores permitidos para
modo
.
nombre-archivo
es un puntero a una cadena de caracteres que representa el nombre valido del archivo y puede incluir una especificación del directorio.
modo
determina como se abre el archivo.
Función para abrir un archivo
Si el archivo que tratamos de abrir NO EXISTE:
El mismo se crea.
Si el archivo que tratamos de abrir EXISTE
Todos los datos del mismo son borrados.
Nota: Al abrir el archivo el indicador de posición se encuentra en el inicio del archivo.
Si al abrirlo el archivo
no existe
, la función fopen()
retorna error
.
Si se abre en modo r,
no se podrá escribir.
Nota: Al abrir el archivo el indicador de posición se encuentra en el inicio del archivo.
Si el archivo que tratamos de abrir
NO EXISTE
:
El mismo
se crea
.
El indicador de posición se ubicará al final
del archivo para agregar datos.
Nota: No se puede desplazar a través del archivo.
Si el archivo que tratamos de abrir
EXISTE
Se encarga de vaciar el buffer en el disco y realizar un cierre formal del archivo a nivel del sistema operativo
Siempre debemos cerrar los archivos abiertos.
Terminar el programa sin cerrar un archivo abierto causa problemas (pérdida de datos, destrucción de archivos y posibles errores intermitentes en el programa).
int fclose ( FILE * archi);
Full transcript