Gestion de bibliothéque dynamique

Fermé
ouled omar ilyes - 9 janv. 2014 à 11:29
[Dal] Messages postés 6198 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 13 décembre 2024 - 9 janv. 2014 à 14:20
Bonjour,


salut les amis, quand je compile, je trouve rien d'erreur mais quelques warning, j'ai essayé de les corriger mais rien, ainsi mon programme, aprés que j'entre les variables, ne fonctionne plus, je pense que c'est une faute d'allocation de memoir, mais j'ai trouvé rien
voici mon code
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "mini projet.h"
int choix, choix1,jour,choix2,CIN,date_acces,edition,nbre_copie;
char mot[20];
char nom[20];
char auteur[20];
livre*tete ;
personne*head ;
personne*pi;
personne*pii;
personne*p;
livre*q;
int main()
{
head=/*(personne*)*/malloc(sizeof(personne));
head=NULL;
tete=/*(livre*)*/malloc(sizeof(livre));
tete=NULL;
printf("\n\n");
printf(" ________________________________________________________________________\n|\n");
printf("| WELCOME IN: GESTIONAIRE ETUDIANT |\n");
printf("|________________________________________________________________________|\n|\n");
printf("| DONNER LE MOT DE PASSE |\n");
scanf("%s",mot);
while(strcmp(mot,mot_de_passe)==0)
{
do
{
printf("| 1-AJOUTER|\n");
printf("| 2-IDENTIFIER |\n");
printf("| 3-EMPRUNTER UN LIVRE |\n");
printf("| 4-RENDRE UN LIVRE |\n");
printf("| 5-VOIR LES PERSONNES QUI SONT DEPASSES LA DATE DE RETOUR MAX|\n");
printf("| 0-QUITTER |\n");
printf("|________________________________________________________________________|\n");
printf("| donner le numero de votre choix |\n");
printf("|________________________________________________________________________|\n\n");
scanf("%d", &choix);
}
while( choix<0 || choix>5);
switch(choix)
{
case 1:
{
do
{
printf("1-AJOUTER UN LIVRE\n");
printf("2-AJOUTER UNE PERSONNE\n");
printf("DONNER VOTRE CHOIX\n");
scanf("%d", &choix1);
}
while((choix1<1) || (choix1>2));
switch(choix1)
{
case 1:
{
q =/*(livre*)*/malloc(sizeof(livre));
q=NULL;
printf("ENTRE LE NOM DU LIVRE\n") ;
scanf("%s",nom) ;
printf("ENTRER L'AUTEUR\n") ;
scanf("%s",auteur) ;
printf("ENTRER L'EDITION DU LIVRE\n") ;
scanf("%d",&edition);
printf("ENTRE LE NBRE DE COPIE DU LIVRE\n");
scanf("%d",&nbre_copie);

if(existe_livre(tete,nom[20],auteur[20],edition)==0)
{

do
{
q=tete;
if(q->next1==NULL)
{q->next1=ajouter_livre(nom[20],auteur[20],edition,nbre_copie);
q=q->next1;
}
else
{
q=q->next1;
}
}
while(q->next1==NULL);
}
else
{
recherche_element_livre(tete,auteur[20],nom[20],edition)->nbre_copie=recherche_element_livre(tete,auteur[20],nom[20],edition)->nbre_copie+nbre_copie;

}

tete=q;

/* identifier_livre;
ajout_nbre_copie;
ajout_code;*/
printf("case 1 dans case 1");
}break;

case 2:
{
pii =/*(personne*)*/malloc(sizeof(personne));
pii=NULL;
printf("ENTRER CIN\n") ;
scanf("%d",&CIN) ;
printf("DONNERR LA DATE D'ACCEES\n");
scanf("%d", &date_acces);
pii=head;
if(existe(pii,CIN)==0)
{
do
{
if ((pii->next)== NULL)
{
pii= ajouter_personne(CIN,date_acces);
pii->next=NULL;
head->next =pii;
}
else

{
pii=pii->next;
}
}
while(pii->next==NULL);
}
else
{
if(strcmp(recherche_element_personne(head,CIN)->etat,"a empruté")==0)
{
printf("IL FAUT RENDRE LES LIVRES EN AVANTS\n");
}
else
{
strcpy(recherche_element_personne(head,CIN)->etat,"libre");
recherche_element_personne(head,CIN)->date_acces=date_acces;
};
}
/*identifier: nom et prenom, cin, numero telephone, date d'accés, code, etat: libre, a emprunté, supprimé, pénalisé
si le nom du personne et cin est identique des coordonnés passé, l' etat de cette personne va changer si son etat est supprimé
sinon ecrire vous ne pouvez pas réinscrir ssi aprés rendre livres empruntés*/
printf("case 2 dans case 1");
}break;
}
}
break;
case 2:
{
do
{
printf("1-IDENTIFIER LIVRE\n");
printf("2-IDENTIFIER PERSONNE\n");
printf("DONNER VOTRE CHOIX \n");
scanf("%d", &choix2);
}
while((choix2<1) || (choix2>2));
switch(choix2)
{
case 1:
{
identifier_livre(tete);
/*donner l'etat d'un livre*/
printf("case1 dans case 2\n");
}break;
case 2 :
{
identifier_personne(head);
/*donner l'etat d'une personne*/
printf("case 2 dans case 2");
}break;
}
} break;
case 3: /*valable si l'état d'emprinteur est ok*/
{
emprunter_livre(head,tete);
/*entrer le code d'un livre;
printf("vous avez choisis la fonction d'empruntage d'un livre\n");

}break;
case 4:
{
rendre_livre(head,tete);
/*entrer_coordonnées;
ajout_nbre_copie;
changer_mis_a_jour_personne;*/
printf("vous avez choisis la tache de rendre un livre\n");

} break;
case 5:
{
personne_penalise(head);
/*penaliser automatiquement toute personne de jours_penalisés
dés qu'il a rendu le livre aprés qu'il a dépasser la date de rendu
et afficher toutes les personnes pénalié avec leur numéro du telephones*/
/*il faut aussi se souvient qu'apres les jours penalisés l'etat du personne revient automatiquement a l'etat libre*/
printf("case 5 \n");
}
case 0:
{
p =/*(personne*)*/ malloc(sizeof(personne));
p=NULL;
printf("SEE YOU TOMORROW!!!\n");
printf(" ________________________________________________________________________\n|\n");
while(p->next!=NULL)
{
p->jour_emprunte++;
jour++;
}
} break;
}
pi =/*(personne*)*/ malloc(sizeof(personne));
pi=NULL ;
pi=head;
while (pi->next!=NULL)
{
if(((jour-pi->date_acces)>=360)&& (strcmp(pi->etat,"emprunte")!=0 )) /*si date dépasse un ans, l'etat du personne est supprimé*/
{
strcpy(pi->etat,"supprime");

}
else
{
pi= pi->next;
}

}
};
return 0;
}







