Liste chainée de liste chainée

Version imprimable

Bonjour, je rencontre un pb pour lire une liste chainée contenant une autre liste chainée dans un fichier.
La structure de ses listes est la suivante :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
typedef struct Famille {
	char nom[30];
	struct Famille *next;
	struct Enfant *tete;
} Famille;
 
typedef struct Enfant {
	char prenom[30];
	struct Enfant *next;
} Enfant;

Pour enregistrer cette liste dans un fichier, j'utilise la fonction suivante :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
void sauvegarder(Famille **tete) {
	Famille *p = *tete;
	Enfant *e = NULL;
	FILE *f = fopen("db3", "wb");
 
	while(p != NULL) {
		fwrite(p, sizeof(Famille), 1, f);
 
		e = p->tete;
		while(e != NULL) {
			fwrite(e, sizeof(Enfant), 1, f);
			e = e->next;
		}
 
		p = p->next;
	}
 
	fclose(f);
}

Mon probleme se trouve dans la fonction charger. Je ne sais pas quoi mettre dans la boucle qui va relier chaque enfant à une famille.
Voila le code de la fonction :

Code:

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 charger(Famille **tete) {
	Famille *p = NULL, *q = NULL;
	Enfant *e = NULL, *ep = NULL;
	FILE *f = fopen("db3", "rb");
 
	*tete = NULL;
 
	while(!feof(f)) {
		p = (Famille *) malloc(sizeof(Famille));
		fread(p, sizeof(Famille), 1, f);
 
		if(*tete == NULL)
			*tete = p;
		else
			q->next = p;
		p->next = NULL;
		q = p;
 
		p->tete = NULL;
 
 		while() {
 			e = (Enfant *) malloc(sizeof(Enfant));
			fread(e, sizeof(Enfant), 1, f);
 
 			if(p->tete == NULL)
 				p->tete = e;
 			else
 				ep->next = e;
 			e->next = NULL;
 			ep = e;
 		}
	}
 
	fclose(f);
}

Merci d'avance pour votre aide.

17/11/2008, 13h20
matafan

Le format de ton fichier n'est pas correct, puisqu'il ne contient pas le lien qu'il y a entre un enfant et une famille. Il faut bien que tu réalises que sauvegarder les pointeurs dans le fichier comme tu le fais n'est d'aucun secour. Un pointeur est une adresse en mémoire. Quant tu lis ton fichier et que tu recréé tes structures, elles seront à des adresses différentes, et les pointeurs pointeront dans le vide.

Tu peux sauvegarder ton fichier sous forme texte style CVS de la forme
famille; enfant; enfant; enfant
famille; enfant
famille; enfant; enfant

la fonction sauvegarde serait de la forme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void sauvegarder(Famille **tete) {
	Famille *p = *tete;
	Enfant *e = NULL;
	FILE *f = fopen("db3", "w");
 
	while(p != NULL) {
		fprintf(f, p->nom, f);
 
		e = p->tete;
		while(e != NULL) {
			fprintf(f, ";%s", e->prenom);
			e = e->next;
		}
                fprintf(f, "\n");
		p = p->next;
	}
 
	fclose(f);
}

la fonction de lecture est un peu plus compliquée :

Code:

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
void charger(Famille **tete) {
	Famille *p = NULL, *q = NULL;
	Enfant *e = NULL, *ep = NULL;
	chat buf[1024];
 
	FILE *f = fopen("db3", "r");
 
	*tete = NULL;
 
	while(fgets(buf, sizeof buf, f) != NULL) {
		// on supprime d'abor le '\n' à la fin pour voir
		// si la taille du buffer est assez grande
		char *ptr = strchr(buf, '\n');
		char *ptr1;
 
		if (ptr == NULL)
		{
			// ici il y a problème
			// a toi de voir ce que tu veux faire
			return ???
		}
		// on supprime le '\n'
		*ptr = 0;
 
		// les cast sont inutiles en C
		p = malloc(sizeof(Famille));
 		if (p == NULL)
		{
			// ici il y a problème
			// a toi de voir ce que tu veux faire
			return ???
		}
 
		// on lit le nom de famille
		ptr = strchr(buf, ';');
		if (ptr != NULL)
		{
			*ptr = 0; 
			ptr1 = ptr+1;
		}
 
		strcpy(p->nom, buf);
 
		if(*tete == NULL)
			*tete = p;
		else
			q->next = p;
		p->next = NULL;
		q = p;
 
		p->tete = NULL;
 
		// on entre dans la boucle de lecture des enfants
		while (ptr != NULL)
		{
			ptr1 = ptr+1;
			ptr = strchr(ptr1, ';');
			if (ptr != NULL)
				*ptr = 0;
 
			e = malloc(sizeof(Enfant));
			if (e == NULL)
			{
				// ici il y a problème
				// a toi de voir ce que tu veux faire
				return ???
			}
 			strcpy(e->prenom, ptr1);
 			if(p->tete == NULL)
 				p->tete = e;
 			else
 				ep->next = e;
 			e->next = NULL;
 			ep = e;
 
		}
 	}
 
	fclose(f);
}

