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

NOMBRE

       __malloc_hook,  __malloc_initialize_hook, __memalign_hook, __free_hook,
       __realloc_hook, __after_morecore_hook  -  variables  de  depuracion  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'ON

       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 dinamicas de memoria.

       La variable __malloc_initialize_hook apunta a una funcion que se invoca
       una unica vez cuando se inicializa la implementacion de malloc. Esta es
       una  varible normal, por lo que se puede redefinir en una aplicacion de
       forma parecida a la siguiente:
           void (*__malloc_initialize_hook)(void) = my_init_hook;
       Ahora la funcion my_init_hook() puede hacer la inicializacion 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
       direccion del invocador de malloc(), etc.

       La  variable  __after_morecore_hook  apunta  a un funcion que se invoca
       cada vez que se pide a sbrk() mas memoria.

EJEMPLO

       A continuacion tiene un pequeno ejemplo de como 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 inicializacion 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' podria llamar a `malloc', por lo que tambien 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'EASE TAMBI'EN

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