et voici le fichier .h





#ifndef MINI_PROJET_H_INCLUDED
#define MINI_PROJET_H_INCLUDED
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define date_limite 15
#define mot_de_passe "ilyes_mahdi"
typedef struct livre1
{
char nom[20];
char auteur[20];
int edition;
int nbre_copie;
char code[20];
struct livre1*next1;
}livre;
typedef struct personne1
{
char nom_prenom[20];
int carte_idendite;
int numero_telephone;
int date_acces;
int CIN;
int jour_emprunte;
char etat[20];
struct personne1*next;
} personne;

int existe(personne*, int);
int existe_livre(livre*, char, char, int);
void identifier_livre(livre* );
livre*ajouter_livre(char ,char, int ,int );
livre*recherche_element_livre(livre*,char, char, int);
personne*recherche_element_personne(personne*, int);
personne*ajouter_personne(int, int);
void identifier_personne(personne*);
void emprunter_livre(personne*,livre*);
void rendre_livre(personne*,livre*);
void personne_penalise(personne*);
#endif // MINI_PROJET_H_INCLUDED





et voila mes fonctions:







#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "mini projet.h"
int existe(personne*head, int CIN)
{
personne*p;
p=/*(personne*)*/malloc(sizeof(personne));
p=NULL;
p->next=/*(personne*)*/malloc(sizeof(personne));
p->next=NULL;
p=head;
while((p->next!= NULL)||(p->CIN!= CIN))
{
p= p->next;
}
if(p->next!=NULL)
{
return 1;
}
else
{
return 0;
};

}
personne*recherche_element_personne(personne*head,int CIN)
{
personne*p;
p=/*(personne*)*/malloc(sizeof(personne));
p=NULL;
p->next=/*(personne*)*/malloc(sizeof(personne));
p->next=NULL;
p=head;
while (existe(p,CIN)!=0)
{
p=p->next;
}
return p;
}


personne*ajouter_personne(int CIN, int date_acces)
{
char nom_prenom[20];
int telephone;
personne*p;
p=/*(personne*)*/malloc(sizeof(personne));
p=NULL;
printf("ENTRER LE NOM ET LE PRENOM DE LA PERSONNE\n") ;
scanf("%s",nom_prenom) ;
printf("ENTRER NUMERO DU TELEPHONE\n") ;
scanf("%d",&telephone);
p->next=/*(personne*)*/malloc(sizeof(personne));
p->next=NULL;
strcpy(p->etat,"libre");
strcpy(p->nom_prenom,nom_prenom);
p->carte_idendite= CIN;
p->numero_telephone= telephone;
p->date_acces= date_acces;
p->jour_emprunte=0;
return p;
}
int existe_livre(livre*tete,char nom, char auteur,int edition )
{
livre*p;
p=/*(livre*)*/malloc(sizeof(livre));
p=NULL;
p->next1=/*(livre*)*/malloc(sizeof(livre));
p->next1=NULL;
p=tete;
while(p->next1!= NULL||(p->nom!=nom && p->auteur!=auteur&& p->edition!=edition))
{
p= p->next1;
};
if(p->next1!=NULL)
{
return 1;
}
else
{
return 0;
};
}

