sami.ghebrid
/
SAE_Algo1.02
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Ajout de la fonction supprimerVille, débuggage et test de toutes les fonctions et documentation complète du code

Browse Source
master
Johnny RATTON 2 years ago
parent bf89b1df4d
commit fa58b290f1
4 changed files with 374 additions and 311 deletions
Show Stats Download Patch File Download Diff File

574
Commun.c
Unescape View File

@ -1,81 +1,85 @@
#include "Jsae.h" #include "Commun.h"
ListeDept listeDeptNouv(void) /*********************************************************** Fonctions de listes **************************************************************/
/**********************************************************************************************************************************************/
/**********************************************************************************************************************************************/
ListeDept listeDeptNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
{ {
ListeDept lDept; ListeDept lDept;
lDept = NULL; lDept = NULL;
return lDept; return lDept;
} }
ListeDept insererEntete(ListeDept lDept,Departement d) 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; MaillonDept *m; /* Création d'un pointeur vers une structure MaillonDept */
m = (MaillonDept *)malloc(sizeof(MaillonDept)); m = (MaillonDept *)malloc(sizeof(MaillonDept)); /* Allocation d'un espace mémoire pour le nouveau maillon */
if(m == NULL) if(m == NULL)
{ {
printf("Problème d'allocation mémoire lors de l'insertion\n"); printf("Problème d'allocation mémoire lors de l'insertion\n"); /* Message d'erreur en cas de problème de malloc */
exit(1); exit(1);
} }
m->d = d; m->d = d; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
m->suiv = lDept; m->suiv = lDept;
return m; return m;
} }
ListeDept insererDept(ListeDept lDept, Departement d) 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) if(lDept == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
{ {
return insererEntete(lDept,d); return insererEntete(lDept,d);
} }
if(strcmp(d.dept, lDept->d.dept) < 0) 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); return insererEntete(lDept,d);
} }
if(strcmp(d.dept,lDept->d.dept) == 0) 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"); printf("Département déjà présent dans cet IUT\n");
return lDept; return lDept;
} }
lDept->suiv = insererDept(lDept->suiv,d); 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; return lDept;
} }
ListeDept supprimerEntete(ListeDept 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; ListeDept aux;
if(lDept == NULL) if(lDept == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
{ {
printf("Opération interdite\n"); printf("Opération interdite\n");
exit(1); exit(1);
} }
aux = lDept; aux = lDept; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
lDept = lDept->suiv; lDept = lDept->suiv; /* On supprime le maillon */
free(aux); free(aux); /* On libère l'espace mémoire du maillon supprimer*/
return lDept; return lDept;
} }
ListeDept supprimerDept(ListeDept lDept, char *dep) 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) if(lDept == NULL) /* La liste est vide, on la retourne sans changements */
{ {
return lDept; return lDept;
} }
if(strcmp(dep, lDept->d.dept) < 0) if(strcmp(dep, lDept->d.dept) < 0) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
{ {
return lDept; return lDept;
} }
if(strcmp(dep,lDept->d.dept) == 0) if(strcmp(dep,lDept->d.dept) == 0) /* Le maillon à supprimer est trouvé, on le supprime */
{ {
return supprimerEntete(lDept); return supprimerEntete(lDept);
} }
lDept->suiv = supprimerDept(lDept->suiv,dep); 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; return lDept;
} }
int longueur(ListeDept 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; int compt = 0; /* On déclare un compteur pour compter le nombre de maillons */
while(lDept != NULL) 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; compt = compt + 1;
lDept = lDept->suiv; lDept = lDept->suiv;
@ -83,7 +87,7 @@ int longueur(ListeDept lDept)
return compt; return compt;
} }
bool vide(ListeDept lDept) bool vide(ListeDept lDept) /* Permet de savoir si une liste est vide et retourne un booléen */
{ {
if(lDept == NULL) if(lDept == NULL)
return true; return true;
@ -99,40 +103,229 @@ bool vide(ListeDept lDept)
return l->v; return l->v;
}*/ }*/
ListeDept rechercherDept(ListeDept lDept, char dept[], int *trouve) 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)) 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; *trouve = 0;
return lDept; return lDept;
} }
if(strcmp(dept, lDept->d.dept) < 0) 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; *trouve = 0;
return lDept; return lDept;
} }
if(strcmp(dept,lDept->d.dept) == 0) 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; *trouve = 1;
return lDept; return lDept;
} }
return rechercherDept(lDept->suiv, dept, trouve); 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) 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); printf("\nPour ce département il y a %d places en 1ère année \n\n",d.nbP);
} }
void creerDept(VilleIUT *tiut[],int tLog)
/********************************************************* Fonctions de Chargement ************************************************************/
/**********************************************************************************************************************************************/
/**********************************************************************************************************************************************/
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) /* 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; Departement d;
int pos, trouve; int pos, trouve;
char ville[31]; char ville[31];
printf("Dans quelle ville souhaitez-vous créer un nouveau département ?\nSaisie : "); 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); scanf("%s%*c", ville);
printf("\n"); printf("\n");
pos = rechercheIUT(tiut, tLog, ville, &trouve); 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) while(trouve == 0)
{ {
printf("Cette ville n'existe pas, veuillez re-saisir : "); printf("Cette ville n'existe pas, veuillez re-saisir : ");
@ -140,92 +333,105 @@ void creerDept(VilleIUT *tiut[],int tLog)
printf("\n"); printf("\n");
pos = rechercheIUT(tiut, tLog, ville, &trouve); pos = rechercheIUT(tiut, tLog, ville, &trouve);
} }
printf("Quel est le nom du département à insérer ?\nSaisie : "); printf("Quel est le nom du département à insérer ?\nSaisie : "); /* Demande le nom du département à insérer */
scanf("%s%*c", d.dept); scanf("%s%*c", d.dept);
rechercherDept(tiut[pos]->lDept, d.dept, &trouve); rechercherDept(tiut[pos]->lDept, d.dept, &trouve); /* Vérification que le département n'existe pas déjà */
if(trouve == 1) 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); printf("Erreur, le département %s existe déjà dans cet IUT\n", d.dept);
return; return;
} }
printf("Combien de place y a-t-il pour dans ce département ?\nSaisie : "); 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); scanf("%d%*c", &d.nbP);
printf("\n"); printf("\n");
printf("Quel est le nom du responsable du département ?\nSaisie : "); printf("Quel est le nom du responsable du département ?\nSaisie : ");
fgets(d.respAd, 31, stdin); fgets(d.respAd, 31, stdin);
d.respAd[strlen(d.respAd) - 1] = '\0'; d.respAd[strlen(d.respAd) - 1] = '\0';
afficherDep(d); afficherDep(d); /* On affiche le département qui va être inséré */
printf("pos : %d\n", pos); tiut[pos]->lDept = insererDept(tiut[pos]->lDept, d); /* On insère le département dans la liste de la ville correspondante */
tiut[pos]->lDept = insererDept(tiut[pos]->lDept, d);
afficherVilleDep(*tiut[pos]);
return; return;
} }
void retirerDept(VilleIUT *tiut[], int tLog) 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; int trouve, pos;
char ville[31], dep[31]; char ville[31], dep[31], choix;
printf("Dans quelle ville souhaitez-vous supprimer un département ?\nSaisie : "); 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); scanf("%s%*c", ville);
printf("\n"); printf("\n");
pos = rechercheIUT(tiut, tLog, ville, &trouve); pos = rechercheIUT(tiut, tLog, ville, &trouve); /* On vérifie que la ville existe */
while(trouve == 0) 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 : "); printf("Cette ville n'existe pas, veuillez re-saisir : ");
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
pos = rechercheIUT(tiut, tLog, ville, &trouve); pos = rechercheIUT(tiut, tLog, ville, &trouve);
} }
printf("Quel est le nom du département à supprimer ?\nSaisie : "); printf("Quel est le nom du département à supprimer ?\nSaisie : "); /* Demande le nom du département à supprimer */
scanf("%s%*c", dep); scanf("%s%*c", dep);
rechercherDept(tiut[pos]->lDept, dep, &trouve); rechercherDept(tiut[pos]->lDept, dep, &trouve); /* Vérifie que le département en question existe */
if(trouve == 0) 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); printf("Erreur, le département %s n'existe pas dans cet IUT\n", dep);
return; return;
} }
tiut[pos]->lDept = supprimerDept(tiut[pos]->lDept, dep); 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; return;
} }
int login(void)
/*********************************************** 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; int i = 3;
char id, mdp[31] = "mettez20svp", mdpatrouve[31]; char id, mdp[31] = "mettez20svp", mdpatrouve[31]; /* Déclaration d'un motdepasse administrateur */
system("clear"); system("clear");
printf("\t################################ Bienvenue! ################################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur ? (U/A)\nSaisie : "); printf("\t################################ Bienvenue! ################################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur ? (C/A)\nSaisie : ");
scanf("%c%*c",&id); scanf("%c%*c",&id);
if(id == 'q') if(id == 'q') /* Si l'utilisateur saisie la lettre 'q', le programme s'arrête */
{ {
return -1; return -1;
} }
while(id != 'A' && id != 'a' && id != 'U' && id != 'u') while(id != 'A' && id != 'a' && id != 'C' && id != 'c') /* Effectue une saisie contrôlée si la saisie ne correspond à aucune option */
{ {
system("clear"); system("clear");
printf("\t#################### Mauvaise saisie ('q' pour quitter) ####################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur? (U/A)\nSaisie : "); printf("\t#################### Mauvaise saisie ('q' pour quitter) ####################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur? (C/A)\nSaisie : ");
scanf("%c%*c",&id); scanf("%c%*c",&id);
if(id == 'q') if(id == 'q')
{ {
return -1; return -1;
} }
} }
if(id == 'A' || id == 'a') if(id == 'A' || id == 'a') /* Si l'utilisateur sélectionne administrateur, il doit ensuit taper le mot de passe */
{ {
while(i != 0) while(i != 0)
{ {
printf("\n\nMot de passe : "); printf("\n\nMot de passe : ");
system("stty -echo"); system("stty -echo"); /* On masque la saisie pour saisir le mot de passe */
fgets(mdpatrouve, 31, stdin); fgets(mdpatrouve, 31, stdin);
mdpatrouve[strlen(mdpatrouve) - 1] = '\0'; mdpatrouve[strlen(mdpatrouve) - 1] = '\0';
printf("\n"); printf("\n");
if(strcmp(mdpatrouve, mdp) == 0 ) if(strcmp(mdpatrouve, mdp) == 0 ) /* Si le mot de passe est bon, la fonction retourne 1 */
{ {
system("stty echo"); system("stty echo");
system("clear"); system("clear");
return 1; return 1;
} }
else else /* Si le mot de passe est faux, l'utilisateur dispose de 2 essais supplémentaire */
{ {
i--; i--;
printf("Mot de passe incorrect, il vous reste %d chances\n",i); printf("Mot de passe incorrect, il vous reste %d chances\n",i);
@ -234,7 +440,7 @@ int login(void)
} }
return -1; return -1;
} }
else else /* Si l'utilisateur sélectionne candidat, la fonction retourne 0 */
{ {
system("clear"); system("clear");
return 0; return 0;
@ -242,28 +448,28 @@ int login(void)
} }
void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax) 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 select = 0, pos;
int trouve; int trouve;
char ville[31]; char ville[31], choix;
ListeDept l; ListeDept l;
printf("_______________________________________________________\n"); printf("__________________________________________________________\n");
printf("| MENU ADMIN |\n"); printf("| MENU ADMIN |\n");
printf("|-----------------------------------------------------|\n"); printf("|--------------------------------------------------------|\n");
printf("| 1 Afficher les villes possédant un IUT |\n"); printf("| 1 Afficher les villes possédant un IUT |\n");
printf("| 2 Afficher les départements d'un IUT |\n"); printf("| 2 Afficher les départements d'un IUT |\n");
printf("| 3 Créer un nouveau département |\n"); printf("| 3 Créer un nouveau département |\n");
printf("| 4 Supprimer un département |\n"); printf("| 4 Supprimer un département |\n");
printf("| 5 Modifier le nombre de places dans un département |\n"); printf("| 5 Effectuer une mise à jour d'un département d'un IUT |\n");
printf("| 6 Modifier l'intitulé d'un département |\n"); printf("| 6 Insérer un nouvel IUT |\n");
printf("| 7 Modifer le nom du responsable d'un département |\n"); printf("| 7 Supprimer un IUT de la liste |\n");
printf("| 8 Lancer/Arrêter la phase de candidature |\n"); printf("| 8 Lancer/Arrêter la phase de candidature |\n");
printf("| 9 Quitter |\n"); printf("| 9 Quitter |\n");
printf("|-----------------------------------------------------|\n\n"); printf("|--------------------------------------------------------|\n\n");
printf("Saisie : "); printf("Saisie : "); /* Choix de l'administrateur */
scanf("%d%*c",&select); scanf("%d%*c",&select);
while(select != 9) 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"); system("clear");
if(select == 1) if(select == 1)
@ -272,18 +478,18 @@ void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax)
} }
if(select == 2) if(select == 2)
{ {
printf("Pour quelle ville souhaitez-vous afficher les départements ?\nSaisie : "); printf("Pour quelle ville souhaitez-vous afficher les départements ?\nSaisie : "); /* Demande une ville à afficher */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
pos = rechercheIUT(tiut, *tLog, ville, &trouve); pos = rechercheIUT(tiut, *tLog, ville, &trouve); /* Vérifie que la ville existe */
while(trouve == 0) while(trouve == 0) /* Si elle n'existe pas, on effectue une saisie contrôlée */
{ {
printf("Cette ville n'existe pas, veuillez re-sasisir : "); printf("Cette ville n'existe pas, veuillez re-sasisir : ");
scanf("%s%*c", ville); scanf("%s%*c", ville);
pos = rechercheIUT(tiut, *tLog, ville , &trouve); pos = rechercheIUT(tiut, *tLog, ville , &trouve);
printf("\n"); printf("\n");
} }
afficherVilleDep(*tiut[pos]); afficherVilleDep(*tiut[pos]); /* Affiche ensuite la ville */
} }
if(select == 3) if(select == 3)
{ {
@ -295,35 +501,67 @@ void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax)
} }
/*if(select == 5) /*if(select == 5)
{ {
miseAJourPlaces(tiut, *tLog); miseAJourGlobale(tiut, tLog);
} }*/
if(select == 6) if(select == 6)
{ {
miseAJourNomDept(tiut, *tLog); 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) if(select == 7)
{ {
miseAJourResp(tiut, *tLog); printf("Quel est le nom de la ville à supprimer ?\nSaisie : "); /* Demande le nom de la ville à supprimer */
}*/ scanf("%s%*c", ville);
printf("_______________________________________________________\n"); 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("| MENU ADMIN |\n");
printf("|-----------------------------------------------------|\n"); printf("|--------------------------------------------------------|\n");
printf("| 1 Afficher les villes possédant un IUT |\n"); printf("| 1 Afficher les villes possédant un IUT |\n");
printf("| 2 Afficher les départements d'un IUT |\n"); printf("| 2 Afficher les départements d'un IUT |\n");
printf("| 3 Créer un nouveau département |\n"); printf("| 3 Créer un nouveau département |\n");
printf("| 4 Supprimer un département |\n"); printf("| 4 Supprimer un département |\n");
printf("| 5 Modifier le nombre de places dans un département |\n"); printf("| 5 Effectuer une mise à jour d'un département d'un IUT |\n");
printf("| 6 Modifier l'intitulé d'un département |\n"); printf("| 6 Insérer un nouvel IUT |\n");
printf("| 7 Modifer le nom du responsable d'un département |\n"); printf("| 7 Supprimer un IUT de la liste |\n");
printf("| 8 Lancer/Arrêter la phase de candidature |\n"); printf("| 8 Lancer/Arrêter la phase de candidature |\n");
printf("| 9 Quitter |\n"); printf("| 9 Quitter |\n");
printf("|-----------------------------------------------------|\n\n"); printf("|--------------------------------------------------------|\n\n");
printf("Saisie : "); printf("Saisie : ");
scanf("%d%*c",&select); scanf("%d%*c",&select);
} }
} }
void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax) void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax) /* Affiche un menu adapté pour un candidat et appelle les fonctions nécessaires pour effectuer les actions souhaitées */
{ {
int select = 0; int select = 0;
while(select != 9) while(select != 9)
@ -342,9 +580,7 @@ void menuCandidat(VilleIUT *tiut[], int *tLog, int tMax)
} }
} }
void clearpage(void) /* Permet de demander à l'utilisateur pour continuer à la suite d'une action et efface le contenu affiché à l'écran */
void clearpage(void)
{ {
char entre; char entre;
printf("\nappuyé sur la touche [ENTREE] pour continuer"); printf("\nappuyé sur la touche [ENTREE] pour continuer");
@ -352,164 +588,24 @@ void clearpage(void)
system("clear"); system("clear");
} }
int chargement(VilleIUT *tiut[],int tMax)
{
FILE *flot;
int tLog = 0, pos, trouve;
char nomV[31];
Departement d;
flot = fopen("IUT.don","r");
if(flot == NULL)
{
printf("Erreur lors de l'ouverture du fichier\n");
fclose(flot);
return -1;
}
fscanf(flot, "%s", nomV);
while(!feof(flot))
{
if(tLog == tMax)
{
printf("Tableau tiut plein\n");
fclose(flot);
return -3;
}
d = lireDep(flot);
pos = rechercheIUT(tiut,tLog,nomV,&trouve);
if(trouve == 1)
{
tiut[pos]->lDept = insererDept(tiut[pos]->lDept, d);
}
else
{
insererVille(tiut, nomV, d, &tLog, tMax, pos);
}
fscanf(flot, "%s", nomV);
}
fclose(flot);
return tLog;
}
Departement lireDep(FILE *flot)
{
Departement d;
fscanf(flot,"%s%d", d.dept, &d.nbP);
fgets(d.respAd,31,flot);
d.respAd[strlen(d.respAd) - 1] = '\0';
return d;
}
int insererVille(VilleIUT *tiut[], char nomV[], Departement d, int *tLog, int tMax, int pos) void globale(void) /* Permet l'initialisation du tableau, le chargement de celui-ci et l'appel des fonctions login, menus et enregistrement */
{
int i;
if(*tLog == tMax)
{
printf("Tableau plein, insertion impossible\n");
return -1;
}
for(i = *tLog - 1; i >= pos; i--)
tiut[i + 1] = tiut[i];
tiut[pos] = (VilleIUT *)malloc(sizeof(VilleIUT));
if(tiut[pos] == NULL)
{
printf("problème d'allocation mémoire lors de l'insertion de la ville\n");
return -1;
}
strcpy(tiut[pos]->nom, nomV);
tiut[pos]->lDept = listeDeptNouv();
tiut[pos]->lDept = insererDept(tiut[pos]->lDept,d);
*tLog = *tLog + 1;
return 0;
}
void afficherDep(Departement d)
{
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)
{
printf("|----------------------------------|\n");
printf("| %-32s |\n", v.nom);
printf("|----------------------------------|\n");
}
void afficherTIUT(VilleIUT *tiut[], int tLog)
{
int i = 0;
printf("____________________________________\n");
printf("| Ville |\n");
for(i = 0; i < tLog; i++)
{
afficherVille(*tiut[i]);
}
printf("\n");
}
void afficherVilleDep(VilleIUT v)
{
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;
}
}
int rechercheIUT(VilleIUT *tiut[], int tLog, char ville[], int *trouve)
{
int inf,sup,t;
inf = 0;
sup = tLog - 1;
printf("Ville recherchée : %s\n", ville);
while(inf <= sup)
{
t = (inf + sup) / 2;
if(strcmp(ville, tiut[t]->nom) == 0)
{
*trouve = 1;
return t;
}
if(strcmp(ville, tiut[t]->nom) < 0)
{
sup = t - 1;
}
else
{
inf = t + 1;
}
}
*trouve = 0;
return inf;
}
void globale(void)
{ {
int tLog, retour; int tLog, retour;
VilleIUT *tiut[100]; VilleIUT *tiut[100]; /* Déclaration du tableau de pointeurs tiut */
if(tiut == NULL) 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"); printf("Problème d'allocation mémoire du tableau tiut\n");
exit(1); exit(1);
} }
tLog = chargement(tiut,100); tLog = chargement(tiut,100); /* Effectue le chargement du tableau tiut */
if(tLog < 0) 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"); printf("Le programme ne peut pas fonctionner\n");
exit(1); exit(1);
} }
retour = login(); retour = login(); /* Appelle la fonction login */
while(retour != -1) 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) if(retour == 1)
{ {

7
Commun.h
Unescape View File

@ -42,18 +42,19 @@ ListeDept listeDeptNouv(void);
ListeDept insererEntete(ListeDept lDept,Departement d); ListeDept insererEntete(ListeDept lDept,Departement d);
ListeDept insererDept(ListeDept lDept, Departement d); ListeDept insererDept(ListeDept lDept, Departement d);
ListeDept supprimerEntete(ListeDept lDept); ListeDept supprimerEntete(ListeDept lDept);
ListeDept supprimerDept(ListeDept lDept, Departement d); ListeDept supprimerDept(ListeDept lDept, char *dep);
bool vide(ListeDept lDept); bool vide(ListeDept lDept);
int longueur(ListeDept lDept); int longueur(ListeDept lDept);
/* Fonctions de département */ /* Fonctions de département */
void creerDept(VilleIUT *tiut[],int tLog); void creerDept(VilleIUT *tiut[],int tLog);
void retirerDept(VilleIUT *tiut[], int *tLog); void retirerDept(VilleIUT *tiut[], int tLog);
/* Fonctions de gestion du tableau */ /* Fonctions de gestion du tableau */
int insererVille(VilleIUT *tiut[], char nomV[], Departement d, int *tLog, int tMax, int pos); 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 */ /* Fonctions de recherche */

67
Jsae.c
Unescape View File

@ -24,12 +24,18 @@ ListeDept insererEntete(ListeDept lDept,Departement d)
ListeDept insererDept(ListeDept lDept, Departement d) ListeDept insererDept(ListeDept lDept, Departement d)
{ {
if(lDept == NULL) if(lDept == NULL)
{
return insererEntete(lDept,d); return insererEntete(lDept,d);
}
if(strcmp(d.dept, lDept->d.dept) < 0) if(strcmp(d.dept, lDept->d.dept) < 0)
{
return insererEntete(lDept,d); return insererEntete(lDept,d);
}
if(strcmp(d.dept,lDept->d.dept) == 0) if(strcmp(d.dept,lDept->d.dept) == 0)
{
printf("Département déjà présent dans cet IUT\n"); printf("Département déjà présent dans cet IUT\n");
return lDept; return lDept;
}
lDept->suiv = insererDept(lDept->suiv,d); lDept->suiv = insererDept(lDept->suiv,d);
return lDept; return lDept;
} }
@ -51,11 +57,17 @@ ListeDept supprimerEntete(ListeDept lDept)
ListeDept supprimerDept(ListeDept lDept, char *dep) ListeDept supprimerDept(ListeDept lDept, char *dep)
{ {
if(lDept == NULL) if(lDept == NULL)
{
return lDept; return lDept;
}
if(strcmp(dep, lDept->d.dept) < 0) if(strcmp(dep, lDept->d.dept) < 0)
{
return lDept; return lDept;
}
if(strcmp(dep,lDept->d.dept) == 0) if(strcmp(dep,lDept->d.dept) == 0)
{
return supprimerEntete(lDept); return supprimerEntete(lDept);
}
lDept->suiv = supprimerDept(lDept->suiv,dep); lDept->suiv = supprimerDept(lDept->suiv,dep);
return lDept; return lDept;
} }
@ -96,7 +108,7 @@ ListeDept rechercherDept(ListeDept lDept, char dept[], int *trouve)
} }
if(strcmp(dept, lDept->d.dept) < 0) if(strcmp(dept, lDept->d.dept) < 0)
{ {
trouve = 0; *trouve = 0;
return lDept; return lDept;
} }
if(strcmp(dept,lDept->d.dept) == 0) if(strcmp(dept,lDept->d.dept) == 0)
@ -107,54 +119,6 @@ ListeDept rechercherDept(ListeDept lDept, char dept[], int *trouve)
return rechercherDept(lDept->suiv, dept, trouve); return rechercherDept(lDept->suiv, dept, trouve);
} }
void miseAJourPlaces(VilleIUT *tiut[], int tLog)
{
int trouve, pos, places;
char ville[31], dept[31], choix;
ListeDept l;
printf("Dans quelle ville se situe le département concerné ?\nSaisie : ");
scanf("%s%*c", ville);
printf("\n");
pos = rechercheIUT(tiut, tLog, ville, &trouve);
while(trouve == 0)
{
printf("Cette ville n'existe pas, veuillez re-saisir : ");
scanf("%s%*c", ville);
printf("\n");
pos = rechercheIUT(tiut, tLog, ville, &trouve);
}
l = tiut[pos]->lDept;
printf("Quel département souhaitez-vous mettre à jour ?\nSaisie : ");
scanf("%s%*c", dept);
printf("\n");
l = rechercherDept(l, dept, &trouve);
while(trouve == 0)
{
printf("Ce département n'existe pas, veuillez-resaisir : ");
scanf("%s%*c", dept);
printf("\n");
l = rechercherDept(l, dept, &trouve);
}
printf("Vous avez sélectionné le département %s dans la ville de %s.\nSouhaitez-vous continuez ? (O/N)\nSaisie : ", dept, ville);
scanf("%c%*c", &choix);
printf("\n");
if(choix == 'N')
{
return;
}
printf("Il y a actuellement %d places.\nQuel est le nouveau nombre de places ?\nSaisie : ", l->d.nbP);
scanf("%d%*c", &places);
printf("\nVous avez saisie %d places, veuillez confirmez (O/N)\nSaisie : ", places);
scanf("%c%*c", &choix);
printf("\n");
if(choix == 'O')
{
l->d.nbP = places;
printf("La mise à jour a bien été effectuée.\n");
}
return;
}
void afficherPlace(Departement d) void afficherPlace(Departement d)
{ {
printf("\nPour ce département il y a %d places en 1ère année \n\n",d.nbP); printf("\nPour ce département il y a %d places en 1ère année \n\n",d.nbP);
@ -329,11 +293,11 @@ void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax)
{ {
retirerDept(tiut, *tLog); retirerDept(tiut, *tLog);
} }
if(select == 5) /*if(select == 5)
{ {
miseAJourPlaces(tiut, *tLog); miseAJourPlaces(tiut, *tLog);
} }
/*if(select == 6) if(select == 6)
{ {
miseAJourNomDept(tiut, *tLog); miseAJourNomDept(tiut, *tLog);
} }
@ -506,6 +470,7 @@ int rechercheIUT(VilleIUT *tiut[], int tLog, char ville[], int *trouve)
int inf,sup,t; int inf,sup,t;
inf = 0; inf = 0;
sup = tLog - 1; sup = tLog - 1;
printf("Ville recherchée : %s\n", ville);
while(inf <= sup) while(inf <= sup)
{ {
t = (inf + sup) / 2; t = (inf + sup) / 2;

5
Jsae.h
Unescape View File

@ -49,11 +49,12 @@ int longueur(ListeDept lDept);
/* Fonctions de département */ /* Fonctions de département */
void creerDept(VilleIUT *tiut[],int tLog); void creerDept(VilleIUT *tiut[],int tLog);
void retirerDept(VilleIUT *tiut[], int *tLog); void retirerDept(VilleIUT *tiut[], int tLog);
/* Fonctions de gestion du tableau */ /* Fonctions de gestion du tableau */
int insererVille(VilleIUT *tiut[], char nomV[], Departement d, int *tLog, int tMax, int pos); 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 */ /* Fonctions de recherche */

Write Preview
Loading…
Cancel
Save