Provided by: manpages-es_1.55-3_all bug

NOMBRE

       __malloc_hook,  __malloc_initialize_hook, __memalign_hook, __free_hook,
       __realloc_hook, __after_morecore_hook  -  variables  de  depuración  de
       malloc

SINOPSIS

       #include <malloc.h>

       void *(*__malloc_hook)(size_t size, const void *caller);

       void *(*__realloc_hook)(void *ptr, size_t size, const void *caller);

       void  *(*__memalign_hook)(size_t  alignment,  size_t  size,  const void
       *caller);

       void (*__free_hook)(void *ptr, const void *caller);

       void (*__malloc_initialize_hook)(void);

       void (*__after_morecore_hook)(void);

DESCRIPCIÓN

       La biblioteca de C de GNU le permite  modificar  el  comportamiento  de
       malloc(),  realloc()  y  free()  especificando  funciones de «enganche»
       (hook) adecuadas. Puede usar estos enganches para que, por ejemplo,  le
       ayuden  a depurar programas que usan asignaciones dinámicas de memoria.

       La variable __malloc_initialize_hook apunta a una función que se invoca
       una única vez cuando se inicializa la implementación de malloc. Esta es
       una varible normal, por lo que se puede redefinir en una aplicación  de
       forma parecida a la siguiente:
           void (*__malloc_initialize_hook)(void) = my_init_hook;
       Ahora  la función my_init_hook() puede hacer la inicialización de todos
       los enganches.

       Las  cuatro  funciones  apuntadas  por  __malloc_hook,  __realloc_hook,
       __memalign_hook   y  __free_hook  tienen  el  mismo  prototipo  de  las
       funciones malloc(), realloc(), memalign()  y  free(),  respectivamente,
       aunque  tienen  un  argumento final adicional caller que proporciona la
       dirección del invocador de malloc(), etc.

       La variable __after_morecore_hook apunta a un  función  que  se  invoca
       cada vez que se pide a sbrk() más memoria.

EJEMPLO

       A continuación tiene un pequeño ejemplo de cómo usar estas variables.

       #include <stdio.h>
       #include <malloc.h>

       /* Prototipos para nuestros enganches.  */
       static void my_init_hook(void);
       static void *my_malloc_hook(size_t, const void *);

       /* Variables para guardar los enganches originales. */
       static void *(*old_malloc_hook)(size_t, const void *);

       /* Redefinimos el enganche de inicialización de la biblioteca de C. */
       void (*__malloc_initialize_hook) (void) = my_init_hook;

       static void
       my_init_hook(void) {
           old_malloc_hook = __malloc_hook;
           __malloc_hook = my_malloc_hook;
       }

       static void *
       my_malloc_hook (size_t size, const void *caller) {
           void *result;

           /* Restauramos todos los enganches originales */
           __malloc_hook = old_malloc_hook;

           /* Llamamos recursivamente a malloc */
           result = malloc (size);

           /* Guardamos los enganches originales */
           old_malloc_hook = __malloc_hook;

           /* ‘printf’ podría llamar a ‘malloc’, por lo que también hay que protegerla. */
           printf ("malloc(%u) invocada desde %p devuelve %p\n",
               (unsigned int) size, caller, result);

           /* Restauramos nuestros enganches */
           __malloc_hook = my_malloc_hook;

           return result;
       }

VÉASE TAMBIÉN

       mallinfo(3), malloc(3), mtrace(3), mcheck(3)