#include<stdio.

h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
struct etudiant{
char nom[20];
char prenom[20];
int niveau;
char adresse[50];
int periode;
int nbr_emprunte_par_et;
int et_pocedant_1_l;
char livre_emprunte[30];
};
typedef struct caracteristique{
char titre[30];
char auteur[30];
char edition[30];
int nivo;
int emprunte;
int nbrEmprunte ;
}Reference;
typedef struct domaine{
char nomDomaine[30];
}Domaine;
typedef struct tab{
int nombreLivres;
int emprunteDomaine;
Reference livreDomaine[50];
}TabGestion;

//==============================================================================
========================================================================
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//-----------------------------------------------------------------------------
---------
int estDigit(char variable[30])
{
int i;
int nbrCaractere=0;
int entier=0;
for(i=0;i<strlen(variable);i++)
{
if(isdigit(variable[i]))
{
entier++;
}else{
nbrCaractere++;
}
}
if(entier==strlen(variable))
{
return atoi(variable);
}
else
{if(nbrCaractere==1)
 printf("\n\aOperation invalide car vous avez introduit un caractere.\n A
ucun caractere ne doit figurer dans votre CHOIX. ");
else
printf("\n\aOperation invalide car vous avez introduit %d caract
eres.\n Aucun caractere ne doit figurer dans votre CHOIX. ",nbrCaractere);
return -1;
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//==============================================================================
=========================================================================
/*FONCTION POUR ENREGISTRER UN ETUDIANT*/
void enregistre_etudiant( struct etudiant en_liste_etudiant[100],int *en_nbr_etu
diant) //*nbr_etudiant est egal nombre d 'etudiant regulier dans l etablissemen
t
{
char en_nom[20],en_prenom[20],en_adresse[50],carChoix1[10];
int i;
if(*en_nbr_etudiant==0)
{
printf("\n\tVOUS ETES SUR LE POINT D\'ENREGISTRER LES L\'ETUDIANTS.\n");
printf("\t--------------------------------------------------\n\n\n");
do{
printf("--> Combien d\'etudiants sont inscrit dans votre etablissement: ");
gets(carChoix1);
*en_nbr_etudiant=estDigit(carChoix1);
if(*en_nbr_etudiant==-1)
printf("\n\n\t--> Entrer une valeur correcte.\n\n");
}while(*en_nbr_etudiant==-1);
for(i=0;i<*en_nbr_etudiant;i++)
{
printf("\n\n\n\n");
printf("\tL\'ETUDIANT %d\n\n",i+1);
printf("* Donnez le nom de l\'etudiant: ");
fflush(stdin);
gets(en_nom);
strcpy(en_liste_etudiant[i].nom,en_nom);
printf("* Donnez le prenom de l\'etudiant: ");
gets(en_prenom);
strcpy(en_liste_etudiant[i].prenom,en_prenom);
do{
printf("* Donnez le niveau de l\'etudiant. Notez bien: Compris entre 1 et 7:
");
gets(carChoix1);
en_liste_etudiant[i].niveau=estDigit(carChoix1);
if((en_liste_etudiant[i].niveau<=0)||(en_liste_etudiant[i].niveau>7))
printf("\n\t Entrer un choix valide.\n\n");
}
while((en_liste_etudiant[i].niveau<=0)||(en_liste_etudiant[i].niveau>7));
printf("* Donnez l\'adresse de l\'etudiant: ");
fflush(stdin);
gets(en_adresse);
 strcpy(en_liste_etudiant[i].adresse,en_adresse);
en_liste_etudiant[i].niveau=0;
en_liste_etudiant[i].periode=0;
en_liste_etudiant[i].nbr_emprunte_par_et=0;
en_liste_etudiant[i].et_pocedant_1_l=0;
strcpy(en_liste_etudiant[i].livre_emprunte,"****************************");
printf("\n\n\t");
system("pause");
system("cls");
}
}
else
printf("\n");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONTION POUR AJOUTER UN ETUDIANT*/
void ajouter(struct etudiant en_liste_etudiant[100],int *(en_nbr_etudiant))
{
(*en_nbr_etudiant)++;
char carChoix1[10];
char en_nom[20],en_prenom[20],en_adresse[50];
printf("\n");
printf("\n\tVOUS ETES SUR LE POINT D\'AJOUTER UN ETUDIANT.\n");
printf("\t--------------------------------------------\n\n\n");
printf("* Donnez le nom de l\'etudiant a ajouter: ");
fflush(stdin);
gets(en_nom);
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].nom,en_nom);
printf("* Donnez le prenom de l\'etudiant a ajouter: ");
gets(en_prenom);
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].prenom,en_prenom);
do{
printf("* Donnez le niveau de l\'etudiant a ajouter. Notez bien: Compris entr
e 1 et 7: ");
gets(carChoix1);
en_liste_etudiant[*(en_nbr_etudiant)-1].niveau=estDigit(carChoix1);
if((en_liste_etudiant[*(en_nbr_etudiant)-1].niveau)<=0||(en_liste_etudiant[*(
en_nbr_etudiant)-1].niveau>7))
printf("\n\t Entrer un choix valide.");
}while((en_liste_etudiant[*(en_nbr_etudiant)-1].niveau)<=0||(en_liste_etudia
nt[*(en_nbr_etudiant)-1].niveau>7));
printf("* Donnez l\'adresse de l\'etudiant a ajouter: ");
fflush(stdin);
gets(en_adresse);
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].adresse,en_adresse);
printf("\n");
printf("--> Votre etudiant est maintenant un etudiant regulier dans votre eta
blissement.\n\n\t");
en_liste_etudiant[*(en_nbr_etudiant)-1].periode=0;
 en_liste_etudiant[*(en_nbr_etudiant)-1].nbr_emprunte_par_et=0;
en_liste_etudiant[*(en_nbr_etudiant)-1].et_pocedant_1_l=0;
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].livre_emprunte,"**************
**************");
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

void ajout(struct etudiant en_liste_etudiant[100],int *(en_nbr_etudiant))

{
(*en_nbr_etudiant)++;
char carChoix1[10];
char en_nom[20],en_prenom[20],en_adresse[50];
printf("\n");
printf("\n\tVOUS ETES SUR LE POINT D\'AJOUTER UN ETUDIANT.\n");
printf("\t--------------------------------------------\n\n\n");
printf("* Donnez le nom de l\'etudiant a ajouter: ");
fflush(stdin);
gets(en_nom);
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].nom,en_nom);
printf("* Donnez le prenom de l\'etudiant a ajouter: ");
gets(en_prenom);
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].prenom,en_prenom);
do{
printf("* Donnez le niveau de l etudiant a ajouter. Notez bien: Compris entre
1 et 7: ");
gets(carChoix1);
en_liste_etudiant[*(en_nbr_etudiant)-1].niveau=estDigit(carChoix1);
if((en_liste_etudiant[*(en_nbr_etudiant)-1].niveau)<=0||(en_liste_etudiant[*(
en_nbr_etudiant)-1].niveau>7))
printf("\n\t Entrer un choix valide.");
}while((en_liste_etudiant[*(en_nbr_etudiant)-1].niveau)<=0||(en_liste_etudia
nt[*(en_nbr_etudiant)-1].niveau>7));
printf("* Donnez l\'adresse de l\'etudiant a ajouter: ");
fflush(stdin);
gets(en_adresse);
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].adresse,en_adresse);
printf("\n");
printf("--> Votre etudiant est maintenant un etudiant regulier dans votre eta
blissement.\n\n\t");
en_liste_etudiant[*(en_nbr_etudiant)-1].periode=0;
en_liste_etudiant[*(en_nbr_etudiant)-1].nbr_emprunte_par_et=0;
en_liste_etudiant[*(en_nbr_etudiant)-1].et_pocedant_1_l=0;
strcpy(en_liste_etudiant[*(en_nbr_etudiant)-1].livre_emprunte,"**************
**************");
system("pause");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
void rangerListe( struct etudiant en_liste_etudiant[100],int en_nbr_etudiant)
{
struct etudiant aide;
int i,j;
for(i=0;i<en_nbr_etudiant;i++)
{
for(j=i+1;j<en_nbr_etudiant;j++)
{
if(strcmp(en_liste_etudiant[j].nom,en_liste_etudiant[i].nom)<=
0)
{
if(strcmp(en_liste_etudiant[j].nom,en_liste_etudiant[i].nom)<0)
{
aide=en_liste_etudiant[i];
en_liste_etudiant[i]=en_liste_etudiant[j];
en_liste_etudiant[j]=aide;
}
else
{
if(strcmp(en_liste_etudiant[j].prenom,en_liste_etudiant[i].prenom)<0)
{
aide=en_liste_etudiant[i];
en_liste_etudiant[i]=en_liste_etudiant[j];
en_liste_etudiant[j]=aide;
}
}
}
}
}
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR AFFICHER LA LISTE DES ETUDIANT*/
void affiche( struct etudiant en_liste_etudiant[100],int en_nbr_etudiant)
{
int C;
int m;
int i,j,ok=0;
int verification,aide;//elle va me permettre de savoir si le nombre d etudiant e
st un multiple de trois pour ne pas afficher un parge vide.
printf("\n\t\tLISTE DES ETUDIANTS.\n");
printf("\t\t-------------------\n\n");
if(en_nbr_etudiant!=0)
{
i=0;
rangerListe(en_liste_etudiant,en_nbr_etudiant);
verification=en_nbr_etudiant%3;
if(verification==0)
aide=en_nbr_etudiant/3;
else
aide=(en_nbr_etudiant/3)+1;
if(en_nbr_etudiant!=0)
{
while(i<aide)
{
printf("\n PAGE - %d -",i+1);
printf("\n -----------");
 m=3+(3*i);
for(j=(3*i);(j<m)&&(j<en_nbr_etudiant);j++)
{
printf("\n");
if(j==0)
printf("\n\tLes informations du premier etudiant de la liste sont");
else
printf("\n\tLes informations du %d eme etudiant de la liste sont",j+1);
printf("\n --> Nom: %s",en_liste_etudiant[j].nom);
printf("\n --> Prenom: %s",en_liste_etudiant[j].prenom);
printf("\n --> Niveau: %d",en_liste_etudiant[j].niveau);
printf("\n --> Adresse: %s",en_liste_etudiant[j].adresse);
printf("\n --> La duree a mettre avec le livre emprunte: %d",en_liste_etudian
t[j].periode);
printf("\n --> Le nombre d\'empunte fais par cet etudiant est: %d",en_liste_e
tudiant[j].nbr_emprunte_par_et);
if(en_liste_etudiant[j].et_pocedant_1_l==0)
printf("\n --> L\'etudiant ne pocede aucun livre de la bibliotheque.\n\n\n\t"
);
else
printf("\n --> L\'etudiant possede un livre de la bibliotheque, le titre est
%s.\n\n\n\t",en_liste_etudiant[j].livre_emprunte);
}
printf("\n++> Tapez sur S pour continuer et sur P pour retourner a la page prec
edante et sur une autre touche pour quitter.");
fflush(stdin);
C=getchar();
system("cls");
if(((C=='S')&&(i!=(en_nbr_etudiant/3)))||((C==10)&&(i!=(en_nbr_etudiant/3))))
{
if((C=='S')&&(verification==0)&&(j==en_nbr_etudiant))
{
if(((C=='S')&&(i==(en_nbr_etudiant/3)-1))||((C==10)&&(i==(en_nbr_etudiant/3))
))
{
printf("\n\a ++> Vous etes a la derniere page.\n");
ok++;
}
}
else
i++;
}
else if((C==10)&&(i==(en_nbr_etudiant/3))&&(ok!=0))
break;
else if(((C=='S')&&(i==(en_nbr_etudiant/3)))||((C==10)&&(i==(en_nbr_etudiant
/3))))
{
printf("\n\a ++> Vous etes a la derniere page.\n");
ok++;
}
 else if((C=='P')&&(i!=0))
{
i=i-1;
}
else if((C=='P')&&(i==0))
printf("\n\a ++> Vous etes a la premiere page.\n");

else
break;
}

}
}
else
printf("\n --> il n\'ya pas d\'etudiant inscrit pour le momment.\n\n\n\t");
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR SUPPRIMER UN ETUDIANT*/
void supprimer( struct etudiant en_liste_etudiant[100],int *en_nbr_etudiant)
{
int pos=-1,i,existe=0;
char en_nom[20],en_prenom[20],affirmation[10];
printf("\n\tVOUS ETES SUR LE POINT DE SUPPRIMER UN ETUDIANT\n");
printf("\t-----------------------------------------------\n");
printf("\n * Donner le nom de l etudiant qui ne fait plus partir de l etabblisse
ment: ");
fflush(stdin);
gets(en_nom);
for(i=0;(i<*en_nbr_etudiant)&&(pos==-1);i++)
{
if(strcmp(en_nom,en_liste_etudiant[i].nom)!=0)
{
existe++;
}
else
{
printf("\n * Donner le prenom de l etudiant qui ne fait plus par
tir de votre etablissement: ");
gets(en_prenom);
fflush(stdin);
if((strcmp(en_prenom,en_liste_etudiant[i].prenom)==0))
pos=i;
}
}
if((existe==0)&&(pos!=-1))
{
printf("\n * L\'etudiant que vous voulez supprimer est regulier dans l e
tablissement");
printf("\n * Voulez vous vraiment le supprimez cet etudiant de l etablis
sement;entrez oui ou non: ");
gets(affirmation);
if((strcmp(affirmation,"oui")==0)&&(en_liste_etudiant[pos].et_pocedant_1
_l==0)||(strcmp(affirmation,"OUI")==0)&&(en_liste_etudiant[pos].et_pocedant_1_l=
=0))
{
for(i=pos;i<*en_nbr_etudiant;i++)
{
en_liste_etudiant[i]=en_liste_etudiant[i+1] ;
}
(*en_nbr_etudiant)--;
printf("\n * Cet etudiant a bien ete supprimer.\n\n\t");
}
else
printf(" * %s %s est en pocetion d un livre de la bibliotheque qu il n a pas
remi, il ne peut pas etre supprime.\n\n\t",en_nom,en_prenom);
}
else
printf("\n * Cet etudiant n\'est pas dans la liste des etudiants reguliers de l\
'etablissement\n\n\t");
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR RECHERCHER UN ETUDIANT*/
void recherche( struct etudiant en_liste_etudiant[100],int en_nbr_etudiant)
{
int pos=-1,i;
char en_nom[20],en_prenom[20];
printf("\n\tACTUELLEMENT VOUS ALLEZ CHERCHER UN ETUDIANT\n");
printf("\t--------------------------------------------\n");
{
printf("\n * Donner le nom de l\'etudiant que vous chercher: ");
fflush(stdin);
gets(en_nom);
for(i=0;i<en_nbr_etudiant;i++)
{
if(strcmp(en_nom,en_liste_etudiant[i].nom)!=0)
{

}
else
{
 printf("\n * Verifion le prenom\n");
printf("\n * Donner le prenom de l\'etudiant que vous chercher:
");
gets(en_prenom);
fflush(stdin);
if((strcmp(en_prenom,en_liste_etudiant[i].prenom)==0))
pos=i;
}
}
if(pos!=-1)
{
printf("\n * Cet etudiant existe dans votre etablissement.");
printf("\n * Les information correspondant a cet etudiant sont: ");
printf("\n");
if(pos==0)
printf("\t * Les informations du premier etudiant de la liste sont\n");
else
printf("\t * Les informations du %d eme etudiant de la liste sont:\n",i+1);
printf("\n --> Nom: %s",en_liste_etudiant[pos].nom);
printf("\n --> Prenom: %s",en_liste_etudiant[pos].prenom);
printf("\n --> Niveau: %d",en_liste_etudiant[pos].niveau);
printf("\n --> Adresse: %s",en_liste_etudiant[pos].adresse);
printf("\n --> La duree a mettre avec le livre emprunte: %d",en_liste_etudian
t[pos].periode);
printf("\n --> Le nombre d\'empunte fais par cet etudiant est: %d",en_liste_e
tudiant[pos].nbr_emprunte_par_et);
if(en_liste_etudiant[pos].et_pocedant_1_l==0)
printf("\n --> L\'etudiant ne pocede aucun livre de la bibliotheque\n\n\t");
else
printf("\n --> L\'etudiant pocede un livre de la bibliotheque, le titre est %
s\n\n\t",en_liste_etudiant[pos].livre_emprunte);
}

else
printf(" * Cet etudiant n\'existe pas dans votre etablissement.\n\n\t");
}
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION QUI DONNE LES INFORMATION SUR LES ETUDIANT DE L ETABLISSEMENT;DIT SI
UN ETUDIANT A EMPRUNTE UN LIVRE OU PAS*/
void info ( struct etudiant en_liste_etudiant[100],int en_nbr_etudiant/*on envoi
e le nombre d etudiant*/)
{
int i,j=0,emprunte=0,ok=0;
int plus_lu[50],max1,plus_lu1=0,m;
int pos_emp[50],max,pos_max;
int somme=0;
printf("\n\tPRESENTATION DU JOURNAL DES ETUDIANTS\n");
printf("\t-------------------------------------\n");
for(i=0;i<en_nbr_etudiant;i++)
 {
if(en_liste_etudiant[i].et_pocedant_1_l==1)
{
emprunte++;
pos_emp[j]=i;
j++;
}
}
printf("\n --> il existe %d etudiant regulier.",en_nbr_etudiant);
if(emprunte==0)
{
printf("\n --> Aucun etudiant n a emprute un livre.");
ok++;
}
else if(emprunte==1)
printf("\n --> Un etudiant est en pocetion d un livre.");
else
printf("\n --> %d etudiant sont en pocetion d un livre\n\n",emprunte);
for(i=0;i<emprunte;i++)
{
printf("\n\t*l etudiant %s %s du niveau: %d\n",en_liste_etudiant[pos_emp[i]].
nom,en_liste_etudiant[pos_emp[i]].prenom,en_liste_etudiant[pos_emp[i]].niveau);
}
for(i=0;i<en_nbr_etudiant;i++)
{
somme=somme+en_liste_etudiant[i].nbr_emprunte_par_et;
}
if(ok==0)//ce teste empeche de repeté la phrase dit plus haut
printf("\n --> Vous avez deja fait au total %d emprunte\n",somme);
for(i=0;i<en_nbr_etudiant;i++)
{
plus_lu[i]=en_liste_etudiant[i].nbr_emprunte_par_et;
}
max=en_liste_etudiant[0].nbr_emprunte_par_et;
pos_max=0;
for(i=1;i<en_nbr_etudiant;i++)
{
if(max<en_liste_etudiant[i].nbr_emprunte_par_et)
{
max=en_liste_etudiant[i].nbr_emprunte_par_et;
pos_max=i;
}
}
m=en_nbr_etudiant;
m--;
for(i=pos_max;i<m;i++)
{
plus_lu[i]=plus_lu[i+1];
}
max1=max;
for(i=0;i<m;i++)
{
if(max1==plus_lu[i])
plus_lu1++;
}
if((plus_lu1==0)&&(en_liste_etudiant[pos_max].et_pocedant_1_l==1))
printf(" --> L etudiant qui a fait le plus emprunte est: %s %s du niveau:
%d\n\n\t",en_liste_etudiant[pos_max].nom,en_liste_etudiant[pos_max].prenom,en_li
ste_etudiant[pos_max].niveau);
else if(max1==0)
printf(" \n\n\t");
else
printf(" --> Il existe %d etudiant qui lise assez les livres de la bib
liotheque.\n\n\t",plus_lu1+1);
system("pause");
system("cls");
}

//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONTION QUI GERE LES ETUDIANTS*/
void gestion_etudiant(struct etudiant liste_etudiant[100],int *nbr_etudiant)
{
int choix;
char carChoix1[10];
enregistre_etudiant(liste_etudiant,*(&nbr_etudiant)) ;
do
{
printf("\n BIEN VENU DANS LE MENU DES ETUDIANTS.\n");
printf(" ------------------------------------\n");
printf("\n--> tapez 1 pour ajouter un etudiant dans la liste des etudiants.");
printf("\n--> tapez 2 pour supprimer un etudiant de la liste des etudiants.");
printf("\n--> tapez 3 pour chercher un etudiant dans la liste des etudiant.");
printf("\n--> tapez 4 pour afficher la liste des etudiants.");
printf("\n--> tapez 5 pour voir les information sur le trafic de l etudiant.");
printf("\n--> tapez 6 pour quitter le menu de l etudiant.\n");
do
{
printf("\n --> ENTRER UN CHOIX VALIDE: ");
gets(carChoix1);
choix=estDigit(carChoix1);
}while((choix<=0)||(choix>6));
system("cls");

switch(choix)
{
case 1:ajouter(liste_etudiant,*(&nbr_etudiant));
break;
case 2:supprimer(liste_etudiant,*(&nbr_etudiant));
break;
case 3:recherche(liste_etudiant,*nbr_etudiant);
break;
case 4:affiche(liste_etudiant,*nbr_etudiant);
break;
case 5:info(liste_etudiant,*nbr_etudiant);
break;
default :
printf("\n\n\n\n\n\n\n\t**** MERCI DE REVENIR AU MENU DE VOTRE BIBLIOTHEQUE **
**\n\n\n\n");
}
}while(choix!=6);
printf("\t --> ");
system("pause");
system("cls");
}
//=============================================================================
========================================================================
//=============================================================================
========================================================================
//==============================================================================
========================================================================
/*FONCTION POUR AJOUTE UN DOMAINE */

void ajouter_domaine(int *nbre_domaine,Domaine liste[50])

{
char nouveau_domaine[30];
printf("\n\n\n\t--> Quel domaine voulez vous adjouter: ");
gets(nouveau_domaine);
(*nbre_domaine)++;
strcpy(liste[*nbre_domaine-1].nomDomaine,nouveau_domaine);
printf("\n\t--> Votre adjout a ete bien effectue.\n\n\t");
system("pause");
system("cls");
}

/*FONCTION POUR SUPPRIMER UN DOMAINE */

void supprimer_domaine(int *nbre_domaine,Domaine liste[50]){
int i=0,un=0;
char nouveau_domaine[30];
printf("\n\n\n\t--> Quel domaine voulez vous supprimer ? ");
gets(nouveau_domaine);
while(i<*nbre_domaine)
{
if((strcmp(liste[i].nomDomaine,nouveau_domaine)==0)&&(un==0))
{
liste[i]=liste[i+1];
un++;
printf("\n\t--> Votre domaine a ete bien supprime.\n\n\t");
(*nbre_domaine)--;
}
i++;
}
 if(un==0)
printf("\n\n\n\t--> Ce domaine n\'existe pas.\n\n\t");
system("pause");
system("cls");
}
/*FONCTION QUI SAISIE LE NOM DES DOMAINE */
void saisie_domaine(int *nbre_domaine,Domaine liste[50])
{
int i;
char nom_domaine[20],carChoix1[10];
if(*nbre_domaine==0)
{
printf("\n\tMERCI DE BIEN VOULOIR SAISIR LES NOMS DES DOMAINES\n");
printf("\t--------------------------------------------------\n\n");
do
{
printf("\n Combien de domaine desirez vous pour votre bibliotheque: ")
;
gets(carChoix1);
*nbre_domaine=estDigit(carChoix1);
if(*nbre_domaine==-1)
printf("\n\t Entrer un choix valide.");
}
while((*nbre_domaine<=0)||(*nbre_domaine>10));
for(i=0;i<*nbre_domaine;i++)
{
printf("\t++> Donner le nom du domaine %d: ",i+1);
fflush(stdin);
gets(nom_domaine);
strcpy(liste[i].nomDomaine,nom_domaine);
}

}
else
printf("\n");
system("cls");
}
//==============================================================================
=======================================================================
//==============================================================================
=======================================================================
//==============================================================================
=======================================================================
//==============================================================================
=======================================================================
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTIO POUR REMPLIR LES LIVRES DANS UN DOMAINE*/
void insertion_livre(Reference liv[50], int *m)
{
char nouveau_l[20],nouveau_a[30],nouveau_e[30],carChoix1[10] ;
printf("\n\tVOUS ETES SUR LE POINT D AJOUTER UN LIVRE\n");
printf("\t-----------------------------------------\n");
if(*m<50)
{
printf("\n ++> Quel livre voulez vous ajouter : ");
fflush(stdin);
gets(nouveau_l);
strcpy(liv[*m-1].titre,nouveau_l);
printf("\n ++> Donner le nom de l auteur: ");
fflush(stdin);
gets(nouveau_a);
strcpy(liv[*m-1].auteur,nouveau_a);
printf("\n ++> Donner l edition du livre: ");
fflush(stdin);
gets(nouveau_e);
strcpy(liv[*m-1].edition,nouveau_e);
do{
printf("\t++> Ce livre correspond aux etudiants du niveau.Notez bien: Comprid
entre 1 et 7: ");
gets(carChoix1);
liv[*m-1].nivo=estDigit(carChoix1);
if((0>=liv[*m-1].nivo)||(liv[*m-1].nivo<7))
printf("\n\t Entrer un choix valide.");
}while((liv[*m-1].nivo)<=0||(liv[*m-1].nivo>7));
(*m)++;
liv[*m-1].emprunte=0; // tableau qui enregistre si un livre est emprun
té
liv[*m-1].nbrEmprunte=0; //tableau qui enregistre le nomde fois qu un liv
re est emprunte
printf("\n\t--> VOTRE LIVRE A BIEN ETE AJOUTE\n\n\t");
}
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR SUPPRIMER UN LIVRE DANS LE DOMAINE*/
void supprimer_livre(Reference liv[50], int *m/*,int tab[],int tab_i[]*/)
{
char nouveau_l[20],affirmation[20];
int i;
int pos=-1; //variable qui entre la position du livre a emprunter
printf("\n\tVOUS ETES SUR LE POINT DE SUPPRIMER UN LIVRE\n");
printf("\t--------------------------------------------\n");

printf("++> Quel livre voulez vous supprimer : ");

fflush(stdin);
gets(nouveau_l);
/*on parcour le tableau et on cherche le livre que l utilisateur veut
supprimer et on retourne sa position*/
for(i=0;(i<*m)&&(pos==-1);i++)
{
 if(strcmp(liv[i].titre,nouveau_l)==0)
pos=i;
}
/*il faut enregistrer le position des livre les afficher,saisir cette position d
u livre a supprimer au
clavier puis par la suite faire un teste pour savoir si c est un livre emprunte*
/
if((pos!=-1)&&(liv[pos].emprunte==0))
{
if(pos!=-1)
{
for(i=pos;i<*m-1;i++)
{
liv[i]=liv[i+1];
//tab[i]/*liv[i].emprunte*/=tab[i+1]/*liv[i+1].emprunte*/;
//tab_i[i]/*liv[i].nbremprunte*/=tab_i[i+1]/*liv[i].nbremprunte*/;
}
(*m)--;
printf("\n--> VOTRE SUPPRESSION A ETE BIEN EFFECTUE.\n\n\t");
}
else
printf("\n --> Le livre que vous voulez supprimer n existe pas dans ce domaine\n
nous vous prions de reprendre votre operation ulterieurement\n\n\t");
}
else
{
printf("\n --> le livre que vous voulez supprimer est un livre emprunter si vous
voulez le supprime il n appartiendra plus a la bibliotheque.");
printf("\n --> Voulez vous vraiment le supprimer? Entre oui ou non ");
gets(affirmation);
if((strcmp(affirmation,"oui")==0)||(strcmp(affirmation,"OUI")==0))
{
for(i=pos;i<*m-1;i++)
{
liv[i]=liv[i+1];
//tab[i]=tab[i+1];
//tab_i[i]=tab_i[i+1];
}
(*m)--;
printf("\n--> VOTRE SUPPRESSION A ETE BIEN EFFECTUE.\n\n\t");
}
else
printf("\n --> Le livre %s n a pas ete supprime car c\'est un livre emprunte.\n\
n\t",liv[pos].titre);
}
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

/*ecrire une fonction pour chercher un livre et l emprunter et va

enregistrer le nombre des emprunte dans le domaine va enregistrer le ou les posi
tions
de ce livre cherche dans tabp et c est grace a cela nous allons allé modifier le t
ableau des emprunte tab.
nombre_livre c est le nombre de livre correspondant a la recherche .*/
void recherche_nom(Reference livre[50],int n,int *emprunte_du_domaine,struct etu
diant en_liste_etudiant[100],int *en_nbr_etudiant )
{
char nom_et[30],prenom_et[30],validation[10];
char carChoix1[10];
int nombre_livre=0;
int verification=0;
int tabp[50]; // tableau qui permet d enregistrer les differente position d un l
ivre si il exit plus d une fois
char liv[20] ;
char confirmation[10];
int i,j=0;
int un=0; //variable permettant de ne pas emprunter un livre plus d u
ne fois
int etudiant_trouve=-1; // postion de l etudiant dans la liste des etudiant
printf("\n\tACTUELLEMENT VOUS ALLEZ CHERCHER UN LIVRE\n");
printf("\t-----------------------------------------\n");
printf("\n ++> Quel livre cherchez vous : ");
fflush(stdin);
gets(liv);
for(i=0;i<n;i++)
{
if(strcmp(liv,livre[i].titre)==0)
{
tabp[j]=i; //tableau des position correspondans aux livre que
nous cherchons
j++; //enregistrer le tableau sans vide.
nombre_livre++; //nombre de livre corespondant a la rechercher
demande par l administrateur
}
}

if(nombre_livre==0)
printf("\n --> Il n\'existe aucun livre correspondant a votre recherche");
else if(nombre_livre==1)
printf("\n --> Il existe 1 lires correspondant a votre recherche");
else
printf("\n --> Il exite %d livres correspondant a votre recherche",nombre_livr
e);
if(nombre_livre!=0)
{
for(i=0;i<nombre_livre;i++)
{
if(i==0)
printf("\n --> Le premier liver se trouve a la position %d ",tabp[i]+1);
else if(i==1)
printf("\n --> Le deuxieme livre se trouve a la position %d ",tabp[i]+1)
;
else
printf("\n --> Le %d livre trouve est a la position %d ",i+1,
tabp[i]+1);
}
printf("\n ++> Voulez vous emprunter ce livre ? entrez oui ou non: ");
gets(confirmation);
 if((strcmp(confirmation,"oui")==0)||strcmp(confirmation,"OUI")==0)
{
for(i=0;i<nombre_livre;i++)
{
if((livre[tabp[i]].emprunte==0)&&(verification==0))
{
verification++;
}
}
if(verification==1)
{
printf("\n --> Donner le nom de l\'etudiant: ");
gets(nom_et);
printf(" --> Donnez le prenom de l\'etudiant: ");
gets(prenom_et);
if(*en_nbr_etudiant!=0)
{
for(i=0;i<*en_nbr_etudiant;i++)
{
if((strcmp(nom_et,en_liste_etudiant[i].n
om)==0)&&(strcmp(prenom_et,en_liste_etudiant[i].prenom)==0))
//pour montre que le nom n est pas corre
spondant
etudiant_trouve=i;
}
}
}
else
{
printf("\n --> le Livre est un livre emprunte");
}

if((etudiant_trouve==-1)&&(verification==1))
{
printf("\n --> L etudiant %s %s ne peut pas em
prunter le livre dans cette bibliotheque, ",nom_et,prenom_et);
printf("\ncar il n est pas enregistrer comme etudiant regulier dans
l etablissement. ");
printf("\nSi vous l emprunte un livre vous devez l enregistrer comm
e etudiant regulier, ");
printf("\nVoulez vous l enregistrer? entrer oui ou non pour la vali
dation de son enregistrement: ");
gets(validation);
if((strcmp(validation,"oui")==0)||(strcmp(validation,"OUI")==0))
{
//ici ont fait l affectation correspondant aux emprunte
le nombre d emprunte le nom du liver emprunté et tout les info necessaire.
system("cls");
for(i=0;i<nombre_livre;i++)
{
if((livre[tabp[i]].emprunte==0)&
&(un==0))
{
livre[tabp[i]].emprunte=1;
//le tab qui enregistre si un livre est emprunté ou pas.
livre[tabp[i]].nbrEmprunte++;
 //le tableau qui enregistre combien de fois un livre a ete emprunté.
(*emprunte_du_domaine)++;
//il enregistre le nombre d emprunte total du do
maine.
ajout(en_liste_etudiant,*(&en_nbr_etudiant));

//ont appel la fontion pour remp

lir les info de l etudiant a la position (*nbr_etudiant-1)
// car dans borlan les tableau c
ommence a zero
do{
printf("\n\n--> Pour une dure de combien de jour: ");
gets(carChoix1);
en_liste_etudiant[*en_nbr_etudiant-1].periode=estDigit(carC
hoix1);
}while(en_liste_etudiant[*en_nbr_etudiant-1].periode==-1);
system("cls");
en_liste_etudiant[*en_nbr_etudiant-1].nbr_emprunte_par_
et=en_liste_etudiant[*en_nbr_etudiant-1].nbr_emprunte_par_et+1;
en_liste_etudiant[*en_nbr_etudiant-1].et_pocedant_1_l=1
;
strcpy(en_liste_etudiant[*en_nbr_etudiant-1].livre_empr
unte,liv);
printf("\n\n\n\n\n\n\n ==> Un email de confirmation d\'
enregistrement a ete envoye a l\'etudiant %s %s \n\n",en_liste_etudiant[*en_nbr_
etudiant-1].nom,en_liste_etudiant[*en_nbr_etudiant-1].prenom);
un++;
//il empeche d emprunter un livre 2 fois

if((livre[tabp[i]].emprunte==1)&&(un==1)&&(strcmp(nom_et,en_li
ste_etudiant[*en_nbr_etudiant-1].nom)==0)&&(strcmp(prenom_et,en_liste_etudiant[*
en_nbr_etudiant-1].prenom)==0)&&(en_liste_etudiant[*en_nbr_etudiant-1].et_poceda
nt_1_l==1))
printf("\n\t--> L\'emprunte a ete bien effectue
pour l\'etudiant %s %s ",nom_et,prenom_et);
else
printf("\n --> Il y a eu une erreur lors de l\'enregistrement
.merci de reprendre.");
}
}
} //fermeture du oui de l enregistrement
else
printf("\n --> L\'etudiant %s %s n a p
as ete enregistre dans votre etablissement.",nom_et,prenom_et);

} //fermerture de l accollade du if si le nom de l etudiant a qui l

on veut emprunter le livre n existe pas
else
{
//faire un teste si l etudiant possede un livre
if(en_liste_etudiant[etudiant_trouve].et_pocedant_1_l==0)
{
 for(i=0;i<nombre_livre;i++)
{
if((livre[tabp[i]].emprunte==0)&
&(un==0))
{
do{
printf(" --> Pour une dure de combien de jour: ");
gets(carChoix1);
en_liste_etudiant[etudiant_trouve].periode=estDigit(carChoi
x1);
}while(en_liste_etudiant[etudiant_trouve].periode==-1);
en_liste_etudiant[etudiant_trouve].nbr_emprunte_par_et=e
n_liste_etudiant[etudiant_trouve].nbr_emprunte_par_et+1;
en_liste_etudiant[etudia
nt_trouve].et_pocedant_1_l=1;
strcpy(en_liste_etudiant[etudiant_trouve].livre_emprunte,li
v);
livre[tabp[i]].emprunte=1;
//le tab qui enregistre si un livre est emprunté ou pas.
livre[tabp[i]].nbrEmprunte++;
//le tableau qui enregistre combien de fois un livre a ete emprunté.
(*emprunte_du_domaine)++;
//il enregistre le nombre d emprunte total du domaine.
un++;
//il empeche d emprunter un livre 2 fois
}
else
{
if(livre[tabp[i]].emprunte==1&&verification==1)
printf(" --> Ce livre est un livre emprunte");
}
if((livre[tabp[i]].emprunte==1)&&(un==1)&&(en_liste_etudiant[e
tudiant_trouve].et_pocedant_1_l==1))
printf("\n\n\t--> L\'emprunte a ete bien effect
ue pour l\'etudiant %s %s ",nom_et,prenom_et);
}
}
else
printf("\n --> Cet etudiant pocede deja un livre qu il n a pas e
ncore rendu");
} //fermerture du else final

/*}
else
printf("\n vous devez d abord enregistrer un etudiant.");
*/

}//fermerture de la bourcle d affirnation

else
printf("\n--> L EMPRUNTE DU LIVRE N A PAS ETE EFFECTUE.");

}//fermeture de l accolade apres avoir effectuer les opperation si le li

vre existe.
printf("\n\n\t");
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR REMETTRE UN LIVRE DANS LE DOMAINE*/
void remise_l(Reference livre[],int n,int en_nbr_etudiant,struct etudiant en_lis
te_etudiant[100])
{
int tabp[50]; //tableau qui permet d enregistrer les differente position d un l
ivre si il exit plus d une fois
char liv[20],nom_et[30],prenom_et[30] ;
char confirmation[10];
int position; //pour enregistrer la position ou se trouve le livre a remettre
int i,j=0,k,un=0,aide=0,nombre_livre_trou=0;
int oui=0,test=0; //variable permettant de tester si l emprunte a deja ete bien
effectué
printf("\n\tVOUS ETES SUR LE POINT DE REMETTRE UN LIVRE\n");
printf("\t-------------------------------------------");
printf("\n ++> Quel livre voulez vous remettre : ");
fflush(stdin);
gets(liv);
for(i=0;i<n;i++)
{
if((strcmp(liv,livre[i].titre)==0)&&(livre[i].emprunte==1))
{
tabp[j]=i; //tabp[j]=i
j++;
nombre_livre_trou++;
test++;
}
}
if((livre[j].emprunte==1)&&(test==1))
{
printf("\n --> Il exite %d livres correspondant au livre que vous voulez remett
re",nombre_livre_trou);
if(nombre_livre_trou!=0)
{
for(i=0;i<nombre_livre_trou;i++)
{
if(i==0)
printf("\n --> Le %der livre trouve est a la position %d ",i+1
,tabp[i]+1);
else
printf("\n --> Le %de livre trouve est a la position %d ",i+1,tabp[i]+1)
;
}

printf("\n ++> Voulez vous remettre ce livre ? entrez oui ou non: ");
 gets(confirmation);
if((strcmp(confirmation,"oui")==0)||(strcmp(confirmation,"OUI")==0))
{
printf("\n --> Donner le nom de l etudiant: ");
gets(nom_et);
printf("\n --> Donnez le prenom de l etudiant: ");
gets(prenom_et);
for(i=0;(i<en_nbr_etudiant)&&(aide==0);i++)
{
if((strcmp(nom_et,en_liste_etudiant[i].nom)==0)&
&(strcmp(prenom_et,en_liste_etudiant[i].prenom)==0)&&(en_liste_etudiant[i].et_po
cedant_1_l==1))
oui++;
position=i;
}
if(oui==1)
{
en_liste_etudiant[position].et_pocedant_1_l=0;

for(k=0;k<nombre_livre_trou;k++)
{
if((livre[tabp[k]].empru
nte==1)&&(un==0))
{
livre[tabp[k]].emprunte=0;
un++;
}

aide++;
if((livre[tabp[k]].emprunte==0)&&(un==1)&&(en_liste_etudiant[position]
.et_pocedant_1_l==0))
printf("\n\n\t--> VOTRE REMISE A ETE BIEN EFFECTUE");
}
}//fermeture du for
for(i=0;(i<en_nbr_etudiant)&&(aide==0);i++)
{
if((strcmp(nom_et,en_liste_etudiant[i].nom)==0)&
&(strcmp(prenom_et,en_liste_etudiant[i].prenom)==0)&&(en_liste_etudiant[i].et_po
cedant_1_l==1))
printf("\n --> L etudiant possede un livre qu il n a pas encore re
mit.");
aide++;
}
for(i=0;(i<en_nbr_etudiant)&&(aide==0);i++)
{
if((strcmp(nom_et,en_liste_etudiant[i].nom)!=0)&&(str
cmp(prenom_et,en_liste_etudiant[i].prenom)==0))
printf("\n --> Cet etudiant n est pas un etudiant de votre etabli
ssement.");
 aide++;
}
for(i=0;(i<en_nbr_etudiant)&&(aide==0);i++)
{
if((strcmp(nom_et,en_liste_etudiant[i].nom)==0)&&(strcmp(prenom_et,e
n_liste_etudiant[i].prenom)!=0))
printf("\n --> Cet etudiant n est pas un etudiant de votre etabli
ssement.");
else
printf("\n --> Cet etudiant n est pas un etudiant de votre etabliss
ement.");
}
}//fermetu de la boucle de confirmation
else
printf("\n\n\t--> LE LIVRE N A PAS ETE REMI.");
}

}
else
printf("\n --> Le livre %s que vous voulez remettre n est pas un livre emprunte
r, merci de renouveller votre operation ulterieurement.",liv);
printf("\n\n\t");
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&
/*FONCTION POUR SAISIR LES LIVRES DANS LE DOMAINE*/
void saisie(int (*nbre_livre),Reference livre[50],char domaine[30])
{
int i;
char nom_livre[20],auteur[30],edition[30];
char carChoix1[10];
if(*nbre_livre==0)
{
printf("\n\tMERCI DE BIEN VOULOIR SAISIR LES LIVRES DU DOMAINE:\n");
printf("\t--------------------------------------------------");
printf("\n\t%s\n\n",domaine);
do{
printf("\n\n++> Combien de livre voulez vous ajouter: ");
gets(carChoix1);
*nbre_livre=estDigit(carChoix1);
if(*nbre_livre==-1)
printf("\n\t Entrer un choix valide.");
}while(*nbre_livre<0);
printf("\n");
for(i=0;i<(*nbre_livre);i++)
{
printf("\n\n\n\t");
printf("LIVRE %d\n\n",i+1);
printf("\t++> Donner le nom du livre: ");
 fflush(stdin);
gets(nom_livre);
strcpy(livre[i].titre,nom_livre);
printf("\t++> Donner le nom de l auteur: ");
fflush(stdin);
gets(auteur);
strcpy(livre[i].auteur,auteur);
printf("\t++> Donner l edition du livre: ");
fflush(stdin);
gets(edition);
strcpy(livre[i].edition,edition);
do{
printf("\t++> Ce livre correspond aux etudiants du niveau.Notez bien: Comprid
entre 1 et 7: ");
gets(carChoix1);
livre[i].nivo=estDigit(carChoix1);
if((livre[i].nivo<=0)||(livre[i].nivo>7))
printf("\n\t Entrer un choix valide.");
}while((livre[i].nivo<=0)||(livre[i].nivo>7));
livre[i].emprunte=0;
livre[i].nbrEmprunte=0;
printf("\n\t");
system("pause");
system("cls");
}
}
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR AFFICHER LES LIVRES DU DOMAINE*/
void affiche(int n, Reference livre[])
{
printf("\n\tLISTE DES LIVRES\n");
printf("\t----------------\n");
int C;
int i;
int m;
int j;
int verification,aide;
if(n!=0)
{
i=0;
verification=n%3;
if(verification==0)
aide=n/3;
else
aide=(n/3)+1;

while(i<aide)
{
printf("\n\t PAGE - %d -",i+1);
printf("\n\t -----------");
m=3+(3*i);
for(j=(3*i);(j<m)&&(j<n);j++)
{
 printf("\n\n\t Caracteristique du livre %d",j+1);
printf("\n ++> Le titre du livre est: %s.",livre[j].titre);
printf("\n ++> Le nom de l Auteur est du livre est: %s.",livre[i].auteur);
printf("\n ++> L edition du livre est: %s.",livre[i].edition);
printf("\n ++> Ce livre correspond aux etudiants du niveau: %d\n\n\t",livre[i
].nivo);
}
printf("\n++> Tapez sur S pour continuer et sur P pour retourner a la page pr
ecedante.");
fflush(stdin);
C=getchar();
system("cls");
if((C=='S')&&(i!=(n/3)))
{
if((C=='S')&&(verification==0)&&(j==n))
{
if(((C=='S')&&(i==(n/3)-1))||((C==10)&&(i==(n/3))))
{
printf("\n\a ++> Vous etes a la derniere page.\n");
}
}
else
i++;
}
else if((C=='S')&&(i==(n/3)))
{
printf("\n\a ++> Vous etes a la derniere page.\n");
}
else if((C=='P')&&(i!=0))
{
i=i-1;
}
else if((C=='P')&&(i==0))
printf("\n\a ++> Vous etes a la premiere page.\n");

else
break;
}
}
else
{
printf("\n ++> Aucun livre n est enregistre dans ce domaine.\n\n\t");
system("pause");
}
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR AVOIR LES INFORMATION LES LIVRE EMPRUNTE ET NON EMPRUNTE*/

void info(Reference livre[],int n,int emprunte_total)

{
int i,j=0,k=0,emprunte=0,non_emprunte=0;
int plus_lu[50];
int moins_lu[50];
int max1;
int plus_lu1=0; //ce tableau me permet de copier le tableau des infornation des
emprunte de peur de le changer
int min1;
int moins_lu1=0; //ce tableau me permet de copier le tableau des infornation des
emprunte de peur de le changer
int m,mm;
int pos_emp[50],max,min,pos_max,pos_min;
int pos_non_emp[50];
float pourcentage,x;
printf("\n\tJOURNAL DU DOMAINE\n");
printf("\t------------------\n");
for(i=0;i<n;i++)
{
if(livre[i].emprunte==1) //on teste si le livre est emprunte dans
le tableau des emprunte
{
emprunte++;
pos_emp[j]=i;
j++;
}
else
{
non_emprunte++;
pos_non_emp[k]=i;
k++;
}
}
printf("\n --> il existe %d livres dans votre bibliotheque.",n);
if(emprunte==0)
printf("\n --> Aucun livre n est emprunte");
else if(emprunte==1)
printf("\n --> Un livre est actuellement emprunte");
else
printf("\n --> %d livres sont actuellement emprunte\n\n",emprunte);
if(emprunte!=0)
{ for(i=0;i<emprunte;i++)
{
printf("\n\t* %s\n",livre[pos_emp[i]].titre);
}
}
if(non_emprunte==0)
printf("\n --> Aucun livre ne se trouve dans la bibliothque actuellement");
else if(non_emprunte==1)
printf("\n --> Un livre est actuellement dans la bibliotheque");
else
printf("\n --> %d sont actuellement dans la bibliotheque\n",non_emprunte);

if(non_emprunte!=0)
{
for(i=0;i<non_emprunte;i++)
{
printf("\n\t* %s\n",livre[pos_non_emp[i]].titre);
}
}
if(emprunte_total==1)
printf("\n --> Vous avez deja fait au total une emprunte dans ce domaine");
else
printf("\n --> Vous avez deja fait au total un emprunte dans ce domaine",empru
nte_total);
for(i=0;i<n;i++)
{
plus_lu[i]=livre[i].nbrEmprunte; //total_emp est le tableau qui pren
d le nombre de fois que un livre est emprunte
moins_lu[i]=livre[i].nbrEmprunte;
}
max=livre[0].nbrEmprunte;
pos_max=0;
for(i=1;i<n;i++)
{
if(max<livre[i].nbrEmprunte)
{
max=livre[i].nbrEmprunte; //je chercher le livre qui est le plus empru
nté et j emregistre sa position
pos_max=i;
}
}
m=n;
m--;
for(i=pos_max;i<m;i++)
{
plus_lu[i]=plus_lu[i+1]; //ici je fais un decalage a partir de la position du
max que j ai trouvé
} //pour etre sur que j ai uniquement un seul livre qu
i est plus lu que les autre.
max1=max;
for(i=0;i<m;i++)
{
if(max1==plus_lu[i])
plus_lu1++;
}
if(plus_lu1==0)
printf("\n --> Le livre le plus lu est: %s\n",livre[pos_max].titre);
else if(max1==0) //si max1 egal a zero alors aucun livre n est emp
runté et il n affiche rien
printf("\n");
else
{
if(plus_lu1!=0)
printf(" --> Il existe %d livres qui sont beaucoup lu.\n",plus_lu1+1);
}

min=livre[0].nbrEmprunte;
pos_min=0;
for(i=1;i<n;i++)
{
if(min>livre[i].nbrEmprunte)
{
min=livre[i].nbrEmprunte; //je cherche le livre le moin emprunté et j
enregistre sa position
 pos_min=i;
}
}
mm=n;
mm--;
for(i=pos_min;i<mm;i++)
{
moins_lu[i]=moins_lu[i+1];
}
min1=min;
for(i=0;i<mm;i++)
{
if(min1==moins_lu[i]) //on cherche a savoir si il y a seulement un seul
livre qui est moins lu
moins_lu1++;
}
if(moins_lu1==0)
{
if(min1==0)
printf(" --> %s est le livre qui n a jamais ete lu.\n",livre[pos_min].titre);
else
printf(" --> Le livre le moins lu du domaine est: %s\n",livre[pos_min].titre);
}
else if((plus_lu1==moins_lu1)&&(max==0))
printf(" --> Tous les livres de ce domaine ne sont pas lu.\n");
else if((plus_lu1==moins_lu1)&&(max!=0))
printf(" --> Tous les livres de ce domaine sont lu.\n");
else
{
if((moins_lu1!=0)&&(min1==0))
printf(" --> Il existe %d livre qui ne sont pas lu.\n",moins_lu1+1);
else
printf(" --> Lls esiste %d livre qui sont moins lu.\n",moins_lu1+1);
}

x=emprunte;
pourcentage=((x/n)*100);
printf(" --> Le pourcentage de lecture est %f\n\n\t",pourcentage);
system("pause");
system("cls");
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*FONCTION POUR LE DOMAINE */
void gestion_du_domaine(TabGestion *gestDomaine,int variable,int *nbre_etudiant,
struct etudiant liste_etudiant[100],char domaine[30])
//int *n, //nombre de livre
//int *emprunte_du_domaine, //nombre total d emprunte du domaine
//int *nbre_etudiant, //nombre detudiant
//struct caracteristique livre_du_domaine[], //tableau qui enregistre les nom de
s livres
//struct etudiant liste_etudiant[100])//tableau qui enregistre les infos sur les
etudiants
/*gestion_du_domaine(gestionDomaine[choix1-4],&nombre_etudiant,liste_des_etudian
t);*/
{
int *n=&gestDomaine[variable].nombreLivres;
int *emprunte_du_domaine=&gestDomaine[variable].emprunteDomaine;
Reference *livre_du_domaine=gestDomaine[variable].livreDomaine;
int choix;
char carChoix1[10];
saisie(*(&n),livre_du_domaine,domaine);
do
{
printf("\n BIEN VENU DANS LE MENU DU DOMAINE: ");
printf("\n --------------------------------- ");
printf("\n %s\n\n",domaine);
printf("\n > Tapez 1 pour chercher un livre dans ce domaine et l emprunter");
printf("\n > Tapez 2 pour ajouter un livre dans ce domaine");
printf("\n > Tapez 3 pour supprimer un livre dans ce domaine");
printf("\n > Tapez 4 pour remettre un livre dans le domaine");
printf("\n > Tapez 5 pour afficher la liste des livres du domaine");
printf("\n > Tapez 6 pour avoir des information sur les livre de ce domaine");
printf("\n > Tapez 7 pour quitter le domaine");
do
{
printf("\n\n\n\n\t\tENTRER UN CHOIX VALIDE: ");
gets(carChoix1);
choix=estDigit(carChoix1);
}while((choix<=0)||(choix>7));
system("cls");
switch(choix)
{

case 1:recherche_nom(livre_du_domaine,*n,*(&emprunte_du_domaine),liste_etudiant,
&(*nbre_etudiant));
break;
case 2:insertion_livre(livre_du_domaine,*(&n));
break;
case 3: supprimer_livre(livre_du_domaine,*(&n));
break;
case 4:remise_l(livre_du_domaine,*n,*nbre_etudiant,liste_etudiant);
break;
case 5:affiche(*n,livre_du_domaine);
break;
/* ecrire une fonction resort la liste des livre qui sont dans sont dans le doma
ine et
la liste des livre emprunté,le livre le plus lu et celui le moins lu,les pourcenta
ge du trafic*/
case 6:info(livre_du_domaine,*n,*emprunte_du_domaine);
break;
default:
printf("\n\t*** MERCI DE REVENIR AU MENU DE VOTRE BIBLIOTHEQUE ***");
break;
}
}while(choix!=7);
system("cls");
}
//==============================================================================
========================================================================
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void enregistrerListeDomaine(int nbre_domaine,Domaine *liste)
{
int i;
FILE *f;
f=fopen("c:\\liste domaine.txt","w");
if(f==NULL)
{
printf("\a Erreur: impossible d ouvrir le fichier %s.","liste-domaine");
}
else
{
fprintf(f,"%d\n",nbre_domaine);
for(i=0;i<nbre_domaine;i++)
{
fprintf(f,"\n%s\n",liste[i].nomDomaine);
}
}
fclose(f);
}

void restaurerListeDomaine(int *nbre_domaine,Domaine *liste)

{
int i;
FILE *f;
f=fopen("c:\\liste domaine.txt","r");
if(f==NULL)
{
printf("\a Erreur: impossible d\'ouvrir le fichier %s.","liste-domaine")
;
}
else
{
fscanf(f,"%d",&(*nbre_domaine));
for(i=0;i<*nbre_domaine;i++)
{
fscanf(f,"%s",liste[i].nomDomaine);
}
}
fclose(f);
}
void enregistrerListeEtudiant(int nbrEtudiant,struct etudiant *listeEtudiant)
{
int i;
FILE *f;
f=fopen("c:\\liste etudiant.txt","w");
if(f==NULL)
{
printf("\a Erreur: impossible d\'ouvrir le fichier %s.","liste-etudiant"
);
}
else
{
fprintf(f,"%d\n",nbrEtudiant);
for(i=0;i<nbrEtudiant;i++)
{
fprintf(f,"\n%s\n%s\n%d\n%s\n%d\n%d\n%d\n%s\n",listeEtudiant[i].
nom,listeEtudiant[i].prenom,listeEtudiant[i].niveau,listeEtudiant[i].adresse,lis
teEtudiant[i].periode,listeEtudiant[i].nbr_emprunte_par_et,listeEtudiant[i].et_p
ocedant_1_l,listeEtudiant[i].livre_emprunte);
}
}
fclose(f);
}

void restaurerListeEtudiant(int *nbrEtudiant,struct etudiant *listeEtudiant)

{
int i;
FILE *f;
f=fopen("c:\\liste etudiant.txt","r");
if(f==NULL)
{
printf("\a Erreur: impossible d ouvrir le fichier %s.","liste-etudiant")
;
}
else
{
fscanf(f,"%d",&(*nbrEtudiant));
for(i=0;i<*nbrEtudiant;i++)
{
fscanf(f,"%s%s%d%s%d%d%d%s",listeEtudiant[i].nom,listeEtudiant[i
].prenom,&listeEtudiant[i].niveau,listeEtudiant[i].adresse,&listeEtudiant[i].per
iode,&listeEtudiant[i].nbr_emprunte_par_et,&listeEtudiant[i].et_pocedant_1_l,lis
teEtudiant[i].livre_emprunte);
}
}
fclose(f);
}
void enregistrerListeLivre(int nbreDomaine,TabGestion *listeDomaine)
{
int i,j;
FILE *f;
f=fopen("c:\\liste livre.txt","w");
if(f==NULL)
{
printf("\a Erreur: impossible d\'ouvrir le fichier %s.","liste-livre");
}
else
{
 for(i=0;i<nbreDomaine;i++)
{
fprintf(f,"\n%d\n%d\n%d\n",nbreDomaine,listeDomaine[i].nombreLivres,list
eDomaine[i].emprunteDomaine);
for(j=0;j<listeDomaine[i].nombreLivres;j++)
{
fprintf(f,"\n%s\n%s\n%s\n%d\n%d\n%d\n",listeDomaine[i].livreDoma
ine[j].titre,listeDomaine[i].livreDomaine[j].auteur,listeDomaine[i].livreDomaine
[j].edition,listeDomaine[i].livreDomaine[j].nivo,listeDomaine[i].livreDomaine[j]
.emprunte,listeDomaine[i].livreDomaine[j].nbrEmprunte);
}
}
}
fclose(f);
}

void restaurerListeLivre(int *nbreDomaine,TabGestion *listeDomaine)

{
int i,j;
FILE *f;
f=fopen("c:\\liste livre.txt","r");
if(f==NULL)
{
printf("\a Erreur: impossible d\'ouvrir le fichier %s.","liste-livres");
}
else
{
for(i=0;i<*nbreDomaine;i++)
{
fscanf(f,"%d%d%d",&(*nbreDomaine),&listeDomaine[i].nombreLivres,&listeDomaine
[i].emprunteDomaine);
for(j=0;j<listeDomaine[i].nombreLivres;j++)
{
fscanf(f,"%s%s%s%d%d%d",listeDomaine[i].livreDomaine[j].titre,li
steDomaine[i].livreDomaine[j].auteur,listeDomaine[i].livreDomaine[j].edition,&li
steDomaine[i].livreDomaine[j].nivo,&listeDomaine[i].livreDomaine[j].emprunte,&li
steDomaine[i].livreDomaine[j].nbrEmprunte);
}
}
}
fclose(f);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//==============================================================================
========================================================================
/*PROGRAMME POUR GERER LA BIBLIOTHEQUE*/
main ()
{
/*variable pour la gestion de l etudiant*/
int nombre_etudiant=0;
struct etudiant liste_des_etudiant[100];
/*variable du void main*/
int i,choix1,numero_D=4;
int nbre_domaine=0;
char carchoix[10];
Domaine listeDomaine[50];
char domaine[30];
TabGestion gestionDomaine[50];
/*ici on appel toute les fonction qui vons restauré les données */
restaurerListeDomaine(&nbre_domaine,listeDomaine);
restaurerListeEtudiant(&nombre_etudiant,liste_des_etudiant);
restaurerListeLivre(&nbre_domaine,gestionDomaine);
system("cls");
/* appel de la fonction qui vas saisir le nom des domaine*/
if(nbre_domaine==0)
{
saisie_domaine(&nbre_domaine,listeDomaine);
}
do
{
printf("\n\n\tBIEN VENU DANS LE MENU DE VOTRE BIBLIOTHEQUE\n");
printf("\t--------------------------------------------\n");
printf("\n\ntapez 1 pour enregistrer les information sur l\'etudiant");
printf("\ntapez 2 pour ajouter un domaine");
printf("\ntapez 3 pour supprimer un domaine");
for(i=0;i<nbre_domaine;i++)
{
printf("\ntapez %d pour acceder au menu de %s",numero_D,listeDom
aine[i].nomDomaine);
numero_D++;
}
numero_D=4;//pour ke quand ton entre a nouveau dans le domaine il respect
e les norme
printf("\ntapez 0 pour quitter le programme\n");
do
{
printf("\n\n\t ENTRE UN CHOIX VALIDE: ");
gets(carchoix);
choix1=estDigit(carchoix);
if(0>choix1||choix1>(nbre_domaine+3))
{
printf("\n\n\n\t--> ");
system("pause");
}
}while(0>choix1||choix1>(nbre_domaine+3));
system("cls");
if(choix1==1)
gestion_etudiant(liste_des_etudiant,&nombre_etudiant);
else if(choix1==2)
{
ajouter_domaine(&nbre_domaine,listeDomaine);
}
else if(choix1==3)
 supprimer_domaine(&nbre_domaine,listeDomaine);
else if(choix1>=4)
{
strcpy(domaine,listeDomaine[choix1-4].nomDomaine);
gestion_du_domaine(gestionDomaine,choix1-4,&nombre_etudiant,liste_des_etu
diant,domaine);

}
else{
if(choix1==0){
printf("Fermeture de la bibliotheque et merci de votre fidelite\n\n\n\t");
}
}
}while(choix1!=0);
system("pause");
system("cls");
enregistrerListeEtudiant(nombre_etudiant,liste_des_etudiant);
enregistrerListeLivre(nbre_domaine,gestionDomaine);
enregistrerListeDomaine(nbre_domaine,listeDomaine);
}