livre*ajouter_livre(char nom,char auteur,int edition,int nbre_copie)
{
livre*p=NULL;
char code_livre[20];
printf("donner le code de livre");
scanf("%s",code_livre);
p=/*(livre*)*/ malloc(sizeof(livre));
p->next1=NULL;
p->next1=(livre*)malloc(sizeof(livre));
strcpy(p->nom,nom);
strcpy(p->auteur,auteur);
p->edition=edition;
p->nbre_copie=nbre_copie;
strcpy(p->code ,code_livre);
return p;
}

livre*recherche_element_livre(livre*tete,char auteur, char nom, int edition)
{
livre*p;
p=/*(livre*)*/ malloc(sizeof(livre));
p=NULL;
p->next1=/*(livre*)*/malloc(sizeof(livre));
p->next1=NULL;
p=tete;
while (existe_livre(tete,auteur,nom,edition)!=0)
{
p=p->next1;
}
return p;
}
void identifier_livre(livre*tete)
{
char nom[20];
printf("DONNER LE NOM DU LIVRE\n");
scanf("%s",nom);
livre*q;
q=/*(livre*)*/ malloc(sizeof(livre));
q=NULL;
q->next1=/*(livre*)*/malloc(sizeof(livre));
q->next1=NULL;
q=tete;
while(q->next1!=NULL)
{
if(strcmp(q->nom,nom)==0)

{
printf("CE LIVRE EXISTE \n");
printf("NBRE DE COPIE EXISTANT EST %d\n SON AUTEUR EST %s \n SON EDITION EST %d\n SON CODE EST %s \n ",q->nbre_copie, q->auteur, q->edition, q->code);
}

q =q->next1;
}
}

void identifier_personne(personne*head)
{
int CIN;
printf("DONNER LE NUMERO DU CIN \n");
scanf("%d", &CIN);
if(existe(head,CIN)==1 )
{
printf("CE PERSONNE EST ENREGISTRES, SON ETAT EST: %s \n",recherche_element_personne(head, CIN)->etat);
}
else
{
printf("CETTE PERSONNE N'EXISTE PAS \n");
}

}
void emprunter_livre(personne*head,livre*tete)
{
int CIN;
char code_livre[20];
personne*p;
livre*q;
p=/*(personne*)*/malloc(sizeof(personne));
p=NULL;
q=/*(livre*)*/malloc(sizeof(livre));
q=NULL;
p->next=/*(personne*)*/malloc(sizeof(personne));
p->next=NULL;
q->next1=/*(livre*)*/malloc(sizeof(livre));
q->next1=NULL;
while(head==NULL)
{p=head;
q=tete;
printf("ENTRER SVP LE CIN DU PERSONNE \n");
scanf("%d", &CIN);
printf("ENTRE SVP LE CODE DU LIVRE\n");
scanf("%s",code_livre);
while (p->next!=NULL )
{
while(q->next1!=NULL)
{
if( strcmp(q->code,code_livre)==0)
{
if(p->CIN==CIN)
{
if((strcmp(p->etat,"libre")==0))
{
strcpy(p->etat,"emprunté");
q->nbre_copie--;;
p->jour_emprunte=0; // nbre de jours valables our l'emprinteur
}
}
else
{
p=p->next;
}
}
else
{
q =q->next1;
}
}
}
if(p->next == NULL && q->next1== NULL && (p->CIN !=CIN || strcmp(q->code,code_livre)!=0))
{
printf("faut code!!!!");}
}
if(tete==NULL){printf("dsl, il n'y a pas de livre dans le programme");}
if(head==NULL){printf("dsl, il n'y a pas de personne dans le programme");}
}

