mon progz de fin d'année, pour vous chers admirateurs. je vous aime mes fans, propagez mon programme à titre d'exemple d'excellence programatissimeuse, merci.  

# include <stdio.h>
# include <stdlib.h>
# include <alloc.h>
# include <string.h>
 
# define ENTR "c:\\etudiant\\entre.dat"
# define STA "c:\\etudiant\\stag.dat"
# define TEMP "c:\\etudiant\\temp.dat"
# define TMP "c:\\etudiant\\tmp.dat"
# define NB_SYNO 10
 
struct entreprise {
    int cle;
    char nom[25+1];
    char addresse[25+1];
    int codepost;
    char ville[25+1];
    char tel[20+1];
    char secteur[20+1];
                };
struct stagiaire
    {
    int cle;
    char nom[25+1];
    int cle_etr;
    char prenom[25+1];
    char addresse[25+1];
    int codepost;
    char ville[25+1];
    char tel[20+1];
    char tel_ent[20+1];
                };
struct liste_ent
    {
    int cle;
    char nom[25+1];
    int posi;
    struct liste_ent *suivant;
    };
struct liste_sta
    {
    int cle;
    char nom[25+1];
    int posi;
    struct liste_sta *suivant;
    };
struct ple_ent
   {
   int posi;
   struct ple_ent *suivant;
   };
struct ple_sta
   {
   int posi;
   struct ple_sta *suivant;
   };
struct temp
   {
   int cle_ent;
   int cle_sta;
   int posi_ent;
   int posi_sta;
   };
struct multi_ent_sect
    {
    char secteur[25+1];
    struct liste_ent *prem_ent;
    struct multi_ent_sect *suivant;
    };
struct multi_ent_sta
    {
    int cle_ent;
    struct liste_sta *prem_sta;
             struct multi_ent_sta *suivant;
    };
crea_temp();
add_ent(struct liste_ent**,struct multi_ent_sect**,struct ple_ent**);
add_sta(struct liste_sta** ,struct multi_ent_sta** ,struct liste_ent**,struct ple_sta**);
modif_sup_ent(struct liste_ent**,struct multi_ent_sect**,struct ple_ent**,struct multi_ent_sta**);
modif_sup_sta(struct liste_sta**,struct multi_ent_sta**,struct liste_ent**ind_nm_ent,struct ple_sta**);
modipent(struct liste_ent**,struct multi_ent_sect**,int);
modipsta(struct liste_sta**,struct multi_ent_sta**,struct liste_ent**ind_nm_ent,int);
afpent(struct entreprise*);
afpsta(struct stagiaire*);
aff_sec_ent();
aff_sec_sta();
afpent_ind(struct liste_ent*);
afpsta_ind(struct liste_sta*);
aff_sect_ent(struct multi_ent_sect*);
aff_sect_ent_spec(struct multi_ent_sect*);
afpent_sta(struct multi_ent_sta*);
afpent_sta_spec(struct multi_ent_sta*);
afpsta_sect(struct multi_ent_sect*,struct multi_ent_sta*);
afpsta_sect(struct multi_ent_sect*,struct multi_ent_sta*);
insert_ent(struct liste_ent**,int,char *,int);
insert_sta (struct liste_sta**,int,char *,int);
insert_multi_ent_sect(struct multi_ent_sect**,struct entreprise*,int);
insert_multi_ent_sta(struct multi_ent_sta**,struct stagiaire*,int);
new_ent (char * ,struct liste_ent **,int,struct liste_ent*,int );
new_sta (char * ,struct liste_sta **,int,struct liste_sta*,int );
seek_ent(struct liste_ent * ,char *,int []);
seek_sta(struct liste_sta *,char *,int []);
int seek_ent_sta(struct multi_ent_sta*,int);
del_ent(struct liste_ent**,int);
del_sta(struct liste_sta**,int);
del_multi_ent_sect(struct multi_ent_sect**,struct entreprise*,int);
del_ent_sta(struct multi_ent_sta**,int,int);
push_ent(struct ple_ent**,int);
push_sta(struct ple_sta**,int);
pop_ent(struct ple_ent**);
pop_sta(struct ple_sta**);
reorga(struct liste_ent**,struct liste_sta**,struct multi_ent_sect**,struct multi_ent_sta**,struct ple_ent**,struct ple_sta**);
compact(struct liste_ent**,struct liste_sta**,struct multi_ent_sect**,struct multi_ent_sta**,struct ple_ent**,struct ple_sta**);
 
main ()
{
struct ple_ent *pile_ent;
struct ple_sta *pile_sta;
struct liste_ent *ind_nm_ent;
struct liste_sta  *ind_nm_sta;
struct multi_ent_sect *ind_sect_ent;
struct multi_ent_sta *ind_ent_sta;
int rep1,rep2,rep3;
 
crea_temp();
ind_nm_ent=NULL;
ind_nm_sta=NULL;
ind_sect_ent=NULL;
ind_ent_sta=NULL;
pile_ent=NULL;
pile_sta=NULL;
reorga(&ind_nm_ent,&ind_nm_sta,&ind_sect_ent,&ind_ent_sta,&pile_ent,&pile_sta);
do{
  do{
 clrscr();
 printf("MENU PRINCIPAL\n" ) ;
 printf("1)Menu Ajout de fiches\n" );
 printf("2)Modification ou supression de fiches\n" );
 printf("3)Affichage de fiches\n" );
 printf("4)Fonction de compactage\n" );
 printf("5)Quitter" );
 fflush(stdin);
 scanf("%d",&rep1);
 }
  while(rep1<1 || rep1>5);
  switch (rep1)
 {
 case (1):
  {
  do {
   do {
    rep2=0;
    clrscr();
    printf("1)Ajout d'une entreprise\n" );
    printf("2)Ajout d'un  stagiaire\n" );
    printf("3)quitter" );
    fflush(stdin);
    scanf("%d",&rep2);
    }
   while(rep2<1 || rep2>3);
   switch (rep2)
    {
    case(1):
     {
     clrscr();
     add_ent(&ind_nm_ent,&ind_sect_ent,&pile_ent);
     break;
     }
    case(2):
     {
                    clrscr();
     add_sta(&ind_nm_sta,&ind_ent_sta,&ind_nm_ent,&pile_sta);
     break;
     }
    }
     }
  while (rep2!=3);
  break;
  }
 case(2):
  {
  do {
     do {
     rep2=0;
     clrscr();
     printf("1)Recherche d'une entreprise\n" );
     printf("2)Recherche d'un stagiaire\n" );
     printf("3)Quitter" );
     fflush(stdin);
     scanf("%d",&rep2);
     }
     while(rep2<1 || rep2>3);
     switch (rep2)
   {
   case (1):
    {
                clrscr ();
    modif_sup_ent(&ind_nm_ent,&ind_sect_ent,&pile_ent,&ind_ent_sta);
    break;
    }
   case (2):
    {
    clrscr ();
    modif_sup_sta(&ind_nm_sta,&ind_ent_sta,&ind_nm_ent,&pile_sta);
    break;
    }
   }
    }
  while(rep2!=3);
  break;
  }
 case (3):
  {
  do {
   do {
    rep2=0;
    clrscr();
    printf("1)Affichage des entreprises\n" );
    printf("2)Affichage des stagiaires\n" );
    printf("3)Quitter" );
    fflush(stdin);
    scanf("%d",&rep2);
    }
   while(rep2<1 || rep2>3);
   switch (rep2)
     {
     case(1):
      {
      do {
       do {
        rep3=0;
        clrscr();
        printf("1)Affichage sequentiel des entreprises\n" );
        printf("2)Affichage des entreprises triees par nom\n" );
        printf("3)Affichage des entreprises par secteur\n" );
        printf("4)Affichage des entreprises d'un secteur specifique\n" );
        printf("5)Quitter" );
        fflush(stdin);
        scanf("%d",&rep3);
        }
       while(rep3<1 || rep3>5);
       switch (rep3)
        {
        case(1):
          {
          aff_sec_ent();
          break;
          }
        case(2):
         {
         afpent_ind(ind_nm_ent);
         break;
         }
        case(3):
         {
         aff_sect_ent(ind_sect_ent);
         break;
         }
        case(4):
         {
         aff_sect_ent_spec(ind_sect_ent);
         break;
         }
        }
         }
      while (rep3!=5);
      break;
      }
     case(2):
      {
                        do {
       do {
        rep3=0;
        clrscr();
        printf("1)Affichage sequentiel des stagiaires\n" );
        printf("2)Affichage des stagiaires tries par nom\n" );
        printf("3)Affichage des stagiaires par entreprise\n" );
        printf("4)Affichage des stagiaires d'une entreprise specifique\n" );
        printf("5)Affichage des stagiaires par secteur\n" );
        printf("6)Affichage des stagiaires d'un secteur specique\n" );
        printf("7)quitter" );
        fflush(stdin);
        scanf("%d",&rep3);
        }
       while(rep3<1 || rep3>7);
       switch (rep3)
        {
        case(1):
         {
         aff_sec_sta();
         break;
          }
        case(2):
         {
         afpsta_ind(ind_nm_sta);
         break;
         }
        case(3):
         {
         afpent_sta(ind_ent_sta);
         break;
         }
                                case(4):
         {
         afpent_sta_spec(ind_ent_sta);
         break;
         }
        case(5):
         {
         afpsta_sect(ind_sect_ent,ind_ent_sta);
         break;
         }
        case(6):
         {
         afpsta_sect_spec(ind_sect_ent,ind_ent_sta);
         break;
         }
        }
       }
      while (rep3!=7);
      break;
      }
     }
  }
  while(rep2!=3);
 break;
 }
  case(4):
  {
  compact(&ind_nm_ent,&ind_nm_sta,&ind_sect_ent,&ind_ent_sta,&pile_ent,&pile_sta);
  break;
  }
  }
}
while (rep1!=5);
}
 
 
 
