Página siguiente Página anterior Índice general

22. glib

glib proporciona muchas definiciones y funciones útiles disponibles para su utilización cuando se crean aplicaciones GDK y GTK. Haré una lista con todas ellas incluyendo una pequeña explicación. Muchas no son más que duplicados de funciones estándar de libc por lo que no entraré en detalle en la explicación de las mismas. Esta sección está pensada principalmente para que se utilice como referencia, para que sepa que es lo que puede utilizar.

22.1 Definiciones

Las definiciones para los límites de muchos de los tipos estándar son:

G_MINFLOAT
G_MAXFLOAT
G_MINDOUBLE
G_MAXDOUBLE
G_MINSHORT
G_MAXSHORT
G_MININT
G_MAXINT
G_MINLONG
G_MAXLONG

Y también, los siguientes typedefs. Cuando no se especifica el tipo que debería aparecer a la izquierda significa que el mismo se establecerá dinámicamente en función de la arquitectura. ¡Recuerde evitar los calculos relativos al tamaño de un puntero si quiere que su aplicación sea portable! P.e., un puntero en un Alpha tiene 8 bytes, pero 4 en 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

22.2 Listas doblemente enlazadas

Las funciones siguientes se utilizan para crear, manipular, y destruir listas doblemente enlazadas. Supondré que sabe lo que son las listas enlazadas, ya que explicarlas va más allá del objetivo de este documento. Por supuesto, no es necesario que conozca como manejar todo esto para utilizar GTK, pero siempre es bonito aprender cosas.

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 );

22.3 Listas simplemente enlazadas

Muchas de las funciones para las listas enlazadas son idénticas a las de más arriba. Aquí hay una lista completa:

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 );
        

22.4 Control de la memoria

gpointer g_malloc( gulong size );

Reemplaza a malloc(). No necesita comprobar el valor devuelto, ya que ya lo hace por usted esta función.

gpointer g_malloc0( gulong size );

Lo mismo que antes, pero rellena con ceros la memoria antes de devolver un puntero a ella.

gpointer g_realloc( gpointer mem,
                    gulong   size );

Vuelve a reservar size bites de memoria empezando en mem. Obviamente, la memoria debe haber sido previamente reservada.

void g_free( gpointer mem );

Libera la memoria. Fácil.

void g_mem_profile( void );

Crea un fichero donde vuelca la memoria que se está utilizando, pero tiene que añadir #define MEM_PROFILE en lo alto de glib/gmem.c y tendrá que hacer un make y un make install.

void g_mem_check( gpointer mem );

Comprueba que una dirección de memoria es válida. Tiene que añadir #define MEM_CHECK en lo alto de gmem.c y tiene que hacer un make y un make install.

22.5 Timers

Temporizadores...

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 );

22.6 Manejo de cadenas de texto

Un puñado de funciones para manejar cadenas de texto. Parecen muy interesantes, y probablemente sean mejores en muchos aspectos que las funciones estándar de C, pero necesitan documentación.

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,
                         ... );

22.7 Funciones de error y funciones varias

gchar *g_strdup( const gchar *str );

Reemplaza a la función strdup. Copia el contenido de la cadena original en un nuevo lugar en memoria, y devuelve un puntero al nuevo lugar.

gchar *g_strerror( gint errnum );

Recomiendo utilizar esta función para todos los mensages de error. Es mucho más bonita, y más portable que perror() y demás funciones clásicas. La salida es normalmente de la forma:

nombre del programa:función que falló:fichero o descripción adicional:strerror

Aquí hay un ejemplo de una llamada utilizada en nuestro programa hello_world:

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

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

Imprime un mensaje de error. El formato es como el de printf, pero le añade ** ERROR **: a su mensaje, y sale del programa. Sólo para errores fatales.

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

El mismo que el anterior, pero añade "** WARNING **: ", y no sale del programa.

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

Imprime message: antes de la cadena que le pase.

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

Reemplazo de printf().

Y nuestra última función:

gchar *g_strsignal( gint signum );

Imprime el nombre de la señal del sistema Unix que corresponde con el número signum. Útil para las funciones genéricas de manejo de señal.

Todo lo anterior está más o menos robado de glib.h. Si alguien quiere documentar una función, ¡sólo tiene que enviarme un correo-e!


Página siguiente Página anterior Índice general