void rendre_livre(personne*head,livre*tete)
{
char code_livre[20];
int CIN;
livre*q;
personne*p;
p=/*(personne*)*/malloc(sizeof(personne));
p=NULL;
p->next=/*(personne*)*/malloc(sizeof(personne));
p->next=NULL;
q=/*(livre*)*/malloc(sizeof(livre));
q=NULL;
q->next1=/*(livre*)*/malloc(sizeof(livre));
q->next1=NULL;
p=head;
q=tete;
printf("DONNER LE CODE DU LIVRE\n ");
scanf("%s",code_livre);
printf("DONNER LE cin DE L'EMPRUNTEUR \n");
scanf("%d", &CIN);
while (p->next!=NULL)
{
while(q->next1!=NULL)
{
if( strcmp(q->code,code_livre)==0 )
{
if(p->carte_idendite==CIN)
{
if(strcmp(p->etat,"supprimé")!=0 )
{
strcpy(p->etat,"libre");
p->jour_emprunte=0;
q->nbre_copie++;
}
}
else
{
p= p->next;
}
}
else
{
q= q->next1;
}
}
}
if((q->next1==NULL) && (p->next ==NULL)&&((strcmp(q->code,code_livre)!=0) || (p->carte_idendite!=CIN) ))
{
printf("l'un des codes est faux!!!");


}
}
void personne_penalise(personne*head )
{
personne*p;
p=/*(personne*)*/malloc(sizeof(personne));
p=NULL;
p->next=/*(personne*)*/malloc(sizeof(personne));
p->next=NULL;
if(head==NULL) {printf("aucune personne est enregistré");}
else
{
p=head;
printf("VOUS OBSERVEREZ LA LISTE DES PERSONNES PENALISES\n ");
while (p->next!=NULL)
{
if((strcmp(p->etat,"emprunté")==0) && (p->jour_emprunte==15 ))
{

printf("\n %s N'A PAS RENDU SON LIVRE, SON NUMERO DU TELEPHONE EST:%d\n", p->nom_prenom, p->numero_telephone);
}
p= p->next;
}
}
}







sinon contacter moi sur mon email
***@***
A voir également:

3 réponses

[Dal] Messages postés 6198 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 13 décembre 2024 1 096
Modifié par [Dal] le 9/01/2014 à 12:14
Salut ouled omar ilyes,

Je n'ai pas lu, ni testé ton programme, qui est très long.

Si tu penses que ton problème est lié à l'allocation de mémoire, tu peux essayer d'utiliser un outil te permettant de repérer les fuites mémoire.

Sous Linux, Valgrind est un outil excellent pour cela.

Sous Windows (et ailleurs), j'ai utilisé par le passé libmss http://libmss.sourceforge.net

Mais il y en a beaucoup d'autres (gratuits et payants).


Dal
0
Char Snipeur Messages postés 9813 Date d'inscription vendredi 23 avril 2004 Statut Contributeur Dernière intervention 3 octobre 2023 1 298
9 janv. 2014 à 12:17
Salut.
Utilise les balises de code pour mettre autant de ligne. Car là, c'est illisible.
Je ne sais pas si ça viens de ça, mais cette façon de faire est débile :
head=/*(personne*)*/malloc(sizeof(personne));
head=NULL;
Tu alloues de l'espace mémoire de la taille d'une personne, que tu référence dans "head" et ensuite, tu fait pointé "head" ailleurs. Donc, ton allocation mémoire est perdue ! Et j'en ai vu pas mal des écritures de ce genre !
0
[Dal] Messages postés 6198 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 13 décembre 2024 1 096
9 janv. 2014 à 14:20
Char Snipeur a raison,

Tu peux remplacer le code qu'il te signale par le code suivant :

head = /*(personne*)*/malloc(sizeof(personne));
if (head == NULL)
{
    perror("Erreur : impossible d'allouer la mémoire");
    exit(EXIT_FAILURE);
}


qui sera bien plus utile.

Il n'y a aucun free() dans ton code... C'est un peu ennuyeux. Chaque allocation de mémoire avec alloc doit correspondre à un free.

De plus, quand tu fais :

int existe(personne*head, int CIN)
{
    personne*p;
    p = /*(personne*)*/malloc(sizeof(personne));
    p = NULL;
    p->next = /*(personne*)*/malloc(sizeof(personne));
    p->next = NULL;
    p = head;
    while ((p->next != NULL )||(p->CIN!= CIN)){
    p= p->next;
    }
    if (p->next != NULL )
    {
        return 1;
    } else {
        return 0;
    }; 
}


Tes allocations ne servent à rien (outre le fait que tu les écrases et que tu ne les libères pas), puisque tu te contentes d'utiliser le pointeur pointé par head que tu affectes à p (et donc il est de la responsabilité de la fonction appelante de vérifier que le pointeur pointe sur une zone mémoire effectivement allouée).

Donc, ce code donnera le même résultat, sans fuites mémoire et en plus simplifié :

int existe(personne*head, int CIN)
{
    personne*p;
    p = head;
    while ((p->next != NULL )||(p->CIN!= CIN))
        p = p->next;
    if (p->next != NULL )
        return 1;
    return 0;
}


Ce type d'erreurs est également fréquemment répété dans de nombreuses parties de ton code.


Dal
0