¿qué es una estructura? estructuras en lenguaje cinf.udec.cl/~apuente/archivos/estructuras,...
TRANSCRIPT
1
Programación Estructurada
Estructuras en Lenguaje C
Andrés G. Puente P.Ingeniero Civil Informático
Universidad del [email protected]
Programación Estructurada
Programación Estructurada
¿Qué es una Estructura?
• A diferencia de los arreglos, donde los elementos son todos del mismo tipo, una estructura puede considerarse como un arreglo , cuyos elementos individuales pueden ser de distinto tipo.
• Estos elementos individuales se llaman miembros/componentes de la estructura
• En C, son el mecanismo y la forma más versátil de trabajar con fichas de información.
Utilización
Programación Estructurada
Sintaxis: struct nombre_estructura{tipo1 miembro1;tipo2 miembro2;...................tipoN miembroN;};
• La palabra struct define la estructura• nombre_estructura es el nombre que identifica
estructuras de este tipo, (misma composición)• miembro1, ..., miembroN, son declaraciones de
miembros individuales. Los miembros pueden ser variables ordinarias, punteros, arreglos u otras estructuras.
Declaración
Programación Estructurada
• Una vez que la composición a sido definida, las variables de este tipo de estructuras pueden declararse como sigue:
Sintaxis: struct nombre_estructura var1, var2, ..., varN;
• Es posible combinar la declaración de la estructura con la declaración de las variables.
• En este caso, el nombre de la estructura es opcional).
Declaración
Programación Estructurada
• Sintaxis (2 posibilidades)struct nombre_estructura{
tipo1 miembro1;tipo2 miembro2;...................tipoN miembroN;} var1, var2,..., varN;
• óstruct {
tipo1 miembro1;tipo2 miembro2;................tipoN miembroN;} var1, var2,..., varN;
Declaración
Programación Estructurada
struct cuenta {int numero_cuenta;char tipo_cuenta;char nombre[30];float saldo;
};struct cuenta cliente1, cliente2;
struct cuenta {int numero_cuenta;char tipo_cuenta;char nombre[30];float saldo;} cliente1, cliente2;
Ejemplo
• Definición de estructura.1. Esta estructura se llama
cuenta y contiene cuatro miembros;
2. Declaración de 2 variables de tipo cuenta.
3. Combinación de la declaración de la estructura con la de las variables.
2
Programación Estructurada
• Una estructura puede ser miembro de otra, (el ANSI establece que se puede anidar hasta 15 estructuras, pero la mayoría de los compiladores admiten más ).
• En tal situación, la declaración de la estructura interna debe aparecer antes que la declaración de la estructura externa.
• También se pueden definir arreglos de estructuras.
Estructuras Anidadas
Programación Estructurada
struct fecha {int mes;int dia;int anio;};
struct cuenta {int numero_cuenta;char tipo_cuenta;char nombre[30];struct fecha ultimo_pago;
} clientes[100];
Ejemplo
• Anidamiento de estructuras.
1. Declaración de una estructura fecha.
2. Declaración una estructura con el nombre cuenta donde el último miembro es una estructura previamente declarada.
3. Declaración de un arreglo de 100 estructuras de tipo cuenta.
Programación Estructurada
• Una estructura puede inicializarse en el momento de su declaración.
• La estructura debe tener un almacenamiento estático para poderse inicializar en el momento de su declaración. Esto significa que debe ser una estructura global o (static).
Inicialización de una Estructura
Programación Estructurada
Inicialización de una estructura struct fecha {
char nombre[80];int mes;int dia;int anio;};
1. Inicialización de los campos de la estructura nacimiento.static struct fecha nacimiento = {"Ana" , 5, 24, 90};
Ejemplo
Programación Estructurada
2. Inicialización de un arreglo static struct fecha nacimientos[]={"Ana" , 5, 24, 66,
"Jose", 12, 30, 73,"Raúl", 7, 15, 72,};
3. Separar la inicialización de cada estructura por un par de llaves.
static struct fecha nacimientos[]={ { "Ana" , 5, 24, 66,}{ "Jose", 12, 30, 73,}{ "Raúl", 7, 15, 72,}};
Ejemplo
Programación Estructurada
• Los miembros individuales de una estructura se referencianutilizando el operador punto (.) y se pueden procesar de la misma manera que las variables ordinarias.
1. Cliente es una variable de tipo cuenta y clientes[100] es un arreglos de 100 estructuras. struct cuenta cliente,clientes[100];
2. Acceso a los campos individuales de la estructura cliente.cliente.nombre = "Jose";cliente.saldo = 1000;
Referencia a los miembros de una estructura
3
Programación Estructurada
3. Acceso al campo ultimo_pago de cliente. (La referencia se hace desde la estructura más externa a la más interna).cliente.ultimo_pago.mes;
Acceder al numero de cuenta del cliente 25.clientes[24].no_cuenta ;clientes[24].saldo ;
Referencia a los miembros de una estructura
Programación Estructurada
• En algunas versiones antiguas de C, las estructuras debían ser procesadas campo a campo y la única operación permisible con la estructura completa era tomar su dirección.
• Sin embargo las nuevas versiones de C, incluso el nuevo ANSI, permiten asignar una estructura completa a otra del mismo composición.
struct cuenta cliente1, cliente2;......cliente2 = cliente1;Operación de asignación.1. Declaración de dos variables2. cliente1 ha sido inicializada.3. Se copian todos los campos.
Operación de Asignación
Programación Estructurada
• La instrucción typedef permite a los usuarios definir nuevos tipos de datos que san equivalentes a los tipos existentes, es decir darle nuevos nombre a los tipos existentes.
• Sintaxis: typedef tipo nuevo_tipo;• donde tipo es el tipo existente y nuevo_tipo es el nuevo
nombre.• La definición de un nuevo tipo de dato no reemplaza al
anterior, sino añade un nuevo nombre y con lo cual, ambos nombres se pueden usar para declarar variables.typedef int edad;edad bebe, joven, adulto;
typedef float altura[100];altura hombre, mujeres;
Tipos definidos por el usuario
Programación Estructurada
• La instrucción typedef es particularmente útil cuando se definen estructuras ya que elimina la necesidad de escribir repetidamente la palabra calve struct.
Sintaxis: typedef struct {tipo1 miembro1;tipo2 miembro2;...................tipoN miembroN;} nuevo_tipo;
• donde nuevo_tipo es el tipo de la estructura definida por el usuario. Las variables pueden definirse en términos del nuevo tipo de datos.
Tipos definidos por el usuario
Programación Estructurada
1. Declaración de un tipo estructura llamado fecha.typedef struct {
int mes;int dia;int anio;}fecha ;
2. Declaración de un tipo estructura llamado Registro ( Notar que contiene el nuevo tipo fecha).typedef struct {
int numero_cuenta;char tipo_cuenta;char nombre[30];float saldo;fecha ultimo_pago;}registro;
3. Declaración de un arreglo.registro clientes[100];
Tipos definidos por el usuario
Programación Estructurada
• Se pueden transferir los campos individuales o las estructuras completas.
• Cuando se pasan campos individuales de una estructura a una función, el manejo es idéntico a las variables ordinarias.
• El paso de los valores se puede hacer por valor o por referencia.1. prototipo de funciones.
void fun1(float );void fun2(float *);
2. Declaración de una variable cliente.registro cliente;
3. Llamada por valor.fun1(clinte.saldo);
4. Llamada por referencia. fun2(&cliente.saldo);
Paso de estructuras a funciones
4
Programación Estructurada
• Se permite una transferencia por valor e incluso una función puede devolver mediante la instrucción return una estructura; (Notar el contraste de con los arreglos, que no pueden ser pasados por valor ni se devuelven mediante la instrucción return).1. la definición de registro debe ser visible.typedef struct {
char nombre[20];int no_cuenta;float saldo;} registro;
2. Prototipo de funciones.void fun1(registro *pt);void fun2(registro cliente);registro fun3(void);
Paso de estructuras a funciones
Programación Estructurada
3. Declaración de una variable cliente1 y cliente2.registro cliente1, cliente2 = {"Jose", 1200, 120.000};....
4. Llamada por referencia.fun1(&cliente2);
5. Llamada por valor.fun2(cliente2);
6. La función devuelve una estructuracliente1 = fun3();
Paso de estructuras a funciones
Programación Estructurada
Punteros en Lenguaje C
Andrés G. Puente P.Ingeniero Civil Informático
Universidad del [email protected]
Programación Estructurada
Programación Estructurada
¿Por qué punteros?
• En lenguaje C toda variable ocupa un lugar en la memoria del computador.
• Los punteros existen para acceder a dichas variables de manera más eficiente.
• Facilitan el paso de gran cantidad de información a una función.
• La aritmética de punteros es muy eficiente y muchas veces posee soporte de hardware.
Utilización
Programación Estructurada
Definición de un puntero
• Un puntero se define de manera análoga a una variable, pero se antepone un asterisco al nombre.
Ejemplos:Int *a; Char *c;Float *f;
Definición
Programación Estructurada
• En el puntero se guarda el valor de una dirección de memoria. Ejemplo:
char* c;c = 1000;
c
999 1000 1001 1002 1003
h o l a
Definición
5
Programación Estructurada
Operadores asociados a punteros
• Operador *Se utiliza para obtener el valor apuntado por una
variable de tipo puntero.
• Operador &Se utiliza para obtener la dirección en memoria
donde podemos encontrar una variable.
Operadores
Programación Estructurada
Ejemplo 1
Int *a;int b,c;
b = 4; /* se pasa el valor 4 a la variable ‘b’ */a = &b; /* la variable ‘a’ guarda la dirección de ‘b’ */c = *a; /* el valor apuntado por ‘a’ es 4 */
Ahora es equivalente escribir ‘b’ o ‘*a’
Ejemplo
Programación Estructurada
Ejemplo 2
char *c;char d, e;e = ‘z’; c = &e;d = *c;
De manera análoga al ejemplo anterior, el valor almacenado en ‘d’ es ‘z’
Ejemplo
Programación Estructurada
Punteros y arreglos
• En C, los punteros y los arreglos son equivalentes.
• Los arreglos pueden ser considerados como punteros de valor constante
int a[100];
a /* es equivalente a la posición de memoria delelemento A[0], es decir, &a[0] */
Punteros y Arreglos
Programación Estructurada
Ejemplo 3
int x[10];int *p;int v;x[0] = 0; x[1] = 1; x[2] = 2; … x[9] = 9;p = x; /* ‘p’ apunta al primer elemento de x */
entonces,
d = *(p + 2); /* ‘d’ es igual a 2 */*(p + 5) = 8; /* luego x[5] toma el valor de 8 */
Ejemplo
Programación Estructurada
Aritmética de punteros
• Si un puntero es solo una dirección de memoria, ¿Por qué existen de diverso tipo?
float* f; /* puntero de tipo flotante (real) */char* c; /* puntero de tipo caracter */ f = f + 1; /* siguiente posición de memoria */c = c + 1; /* siguiente posición de memoria */
Debido a que el largo de un flotante en memoria es distinto al largo de un caracter, el tipo es importante.
Aritmética
6
Programación Estructurada
Funciones y punteros
• Los punteros se usan en conjunción con funciones, cuando:
– Se requiere pasar un arreglo de datos a una función.
– Se requiere que una función modifique el valor de un determinado parámetro.
– Se necesita manejar Listas Encadenadas (fuera de los alcances del curso).
Funciones y Punteros
Programación Estructurada
Ejemplo 4int a[10], b;b = suma(a);…int suma(int* x) /* aquí se pasa el arreglo como puntero */ {
int i, s; s = 0;for(i = 0; i < 10; i++)
s += *(x + i);return s;
}
Ejemplo
Programación Estructurada
Ejemplo 5
swap(&x, &y); /* la función necesita las direccionesde las variables a intercambiar */
void swap(int* a, int* b){
int tmp;
tmp = *a; *a = *b;*b = tmp;
}
Ejemplo
Programación Estructurada
Utilización de punteros
• En este curso se utilizarán punteros para pasar valores “tipo arreglo” a una función.
• Para el manejo de cadenas de caracteres.
Utilización
Programación Estructurada
Ejemplo 6
• Función que calcula el tamaño de un stringint strlen(char* s){
char* p = s;while(*p)
p++;return (p – s);
}
Ejemplo
Programación Estructurada
¡Precauciones!
• Un puntero no se puede utilizar si no ha sido inicializado. Ejemplo:
int *p;int b;*p = 66; /* error, se está guardando un valor, en una
posición de memoria desconocida */p = &b; *p = 66; /* correcto, porque ‘p’ apunta a un lugar
conocido y válido */
OJO
7
Programación Estructurada Programación Estructurada
Introducción
• Las estructuras de datos como arreglos, punteros, etc. se encuentran almacenadas en memoria principal.
• Este tipo de almacenamiento, conocido por almacenamiento principal o primario, tiene dos ventajas:– Su pequeño tiempo de acceso – Este tiempo necesario para acceder a los datos
almacenados en una posición es el mismo que el tiempo necesario para acceder a los datos almacenados en otra posición del dispositivo.
Programación Estructurada
• Sin embargo, no siempre es posible almacenar los datos en la memoria central o principal del computador, debido a las limitaciones que su uso plantea:
• La cantidad de datos que puede manipular un programa está limitada a la memoria del computador.
• La existencia de los datos en memoria, está supeditada al tiempo que el computador está encendido y el programa ejecutándose (tiempo de vida efímero).
Introducción
Programación Estructurada
• Estas limitaciones dificultan:
• La manipulación de gran número de datos, ya que—en ocasiones—pueden no caber en la memoria principal.
• La transmisión de salida de resultados de un programa pueda ser tratada como entrada a otro programa.
• Para poder superar estas dificultades se necesitan dispositivos de almacenamiento secundario que permite su recuperación posterior.
• Las estructuras de datos aplicadas a colecciones de datos en almacenamientos secundarios se llaman organización de archivos.
Introducción
Programación Estructurada
• La noción de archivo o fichero está relacionada con los conceptos de:• Almacenamiento permanente de datos.• Fraccionamiento o partición de grandes volúmenes
de información en unidades más pequeñas que puedan ser almacenadas en memoria central y procesadas por un programa.
Introducción
Programación Estructurada
¿Qué es un archivo?
• Es una estructura de datos compuesto por registros y éstos a su vez por campos. Reside en una unidad de almacenamiento permanente (cinta magnética, disco magnético, disco óptico, disco láser, etc.)
50.000Okidata StylusC.oki1030.000Canon B.J.bjc250
PrecioNombreCódigo
Campos
Registros
Definición
8
Programación Estructurada
Componentes
1. Registros: Corresponden a cada una de las filas contenidas en el archivo. Normalmente se le asocia un identificador o clave.
2. Campos: Corresponden a las columnas contenidas en los registros. A cada uno se le asocia su propio tipo de dato básico o compuesto, así como también su tipo de validación y regla de integridad.
Definición
Programación Estructurada
Campos
• Los caracteres se agrupan en campos de datos. Un campo es un ítem o elemento de datos elementales, tales como un nombre, rut, ciudad, teléfono, etc.
• Un campo está caracterizado por su tamaño o longitud y su tipo de datos (cadena de caracteres, entero, lógico, etc.).
• Los campos pueden incluso variar en longitud. En la mayoría de los lenguajes de programación los campos de longitud variable no están soportados y se suponen de longitud fija
Definición
Programación Estructurada
• Un campo es la unidad mínima de información de un registro.
• Los datos contenidos en un campo se dividen con frecuencia en subcampos; por ejemplo, el campo fecha se divide en los subcampos día, mes, año.
Definición
Campos
Programación Estructurada
• Un registro es una colección de información, normalmente relativa a una entidad particular.
• Un registro es una colección de campos lógicamente relacionados, que pueden ser tratados como una unidad por algún programa.
• Un ejemplo de un registro puede ser la información de un determinado empleado que contiene los campos de nombre, dirección, fecha de nacimiento, estudios, salario, teléfono, etc.
Definición
Registros
Programación Estructurada
• Los registros pueden ser todos de longitud fija; por ejemplo, los registros de empleados pueden contener el mismo número de campos, cada uno de la misma longitud para nombre, dirección, fecha, etc. También pueden ser de longitud variable.
• Los registros organizados en campos se denominan registros lógicos.
Definición
Registros
Programación Estructurada
• Un Archivo de datos - o simplemente un archivo - es una colección de registros relacionados entre sí con aspectos en común y organizados para un propósito específico.
• Por ejemplo, un archivo de una asignatura, contiene un conjunto de registros de los estudiantes de esa asignatura. Otros ejemplos pueden ser el Archivo de nóminas de una empresa, inventarios, stocks, etc.
Definición
Archivos
9
Programación Estructurada
• Un archivo en un computador es una estructura diseñada para contener datos.
• Los datos están organizados de tal modo que puedan ser recuperados fácilmente, actualizados o borrados y almacenados de nuevo en el archivo con todos los cambios realizados.
Definición
Archivos
Programación Estructurada
Clasificación General
• La forma de clasificación más básica se realiza de acuerdo al formato en que residen estos archivos.
• De esta forma hablamos de archivos ASCII (de texto) y archivos binarios.
Clasificación
Programación Estructurada
Definición archivo binario
Estructura de datos permanente compuesto por registros (filas) y éstos a su vez por campos (columnas). Se caracteriza por tener un tipo de dato asociado, el cual define su estructura interna.
Definición archivo texto
Estructura de datos permanente no estructurado formado por una secuencia de caracteres ASCII.
Clasificación
Programación Estructurada
Secuencial• Se accesan uno a uno los registros desde el primero
hasta el último o hasta aquel que cumpla con cierta condición de búsqueda. Se permite sobre archivos de Organización secuencial y Secuencial Indexada.
Random• Se accesan en primera instancia la tabla de índices de
manera de recuperar la dirección de inicio de bloque en donde se encuentra el registro buscado. (dentro del rea primaria o de overflow). Se permite para archivos con Organización Sec.Indexada.
Tipos de Acceso a los Archivos
Programación Estructurada
Dinámico• Se accesan en primera instancia la tabla de índices de
manera de recuperar la dirección de inicio de bloque en donde se encuentra el registro buscado. (dentro del rea primaria o de overflow). Se permite para archivos con Organización Sec.Indexada.
Directo• Es aquel que utiliza la función de Hashing para
recuperar los registros. Sólo se permite para archivos con Organización Relativa.
Tipos de Acceso a los Archivos
Programación Estructurada
Según su Uso
• La siguiente tabla resume las distintas denominaciones dadas a los archivos según la utilización dada:
Son copias de seguridad de otros archivos
De Respaldo
Archivo de ventas diarias en un sistema de ventas
Se utilizan para actualizar otros archivos. Pueden ser eliminados al término de este proceso o conservados como respaldos
Transaccionales
Archivo de empleados en un sistema de Remuneraciones
Perduran durante todo el ciclo de vida de los sistemas
Maestros
EjemploDefiniciónTipo
Clasificación de los Archivos
10
Programación Estructurada
Planillas de sueldos en un sistema de Remuneraciones
Son respuestas del sistema computacional cuyos contenidos deben ser interpretados por personas. Pueden ser en forma escrita, por pantalla e incluso hacia algún archivo con formato editable
Informes o reportes
Registro % imposiciones % descuentos isapre, etc
Corresponden a los archivos de consultas de parámetros
De Referencia
Registros de movimientos diarios de CC en un Sistema Bancario de CC
Registran acontecimientos a través del tiempo.
Históricos
Son creados y eliminados entro de un proceso computacional
De Paso
EjemploDefiniciónTipo
Clasificación de los Archivos
Programación Estructurada
Secuencial
• Es la organización más común. Los registros se almacenan uno tras otro por orden de llegada.
• Para accesar un registro determinado se deben leer todos los registros que están almacenados antes que él.
• Se recomienda: para archivos de procesamiento batch(aquellos para los cuales se debe realizar la misma operación sobre la mayor parte de sus registros)
Organización Básica de Archivos
Programación Estructurada
Secuencial Indexada
• Los registros son almacenados en una distribución tal que permiten ser consultados a través de índices. En ellos se distinguen 3 áreas de almacenamiento:
1.De índices: Mecanismo de acceso a los registros de datos. 2.Primaria o de datos: En donde se encuentran los datos
propiamente tal. 3.De overflow: Encargada de recibir aquellos registros que no
pueden ser almacenados en el área primaria.
• Se recomienda : Para archivos de consulta.
Organización Básica de Archivos
Programación Estructurada
Relativa
• Existe una relación directa entre la ubicación lógica de un registro y su ubicación física.
• Para ello se necesita una función matemática que asigne a un valor de clave una dirección física única.
• El encontrar una Fh óptima es tarea compleja por lo que esta organización es poco utilizada.
• Se recomienda: Para archivos en donde sea crucial minimizar tiempos de acceso.
Organización Básica de Archivos
Programación Estructurada
Clasificación
• Consiste ordenar el archivo a partir de uno o más criterios impuestos sobre sus campos.
• Es normal que los archivos estén ordenados por clave o por algún campo alfabético ascendente o descendentemente.
Operaciones Básicas de Archivos
Programación Estructurada
Cod_car..........NombreApellidoNº Mat.Rut
14ClaudioPérez12345333
12AnaRojas15003222
23VíctorBustamante12001111
Cod_car..........NombreApellidoNº Mat.Rut
23VíctorBustamante12001111
14ClaudioPérez12345333
12AnaRojas15003222
Proceso de clasificación (ordenar por cod_car)
Operaciones Básicas de Archivos
11
Programación Estructurada
Concatenación
• Consiste en unir 2 ó más archivos en uno (uno a continuación del otro).
“62
“55
“47
“35“23
“17
“10
DatosClave
“92
“40“30
“22
“13
DatosClave
Proceso de
Concatenación
92
40
30
22
1362
55
“47
“35
“23
“17“10
DatosClave
Operaciones Básicas de Archivos
Programación Estructurada
Intercalación• Consiste en generar un archivo ordenado según algún criterio preestablecido a partir de dos ó más archivos que pueden o no encontrarse en la misma secuencia.
“62
“55
“47
“35“23
“17
“10
DatosClave
“92
“40“30
“22
“13
DatosClave
Proceso de
Intercalación
92
62
55
47
4035
30
“23
“22
“17
“13“10
DatosClave
Operaciones Básicas de Archivos
Programación Estructurada
Pareamiento
• Consiste en ubicar registros correspondientes entre 2 ómás archivos.
• Consiste en ubicar aquellos pares de registros pertenecientes a dos archivos diferentes que cumplen una cierta relación de correspondencia.
Edición
• Consiste en preparar los datos que constituyen a uno ómás archivos para que sean interpretados por personas.
• Se asocia generalmente a la generación de listados en papel impreso.
Operaciones Básicas de Archivos
Programación Estructurada
Cod_car..........NombreApellidoNº Mat.Rut
14ClaudioPérez12345333
12AnaRojas15003222
12VíctorBustamante12001111
Proceso de Edición
Listado de Alumnos I. C. I.Código:12 Fecha: 15 de Octubre de 2002
NombreApellidoNº Mat.Rut
AnaRojas15003222
VíctorBustamante12001111
Operaciones Básicas de Archivos
Programación Estructurada
Validación
• Consiste en asegurar la veracidad e integridad de los datos que ingresan a un archivo. Existen numerosas técnicas de validación tales como: Dígito verificador, chequeo de tipo, chequeo de rango.
Maestro de
ArtículosVALIDACIÓN
Listado de
Errores
Maestro de
Artículos’
Operaciones Básicas de Archivos
Programación Estructurada
Actualización
• Consiste en agregar y eliminar registros desde un archivo, así como también modificar el valor de uno ómás campos. También se conoce como mantención de uno o más archivos.
Maestro de
Artículos
VALIDACIÓN
Listado de
Errores
Maestro de
Artículos’
Archivo de
transac.
Operaciones Básicas de Archivos
12
Programación Estructurada
Trabajando con archivos
Nombre: ARCHIVOS.CPPUtilidad: Este programa ejemplifica la actualizacion de un archivo tipificado de
longitud fija utilizando funciones de acceso directo (crear archivo, agregar, modificar, eliminar y listar registros)
#include <stdio.h>#include <conio.h>#include <string.h>#include <stdlib.h>#include <ctype.h>#include <dos.h>#define archivo "empleados.dat" /* Nombre fisico del archivo */
Operaciones Básicas de Archivos
Programación Estructurada
Definiendo las estructurastypedef enum {False, True} boolean;struct TNombre{
char Codigo[40], Nombre[40], Apellido[40];};struct TFecha{
int dia,mes,anio;};struct TEmpleado{
struct TNombre Identificacion;char direccion[50];struct TFecha FechaNac;boolean Existe;
};
FILE *f; /* Puntero al archivo */
Operaciones Básicas de Archivos
Programación Estructurada
Verificando existencia del archivo
boolean FileExist(FILE **Empleados, char filename[30]){
clrscr();
if ((*Empleados=fopen(filename,"rb"))==NULL){
if ((*Empleados=fopen(filename,"wb"))==NULL)return False; /* No se pudo crear */
else /* Se crea uno nuevo */{
fclose(*Empleados);return True;
}}else /* Se abre uno existente */{
fclose(*Empleados);return True;
}}
Operaciones Básicas de Archivos
Programación Estructurada
Visualizar un registro completo, después de la lectura desde archivo
void Ver(struct TEmpleado R){gotoxy(20,4); printf("Codigo : %s",R.Identificacion.Codigo);gotoxy(20,5); printf("Nombre : %s",R.Identificacion.Nombre);gotoxy(20,6); printf("Apellido : %s",R.Identificacion.Apellido);gotoxy(20,7); printf("Direcci¢n : %s",R.direccion);gotoxy(20,8); printf("Fecha Nacimiento : %d / %d / %d ",R.FechaNac.dia,
R.FechaNac.mes, R.FechaNac.anio);}
Operaciones Básicas de Archivos
Programación Estructurada
Ubicando un registro/* Devuelve posición de registro si es que existe, de lo contrario devuele (-1) */long Posicion(FILE *f, char N[40]){
struct TEmpleado Registro;int Encontrado;long int num_reg=0;
Encontrado=False;fseek(f, 0L, SEEK_SET); /* Se ubica en el primer registro */
while(!feof(f) && !Encontrado){
fread(&Registro, sizeof(struct TEmpleado), 1, f);Encontrado=!(strcmp(Registro.Identificacion.Codigo, N));num_reg++;
}
if (Encontrado)return ((num_reg-1)*sizeof(struct TEmpleado));
elsereturn (-1);
}
Operaciones Básicas de Archivos
Programación Estructurada
Rellenar el registro, previo a la grabación/* Ingresa desde el teclado un registro */void Leer(struct TEmpleado *R){ gotoxy(20,14); printf("C¢digo : ");
gets((*R).Identificacion.Codigo);gotoxy(20,15); printf("Nombre : ");gets((*R).Identificacion.Nombre);gotoxy(20,16); printf("Apellido : ");gets((*R).Identificacion.Apellido);gotoxy(20,17); printf("Direcci¢n : ");gets((*R).direccion);gotoxy(20,18); printf("Fecha Nacimiento (dia) : ");scanf("%d",&(*R).FechaNac.dia);gotoxy(20,19); printf("Fecha Nacimiento (mes) : ");scanf("%d",&(*R).FechaNac.mes);gotoxy(20,20); printf("Fecha Nacimiento (a¤o) : ");scanf("%d",&(*R).FechaNac.anio);(*R).Existe=True;fflush(stdin);PulsarTecla();}
Operaciones Básicas de Archivos
13
Programación Estructurada
Calcular Tamaño en bytes del archivolong filesize(FILE *stream){
long curpos,length;
curpos=ftell(stream);fseek(stream,0L,SEEK_END);length=ftell(stream);fseek(stream,curpos,SEEK_SET);
return length;}
Operaciones Básicas de Archivos
Programación Estructurada
Listar Archivo/* Lista el contenido del archivo (lo que existe) */void Listado(FILE **f){ struct TEmpleado R;
/* Abriendo para lectura */if ((*f=fopen(archivo,"rb"))==NULL){
printf("Archivo no existe!!!");PulsarTecla();
}else{ fseek(*f, 0L, SEEK_SET); /* Se ubica al principio del archivo */
while(!feof(*f)){clrscr();printf("Registro %ld de %ld", (ftell(*f)/sizeof (struct TEmpleado))+1,filesize(*f)/sizeof(struct TEmpleado));
if (fread(&R, sizeof(struct TEmpleado), 1, *f)!=1) break;if (R.Existe){Ver(R);PulsarTecla();
}else{
gotoxy(25,10);printf("******* Registro Eliminado *******");PulsarTecla();
}}
fclose(*f);}
}
Operaciones Básicas de Archivos
Programación Estructurada
Agregar Registrosvoid Agregar(FILE **f){struct TEmpleado R,E;
long int I;/* Abriendo para Lectura-Escritura */if((*f=fopen(archivo,"r+b"))==NULL){printf("Error de apertura");PulsarTecla();}else{ do
{ gotoxy(10,12); printf("[Nuevo Registro Empleado]");Leer(&E);Ver(E);I=Posicion(*f, E.Identificacion.Codigo);if(I==-1) /* Verificacion de existencia */{I=filesize(*f)/sizeof(struct TEmpleado);fseek(*f, 0L, SEEK_END); /* Se ubica al final del archivo */if(fwrite(&E, sizeof(struct TEmpleado), 1, *f)!=1){
printf("Error de escritura");PulsarTecla();break;
}gotoxy(20,11);printf("Grabando Registro...");delay(4000);
Operaciones Básicas de Archivos
Programación Estructurada
Agregar Registros}else
{fseek(*f, I, SEEK_SET);fread(&R, sizeof(struct TEmpleado), 1, *f);if (R.Existe){
gotoxy(20,21);printf("Registro ya existe");PulsarTecla();
}else{
fseek(*f, 0L, SEEK_END); /* Graba al final */fwrite(&E, sizeof(struct TEmpleado), 1, *f);gotoxy(20,11);printf("Grabando Registro...");delay(4000);
}}clrscr();gotoxy(25,23);printf("Presione - n - para salir de [Inserci¢n]");
} while(toupper(getch())!='N');fclose(*f);
}}
Operaciones Básicas de Archivos
Programación Estructurada
Modificar Registrosvoid Modificar(FILE **f){ char codigo[40];
struct TEmpleado aux;long int pos;
if ((*f=fopen(archivo,"r+b"))==NULL){
printf("Archivo no existe!!!");PulsarTecla();
}else {
do{ clrscr();
gotoxy(25,2); printf("[MODIFICA]");gotoxy(25,4); printf("Introduzca c¢digo de empleado: ");gets(codigo);fflush(stdin);pos=Posicion(*f, codigo);if(pos==-1){ gotoxy(20,11);
printf("Registro no existe");}else{ fseek(*f, pos, SEEK_SET);
if(fread(&aux, sizeof(struct TEmpleado), 1, *f)!=1) break;
Operaciones Básicas de Archivos
Programación Estructurada
Modificar Registrosif(aux.Existe){ clrscr();
gotoxy(25,2);printf("[Modifica Registro %ld]", pos/sizeof(struct TEmpleado)+1);Ver(aux);gotoxy(20,11);printf("¨Desea modificar estos datos(S/N)? ");if(toupper(getch())=='S'){
Leer(&aux);fseek(*f,pos,SEEK_SET);fwrite(&aux, sizeof(struct TEmpleado), 1, *f);}
}else{gotoxy(20,11);printf("No existe (eliminado en sesi¢n anterior)");PulsarTecla();}
}gotoxy(25,23);printf("Presione - n - para salir de [Modificar]");} while(toupper(getch())!='N');
fclose(*f);}
}
Operaciones Básicas de Archivos
14
Programación Estructurada
Eliminación Lógica (marcado de registro)void EliminarLogico(FILE **f){ struct TEmpleado E;
char N[40];int I;/* Abriendo para Lectura-Escritura */if ((*f=fopen(archivo, "r+b"))==NULL){printf("Error de Apertura");PulsarTecla();}else{ fseek (*f, 0L, SEEK_SET);
gotoxy(25,2);do{ clrscr();
gotoxy(20,2); printf("[Eliminaci¢n]");gotoxy(20,5); printf("C¢digo Empleado a Eliminar: ");gets(N) ;fflush(stdin);I=Posicion(*f,N);if(I==-1){
gotoxy(20,11);printf("Registro no existe...");
}else{
fseek(*f, I, SEEK_SET);fread(&E, sizeof(struct TEmpleado), 1, *f);
Operaciones Básicas de Archivos
Programación Estructurada
if (E.Existe){
gotoxy(20,3); clreol();Ver(E);E.Existe=False; /* Eliminacion logica */fseek(*f, I, SEEK_SET);fwrite(&E, sizeof (struct TEmpleado), 1, *f);gotoxy(20,11);printf("Eliminando Registro...");delay(4000);
}else{
gotoxy(20,11);printf("Registro no existe...");
}}gotoxy(25,23);printf("Presione - n - para salir de [Eliminaci¢n]");
} while (toupper(getche())!='N');fclose(*f);
}}
Operaciones Básicas de Archivos
Programación Estructurada
Eliminación físicavoid EliminarFisico(FILE *f){
FILE *temp;struct TEmpleado aux;int cuenta=0;
if((f=fopen(archivo,"rb"))==NULL){
printf("Error al abrir el archivo %s", archivo);PulsarTecla();
}else{
if (filesize(f)!=0){
if((temp=fopen("temp.dat","wb"))==NULL){
printf("Error de creaci¢n del archivo temporal");PulsarTecla();
}else{
Operaciones Básicas de Archivos
Programación Estructurada
printf("Eliminando fisicamente los registro del archivo %s ...", archivo);delay(4000);rewind(f);rewind(temp);while(!feof(f)){fread(&aux, sizeof(struct TEmpleado), 1, f);if(aux.Existe)fwrite(&aux, sizeof(struct TEmpleado), 1, temp);else cuenta++; /* Cuenta los registros que no existen */}fclose(f);fclose(temp);if(cuenta!=0){remove(archivo);rename("temp.dat", archivo);}else remove("temp.dat");} }
else /* Si el archivo se encuentra vacio */{ fclose(f);
printf("El archivo %s se encuentra vacio", archivo);PulsarTecla();
}}
}
Operaciones Básicas de Archivos
Programación Estructurada
void Consultar(FILE *f){ struct TEmpleado E;
long int I;char N[40];
/* Abriendo para lectura */if ((f=fopen(archivo, "rb"))== NULL){printf("Archivo no existe!!!");PulsarTecla();}else{ fseek (f, 0L, SEEK_SET);
do{ clrscr();
gotoxy(25,2); printf("[Consulta]");gotoxy(25,4); printf("Introduzca codigo de empleado: ");gets(N);fflush(stdin);I=Posicion(f,N);if (I==-1){gotoxy(20,11);printf("Registro no existe");}else{fseek (f,I,SEEK_SET); /* Ubica puntero en el registro I */if(fread (&E, sizeof (struct TEmpleado), 1, f)!=1) break;if(E.Existe){clrscr();gotoxy(25,2);printf("[Consulta Registro %ld]", I/sizeof(struct TEmpleado)+1);Ver(E);}else
Operaciones Básicas de Archivos
Programación Estructurada
{
gotoxy(20,11);printf("No existe (eliminado en sesi¢n anterior)");}}gotoxy(25,23);printf("Presione - n - para salir de [consultas]");
} while(toupper(getche())!='N');fclose(f);
}}
Operaciones Básicas de Archivos
15
Programación Estructurada
Programa Principal/* Bloque principal */int main(void){
clrscr();if (!FileExist(&f,archivo)){
printf ("Error de apertura o creacion de archivo");exit(1);
}else
Menu(); //Menú de operaciones básicas
return(0);}
Operaciones Básicas de Archivos