Discussion :

[shenmue]

Bonjour à tous,
J'ai pour objectif de réaliser une sorte de gestion de bibliothèque capable de sauvegarder les caractéristiques de livre dans un fichier, le tout sous liste chainée. Or dans mon programme , il se trouve que lorsque je sauvegarde une structure (se trouve les caractérisques d'un livre),dans le fichier de sauvegarde il n'y a pas les ce que j'ai rentré dans la structure.
Le problème c'est que je ne sais pas si je sauvegarde mal ou autre chose.
J'espere que vous pourrez m'aider a résoudre ce problème.
Je m'excuse d'avance car je sais que cela n'est pas tres rigoureux du point de vue codage mais je débute
Voici mon code:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include <stdio.h>
#include <stdlib.h>
 
 
typedef struct livre
{
       char titre[50];
       char auteur[50];
       char code[50];
 
       struct livre *precedent; //precedent pointe sur la structure precedente
}livre;
 
 
int initialisation(livre **p)
{
livre *ptr3;
 
FILE *fichier;
fichier=fopen("sauvegardelivres.txt", "rb");
 
do{
ptr3 = malloc(sizeof(livre));
ptr3->precedent = *p;
*p = ptr3;
}while(fread(ptr3 , 1 , sizeof(livre), fichier));
 
fclose(fichier);
}
 
 
int sauvegarder(livre *ptr)
{
FILE* fichier;
livre*ptr2;
ptr2=ptr;
    fichier = fopen("sauvegardelivres.txt", "wt");
 
    if (fichier != NULL)
  	 {
    	while(ptr2 != NULL){
    		fwrite(ptr2 , 1 , sizeof(livre), fichier);// On peut lire et écrire dans le fichier
    		ptr2 = ptr2->precedent;
   	 	} 
     	 }
    else
    	{
        	printf("Impossible d'ouvrir le fichier test.txt");
    	}
fclose(fichier);
}
 
 
void Ajoutlivre(livre **p)
{
 
     livre *nvlElement ;
 
     nvlElement= malloc(sizeof(livre));
 
 
     printf("Entrez le titre du livre:");
     gets(nvlElement->titre);
     printf("Entrez le nom de l auteur :");
     gets(nvlElement->auteur);
     printf("Entrez le code :");
     gets(nvlElement->code);
 
     nvlElement->precedent = *p; //adresse de l'element precedent pointé par pointeur p
 
     *p = nvlElement;       //p pointe sur le dernier element créé
 
}
 
 
void Affichage(livre *p)
{
     while (p!=NULL)
           {
           printf("%s\n",p->titre);
           printf("%s\n",p->auteur);
           printf("%s\n",p->code);
 
           p = (*p).precedent;
           }
} 
 
 
 
int main(int argc, char *argv[])
{	
    livre *pointSommet = NULL;
   // initialisation(&pointSommet);
   // Affichage(pointSommet);
 
    Ajoutlivre(&pointSommet);
    sauvegarder(pointSommet);
    Affichage(pointSommet);
 
    system("PAUSE");
    return 0;
}

La fonction initialisation sert à récuperer les livres déja sauvegarder et construire la liste chainée qui servira a la gestion de la bibliothèque.
Voila, j'espere que j'aurai été assez clair.
Merci

[Sve@r]

Certains compilos modifient les structures pour les optimiser (alignement sur un mot, etc). Et donc le danger de ce genre de manip (je bazarde la structure d'un coup par fwrite) c'est que tu ne pourras relire ton fichier que sur la même machine avec le compilo qui t'aura généré la même structure dans le programme de relecture.

Une méthode plus "souple" consiste à faire du fprintf() pour chaque champs de ta structure et tu sépares, dans le fichier, les champs avec un séparateur déterminé (point-virgule par exemple) => tu écris un CSV en somme. Ton fichier pourra être porté sur n'importe quel autre système et ton programme de lecture (qui utilisera "fscanf()") pourra le relire n'importe où.

Bien entendu, quelle que soit la méthode que tu utiliseras, cela ne sert à rien d'écrire dans le fichier le pointeur "*suivant" car ce pointeur n'a de signification que dans le programme en exécution. Lors de la relecture, il te faudra
- lire un enregistrement
- mémoriser cet enregistrement dans ta liste via les opérations d'insertions classiques de ton programme

[shenmue]

Sve@r, merci de m'avoir répondu.
Donc si je te suis bien, on enregistre les données en texte et non pas en binaire pour évité les erreurs que tu as cité.
Or en binaire, ca semble plus simple de recuperer les structures avec un malloc (désolé mais j'essaye de faire plus simple, j'ai un peu du mal à comprendre).
Sinon je vais essayer d'appliquer ta méthode si j'y arrive

merci

[nicolas.sitbon]

Normalement tu as ce qu'il faut comme explication ici :
http://emmanuel-delahaye.developpez....m#enreg_struct
Cordialement.