P5. Estructuras - Sistemas Informáticos Industriales (1774)

Transcripción

Escuela Politécnica Superior de Elche
Grado de Ing. Electrónica y Automática Industrial
Sistemas Informáticos Industriales
Curso 2015-16
Práctica 5: Estructuras
0. Instrucciones sobre la entrega de la práctica
En esta práctica a entregar de forma individual por el alumno se usará una base de datos estructurada con
información sobre personas. Esta base de datos estará situada en un fichero de texto y se realizarán acciones para
añadir nueva información, eliminar información, mostrar la información o realizar comprobaciones. Se
proporciona al alumno un código como base para realizar esta práctica indicando aquellos puntos que el alumno
debe completar para realizar las tareas indicadas en el guión. En ningún momento se solicitará información por
teclado al usuario, sino que toda la información será pasada al ejecutable creado mediante la línea de comandos.
Consideraciones a tener en cuenta para que la práctica sea corregida correctamente:
• Se proporcionan al alumno los siguientes ficheros:
o practica5.c que contiene los prototipos de las funciones y el main.
Este fichero no debe ser modificado.
o practica5.h que contiene la declaración de la estructura y variables globales.
Este fichero no debe ser modificado.
o practica5_entrega.c que contiene la estructura principal de las funciones que el alumno
debe rellenar.
Fichero a completar por el alumno para la realización de la práctica.
• Las funciones incluidas en el fichero practica5_entrega.c que el alumno debe completar y que son
llamadas desde el main son las siguientes:
o Función MostrarDatos
o Función ComprobarLista
o Función LeerAmigoFichero
o Función BorraDatos
o Función EscribirAmigoFichero
o Función AgrupaAmigos
o Función ComparaFechas (función ya resuelta para entender el uso de la librería time.h)
• El fichero con la base de datos se encontrará siempre en el fichero basedatos.txt.
• Los teléfonos serán únicos y no podrán repetirse entre usuarios. Por lo tanto en la operación de
borrado se utilizarán los teléfonos ya que como mucho una única persona podrá tenerlo. Además,
en la función ComprobarLista también se usaran los teléfonos para comprobar si la nueva persona a
añadir ya se encuentra en la base de datos.
Se valorará tanto el funcionamiento de cada una de las partes como la claridad del código y los comentarios.
El código se evaluará tanto con los ficheros ejemplo que tenéis en la web como con otros similares. La no
entrega o copia implica el suspenso de dicha práctica.
Ejemplos de llamada desde la línea de comandos que se usarán para la corrección:
• practica5.exe show
o Se muestra por pantalla la base de datos inicial.
• practica5.exe add entradadatos.txt
o Se añade una nueva persona a la base de datos cuya información se encuentra en el fichero
entradadatos.txt. Si la nueva persona ya está en la base de datos (se usan los teléfonos para
comprobarlo) se indica y no se añade.
• practica5.exe check
o Se comprueba que muestre las personas cuyo cumpleaños sea en los próximos 7 días.
• practica5.exe del 5552501
o Se elimina a la persona con teléfono fijo o móvil indicado.
• practica5.exe group
o Se mostrará para cada país la lista de personas que pertenecen.
La práctica deberá subirse a través del acceso identificado a la tarea correspondiente antes de la fecha límite
(29 de abril). Únicamente deberá entregarse el fichero practica5_entrega.c debidamente comentado y
con el nombre y DNI del alumno como un comentario en la primera línea del fichero. Para la corrección
incluiré dicho fichero en el proyecto junto con los ficheros originales practica5.c y practica5.h para
compilarlo y evaluar su funcionamiento.
1/16
Curso 2015-16
1. Objetivos
Los objetivos de esta práctica son:
•
•
•
Declarar estructuras en lenguaje C de forma correcta. Esto nos permitirá definir
nuevos tipos de datos que no existen en el lenguaje.
Utilizar de forma correcta las estructuras definidas. Esta posibilidad del lenguaje nos
permite manejar información abstracta de forma más sencilla.
Crear una base de datos sencilla, que nos permita manejar toda la información
relativa a una persona de forma sencilla.
2. Introducción
En esta práctica nos proponemos realizar un programa en C que sea capaz de almacenar y
gestionar la información de un conjunto de personas que se almacenarán en una base de datos.
Para ello utilizaremos los conceptos de estructuras en C vistos en teoría. También se usarán
las funciones de E/S de ficheros que ya conocemos de prácticas anteriores para almacenar la
información de forma permanente en el PC. El programa que realizaremos contará con una
serie de opciones en línea de comandos, que nos permitirán modificar la información,
añadiendo nuevas personas al listado, eliminar otras, etc.
Además, haremos uso de las funciones de la librería estándar de C <time.h> que nos
permitirán conocer la fecha y hora actual desde nuestro programa, avisarnos de fechas
señaladas con antelación (p.e. cumpleaños, aniversarios…).
3. Repaso de estructuras en C
La base de datos explicada a continuación es un ejemplo similar a la que se usará en la
práctica a realizar pero no idéntica.
3.1.- Definir la estructura de datos a utilizar
Vamos a empezar por declarar la estructura de datos necesaria para almacenar la siguiente
información relativa a una persona:
•
•
•
•
Nombre (máximo 50 caracteres).
Dirección (máximo 50 caracteres).
Año de nacimiento (tres enteros).
Gustos y aficiones (máximo 50 caracteres).
2/16
Curso 2015-16
Para hacer esto, podemos definir la siguiente estructura de datos en C:
#define TAMMAX 50
struct amigo{
char nombre[TAMMAX];
char direccion[TAMMAX];
int dia, mes, anyo; //fecha de nacimiento
char aficiones[TAMMAX];
};
Como se puede observar, dentro de esta estructura están definidas las siguientes variables:
•
•
•
•
char nombre[TAMMAX]: Es un array de caracteres (cadena de caracteres).
Almacena el nombre del amigo (p.e. “Pedro López Martínez”).
char direccion[TAMMAX]: Es un array de caracteres. Almacena la dirección del
amigo (p.e. “c/Antonio Machado 45”).
int dia, mes y anyo: Día, mes y año de nacimiento.
char aficiones[TAMMAX]: Es un array de caracteres. Almacena los gustos de la
persona (p.e. Música pop, atletismo…).
3.2.- Uso de la estructura
Para almacenar la información relativa a varias personas, podemos declarar diferentes
variables de tipo amigo.
int main(void)
{
struct amigo amigo1, amigo2;
printf("\nNombre del alumno: ");
gets(amigo1.nombre);
printf("\nDireccion: ");
gets(amigo1.direccion);
…
}
Sin embargo, si necesitamos almacenar un mayor número de elementos de tipo struct
amigo esta no es la manera más conveniente de hacerlo. Para ello podemos utilizar un array
de estructuras. Lo podremos declarar de la siguiente manera:
int main(void)
{
struct amigo amigos[50];
printf("\nNombre: ");
gets(amigos[i].nombre);
gets(amigo1.direccion);
…
}
3/16
Curso 2015-16
Escribir struct amigo cada vez que deseamos una variable de ese tipo es bastante
tedioso. Es práctica común utilizar la sintaxis typedef para utilizar un nombre más corto.
#define TAMMAX 50
struct amigo{
char direccion[TAMMAX];
char fecha[TAMMAX];
int dia, mes, anyo;
char aficiones[TAMMAX];
};
typedef struct amigo amigo; // typedef nombreAntiguo nombreNuevo;
Hecho esto, podremos declarar variables de tipo struct amigo de la siguiente manera:
int main(void)
{
amigo amigo1;
amigo amigos[50];
printf("\nNombre: ");
gets(amigos[i].nombre); //Recoge el nombre por teclado
gets(amigo1.direccion);//Recoge la dirección por teclado
…
}
Nótese que, en el código anterior, hemos limitado el número de variables de tipo amigo a 50.
Si queremos manejar un número variable de estructuras, deberemos utilizar un puntero y las
funciones para reserva de memoria dinámica.
int main(void)
{
amigo *pa;
int n;
printf("\nIntroduzca el número de estructuras a almacenar: ");
scanf(“%d”, &n);
//Reservamos memoria para n estructuras de tipo amigo
pa = (amigo*)malloc(n*sizeof(amigo));
…
…
free(pa);
}
4/16
Curso 2015-16
4. Realización de la práctica
4.1.- Funcionamiento del programa:
Al programa se le deberá pasar una serie de argumentos por línea de comandos, tal y como se
detallan a continuación.
Opciones del programa:
add
Uso: practica5.exe add entradadatos.txt
El programa añade la información de una persona existente en el fichero nombrado
entradadatos.txt
Se presenta un ejemplo del funcionamiento a continuación. Si suponemos que en fichero
entradadatos.txt y el fichero basedatos.txt existe la siguiente información:
Entonces, ejecutar practica5.exe add entradadatos.txt, debe producir lo siguiente:
5/16
Curso 2015-16
El fichero basedatos.txt queda:
Si repetimos el comando: practica5.exe add entradadatos.txt, el programa debe darse
cuenta de que la persona ya se encuentra en la base de datos, con lo que debe aparecer:
Y se debe comprobar que el fichero de la base de datos se mantiene igual.
6/16
Curso 2015-16
del
Uso: practica5.exe del 5552504
En este caso se eliminará de la base de datos a la persona cuyo cualquiera de sus dos
teléfonos (fijo o móvil) coincidida con el indicado en el tercer parámetro.
Nota: Supondremos que los números de teléfonos no pueden repetirse entre personas.
Si ninguna persona de la base de datos coincide con el teléfono indicado deberá indicarse por
pantalla que ninguna persona ha sido eliminada de la base de datos. Si ejecutamos de nuevo el
comando anterior, puesto que la persona ya fue eliminada de la base de datos, en este caso se
indica que nadie ha sido eliminado.
group
Uso:
practica5.exe group
En este caso se mostrará una lista de todos los países incluidas en la base de datos
indicando a continuación que amigos pertenecen a cada una según el ejemplo que se muestra
a continuación:
7/16
Curso 2015-16
show
Uso: Practica5.exe show
Muestra todas las personas de la lista.
check
Uso: Practica5.exe check
Comprueba la fecha actual del sistema. Si en la lista existe alguna persona cuyo cumpleaños
sea dentro de 7 o menos días, la muestra por pantalla. La función utiliza la librería time.h y el
código se proporciona al alumno. Se añadió una nueva persona cuyo cumpleaños es dentro de
este plazo para mostrar su funcionamiento.
En este caso se ha mostrado a una persona cuyo cumpleaños es en menos de 7 días. En caso
de haber más de una persona que cumpla este criterio se mostrarán todas.
8/16
Curso 2015-16
4.2.- practica5.c que contiene la función main:
Como ayuda, se presenta a continuación el main del programa que también podéis descargar
desde el blog. El cuerpo principal de esté código no debe modificarse. Únicamente se deben
rellenar las funciones y los segmentos de código indicados (marcados en negrita en este
documento).
#include
#include
#include
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<time.h>
<string.h>
<math.h>
<locale.h>
"practica5.h"
// Prototipos de las funciones
void MostrarDatos(amigo a);
void LeerAmigoFichero(amigo *a);
void EscribirAmigoFichero(amigo a);
int ComprobarLista(amigo* lista_amigos, amigo nuevo_amigo, int n_amigos);
int ComparaFechas(amigo am, int margendias);
int BorrarDatos(amigo* lista_amigos, int n_amigos, char *telefono);
void AgruparAmigos(amigo* lista_amigos, int n_amigos);
// ************************ MAIN **********************
// ****************************************************
int main(int argc, char *argv[])
{
// Declaración de variables
int n_amigos;
int i, res;
1:
amigo *pamigos;
amigo nuevo_amigo;
char temp[TAMMAX];
setlocale(LC_CTYPE, "Spanish");
2:
//Leer los amigos de la base de datos y cargarlos en memoria
fpdatos = fopen("basedatos.txt","r");
if (fpdatos == NULL)
{
printf("No ha sido posible abrir la base de datos\n");
return -1;
}
fscanf(fpdatos,"%d", &n_amigos); // Lee el número de amigos del fichero
if(n_amigos==0){
printf("\nNo hay amigos en la base de datos");
pamigos=NULL;
}
else{
printf("\nLeyendo %d amigos de la base de datos.\n", n_amigos);
// Reserva dinámica de memoria para almacenar al número de amigos que
contenga la base de datos
3:
pamigos = (amigo*)malloc(n_amigos*sizeof(amigo));
for(i=0; i < n_amigos; i++)
4:
LeerAmigoFichero(&pamigos[i]); // Esta función leerá un único
amigo cada vez
}
fclose(fpdatos);
9/16
Curso 2015-16
// Una vez leida la base de datos comenzaremos a comprobar el comando
introducico para ejecutar la opción deseada
if(argc < 2)
{
printf("\nOpcion incorrecta:\nUso:\npractica5.exe [opcion] [parametro]\n");
return -1;
}
5:
else if(strcmp(argv[1],"add")==0)
{
//Abrimos fichero de entrada con el nuevo amigo
fpdatos = fopen(argv[2],"r");
{
printf("No ha sido posible abrir el fichero indicado\n");
return -1;
}
6:
LeerAmigoFichero(&nuevo_amigo); // Leemos al nuevo amigo
fclose(fpdatos);
7:
res=ComprobarLista(pamigos, nuevo_amigo, n_amigos); //comprobar si está
en la lista, 1 si esta, 0 si no está
if(!res) // En caso de no estar lo añade
{
n_amigos++; //un nuevo amigo
8:
pamigos =(amigo*)realloc(pamigos, n_amigos*sizeof(amigo));
pamigos[n_amigos-1]=nuevo_amigo;
//
EscribirAmigoFichero(pamigos[n_amigos-1])
printf("\nNueva entrada añadida con exito\n");
}
else
{
printf("La persona ya se encuentra en la base de datos\n");
}
}
9:
else if(strcmp(argv[1],"del")==0)
{
// Se llama a la función borrar para comprobar si algún amigo
// de la base de datos coincide con el telefono introducido
// El amigo se eliminará de la variable pamigos dentro de la función
// La función devolverá el nuevo número de amigos
n_amigos=BorrarDatos(pamigos, n_amigos,argv[2]);
}
10:
else if(strcmp(argv[1],"show")==0)
{
MostrarDatos(pamigos[i]); // Muestra los amigo uno a uno
// En este caso, puesto que sólo se ha mostrado la base de datos sin hacer
modificaciones,
// no será necesario escribirla de nuevo, por lo tanto, se finaliza la
ejecución
return 0;
}
11:
else if(strcmp(argv[1],"check")==0)
{
// Comprueba si el cumpleaños de algun amigo será en los próximos 7 días
{
res = ComparaFechas(pamigos[i], 7);
if(res)
MostrarDatos(pamigos[i]); // En caso afirmativo muestra su
información
}
10/16
Curso 2015-16
// En este caso, puesto que sólo se muestra información de la base de
datos sin hacer modificaciones,
ejecución
return 0;
}
12:
else if(strcmp(argv[1],"group")==0)
{
AgruparAmigos(pamigos,n_amigos);
// En este caso, puesto que sólo se muestra información de la base de
datos sin hacer modificaciones,
ejecución
return 0;
}
else
{
printf("La opcion introducida (%s) no está contemplada\n",argv[1]);
return -1;
}
// Una vez finalicen las acciones, en algunos de los casos será necesario
volver a escribir la base de datos
// Escribir los datos ya procesados en el fichero sustituyendo la base de datos
anterior
fpdatos = fopen("basedatos.txt","w");
{
printf("No ha sido posible abrir la base de datos\n");
return -1;
}
fprintf(fpdatos,"%d", n_amigos); // Escribe el número actualizado de amigos
13:
EscribirAmigoFichero(pamigos[i]); // Va escribiendo la
información de cada amigo uno a uno
fclose(fpdatos);
free(pamigos); //Liberamos memoria
}
Se han marcado en negrita los puntos clave del programa para comentarlos a continuación:
1: pamigos es el puntero para almacenar la lista de alumnos
2: se abre la base de datos donde se encuentran todos los amigos guardados. El formato del
fichero es el descrito en el apartado 4.6.
3: se reserva memoria para n_amigos estructuras de tipo amigo.
4: se lee la lista de amigos desde fichero
5: opción para añadir un nuevo amigo a la lista.
6: se lee un nuevo amigo desde el fichero pasado en argv[2] (ej. entradadatos.txt)
7: se comprueba que el amigo no se encuentre ya en la lista.
8: en caso de no encontrarse en la lista, se reserva memoria para un amigo más y se añade al
final de la lista. No es necesario que la lista se encuentre ordenada.
9: opción para eliminar una entrada de la lista. Se elimina el amigo cuyo teléfono sea argv[2]
10: se muestran todos los amigos de la lista.
11: se muestran todos los amigos cuyas fechas de cumpleaños se encuentren cercanas.
12: se muestran los amigos agrupados por ciudad
13: una vez se ha procesado la lista, añadiendo o eliminando entradas, se vuelve a escribir en
el fichero.
11/16
Curso 2015-16
4.3.- practica5.h que la declaración de la estructura y de las variables globales:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <math.h>
#include <locale.h>
#define TAMMAX 50
// Declaración de las estructuras a usar en la práctica
struct direccion{
char calle[TAMMAX];
char c_postal[TAMMAX];
char ciudad[TAMMAX];
char provincia[TAMMAX];
char pais[TAMMAX];
};
typedef struct direccion direccion;
struct contacto{
char fijo[TAMMAX];
char movil[TAMMAX];
char mail1[TAMMAX];
char mail2[TAMMAX];
};
typedef struct contacto contacto;
struct amigo{
direccion direcc;
contacto contact;
int dia, mes, anyo; // cumpleaños
};
typedef struct amigo amigo;
// Declaración de la variable fpdatos de forma global para abrir y cerrar ficheros
FILE* fpdatos;
12/16
Curso 2015-16
4.4.- practica5_entrega.c que contiene la lista de funciones que debéis completar:
// NOMBRE Y DNI DEL ALUMNO
#include "practica5.h"
//Muestra todos los datos de un amigo
void MostrarDatos(amigo a)
{
//***************************************************************************
//CÓDIGO A ESCRIBIR POR EL ALUMNO
//***************************************************************************
}
//Lee todos los datos de un amigo
void LeerAmigoFichero(amigo *a)
{
//***************************************************************************
//***************************************************************************
}
// Escribe una amigo en la base de datos
void EscribirAmigoFichero(amigo a)
{
//***************************************************************************
//***************************************************************************
}
// Devuelve 1 si nuevo_amigo se encuentra en la lista (se usan los telefonos para
comprobarlo
// Será necesario comprobar si hay alguna coincidencia entre fijo-fijo, movilmovil, fijo-movil y movil-fijo
int ComprobarLista(amigo* lista_amigos, amigo nuevo_amigo, int n_amigos)
{
//***************************************************************************
//***************************************************************************
}
//Compara la fecha actual con el cumpleaños del amigo
//devuelve 1 si faltan menos de margendias para la fecha
int ComparaFechas(amigo am, int margendias)
{
int dia, mes;
time_t rawtime;
struct tm * timeinfo;
int dias1, dias2;
dia = am.dia;
mes = am.mes;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
//Obtenemos el dia del año de hoy de la estructura
dias1 =
timeinfo->tm_yday;
13/16
Curso 2015-16
//Cambiamos los datos para el mes del amigo
timeinfo->tm_mon = mes - 1;
timeinfo->tm_mday = dia;
mktime(timeinfo); //tm_yday se
//Obtenemos el dia del año de la fecha del amigo
dias2 = timeinfo->tm_yday;
// Si faltan menos de margendías y la fecha no es pasada
if((dias2-dias1 < margendias)&&(dias2-dias1 >= 0))
return 1;
return 0;
}
// Elimina a aquel amigo de la base de datos cuyo telefono indicado coincida con su
fijo o movil
// La función devolverá el nuevo número de amigos
int BorrarDatos(amigo* lista_amigos, int n_amigos, char *telefono)
{
//***************************************************************************
//***************************************************************************
}
// Esta función mostrará cada una de las ciudades (sólo una vez)
// indicando a continuación el nombre de cada amigos que pertenecen a dicha ciudad
void AgruparAmigos(amigo* lista_amigos, int n_amigos)
{
//***************************************************************************
//***************************************************************************
}
14/16
Curso 2015-16
4.5.- Funciones a realizar:
La llamada a las funciones se debe realizar según se especifica en la función main anterior. A
continuación se presenta el prototipo de cada función y se explica su funcionamiento:
void MostrarDatos(amigo a);
Debe mostrar toda la información que se guarda en una estructura de tipo amigo.
void LeerAmigoFichero(amigo *a);
Debe leer desde el fichero todos los datos de una persona. Utilícese el puntero global fpdatos,
ya que debe ser capaz de leer del fichero datos.txt o del fichero de entrada.
void EscribirAmigoFichero(amigo a);
Escribe en el fichero datos.txt todos los datos de la estructura amigo.
int ComprobarLista(amigo* lista_amigos, amigo nuevo_amigo, int n_amigos);
Debe recorrer toda la lista de amigos para comprobar si los datos de nuevo_amigo ya se
encuentran en la lista. Debe devolver 1 en caso de que ya se encuentren y 0 en caso contrario.
int ComparaFechas(amigo am, int margendias);
La función se proporciona al alumno. Comprueba si la fecha del cumpleaños de la estructura
am se dará dentro de, al menos, margendias días.
int BorrarDatos(amigo* lista_amigos, int n_amigos, char *telefono);
La función borra al amigo cuyo teléfono fijo o móvil coincida con el indicado. Devuelve el
nuevo número de amigos
void AgruparAmigos(amigo* lista_amigos, int n_amigos);
La función muestra la lista de amigos agrupados por país.
15/16
Curso 2015-16
4.6.- Formato de los ficheros tanto de basedatos.txt como de los ficheros utilizados para
añadir nuevos amigos:
El formato del fichero basedatos.txt se detalla a continuación. El fichero se puede editar con el
bloc de notas de Windows. El primer parámetro es el número de entradas existentes en el
fichero. A continuación, se encuentran ordenados todos los datos de cada persona, separados
por un retorno de carro. En el caso de un fichero para añadir un nuevo amigo a la base de
datos, el primer valor será 1 y a continuación se indican los datos de la persona con la misma
estructura que la base de datos:
•
•
•
•
•
•
•
•
•
•
•
Nombre
Dirección Calle
Dirección Código postal
Dirección Ciudad
Dirección Provincia
Dirección País
Contacto Fijo
Contacto Móvil
Contacto Mail1
Contacto Mail2
Cumpleaños día mes año
16/16

P5. Estructuras - Sistemas Informáticos Industriales (1774)

Transcripción

Documentos relacionados

RESPUESTA

Protección de datos

1.- Dada la siguiente plantilla de estructura: struct vendedor { char

datos del alumno para la fct cfgm .