Discussion :

[Almenor]

Bonjour,

Voici mon problème :

J'ai ces structure qui vont être utilisées dans un arbre binaire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
struct personne
    {
        char nom[31];//nom de la personne (30 caractère max)
        char prenom[31];//prénom de la personne (30 caractère max)
        char nationalite[41];//nationalité de la personne (40 caractère max)
    };
 
    struct film
    {
        char titre[51];//titre du film (50 caractère max)
        struct personne realisateur;//réalisateur du film
        struct personne *liste;//tableau dynamique de personnes (acteurs)
        int nbr;//nombre d'acteur dans le film
        int an;//année de réalisation du film
    };
 
    struct noeud//arbre binaire
    {
        struct film fi;
        struct noeud *fg;//pointe vers le fils gauche
        struct noeud *fd;//pointe vers le fils droit
    };

J'essaye d'écrire une fonction save qui as écrire les données encodées dans un fichier et une fonction read qui vas les lire et les réinserer.

La fonction save à l'air de fonctionner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
void recursave (struct noeud* ptr,FILE *fp)
{
     if(ptr != NULL)
     {
            fwrite(ptr, sizeof(struct noeud), 1, fp);
            recursave(ptr->fg,fp);
            recursave(ptr->fd,fp);
     }
}
 
 
 
void save(struct noeud *racine)
{
    FILE *fp = NULL;
    if(!(fp = fopen("data","wb")))
         printf("erreur ouverture fichier!\n");
    else
    {
        if(!racine)
        {    
            printf("Il n'y a rien %c %ccrire dans le fichier\n",133,130);
            system("pause");
            system("cls");
        } 
        else
        {    
            recursave(racine,fp);
            printf("Les donn%ces ont %ct%c sauvegard%ces avec succ%cs\n",130,130,130,130,138);
            system("pause");
            system("cls");
        } 
    }
    if(fclose(fp))
        printf("Erreur fermeture fichier.\n");
}

Mais je ne peux pas le savoir avec cetitude car ma fonction read refuse de fonctionner, j'ai un plantage mais aucunes erreurs ni warning à la compilation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void read(struct noeud *racine)
{
    struct film *f;
    FILE *fp = NULL;
    if (!(fp = fopen("data","rb")))
          printf("erreur ouverture fichier!\n");
    else
    {
        while((fread(f,sizeof(struct film),1,fp)) != EOF);
            inserer(&racine,new_noeud(*f));
        if(fclose(fp))
            printf("Erreur fermeture fichier.\n");
    }
}

Merci d'avance pour votre aide

[diogene]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

inserer(&racine,new_noeud(*f));

Il faudrait donner le code des fonctions inserer() et new_noeud()

C'est normal ce ; ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        while((fread(f,sizeof(struct film),1,fp)) != EOF);
            inserer(&racine,new_noeud(*f));

[Almenor]

non, il faut enlever le point virgule

tout le reste fonctionne à la perfection, insertion dans l'arbre binaire, affichage des données, etc...

mais voici quand même les fonctions demandées :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
struct noeud *new_noeud(struct film f)//crée un nouveau noeud et renvoie l'adresse du noeud
{
    struct noeud *ptr = NULL;
    if((ptr = (struct noeud*) malloc(sizeof(struct noeud))) == NULL)
    {
        fprintf(stderr,"Allocation Impossible");
        exit(EXIT_FAILURE);
    }
    else
    {
        ptr->fi = f;
        ptr->fg = NULL;
        ptr->fd = NULL;
    }
    return ptr;
}
 
void inserer(struct noeud **racine, struct noeud *nouv)
{
    if (*racine == NULL) // si l'arbre est vide 
        *racine = nouv;
    else
    {
        //on compare les titres des films
        if(strcmp((*racine)->fi.titre,nouv->fi.titre) >= 0)//si la fonction strcmp renvoi 0 ou 1 (alphabétiquement supérieur ou égal)
            inserer(&((*racine)->fg),nouv);//on insère à gauche
        else
            inserer(&((*racine)->fd),nouv);//sinon on insère à droite (aphabétiquement inférieur)
    }
}

[diogene]

