[GTK] Piles avec listes chainees

Version imprimable

Bonsoir,

J'ai tenté de coder la fonction empiler et dépiler en GTK, cependant lorsque je compile, le programme plante. Je pense que ceci est du à ma fonction dépiler que j'ai du mal à coder. Serait-il possible que vous m'expliquiez mes erreurs svp ? A dire vrai j'ai pas mal de lacunes en ce qui concerne les listes chainées.
Merci

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
#include <stdlib.h>
#include <gtk/gtk.h>
 
 
 
//typedef
struct GSList{
  gint donnee;
  struct GSList *suivant;
};
//GSList;
 
typedef struct ListeRepere{
  struct GSList *debut;
  int taille;
} t_liste;
 
 
/* initialisation */
void initialisation (t_liste *tas);
 
/* EMPILER*/
int empiler (t_liste *tas, gint donnee);
 
/* DEPILER*/
int depiler (t_liste *tas);
 
/* Affichage de élément en haut de la pile (LastInFirstOut) */
#define pile_donnee(tas)  tas->debut->donnee
 
/* Affiche la pile */
void affiche (t_liste *tas);
 
 
void initialisation (t_liste * tas){
  tas->debut = NULL;
  tas->taille = 0;
}
 
/* empiler (ajouter) un élément dans la pile */
int empiler (t_liste * tas, gint donnee)
{
  struct GSList *nouveau_element = NULL;
 
 
  nouveau_element = g_slist_append(nouveau_element,(gint*)donnee);
 
  nouveau_element->suivant = tas->debut;
  tas->debut = nouveau_element;
  tas->taille++;
}
 
/* depiler (supprimer un élément de la pile */
int depiler (t_liste * tas){
  struct GSList *supp_element;
  if (tas->taille == 0)
    return -1;
 
  supp_element = (gint*)g_slist_nth_data(supp_element, tas->debut->donnee);
 
  tas->debut->donnee = (gint*)(supp_element->donnee);
 
  supp_element = g_slist_remove(supp_element, (gint*)tas->debut->donnee);
 
 
  tas->debut = tas->debut->suivant;
  g_slist_free (&supp_element->donnee);
  g_slist_free (supp_element);
  tas->taille--;
  return 0;
}
 
/* affichage de la pile */
void affiche (t_liste * tas){
  struct GSList *courant;
  gint i;
  courant = tas->debut;
 
  for(i=0;i<tas->taille;++i){
    g_print("\t\t%d\n", courant->donnee);
    courant = courant->suivant;
  }
}
 
int main (int   argc,char *argv[])
{
  t_liste *tas;
  gint valeur;
 
  GtkWidget *pWindow;
 
 
  gtk_init(&argc, &argv);
 
  pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(pWindow), "Le widget GtkEntry");
  gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
  //g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
  if ((tas = (t_liste *) malloc (sizeof (t_liste))) == NULL)
    return -1;
 
  initialisation (tas);
 
 
  g_print ("Entrez un nombre : ");
  scanf ("%d", &valeur);
  empiler (tas, valeur);
  g_print ("La pile (%d elements): \n",tas->taille);
  g_print("\n********** Haut de la PILE **********\n");
  affiche(tas);
  g_print("__________ Bas de la PILE __________\n\n");
 
  g_print ("Entrez un nombre : ");
  scanf ("%d", &valeur);
  empiler (tas, valeur);
  g_print ("La pile (%d elements): \n",tas->taille);
  g_print("\n********** Haut de la PILE **********\n");
  affiche(tas);
  g_print("__________ Bas de la PILE __________\n\n");
 
  g_print ("Entrez un nombre : ");
  scanf ("%d", &valeur);
  empiler (tas, valeur);
  g_print ("La pile (%d elements): \n",tas->taille);
  g_print("\n********** Haut de la PILE **********\n");
  affiche(tas);
  g_print("__________ Bas de la PILE __________\n\n");
 
 
  g_print ("\nLe dernier entre est supprime\n");
  depiler (tas);              // suppression de dernier element entre
  g_print ("La pile (%d elements): \n",tas->taille);
  g_print("\n********** Haut de la PILE **********\n");
  affiche(tas);
  g_print("__________ Bas de la PILE __________\n\n");
 
 
  gtk_widget_show(pWindow);
 
  g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
  gtk_main();
  return EXIT_SUCCESS;
}

28/10/2010, 20h42
gerald3d

Pour commencer tu définies une structure qui s'appelle GSList. Ce type de donnée est déjà définie par la GLib. Je pense que ca doit déjà poser pas mal de problèmes au compilateur ;).
28/10/2010, 20h58
BB008

J'ai modifié le nom de la structure mais en compilant j'ai beaucoup des erreurs alors qu'avant je n'avais que des warnings. Merci tout de même pour la réponse.

Pour te donner une idée de la déclaration en voila une typique :
Code:

