You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
954 lines
37 KiB
954 lines
37 KiB
#include "J2sae.h"
|
|
|
|
/************************************** Fonctions de Chargement ********************************************/
|
|
/****************************************** Et de sauvegarde*************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
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; /* La fonction renvoie ensuite le tableau de Candidats si tout se passe bien */
|
|
Candidat **tCand, *c; /* Déclaration du tableau de candidats et d'une variable de chargement */
|
|
int i;
|
|
flot = fopen("Candidats.don", "r");
|
|
if(flot == NULL)
|
|
{
|
|
printf("Erreur lors de l'ouverture du fichier candidat\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
fscanf(flot, "%d", tMax); /* Lecture du nombre de candidats pour déterminer la taille physique du tableau */
|
|
tCand = (Candidat **)malloc(sizeof(Candidat *) * (*tMax)); /* Allocation dynamique du tableau de candidats*/
|
|
if(tCand == NULL)
|
|
{
|
|
printf("Erreur d'allocation mémoire tableau candidat\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
for(i = 0; i < *tMax; i++) /* Remplissage du tableau */
|
|
{
|
|
c = lireCandidat(flot); /* Lecture d'un candidat */
|
|
tCand[i] = c; /* Insertion du candidat lu dans le tableau */
|
|
}
|
|
fclose(flot);
|
|
return tCand;
|
|
}
|
|
|
|
Candidat * lireCandidat(FILE *flot) /* Fonction permettant de lire un candidat dans un fichier et renvoyant un pointeur vers la structure candidat lue */
|
|
{
|
|
Candidat *c; /* Déclaration d'un pointeur vers un candidat pour la lecture et l'allocation dynamique d'un candidat */
|
|
Choix choix; /* Déclaration d'une variable de type Choix pour la lecture des choix du candidat */
|
|
int i = 0;
|
|
c = (Candidat *)malloc(sizeof(Candidat)); /* Allocation dynamique du candidat */
|
|
if(c == NULL)
|
|
{
|
|
printf("Erreur d'allocation mémoire candidat\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
fscanf(flot, "%d%*c", &c->numeroC); /* Lectures des informations du candidat (numero, nom, prenom, notes, nombre de choix)*/
|
|
fgets(c->nom, 31, flot);
|
|
c->nom[strlen(c->nom) - 1] = '\0';
|
|
fgets(c->prenom, 31, flot);
|
|
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]);
|
|
c->moyenne = (c->notes[0] + c->notes[1] + c->notes[2] + c->notes[3]) / 4;
|
|
fscanf(flot, "%d%*c", &c->nombreChoix);
|
|
c->tChoix = (Choix **)malloc(sizeof(Choix *) * c->nombreChoix); /* Allocation dynamique du tableau de pointeurs vers des structures Choix*/
|
|
if(c->tChoix == NULL) /* pour le chargement des choix du candidats */
|
|
{
|
|
printf("Erreur lors de l'allocation mémoire du tableau de choix\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
while(i < c->nombreChoix) /* Lecture des choix du candidats et placements de ceux-ci dans le tableau tChoix */
|
|
{
|
|
c->tChoix[i] = lireChoix(flot);
|
|
i = i + 1;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
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; /* Déclaration d'un pointeur vers une variable de type choix pour la lecture */
|
|
c = (Choix *)malloc(sizeof(Choix)); /* Allocation dynamique de la structure choix */
|
|
if(c == NULL)
|
|
{
|
|
printf("Erreur d'allocation mémoire choix\n");
|
|
exit(1);
|
|
}
|
|
fgets(c->ville, 31, flot); /* Lectures des différentes informations relatives au choix */
|
|
c->ville[strlen(c->ville) - 1] = '\0';
|
|
fgets(c->dep, 31, flot);
|
|
c->dep[strlen(c->dep) - 1] = '\0';
|
|
fscanf(flot, "%d%d%*c", &c->decisionResp, &c->decisionCand);
|
|
return c;
|
|
}
|
|
|
|
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;
|
|
int i, j;
|
|
flot = fopen("CandidatsSauv.don", "w"); /* Ouverture du fichier */
|
|
if(flot == NULL)
|
|
{
|
|
printf("Erreur de l'ouverture du fichier lors de l'enregistrement\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
fprintf(flot, "%d\n", tMax); /* Ecriture su nombre de candidats */
|
|
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);
|
|
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);
|
|
}
|
|
}
|
|
fclose(flot);
|
|
return;
|
|
}
|
|
|
|
|
|
/***************************************** Fonctions d'affichage ********************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
void afficherChoix(Choix *c) /* Fonction permettant d'afficher les informations d'un choix donné en paramètre */
|
|
{
|
|
printf("|_______________________________________________________________________________|\n");
|
|
printf("| %-32s | %-32s | %2d | %2d |\n", c->ville, c->dep, c->decisionResp, c->decisionCand);
|
|
printf("|-------------------------------------------------------------------------------|\n");
|
|
}
|
|
|
|
void afficherCandidat(Candidat *c) /* Fonction permettant d'afficher les informations d'un candidat donné en paramètre */
|
|
{
|
|
printf("|-------------------------------------------------------------------------------------------------------------------|\n");
|
|
printf("| %-4d | %-32s | %-32s | %2.2f | %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], c->moyenne);
|
|
printf("|-------------------------------------------------------------------------------------------------------------------|\n");
|
|
}
|
|
|
|
void afficherCandChoix(Candidat *tCand[],int tMax) /* Fonction permettant d'afficher tous les candidats du tableau tCand ainsi que tous leurs choix */
|
|
{
|
|
int i, j;
|
|
for(i = 0; i < tMax; i++)
|
|
{
|
|
printf("_____________________________________________________________________________________________________________________\n");
|
|
printf("| Candidat |\n");
|
|
afficherCandidat(tCand[i]);
|
|
printf("\n");
|
|
printf("_________________________________________________________________________________\n");
|
|
printf("| Choix |\n");
|
|
for(j = 0; j < tCand[i]->nombreChoix; j++)
|
|
{
|
|
afficherChoix(tCand[i]->tChoix[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void afficherCandDep(Candidat *tCand[], int tMax) /* Fonction permettant d'afficher tous les candidats ayant fait une demande pour un département */
|
|
{
|
|
int i, j;
|
|
char ville[31], dep[31];
|
|
printf("Dans quelle ville se trouve le départment dont vous souhaitez afficher les candidats ?\nSaisie : ");
|
|
scanf("%s%*c", ville);
|
|
printf("\n");
|
|
printf("Quelle est le nom du département dont vous souhaitez afficher les candidats ?\nSaisie : ");
|
|
scanf("%s%*c", dep);
|
|
printf("\n");
|
|
for(i = 0; i < tMax; i++)
|
|
{
|
|
for(j = 0; j < tCand[i]->nombreChoix; j++)
|
|
{
|
|
if(strcmp(tCand[i]->tChoix[j]->ville, ville) == 0 && strcmp(tCand[i]->tChoix[j]->dep, dep) == 0)
|
|
{
|
|
afficherCandidat(tCand[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void afficherCandidatsParCatégorie(Candidat *tCand[], char ville[], char dep[], int tMax)
|
|
{
|
|
int categ, i, pos, trouve;
|
|
printf("Quelle catégorie de candidats souhaitez-vous afficher ? (admis = 1 / attente = 2)\nSaisie : ");
|
|
saisie("%d%*c", &categ);
|
|
printf("\n");
|
|
for(i = 0; i < tMax; i++)
|
|
{
|
|
pos = rechercherChoix(tCand[i]->tChoix, nombreChoix, ville, dep, &trouve);
|
|
if(trouve == 1)
|
|
{
|
|
if(tCand[i]->tChoix[pos]->decisionResp == categ)
|
|
{
|
|
afficherCandidat(tCand[i]);
|
|
afficherChoix(tCand[i]->tChoix[pos]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************ Fonctions de réallocation *********************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
Candidat ** reallocationCand(Candidat *tCand[], int tMax) /* Fonction permettant de re-allouer le tableau des candidats en ajoutant 1 à sa taile physique */
|
|
{
|
|
Candidat **aux;
|
|
aux = (Candidat **)realloc(tCand, sizeof(Candidat *) * (tMax + 1));
|
|
if(aux == NULL)
|
|
{
|
|
printf("Erreur lors de la réallocation du tableau\n");
|
|
}
|
|
return aux;
|
|
}
|
|
|
|
Choix ** reallocationChoix(Choix *tChoix[], int nbChoix) /* Fonction permettant de re-allouer un tableau de choix en ajoutant 1 à sa taille physique */
|
|
{
|
|
Choix **aux;
|
|
nbChoix = nbChoix + 1;
|
|
aux = (Choix **)realloc(tChoix, nbChoix * sizeof(Choix *));
|
|
if(aux == NULL)
|
|
{
|
|
printf("Erreur lors de la réallocation du tableau\n");
|
|
}
|
|
return aux;
|
|
}
|
|
|
|
|
|
/************************************* Fonctions de tri *****************************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
void triCandidats(Candidat *tCand[], int tMax) /* Fonction permettant de trier un tableau de candidats en effectuant un tri par échange */
|
|
{
|
|
int maxi;
|
|
while(tMax > 1)
|
|
{
|
|
maxi = plusGrandCand(tCand, tMax); /* Appel de la fonction plusGrand pour déterminer le plus grand élément du tableau */
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
for(i = 1; i < tMax; i++)
|
|
{
|
|
if(strcmp(tCand[i]->nom, tCand[maxi]->nom) == 0)
|
|
{
|
|
if(strcmp(tCand[i]->prenom, tCand[maxi]->prenom) > 0)
|
|
{
|
|
maxi = i;
|
|
}
|
|
}
|
|
if(strcmp(tCand[i]->nom, tCand[maxi]->nom) > 0)
|
|
{
|
|
maxi = i;
|
|
}
|
|
}
|
|
return maxi;
|
|
}
|
|
|
|
void echangerCand(Candidat *tCand[], int i, int j) /* Fonction permettant d'échanger deux éléments dans un tableau de candidats*/
|
|
{
|
|
Candidat *aux;
|
|
aux = tCand[i];
|
|
tCand[i] = tCand[j];
|
|
tCand[j] = aux;
|
|
}
|
|
|
|
void triChoix(Choix *tChoix[], int nombreChoix) /* Fonction de tri par échange permettant de trier un tableau de Choix */
|
|
{
|
|
int maxi;
|
|
while(nombreChoix > 1)
|
|
{
|
|
maxi = plusGrandChoix(tChoix, nombreChoix);
|
|
echangerChoix(tChoix, maxi, nombreChoix - 1);
|
|
nombreChoix = nombreChoix - 1;
|
|
}
|
|
}
|
|
|
|
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;
|
|
for(i = 1; i < nombreChoix; i++)
|
|
{
|
|
if(strcmp(tChoix[i]->ville, tChoix[maxi]->ville) == 0)
|
|
{
|
|
if(strcmp(tChoix[i]->dep, tChoix[maxi]->dep) > 0)
|
|
{
|
|
maxi = i;
|
|
}
|
|
}
|
|
if(strcmp(tChoix[i]->ville, tChoix[maxi]->ville) > 0)
|
|
{
|
|
maxi = i;
|
|
}
|
|
}
|
|
return maxi;
|
|
}
|
|
|
|
void echangerChoix(Choix *tChoix[], int i, int j) /* Fonction permettant d'échanger deux éléments d'un tableau de choix */
|
|
{
|
|
Choix *aux;
|
|
aux = tChoix[i];
|
|
tChoix[i] = tChoix[j];
|
|
tChoix[j] = aux;
|
|
}
|
|
|
|
|
|
/******************************* Fonctions d'insertion/suppresion/maj ***************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
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;
|
|
char ville[31], dep[31];
|
|
Choix *c;
|
|
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);
|
|
printf("\n");
|
|
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);
|
|
printf("\n");
|
|
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)
|
|
{
|
|
printf("Erreur, ce choix figure déjà dans votre liste\n");
|
|
return tChoix;
|
|
}
|
|
c = (Choix *)malloc(sizeof(Choix)); /* Allocation dynamique du choix à insérer */
|
|
if(c == NULL)
|
|
{
|
|
printf("Erreur d'allocation mémoire lors de l'insertion du choix\n");
|
|
return tChoix;
|
|
}
|
|
strcpy(c->ville, ville); /* Ajout des valeurs dans le choix à insérer */
|
|
strcpy(c->dep, dep);
|
|
c->decisionResp = 0; /* Par défaut, les décisions du candidat et du responsable sont initialisées à 0*/
|
|
c->decisionCand = 0;
|
|
tChoix = reallocationChoix(tChoix, *nombreChoix); /* Réallocation du tableau de choix pour ajouter une place */
|
|
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[pos] = c; /* Ajout du choix dans le tableau */
|
|
*nombreChoix = *nombreChoix + 1; /* Mise à jour de la taille physique du tableau */
|
|
return tChoix;
|
|
}
|
|
|
|
Choix ** supprimerChoix(Choix *tChoix[], int *nombreChoix) /* Fonction permettant de supprimer un choix d'un tableau de choix */
|
|
{
|
|
Choix **aux, *temp; /* Déclaration d'une variable aux prenant la valeur du tableau */
|
|
int i, pos, trouve;
|
|
char ville[31], dep[31], saisie;
|
|
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);
|
|
printf("\n");
|
|
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);
|
|
printf("\n");
|
|
pos = rechercherChoix(tChoix, *nombreChoix, ville, dep, &trouve); /* Vérification que le choix indiqué figure bien dan le tableau des choix */
|
|
if(trouve == 0)
|
|
{
|
|
printf("Erreur, ce choix ne figure pas dans votre liste\n");
|
|
return tChoix;
|
|
}
|
|
printf("Êtes-vous sur de vouloir supprimer ce choix ? (O/n)\nSaisie : "); /* Demande de confirmation de la supression */
|
|
scanf("%c%*c", &saisie);
|
|
printf("\n");
|
|
if(saisie == 'n' || saisie == 'N') /* Si non, retourne le tableau sans le changer */
|
|
{
|
|
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 */
|
|
{
|
|
tChoix[i] = tChoix[i + 1];
|
|
}
|
|
*nombreChoix = *nombreChoix - 1; /* Mise à jour de la taille physique du tableau */
|
|
aux = (Choix **)realloc(tChoix, *nombreChoix * sizeof(Choix *)); /* Réallocation du tableau en enlevant une place à la fin */
|
|
if(aux == NULL)
|
|
{
|
|
printf("Problème avec la réallocation lors de la suppression\n");
|
|
free(temp);
|
|
return tChoix;
|
|
}
|
|
free(temp);
|
|
return aux;
|
|
}
|
|
|
|
|
|
int 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;
|
|
char ville[31], dep[31];
|
|
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);
|
|
printf("\n");
|
|
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);
|
|
printf("\n");
|
|
pos = rechercherChoix(tChoix, nombreChoix, ville, dep, &trouve); /* Vérifie que ce choix existe bien dans le tableau choix du candidat */
|
|
if(trouve == 0)
|
|
{
|
|
printf("Erreur, ce choix ne figure pas dans votre liste\n");
|
|
return -2;
|
|
}
|
|
system("clear");
|
|
if(tChoix[pos]->decisionCand == 0)
|
|
{
|
|
printf("Vous n'avez actuellement pris aucune décision\n\n");
|
|
printf("|---------------------------------------|\n");
|
|
printf("| Que souhaitez-vous faire ? |\n");
|
|
printf("|---------------------------------------|\n");
|
|
printf("| 1 Accepter la proposition d'admission |\n");
|
|
printf("| 2 Refuser la proposition d'admission |\n");
|
|
printf("| 3 Ne rien changer |\n");
|
|
printf("|---------------------------------------|\n");
|
|
printf("Saisie : ");
|
|
scanf("%d%*c", &saisie);
|
|
printf("\n");
|
|
if(saisie == 1)
|
|
{
|
|
tChoix[pos]->decisionCand = 1;
|
|
return 1;
|
|
}
|
|
if(saisie == 2)
|
|
{
|
|
tChoix[pos]->decisionCand = -1;
|
|
return -1;
|
|
}
|
|
if(saisie == 3)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// void miseAJourChoixResp(Choix *tChoix[], int pos) /* Fontcion permettant de mettre à jour la décision d'un responsable d'admission concernant un candidat */
|
|
// {
|
|
// int saisie;
|
|
// system("clear");
|
|
// if(tChoix[pos]->decisionCand == 0) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
|
|
// {
|
|
// printf("Votre décision est actuellement en attente\n\n");
|
|
// printf("|---------------------------------------|\n");
|
|
// printf("| Que souhaitez-vous faire ? |\n");
|
|
// printf("|---------------------------------------|\n");
|
|
// printf("| 1 Accepter la demande d'admission |\n");
|
|
// printf("| 2 Mettre sur liste d'attente |\n");
|
|
// printf("| 3 Refuser la demande d'admission |\n");
|
|
// printf("| 4 Ne rien changer |\n");
|
|
// printf("|---------------------------------------|\n");
|
|
// printf("Saisie : ");
|
|
// scanf("%d%*c", &saisie);
|
|
// printf("\n");
|
|
// if(saisie == 1)
|
|
// {
|
|
// tChoix[pos]->decisionResp = 1;
|
|
// return;
|
|
// }
|
|
// if(saisie == 2)
|
|
// {
|
|
// tChoix[pos]->decisionCand = 2;
|
|
// return;
|
|
// }
|
|
// if(saisie == 3)
|
|
// {
|
|
// tChoix[pos]->decisionCand = -1;
|
|
// return;
|
|
// }
|
|
// if(saisie == 4)
|
|
// {
|
|
// return;
|
|
// }
|
|
// }
|
|
// if(tChoix[pos]->decisionCand == 2) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
|
|
// {
|
|
// printf("Votre décision est actuellement en attente\n\n");
|
|
// printf("|---------------------------------------|\n");
|
|
// printf("| Que souhaitez-vous faire ? |\n");
|
|
// printf("|---------------------------------------|\n");
|
|
// printf("| 1 Accepter la demande d'admission |\n");
|
|
// printf("| 2 Refuser la demande d'admission |\n");
|
|
// printf("| 3 Ne rien changer |\n");
|
|
// printf("|---------------------------------------|\n");
|
|
// printf("Saisie : ");
|
|
// scanf("%d%*c", &saisie);
|
|
// printf("\n");
|
|
// if(saisie == 1)
|
|
// {
|
|
// tChoix[pos]->decisionResp = 1;
|
|
// return;
|
|
// }
|
|
// if(saisie == 2)
|
|
// {
|
|
// tChoix[pos]->decisionCand = -1;
|
|
// return;
|
|
// }
|
|
// if(saisie == 3)
|
|
// {
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
Candidat ** creerCandidat(Candidat *tCand[], int *tMax)
|
|
{
|
|
int pos, trouve, i, numeroC;
|
|
char nom[31], prenom[31];
|
|
float notes[4];
|
|
Candidat *c;
|
|
printf("Quel est votre numéro de candidat ?\nSaisie : "); /* Demande à l'utilisateur le numéro du candidat pour l'insertion */
|
|
scanf("%d%*c", &numeroC);
|
|
printf("\n");
|
|
pos = rechercherCandidat(tCand, *tMax, numeroC, &trouve); /* Vérifie que le numero de candidat n'existe pas déjà */
|
|
if(trouve == 1)
|
|
{
|
|
printf("Erreur, votre numéro de candidat existe déjà dans la base de données\n");
|
|
return tCand;
|
|
}
|
|
c = (Candidat *)malloc(sizeof(Candidat)); /* Allocation dynamique du candidat à insérer */
|
|
if(c == NULL)
|
|
{
|
|
printf("Erreur d'allocation mémoire lors de l'insertion du candidat\n");
|
|
return tCand;
|
|
}
|
|
printf("Quel est votre nom ?\n");
|
|
scanf("%s%*c", nom);
|
|
printf("\n");
|
|
printf("Quel est votre prenom ?\n");
|
|
scanf("%s%*c", prenom);
|
|
printf("\n");
|
|
printf("Quel est votre moyenne de maths ?\n");
|
|
scanf("%f%*c", ¬es[0]);
|
|
printf("\n");
|
|
printf("Quel est votre moyenne de français ?\n");
|
|
scanf("%f%*c", ¬es[1]);
|
|
printf("\n");
|
|
printf("Quel est votre moyenne d'anglais ?\n");
|
|
scanf("%f%*c", ¬es[2]);
|
|
printf("\n");
|
|
printf("Quel est votre moyenne de spécialité ?\n");
|
|
scanf("%f%*c", ¬es[3]);
|
|
printf("\n");
|
|
c->numeroC = numeroC;
|
|
strcpy(c->nom, nom); /* Ajout des valeurs dans le candidat à insérer */
|
|
strcpy(c->prenom, prenom);
|
|
c->notes[0] = notes[0];
|
|
c->notes[1] = notes[1];
|
|
c->notes[2] = notes[2];
|
|
c->notes[3] = notes[3];
|
|
tCand = reallocationCand(tCand, *tMax); /* Réallocation du tableau de candidats pour ajouter une place */
|
|
for(i = *tMax; i > pos; i--) /* Décalage à droite des éléments du tableau à partir de la position d'insertion */
|
|
{
|
|
tCand[i] = tCand[i - 1];
|
|
}
|
|
tCand[pos] = c; /* Ajout du candidat dans le tableau */
|
|
*tMax = *tMax + 1; /* Mise à jour de la taille physique du tableau */
|
|
return tCand;
|
|
}
|
|
|
|
/*********************************** Fonctions de recherche *************************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
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; /* Si le choix et trouvé, la fonction donne la valeur 1 à la*/
|
|
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; /* d'insertion et met trouve à 0 */
|
|
if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) == 0)
|
|
{
|
|
*trouve = 1;
|
|
return m;
|
|
}
|
|
if(strcmp(ville, tChoix[m]->ville) > 0)
|
|
{
|
|
inf = m + 1;
|
|
}
|
|
if(strcmp(ville, tChoix[m]->ville) < 0)
|
|
{
|
|
sup = m - 1;
|
|
}
|
|
if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) > 0)
|
|
{
|
|
inf = m + 1;
|
|
}
|
|
if(strcmp(ville, tChoix[m]->ville) == 0 && strcmp(dep, tChoix[m]->dep) < 0)
|
|
{
|
|
sup = m - 1;
|
|
}
|
|
}
|
|
*trouve = 0;
|
|
return inf;
|
|
}
|
|
|
|
|
|
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; /* de recherche de choix */
|
|
while(inf <= sup)
|
|
{
|
|
m = (inf + sup) / 2;
|
|
if(numeroC == tCand[m]->numeroC)
|
|
{
|
|
*trouve = 1;
|
|
return m;
|
|
}
|
|
if(numeroC > tCand[m]->numeroC)
|
|
{
|
|
inf = m + 1;
|
|
}
|
|
else
|
|
{
|
|
sup = m - 1;
|
|
}
|
|
|
|
}
|
|
*trouve = 0;
|
|
return inf;
|
|
}
|
|
|
|
/**************************************** File d'attente ****************************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
FileCand filenouv(void)
|
|
{
|
|
FileCand f;
|
|
f.t = NULL;
|
|
f.q = NULL;
|
|
return f;
|
|
}
|
|
|
|
FileCand adjq(FileCand f, Candidat *c)
|
|
{
|
|
MaillonCandidat *m;
|
|
m = (MaillonCandidat *)malloc(sizeof(MaillonCandidat));
|
|
if(m == NULL)
|
|
{
|
|
printf("Erreur de malloc pour la file d'attente\n");
|
|
exit(1);
|
|
}
|
|
m->c = c;
|
|
m->suiv = NULL;
|
|
if(videFile(f))
|
|
{
|
|
f.t = m;
|
|
f.q = m;
|
|
return f;
|
|
}
|
|
f.q->suiv = m;
|
|
f.q = m;
|
|
return f;
|
|
}
|
|
|
|
FileCand supt(FileCand f)
|
|
{
|
|
MaillonCandidat *aux;
|
|
if(videFile(f))
|
|
{
|
|
printf("Opération interdite\n");
|
|
exit(1);
|
|
}
|
|
if(f.t == f.q)
|
|
{
|
|
free(f.t);
|
|
return filenouv();
|
|
}
|
|
aux = f.t;
|
|
f.t = f.t->suiv;
|
|
free(aux);
|
|
return f;
|
|
}
|
|
|
|
Candidat * tete(FileCand f)
|
|
{
|
|
if(videFile(f))
|
|
{
|
|
printf("File d'attente vide\n");
|
|
exit(1);
|
|
}
|
|
return f.t->c;
|
|
}
|
|
|
|
int longueurFile(FileCand f)
|
|
{
|
|
int i = 0;
|
|
while(f.t != NULL)
|
|
{
|
|
f.t = f.t->suiv;
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
int positionFileAttente(FileCand f, int numeroC)
|
|
{
|
|
int i = 0;
|
|
while(f.t != NULL)
|
|
{
|
|
if(numeroC == f.t->c->numeroC)
|
|
{
|
|
return i;
|
|
}
|
|
f.t = f.t->suiv;
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
bool videFile(FileCand f)
|
|
{
|
|
if(f.t == NULL && f.q == NULL)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void afficher(FileCand f)
|
|
{
|
|
printf("|----------------------------------------------------------------------------|\n");
|
|
printf("| Liste d'attente |\n");
|
|
printf("|----------------------------------------------------------------------------|\n");
|
|
while(f.t != NULL)
|
|
{
|
|
printf("| %-4d | %-32s | %-32s |\n",f.t->c->numeroC, f.t->c->nom, f.t->c->prenom);
|
|
printf("|----------------------------------------------------------------------------|\n");
|
|
f.t = f.t->suiv;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
/************************************* Fonctions de liste d'admission ***************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
ListeCand listeCandNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
|
|
{
|
|
ListeCand lCand;
|
|
lCand = NULL;
|
|
return lCand;
|
|
}
|
|
|
|
ListeCand insererCandEntete(ListeCand lCand,Candidat *c) /*Permet d'insérer un MaillonCand en début d'une liste passée en paramètre puis renvoie cette même liste*/
|
|
{
|
|
MaillonCandidat *m; /* Création d'un pointeur vers une structure MaillonCand */
|
|
m = (MaillonCandidat *)malloc(sizeof(MaillonCandidat)); /* Allocation d'un espace mémoire pour le nouveau maillon */
|
|
if(m == NULL)
|
|
{
|
|
printf("Problème d'allocation mémoire lors de l'insertion d'un candidat dans la liste d'admission\n"); /* Message d'erreur en cas de problème de malloc */
|
|
exit(1);
|
|
}
|
|
m->c = c; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
|
|
m->suiv = lCand;
|
|
return m;
|
|
}
|
|
|
|
ListeCand insererCand(ListeCand lCand, Candidat *c) /* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alphabétique/croissant et retourne cette liste */
|
|
{
|
|
if(lCand == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
|
|
{
|
|
return insererCandEntete(lCand, c);
|
|
}
|
|
if(c->numeroC < lCand->c->numeroC) /* Si le numéro de candidat est inférieur à celui de la liste testé, le maillon est inséré en tête*/
|
|
{
|
|
return insererCandEntete(lCand, c);
|
|
}
|
|
if(c->numeroC == lCand->c->numeroC) /* Si le maillon existe déjà, retourne la liste sans changement */
|
|
{
|
|
printf("Candidat déjà présent dans la liste\n");
|
|
return lCand;
|
|
}
|
|
lCand->suiv = insererCand(lCand->suiv, c); /* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
|
|
return lCand;
|
|
}
|
|
|
|
ListeCand supprimerCandEntete(ListeCand lCand) /* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
|
|
{
|
|
ListeCand aux;
|
|
if(lCand == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
|
|
{
|
|
printf("Opération interdite\n");
|
|
exit(1);
|
|
}
|
|
aux = lCand; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
|
|
lCand = lCand->suiv; /* On supprime le maillon */
|
|
free(aux); /* On libère l'espace mémoire du maillon supprimer*/
|
|
return lCand;
|
|
}
|
|
|
|
ListeCand supprimerCand(ListeCand lCand, Candidat *c) /* 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(lCand == NULL) /* La liste est vide, on la retourne sans changements */
|
|
{
|
|
return lCand;
|
|
}
|
|
if(c->numeroC < lCand->c->numeroC) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
|
|
{
|
|
return lCand;
|
|
}
|
|
if(c->numeroC == lCand->c->numeroC) /* Le maillon à supprimer est trouvé, on le supprime */
|
|
{
|
|
return supprimerCandEntete(lCand);
|
|
}
|
|
lCand->suiv = supprimerCand(lCand->suiv, c); /* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
|
|
return lCand;
|
|
}
|
|
|
|
int longueur(ListeCand lCand) /* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
|
|
{
|
|
int compt = 0; /* On déclare un compteur pour compter le nombre de maillons */
|
|
while(lCand != 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;
|
|
lCand = lCand->suiv;
|
|
}
|
|
return compt;
|
|
}
|
|
|
|
bool videListe(ListeCand lCand) /* Permet de savoir si une liste est vide et retourne un booléen */
|
|
{
|
|
if(lCand == NULL)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
ListeCand rechercherCandListe(ListeCand lCand, int numeroC, int *trouve) /* Permet de recherche un maillon dans une liste de départements passée en paramètre pour ensuite renvoyer son adresse*/
|
|
{
|
|
if(videListe(lCand)) /* Si la liste est vide, la variable trouve passée en pointeur prend la valeur 0 et on retourne la liste */
|
|
{
|
|
*trouve = 0;
|
|
return lCand;
|
|
}
|
|
if(numeroC < lCand->c->numeroC) /* Même procédé que la condition précédente si le département recherché n'est pas trouvé*/
|
|
{
|
|
*trouve = 0;
|
|
return lCand;
|
|
}
|
|
if(numeroC == lCand->c->numeroC) /* Si le département recherché est trouvé, trouve prend la valeur 1 et on retourne la liste */
|
|
{
|
|
*trouve = 1;
|
|
return lCand;
|
|
}
|
|
return rechercherCandListe(lCand->suiv, numeroC, trouve); /* Si aucune condition n'est respectée, renvoie la même recherche pour le maillon suivant */
|
|
}
|
|
|
|
|
|
|
|
/********************************** Fonction globale et menus ***********************************************/
|
|
/************************************************************************************************************/
|
|
/************************************************************************************************************/
|
|
|
|
void globale2(void) /* Permet de gérer l'exécution du programme */
|
|
{
|
|
int tMax, pos, trouve, i = 0, j, mini = i;
|
|
Candidat **tCand, c, **aux, *temp; /* Initialisation du tableau de candidats */
|
|
tCand = chargementCandidats(&tMax); /* Remplissage du tableau par chargement */
|
|
triCandidats(tCand, tMax); /* Tri du tableau */
|
|
for(i = 0; i < tMax; i++) /* Tri du tableau choix pour chaque candidat */
|
|
{
|
|
triChoix(tCand[i]->tChoix, tCand[i]->nombreChoix);
|
|
}
|
|
aux = tCand;
|
|
for(i = 0; i < tMax - 1; i++)
|
|
{
|
|
for(j = i + 1; j < tMax; j++)
|
|
{
|
|
if(tCand[j]->moyenne < tCand[i]->moyenne)
|
|
{
|
|
mini = j;
|
|
}
|
|
}
|
|
temp = tCand[i];
|
|
tCand[i] = tCand[mini];
|
|
tCand[mini] = temp;
|
|
}
|
|
//menuCandidat(tCand, tMax); /* Appel du menu adapté au candidat */
|
|
afficherCandChoix(aux, tMax);
|
|
sauvegarder(tCand, tMax); /* Sauvegarde du tableau de candidats */
|
|
}
|
|
|
|
void menuCandidat2(Candidat *tCand[], int tMax) /* Fonction affichant un menu adapté pour un candidat */
|
|
{
|
|
int pos,trouve, saisie, i, numeroC;
|
|
system("clear");
|
|
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);
|
|
printf("\n");
|
|
pos = rechercherCandidat(tCand, tMax, numeroC, &trouve); /* Vérifie que le numéro de candidat est correct */
|
|
if(trouve == 0)
|
|
{
|
|
printf("Erreur, vous n'êtes pas inscrit dans la base de données\n");
|
|
return;
|
|
}
|
|
system("clear");
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("| Bienvenue %-32s |\n", tCand[pos]->prenom);
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("| Que souhaitez-vous faire ? |\n");
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("| 1 Afficher vos choix |\n");
|
|
printf("| 2 Ajouter un choix |\n");
|
|
printf("| 3 Supprimer un choix |\n");
|
|
printf("| 4 Mettre à jour votre décision concernant un établissement |\n");
|
|
printf("| 9 Quitter |\n");
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("Saisie : ");
|
|
scanf("%d%*c", &saisie);
|
|
printf("\n");
|
|
while(saisie != 9) /* Saisie contrôlée et affichage du menu tant que le candidat ne demande pas à quitter */
|
|
{
|
|
system("clear");
|
|
if(saisie == 1)
|
|
{
|
|
for(i = 0; i < tCand[pos]->nombreChoix; i++)
|
|
{
|
|
afficherChoix(tCand[pos]->tChoix[i]);
|
|
}
|
|
}
|
|
if(saisie == 2)
|
|
{
|
|
tCand[pos]->tChoix = insererChoix(tCand[pos]->tChoix, &tCand[pos]->nombreChoix);
|
|
}
|
|
if(saisie == 3)
|
|
{
|
|
tCand[pos]->tChoix = supprimerChoix(tCand[pos]->tChoix, &tCand[pos]->nombreChoix);
|
|
}
|
|
if(saisie == 4)
|
|
{
|
|
miseAJourChoixCand(tCand[pos]->tChoix, tCand[pos]->nombreChoix);
|
|
}
|
|
clearpage();
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("| Que souhaitez-vous faire ? |\n");
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("| 1 Afficher vos choix |\n");
|
|
printf("| 2 Ajouter un choix |\n");
|
|
printf("| 3 Supprimer un choix |\n");
|
|
printf("| 4 Mettre à jour votre décision concernant un établissement |\n");
|
|
printf("| 9 Quitter |\n");
|
|
printf("|------------------------------------------------------------|\n");
|
|
printf("Saisie : ");
|
|
scanf("%d%*c", &saisie);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
void clearpage(void) /* Permet de demander à l'utilisateur pour continuer à la suite d'une action et efface le contenu affiché à l'écran */
|
|
{
|
|
char entre;
|
|
printf("\n");
|
|
printf("Appuyez sur la touche [ENTREE] pour continuer");
|
|
scanf("%c", &entre);
|
|
system("clear");
|
|
} |