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

Documentation complète de la partie 2

Browse Source
master
Johnny RATTON 2 years ago
parent 5e22520d90
commit e2faad7e78
2 changed files with 184 additions and 190 deletions
Show Stats Download Patch File Download Diff File

188
Commun.c
Unescape View File

@ -853,16 +853,14 @@ void enregistrement(VilleIUT *tiut[],int tLog) /* Permet l'enregistrement du tab
// ########################################################################################### // ###########################################################################################
// ########################################################################################### // ###########################################################################################
#include "J2sae.h"
/************************************** Fonctions de Chargement ********************************************/ /************************************** Fonctions de Chargement ********************************************/
/****************************************** Et de sauvegarde*************************************************/ /****************************************** Et de sauvegarde*************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
Candidat ** chargementCandidats(int *tMax) Candidat ** chargementCandidats(int *tMax) /* Permet de charger le contenu du fichier Candidats.don dans un tableau de pointeur vers */
{ { /* des structures Candidats qui contiennent un tableau de pointeurs vers des structures choix*/
FILE *flot; FILE *flot; /* La fonction renvoie ensuite le tableau de Candidats si tout se passe bien */
Candidat **tCand, *c; Candidat **tCand, *c; /* Déclaration du tableau de candidats et d'une variable de chargement */
int i; int i;
flot = fopen("Candidats.don", "r"); flot = fopen("Candidats.don", "r");
if(flot == NULL) if(flot == NULL)
@ -871,52 +869,51 @@ Candidat ** chargementCandidats(int *tMax)
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
fscanf(flot, "%d", tMax); fscanf(flot, "%d", tMax); /* Lecture du nombre de candidats pour déterminer la taille physique du tableau */
printf("tMax : %d\n", *tMax); printf("tMax : %d\n", *tMax);
tCand = (Candidat **)malloc(sizeof(Candidat *) * (*tMax)); tCand = (Candidat **)malloc(sizeof(Candidat *) * (*tMax)); /* Allocation dynamique du tableau de candidats*/
printf("Allocation du tableau\n");
if(tCand == NULL) if(tCand == NULL)
{ {
printf("Erreur d'allocation mémoire tableau candidat\n"); printf("Erreur d'allocation mémoire tableau candidat\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
for(i = 0; i < *tMax; i++) for(i = 0; i < *tMax; i++) /* Remplissage du tableau */
{ {
c = lireCandidat(flot); c = lireCandidat(flot); /* Lecture d'un candidat */
tCand[i] = c; tCand[i] = c; /* Insertion du candidat lu dans le tableau */
} }
fclose(flot); fclose(flot);
return tCand; return tCand;
} }
Candidat * lireCandidat(FILE *flot) Candidat * lireCandidat(FILE *flot) /* Fonction permettant de lire un candidat dans un fichier et renvoyant un pointeur vers la structure candidat lue */
{ {
Candidat *c; Candidat *c; /* Déclaration d'un pointeur vers un candidat pour la lecture et l'allocation dynamique d'un candidat */
Choix choix; Choix choix; /* Déclaration d'une variable de type Choix pour la lecture des choix du candidat */
int i = 0; int i = 0;
c = (Candidat *)malloc(sizeof(Candidat)); c = (Candidat *)malloc(sizeof(Candidat)); /* Allocation dynamique du candidat */
if(c == NULL) if(c == NULL)
{ {
printf("Erreur d'allocation mémoire candidat\n"); printf("Erreur d'allocation mémoire candidat\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
fscanf(flot, "%d%*c", &c->numeroC); fscanf(flot, "%d%*c", &c->numeroC); /* Lectures des informations du candidat (numero, nom, prenom, notes, nombre de choix)*/
fgets(c->nom, 31, flot); fgets(c->nom, 31, flot);
c->nom[strlen(c->nom) - 1] = '\0'; c->nom[strlen(c->nom) - 1] = '\0';
fgets(c->prenom, 31, flot); fgets(c->prenom, 31, flot);
c->prenom[strlen(c->prenom) - 1] = '\0'; c->prenom[strlen(c->prenom) - 1] = '\0';
fscanf(flot, "%f%f%f%f%*c", &c->notes[0], &c->notes[1], &c->notes[2], &c->notes[3]); fscanf(flot, "%f%f%f%f%*c", &c->notes[0], &c->notes[1], &c->notes[2], &c->notes[3]);
fscanf(flot, "%d%*c", &c->nombreChoix); fscanf(flot, "%d%*c", &c->nombreChoix);
c->tChoix = (Choix **)malloc(sizeof(Choix *) * c->nombreChoix); c->tChoix = (Choix **)malloc(sizeof(Choix *) * c->nombreChoix); /* Allocation dynamique du tableau de pointeurs vers des structures Choix*/
if(c->tChoix == NULL) if(c->tChoix == NULL) /* pour le chargement des choix du candidats */
{ {
printf("Erreur lors de l'allocation mémoire du tableau de choix\n"); printf("Erreur lors de l'allocation mémoire du tableau de choix\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
while(i < c->nombreChoix) while(i < c->nombreChoix) /* Lecture des choix du candidats et placements de ceux-ci dans le tableau tChoix */
{ {
c->tChoix[i] = lireChoix(flot); c->tChoix[i] = lireChoix(flot);
i = i + 1; i = i + 1;
@ -924,16 +921,16 @@ Candidat * lireCandidat(FILE *flot)
return c; return c;
} }
Choix * lireChoix(FILE *flot) Choix * lireChoix(FILE *flot) /* Fonction permettant de lire le Choix d'un candidat dans un fichier et renvoyant un pointeur vers la structure choix*/
{ { /* Du choix qui a été lu */
Choix *c; Choix *c; /* Déclaration d'un pointeur vers une variable de type choix pour la lecture */
c = (Choix *)malloc(sizeof(Choix)); c = (Choix *)malloc(sizeof(Choix)); /* Allocation dynamique de la structure choix */
if(c == NULL) if(c == NULL)
{ {
printf("Erreur d'allocation mémoire choix\n"); printf("Erreur d'allocation mémoire choix\n");
exit(1); exit(1);
} }
fgets(c->ville, 31, flot); fgets(c->ville, 31, flot); /* Lectures des différentes informations relatives au choix */
c->ville[strlen(c->ville) - 1] = '\0'; c->ville[strlen(c->ville) - 1] = '\0';
fgets(c->dep, 31, flot); fgets(c->dep, 31, flot);
c->dep[strlen(c->dep) - 1] = '\0'; c->dep[strlen(c->dep) - 1] = '\0';
@ -941,22 +938,22 @@ Choix * lireChoix(FILE *flot)
return c; return c;
} }
void sauvegarder(Candidat *tCand[], int tMax) void sauvegarder(Candidat *tCand[], int tMax) /* Fonctions permettant de sauvegarder l'ensemble des candidats et de leur choix dans un fichier */
{ { /* CandidatsSauv.don */
FILE *flot; FILE *flot;
int i, j; int i, j;
flot = fopen("CandidatsSauv.don", "w"); flot = fopen("CandidatsSauv.don", "w"); /* Ouverture du fichier */
if(flot == NULL) if(flot == NULL)
{ {
printf("Erreur de l'ouverture du fichier lors de l'enregistrement\n"); printf("Erreur de l'ouverture du fichier lors de l'enregistrement\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
fprintf(flot, "%d\n", tMax); fprintf(flot, "%d\n", tMax); /* Ecriture su nombre de candidats */
for(i = 0; i < tMax; i++) for(i = 0; i < tMax; i++) /* Ecriture de chaque candidat*/
{ {
fprintf(flot, "%d\n%s\n%s\n%d\n", tCand[i]->numeroC, tCand[i]->nom, tCand[i]->prenom, tCand[i]->nombreChoix); fprintf(flot, "%d\n%s\n%s\n%d\n", tCand[i]->numeroC, tCand[i]->nom, tCand[i]->prenom, tCand[i]->nombreChoix);
for(j = 0; j < tCand[i]->nombreChoix; j++) for(j = 0; j < tCand[i]->nombreChoix; j++) /* Ecriture de chaque choix du candidat */
{ {
fprintf(flot, "%s\n%s\n%d\n%d\n", tCand[i]->tChoix[j]->ville, tCand[i]->tChoix[j]->dep, tCand[i]->tChoix[j]->decisionResp, tCand[i]->tChoix[j]->decisionCand); fprintf(flot, "%s\n%s\n%d\n%d\n", tCand[i]->tChoix[j]->ville, tCand[i]->tChoix[j]->dep, tCand[i]->tChoix[j]->decisionResp, tCand[i]->tChoix[j]->decisionCand);
} }
@ -970,21 +967,21 @@ void sauvegarder(Candidat *tCand[], int tMax)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
void afficherChoix(Choix *c) void afficherChoix(Choix *c) /* Fonction permettant d'afficher les informations d'un choix donné en paramètre */
{ {
printf("|_______________________________________________________________________________|\n"); printf("|_______________________________________________________________________________|\n");
printf("| %-32s | %-32s | %2d | %2d |\n", c->ville, c->dep, c->decisionResp, c->decisionCand); printf("| %-32s | %-32s | %2d | %2d |\n", c->ville, c->dep, c->decisionResp, c->decisionCand);
printf("|-------------------------------------------------------------------------------|\n"); printf("|-------------------------------------------------------------------------------|\n");
} }
void afficherCandidat(Candidat *c) void afficherCandidat(Candidat *c) /* Fonction permettant d'afficher les informations d'un candidat donné en paramètre */
{ {
printf("|------------------------------------------------------------------------------------------------------------|\n"); printf("|------------------------------------------------------------------------------------------------------------|\n");
printf("| %-4d | %-32s | %-32s | %2.2f | %2.2f | %2.2f | %2.2f |\n", c->numeroC, c->nom, c->prenom, c->notes[0], c->notes[1], c->notes[2], c->notes[3]); printf("| %-4d | %-32s | %-32s | %2.2f | %2.2f | %2.2f | %2.2f |\n", c->numeroC, c->nom, c->prenom, c->notes[0], c->notes[1], c->notes[2], c->notes[3]);
printf("|------------------------------------------------------------------------------------------------------------|\n"); printf("|------------------------------------------------------------------------------------------------------------|\n");
} }
void afficherCandChoix(Candidat *tCand[],int tMax) void afficherCandChoix(Candidat *tCand[],int tMax) /* Fonction permettant d'afficher tous les candidats du tableau tCand ainsi que tous leurs choix */
{ {
int i, j; int i, j;
for(i = 0; i < tMax; i++) for(i = 0; i < tMax; i++)
@ -1002,7 +999,7 @@ void afficherCandChoix(Candidat *tCand[],int tMax)
} }
} }
void afficherCandDep(Candidat *tCand[], int tMax) void afficherCandDep(Candidat *tCand[], int tMax) /* Fonction permettant d'afficher tous les candidats ayant fait une demande pour un département */
{ {
int i, j; int i, j;
char ville[31], dep[31]; char ville[31], dep[31];
@ -1029,7 +1026,7 @@ void afficherCandDep(Candidat *tCand[], int tMax)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
Candidat ** reallocationCand(Candidat *tCand[], int tMax) Candidat ** reallocationCand(Candidat *tCand[], int tMax) /* Fonction permettant de re-allouer le tableau des candidats en ajoutant 1 à sa taile physique */
{ {
Candidat **aux; Candidat **aux;
aux = (Candidat **)realloc(tCand, sizeof(Candidat *) * (tMax + 1)); aux = (Candidat **)realloc(tCand, sizeof(Candidat *) * (tMax + 1));
@ -1040,7 +1037,7 @@ Candidat ** reallocationCand(Candidat *tCand[], int tMax)
return aux; return aux;
} }
Choix ** reallocationChoix(Choix *tChoix[], int nbChoix) Choix ** reallocationChoix(Choix *tChoix[], int nbChoix) /* Fonction permettant de re-allouer un tableau de choix en ajoutant 1 à sa taille physique */
{ {
Choix **aux; Choix **aux;
nbChoix = nbChoix + 1; nbChoix = nbChoix + 1;
@ -1057,19 +1054,19 @@ Choix ** reallocationChoix(Choix *tChoix[], int nbChoix)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
void triCandidats(Candidat *tCand[], int tMax) void triCandidats(Candidat *tCand[], int tMax) /* Fonction permettant de trier un tableau de candidats en effectuant un tri par échange */
{ {
int maxi; int maxi;
while(tMax > 1) while(tMax > 1)
{ {
maxi = plusGrandCand(tCand, tMax); maxi = plusGrandCand(tCand, tMax); /* Appel de la fonction plusGrand pour déterminer le plus grand élément du tableau */
echangerCand(tCand, maxi, tMax - 1); echangerCand(tCand, maxi, tMax - 1); /* Appel de la fonction échange pour placer le plus grnad élément du tableau en dernière position */
tMax = tMax - 1; tMax = tMax - 1;
} }
} }
int plusGrandCand(Candidat *tCand[], int tMax) int plusGrandCand(Candidat *tCand[], int tMax) /* Fonction permettant de trouver le plus grand élément du tableau candidat en le parcourant et en*/
{ { /* comparant ses éléments. Elle renvoie ensuite l'indice du plus grand élément */
int maxi = 0, i; int maxi = 0, i;
for(i = 1; i < tMax; i++) for(i = 1; i < tMax; i++)
{ {
@ -1081,7 +1078,7 @@ int plusGrandCand(Candidat *tCand[], int tMax)
return maxi; return maxi;
} }
void echangerCand(Candidat *tCand[], int i, int j) void echangerCand(Candidat *tCand[], int i, int j) /* Fonction permettant d'échanger deux éléments dans un tableau de candidats*/
{ {
printf("Echange\n"); printf("Echange\n");
Candidat *aux; Candidat *aux;
@ -1090,7 +1087,7 @@ void echangerCand(Candidat *tCand[], int i, int j)
tCand[j] = aux; tCand[j] = aux;
} }
void triChoix(Choix *tChoix[], int nombreChoix) void triChoix(Choix *tChoix[], int nombreChoix) /* Fonction de tri par échange permettant de trier un tableau de Choix */
{ {
int maxi; int maxi;
while(nombreChoix > 1) while(nombreChoix > 1)
@ -1101,7 +1098,7 @@ void triChoix(Choix *tChoix[], int nombreChoix)
} }
} }
int plusGrandChoix(Choix *tChoix[], int nombreChoix) int plusGrandChoix(Choix *tChoix[], int nombreChoix) /* Fontcion permettant de trouver le plus grand élément d'un tableau de choix et de renvoyer son indice */
{ {
int maxi = 0, i; int maxi = 0, i;
for(i = 1; i < nombreChoix; i++) for(i = 1; i < nombreChoix; i++)
@ -1121,7 +1118,7 @@ int plusGrandChoix(Choix *tChoix[], int nombreChoix)
return maxi; return maxi;
} }
void echangerChoix(Choix *tChoix[], int i, int j) void echangerChoix(Choix *tChoix[], int i, int j) /* Fonction permettant d'échanger deux éléments d'un tableau de choix */
{ {
Choix *aux; Choix *aux;
aux = tChoix[i]; aux = tChoix[i];
@ -1134,103 +1131,101 @@ void echangerChoix(Choix *tChoix[], int i, int j)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
Choix ** insererChoix(Choix *tChoix[], int *nombreChoix) Choix ** insererChoix(Choix *tChoix[], int *nombreChoix) /* Fonction permettant d'ajouter un nouveau choix dans un tableau de choix et retournant le tableau*/
{ {
int pos, trouve, i; int pos, trouve, i;
char ville[31], dep[31]; char ville[31], dep[31];
Choix *c; Choix *c;
printf("Dans quelle ville se trouve la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); printf("Dans quelle ville se trouve la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); /* Demande à l'utilisateur la ville dans laquelle insérer */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
printf("Quelle est le nom de la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); printf("Quelle est le nom de la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); /* Demande le département dans la ville */
scanf("%s%*c", dep); scanf("%s%*c", dep);
printf("\n"); printf("\n");
pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); /* Vérifie que le choix ne figure pas déjà dans le tableau de choix */
if(trouve == 1) if(trouve == 1)
{ {
printf("Erreur, ce choix figure déjà dans votre liste\n"); printf("Erreur, ce choix figure déjà dans votre liste\n");
return tChoix; return tChoix;
} }
c = (Choix *)malloc(sizeof(Choix)); c = (Choix *)malloc(sizeof(Choix)); /* Allocation dynamique du choix à insérer */
if(c == NULL) if(c == NULL)
{ {
printf("Erreur d'allocation mémoire lors de l'insertion du choix\n"); printf("Erreur d'allocation mémoire lors de l'insertion du choix\n");
return tChoix; return tChoix;
} }
strcpy(c->ville, ville); strcpy(c->ville, ville); /* Ajout des valeurs dans le choix à insérer */
strcpy(c->dep, dep); strcpy(c->dep, dep);
c->decisionResp = 0; c->decisionResp = 0; /* Par défaut, les décisions du candidat et du responsable sont initialisées à 0*/
c->decisionCand = 0; c->decisionCand = 0;
tChoix = reallocationChoix(tChoix, *nombreChoix); tChoix = reallocationChoix(tChoix, *nombreChoix); /* Réallocation du tableau de choix pour ajouter une place */
for(i = *nombreChoix; i > pos; i--) for(i = *nombreChoix; i > pos; i--) /* Décalage à droite des éléments du tableau à partir de la position d'insertion */
{ {
tChoix[i] = tChoix[i - 1]; tChoix[i] = tChoix[i - 1];
} }
tChoix[pos] = c; tChoix[pos] = c; /* Ajout du choix dans le tableau */
*nombreChoix = *nombreChoix + 1; *nombreChoix = *nombreChoix + 1; /* Mise à jour de la taille physique du tableau */
return tChoix; return tChoix;
} }
Choix ** supprimerChoix(Choix *tChoix[], int *nombreChoix) Choix ** supprimerChoix(Choix *tChoix[], int *nombreChoix) /* Fonction permettant de supprimer un choix d'un tableau de choix */
{ {
Choix **aux, *temp; Choix **aux; /* Déclaration d'une variable aux prenant la valeur du tableau */
int i, pos, trouve; int i, pos, trouve;
char ville[31], dep[31], saisie; char ville[31], dep[31], saisie;
printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande au candidat dans quelle ville supprimer le choix */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande au candidat dans quel département de la ville */
scanf("%s%*c", dep); scanf("%s%*c", dep);
printf("\n"); printf("\n");
pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); /* Vérification que le choix indiqué figure bien dan le tableau des choix */
if(trouve == 0) if(trouve == 0)
{ {
printf("Erreur, ce choix ne figure pas dans votre liste\n"); printf("Erreur, ce choix ne figure pas dans votre liste\n");
return tChoix; return tChoix;
} }
printf("Êtes-vous sur de vouloir supprimer ce choix ? (O/n)\nSaisie : "); printf("Êtes-vous sur de vouloir supprimer ce choix ? (O/n)\nSaisie : "); /* Demande de confirmation de la supression */
scanf("%c%*c", &saisie); scanf("%c%*c", &saisie);
printf("\n"); printf("\n");
if(saisie == 'n' || saisie == 'N') if(saisie == 'n' || saisie == 'N') /* Si non, retourne le tableau sans le changer */
{ {
return tChoix; return tChoix;
} }
temp = tChoix[pos]; for(i = pos; i < *nombreChoix - 1; i++) /* Décalage à gauche des éléments du tableau à partir du dernier jusqu'au choix à supprimer */
for(i = pos; i < *nombreChoix - 1; i++)
{ {
tChoix[i] = tChoix[i + 1]; tChoix[i] = tChoix[i + 1];
} }
*nombreChoix = *nombreChoix - 1; *nombreChoix = *nombreChoix - 1; /* Mise à jour de la taille physique du tableau */
aux = (Choix **)realloc(tChoix, *nombreChoix * sizeof(Choix *)); aux = (Choix **)realloc(tChoix, *nombreChoix * sizeof(Choix *)); /* Réallocation du tableau en enlevant une place à la fin */
if(aux == NULL) if(aux == NULL)
{ {
printf("Problème avec la réallocation lors de la suppression\n"); printf("Problème avec la réallocation lors de la suppression\n");
return tChoix; return tChoix;
} }
free(temp);
return aux; return aux;
} }
void miseAJourChoixCand(Choix *tChoix[], int nombreChoix) void miseAJourChoixCand(Choix *tChoix[], int nombreChoix) /* Fontcion permettant de mettre à jour la décision d'un candidat concernant un de ses choix */
{ {
int pos, trouve, saisie; int pos, trouve, saisie;
char ville[31], dep[31]; char ville[31], dep[31];
printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande au candidat la ville concernée par le choix */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande le département dans la ville en question */
scanf("%s%*c", dep); scanf("%s%*c", dep);
printf("\n"); printf("\n");
pos = rechercherChoix(tChoix, nombreChoix, ville, dep, &trouve); pos = rechercherChoix(tChoix, nombreChoix, ville, dep, &trouve); /* Vérifie que ce choix existe bien dans le tableau choix du candidat */
if(trouve == 0) if(trouve == 0)
{ {
printf("Erreur, ce choix ne figure pas dans votre liste\n"); printf("Erreur, ce choix ne figure pas dans votre liste\n");
return; return;
} }
system("clear"); system("clear");
if(tChoix[pos]->decisionCand == -1) if(tChoix[pos]->decisionCand == -1) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
{ {
printf("Vous avez actuellement refusé la proposition d'admission de l'établissement\n\n"); printf("Vous avez actuellement refusé la proposition d'admission de l'établissement\n\n");
printf("|---------------------------------------|\n"); printf("|---------------------------------------|\n");
printf("| Que souhaitez-vous faire ? |\n"); printf("| Que souhaitez-vous faire ? |\n");
@ -1319,12 +1314,12 @@ void miseAJourChoixCand(Choix *tChoix[], int nombreChoix)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
int rechercherChoix(Choix *tChoix[], int nombreChoix, char ville[], char dep[], int *trouve) int rechercherChoix(Choix *tChoix[], int nombreChoix, char ville[], char dep[], int *trouve) /* Permet d'effectuer une recherche dichotomique dans un tableau*/
{ { /* de choix en comparant les villes et départements */
int inf = 0, sup = nombreChoix - 1, m; int inf = 0, sup = nombreChoix - 1, m; /* Si le choix et trouvé, la fonction donne la valeur 1 à la*/
while(inf <= sup) while(inf <= sup) /* variable trouve passée par pointeur et renvoie sa position*/
{ { /* Si il n'est pas trouvé, la fonction renvoie sa position */
m = (inf + sup) / 2; m = (inf + sup) / 2; /* d'insertion et met trouve à 0 */
if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) == 0) if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) == 0)
{ {
*trouve = 1; *trouve = 1;
@ -1352,9 +1347,9 @@ int rechercherChoix(Choix *tChoix[], int nombreChoix, char ville[], char dep[],
} }
int rechercherCandidat(Candidat *tCand[], int tMax, int numeroC, int *trouve) int rechercherCandidat(Candidat *tCand[], int tMax, int numeroC, int *trouve) /* Permet d'effectuer une recherche dichotomique dans un tableau de candidats*/
{ { /* en comparants les numéros de candidats. Même principe que pour la fonction*/
int inf = 0, sup = tMax - 1, m; int inf = 0, sup = tMax - 1, m; /* de recherche de choix */
while(inf <= sup) while(inf <= sup)
{ {
m = (inf + sup) / 2; m = (inf + sup) / 2;
@ -1382,29 +1377,28 @@ int rechercherCandidat(Candidat *tCand[], int tMax, int numeroC, int *trouve)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
void globale2(void) void globale(void) /* Permet de gérer l'exécution du programme */
{ {
int tMax, pos, trouve, i; int tMax, pos, trouve, i;
Candidat **tCand, c; Candidat **tCand, c; /* Initialisation du tableau de candidats */
tCand = chargementCandidats(&tMax); tCand = chargementCandidats(&tMax); /* Remplissage du tableau par chargement */
sauvegarder(tCand, tMax); triCandidats(tCand, tMax); /* Tri du tableau */
triCandidats(tCand, tMax); for(i = 0; i < tMax; i++) /* Tri du tableau choix pour chaque candidat */
afficherCandChoix(tCand, tMax);
for(i = 0; i < tMax; i++)
{ {
triChoix(tCand[i]->tChoix, tCand[i]->nombreChoix); triChoix(tCand[i]->tChoix, tCand[i]->nombreChoix);
} }
menuCandidat2(tCand, tMax); menuCandidat(tCand, tMax); /* Appel du menu adapté au candidat */
sauvegarder(tCand, tMax); /* Sauvegarde du tableau de candidats */
} }
void menuCandidat2(Candidat *tCand[], int tMax) void menuCandidat(Candidat *tCand[], int tMax) /* Fonction affichant un menu adapté pour un candidat */
{ {
int pos,trouve, saisie, i, numeroC; int pos,trouve, saisie, i, numeroC;
system("clear"); system("clear");
printf("Quel est votre numéro de candidat ?\nSaisie : "); printf("Quel est votre numéro de candidat ?\nSaisie : "); /* Demande le numéro de candidat pour qu'il ne puisse accéder qu'à ses informations */
scanf("%d%*c", &numeroC); scanf("%d%*c", &numeroC);
printf("\n"); printf("\n");
pos = rechercherCandidat(tCand, tMax, numeroC, &trouve); pos = rechercherCandidat(tCand, tMax, numeroC, &trouve); /* Vérifie que le numéro de candidat est correct */
if(trouve == 0) if(trouve == 0)
{ {
printf("Erreur, vous n'êtes pas inscrit dans la base de données\n"); printf("Erreur, vous n'êtes pas inscrit dans la base de données\n");
@ -1412,6 +1406,8 @@ void menuCandidat2(Candidat *tCand[], int tMax)
} }
system("clear"); system("clear");
printf("|------------------------------------------------------------|\n"); printf("|------------------------------------------------------------|\n");
printf("| Bienvenue %-32s |\n", tCand[pos]->prenom);
printf("|------------------------------------------------------------|\n");
printf("| Que souhaitez-vous faire ? |\n"); printf("| Que souhaitez-vous faire ? |\n");
printf("|------------------------------------------------------------|\n"); printf("|------------------------------------------------------------|\n");
printf("| 1 Afficher vos choix |\n"); printf("| 1 Afficher vos choix |\n");
@ -1423,7 +1419,7 @@ void menuCandidat2(Candidat *tCand[], int tMax)
printf("Saisie : "); printf("Saisie : ");
scanf("%d%*c", &saisie); scanf("%d%*c", &saisie);
printf("\n"); printf("\n");
while(saisie != 9) while(saisie != 9) /* Saisie contrôlée et affichage du menu tant que le candidat ne demande pas à quitter */
{ {
system("clear"); system("clear");
if(saisie == 1) if(saisie == 1)

186
J2sae.c
Unescape View File

@ -4,10 +4,10 @@
/****************************************** Et de sauvegarde*************************************************/ /****************************************** Et de sauvegarde*************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
Candidat ** chargementCandidats(int *tMax) Candidat ** chargementCandidats(int *tMax) /* Permet de charger le contenu du fichier Candidats.don dans un tableau de pointeur vers */
{ { /* des structures Candidats qui contiennent un tableau de pointeurs vers des structures choix*/
FILE *flot; FILE *flot; /* La fonction renvoie ensuite le tableau de Candidats si tout se passe bien */
Candidat **tCand, *c; Candidat **tCand, *c; /* Déclaration du tableau de candidats et d'une variable de chargement */
int i; int i;
flot = fopen("Candidats.don", "r"); flot = fopen("Candidats.don", "r");
if(flot == NULL) if(flot == NULL)
@ -16,52 +16,51 @@ Candidat ** chargementCandidats(int *tMax)
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
fscanf(flot, "%d", tMax); fscanf(flot, "%d", tMax); /* Lecture du nombre de candidats pour déterminer la taille physique du tableau */
printf("tMax : %d\n", *tMax); printf("tMax : %d\n", *tMax);
tCand = (Candidat **)malloc(sizeof(Candidat *) * (*tMax)); tCand = (Candidat **)malloc(sizeof(Candidat *) * (*tMax)); /* Allocation dynamique du tableau de candidats*/
printf("Allocation du tableau\n");
if(tCand == NULL) if(tCand == NULL)
{ {
printf("Erreur d'allocation mémoire tableau candidat\n"); printf("Erreur d'allocation mémoire tableau candidat\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
for(i = 0; i < *tMax; i++) for(i = 0; i < *tMax; i++) /* Remplissage du tableau */
{ {
c = lireCandidat(flot); c = lireCandidat(flot); /* Lecture d'un candidat */
tCand[i] = c; tCand[i] = c; /* Insertion du candidat lu dans le tableau */
} }
fclose(flot); fclose(flot);
return tCand; return tCand;
} }
Candidat * lireCandidat(FILE *flot) Candidat * lireCandidat(FILE *flot) /* Fonction permettant de lire un candidat dans un fichier et renvoyant un pointeur vers la structure candidat lue */
{ {
Candidat *c; Candidat *c; /* Déclaration d'un pointeur vers un candidat pour la lecture et l'allocation dynamique d'un candidat */
Choix choix; Choix choix; /* Déclaration d'une variable de type Choix pour la lecture des choix du candidat */
int i = 0; int i = 0;
c = (Candidat *)malloc(sizeof(Candidat)); c = (Candidat *)malloc(sizeof(Candidat)); /* Allocation dynamique du candidat */
if(c == NULL) if(c == NULL)
{ {
printf("Erreur d'allocation mémoire candidat\n"); printf("Erreur d'allocation mémoire candidat\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
fscanf(flot, "%d%*c", &c->numeroC); fscanf(flot, "%d%*c", &c->numeroC); /* Lectures des informations du candidat (numero, nom, prenom, notes, nombre de choix)*/
fgets(c->nom, 31, flot); fgets(c->nom, 31, flot);
c->nom[strlen(c->nom) - 1] = '\0'; c->nom[strlen(c->nom) - 1] = '\0';
fgets(c->prenom, 31, flot); fgets(c->prenom, 31, flot);
c->prenom[strlen(c->prenom) - 1] = '\0'; c->prenom[strlen(c->prenom) - 1] = '\0';
fscanf(flot, "%f%f%f%f%*c", &c->notes[0], &c->notes[1], &c->notes[2], &c->notes[3]); fscanf(flot, "%f%f%f%f%*c", &c->notes[0], &c->notes[1], &c->notes[2], &c->notes[3]);
fscanf(flot, "%d%*c", &c->nombreChoix); fscanf(flot, "%d%*c", &c->nombreChoix);
c->tChoix = (Choix **)malloc(sizeof(Choix *) * c->nombreChoix); c->tChoix = (Choix **)malloc(sizeof(Choix *) * c->nombreChoix); /* Allocation dynamique du tableau de pointeurs vers des structures Choix*/
if(c->tChoix == NULL) if(c->tChoix == NULL) /* pour le chargement des choix du candidats */
{ {
printf("Erreur lors de l'allocation mémoire du tableau de choix\n"); printf("Erreur lors de l'allocation mémoire du tableau de choix\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
while(i < c->nombreChoix) while(i < c->nombreChoix) /* Lecture des choix du candidats et placements de ceux-ci dans le tableau tChoix */
{ {
c->tChoix[i] = lireChoix(flot); c->tChoix[i] = lireChoix(flot);
i = i + 1; i = i + 1;
@ -69,16 +68,16 @@ Candidat * lireCandidat(FILE *flot)
return c; return c;
} }
Choix * lireChoix(FILE *flot) Choix * lireChoix(FILE *flot) /* Fonction permettant de lire le Choix d'un candidat dans un fichier et renvoyant un pointeur vers la structure choix*/
{ { /* Du choix qui a été lu */
Choix *c; Choix *c; /* Déclaration d'un pointeur vers une variable de type choix pour la lecture */
c = (Choix *)malloc(sizeof(Choix)); c = (Choix *)malloc(sizeof(Choix)); /* Allocation dynamique de la structure choix */
if(c == NULL) if(c == NULL)
{ {
printf("Erreur d'allocation mémoire choix\n"); printf("Erreur d'allocation mémoire choix\n");
exit(1); exit(1);
} }
fgets(c->ville, 31, flot); fgets(c->ville, 31, flot); /* Lectures des différentes informations relatives au choix */
c->ville[strlen(c->ville) - 1] = '\0'; c->ville[strlen(c->ville) - 1] = '\0';
fgets(c->dep, 31, flot); fgets(c->dep, 31, flot);
c->dep[strlen(c->dep) - 1] = '\0'; c->dep[strlen(c->dep) - 1] = '\0';
@ -86,22 +85,22 @@ Choix * lireChoix(FILE *flot)
return c; return c;
} }
void sauvegarder(Candidat *tCand[], int tMax) void sauvegarder(Candidat *tCand[], int tMax) /* Fonctions permettant de sauvegarder l'ensemble des candidats et de leur choix dans un fichier */
{ { /* CandidatsSauv.don */
FILE *flot; FILE *flot;
int i, j; int i, j;
flot = fopen("CandidatsSauv.don", "w"); flot = fopen("CandidatsSauv.don", "w"); /* Ouverture du fichier */
if(flot == NULL) if(flot == NULL)
{ {
printf("Erreur de l'ouverture du fichier lors de l'enregistrement\n"); printf("Erreur de l'ouverture du fichier lors de l'enregistrement\n");
fclose(flot); fclose(flot);
exit(1); exit(1);
} }
fprintf(flot, "%d\n", tMax); fprintf(flot, "%d\n", tMax); /* Ecriture su nombre de candidats */
for(i = 0; i < tMax; i++) for(i = 0; i < tMax; i++) /* Ecriture de chaque candidat*/
{ {
fprintf(flot, "%d\n%s\n%s\n%d\n", tCand[i]->numeroC, tCand[i]->nom, tCand[i]->prenom, tCand[i]->nombreChoix); fprintf(flot, "%d\n%s\n%s\n%d\n", tCand[i]->numeroC, tCand[i]->nom, tCand[i]->prenom, tCand[i]->nombreChoix);
for(j = 0; j < tCand[i]->nombreChoix; j++) for(j = 0; j < tCand[i]->nombreChoix; j++) /* Ecriture de chaque choix du candidat */
{ {
fprintf(flot, "%s\n%s\n%d\n%d\n", tCand[i]->tChoix[j]->ville, tCand[i]->tChoix[j]->dep, tCand[i]->tChoix[j]->decisionResp, tCand[i]->tChoix[j]->decisionCand); fprintf(flot, "%s\n%s\n%d\n%d\n", tCand[i]->tChoix[j]->ville, tCand[i]->tChoix[j]->dep, tCand[i]->tChoix[j]->decisionResp, tCand[i]->tChoix[j]->decisionCand);
} }
@ -115,21 +114,21 @@ void sauvegarder(Candidat *tCand[], int tMax)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
void afficherChoix(Choix *c) void afficherChoix(Choix *c) /* Fonction permettant d'afficher les informations d'un choix donné en paramètre */
{ {
printf("|_______________________________________________________________________________|\n"); printf("|_______________________________________________________________________________|\n");
printf("| %-32s | %-32s | %2d | %2d |\n", c->ville, c->dep, c->decisionResp, c->decisionCand); printf("| %-32s | %-32s | %2d | %2d |\n", c->ville, c->dep, c->decisionResp, c->decisionCand);
printf("|-------------------------------------------------------------------------------|\n"); printf("|-------------------------------------------------------------------------------|\n");
} }
void afficherCandidat(Candidat *c) void afficherCandidat(Candidat *c) /* Fonction permettant d'afficher les informations d'un candidat donné en paramètre */
{ {
printf("|------------------------------------------------------------------------------------------------------------|\n"); printf("|------------------------------------------------------------------------------------------------------------|\n");
printf("| %-4d | %-32s | %-32s | %2.2f | %2.2f | %2.2f | %2.2f |\n", c->numeroC, c->nom, c->prenom, c->notes[0], c->notes[1], c->notes[2], c->notes[3]); printf("| %-4d | %-32s | %-32s | %2.2f | %2.2f | %2.2f | %2.2f |\n", c->numeroC, c->nom, c->prenom, c->notes[0], c->notes[1], c->notes[2], c->notes[3]);
printf("|------------------------------------------------------------------------------------------------------------|\n"); printf("|------------------------------------------------------------------------------------------------------------|\n");
} }
void afficherCandChoix(Candidat *tCand[],int tMax) void afficherCandChoix(Candidat *tCand[],int tMax) /* Fonction permettant d'afficher tous les candidats du tableau tCand ainsi que tous leurs choix */
{ {
int i, j; int i, j;
for(i = 0; i < tMax; i++) for(i = 0; i < tMax; i++)
@ -147,7 +146,7 @@ void afficherCandChoix(Candidat *tCand[],int tMax)
} }
} }
void afficherCandDep(Candidat *tCand[], int tMax) void afficherCandDep(Candidat *tCand[], int tMax) /* Fonction permettant d'afficher tous les candidats ayant fait une demande pour un département */
{ {
int i, j; int i, j;
char ville[31], dep[31]; char ville[31], dep[31];
@ -174,7 +173,7 @@ void afficherCandDep(Candidat *tCand[], int tMax)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
Candidat ** reallocationCand(Candidat *tCand[], int tMax) Candidat ** reallocationCand(Candidat *tCand[], int tMax) /* Fonction permettant de re-allouer le tableau des candidats en ajoutant 1 à sa taile physique */
{ {
Candidat **aux; Candidat **aux;
aux = (Candidat **)realloc(tCand, sizeof(Candidat *) * (tMax + 1)); aux = (Candidat **)realloc(tCand, sizeof(Candidat *) * (tMax + 1));
@ -185,7 +184,7 @@ Candidat ** reallocationCand(Candidat *tCand[], int tMax)
return aux; return aux;
} }
Choix ** reallocationChoix(Choix *tChoix[], int nbChoix) Choix ** reallocationChoix(Choix *tChoix[], int nbChoix) /* Fonction permettant de re-allouer un tableau de choix en ajoutant 1 à sa taille physique */
{ {
Choix **aux; Choix **aux;
nbChoix = nbChoix + 1; nbChoix = nbChoix + 1;
@ -202,19 +201,19 @@ Choix ** reallocationChoix(Choix *tChoix[], int nbChoix)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
void triCandidats(Candidat *tCand[], int tMax) void triCandidats(Candidat *tCand[], int tMax) /* Fonction permettant de trier un tableau de candidats en effectuant un tri par échange */
{ {
int maxi; int maxi;
while(tMax > 1) while(tMax > 1)
{ {
maxi = plusGrandCand(tCand, tMax); maxi = plusGrandCand(tCand, tMax); /* Appel de la fonction plusGrand pour déterminer le plus grand élément du tableau */
echangerCand(tCand, maxi, tMax - 1); echangerCand(tCand, maxi, tMax - 1); /* Appel de la fonction échange pour placer le plus grnad élément du tableau en dernière position */
tMax = tMax - 1; tMax = tMax - 1;
} }
} }
int plusGrandCand(Candidat *tCand[], int tMax) int plusGrandCand(Candidat *tCand[], int tMax) /* Fonction permettant de trouver le plus grand élément du tableau candidat en le parcourant et en*/
{ { /* comparant ses éléments. Elle renvoie ensuite l'indice du plus grand élément */
int maxi = 0, i; int maxi = 0, i;
for(i = 1; i < tMax; i++) for(i = 1; i < tMax; i++)
{ {
@ -226,7 +225,7 @@ int plusGrandCand(Candidat *tCand[], int tMax)
return maxi; return maxi;
} }
void echangerCand(Candidat *tCand[], int i, int j) void echangerCand(Candidat *tCand[], int i, int j) /* Fonction permettant d'échanger deux éléments dans un tableau de candidats*/
{ {
printf("Echange\n"); printf("Echange\n");
Candidat *aux; Candidat *aux;
@ -235,7 +234,7 @@ void echangerCand(Candidat *tCand[], int i, int j)
tCand[j] = aux; tCand[j] = aux;
} }
void triChoix(Choix *tChoix[], int nombreChoix) void triChoix(Choix *tChoix[], int nombreChoix) /* Fonction de tri par échange permettant de trier un tableau de Choix */
{ {
int maxi; int maxi;
while(nombreChoix > 1) while(nombreChoix > 1)
@ -246,7 +245,7 @@ void triChoix(Choix *tChoix[], int nombreChoix)
} }
} }
int plusGrandChoix(Choix *tChoix[], int nombreChoix) int plusGrandChoix(Choix *tChoix[], int nombreChoix) /* Fontcion permettant de trouver le plus grand élément d'un tableau de choix et de renvoyer son indice */
{ {
int maxi = 0, i; int maxi = 0, i;
for(i = 1; i < nombreChoix; i++) for(i = 1; i < nombreChoix; i++)
@ -266,7 +265,7 @@ int plusGrandChoix(Choix *tChoix[], int nombreChoix)
return maxi; return maxi;
} }
void echangerChoix(Choix *tChoix[], int i, int j) void echangerChoix(Choix *tChoix[], int i, int j) /* Fonction permettant d'échanger deux éléments d'un tableau de choix */
{ {
Choix *aux; Choix *aux;
aux = tChoix[i]; aux = tChoix[i];
@ -279,103 +278,101 @@ void echangerChoix(Choix *tChoix[], int i, int j)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
Choix ** insererChoix(Choix *tChoix[], int *nombreChoix) Choix ** insererChoix(Choix *tChoix[], int *nombreChoix) /* Fonction permettant d'ajouter un nouveau choix dans un tableau de choix et retournant le tableau*/
{ {
int pos, trouve, i; int pos, trouve, i;
char ville[31], dep[31]; char ville[31], dep[31];
Choix *c; Choix *c;
printf("Dans quelle ville se trouve la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); printf("Dans quelle ville se trouve la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); /* Demande à l'utilisateur la ville dans laquelle insérer */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
printf("Quelle est le nom de la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); printf("Quelle est le nom de la formation que vous souhaitez ajouter à vos choix ?\nSaisie : "); /* Demande le département dans la ville */
scanf("%s%*c", dep); scanf("%s%*c", dep);
printf("\n"); printf("\n");
pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); /* Vérifie que le choix ne figure pas déjà dans le tableau de choix */
if(trouve == 1) if(trouve == 1)
{ {
printf("Erreur, ce choix figure déjà dans votre liste\n"); printf("Erreur, ce choix figure déjà dans votre liste\n");
return tChoix; return tChoix;
} }
c = (Choix *)malloc(sizeof(Choix)); c = (Choix *)malloc(sizeof(Choix)); /* Allocation dynamique du choix à insérer */
if(c == NULL) if(c == NULL)
{ {
printf("Erreur d'allocation mémoire lors de l'insertion du choix\n"); printf("Erreur d'allocation mémoire lors de l'insertion du choix\n");
return tChoix; return tChoix;
} }
strcpy(c->ville, ville); strcpy(c->ville, ville); /* Ajout des valeurs dans le choix à insérer */
strcpy(c->dep, dep); strcpy(c->dep, dep);
c->decisionResp = 0; c->decisionResp = 0; /* Par défaut, les décisions du candidat et du responsable sont initialisées à 0*/
c->decisionCand = 0; c->decisionCand = 0;
tChoix = reallocationChoix(tChoix, *nombreChoix); tChoix = reallocationChoix(tChoix, *nombreChoix); /* Réallocation du tableau de choix pour ajouter une place */
for(i = *nombreChoix; i > pos; i--) for(i = *nombreChoix; i > pos; i--) /* Décalage à droite des éléments du tableau à partir de la position d'insertion */
{ {
tChoix[i] = tChoix[i - 1]; tChoix[i] = tChoix[i - 1];
} }
tChoix[pos] = c; tChoix[pos] = c; /* Ajout du choix dans le tableau */
*nombreChoix = *nombreChoix + 1; *nombreChoix = *nombreChoix + 1; /* Mise à jour de la taille physique du tableau */
return tChoix; return tChoix;
} }
Choix ** supprimerChoix(Choix *tChoix[], int *nombreChoix) Choix ** supprimerChoix(Choix *tChoix[], int *nombreChoix) /* Fonction permettant de supprimer un choix d'un tableau de choix */
{ {
Choix **aux, *temp; Choix **aux; /* Déclaration d'une variable aux prenant la valeur du tableau */
int i, pos, trouve; int i, pos, trouve;
char ville[31], dep[31], saisie; char ville[31], dep[31], saisie;
printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande au candidat dans quelle ville supprimer le choix */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande au candidat dans quel département de la ville */
scanf("%s%*c", dep); scanf("%s%*c", dep);
printf("\n"); printf("\n");
pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); /* Vérification que le choix indiqué figure bien dan le tableau des choix */
if(trouve == 0) if(trouve == 0)
{ {
printf("Erreur, ce choix ne figure pas dans votre liste\n"); printf("Erreur, ce choix ne figure pas dans votre liste\n");
return tChoix; return tChoix;
} }
printf("Êtes-vous sur de vouloir supprimer ce choix ? (O/n)\nSaisie : "); printf("Êtes-vous sur de vouloir supprimer ce choix ? (O/n)\nSaisie : "); /* Demande de confirmation de la supression */
scanf("%c%*c", &saisie); scanf("%c%*c", &saisie);
printf("\n"); printf("\n");
if(saisie == 'n' || saisie == 'N') if(saisie == 'n' || saisie == 'N') /* Si non, retourne le tableau sans le changer */
{ {
return tChoix; return tChoix;
} }
temp = tChoix[pos]; for(i = pos; i < *nombreChoix - 1; i++) /* Décalage à gauche des éléments du tableau à partir du dernier jusqu'au choix à supprimer */
for(i = pos; i < *nombreChoix - 1; i++)
{ {
tChoix[i] = tChoix[i + 1]; tChoix[i] = tChoix[i + 1];
} }
*nombreChoix = *nombreChoix - 1; *nombreChoix = *nombreChoix - 1; /* Mise à jour de la taille physique du tableau */
aux = (Choix **)realloc(tChoix, *nombreChoix * sizeof(Choix *)); aux = (Choix **)realloc(tChoix, *nombreChoix * sizeof(Choix *)); /* Réallocation du tableau en enlevant une place à la fin */
if(aux == NULL) if(aux == NULL)
{ {
printf("Problème avec la réallocation lors de la suppression\n"); printf("Problème avec la réallocation lors de la suppression\n");
return tChoix; return tChoix;
} }
free(temp);
return aux; return aux;
} }
void miseAJourChoixCand(Choix *tChoix[], int nombreChoix) void miseAJourChoixCand(Choix *tChoix[], int nombreChoix) /* Fontcion permettant de mettre à jour la décision d'un candidat concernant un de ses choix */
{ {
int pos, trouve, saisie; int pos, trouve, saisie;
char ville[31], dep[31]; char ville[31], dep[31];
printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Dans quelle ville se trouve la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande au candidat la ville concernée par le choix */
scanf("%s%*c", ville); scanf("%s%*c", ville);
printf("\n"); printf("\n");
printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); printf("Quelle est le nom de la formation que vous souhaitez retirer de vos choix ?\nSaisie : "); /* Demande le département dans la ville en question */
scanf("%s%*c", dep); scanf("%s%*c", dep);
printf("\n"); printf("\n");
pos = rechercherChoix(tChoix, nombreChoix, ville, dep, &trouve); pos = rechercherChoix(tChoix, nombreChoix, ville, dep, &trouve); /* Vérifie que ce choix existe bien dans le tableau choix du candidat */
if(trouve == 0) if(trouve == 0)
{ {
printf("Erreur, ce choix ne figure pas dans votre liste\n"); printf("Erreur, ce choix ne figure pas dans votre liste\n");
return; return;
} }
system("clear"); system("clear");
if(tChoix[pos]->decisionCand == -1) if(tChoix[pos]->decisionCand == -1) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
{ {
printf("Vous avez actuellement refusé la proposition d'admission de l'établissement\n\n"); printf("Vous avez actuellement refusé la proposition d'admission de l'établissement\n\n");
printf("|---------------------------------------|\n"); printf("|---------------------------------------|\n");
printf("| Que souhaitez-vous faire ? |\n"); printf("| Que souhaitez-vous faire ? |\n");
@ -464,12 +461,12 @@ void miseAJourChoixCand(Choix *tChoix[], int nombreChoix)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
int rechercherChoix(Choix *tChoix[], int nombreChoix, char ville[], char dep[], int *trouve) int rechercherChoix(Choix *tChoix[], int nombreChoix, char ville[], char dep[], int *trouve) /* Permet d'effectuer une recherche dichotomique dans un tableau*/
{ { /* de choix en comparant les villes et départements */
int inf = 0, sup = nombreChoix - 1, m; int inf = 0, sup = nombreChoix - 1, m; /* Si le choix et trouvé, la fonction donne la valeur 1 à la*/
while(inf <= sup) while(inf <= sup) /* variable trouve passée par pointeur et renvoie sa position*/
{ { /* Si il n'est pas trouvé, la fonction renvoie sa position */
m = (inf + sup) / 2; m = (inf + sup) / 2; /* d'insertion et met trouve à 0 */
if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) == 0) if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) == 0)
{ {
*trouve = 1; *trouve = 1;
@ -497,9 +494,9 @@ int rechercherChoix(Choix *tChoix[], int nombreChoix, char ville[], char dep[],
} }
int rechercherCandidat(Candidat *tCand[], int tMax, int numeroC, int *trouve) int rechercherCandidat(Candidat *tCand[], int tMax, int numeroC, int *trouve) /* Permet d'effectuer une recherche dichotomique dans un tableau de candidats*/
{ { /* en comparants les numéros de candidats. Même principe que pour la fonction*/
int inf = 0, sup = tMax - 1, m; int inf = 0, sup = tMax - 1, m; /* de recherche de choix */
while(inf <= sup) while(inf <= sup)
{ {
m = (inf + sup) / 2; m = (inf + sup) / 2;
@ -527,29 +524,28 @@ int rechercherCandidat(Candidat *tCand[], int tMax, int numeroC, int *trouve)
/************************************************************************************************************/ /************************************************************************************************************/
/************************************************************************************************************/ /************************************************************************************************************/
void globale(void) void globale(void) /* Permet de gérer l'exécution du programme */
{ {
int tMax, pos, trouve, i; int tMax, pos, trouve, i;
Candidat **tCand, c; Candidat **tCand, c; /* Initialisation du tableau de candidats */
tCand = chargementCandidats(&tMax); tCand = chargementCandidats(&tMax); /* Remplissage du tableau par chargement */
sauvegarder(tCand, tMax); triCandidats(tCand, tMax); /* Tri du tableau */
triCandidats(tCand, tMax); for(i = 0; i < tMax; i++) /* Tri du tableau choix pour chaque candidat */
afficherCandChoix(tCand, tMax);
for(i = 0; i < tMax; i++)
{ {
triChoix(tCand[i]->tChoix, tCand[i]->nombreChoix); triChoix(tCand[i]->tChoix, tCand[i]->nombreChoix);
} }
menuCandidat(tCand, tMax); menuCandidat(tCand, tMax); /* Appel du menu adapté au candidat */
sauvegarder(tCand, tMax); /* Sauvegarde du tableau de candidats */
} }
void menuCandidat(Candidat *tCand[], int tMax) void menuCandidat(Candidat *tCand[], int tMax) /* Fonction affichant un menu adapté pour un candidat */
{ {
int pos,trouve, saisie, i, numeroC; int pos,trouve, saisie, i, numeroC;
system("clear"); system("clear");
printf("Quel est votre numéro de candidat ?\nSaisie : "); printf("Quel est votre numéro de candidat ?\nSaisie : "); /* Demande le numéro de candidat pour qu'il ne puisse accéder qu'à ses informations */
scanf("%d%*c", &numeroC); scanf("%d%*c", &numeroC);
printf("\n"); printf("\n");
pos = rechercherCandidat(tCand, tMax, numeroC, &trouve); pos = rechercherCandidat(tCand, tMax, numeroC, &trouve); /* Vérifie que le numéro de candidat est correct */
if(trouve == 0) if(trouve == 0)
{ {
printf("Erreur, vous n'êtes pas inscrit dans la base de données\n"); printf("Erreur, vous n'êtes pas inscrit dans la base de données\n");
@ -557,6 +553,8 @@ void menuCandidat(Candidat *tCand[], int tMax)
} }
system("clear"); system("clear");
printf("|------------------------------------------------------------|\n"); printf("|------------------------------------------------------------|\n");
printf("| Bienvenue %-32s |\n", tCand[pos]->prenom);
printf("|------------------------------------------------------------|\n");
printf("| Que souhaitez-vous faire ? |\n"); printf("| Que souhaitez-vous faire ? |\n");
printf("|------------------------------------------------------------|\n"); printf("|------------------------------------------------------------|\n");
printf("| 1 Afficher vos choix |\n"); printf("| 1 Afficher vos choix |\n");
@ -568,7 +566,7 @@ void menuCandidat(Candidat *tCand[], int tMax)
printf("Saisie : "); printf("Saisie : ");
scanf("%d%*c", &saisie); scanf("%d%*c", &saisie);
printf("\n"); printf("\n");
while(saisie != 9) while(saisie != 9) /* Saisie contrôlée et affichage du menu tant que le candidat ne demande pas à quitter */
{ {
system("clear"); system("clear");
if(saisie == 1) if(saisie == 1)

Write Preview
Loading…
Cancel
Save