Discussion :

[grex1]

bonjour,
Je suis se tutorial:http://gtk.developpez.com/cours/gtk2/index.php
Sa fait longtemps que j'esaye d'apprendre la gtk,a chaque fois je bloque sur les listes chainé,y aurré t'"il un moyun de continuer a apprendre la gtk sens utiliser de liste chainé?
j'ai essayé d'aller directement au gtk entry en sautent les liste chaines,mais il s'en serve dans l'explication de fonctionement des gtk entry.

[liberforce]

Bonjour,

les listes chaînées sont avec les tableaux une structure de stockage de données très utilisée. Ça fait partie du B-A BA en C, ce n'est pas spécifique à la GLib et GTK+.

[gerald3d]

Un bon truc pour comprendre, construis-en une. C'est la méthode que je me suis imposée (il y a longtemps maintenant ). Ca m'a permis d'en comprendre tous les rouages.

[liberforce]

Et pour comprendre les pointeurs, qui sont la base des listes chaînées, l'incontournable Binky est là.

[ame="http://video.yahoo.com/watch/409141/2387613"]Pointer Fun with Binky on Yahoo! Video[/ame]

[grex1]

les pointeurs,c'est pas se qui m'a causé le plus de difficulté,le plus dur a comprendre sété les structures,mais mintenan je comprend.
Pris individuelment j'arrive a comprendre,mais il ne s'agis pas que de comprendre.
le probleme des liste chainé c'est qu'on utilise tout a la fois,alors je mélange tout.
Mais c'est déja bien d'être arrivé jusque la(sa seré con d'arrété) car je suis dyslexique,alors je suis pas senssé faire de la programmation.
J'arrive a compensser et je fait des copier coller pour l'ortographe des fonctions(et d'autre truck) mais c'est ma mémoire de travaille qui pose probleme.
J'ai aussi tendance a mettre tout dans le désordre,le coté programmation orienté objet de gtk m'avé aussi causé des probleme a se niveau la mais j'ai reussi a m'adapter avec du mal.
Mais pour les listes chainées j'ai tout éssayé mais c'est tros dur,a la fois faut que je me consentre sur l'ordre et a la fois sur les infos que je doit garder en mémoire.

[gerald3d]

Alors pour faire plus simple, il existe 2 types de listes chaînées:

1. simplement chainée,
2. doublement chaînée.

Les listes simplement chaînées :
Chaque élément de la liste doit avoir un pointeur sur la donnée sauvée et un pointeur sur l'emplacement de l'élément suivant.

Code :

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

1
2
3
4
5
6
7
element1
data
next     ------>    element2
                        data
                        next       -------->     element3
                                                     data
                                                     next

Cette forme de liste est la plus simple. L'inconvénient majeur est que l'on doit la parcourir de façon séquentielle (élément par élément) pour extraire l'élément X. Elle a l'avantage de ne pas être très gourmande en mémoire.

Les listes doublement chaînées:
Elles ont une forme presque identiques aux listes simplement chaînées. Cependant on ajoute une information à chaque élément. Cette fois-ci on dispose du pointeur sur l'élément précédent aussi.

Code :

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

1
2
3
4
5
6
7
8
9
10
element1
data
previous
next     ------>    element2
  ^                    data
   |---------------- previous
                        next       -------->     element3
                          ^                         data
                           |---------------------previous
                                                     next

Ainsi, à partir de n'importe quel élément on peut parcourir la liste dans un sens ou dans un autre. L'inconvénient est son occupation mémoire plus importante.

La structure:
On peut donc remarquer que "element" est une structure. On pourrait l'écrire ainsi:

Code :

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

1
2
3
4
5
6
struct _element
{
  struct _element previous;
  struct _element next;
  gpointer data;
};

Il suffit d'enlever la déclaration "previous" pour avoir la structure d'une liste simplement chaînée.

Les fonctions de la Glib:
Cette bibliothèque met à notre disposition toutes les fonctions nécessaires à l'utilisation de telles chaînes. Il n'est donc pas nécessaire de déclarer la structure. Seule la donnée à insérer est nécessaire.

Pour faire souple, les fonctions insèrent une donnée non typée. Comme ca on peut y insérer n'importe quoi. La seule contrainte est que la donnée doit être un pointeur sur une donnée.

Exemple:
Je désire sauver une liste de nombres allant de 0 à 10 dans une liste doublement chaînée. Pour les données soit j'alloue dynamiquement chaque élément dans le tas avec malloc, soit je déclare un tableau dans la pile.
Pour l'éxemple j'ai pris la deuxième solution, pour simplifier le code. Mais attention à ce genre d'utilisation. Il faut toujours être certain que les données existent toujours lors de leur utilisation.

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
#include <gtk/gtk.h>
 
int main(int argc, char *argv[])
{
	guint nombre[] ={0,1,2,3,4,5,6,7,8,9};
	GList *list=NULL;
	gint i=0;
 
	for (i=0; i< 10; i++)
	{
		/* Insertion de chaque élément dans la liste. A chaque insertion le
		 * pointeur "list" est initialisé sur le premier élément. Je passe ici sur
		 * les performances d'utilisation de "g_list_prepend();" par rapport à la
		 * fonction présente. Ce n'est pas le but de l'exemple.
		 */
		list=g_list_append(list, &nombre[i]);
	}
 
	/* Lecture de la liste. Ici je déclare un pointeur temporaire sur la liste
	 * pour ne pas perdre le premier pointeur de la liste.
	 */
	GList *TmpList=list;
	guint *element=NULL;
	while (TmpList)
	{
		element=(guint*)TmpList->data;
		g_print("élément : %d\n", *element);
		/* On passe à l'élément suivant. Si on est sur le dernier élément alors
		 * le pointeur suivant vaut NULL. Ce qui nous permet de sortir de la boucle
		 * while();*/
		TmpList=g_list_next(TmpList);
	}
 
	return 0;
}

J'ai essayé de faire des phrases les plus courtes possibles. Regarde aussi dans le code exemple il y a des commentaires.
En espérant que cela t'aide.