Didacticiel: glib

Page suivante Page précédente Table des matières

## 17. glib

La glib fournit de nombreuses fonctions et définitions utiles, prêtes à être utilisées lorsqu'on crée des applications GDK et GTK. Je les énumèrerais toutes avec une brève explication. Beaucoup sont des répliques des fonctions standards de la libc, et je ne les détaillerais donc pas trop. Ceci doit surtout servir de référence afin de savoir ce qui est disponible pour être utilisé.

## 17.1 Définitions

Les définitions pour les bornes de la plupart des types standards sont :

> `

>     G_MINFLOAT
>     G_MAXFLOAT
>     G_MINDOUBLE
>     G_MAXDOUBLE
>     G_MINSHORT
>     G_MAXSHORT
>     G_MININT
>     G_MAXINT
>     G_MINLONG
>     G_MAXLONG

> `

Voici aussi les redéfinitions de types. Celles qui ne sont pas spécifiées sont configurées dynamiquement selon l'architecture. Évitez surtout de compter sur la taille d'un pointeur si vous voulez un programme portable ! Un pointeur sur un Alpha fait 8 octets, mais il en fait 4 sur un Intel.

> `

>     char   gchar;
>     short  gshort;
>     long   glong;
>     int    gint;
>     char   gboolean;

>     unsigned char   guchar;
>     unsigned short  gushort;
>     unsigned long   gulong;
>     unsigned int    guint;

>     float   gfloat;
>     double  gdouble;
>     long double gldouble;

>     void* gpointer;

>     gint8
>     guint8
>     gint16
>     guint16
>     gint32
>     guint32

> `

## 17.2 Listes doublement chaînées

Les fonctions suivantes servent à créer, gérer et détruire des listes doublement chaînées. Je suppose que vous savez ce qu'est une liste chaînée car leur explication n'entre pas dans le cadre de ce document. Bien sûr, il n'y a pas besoin de les connaître pour une utilisation générale de GTK, mais c'est bien de savoir comment elles fonctionnent.

> `

>     GList* g_list_alloc       (void);

>     void   g_list_free        (GList     *list);

>     void   g_list_free_1      (GList     *list);

>     GList* g_list_append      (GList     *list,
>                                gpointer   data);

>     GList* g_list_prepend     (GList     *list,
>                                gpointer   data);

>     GList* g_list_insert      (GList     *list,
>                                gpointer   data,
>                                gint       position);

>     GList* g_list_remove      (GList     *list,
>                                gpointer   data);

>     GList* g_list_remove_link (GList     *list,
>                                GList     *link);

>     GList* g_list_reverse     (GList     *list);

>     GList* g_list_nth         (GList     *list,
>                                gint       n);

>     GList* g_list_find        (GList     *list,
>                                gpointer   data);

>     GList* g_list_last        (GList     *list);

>     GList* g_list_first       (GList     *list);

>     gint   g_list_length      (GList     *list);

>     void   g_list_foreach     (GList     *list,
>                                GFunc      func,
>                                gpointer   user_data);

> `

## 17.3 Listes simplement chaînées

La plupart des fonctions pour les listes simplement chaînées ci-dessous sont identiques à celles vues plus haut. Voici une liste complète :

> `

>     GSList* g_slist_alloc       (void);

>     void    g_slist_free        (GSList   *list);

>     void    g_slist_free_1      (GSList   *list);

>     GSList* g_slist_append      (GSList   *list,
>                                  gpointer  data);

>     GSList* g_slist_prepend     (GSList   *list,
>                                  gpointer  data);

>     GSList* g_slist_insert      (GSList   *list,
>                                  gpointer  data,
>                                  gint      position);

>     GSList* g_slist_remove      (GSList   *list,
>                                  gpointer  data);

>     GSList* g_slist_remove_link (GSList   *list,
>                                  GSList   *link);

>     GSList* g_slist_reverse     (GSList   *list);

>     GSList* g_slist_nth         (GSList   *list,
>                                  gint      n);

>     GSList* g_slist_find        (GSList   *list,
>                                  gpointer  data);

>     GSList* g_slist_last        (GSList   *list);

>     gint    g_slist_length      (GSList   *list);

>     void    g_slist_foreach     (GSList   *list,
>                                  GFunc     func,
>                                  gpointer  user_data);

> `

## 17.4 Gestion de la mémoire

> `

>     gpointer g_malloc      (gulong    size);

> `