/****************FONCTION DE CREATION DU FICHIER TEMP***********************/
 
crea_temp()
{
FILE *ptemp;
int i;
struct temp tmp;
 
ptemp=fopen(TEMP,"r+b" );
if(!ptemp)
 {
 ptemp=fopen(TEMP,"wb" );
 tmp.cle_ent=0;
 tmp.cle_sta=0;
 tmp.posi_ent=0;
 tmp.posi_sta=0;
 fwrite(&tmp,sizeof(struct temp),1,ptemp);
 }
fclose(ptemp);
}
 
 
/*******************FONCTION D'AJOUT D'UN RECORD ENTTREPRISE***************/
 
add_ent(struct liste_ent **ind_nm_ent,struct multi_ent_sect **ind_sect_ent,struct ple_ent **pile_ent)
{
char essai[128],rep;
FILE *ptemp,*pent;
struct entreprise tmp;
struct temp tmp_temp;
do {
                clrscr();
 printf("\nEntrer le nom de l'entreprise:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un nom de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
strcpy(tmp.nom,essai);
do {
 printf("\nEntrer l'addresse de l'entreprise:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une addresse de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
strcpy(tmp.addresse,essai);
do {
 tmp.codepost=0;
 printf("\nEntrer le code postal de l'entreprise, celui-ci doit etre compris entre 1000 et 9999 inclus :   " );
 fflush(stdin);
 scanf("%d",&tmp.codepost);
 }
while(tmp.codepost <1000 ||tmp.codepost>9999);
do {
 printf("\nEntrer la ville de l'entreprise:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une ville de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
strcpy(tmp.ville,essai);
do {
 printf("\nEntrer le numéro de  téléphone de l'entreprise:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>20) printf("\nVous devez entrer un numero de telephone de maximum 20 caracteres" );
 }
while (strlen(essai)>20);
strcpy(tmp.tel,essai);
do {
 printf("\nEntrer le secteur d'activite de l'entreprise:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un intitule de secteur de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
strcpy(tmp.secteur,essai);
do
  {
  printf("Etes vous sur de vouloir ajouter cette fiche(o/n)?" );
  fflush(stdin);
  rep=getchar();
  rep=tolower(rep);
  }
while(rep!='o' && rep!='n');
if (rep=='o')
   {
   ptemp=fopen(TEMP,"r+b" );
   pent=fopen(ENTR,"r+b" );
   if (!pent) pent=fopen(ENTR,"wb" );
   fread(&tmp_temp,sizeof(struct temp),1,ptemp);
   tmp.cle=tmp_temp.cle_ent;
   if(*pile_ent==NULL)
   {
   fseek(pent,sizeof(struct entreprise)*tmp_temp.posi_ent,SEEK_SET);
   insert_ent(ind_nm_ent,tmp.cle,tmp.nom,tmp_temp.posi_ent);
   insert_multi_ent_sect(ind_sect_ent,&tmp,tmp_temp.posi_ent);
      tmp_temp.posi_ent++;
   }
   else
  {
  fseek(pent,sizeof(struct entreprise)* (*pile_ent)->posi,SEEK_SET);
  insert_ent(ind_nm_ent,tmp_temp.cle_ent,tmp.nom,(*pile_ent)->posi);
  insert_multi_ent_sect(ind_sect_ent,&tmp,(*pile_ent)->posi);
  pop_ent (pile_ent);
  }
   fwrite(&tmp,sizeof(struct entreprise),1,pent);
   fclose(pent);
   tmp_temp.cle_ent++;
   rewind(ptemp);
   fwrite(&tmp_temp,sizeof(struct temp),1,ptemp);
   fclose(ptemp);
   }
}
 
 
/***************************FONCTION D'AJOUT D'UN RECORD STAGIAIRE*******/
 
add_sta (struct liste_sta **ind_nm_sta,struct multi_ent_sta **ind_ent_sta,struct liste_ent **ind_nm_ent,struct ple_sta **pile_sta)
{
char essai[128],nomch[25+1],rep,rep2;
int vec[10],i;
FILE *ptemp,*psta,*pent;
struct stagiaire tmp;
struct temp tmp_temp;
struct entreprise tmp_ent;
 
if (*ind_nm_ent==NULL) {printf("Aucune entreprise existante, vous devez d'abord en entrer une!" );fflush(stdin);getch();}
else {
pent=fopen(ENTR,"r+b" );
do {
 printf("\nEntrer le nom du stagiaire:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un nom de stagiaire de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
strcpy(tmp.nom,essai);
do {
 printf("\nEntrer le prenom du stagiaire:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un prenom de stagiaire de maximum 25 caractere" );
 }
while (strlen(essai)>25);
strcpy(tmp.prenom,essai);
do {
 printf("\nEntrer l'addresse du stagiaire:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une addresse de stagiaire de maximum 25 caractere" );
 }
while (strlen(essai)>25);
strcpy(tmp.addresse,essai);
do {
   tmp.codepost=0;
   printf("\nEntrer le code postal du stagiaire,celui-ci doit etre entre 1000 et 9999 inclus:   " );
   fflush(stdin);
   scanf("%d",&tmp.codepost);
   }
while(tmp.codepost <1000 ||tmp.codepost>9999);
do {
 printf("\nEntrer la ville du stagiaire:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une ville de maximum 25 caractere" );
 }
while (strlen(essai)>25);
strcpy(tmp.ville,essai);
do {
 printf("\nEntrer le numero de telephone prive du stagiaire:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>20) printf("\nVous devez entrer un numero de telephone de maximum 20 caractere" );
 }
while (strlen(essai)>20);
strcpy(tmp.tel,essai);
do {
 printf("\nEntrer le numero de telephone de l'entreprise du stagiaire:   " );
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>20) printf("\nVous devez entrer un numero de telephone de maximum 20 caractere" );
 }
while (strlen(essai)>20);
strcpy(tmp.tel_ent,essai);
do
   {
 printf ("\nEntrez le nom de l'entreprise cherchee: " );
 fflush (stdin);
 gets (nomch);
 seek_ent (*ind_nm_ent,nomch,vec);
 rep='x';
 i=0;
 if (vec[i]!=-1)
    {
    while (vec[i]!=-1 && rep!='O' && rep!='A')
    {
    rewind (pent);
    fseek (pent,vec[i]*sizeof(struct entreprise),SEEK_SET);
    fread(&tmp_ent,sizeof(struct entreprise),1,pent);
    clrscr();
    afpent(&tmp_ent);
    do {
    if(vec[i+1]!=-1) printf ("\nAppuier sur O pour mettre cette fiche N pour voir la fiche suivante  A pour Annuler: " );
    else printf ("\nAppuier sur O pour mettre cette fiche A pour Annuler: " );
    fflush (stdin);
    rep=getchar ();
    rep=toupper (rep);
    }
    while (rep!='A' &&  rep!='O' && rep!='N');
    if (rep=='O')
    {
    tmp.cle_etr=tmp_ent.cle;
    }
    i++;
    }
    }
  else
   {
   printf ("\nCe nom n'existe pas\n" );
   do {
    printf ("\nO pour rechercher une autre entreprise A pour Annuler: " );
    fflush (stdin);
    rep2=getchar ();
    rep2=toupper (rep2);
    }
   while (rep2!='A' &&  rep2!='O');
   }
 }
while (rep!='O' && rep2!='A');
if (rep=='O')
   {
 do
   {
   printf("Voulez etes sur de vouloir ajouter cette fiche(o/n)?" );
   fflush(stdin);
   rep=getchar();
   rep=tolower(rep);
   }
 while(rep!='o' && rep!='n');
   }
}
if(rep=='o')
  {
  ptemp=fopen(TEMP,"r+b" );
  psta=fopen(STA,"r+b" );
   if (!psta) psta=fopen(STA,"wb" );
  fread(&tmp_temp,sizeof(struct temp),1,ptemp);
  tmp.cle=tmp_temp.cle_sta;
  if(*pile_sta==NULL)
 {
 fseek(psta,sizeof(struct stagiaire)*tmp_temp.posi_sta,SEEK_SET);
 insert_sta(ind_nm_sta,tmp.cle,tmp.nom,tmp_temp.posi_sta);
 insert_multi_ent_sta(ind_ent_sta,&tmp,tmp_temp.posi_sta);
 tmp_temp.posi_sta++;
 }
  else
 {
 fseek(psta,sizeof(struct stagiaire)*(*pile_sta)->posi,SEEK_SET);
 insert_sta(ind_nm_sta,tmp.cle,tmp.nom,(*pile_sta)->posi);
 insert_multi_ent_sta(ind_ent_sta,&tmp,(*pile_sta)->posi);
 pop_sta (pile_sta);
 }
  fwrite(&tmp,sizeof(struct stagiaire),1,psta);
  tmp_temp.cle_sta++;
  rewind(ptemp);
  fwrite(&tmp_temp,sizeof(struct temp),1,ptemp);
  fclose(ptemp);
  fclose(psta);
  }
fclose(pent);
}
 
 
/******FONCTION DE MODIFICATION OU DE SUPRESSION D'UNE ENTREPRISE************/
 
modif_sup_ent(struct liste_ent **ind_nm_ent,struct multi_ent_sect **ind_sect_ent,struct ple_ent **pile_ent,struct multi_ent_sta **ind_ent_sta)
{
char essai[128],nomch[25+1],rep,rep2;
int vec[10],i,valid;
FILE *pent;
struct stagiaire tmp;
struct entreprise tmp_ent;
 
pent=fopen(ENTR,"r+b" );
printf ("Entrez le nom de l'entreprise  recherchee:   " );
fflush (stdin);
gets (nomch);
seek_ent (*ind_nm_ent,nomch,vec);
rep='x';
i=0;
if (vec[i]!=-1)
   {
 while (vec[i]!=-1  && rep!='A')
  {
  fseek (pent,vec[i]*sizeof(struct entreprise),SEEK_SET);
  fread(&tmp_ent,sizeof(struct entreprise),1,pent);
  clrscr();
  afpent(&tmp_ent);
  do {
   if(vec[i+1]!=-1) printf ("\n M pour Modifier \n S pour Suprimer \n A pour Annuler \n N pour Next: " );
   else printf ("\n M pour Modifier \n S pour Suprimer \n A pour Annuler: " );
   fflush (stdin);
   rep=getchar ();
   rep=toupper (rep);
   }
  while (rep!='A' && rep!='S' && rep!='M' && rep!='N');
  if (rep=='M')
   {
   modipent(ind_nm_ent,ind_sect_ent,vec[i]);
   }
   else
    {
    if (rep=='S')
     {
     valid=seek_ent_sta(*ind_ent_sta,tmp_ent.cle);
     if (valid==0)
      {
      del_ent (ind_nm_ent,vec[i]);
      del_multi_ent_sect(ind_sect_ent,&tmp_ent,vec[i]);
      tmp_ent.cle=-1;
      fseek (pent,vec[i]*sizeof(struct entreprise),SEEK_SET);
      fwrite(&tmp_ent,sizeof(struct entreprise),1,pent);
      push_ent (pile_ent,vec[i]);
      }
     else {printf("Vous devez supprimer les stagiaires de cette entreprise encore présent" );}
     }
     }
    i++;
  }
 }
 else { printf ("\nEntreprise non trouvee" );fflush (stdin); getch ();}
fclose(pent);
}
 
 
/******FONCTION DE MODIFICATION OU DE SUPRESSION D'UN STAGIAIRE**************/
 
modif_sup_sta(struct liste_sta **ind_nm_sta,struct multi_ent_sta **ind_ent_sta,struct liste_ent **ind_nm_ent,struct ple_sta **pile_sta)
{
char essai[128],nomch[25+1],rep,rep2;
int vec[10],i;
FILE *psta;
struct stagiaire tmp_sta;
 
psta=fopen(STA,"r+b" );
printf ("Entrez le nom du stagiaire recherche:   " );
fflush (stdin);
gets (nomch);
rep='x';
i=0;
seek_sta(*ind_nm_sta,nomch,vec);
if (vec[i]!=-1)
   {
 while (vec[i]!=-1  && rep!='A')
  {
  fseek (psta,vec[i]*sizeof(struct stagiaire),SEEK_SET);
  fread(&tmp_sta,sizeof(struct stagiaire),1,psta);
  clrscr();
  afpsta(&tmp_sta);
  do {
   if(vec[i+1]!=-1) printf ("\n  M pour Modifier\n S pour Suprimer \n A pour Annuler \n N pour Next: " );
   else printf ("\n  M pour Modifier \n S pour Suprimer \n A pour Annuler: " );
   fflush (stdin);
   rep=getchar ();
   rep=toupper (rep);
   }
  while (rep!='A' && rep!='S' && rep!='M' && rep!='N');
  if (rep=='M')
   {
   modipsta(ind_nm_sta,ind_ent_sta,ind_nm_ent,vec[i]);
   }
  else { if (rep=='S')
    {
    del_sta (ind_nm_sta,vec[i]);
    del_ent_sta(ind_ent_sta,tmp_sta.cle_etr,vec[i]);
    tmp_sta.cle=-1;
    fseek (psta,vec[i]*sizeof(struct stagiaire),SEEK_SET);
    fwrite(&tmp_sta,sizeof(struct stagiaire),1,psta);
    push_sta (pile_sta,vec[i]);
    }
     }
   i++;
   }
   }
  else { printf ("\nCe nom de stagiaire n'existe  pas!" );fflush (stdin); getch ();}
fclose(psta);
}
 
 
/*************FONCTION DE MODIFICATION D'UN RECORD ENTREPRISE*************/
 
modipent(struct liste_ent **ind_nm_ent,struct multi_ent_sect **ind_sect_ent,int posi)
{
char essai[128],rep;
struct entreprise tmp,old;
FILE *pent;
 
pent=fopen(ENTR,"r+b" );
fseek(pent,sizeof(struct entreprise)*posi,SEEK_SET);
fread(&tmp,sizeof(struct entreprise),1,pent);
fseek(pent,sizeof(struct entreprise)*posi,SEEK_SET);
fread(&old,sizeof(struct entreprise),1,pent);
do {
 printf("\nEntrer le nouveau nom de l'entreprise\n appuyez sur ENTER si vous voulez garder %s comme nom:   ",tmp.nom);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un nom d'entreprise de maximum 25 caractere" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.nom,essai);
do {
 printf("\nEntrer la nouvelle addresse de l'entreprise\n appuyez sur ENTER si vous voulez garder %s comme addresse:   ",tmp.addresse);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une addresse d'entreprise de maximum 25 caractere" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.addresse,essai);
do {
 tmp.codepost=0;
 printf("\nEntrer le code postal de l'entreprise, celui-ci doit etre compris entre 1000 et 9999 inclus:   " );
 fflush(stdin);
 scanf("%d",&tmp.codepost);
 }
while(tmp.codepost <1000 ||tmp.codepost>9999);
do {
 printf("\nEntrer la nouvelle ville de l'entreprise\n appuyez sur ENTER si vous voulez garder %s comme ville:   ",tmp.ville);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\n\nVous devez entrer une ville de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.ville,essai);
do {
 printf("\nEntrer le nouveau numero de telephone de l'entreprise\n appuyez sur ENTER si vous voulez garder %s comme telephone:   ",tmp.tel);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>20) printf("\nVous devez entrer un numero de telephone de maximum 20 caracteres" );
 }
while (strlen(essai)>20);
if (strlen(essai)!=0) strcpy(tmp.tel,essai);
do {
 printf("\nEntrer le nouveau  secteur d'activite de l'entreprise\n appuyez sur ENTER si vous voulez garder %s comme secteur d'activite:   ",tmp.secteur);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un intitule de secteur de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.secteur,essai);
do
  {
  printf("\n Etes vous sur de vouloir modifier cette fiche(o/n)?" );
  fflush(stdin);
  rep=getchar();
  rep=tolower(rep);
  }
while(rep!='o' && rep!='n');
if (rep=='o')
  {
  del_ent (ind_nm_ent,posi);
  del_multi_ent_sect(ind_sect_ent,&old,posi);
  fseek (pent,posi*sizeof(struct entreprise),SEEK_SET);
  fwrite(&tmp,sizeof(struct entreprise),1,pent);
  insert_ent(ind_nm_ent,tmp.cle,tmp.nom,posi);
  insert_multi_ent_sect(ind_sect_ent,&tmp,posi);
  }
fclose(pent);
}
 
 
/**************FONCTION DE MODIFICATION D'UN RECORD STAGIAIRE************/
 
modipsta(struct liste_sta**ind_nm_sta,struct multi_ent_sta **ind_ent_sta,struct liste_ent**ind_nm_ent,int posi)
{
char essai[128],nomch[128],rep,rep2;
int i,vec[NB_SYNO];
struct stagiaire tmp,old;
struct entreprise tmp_ent;
FILE *pent,*psta;
 
pent=fopen(ENTR,"rb" );
psta=fopen(STA,"r+b" );
fseek(psta,sizeof(struct stagiaire)*posi,SEEK_SET);
fread(&tmp,sizeof(struct stagiaire),1,psta);
fseek(psta,sizeof(struct stagiaire)*posi,SEEK_SET);
fread(&old,sizeof(struct stagiaire),1,psta);
do {
 printf("\Entrer le nom du stagiaire \n appuyez sur ENTER si vous voulez garder %s comme nom: ",tmp.nom);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un nom de stagiaire de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.nom,essai);
do {
 printf("\nEntrer le prenom du stagiaire\n appuyez sur ENTER si vous voulez garder %s comme prenom: ",tmp.prenom);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer un prenom de stagiaire de maximum 25 caractere" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.prenom,essai);
do {
 printf("\nEntrer l'addresse du stagiaire\n appuyez sur  ENTER si vous voulez garder %s comme addresse: ",tmp.addresse);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une addresse de stagiaire de maximum 25 caracteres" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.addresse,essai);
do {
   tmp.codepost=0;
   printf("\nEntrer le code postal du stagiaire,celui-ci doit etre entre 1000 et 9999 inclus:   " );
   fflush(stdin);
   scanf("%d",&tmp.codepost);
   }
while(tmp.codepost <1000 ||tmp.codepost>9999);
do {
 printf("\nEntrer la ville du stagiaire\n appuyez ENTER si vous voulez garder %s comme ville: ",tmp.ville);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>25) printf("\nVous devez entrer une ville de maximum 25 caractere" );
 }
while (strlen(essai)>25);
if (strlen(essai)!=0) strcpy(tmp.ville,essai);
do {
 printf("\nEntrer le numero de telephone prive du stagiaire\n appuyez sur ENTER si vous voulez garder %s comme telephone: ",tmp.tel);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>20) printf("\nVous devez entrer un numero de telephone de maximum 20 caractere" );
 }
while (strlen(essai)>20);
if (strlen(essai)!=0) strcpy(tmp.tel,essai);
do {
 printf("\nEntrer le numero de telephone de l'entreprise du stagiaire\n appuyez sur ENTER si vous voulez garder %s comme telephone: ",tmp.tel_ent);
 fflush(stdin);
 gets(essai);
 if (strlen(essai)>20) printf("\nVous devez entrer un numero de telephone de maximum 20 caractere" );
 }
while (strlen(essai)>20);
if (strlen(essai)!=0) strcpy(tmp.tel_ent,essai);
do
   {
 printf ("\nEntrez le nom de l'entreprise cherchee:   " );
 fflush (stdin);
 gets (nomch);
 seek_ent (*ind_nm_ent,nomch,vec);
 rep='x';
 i=0;
 if (vec[i]!=-1)
    {
    while (vec[i]!=-1 && rep!='O' && rep!='A')
    {
    fseek (pent,vec[i]*sizeof(struct entreprise),SEEK_SET);
    fread(&tmp_ent,sizeof(struct entreprise),1,pent);
    clrscr();
    afpent(&tmp_ent);
    do {
    if(vec[i+1]!=-1) printf ("\n O pour mettre cette fiche\n N pour voir la fiche suivante \n A pour Annuler: " );
    else printf ("\n O pour mettre cette fiche\n A pour Annuler: " );
    fflush (stdin);
    rep=getchar ();
    rep=toupper (rep);
    }
    while (rep!='A' &&  rep!='O' && rep!='N');
    if (rep=='O')
    {
    tmp.cle_etr=tmp_ent.cle;
    }
    i++;
    }
    }
  else
   {
   printf ("\nCe nom n'existe pas\n" );
   do {
    printf ("\n O pour rechercher une autre entreprise \n A pour Annuler: " );
    fflush (stdin);
    rep2=getchar ();
    rep2=toupper (rep2);
    }
   while (rep2!='A' &&  rep2!='O');
   }
 }
while (rep!='O' && rep2!='A');
if (rep=='O')
   {
 do
   {
   printf("Etes vous sur de vouloir modifier cette fiche(o/n)?" );
   fflush(stdin);
   rep=getchar();
   rep=tolower(rep);
   }
 while(rep!='o' && rep!='n');
   }
if (rep=='o')
  {
  del_sta (ind_nm_sta,posi);
  del_ent_sta(ind_ent_sta,old.cle_etr,posi);
  fseek (psta,posi*sizeof(struct stagiaire),SEEK_SET);
  fwrite(&tmp,sizeof(struct stagiaire),1,psta);
  insert_sta(ind_nm_sta,tmp.cle,tmp.nom,posi);
  insert_multi_ent_sta(ind_ent_sta,&tmp,posi);
  }
fclose(pent);
fclose(psta);
}
 
/*************FONCTION DE VISUALISATION D'UN RECORD ENTREPRISE*************/
 
afpent(struct entreprise* fiche)
{
printf("\nCle   : %d",fiche->cle);
printf("\nNom   : %s",fiche->nom);
printf("\nAddresse   : %s",fiche->addresse);
printf("\nCode postale   : %d",fiche->codepost);
printf("\nVille   : %s",fiche->ville);
printf("\nTelephone   : %s",fiche->tel);
printf("\nSecteur   : %s",fiche->secteur);
}
 
 
/*************FONCTION DE VISUALISATION D'UN RECORD STAGIAIRE***************/
 
afpsta(struct stagiaire* fiche)
{
printf("Cle   : %d",fiche->cle);
printf("\nNom   : %s",fiche->nom);
printf("\nCle etrangere   : %d",fiche->cle_etr);
printf("\nPrenom    : %s",fiche->prenom);
printf("\nAddresse   : %s",fiche->addresse);
printf("\nCode postale   : %d",fiche->codepost);
printf("\nVille   : %s",fiche->ville);
printf("\nTelephone prive   : %s",fiche->tel);
printf("\nTelephone de l'entreprise   : %s",fiche->tel_ent);
}
 
 
/*********FONCTION DE VISUALISATION SEQUENTIELLE DU FICHIER ENTREPRISE******/
 
aff_sec_ent ()
{
FILE *f1;
struct entreprise tmp;
 
f1=fopen(ENTR,"rb" );
while(fread(&tmp,sizeof(struct entreprise),1,f1))
{
if(tmp.cle!=-1)
 {
 clrscr();
 afpent(&tmp);
 fflush(stdin);
 getch();
 }
}
}
/********FONCTION DE VISUALISATION SEQUENTIELLE DU FICHIER STAGIAIRE********/
 
aff_sec_sta ()
{
FILE *f1;
struct stagiaire tmp;
 
f1=fopen(STA,"rb" );
while(fread(&tmp,sizeof(struct stagiaire),1,f1))
{
if(tmp.cle!=-1)
 {
    clrscr();
 afpsta(&tmp);
 fflush(stdin);
 getch();
 }
}
}
 
 
/****FONCTION DE VISUALISATION DES RECORDS ENTREPRISE INDEXE SUR LE NOM*****/
 
afpent_ind(struct liste_ent* index)
{
struct entreprise tmp;
FILE* f1;
 
f1=fopen(ENTR,"rb" );
while(index!=NULL)
   {
 clrscr();
 fseek(f1,sizeof(struct entreprise)*index->posi,SEEK_SET);
 fread(&tmp,sizeof(struct entreprise),1,f1);
 afpent(&tmp);
 fflush(stdin);
 getch();
 index=index->suivant;
 }
}
 
 
/*****FONCTION DE VISUALISATION DES RECORDS STAGIAIRE INDEXE SUR LE NOM****/
 
afpsta_ind(struct liste_sta* index)
{
struct stagiaire tmp;
FILE *f1;
 
f1=fopen(STA,"rb" );
while(index!=NULL)
 {
 clrscr();
 fseek(f1,sizeof(struct stagiaire)*index->posi,SEEK_SET);
 fread(&tmp,sizeof(struct stagiaire),1,f1);
 afpsta(&tmp);
 fflush(stdin);
 getch();
 index=index->suivant;
 }
}
 
/******FONCTION DE VISUALISATION DES RECORDS ENTREPRISE INDEXE SUR LE SECTEUR*/
 
aff_sect_ent(struct multi_ent_sect* index)
{
struct entreprise tmp;
struct liste_ent *ss_ind;
FILE* f1;
 
f1=fopen(ENTR,"rb" );
while(index!=NULL)
   {
   ss_ind=index->prem_ent;
   while(ss_ind!=NULL)
  {
  clrscr();
  fseek(f1,sizeof(struct entreprise)*ss_ind->posi,SEEK_SET);
  fread(&tmp,sizeof(struct entreprise),1,f1);
  printf("\nintitule du secteur:    %s\n",tmp.secteur);
  afpent(&tmp);
  fflush(stdin);
  getch();
  ss_ind=ss_ind->suivant;
  }
 index=index->suivant;
 }
}
 
 
/***FONCTION DE VISUALISATION DES RECORDS ENTREPRISE D'UN SECTEUR SPECIFIQUE**/
 
aff_sect_ent_spec(struct multi_ent_sect* index)
{
char secteur[25+1];
struct entreprise tmp;
struct liste_ent *ss_ind;
FILE* f1;
 
f1=fopen(ENTR,"rb" );
printf("\nEntrez le nom du secteur rechercher:   " );
fflush(stdin);
gets(secteur);
while((strcmp(index->secteur,secteur))<0 && index!=NULL)
   {
   index=index->suivant;
 }
if ((strcmp(index->secteur,secteur))==0)
 {
 ss_ind=index->prem_ent;
 while (ss_ind!=NULL)
  {
        clrscr();
  fseek(f1,sizeof(struct entreprise)*ss_ind->posi,SEEK_SET);
  fread(&tmp,sizeof(struct entreprise),1,f1);
  printf("\nintitule du secteur:    %s\n",tmp.secteur);
  afpent(&tmp);
  fflush(stdin);
  getch();
  ss_ind=ss_ind->suivant;
  }
 }
else
 {
 printf("\naucune entreprise appartenant a ce secteur" );
 fflush(stdin);
 getch();
 }
}
 
 
/**FONCTION DE VISUALISATION DES RECORDS STAGIAIRE INDEXE SUR L'ENTREPRISE*/
 
afpent_sta(struct multi_ent_sta* index)
{
struct stagiaire tmp;
struct liste_sta *ss_ind;
FILE*f1;
 
f1=fopen(STA,"rb" );
while(index!=NULL)
   {
   ss_ind=index->prem_sta;
   while(ss_ind!=NULL)
  {
  clrscr();
  fseek(f1,sizeof(struct stagiaire)*ss_ind->posi,SEEK_SET);
  fread(&tmp,sizeof(struct stagiaire),1,f1);
  printf("\nentreprise numero:    %d\n",tmp.cle_etr);
  afpsta(&tmp);
  fflush(stdin);
  getch();
  ss_ind=ss_ind->suivant;
  }
 index=index->suivant;
 }
}
 
 
/*FONCTION DE VISUALISATION DES RECORDS STAGIAIRE D'UNE ENTREPRISE SPECIFIQUE*/
 
afpent_sta_spec(struct multi_ent_sta* index)
{
int cle;
struct stagiaire tmp;
struct liste_sta *ss_ind;
FILE*f1;
 
f1=fopen(STA,"rb" );
printf("\nEntrez la cle de l'entreprise:    " );
scanf("%d",&cle);
while(index->cle_ent<cle && index!=NULL)
   {
   index=index->suivant;
   }
if (cle==index->cle_ent)
   {
   ss_ind=index->prem_sta;
   while(ss_ind!=NULL)
  {
  clrscr();
  fseek(f1,sizeof(struct stagiaire)*ss_ind->posi,SEEK_SET);
  fread(&tmp,sizeof(struct stagiaire),1,f1);
  printf("\nnumero d'entreprise:   %d\n",tmp.cle_etr);
  afpsta(&tmp);
  fflush(stdin);
  getch();
  ss_ind=ss_ind->suivant;
  }
 }
else
 {
 printf("\nCette entreprise n'a aucun stagiaire ou n'existe pas" );
 fflush(stdin);
 getch();
 }
}
 
 
/*******FONCTION D'AFFICHAGE DES STAGIAIRE PAR SECTEUR****************/
 
afpsta_sect(struct multi_ent_sect*ind_sect,struct multi_ent_sta*ind_ent_sta)
{
struct multi_ent_sta *tmp;
struct stagiaire stag;
struct liste_ent *ss_ind_ent;
struct liste_sta *ss_ind_sta;
FILE *f1;
 
f1=fopen(STA,"rb" );
while (ind_sect!=NULL)
 {
 ss_ind_ent=ind_sect->prem_ent;
 while (ss_ind_ent!=NULL)
  {
  tmp=ind_ent_sta;
  while(tmp->cle_ent!=ss_ind_ent->cle && tmp!=NULL)
   {
   tmp=tmp->suivant;
   }
  if (tmp!=NULL)
   {
   ss_ind_sta=tmp->prem_sta;
   while(ss_ind_sta!=NULL)
    {
    fseek(f1,sizeof(struct stagiaire)*ss_ind_sta->posi,SEEK_SET);
    fread(&stag,sizeof(struct stagiaire),1,f1);
    clrscr();
    printf("\nintitule du secteur:   %s\n",ind_sect->secteur);
    afpsta(&stag);
    fflush(stdin);
    getch();
    ss_ind_sta=ss_ind_sta->suivant;
    }
   }
  ss_ind_ent=ss_ind_ent->suivant;
  }
 ind_sect=ind_sect->suivant;
 }
}
 
/******FONCTION D'AFFICHAGE DES STAGIAIRE D'UN SECTEUR SPECIFIQUE**********/
 
afpsta_sect_spec(struct multi_ent_sect*ind_sect,struct multi_ent_sta*ind_ent_sta)
{
char secteur[25];
struct multi_ent_sta *tmp;
struct stagiaire stag;
struct liste_ent *ss_ind_ent;
struct liste_sta *ss_ind_sta;
FILE *f1;
 
f1=fopen(STA,"rb" );
printf("\nEntrer le nom du secteur recherchee:   " );
fflush(stdin);
gets(secteur);
while (strcmp(ind_sect->secteur,secteur)<0)
 {
 ind_sect=ind_sect->suivant;
 }
if(strcmp(ind_sect->secteur,secteur)==0)
 {
 ss_ind_ent=ind_sect->prem_ent;
 while (ss_ind_ent!=NULL)
  {
  tmp=ind_ent_sta;
  while(tmp->cle_ent!=ss_ind_ent->cle && tmp!=NULL)
   {
   tmp=tmp->suivant;
   }
  if (tmp!=NULL)
   {
   ss_ind_sta=tmp->prem_sta;
   while(ss_ind_sta!=NULL)
    {
    fseek(f1,sizeof(struct stagiaire)*ss_ind_sta->posi,SEEK_SET);
    fread(&stag,sizeof(struct stagiaire),1,f1);
    clrscr();
    printf("\nintitule du secteur:   %s\n",ind_sect->secteur);
    afpsta(&stag);
    fflush(stdin);
    getch();
    ss_ind_sta=ss_ind_sta->suivant;
    }
   }
  ss_ind_ent=ss_ind_ent->suivant;
  }
 }
else
 {
 printf("\naucun stagiaire appartenant a ce secteur" );
 fflush(stdin);
 getch();
 }
}
 
/********FONCTION D'INSERTION D'UN RECORD ENTREPRISE DANS LA LISTE**********/
 
insert_ent(struct liste_ent **racine,int cle,char *nom,int posi)
{
int essai;
struct liste_ent *p_prest,*p_old;
 
if (*racine==NULL || strcmp (nom,(*racine)->nom)<0)
 {
 new_ent (nom,racine,cle,*racine,posi);
 }
else
 {
 p_prest=(*racine)->suivant;
 p_old=*racine;
 while (p_prest!=NULL && strcmp (nom,p_prest->nom)>0)
   {
   p_old=p_prest;
   p_prest=p_prest->suivant;
   }
 new_ent (nom,&p_old->suivant,cle,p_prest,posi);
 }
}
 
 
/********FONCTION D'INSERTION D'UN RECORD STAGIAIRE DANS LA LISTE**********/
 
insert_sta (struct liste_sta **racine,int cle,char *nom,int posi)
{
struct liste_sta *p_prest,*p_old;
 
if (*racine==NULL || strcmp (nom,(*racine)->nom)<0)
 {
 new_sta (nom,racine,cle,*racine,posi);
 }
else
 {
 p_prest=(*racine)->suivant;
 p_old=*racine;
 while (p_prest!=NULL && strcmp (nom,p_prest->nom)>0)
   {
   p_old=p_prest;
   p_prest=p_prest->suivant;
   }
 new_sta (nom,&p_old->suivant,cle,p_prest,posi);
 }
}
 
 
/*FONCTION D'INSERTION D'UN RECORD ENTREPRISE DANS LA MULTILISTE SECTEUR*/
 
insert_multi_ent_sect(struct multi_ent_sect**racine,struct entreprise* tmp,int posi)
{
struct multi_ent_sect *p_prest,*p_old;
 
if (*racine==NULL || strcmp (tmp->secteur,(*racine)->secteur)<0)
   {
   new_multi_ent_sect(tmp,racine,*racine,posi);
   }
else {
  if (strcmp (tmp->secteur,(*racine)->secteur)==0)
  {
  insert_ent(&(*racine)->prem_ent,tmp->cle,tmp->nom,posi);
  }
  else {
    p_prest=(*racine)->suivant;
    p_old=*racine;
    while (p_prest!=NULL && strcmp (tmp->secteur,p_prest->secteur)>0)
   {
            p_old=p_prest;
   p_prest=p_prest->suivant;
   }
    if (strcmp (tmp->secteur,(p_prest)->secteur)==0)
   {
   insert_ent(&p_prest->prem_ent,tmp->cle,tmp->nom,posi);
   }
    else {
      new_multi_ent_sect(tmp,&p_old->suivant,p_prest,posi);
      }
    }
  }
}
 
 
/***FONCTION D'INSERTION D'UN RECORD STAGIAIRE DANS LA MULTILISTE SECTEUR*/
 
insert_multi_ent_sta(struct multi_ent_sta**racine,struct stagiaire* tmp,int posi)
{
struct multi_ent_sta *p_prest,*p_old;
 
if (*racine==NULL || tmp->cle_etr<(*racine)->cle_ent)
   {
   new_multi_ent_sta(tmp,racine,*racine,posi);
   }
else {
  if ((tmp)->cle_etr==(*racine)->cle_ent)
  {
  insert_sta(&(*racine)->prem_sta,tmp->cle,tmp->nom,posi);
  }
  else {
    p_prest=(*racine)->suivant;
    p_old=*racine;
    while (p_prest!=NULL && tmp->cle_etr > p_prest->cle_ent)
   {
            p_old=p_prest;
   p_prest=p_prest->suivant;
   }
    if (tmp->cle_etr==(p_prest)->cle_ent)
   {
   insert_sta(&p_prest->prem_sta,tmp->cle,tmp->nom,posi);
   }
    else {
      new_multi_ent_sta(tmp,&p_old->suivant,p_prest,posi);
      }
    }
  }
}
 
 
/*******FONCTION D'AJOUT D'UN RECORD ENTREPRISE DANS LA LISTE**********/
 
new_ent (char * nom,struct liste_ent **p_old,int cle,struct liste_ent* p_next,int posi)
{
struct liste_ent *new;
 
new=malloc (sizeof(struct liste_ent));
strcpy (new->nom,nom);
new->suivant=p_next;
new->cle=cle;
new->posi=posi;
*p_old=new;
}
 
 
/************FONCTION D'AJOUT D'UN RECORD STAGIAIRE DANS LA LISTE*********/
 
new_sta (char * nom,struct liste_sta **p_old,int cle,struct liste_sta* p_next,int posi)
{
struct liste_sta *new;
 
new=malloc (sizeof(struct liste_sta));
strcpy (new->nom,nom);
new->suivant=p_next;
new->cle=cle;
new->posi=posi;
*p_old=new;
}
 
 
/******FONCTION D'AJOUT D'UN RECORD ENTREPRISE DANS LA MULTI LISTE********/
 
new_multi_ent_sect (struct entreprise *tmp,struct multi_ent_sect **p_old,struct multi_ent_sect* p_next,int posi)
{
struct multi_ent_sect *new;
 
new=malloc (sizeof(struct multi_ent_sect));
strcpy (new->secteur,tmp->secteur);
*p_old=new;
new->suivant=p_next;
new->prem_ent=NULL;
insert_ent(&new->prem_ent,tmp->cle,tmp->nom,posi);
}
 
 
/******FONCTION D'AJOUT D'UN RECORD STAGIAIRE DANS LA MULTI LISTE*********/
 
new_multi_ent_sta (struct stagiaire *tmp,struct multi_ent_sta **p_old,struct multi_ent_sta* p_next,int posi)
{
struct multi_ent_sta *new;
 
new=malloc (sizeof(struct multi_ent_sta));
new->cle_ent=tmp->cle_etr;
*p_old=new;
new->suivant=p_next;
new->prem_sta=NULL;
insert_sta(&new->prem_sta,tmp->cle,tmp->nom,posi);
}
 
 
/******FONCTION DE RECHERCHE D'UN RECORD ENTREPRISE BASE SUR LE NOM********/
 
seek_ent(struct liste_ent * index ,char *nomch,int vec [NB_SYNO])
{
int i=0;
 
while (index!=NULL && strcmp(nomch,index->nom)>=0 )
  {
  if (strcmp(nomch,index->nom)==0)
   {
   vec[i]=(index)->posi;
            index=index->suivant;
   i++;
   }
  else index=index->suivant;
  }
vec[i]=-1;
}
 
 
/*******FONCTION DE RECHERCHE D'UN RECORD STAGIARE BASE SUR LE NOM*******/
 
seek_sta(struct liste_sta * index ,char *nomch,int vec [NB_SYNO])
{
int i=0;
 
while (index!=NULL && strcmp(nomch,index->nom)>=0 )
  {
  if (strcmp(nomch,index->nom)==0)
   {
   vec[i]=(index)->posi;
            index=index->suivant;
   i++;
   }
  else index=index->suivant;
  }
vec[i]=-1;
}
/***FONCTION DE RECHERCHE D'UN RECORD ENTREPRISE DANS LA MULTI-LISTE*******/
 
int seek_ent_sta(struct multi_ent_sta* index,int cle)
{
int valid=1;
 
while (index!=NULL && cle<index->cle_ent)
  {
  index=index->suivant;
  }
if (cle==index->cle_ent|| index->prem_sta==NULL)valid=0;
return valid;
}
 
 
/******FONCTION DE SUPPRESION D'UN RECORD ENTREPRISE DANS LA LISTE**********/
 
del_ent (struct liste_ent **racine,int  a_sup)
{
struct liste_ent *p_prest,*p_old;
 
if (a_sup==(*racine)->posi)
 {
 free (*racine);
 *racine=(*racine)->suivant;
  }
else
 {
 p_prest=(*racine)->suivant;
 p_old=*racine;
 while (a_sup!=p_prest->posi)
   {
   p_old=p_prest;
   p_prest=p_prest->suivant;
   }
 
 p_old->suivant=p_prest->suivant;
 free (p_prest);
 }
}
 
 
/********FONCTION DE SUPPRESSION D'UN RECORD STAGIAIRE DANS LA LISTE********/
 
del_sta (struct liste_sta **racine,int  a_sup)
{
struct liste_sta *p_prest,*p_old;
 
if (a_sup==(*racine)->posi)
 {
 free (*racine);
 *racine=(*racine)->suivant;
  }
else
 {
 p_prest=(*racine)->suivant;
 p_old=*racine;
 while (a_sup!=p_prest->posi)
   {
   p_old=p_prest;
   p_prest=p_prest->suivant;
   }
 
 p_old->suivant=p_prest->suivant;
 free (p_prest);
 }
}
 
 
 
/*FONCTION DE SUPPRESION D'UN RECORD ENTREPRISE DANS LA MULTI-LISTE BASE SUR LE SECTEUR*/
 
del_multi_ent_sect(struct multi_ent_sect** index,struct entreprise*tmp,int posi)
{
struct multi_ent_sect *p_prest,*p_old;
 
if (strcmp((*index)->secteur,tmp->secteur)==0)
 {
 del_ent(&(*index)->prem_ent,posi);
 if ((*index)->prem_ent==NULL)
    {
    free (*index);
    *index=(*index)->suivant;
    }
 }
else
 {
 p_prest=(*index)->suivant;
 p_old=*index;
 while (strcmp(p_prest->secteur,tmp->secteur)!=0)
   {
   p_old=p_prest;
   p_prest=p_prest->suivant;
   }
 del_ent(&(p_prest->prem_ent),posi);
 if (p_prest->prem_ent==NULL)
  {
 p_old->suivant=p_prest->suivant;
 free (p_prest);
  }
 }
}
 
 
/*FONCTION DE SUPPRESION D'UN RECORD STAGIARE DANS LA MULTI-LISTE BASE SUR LES ENTREPRISE*/
 
del_ent_sta(struct multi_ent_sta** index,int cle_etr,int posi)
{
struct multi_ent_sta *p_prest,*p_old;
 
if ((*index)->cle_ent==cle_etr)
 {
 del_sta(&(*index)->prem_sta,posi);
 if ((*index)->prem_sta==NULL)
    {
    free (*index);
    *index=(*index)->suivant;
    }
 }
else
 {
 p_prest=(*index)->suivant;
 p_old=*index;
 while (p_prest->cle_ent!=cle_etr)
   {
   p_old=p_prest;
   p_prest=p_prest->suivant;
   }
 del_sta(&(p_prest->prem_sta),posi);
 if (p_prest->prem_sta==NULL)
  {
 p_old->suivant=p_prest->suivant;
 free (p_prest);
  }
 }
}
 
/*******FONCTION D'AJOUT D'UN ELEMENT DANS LA PILE ENTREPRISE************/
 
push_ent (struct ple_ent **p_sup,int posi)
{
struct ple_ent *new;
 
new=malloc (sizeof(struct ple_ent));
new->suivant=(*p_sup);
new->posi=posi;
*p_sup=new;
}
 
 
/********FONCTION D'AJOUT D'UN ELEMENT DANS LA PILE ENTREPRISE************/
 
push_sta (struct ple_sta **p_sup,int posi)
{
struct ple_sta *new;
 
new=malloc (sizeof(struct ple_sta));
new->suivant=(*p_sup);
new->posi=posi;
*p_sup=new;
}
 
 
/********FONCTION DE SUPPRESION D'UN ELEMENT DE LA PILE ENTREPRISE********/
 
pop_ent (struct ple_ent **p_sup)
{
struct ple_ent *tmp;
tmp=(*p_sup)->suivant;
free (*p_sup);
*p_sup=tmp;
}
 
 
pop_sta (struct ple_sta **p_sup)
{
struct ple_sta *tmp;
tmp=(*p_sup)->suivant;
free (*p_sup);
*p_sup=tmp;
}
 
/**********FONCTION DE REORGANISATION DU FICHIER***********************/
 
reorga(struct liste_ent **ind_nm_ent,struct liste_sta **ind_nm_sta,struct multi_ent_sect **ind_sect_ent,struct multi_ent_sta **ind_ent_sta,struct ple_ent **pile_ent,struct ple_sta **pile_sta)
{
struct entreprise tmp_ent;
struct stagiaire tmp_sta;
int i;
FILE *psta;
FILE *pent;
 
pent=fopen(ENTR,"rb" );
psta=fopen(STA,"rb" );
i=0;
while (fread(&tmp_ent,sizeof(struct entreprise),1,pent))
 {
 if (tmp_ent.cle!=-1)
    {
  insert_ent(ind_nm_ent,tmp_ent.cle,tmp_ent.nom,i);
  insert_multi_ent_sect(ind_sect_ent,&tmp_ent,i);
  }
 else
  {
  push_ent(pile_ent,i);
  }
 i++;
 }
i=0;
while (fread(&tmp_sta,sizeof(struct stagiaire),1,psta))
 {
 if (tmp_sta.cle!=-1)
    {
  insert_sta(ind_nm_sta,tmp_sta.cle,tmp_sta.nom,i);
  insert_multi_ent_sta(ind_ent_sta,&tmp_sta,i);
  }
 else
  {
  push_sta(pile_sta,i);
  }
 i++;
 }
fclose (pent);
fclose(psta);
}
 
 
/*********************FONCTION DE COMPACTAGE **************************/
 
compact(struct liste_ent **ind_nm_ent,struct liste_sta **ind_nm_sta,struct multi_ent_sect **ind_sect_ent,struct multi_ent_sta **ind_ent_sta,struct ple_ent**pile_ent,struct ple_sta**pile_sta)
{
int i,j;
FILE * f_tmp;
FILE *psta;
FILE *pent;
struct liste_ent *ent;
struct liste_sta *sta;
struct entreprise tmp_ent;
struct stagiaire tmp_sta;
struct temp tmp_temp;
char nom[50];
 
while(*pile_ent!=NULL)
 {
 pop_ent(pile_ent);
 }
while(*pile_sta!=NULL)
 {
 pop_sta(pile_sta);
 }
while(*ind_nm_ent!=NULL)
 {
 free(*ind_nm_ent);
 *ind_nm_ent=(*ind_nm_ent)->suivant;
 }
while(*ind_nm_sta!=NULL)
 {
 free(*ind_nm_sta);
 *ind_nm_sta=(*ind_nm_sta)->suivant;
 }
pent=fopen(ENTR,"rb" );
while (*ind_sect_ent!=NULL)
 {
 ent=(*ind_sect_ent)->prem_ent;
 fseek(pent,sizeof(struct entreprise)*ent->posi,SEEK_SET);
 fread(&tmp_ent,sizeof(struct entreprise),1,pent);
 del_multi_ent_sect(ind_sect_ent,&tmp_ent,ent->posi);
 }
while (*ind_ent_sta!=NULL)
 {
 sta=(*ind_ent_sta)->prem_sta;
 del_ent_sta(ind_ent_sta,(*ind_ent_sta)->cle_ent,sta->posi);
 }
 
i=0;
rewind(pent);
f_tmp=fopen(TMP,"wb" );
while (fread(&tmp_ent,sizeof(struct entreprise),1,pent))
 {
 if (tmp_ent.cle!=-1)
    {
  insert_ent(ind_nm_ent,tmp_ent.cle,tmp_ent.nom,i);
  insert_multi_ent_sect(ind_sect_ent,&tmp_ent,i);
  fwrite(&tmp_ent,sizeof(struct entreprise),1,f_tmp);
  i++;
  }
 }
fclose(pent);
fclose(f_tmp);
remove(ENTR);
rename(TMP,ENTR);
j=0;
f_tmp=fopen(TMP,"wb" );
psta=fopen(STA,"rb" );
while (fread(&tmp_sta,sizeof(struct stagiaire),1,psta))
 {
 if (tmp_sta.cle!=-1)
    {
  insert_sta(ind_nm_sta,tmp_sta.cle,tmp_sta.nom,j);
  insert_multi_ent_sta(ind_ent_sta,&tmp_sta,j);
  fwrite(&tmp_sta,sizeof(struct stagiaire),1,f_tmp);
  j++;
  }
 }
fclose(psta);
fclose(f_tmp);
remove(STA);
rename(TMP,STA);
f_tmp=fopen(TEMP,"r+b" );
fread(&tmp_temp,sizeof(struct temp),1,f_tmp);
tmp_temp.posi_ent=i;
tmp_temp.posi_ent=j;
rewind(f_tmp);
fwrite(&tmp_temp,sizeof(struct temp),1,f_tmp);
fclose(f_tmp);
}


C'est quoi cette horreur ?
 
Tu as eut la moyenne avec cette chose ?

ça nous fait une belle jambe

 
c'est dla bombe bébé

 
merci de ta reconnaissance. je tient à etre accepté dans votre club très fermé des programmateurs à la jambe de bois.

 
probleme? viens me retrouver a la kermesse de st vith si oui!

 
mais que fais taz ?

 
Bah oui.
 
Pas de commentaires, des define à la con (c'est quoi la différence entre TMP et TEMP ? ), des tailles de chaines fixes.
 
Après 10 lignes, j'ai craqué.

 
l'important c ke le programmateur omprenne, pas les noobs qui trainent autour    
 
Je suis le programmateur, je suis DIEU, le tout puissant!

 
il baze?

 
allez viende seulement si t un vrai programmateur a la jambe de bois!

Comme quoi le C est nocif à la santé mentale
 
Edit:

C quoi ste merde t'aurais pu au moin utiliser les balises de code que ça ressemble à qqc.
 
Edit: c un troll spas possible.

je suis dispensée alors  

les balises CPP c'est fait pour quoi?
 

 
et gueule pas trop vite avec ta fête de Saint-Vith, ya quelques belges de bonne carrure ici
 
edit: en fait c'est super moche ton truc, je t'aurais collé un zéro pointé pour absence de commentaires

 
Tu veux dire les trucs sur les machines à laver?

Leto arrete de repomper mes blagues    
sinon perso 3/10 arf    

nan mais franchement là meme moi je pense pouvoir faire mieux alors c'est pas rien.
 
C'est null

 
ta mère en short

c'est bruno

 
Ah oui, mais la ca nous fait poutre sur caribou, tu recules de deux cases et poses deux cartes chances sur pioche

Et la tienne en string.h

en std::string

brash, brash, ce pseudo me dit qqchose

 
en char*

on s'en fout de CString a sa maman  

ben je viens de dire que c'était bruno

 
 
ne me remerciez pas ca m'a fait plaisir

c'est pas l'auteur du topic

GCS suxorize

Ah ben voila tiens, on veut aider les autres a comprendre ce magnifique bout de code, veritable hommage au langage C tant il est propre et astucieux, et voila comment on se fait accueillir

Dsl, j'ai capté qu'après... désolé chrisbk

 
ah oui  

ton code est mité... rien que les fflush(stdin) ça en dit long. au fait, tu sais ce que c'est que la gestion d'erreur?

laisse couler, c'est un type spécialisé dans le troll et les farces de mauvais gout
j'ai envie de jouer au ping-pong avec ce topic

 
tiens oui, ca pourrait les interesser sur overclocking un topic de cette qualité