Dans la fonction read() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void read(struct noeud *racine)
{
    struct film *f;
    FILE *fp = NULL;
    if (!(fp = fopen("data","rb")))
          printf("erreur ouverture fichier!\n");
    else
    {
        while((fread(f,sizeof(struct film),1,fp)) != EOF);
            inserer(&racine,new_noeud(*f));
.....

1- La lecture par fread() va planter : l'adresse de destination est celle contenue dans f et dans f, il n'y a rien de mis. De plus, il n'y a pas de place réservée pour stocker la structure.
Tu dois mettre l'adresse d'une struct film, pas un pointeur sur une struct film

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
struct film f;
....
        while((fread(&f,sizeof(struct film),1,fp)) != EOF)....

2- La fonction inserer() doit pouvoir modifier la tête de liste et c'est pourquoi tu as mis comme argument un struct noeud **. Elle va donc modifier la valeur de racine qui est une variable locale à la fonction mais cela ne modifiera pas la tête de la liste utilisée pour appeler read().

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void read(struct noeud **racine)
{
    struct film f;
    FILE *fp = NULL;
    if (!(fp = fopen("data","rb")))
          printf("erreur ouverture fichier!\n");
    else
    {
        while((fread(&f,sizeof(struct film),1,fp)) != EOF)
            inserer(racine,new_noeud(f));
....

En modifiant en conséquence l'argument d'appel de read().

[Almenor]

Merci pour ton aide

Cependant, aucun message d'erreur, aucun warning, quand j'appel la fonction read rien ne se passe, même pas un plantage, comme si ça bouclait...

Je me demande si cette partie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while((fread(&f,sizeof(struct film),1,fp)) != EOF)

fonctionne correctement.

Peut être devrais-je ajouter un symbole non utilisé comme une un point virgule à la fin du fichier dans la fonction save puis lire le fichier jusqu'a ce qu'il rencontre ce point virgule ?

Mais je ne comprends pas pourquoi ça ne marcherai pas avec EOF...

[diogene]

n1256 :

7.19.8.1 The fread function
size_t fread(void * restrict ptr, size_t size, size_t nmemb, FILE * restrict stream);
....
The fread function returns the number of elements successfully read, which may be less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero, fread returns zero and the contents of the array and the state of the stream remain unchanged.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while((fread(&f,sizeof(struct film),1,fp)) == 1)

[Almenor]

*part se cacher*

Merci

[Almenor]

fread 2 : le retour

Je n'ouvre pas un nouveau sujet car c'est pour un problème identique.

On peut voir dans les structure du 1er post que j'ai un tableau dynamique de structure personnes.

Pour gérer ça, j'ai modifier ma fonction recursave comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void recursave (struct noeud* ptr,FILE *fp)
{
     if(ptr != NULL)
     {
            int i = 0;
            fwrite(ptr, sizeof(struct noeud), 1, fp);
            fwrite(ptr->fi.liste, sizeof(struct personne), ptr->fi.nbr, fp);  
            recursave(ptr->fg,fp);
            recursave(ptr->fd,fp);
     }
}

ça m'a tout l'air correct lorsque j'ouvre le fichier créé.

Mon problème se situe encore dans la fonction read. Je l'ai modifiée comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void read(struct noeud **racine)
{
    int i = 0;
    struct film f;
    struct personne p;
    FILE *fp = NULL;
    if (!(fp = fopen("data","rb")))
          printf("erreur ouverture fichier!\n");
    else
    {
        while((fread(&f,sizeof(struct film),1,fp)) == 1)
        {
            if ((f.liste = malloc(f.nbr* sizeof(struct personne))) == NULL) 
            {
                fprintf(stderr,"Allocation Impossible");
                exit(EXIT_FAILURE);
            }
            for(i=0;i<f.nbr;i++)
            {
                fread(&p,sizeof(struct personne),1,fp);
                f.liste[i] =  p;
            }
            inserer(racine,new_noeud(f));
        }
        if(fclose(fp))
            printf("Erreur fermeture fichier.\n");
    }
}

je n'arrive pas à allouer la mémoire pour f.film => Allocation impossible.

[diogene]

Mais, f.film n'existe pas : f est un struct film et n'a pas de champ film.
Tu confonds avec un struct noeud.

D'ailleurs, tu écris un struct noeud et tu lis un struct film !

[Almenor]

Oula, là je commence à me dire que j'ai dû louper un truc ou deux...

Bon, je récapitule :

avant de vouloir insérer le tableau dynamique d'acteur, ça fonctionnait à merveille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void read(struct noeud **racine)
{
    struct film f;
    FILE *fp = NULL;
    if (!(fp = fopen("data","rb")))
          printf("erreur ouverture fichier!\n");
    else
    {
        while((fread(&f,sizeof(struct film),1,fp)) == 1)
        {
            inserer(racine,new_noeud(f));
        }
        if(fclose(fp))
            printf("Erreur fermeture fichier.\n");
    }
}

Donc, je crée une structure f de type film, dans laquelle je viens y mettre les données que j'ai récupérée sur le fichier, puis j'utilise ma fonction insérer à laquelle j'envoie l'adresse la racine ainsi que l'adresse de new_noeud avec la structure f en argument (les données sur le film récupérées dans le fichier).

Donc, quand j'ai écris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void read(struct noeud **racine)
{
    int i = 0;
    struct film f;
    struct personne p;
    FILE *fp = NULL;
    if (!(fp = fopen("data","rb")))
          printf("erreur ouverture fichier!\n");
    else
    {
        while((fread(&f,sizeof(struct film),1,fp)) == 1)
        {
            if ((f.liste = malloc(f.nbr* sizeof(struct personne))) == NULL) 
            {
                fprintf(stderr,"Allocation Impossible");
                exit(EXIT_FAILURE);
            }
            for(i=0;i<f.nbr;i++)
            {
                fread(&p,sizeof(struct personne),1,fp);
                f.liste[i] =  p;
            }
            inserer(racine,new_noeud(f));
        }
        if(fclose(fp))
            printf("Erreur fermeture fichier.\n");
    }
}

Je me suis dit que comme les données que j'ai récupérer dans mon fichier sont dans la structure f il me suffit d'allouer autan de mémoire qu'il y a d'acteurs encodé (f.nbr) multiplié par la taille d'une struct personne (sizeof(struct personne)) puisque c'est ça maintenant que l'on vas récuprer sur le fichier : mes données d'une (ou plusieurs personnes). On met tout ça dans une structure p de type personne et on alloue ça à la liste dynamique (f.liste[i] = p

Ou mon résonnement ne tient plus (pas ?) la route ?

Et j'ai essayé de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
if ((racine.fi.liste = malloc(f.nbr* sizeof(struct personne))) == NULL) 
            {
                fprintf(stderr,"Allocation Impossible");
                exit(EXIT_FAILURE);
            }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

303 J:\Projet_film\fonctions_film.c request for member `fi' in something not a structure or union

[diogene]

Ta fonction de lecture doit être le miroir de ta fonction d'écriture (recursave).

Celle-ci fait
1- l'écriture d'une struct noeud (*ptr), donc une struct film (ptr->fi), suivi éventuellement d'octets de bourrage, suivi d'un pointeur(ptr->fg) (qui n'a pas de sens une fois dans le fichier), suivi éventuellement d'octets de bourrage, suivi d'un pointeur (ptr->fg) (qui n'a pas de sens une fois dans le fichier), suivi éventuellement d'octets de bourrage.
2- puis de ptr->fi.nbr struct personne

On a alors schématiquement sur le disque (_ sont d'éventuels octets de bourrage des structures qui seront présent dans le fichier)

   [<fi>_<fg>_<fd>_][struct personne][struct personne][struct personne] ...

autrement dit

   [[<fi.titre>_<fi.realisateur>_<fi.liste>_<fi.nbr>_<Fi.an>_]_<fg>_<fd>_][struct personne]...[struct personne]
    <-----------------------struct film--------------------->             <----fi.nbr struct personne--------->
   <------------------------struct noeud-------------------------------->

Si on lit un struct film, après cette lecture on est positionné sur le fichier de cette façon :

   _<fg>_<fd>_][struct personne]...[struct personne]
               <----fi.nbr struct personne--------->

ce qui est une erreur.

Le mieux est d'écrire (et lire) la struct film (ptr->fi) puisque de toute façon les pointeurs sont inutilisables à la lecture.

[Almenor]

Ok ! Je comprends maintenant quand tu disait "D'ailleurs, tu écris un struct noeud et tu lis un struct film ! " et c'est tellement logique ...

Un grand merci