« GLib/GLib Data Types » : différence entre les versions
Contenu supprimé Contenu ajouté
Aucun résumé des modifications |
Aucun résumé des modifications |
||
Ligne 248 :
<source lang="c">
g_list_free(list);
return 0;
}
</source>
=== Tri, foreach ===
Pour trier une GList, nous allons utiliser une GCompareFunc.
Une GCompareFunc est une fonction de comparaison prenant en paramètre 2 gconstpointer et renvoyant un entier.
Cet entier est négatif si le premier argument est inférieur au second, 0 en cas d'égalité, positif sinon.
Toute valeur est possible, néanmoins il est de convention pour ce type de fonction de renvoyer -1, 0 et 1.
<source lang="c">
int trierEntiers(gconstpointer a, gconstpointer b) {
if( *((int*)a) < *((int*)b) ) return -1;
else if ( *((int*)a) == *((int*)b) ) return 0;
else return 1;
}
</source>
Faisons maintenant un petit programme qui démontrera comment utiliser le tri et le foreach (boucle itérative).
Son début ressemble à un exemple vu plus haut, plus la fonction de tri ci-dessus.
<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);
}
/* Cette fonction est conforme au prototype d'une GCompareFunc
* une GCompareFunc est une fonction prenant en paramètre 2 gconstpointer et renvoyant un entier
* cet entier est négatif si le premier argument est inférieur au second, 0 en cas d'égalité, positif sinon.
* un gconstpointer est un const void*
*/
int trierEntiers(gconstpointer a, gconstpointer b) {
if( *((int*)a) < *((int*)b) ) return -1;
else if ( *((int*)a) == *((int*)b) ) return 0;
else return 1;
}
/* Cette fonction est conforme au prototype d'une GFunc
* Le premier paramètre est l'élément courant d'une GList dans le cadre d'un appel de g_list_foreach,
* Le deuxième argument est commun à chaque appel (troisième argument de g_list_foreach).
*/
void additionnerEntiers(gpointer nb, gpointer total) {
* ((int*)total) += * ((int*)nb);
}
int main(int argc, char* argv[]) {
// 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;
// Nous allons faire saisir 10 nombres à l'utilisateur
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
/* Cette fonction renvoie un pointeur vers la nouvelle
* adresse de départ de la liste, car celle ci peut changer
*/
list = g_list_append(list,currentEntry);
// Incrémentation du compteur
cpt++;
}
</source>
g_list_sort prend en paramètre une GList et une fonction de comparaison.
<source lang="c">
list = g_list_sort(list, trierEntiers);
printf("Voici les éléments triés:\n");
int i = 0;
for( i=0; i<g_list_length(list); i++ ) {
printf("élément %i: %i\n", i, * ((int*) (g_list_nth(list,i)->data)) );
}
</source>
Faisons maintenant un foreach sur notre liste. Un foreach est une boucle qui itère sur chaque élément contenu dans une liste.
g_list_foreach est une fonction qui prend en paramètre une GList ainsi qu'un pointeur vers une GFunc (fonction ne renvoyant rien et recevant deux gpointer) et un pointeur vers une donnée commune à chaque appel qui sera effectué (deuxième argument de la GFunc, le premier étant l'élément courant de la liste).
<source lang="c">
g_list_foreach(list, additionnerEntiers, total);
printf("Le total des nombres saisis est: %i\n",*total);
</source>
Terminons proprement l'éxécution de notre programme.
<source lang="c">
// Libération de la liste
/* La fonction freeFunction se chargera de désallouer
* proprement les éléments qui ont étés réservés avec malloc
*/
g_list_free_full(list,freeFunction);
return 0;
}
| |||