n'ayant pas le C sur ma machine actuellement, ce n'est pas testé, mais c'est l'idée.
Evidemment, comme le séparateur de champ est ';', celà ne marche pas s'il y en a un dans les noms de famille, mais c'est quand même assez rare, enfin je crois !

Merci pour cette reponse rapide ! :)
J'arrive bien à ecrire et a récupérer correctement mes familles. J'ai ajouter un char contenant 'F' quand j'enregistre une famille et un contenant 'E' quand j'enregistre un enfant.
Je recupere ce caractere et je le test dans ma fonction charger pour choisir le bon fread.

Je met ici les deux fonctions pour les gens que ca interesse.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
void sauvegarder(Famille **tete) {
	Famille *p = *tete;
	Enfant *e = NULL;
	FILE *f = fopen("db3", "wb");
	char cF = 'F', cE = 'E';
 
	while(p != NULL) {
		fwrite(&cF, sizeof(char), 1, f);
		fwrite(p, sizeof(Famille), 1, f);
 
		e = p->tete;
		while(e != NULL) {
			fwrite(&cE, sizeof(char), 1, f);
			fwrite(e, sizeof(Enfant), 1, f);
			e = e->next;
		}
 
		p = p->next;
	}
 
	fclose(f);
}

Code:

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
 
void charger(Famille **tete) {
	Famille *p = NULL, *q = NULL;
	Enfant *e = NULL, *ep = NULL;
	FILE *f = fopen("db3", "rb");
	char c;
 
	*tete = NULL;
 
	while(!feof(f)) {
		fread(&c, sizeof(char), 1, f);
		if(c == 'F') {
			p = (Famille *) malloc(sizeof(Famille));
			fread(p, sizeof(Famille), 1, f);
 
			if(*tete == NULL)
				*tete = p;
			else
				q->next = p;
			p->next = NULL;
			q = p;
 
			p->tete = NULL;
		} else {
			e = (Enfant *) malloc(sizeof(Enfant));
			fread(e, sizeof(Enfant), 1, f);
 
			if(p->tete == NULL)
				p->tete = e;
			else
				ep->next = e;
			e->next = NULL;
			ep = e;
		}
	}
 
	fclose(f);
}

17/11/2008, 14h25
Médinoc

Je pense qu'un format "Famille, nombre d'enfants, enfants" serait plus facile à lire, car il ne restreint pas le format de lecture. Ainsi, si tu faisais un programme utilisant des tableaux plutôt que des listes, il pourrait quand même lire le fichier facilement.
17/11/2008, 15h48
Trap D

Citation:

Envoyé par Médinoc

Je pense qu'un format "Famille, nombre d'enfants, enfants" serait plus facile à lire, car il ne restreint pas le format de lecture. Ainsi, si tu faisais un programme utilisant des tableaux plutôt que des listes, il pourrait quand même lire le fichier facilement.

Ça oblige à parcourir d'abord la liste des enfants, ou faire des positionnements toujours un peu dangereux dans le fichier.
Je reste persuadé que le format CSV (et non pas CVS comme je l'ai écrit tout à l'heure) est le meilleur pour ce genre de problème, même s'il la lecture/ecriture est plus lente.
17/11/2008, 15h59
Médinoc

En effet, il faudrait parcourir la liste avant.
D'un autre côté, c'est la même chose que faire un strlen() avant de dupliquer une chaîne: C'est une recherche de la valeur sentinelle pour calculer la taille.

À moins d'avoir un besoin vraiment critique en termes de performances, ça ne me parait pas handicapant.
17/11/2008, 19h22
bobhansel

Je n'ai pas utilisé de tableau ici car je ne voulais pas devoir reallouer un nouveau tableau à chaque fois que j'ajoute une famille ou un enfant.
D'autre part je ne pouvais pas non plus utiliser le format csv car j'enregistre dans cette structure d'autres elements binaires (des types propres à qt par exemple) que je n'ai pas postés ici pour ne pas alourdir le poste.
La methode que j'ai utilisée d'en mon dernier post est suffisante pour lier les enfants à chaque famille car comme j'enregistre tous les elements dans l'odre, des que je lis une famille, je sais que toutes les structures enfant suivantes appartiennent à cette famille.
Merci de votre aide.
Je reviendrais surement pour d'autres soucis :lol: