[Résolu] Listes chaînées génériques
Bonsoir,
J'ai un projet d'informatique qui utilise beaucoup de listes chaînées, donc pour éviter de recoder à chaque fois les fonctions qui relient les maillons entre eux, j'ai pensé à utiliser des listes chaînées génériques.
Mais à partir de là je me rends compte que ça nécessite quand même beaucoup de fonctions à coder à côté pour gérer les données qui elles ne sont pas génériques... D'où une première question est-ce vraiment utile/utilisé ?
J'ai quand même codé une bibliothèque de fonctions gérant tout ça, mais lorsque dans le champ void* data, je souhaite insérer une structure Point, seul le premier champ x garde sa valeur, les deux autres étant mis à 0. Je ne comprends pas pourquoi :-S.
Voici mon code :
bibilothèque : listes génériques
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "d_linked_list.h"
Item*
create_item(void* data, size_t size)
{
Item* new_item = NULL;
if ((new_item = malloc(sizeof(Item))))
{
if ((new_item->data = malloc(size)))
{
memcpy(new_item->data, data, size);
new_item->next = NULL;
new_item->previous = NULL;
}
else
{
fprintf(stderr, "Allocation impossible\n");
}
}
else
{
fprintf(stderr, "Allocation impossible\n");
}
return new_item;
}
List
add_item_top_list(List* list, void* data, size_t size)
{
Item* item = NULL;
if ((item = create_item(data, size)))
{
if (*list != NULL)
{
item->next = *list;
item->next->previous = item;
}
*list = item;
}
else
{
return NULL;
}
return *list;
}
List
add_item_end_list(List* list, void* data, size_t size)
{
Item* item = NULL;
Item* index = NULL;
if ((item = create_item(data, size)))
{
if (*list == NULL)
{
*list = item;
}
else
{
index = go_to_end_list(list);
index->next = item;
item->previous = index;
}
}
else
{
return NULL;
}
return *list;
}
Item*
go_to_end_list(List* list)
{
Item* index = *list;
while (index->next != NULL)
{
index = index->next;
}
return index;
}
void
extract_item(List* list, Item* item)
{
if (*list == item)
{
*list = item->next;
item->next->previous = NULL;
item->next = NULL;
}
else if (item->next == NULL)
{
item->previous->next = NULL;
item->previous = NULL;
}
else
{
item->previous->next = item->next;
item->next->previous = item->previous;
item->next = NULL;
item->previous = NULL;
}
}
void
destroy_item(Item* item)
{
free(item);
}
void
destroy_list(List* list)
{
Item* tmp = *list;
do
{
tmp = tmp->next;
free(tmp->previous);
} while (tmp != NULL);
}
int
number_of_items(List* list)
{
int n = 0;
Item* item = NULL;
item = *list;
while (item != NULL)
{
n++;
item = item->next;
}
return n;
}
Item*
get_last_item(List* list)
{
Item* item = NULL;
item = *list;
while (item->next != NULL)
{
item = item->next;
}
return item;
} |
header de la biblio :
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
| #ifndef D_LINKED_LIST
#define D_LINKED_LIST
typedef struct item
{
void* data;
struct item* next;
struct item* previous;
} Item, *List;
Item*
create_item(void* data, size_t size);
List
add_item_top_list(List* list, void* data, size_t size);
List
add_item_end_list(List* list, void* data, size_t size);
Item*
go_to_end_list(List* list);
void
destroy_item(Item* item);
void
destroy_list(List* list);
int
number_of_items(List* list);
Item*
get_last_item(List* list);
#endif |
Le fichier de test :
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
| #include <stdio.h>
#include <stdlib.h>
#include "a_star.h"
#include "d_linked_list.h"
Point*
creer_point(int x, int y, int distance)
{
Point* nv_point = NULL;
if ((nv_point = malloc(sizeof(Point))))
{
nv_point->x = x;
nv_point->y = y;
nv_point->distance = distance;
}
else
{
fprintf(stderr, "Allocation impossible\n");
}
return nv_point;
}
void
afficher_liste(List* list)
{
Item* item = NULL;
Point* point = NULL;
item = *list;
while (item != NULL)
{
point = (Point*) item->data;
printf("%d %d %d\n", point->x, point->y, point->distance);
item = item->next;
}
}
int
main(void)
{
List list = NULL;
int i = 0;
Point* point = NULL;
for (i = 0; i < 10; i++)
{
point = creer_point(i, i, i);
printf("%d %d %d\n", point->x, point->y, point->distance);
list = add_item_end_list(&list, point, sizeof(point));
}
afficher_liste(&list);
return 0;
} |
header du fichier test :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| #ifndef A_STAR_H
#define A_STAR_H
#define X 60
#define Y 40
typedef struct point
{
int x;
int y;
int distance;
} Point;
Point*
creer_point(int x, int y, int distance);
#endif |
On voit apparaître le nom a_star pour l'algorithme de pathfinding, qui sera une des utilisations de la bibilothèque. Donc là j'essaye d'insérer des valeur de 0 à 9 dans les trois champs, on voit bien que la structure point est bien créée. En revanche après l'ajout dans la liste, problème...
Exemple : au début 111, 222, 333 puis après ajout 100 200 300...
Sinon, j'ai aussi essayé de faire une structure coordonnées pour rassemble les int x, int y mais ça commençait à faire struct de struct de struct et parfois je me retrouvais avec des item->data->coordonnees.x ou des choses dans la même style sans trop savoir pourquoi...
Si vous pouviez m'éclairer ce serait sympa ;-).
Merci à vous.
Bye.
