Une partie de mon programme ne fonctionne pas

#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   Aucun caractere ne doit figurer dans votre CHOIX. ");
      else
		printf("\n\aOperation invalide car vous avez introduit %d caracteres.\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_etudiant)  //*nbr_etudiant est egal nombre d 'etudiant regulier dans l etablissement
{

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 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_etudiant[*(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 etablissement.\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_etudiant[*(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 etablissement.\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 est 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_etudiant[j].periode);
printf("\n    --> Le nombre d\'empunte fais par cet etudiant est: %d",en_liste_etudiant[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 precedante 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 etabblissement: ");
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 partir 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 etablissement");
	printf("\n * Voulez vous vraiment le supprimez cet etudiant de l etablissement;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_etudiant[pos].periode);
printf("\n    --> Le nombre d\'empunte fais par cet etudiant est: %d",en_liste_etudiant[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 envoie 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_liste_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 bibliotheque.\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 emprunté
   liv[*m-1].nbrEmprunte=0;     //tableau qui enregistre le nomde fois qu un livre 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 du 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 positions
de ce livre cherche dans tabp et c est grace a cela nous allons allé modifier le tableau 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 etudiant 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 livre 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 une 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_livre);
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].nom)==0)&&(strcmp(prenom_et,en_liste_etudiant[i].prenom)==0))                                                            //pour montre que le nom n est pas correspondant
            	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 emprunter 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 comme etudiant regulier, ");
             printf("\nVoulez vous l enregistrer? entrer oui ou non pour la validation 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 domaine.
                      ajout(en_liste_etudiant,*(&en_nbr_etudiant));


      						//ont appel la fontion pour remplir les info de l etudiant a la position (*nbr_etudiant-1)
      						// car dans borlan les tableau commence a zero

                         do{
                     printf("\n\n--> Pour une dure de combien de jour: ");
                     gets(carChoix1);
                     en_liste_etudiant[*en_nbr_etudiant-1].periode=estDigit(carChoix1);
                     }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_emprunte,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_liste_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_pocedant_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 pas 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(carChoix1);
                     }while(en_liste_etudiant[etudiant_trouve].periode==-1);

               		en_liste_etudiant[etudiant_trouve].nbr_emprunte_par_et=en_liste_etudiant[etudiant_trouve].nbr_emprunte_par_et+1;
							en_liste_etudiant[etudiant_trouve].et_pocedant_1_l=1;
                     strcpy(en_liste_etudiant[etudiant_trouve].livre_emprunte,liv);

            			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[etudiant_trouve].et_pocedant_1_l==1))
         			 printf("\n\n\t--> L\'emprunte a ete bien effectue pour l\'etudiant %s %s  ",nom_et,prenom_et);
                  }
               }
               else
               printf("\n  --> Cet etudiant pocede deja un livre qu il n a pas encore 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 livre 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_liste_etudiant[100])
{

int tabp[50];  //tableau qui permet d enregistrer les differente position d un livre 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 remettre",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_pocedant_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]].emprunte==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_pocedant_1_l==1))
             printf("\n -->  L etudiant possede un livre qu il n a pas encore remit.");
             aide++;
             }
            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))
              printf("\n -->  Cet etudiant n est pas un etudiant de votre etablissement.");
            aide++;
            }
           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))
              printf("\n -->  Cet etudiant n est pas un etudiant de votre etablissement.");
           else
            printf("\n -->  Cet etudiant n est pas un etudiant de votre etablissement.");
           }
          }//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 emprunter, 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 precedante.");
   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",emprunte_total);
for(i=0;i<n;i++)
{
plus_lu[i]=livre[i].nbrEmprunte;             //total_emp est le tableau qui prend 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 emprunté 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 qui 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 emprunté 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 des livres
//struct etudiant liste_etudiant[100])//tableau qui enregistre les infos sur les etudiants
/*gestion_du_domaine(gestionDomaine[choix1-4],&nombre_etudiant,liste_des_etudiant);*/
{
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 domaine et
la liste des livre emprunté,le livre le plus lu et celui le moins lu,les pourcentage 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,listeEtudiant[i].periode,listeEtudiant[i].nbr_emprunte_par_et,listeEtudiant[i].et_pocedant_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].periode,&listeEtudiant[i].nbr_emprunte_par_et,&listeEtudiant[i].et_pocedant_1_l,listeEtudiant[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,listeDomaine[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].livreDomaine[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,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);
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//======================================================================================================================================================

/*PROGRAMME POUR GERER LA BIBLIOTHEQUE*/

void 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,listeDomaine[i].nomDomaine);
		numero_D++;
		}
       numero_D=4;//pour ke quand ton entre a nouveau dans le domaine il respecte 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_etudiant,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);
}

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);