« GLib/GLib Data Types » : différence entre les versions

Contenu supprimé Contenu ajouté
Aucun résumé des modifications
Aucun résumé des modifications
Ligne 75 :
<source lang="c">
g_string_free(nom,TRUE);
return 0;
}
</source>
 
== GList ==
 
Le deuxième type que nous verrons est la GList classique, qui est une liste doublement chainée.
Une liste doublement chainée est représentée par un ensemble de noeuds, chacun ayant un pointeur vers le noeud précédent et le noeud suivant.
 
Les 3 premières fonctions que nous verrons sont:
* g_list_append, qui permet d'ajouter un élément à une liste.
* g_list_length, qui permet de connaitre la taille d'une liste.
* g_list_nth, qui permet d'obtenir un élément en fonction de son index.
 
Faisons maintenant un programme simple, dans lequel nous verrons comment ajouter, et obtenir les éléments d'une GList à l'aide de ces fonctions.
 
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <glib.h>
 
// Fonction de libération de la mémoire, voir plus bas
void freeFunction(gpointer data) {
free(data);
}
 
int main(int argc, char* argv[]) {
</source>
 
Initialisons nos variables:
 
<source lang="c">
// Déclaration d'un pointeur vers un entier
int* currentEntry = NULL;
// Déclaration d'un compteur
int cpt = 0;
// Déclaration et instantiation d'une GList
GList* list = NULL;
</source>
 
Comme vous l'avez peut être noté, NULL suffit à remplir un pointeur vers une GList vide. En effet, la fonction g_list_append s'occupera d'initialiser ce pointeur lors de l'ajout du premier élément.
 
glist_append renvoie un pointeur vers la nouvelle adresse de départ de la liste, car celle ci peut changer.
Son premier paramètre est un pointeur vers la liste.
Son deuxième paramètre est un pointeur vers la donnée à ajouter.
Si list vaut NULL, création d'une nouvelle GList.
 
Nous allons faire saisir 10 nombres à l'utilisateur.
<source lang="c">
while(cpt < 10) {
// Allocation mémoire pour un nombre entier
currentEntry = malloc(sizeof(int));
 
// Demande de saisie
printf("veuillez saisir le nombre %i: ",cpt);
scanf("%i",currentEntry);
 
// Ajout du nombre entier à la liste
list = g_list_append(list,currentEntry);
// Incrémentation du compteur
cpt++;
}
</source>
 
Voyons comment déterminer la taille de la liste et accéder aux éléments par leur index.
<source lang="c">
printf("démonstration de l'accès aux éléments par leur index:\n");
// g_list_length prend en paramètre une liste et renvoie sa taille
int i = 0;
for( i=0; i<g_list_length(list); i++ ) {
/* g_list_nth prend en paramètre une liste et un index
* et renvoie une structure GList
* dont le membre data est le pointeur vers l'élément contenu
*/
printf("élément %i: %i\n", i, * ((int*) (g_list_nth(list,i)->data)) );
}
</source>
 
g_list_free_full prend en paramètre une GList qu'elle désalouera, en appelant auparavant freeFunction sur chacun de ses éléments.
freeFunction est un pointeur de fonction cette fonction ne renvoie rien et prend en paramètre un pointeur vers un élément de notre liste.
La fonction freeFunction se chargera de désallouer proprement les éléments qui ont étés réservés par malloc.
<source lang="c">
g_list_free_full(list,freeFunction);
return 0;
}