Sami GHEBRID
2 years ago
parent
d915566ab7
commit
18ed424791
@ -0,0 +1,43 @@
|
||||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#include<stdbool.h>
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char dept[31];
|
||||
int nbP;
|
||||
char respAd[31];
|
||||
} Departement;
|
||||
|
||||
typedef struct maillonDept
|
||||
{
|
||||
Departement d;
|
||||
struct maillonDept *suiv;
|
||||
|
||||
} MaillonDept,*ListeDept;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char nom[31];
|
||||
ListeDept lDept;
|
||||
} VilleIUT;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char ville[31];
|
||||
char dep[31];
|
||||
int decisionResp;
|
||||
int decisionCand;
|
||||
} Choix;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int numeroC;
|
||||
char nom[31];
|
||||
char prenom[31];
|
||||
float notes[4];
|
||||
int nombreChoix;
|
||||
Choix **tchoix;
|
||||
} Candidat;
|
||||
@ -1,64 +1,743 @@
|
||||
#include"Ssae.h"
|
||||
|
||||
void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax){
|
||||
int select=0;
|
||||
while(select!=9){
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void clearpage(void)
|
||||
{
|
||||
char entre;
|
||||
printf("\nappuyé sur la touche [ENTREE] pour continuer");
|
||||
scanf("%*c%c", &entre);
|
||||
system("clear");
|
||||
printf("\t AFFICHAGE ADMIN\n\n");
|
||||
printf("1\tModifier le nombre de places dans un département\n");
|
||||
printf("2\tCréer un nouveau département\n");
|
||||
printf("3\tSupprimer un département\n");
|
||||
printf("4\tLancer/Arrêter la phase de candidature\n");
|
||||
printf("5\tModifer le nom du responsable d'un département\n");
|
||||
scanf("%d",&select);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax)
|
||||
{
|
||||
int select, pos;
|
||||
char ville[31], dept[31];
|
||||
int trouve;
|
||||
MaillonDept *m;
|
||||
system("clear");
|
||||
printf("____________________________________________________-\n");
|
||||
printf("| AFFICHAGE CANDIDAT |\n");
|
||||
printf("|---------------------------------------------------|\n");
|
||||
printf("| 1 Afficher les villes où il y a un IUT |\n");
|
||||
printf("| 2 Afficher tous les départements dans chaque IUT |\n");
|
||||
printf("| 3 Nombres de places en première année |\n");
|
||||
printf("| 4 Rechercher un département dans les IUT |\n");
|
||||
printf("| 9 Quitter |\n");
|
||||
printf("|___________________________________________________|\n");
|
||||
printf("Saisie : ");
|
||||
scanf("%d%*c",&select);
|
||||
while(select != 9)
|
||||
{
|
||||
system("clear");
|
||||
if(select==1)
|
||||
{
|
||||
afficherTIUT(tiut,*tLog);
|
||||
}
|
||||
if(select==2)
|
||||
{
|
||||
printf("Quel IUT souhaitez-vous chercher \nSaisie : ");
|
||||
scanf("%s%*c",ville);
|
||||
printf("\n");
|
||||
pos=rechercheIUT(tiut,*tLog,ville,&trouve);
|
||||
while(trouve == 0)
|
||||
{
|
||||
printf("Cette ville n'existe pas, veuillez-resaisir\nSaisie : ");
|
||||
scanf("%s%*c",ville);
|
||||
pos=rechercheIUT(tiut,*tLog,ville,&trouve);
|
||||
printf("\n");
|
||||
}
|
||||
afficherVilleDep(*tiut[pos]);
|
||||
}
|
||||
if(select==3)
|
||||
{
|
||||
printf("Quel IUT ?\nSaisie :");
|
||||
scanf("%s%*c",ville);
|
||||
pos=rechercheIUT(tiut,*tLog,ville,&trouve);
|
||||
while(trouve==0)
|
||||
{
|
||||
printf("Cette ville n'existe pas, veuillez-resaisir\nSaisie : ");
|
||||
scanf("%s%*c",ville);
|
||||
pos=rechercheIUT(tiut,*tLog,ville,&trouve);
|
||||
printf("\n");
|
||||
}
|
||||
printf("Quel département ?\nSaisie : ");
|
||||
scanf("%s%*c",dept);
|
||||
m=rechercherDept(tiut[pos]->lDept,dept,&trouve);
|
||||
while(trouve==0)
|
||||
{
|
||||
printf("Ce département n'existe pas, veuillez-resaisir\nSaisie : ");
|
||||
scanf("%s%*c",dept);
|
||||
m=rechercherDept(tiut[pos]->lDept,dept,&trouve);
|
||||
}
|
||||
afficherPlace(m->d);
|
||||
clearpage();
|
||||
|
||||
}
|
||||
if(select==4)
|
||||
{
|
||||
afficheDeptDesIUT(tiut,*tLog);
|
||||
}
|
||||
printf("_____________________________________________________\n");
|
||||
printf("| AFFICHAGE CANDIDAT |\n");
|
||||
printf("|---------------------------------------------------|\n");
|
||||
printf("| 1 Afficher les villes où il y a un IUT |\n");
|
||||
printf("| 2 Afficher tous les départements dans chaque IUT |\n");
|
||||
printf("| 3 Nombres de places en première année |\n");
|
||||
printf("| 4 Rechercher un département dans les IUT |\n");
|
||||
printf("| 9 Quitter |\n");
|
||||
printf("|___________________________________________________|\n");
|
||||
printf("Saisie :");
|
||||
scanf("%d%*c",&select);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax){
|
||||
int select=0;
|
||||
while(select!=9){
|
||||
void afficheDeptDesIUT(VilleIUT *tiut[], int tLog)
|
||||
{
|
||||
char dept[31];
|
||||
int i,trouve;
|
||||
system("clear");
|
||||
printf("\t AFFICHAGE CANDIDAT \n\n");
|
||||
printf("1\tRechercher les villes où il y a un IUT\n");
|
||||
printf("2\tRechercher chaque département dans les IUT\n");
|
||||
printf("3\tNombres de places en 1A\n");
|
||||
printf("4\tRechercher un département dans les IUT\n");
|
||||
scanf("%d",&select);
|
||||
printf("######################################################################################################################\n");
|
||||
printf("Quel département cherchez-vous dans les IUT ?\t");
|
||||
scanf("%s%*c",dept);
|
||||
printf("\n\n\t\tCe département est présent dans ces IUT :\n");
|
||||
printf("----------------------------------------------------------------------------------------------------\n");
|
||||
for(i=0;i<tLog;i++)
|
||||
{
|
||||
rechercherDept(tiut[i]->lDept,dept,&trouve);
|
||||
if (trouve==1)
|
||||
{
|
||||
printf("|%s",tiut[i]->nom);
|
||||
}
|
||||
}
|
||||
printf("|\n");
|
||||
clearpage();
|
||||
}
|
||||
|
||||
|
||||
|
||||
void clearpage(void)
|
||||
|
||||
ListeDept listeDeptNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
|
||||
{
|
||||
char entre;
|
||||
printf("\nappuyé sur la touche [ENTREE] pour continuer");
|
||||
scanf("%*c%c", &entre);
|
||||
system("clear");
|
||||
ListeDept lDept;
|
||||
lDept = NULL;
|
||||
return lDept;
|
||||
}
|
||||
|
||||
ListeDept insererEntete(ListeDept lDept,Departement d) /*Permet d'insérer un MaillonDept en début d'une liste passée en paramètre puis renvoie cette même liste*/
|
||||
{
|
||||
MaillonDept *m; /* Création d'un pointeur vers une structure MaillonDept */
|
||||
m = (MaillonDept *)malloc(sizeof(MaillonDept)); /* Allocation d'un espace mémoire pour le nouveau maillon */
|
||||
if(m == NULL)
|
||||
{
|
||||
printf("Problème d'allocation mémoire lors de l'insertion\n"); /* Message d'erreur en cas de problème de malloc */
|
||||
exit(1);
|
||||
}
|
||||
m->d = d; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
|
||||
m->suiv = lDept;
|
||||
return m;
|
||||
}
|
||||
|
||||
ListeDept insererDept(ListeDept lDept, Departement d) /* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alpĥabétique/croissant et retourne cette liste */
|
||||
{
|
||||
if(lDept == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
|
||||
{
|
||||
return insererEntete(lDept,d);
|
||||
}
|
||||
if(strcmp(d.dept, lDept->d.dept) < 0) /* Si le nom du département est inférieur à celui de la liste testé, le maillon est inséré en tête*/
|
||||
{
|
||||
return insererEntete(lDept,d);
|
||||
}
|
||||
if(strcmp(d.dept,lDept->d.dept) == 0) /* Si le maillon existe déjà, retourne la liste sans changement */
|
||||
{
|
||||
printf("Département déjà présent dans cet IUT\n");
|
||||
return lDept;
|
||||
}
|
||||
lDept->suiv = insererDept(lDept->suiv,d); /* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
|
||||
return lDept;
|
||||
}
|
||||
|
||||
ListeDept supprimerEntete(ListeDept lDept) /* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
|
||||
{
|
||||
ListeDept aux;
|
||||
if(lDept == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
|
||||
{
|
||||
printf("Opération interdite\n");
|
||||
exit(1);
|
||||
}
|
||||
aux = lDept; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
|
||||
lDept = lDept->suiv; /* On supprime le maillon */
|
||||
free(aux); /* On libère l'espace mémoire du maillon supprimer*/
|
||||
return lDept;
|
||||
}
|
||||
|
||||
ListeDept supprimerDept(ListeDept lDept, char *dep) /* Permet de supprimer un maillon d'une liste lDept passée en paramètre à partir de son attribut nom de département (dept) et retourne cette liste */
|
||||
{
|
||||
if(lDept == NULL) /* La liste est vide, on la retourne sans changements */
|
||||
{
|
||||
return lDept;
|
||||
}
|
||||
if(strcmp(dep, lDept->d.dept) < 0) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
|
||||
{
|
||||
return lDept;
|
||||
}
|
||||
if(strcmp(dep,lDept->d.dept) == 0) /* Le maillon à supprimer est trouvé, on le supprime */
|
||||
{
|
||||
return supprimerEntete(lDept);
|
||||
}
|
||||
lDept->suiv = supprimerDept(lDept->suiv,dep); /* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
|
||||
return lDept;
|
||||
}
|
||||
|
||||
int longueur(ListeDept lDept) /* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
|
||||
{
|
||||
int compt = 0; /* On déclare un compteur pour compter le nombre de maillons */
|
||||
while(lDept != NULL) /* Tant que la liste n'est pas vide, on incrémente le compteur de 1 et on passe au maillon suivant */
|
||||
{
|
||||
compt = compt + 1;
|
||||
lDept = lDept->suiv;
|
||||
}
|
||||
return compt;
|
||||
}
|
||||
|
||||
bool vide(ListeDept lDept) /* Permet de savoir si une liste est vide et retourne un booléen */
|
||||
{
|
||||
if(lDept == NULL)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/*int tete(Liste l){
|
||||
if(l==NULL){
|
||||
printf("Opération interdite\n");
|
||||
exit(1)
|
||||
}
|
||||
return l->v;
|
||||
}*/
|
||||
|
||||
ListeDept rechercherDept(ListeDept lDept, char dept[], int *trouve) /* Permet de recherche un maillon dans une liste de départements passée en paramètre pour ensuite renvoyer son adresse*/
|
||||
{
|
||||
if(vide(lDept)) /* Si la liste est vide, la variable trouve passée en pointeur prend la valeur 0 et on retourne la liste */
|
||||
{
|
||||
*trouve = 0;
|
||||
return lDept;
|
||||
}
|
||||
if(strcmp(dept, lDept->d.dept) < 0) /* Même procédé que la condition précédente si le département recherché n'est pas trouvé*/
|
||||
{
|
||||
*trouve = 0;
|
||||
return lDept;
|
||||
}
|
||||
if(strcmp(dept,lDept->d.dept) == 0) /* Si le département recherché est trouvé, trouve prend la valeur 1 et on retourne la liste */
|
||||
{
|
||||
*trouve = 1;
|
||||
return lDept;
|
||||
}
|
||||
return rechercherDept(lDept->suiv, dept, trouve); /* Si aucune condition n'est respectée, renvoie la même recherche pour le maillon suivant */
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/********************************************************* Fonctions d'affichage **************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
|
||||
|
||||
void afficherDep(Departement d) /* Permet d'afficher un département passé en paramètre de façon esthétique */
|
||||
{
|
||||
printf("______________________________________________________________________________\n");
|
||||
printf("| Département |\n");
|
||||
printf("|----------------------------------------------------------------------------|\n");
|
||||
printf("| %-32s | %3d | %-32s |\n", d.dept, d.nbP, d.respAd);
|
||||
printf("|----------------------------------------------------------------------------|\n");
|
||||
}
|
||||
|
||||
void afficherVille(VilleIUT v) /* Permet d'afficher le nom d'une variable de type structure villeIUT passée en paramètre de façon esthétique */
|
||||
{
|
||||
printf("|----------------------------------|\n");
|
||||
printf("| %-32s |\n", v.nom);
|
||||
printf("|----------------------------------|\n");
|
||||
}
|
||||
|
||||
void afficherTIUT(VilleIUT *tiut[], int tLog) /* Permet d'afficher le nom de toute les villes présentes dans le tableau tiut de façon esthétique*/
|
||||
{
|
||||
int i = 0;
|
||||
printf("____________________________________\n");
|
||||
printf("| Ville |\n");
|
||||
for(i = 0; i < tLog; i++)
|
||||
{
|
||||
afficherVille(*tiut[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void afficherVilleDep(VilleIUT v) /* Permet d'afficher une ville passée en paramètre ainsi que tous les départements qui y sont présent de manière esthétique*/
|
||||
{
|
||||
ListeDept l;
|
||||
printf("_________________________________________________________________________________________________________________\n");
|
||||
printf("| Ville | Département |\n");
|
||||
printf("|----------------------------------|----------------------------------------------------------------------------|\n");
|
||||
l = v.lDept;
|
||||
while(l != NULL)
|
||||
{
|
||||
printf("| %-32s | %-32s | %3d | %-32s |\n", v.nom, l->d.dept, l->d.nbP, l->d.respAd);
|
||||
printf("|----------------------------------|----------------------------------------------------------------------------|\n");
|
||||
l = l->suiv;
|
||||
}
|
||||
}
|
||||
|
||||
void afficherPlace(Departement d) /* Permet d'afficher le nombre de place disponibles dans un département passé en paramètres */
|
||||
{
|
||||
printf("\nPour ce département il y a %d places en 1ère année \n\n",d.nbP);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/********************************************************* Fonctions de Chargement ************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
|
||||
int rechercheIUT(VilleIUT *tiut[], int tLog, char ville[], int *trouve){
|
||||
int inf,sup,t;
|
||||
inf=0;
|
||||
sup=tLog-1;
|
||||
while(inf<=sup){
|
||||
t=(inf+sup)/2;
|
||||
if(strcmp(ville,tiut[t]->nom)==0){
|
||||
*trouve=1;
|
||||
|
||||
int chargement(VilleIUT *tiut[],int tMax) /* Permet de charger le contenu du fichier IUT.don dans des structures MaillonDept et VilleIUT pour remplir le tableau tiut */
|
||||
{
|
||||
FILE *flot; /* Déclaration de la variable pour lire le fichier */
|
||||
int tLog = 0, pos, trouve; /* tLog, la taille logique que l'on incrémente à chaque nouvelle ville insérée dan le tableau */
|
||||
char nomV[31];
|
||||
Departement d;
|
||||
flot = fopen("IUT.don","r"); /* Ouverture du fichier */
|
||||
if(flot == NULL) /* En cas de problème avec l'ouverture du fichier, on affiche un message d'erreur, on ferme le fichier et on quitte la fonction */
|
||||
{
|
||||
printf("Erreur lors de l'ouverture du fichier\n");
|
||||
fclose(flot);
|
||||
return -1;
|
||||
}
|
||||
fscanf(flot, "%s", nomV); /* On commence par lire le nom de la première ville dans le fichier */
|
||||
while(!feof(flot))
|
||||
{
|
||||
if(tLog == tMax) /* Si le tableau est plein, on affiche un message d'erreur, on ferme le fichier et on arrête la fonction */
|
||||
{
|
||||
printf("Tableau tiut plein\n");
|
||||
fclose(flot);
|
||||
return -3;
|
||||
}
|
||||
d = lireDep(flot); /* On appelle la fonction lireDep pour remplir une structure Département à partir du fichier */
|
||||
pos = rechercheIUT(tiut,tLog,nomV,&trouve); /* On recherche la ville lue dans le tableau et on récupère sa position si elle est présente ou sa position d'insertion dans le cas contraire*/
|
||||
if(trouve == 1) /* Si la ville a été trouvée, on insère le département d lu dans la liste des départements de la ville en question*/
|
||||
{
|
||||
tiut[pos]->lDept = insererDept(tiut[pos]->lDept, d);
|
||||
}
|
||||
else /* Si la ville n'existe pas, on l'insère dans le tableau et on insère dans sa liste le département d */
|
||||
{
|
||||
insererVille(tiut, nomV, &tLog, tMax, pos);
|
||||
tiut[pos]->lDept = insererDept(tiut[pos]->lDept,d);
|
||||
}
|
||||
fscanf(flot, "%s", nomV); /* On lit le nom de la ville suivante pour continuer le remplissage du tableau */
|
||||
}
|
||||
fclose(flot); /* On ferme le fichier avant de retourner la taille logique du tableau */
|
||||
return tLog;
|
||||
}
|
||||
|
||||
Departement lireDep(FILE *flot) /* Permet de lire à partir d'un flot passé en paramètre les informations relatives à un département pour les insérer dans une structure Département*/
|
||||
{
|
||||
Departement d;
|
||||
fscanf(flot,"%s%d", d.dept, &d.nbP);
|
||||
fgets(d.respAd,31,flot);
|
||||
d.respAd[strlen(d.respAd) - 1] = '\0';
|
||||
return d;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/************************************************************** Fonctions de Villes ***********************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
|
||||
|
||||
int insererVille(VilleIUT *tiut[], char nomV[], int *tLog, int tMax, int pos) /* Permet d'insérer une ville dans le tableau tiut et renvoie un entier dépendant du déroulement de l'insertion */
|
||||
{
|
||||
int i;
|
||||
if(*tLog == tMax) /* Si le tableau est plein, l'insertion est impossible, on affiche un message d'erreur et on retourne -1 */
|
||||
{
|
||||
printf("Tableau plein, insertion impossible\n");
|
||||
return -1;
|
||||
}
|
||||
for(i = *tLog - 1; i >= pos; i--) /* On décale tous les éléments vers la droite depuis le dernier élément du tableau jusqu'à la position d'insertion passée en paramètre */
|
||||
{
|
||||
tiut[i + 1] = tiut[i];
|
||||
}
|
||||
tiut[pos] = (VilleIUT *)malloc(sizeof(VilleIUT)); /* On alloue un espace mémoire pour la nouvelle ville à insérer */
|
||||
if(tiut[pos] == NULL) /* Si l'allocation se passe mal, on affiche un message d'erreur et on retourne -1 */
|
||||
{
|
||||
printf("Problème d'allocation mémoire lors de l'insertion de la ville\n");
|
||||
return -1;
|
||||
}
|
||||
strcpy(tiut[pos]->nom, nomV); /* On copie le nom de la ville à insérer passé en paramètre dans le nom de la structure VilleIUT allouée précédemment*/
|
||||
tiut[pos]->lDept = listeDeptNouv(); /* On créer une liste de départements vide pour la nouvelle ville */
|
||||
*tLog = *tLog + 1; /* On incrémente de 1 la taille logique après insertion de la nouvelle ville */
|
||||
return 0;
|
||||
}
|
||||
|
||||
int supprimerVille(VilleIUT *tiut[], char nomV[], int *tLog, int pos) /* Permet de supprimer une ville du tableau tiut dont le nom est passé en paramètre*/
|
||||
{
|
||||
VilleIUT *aux; /* Création d'un pointeur auxiliaire vers une structure villeIUT */
|
||||
aux = tiut[pos]; /* Attribution de la ville à supprimer à la variable auxiliaire */
|
||||
while(pos < *tLog - 1) /* Décalage à gauche de tous les éléments du tableau à partir de la position de la villeà supprimer passée en paramètre */
|
||||
{
|
||||
tiut[pos] = tiut[pos + 1];
|
||||
pos++;
|
||||
}
|
||||
while(aux->lDept != NULL) /* Suppression de tous les départements dans la liste de la ville supprimée */
|
||||
{
|
||||
aux->lDept = supprimerEntete(aux->lDept);
|
||||
}
|
||||
free(aux); /* Libération de la mémoire occupée par la ville supprimée*/
|
||||
*tLog = *tLog - 1; /* Diminution de la taille logique de 1 après la suppression de la ville */
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int rechercheIUT(VilleIUT *tiut[], int tLog, char ville[], int *trouve) /* Permet d'effectuer une recherche dichotomique dans le tableau tiut d'une ville passée en paramètre */
|
||||
{
|
||||
int inf,sup,t; /* Déclarations des variables permettant la navigarion dans le tableau */
|
||||
inf = 0;
|
||||
sup = tLog - 1;
|
||||
while(inf <= sup)
|
||||
{
|
||||
t = (inf + sup) / 2; /* Calcul de l'indice de position central du tableau*/
|
||||
if(strcmp(ville, tiut[t]->nom) == 0) /* Si la ville est trouvée, on donne la valeur 1 à la variable trouve passée par pointeur et on retourne sa position */
|
||||
{
|
||||
*trouve = 1;
|
||||
return t;
|
||||
}
|
||||
if(strcmp(ville,tiut[t]->nom)<0)
|
||||
sup=t-1;
|
||||
else inf=t+1;
|
||||
if(strcmp(ville, tiut[t]->nom) < 0) /* Si la ville recherchée est inférieure à la ville à la position t (centrale), on continue la recherche dans la partie gauche du tableau */
|
||||
{
|
||||
sup = t - 1;
|
||||
}
|
||||
else /* Dans le cas contraire, on continue la recherche dans la partie droite du tableau */
|
||||
{
|
||||
inf = t + 1;
|
||||
}
|
||||
}
|
||||
*trouve = 0; /* Si la ville n'a pas été trouvée, on donne la valeur 0 à trouve et on retourne sa position d'insertion inf */
|
||||
return inf;
|
||||
}
|
||||
|
||||
|
||||
/******************************************************* Fonctions de départements ************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
|
||||
|
||||
void creerDept(VilleIUT *tiut[],int tLog) /* Permet de demander à l'administrateur toutes les informations nécessaires pour la création d'un nouveau département et exécute cette création */
|
||||
{
|
||||
Departement d;
|
||||
int pos, trouve;
|
||||
char ville[31];
|
||||
printf("Dans quelle ville souhaitez-vous créer un nouveau département ?\nSaisie : "); /* Recueil du nom de la ville dans laquelle insérer le département */
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, tLog, ville, &trouve); /* Vérification que la ville est bien existante, si ce n'est pas le cas, on re-demande de saisir le nom tant que ce n'est pas bon */
|
||||
while(trouve == 0)
|
||||
{
|
||||
printf("Cette ville n'existe pas, veuillez re-saisir : ");
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, tLog, ville, &trouve);
|
||||
}
|
||||
printf("Quel est le nom du département à insérer ?\nSaisie : "); /* Demande le nom du département à insérer */
|
||||
scanf("%s%*c", d.dept);
|
||||
rechercherDept(tiut[pos]->lDept, d.dept, &trouve); /* Vérification que le département n'existe pas déjà */
|
||||
if(trouve == 1) /* Si le département existe déjà, on affiche un message d'erreur et on arrête la fonction */
|
||||
{
|
||||
printf("Erreur, le département %s existe déjà dans cet IUT\n", d.dept);
|
||||
return;
|
||||
}
|
||||
printf("Combien de place y a-t-il pour dans ce département ?\nSaisie : "); /* On continue de demander les informations nécessaires sur le département à insérer */
|
||||
scanf("%d%*c", &d.nbP);
|
||||
printf("\n");
|
||||
printf("Quel est le nom du responsable du département ?\nSaisie : ");
|
||||
fgets(d.respAd, 31, stdin);
|
||||
d.respAd[strlen(d.respAd) - 1] = '\0';
|
||||
afficherDep(d); /* On affiche le département qui va être inséré */
|
||||
tiut[pos]->lDept = insererDept(tiut[pos]->lDept, d); /* On insère le département dans la liste de la ville correspondante */
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void retirerDept(VilleIUT *tiut[], int tLog) /* Permet de gérer la suppression d'un département dans une ville saisie dans la fonction */
|
||||
{
|
||||
int trouve, pos;
|
||||
char ville[31], dep[31], choix;
|
||||
printf("Dans quelle ville souhaitez-vous supprimer un département ?\nSaisie : "); /* Demande dans quelle ville on souhaite supprimer un département */
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, tLog, ville, &trouve); /* On vérifie que la ville existe */
|
||||
while(trouve == 0) /* Si la ville n'existepas, on effectue une saisie contrôlée tant que ce n'est pas bon */
|
||||
{
|
||||
printf("Cette ville n'existe pas, veuillez re-saisir : ");
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, tLog, ville, &trouve);
|
||||
}
|
||||
printf("Quel est le nom du département à supprimer ?\nSaisie : "); /* Demande le nom du département à supprimer */
|
||||
scanf("%s%*c", dep);
|
||||
rechercherDept(tiut[pos]->lDept, dep, &trouve); /* Vérifie que le département en question existe */
|
||||
if(trouve == 0) /* S'il n'existe pas, affiche un message d'erreur et arrête la fonction */
|
||||
{
|
||||
printf("Erreur, le département %s n'existe pas dans cet IUT\n", dep);
|
||||
return;
|
||||
}
|
||||
printf("Êtes-vous sur de vouloir supprimer ce département ? (O/n)\nSaisie : "); /* Demande confirmation de la suppression */
|
||||
scanf("%c%*c", &choix);
|
||||
printf("\n");
|
||||
if(choix == 'N' || choix == 'n') /* Si le choix et non, annule la supression */
|
||||
{
|
||||
printf("Suppression annulée\n");
|
||||
return;
|
||||
}
|
||||
tiut[pos]->lDept = supprimerDept(tiut[pos]->lDept, dep); /* Supprime le département */
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*********************************************** Fonctions de login, menus, globale et clearpage **********************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
/**********************************************************************************************************************************************/
|
||||
|
||||
|
||||
int login(void) /* Affiche un menu de connexion pour ensuite adapter l'affichage et les fonctionnalités au type d'utilisateur */
|
||||
{
|
||||
int i = 3;
|
||||
char id, mdp[31] = "mettez20svp", mdpatrouve[31]; /* Déclaration d'un motdepasse administrateur */
|
||||
system("clear");
|
||||
printf("\t################################ Bienvenue! ################################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur ? (C/A)\nSaisie : ");
|
||||
scanf("%c%*c",&id);
|
||||
if(id == 'q') /* Si l'utilisateur saisie la lettre 'q', le programme s'arrête */
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
while(id != 'A' && id != 'a' && id != 'C' && id != 'c') /* Effectue une saisie contrôlée si la saisie ne correspond à aucune option */
|
||||
{
|
||||
system("clear");
|
||||
printf("\t#################### Mauvaise saisie ('q' pour quitter) ####################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur? (C/A)\nSaisie : ");
|
||||
scanf("%c%*c",&id);
|
||||
if(id == 'q')
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if(id == 'A' || id == 'a') /* Si l'utilisateur sélectionne administrateur, il doit ensuit taper le mot de passe */
|
||||
{
|
||||
while(i != 0)
|
||||
{
|
||||
printf("\n\nMot de passe : ");
|
||||
system("stty -echo"); /* On masque la saisie pour saisir le mot de passe */
|
||||
fgets(mdpatrouve, 31, stdin);
|
||||
mdpatrouve[strlen(mdpatrouve) - 1] = '\0';
|
||||
printf("\n");
|
||||
if(strcmp(mdpatrouve, mdp) == 0 ) /* Si le mot de passe est bon, la fonction retourne 1 */
|
||||
{
|
||||
system("stty echo");
|
||||
system("clear");
|
||||
return 1;
|
||||
}
|
||||
else /* Si le mot de passe est faux, l'utilisateur dispose de 2 essais supplémentaire */
|
||||
{
|
||||
i--;
|
||||
printf("Mot de passe incorrect, il vous reste %d chances\n",i);
|
||||
}
|
||||
system("stty echo");
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
else /* Si l'utilisateur sélectionne candidat, la fonction retourne 0 */
|
||||
{
|
||||
system("clear");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void afficherVille(VilleIUT v){
|
||||
printf("%s",v.nom);
|
||||
|
||||
void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax) /* Affiche un menu de choix adaptés pour un administrateur et appelle les fonctions en conséquence */
|
||||
{
|
||||
int select = 0, pos;
|
||||
int trouve;
|
||||
char ville[31], choix;
|
||||
ListeDept l;
|
||||
printf("__________________________________________________________\n");
|
||||
printf("| MENU ADMIN |\n");
|
||||
printf("|--------------------------------------------------------|\n");
|
||||
printf("| 1 Afficher les villes possédant un IUT |\n");
|
||||
printf("| 2 Afficher les départements d'un IUT |\n");
|
||||
printf("| 3 Créer un nouveau département |\n");
|
||||
printf("| 4 Supprimer un département |\n");
|
||||
printf("| 5 Effectuer une mise à jour d'un département d'un IUT |\n");
|
||||
printf("| 6 Insérer un nouvel IUT |\n");
|
||||
printf("| 7 Supprimer un IUT de la liste |\n");
|
||||
printf("| 8 Lancer/Arrêter la phase de candidature |\n");
|
||||
printf("| 9 Quitter |\n");
|
||||
printf("|--------------------------------------------------------|\n\n");
|
||||
printf("Saisie : "); /* Choix de l'administrateur */
|
||||
scanf("%d%*c",&select);
|
||||
while(select != 9) /* Tant que l'utilisateur ne saisie pas 9, le menu réapparait après que la fonction appelée est terminée */
|
||||
{
|
||||
system("clear");
|
||||
if(select == 1)
|
||||
{
|
||||
afficherTIUT(tiut, *tLog);
|
||||
}
|
||||
if(select == 2)
|
||||
{
|
||||
printf("Pour quelle ville souhaitez-vous afficher les départements ?\nSaisie : "); /* Demande une ville à afficher */
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, *tLog, ville, &trouve); /* Vérifie que la ville existe */
|
||||
while(trouve == 0) /* Si elle n'existe pas, on effectue une saisie contrôlée */
|
||||
{
|
||||
printf("Cette ville n'existe pas, veuillez re-sasisir : ");
|
||||
scanf("%s%*c", ville);
|
||||
pos = rechercheIUT(tiut, *tLog, ville , &trouve);
|
||||
printf("\n");
|
||||
}
|
||||
afficherVilleDep(*tiut[pos]); /* Affiche ensuite la ville */
|
||||
}
|
||||
if(select == 3)
|
||||
{
|
||||
creerDept(tiut, *tLog);
|
||||
}
|
||||
if(select == 4)
|
||||
{
|
||||
retirerDept(tiut, *tLog);
|
||||
}
|
||||
/*if(select == 5)
|
||||
{
|
||||
miseAJourGlobale(tiut, tLog);
|
||||
}*/
|
||||
if(select == 6)
|
||||
{
|
||||
printf("Quel est le nom de la ville à insérer ?\nSaisie : "); /* Demande le nom de la ville à insérer */
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, *tLog, ville, &trouve); /* Vérifie que la ville existe */
|
||||
if(trouve == 1) /* Si elle existe, affiche un message d'erreur */
|
||||
{
|
||||
printf("Erreur, cette ville existe déjà !\n");
|
||||
}
|
||||
else /* Sinon, appelle la fonction d'insertion */
|
||||
{
|
||||
insererVille(tiut, ville, tLog, tMax, pos);
|
||||
}
|
||||
}
|
||||
if(select == 7)
|
||||
{
|
||||
printf("Quel est le nom de la ville à supprimer ?\nSaisie : "); /* Demande le nom de la ville à supprimer */
|
||||
scanf("%s%*c", ville);
|
||||
printf("\n");
|
||||
pos = rechercheIUT(tiut, *tLog, ville, &trouve); /* Vérifie qu'elle existe */
|
||||
if(trouve == 0) /* Si elle n'existe pas, affiche un message d'erreur */
|
||||
{
|
||||
printf("Erreur, cette ville n'existe pas !\n");
|
||||
}
|
||||
else /* Sinon, demande confirmation, si confirmé, supprime la ville, sinon annule la suppression */
|
||||
{
|
||||
printf("Êtes-vous sur de vouloir supprimer cette ville ? (O/n)\nSaisie : "); /* Demande confirmation de la suppression */
|
||||
scanf("%c%*c", &choix);
|
||||
printf("\n");
|
||||
if(choix == 'N' || choix == 'n') /* Si le choix et non, annule la supression */
|
||||
{
|
||||
printf("Suppression annulée\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
supprimerVille(tiut, ville, tLog, pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("__________________________________________________________\n");
|
||||
printf("| MENU ADMIN |\n");
|
||||
printf("|--------------------------------------------------------|\n");
|
||||
printf("| 1 Afficher les villes possédant un IUT |\n");
|
||||
printf("| 2 Afficher les départements d'un IUT |\n");
|
||||
printf("| 3 Créer un nouveau département |\n");
|
||||
printf("| 4 Supprimer un département |\n");
|
||||
printf("| 5 Effectuer une mise à jour d'un département d'un IUT |\n");
|
||||
printf("| 6 Insérer un nouvel IUT |\n");
|
||||
printf("| 7 Supprimer un IUT de la liste |\n");
|
||||
printf("| 8 Lancer/Arrêter la phase de candidature |\n");
|
||||
printf("| 9 Quitter |\n");
|
||||
printf("|--------------------------------------------------------|\n\n");
|
||||
printf("Saisie : ");
|
||||
scanf("%d%*c",&select);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void globale(void) /* Permet l'initialisation du tableau, le chargement de celui-ci et l'appel des fonctions login, menus et enregistrement */
|
||||
{
|
||||
int tLog, retour;
|
||||
VilleIUT *tiut[100]; /* Déclaration du tableau de pointeurs tiut */
|
||||
if(tiut == NULL) /* En cas de problème de mémoire, affiche un message d'erreur et quitte le programme */
|
||||
{
|
||||
printf("Problème d'allocation mémoire du tableau tiut\n");
|
||||
exit(1);
|
||||
}
|
||||
tLog = chargement(tiut,100); /* Effectue le chargement du tableau tiut */
|
||||
if(tLog < 0) /* En cas de problème avec le chargement, affiche un message d'erreur et quitte le programme */
|
||||
{
|
||||
printf("Le programme ne peut pas fonctionner\n");
|
||||
exit(1);
|
||||
}
|
||||
retour = login(); /* Appelle la fonction login */
|
||||
while(retour != -1) /* Tant que login ne retourne pas -1, la fonction appelle le menu adaptée en fonction du retour de login puis appelle de nouveau login */
|
||||
{
|
||||
if(retour == 1)
|
||||
{
|
||||
menuAdmin(tiut, &tLog, 100);
|
||||
}
|
||||
if(retour == 0)
|
||||
{
|
||||
menuCandidat(tiut, &tLog, 100);
|
||||
}
|
||||
retour = login();
|
||||
}
|
||||
enregistrement(tiut, tLog);
|
||||
}
|
||||
|
||||
void enregistrement(VilleIUT *tiut[],int tLog) /* Permet l'enregistrement du tableau tiut dans le fichier IUT.don */
|
||||
{
|
||||
int i;
|
||||
FILE *flot;
|
||||
flot = fopen("IUT.don", "w"); /* Ouverture du fichier IUT.don dans la variable flot */
|
||||
if(flot == NULL) /* En cas d'erreur de l'ouverture du fichier, affiche un message d'erreur, ferme le fichier et quitte la fonction */
|
||||
{
|
||||
printf("Erreur de l'enregistrement du fichier\n");
|
||||
fclose(flot);
|
||||
return;
|
||||
}
|
||||
while(i < tLog) /* Boucle allant jusqu'à la dernière ville du tableau */
|
||||
{
|
||||
while(tiut[i]->lDept != NULL) /* Boucle allant jusqu'au dernier département de la ville */
|
||||
{
|
||||
fprintf(flot, "%s\t%s\t%d\t%s\n", tiut[i]->nom, tiut[i]->lDept->d.dept, tiut[i]->lDept->d.nbP, tiut[i]->lDept->d.respAd); /* Écriture dans le fichier */
|
||||
tiut[i]->lDept = tiut[i]->lDept->suiv;
|
||||
}
|
||||
i++; /* Incrémentation de l'indice i pour passer à la ville suivante */
|
||||
}
|
||||
fclose(flot);
|
||||
}
|
||||
@ -1,34 +1,79 @@
|
||||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#include<stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
//################ Types de structures ###############
|
||||
|
||||
typedef struct maillonDept
|
||||
typedef struct
|
||||
{
|
||||
char dept[31];
|
||||
int nbP;
|
||||
char respAd[31];
|
||||
} Departement;
|
||||
|
||||
typedef struct maillonDept
|
||||
{
|
||||
Departement d;
|
||||
struct maillonDept *suiv;
|
||||
|
||||
}MaillonDept,*ListeDept;
|
||||
} MaillonDept,*ListeDept;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char nom[31];
|
||||
ListeDept *lDept;
|
||||
ListeDept lDept;
|
||||
} VilleIUT;
|
||||
|
||||
}VilleIUT;
|
||||
/* Fonctions de Chargement */
|
||||
|
||||
//################ Fonctions communes #################
|
||||
int chargement(VilleIUT *tiut[],int tMax);
|
||||
Departement lireDep(FILE *flot);
|
||||
void enregistrement(VilleIUT *tiut[], int tLog);
|
||||
|
||||
void clearpage(void);
|
||||
/* Fonctions d'affichage */
|
||||
|
||||
void afficherPlace(Departement d);
|
||||
void afficherDep(Departement d);
|
||||
void afficherVille(VilleIUT v);
|
||||
void afficherTIUT(VilleIUT *tiut[], int tLog);
|
||||
void afficherVilleDep(VilleIUT v);
|
||||
void afficheDeptDesIUT(VilleIUT *tiut[], int tLog);
|
||||
|
||||
/* Fonctions de Listes */
|
||||
|
||||
ListeDept listeDeptNouv(void);
|
||||
ListeDept insererEntete(ListeDept lDept,Departement d);
|
||||
ListeDept insererDept(ListeDept lDept, Departement d);
|
||||
ListeDept supprimerEntete(ListeDept lDept);
|
||||
ListeDept supprimerDept(ListeDept lDept, char *dep);
|
||||
bool vide(ListeDept lDept);
|
||||
int longueur(ListeDept lDept);
|
||||
|
||||
/* Fonctions de département */
|
||||
|
||||
void creerDept(VilleIUT *tiut[],int tLog);
|
||||
void retirerDept(VilleIUT *tiut[], int tLog);
|
||||
|
||||
/* Fonctions de gestion du tableau */
|
||||
|
||||
int insererVille(VilleIUT *tiut[], char nomV[],int *tLog, int tMax, int pos);
|
||||
int supprimerVille(VilleIUT *tiut[], char nomV[], int *tLog, int pos);
|
||||
|
||||
/* Fonctions de recherche */
|
||||
|
||||
ListeDept rechercherDept(ListeDept lDept, char dept[], int *trouve);
|
||||
int rechercheIUT(VilleIUT *tiut[], int tLog, char ville[], int *trouve);
|
||||
|
||||
//################ Fonction Menu #####################
|
||||
/* Fonctions de mise à jour */
|
||||
|
||||
void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax);
|
||||
void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax);
|
||||
void miseAJourNomDept(VilleIUT *tiut[], int tLog);
|
||||
void miseAJourResp(VilleIUT *tiut[], int tLog);
|
||||
void miseAJourPlaces(VilleIUT *tiut[], int tLog);
|
||||
|
||||
/* Fonctions de gestion d'affichage, menus et globale */
|
||||
|
||||
int login(void);
|
||||
void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax);
|
||||
void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax);
|
||||
void clearpage(void);
|
||||
void globale(void);
|
||||
@ -1,21 +1,7 @@
|
||||
#include"Ssae.h"
|
||||
|
||||
int main(void){
|
||||
VilleIUT* tab[20];
|
||||
VilleIUT a,b,c;
|
||||
char test[20];
|
||||
int trouve = 0, pos;
|
||||
strcpy(a.nom,"Clermont");
|
||||
strcpy(b.nom,"Lyon");
|
||||
strcpy(c.nom,"Paris");
|
||||
strcpy(test,"Lyon");
|
||||
a.lDept = NULL;
|
||||
b.lDept = NULL;
|
||||
c.lDept = NULL;
|
||||
tab[0] = &a;
|
||||
tab[1] = &b;
|
||||
tab[2] = &c;
|
||||
pos = rechercheIUT(tab,3,test,&trouve);
|
||||
printf("%d %d\n",pos,trouve);
|
||||
int main (void)
|
||||
{
|
||||
globale();
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in new issue