Remplace malloc(). On n'a pas besoin de vérifier la valeur de retour car cela est fait pour nous dans cette fonction.

> `

>     gpointer g_malloc0     (gulong    size);

> `

Identique à la précédente, mais initialise la mémoire à zéro avant de retourner un pointeur vers la zone réservée.

> `

>     gpointer g_realloc     (gpointer  mem,
>                             gulong    size);

> `

Réalloue size octets de mémoire à partir de mem. Évidemment, la mémoire doit avoir été allouée auparavant.

> `

>     void     g_free        (gpointer  mem);

> `

Libère la mémoire. Facile.

> `

>     void     g_mem_profile (void);

> `

Produit un profil de la mémoire utilisée, mais requiert l'ajout de #define MEM_PROFILE au début de glib/gmem.c, de refaire un make et un make install.

> `

>     void     g_mem_check   (gpointer  mem);

> `

Vérifie qu'un emplacement mémoire est valide. Nécessite que l'on ajoute #define MEM_CHECK au début de gmem.c que l'on refasse un make et un make install.

## 17.5 Timers

Fonctions des timers...

> `

>     GTimer* g_timer_new     (void);

>     void    g_timer_destroy (GTimer  *timer);

>     void    g_timer_start   (GTimer  *timer);

>     void    g_timer_stop    (GTimer  *timer);

>     void    g_timer_reset   (GTimer  *timer);

>     gdouble g_timer_elapsed (GTimer  *timer,
>                              gulong  *microseconds);

> `

## 17.6 Gestion des chaînes

Un ensemble complet de fonction de gestion des chaînes. Elles semblent toutes très intéressantes et sont sûrement meilleures, à bien des égards, que les fonctions C standards, mais elle nécessitent de la documentation.

> `

>     GString* g_string_new       (gchar   *init);
>     void     g_string_free      (GString *string,
>                                  gint     free_segment);

>     GString* g_string_assign    (GString *lval,
>                                  gchar   *rval);

>     GString* g_string_truncate  (GString *string,
>                                  gint     len);

>     GString* g_string_append    (GString *string,
>                                  gchar   *val);

>     GString* g_string_append_c  (GString *string,
>                                  gchar    c);

>     GString* g_string_prepend   (GString *string,
>                                  gchar   *val);

>     GString* g_string_prepend_c (GString *string,
>                                  gchar    c);

>     void     g_string_sprintf   (GString *string,
>                                  gchar   *fmt,
>                                  ...);

>     void     g_string_sprintfa  (GString *string,
>                                  gchar   *fmt,
>                                  ...);

> `

## 17.7 Utilitaires et fonctions d'erreurs

> `

>     gchar* g_strdup    (const gchar *str);

> `

Remplace la fonction strdup. Elle copie le contenu de la chaîne d'origine dans la mémoire venant d'être allouée et retourne un pointeur sur cette zone.

> `

>     gchar* g_strerror  (gint errnum);

> `

Je recommande de l'utiliser pour tous les messages d'erreur. Elle est beaucoup plus propre et plus portable que perror() ou les autres. La sortie est habituellement de la forme :

> `

>     nom du programme:fonction qui a échoué:fichier ou autre descripteur:strerror

> `

Voici un exemple d'appel utilisé dans le programme « Bonjour tout le monde ! » :

> `

>     g_print("bonjour_monde:open:%s:%s\n", filename, g_strerror(errno));

> `

> `

>     void g_error   (gchar *format, ...);

> `

Affiche un message d'erreur. Le format est comme printf, mais il ajoute « ** ERROR **: » au début du message et sort du programme. À n'utiliser que pour les erreurs fatales.

> `

>     void g_warning (gchar *format, ...);

> `

Comme au dessus, mais ajoute « ** WARNING **: », et ne termine pas le programme.

> `

>     void g_message (gchar *format, ...);

> `

Affiche « message: » avant la chaîne passée en paramètre.

> `

>     void g_print   (gchar *format, ...);

> `

Remplace printf().

Enfin la dernière fonction :

> `

>     gchar* g_strsignal (gint signum);

> `

Affiche le nom du signal système Unix correspondant au numéro de signal. Utile pour les fonctions génériques de gestion de signaux.

Tout ce qui est ci-dessus est plus ou moins volé à glib.h. Si quelqu'un s'occupe de documenter une fonction, qu'il m'envoit un courrier !

Page suivante Page précédente Table des matières