1 2 3 4 5 6 7 8 9 typedef struct { gint donnee; struct SPile *suivant; }SPile; typedef struct { SPile *debut; gint taille; } t_liste;

29/10/2010, 10h51
BB008

Merci beaucoup ! Mais en modifiant, j'obtiens cette erreur lorsque je compile :
Z:\ESSAI PILE\main.c|67|error: dereferencing pointer to incomplete type.

Je ne vois pas où se situe le problème de pointeurs.
Pourriez-vous m'éclairer svp ?

Merci d'avance.
29/10/2010, 18h59
gerald3d

En regardant ton code je ne comprends pas bien où tu veux en venir.

Pour faire une pile FIFO ou LIFO avec une liste chaînée c'est relativement simple.
Les GList et GSList de la GLib mettent à ta disposition différentes fonctions qui simplifient grandement la gestion. Par exemple tu peux savoir à tout moment le nombre d'éléments inclus dans la liste, tu peux extraire le premier élément, le dernier élément au choix. La seule gestion personnelle est la limitation du nombre d'éléments que tu veux.

En partant de ce principe la structure t_liste est inutile. Le pointeur suivant dans la structure SPile est aussi inutile puisque la GSList (ou GList) gère tout ca pour nous. En résumé la structure SPile est aussi inutile. Seul un pointeur valide sur int est nécessaire.

Une fois le constat fait on peut maintenant nettoyer le code :D.

Je te donne ton code complétement revu avec les commentaires du post précédent.

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
#include <stdlib.h>
#include <gtk/gtk.h>
 
 
/* initialisation */
void initialisation (GList **pile);
 
/* EMPILER*/
int empiler (GList **pile, gint donnee);
 
/* DEPILER*/
int depiler (GList **pile);
 
/* Affiche la pile */
void affiche (GList *pile);
 
 
void pile_empty(gpointer data, gpointer user_data)
{
  g_free(data);
}
 
void initialisation (GList **pile){
  g_list_foreach(*pile, (GFunc)pile_empty, NULL);
  *pile=NULL;
}
 
/* empiler (ajouter) un élément dans la pile */
int empiler (GList **pile, gint donnee)
{
  gint *data = g_new(int, 1);
 
  *data = donnee;
 
  *pile = g_list_prepend(*pile, data);
 
  return 0;
}
 
/* depiler (supprimer un élément de la pile) */
int depiler (GList **pile){
  GList *list = *pile;
  gint *data=NULL;
 
  if (*pile==NULL)
    return -1;
 
  data = (gint*)list->data;
  *pile = g_list_remove (*pile, list->data);
 
  g_free(data);
  return 0;
}
 
/* affichage de la pile */
void affiche (GList *pile){
  GList *list = g_list_first(pile);
 
  while (list){
    g_print("\t\t%d\n", *(gint*)list->data);
    list = g_list_next(list);
  }
}
 
int main (int   argc,char *argv[])
{
  GList *pile=NULL;
  gint valeur;
 
  initialisation (&pile);
 
  g_print ("Entrez un nombre : ");
  scanf ("%d", &valeur);
  empiler (&pile, valeur);
  g_print ("La pile (%d elements): \n", g_list_length(pile));
  g_print("\n********** Haut de la PILE **********\n");
  affiche(pile);
  g_print("__________ Bas de la PILE __________\n\n");
 
  g_print ("Entrez un nombre : ");
  scanf ("%d", &valeur);
  empiler (&pile, valeur);
  g_print ("La pile (%d elements): \n", g_list_length(pile));
  g_print("\n********** Haut de la PILE **********\n");
  affiche(pile);
  g_print("__________ Bas de la PILE __________\n\n");
 
  g_print ("Entrez un nombre : ");
  scanf ("%d", &valeur);
  empiler (&pile, valeur);
  g_print ("La pile (%d elements): \n", g_list_length(pile));
  g_print("\n********** Haut de la PILE **********\n");
  affiche(pile);
  g_print("__________ Bas de la PILE __________\n\n");
 
 
  g_print ("\nLe dernier entre est supprime\n");
  depiler (&pile);              // suppression de dernier element entre
  g_print ("La pile (%d elements): \n", g_list_length(pile));
  g_print("\n********** Haut de la PILE **********\n");
  affiche(pile);
  g_print("__________ Bas de la PILE __________\n\n");
 
  return EXIT_SUCCESS;
}

29/10/2010, 21h25
BB008

Oui, effectivement, mon code n'a ni queue ni tête. Je vais suivre vos indications et reprendre mon code. Je vous remercie de m'avoir aidée.
02/11/2010, 18h49
liberforce

Les piles (LIFO et FIFO) sont implémentées dans la GLib par GQueue.
g_queue_push_head ajoute en début de queue, g_queue_push_tail ajoute en fin de queue, g_queue_pop_head enlève en début de queue, et g_queue_pop_tail enlève en fin de queue.