Problema al anular malloc

Question

Estoy intentando anular malloc haciendo esto.

#define malloc(X) my_malloc((X)) 

void* my_malloc(size_t size) 
{ 

    void *p = malloc(size); 
    printf ("Allocated = %s, %s, %s, %x\n",__FILE__, __LINE__, __FUNCTION__, p); 
    return p; 
} 

Sin embargo, esto está llamando indefinidamente my_malloc de forma recursiva (a causa de la llamada malloc dentro my_malloc). Quería llamar a la función C malloc dentro de my_malloc y no a la implementación de macro. ¿Podrías decirme cómo hacer eso?

Gracias.

Answer 1

Problema resuelto:

void* my_malloc(size_t size, const char *file, int line, const char *func) 
{ 

    void *p = malloc(size); 
    printf ("Allocated = %s, %i, %s, %p[%li]\n", file, line, func, p, size); 
    return p; 
} 
#define malloc(X) my_malloc(X, __FILE__, __LINE__, __FUNCTION__) 

Answer 2

¿Qué ocurre si implementó my_malloc() en un archivo diferente que no muestra #Define?

Answer 3

#define es un reemplazo de macro. La llamada a malloc (tamaño) está siendo reemplazada por my_malloc (tamaño).

Answer 4

A diferencia de los nuevos/borrar, no hay forma estándar para anular malloc y libre en C estándar o C++.

Sin embargo, la mayoría de las plataformas de alguna manera le permitirán compensar estas funciones de biblioteca estándar con la suya, por ejemplo, en tiempo de enlace.

Si eso no funciona, y la portabilidad es necesario, primero declarar las funciones, a continuación, declarar las define:

#include <stdlib.h> 

void *myMalloc(size_t size) { 
// log 
return malloc(size); 
} 

void myFree(void *ptr) { 
// log 
free(ptr); 
} 

#define malloc(size) myMalloc(size) 
#define free(ptr) myFree(ptr) 

Answer 5

Debe utilizar LD_PRELOAD sobrescribir este tipo de función (Biblioteca mediadora es el nombre real que no podía recordar) ..

Explicación here

Answer 6

Si intenta #definemalloc (un identificador reservado), entonces el comportamiento de su programa no está definido de manera que y Debería tratar de encontrar otra forma de abordar su problema. Si realmente necesita hacer esto, entonces esto puede funcionar.

#include <stdlib.h> 

#define malloc(x) my_malloc(x) 

void *my_malloc(size_t x) 
{ 
     return (malloc)(x); 
} 

función como macros solamente se expanden si se encuentran como macro-name seguido por (. El paréntesis adicional alrededor de malloc significa que no es de esta forma por lo que no es reemplazado por el preprocesador. La sintaxis resultante sigue siendo una llamada de función válida por lo que aún se llamará al malloc real.

Answer 7

Con Glibc, existe malloc_hook(3) como el manera apropiada de forma global interponer su propia función malloc.

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

static void *(*old_malloc_hook)(size_t, const void *); 

static void *new_malloc_hook(size_t size, const void *caller) { 
    void *mem; 

    __malloc_hook = old_malloc_hook; 
    mem = malloc(size); 
    fprintf(stderr, "%p: malloc(%zu) = %p\n", caller, size, mem); 
    __malloc_hook = new_malloc_hook; 

    return mem; 
} 

static void init_my_hooks(void) { 
    old_malloc_hook = __malloc_hook; 
    __malloc_hook = new_malloc_hook; 
} 

void (*__malloc_initialize_hook)(void) = init_my_hooks; 

 
$ cat >mem.c <<'EOF' 
(the code above) 
EOF 
$ cat >main.c <<'EOF' 
#include <stdio.h> 
#include <stdlib.h> 
int main() { 
    char *buf = malloc(50); 
    sprintf(buf, "Hello, world!"); 
    puts(buf); 
    free(buf); 
    return 0; 
} 
EOF 
$ cc mem.c main.c 
$ ./a.out 
0x40077e: malloc(50) = 0x22f7010 
Hello, world! 

(Podríamos utilizar __attribute__((constructor)), pero ese truco no es necesario: Glibc cómodamente ofrece __malloc_initialize_hook como otra manera de cargar el código antes de ejecutar main.)

Answer 8

Para solucionar el problema, tanto macro-reemplazo, y crea LÍNEA etc trabajo como usted está esperando que lo harán:

#define malloc(X) my_malloc((X), __FILE__, __LINE__, __FUNCTION__) 

void* my_malloc(size_t size, const char *f, int l, const char *u) 
{ 

    void *p = (malloc)(size); 
    printf ("Allocated = %s, %d, %s, %x\n", f, l, u, p); 
    return p; 
} 

(De esa manera LÍNEA serán evaluados y amigos, donde la macro se expande; de ​​lo contrario, siempre serían lo mismo).

Encerrar el nombre (malloc) en parantheses impide que la macro malloc se expanda, ya que se trata de una macro similar a una función.

Answer 9

#define malloc(X) my_malloc((X)) 

void* my_malloc(size_t size) 
{ 
    #define my_malloc(X) malloc((X)) 

    void *p = malloc(size); 
    printf ("Allocated = %s, %s, %s, %x\n",__FILE__, __LINE__, __FUNCTION__, p); 
    return p; 
} 

Aquí dentro del my_malloc función, #define my_malloc (X) malloc ((X)) va a funcionar. Fuera de esta función no tiene ningún efecto. Por lo tanto, se invocará la función C malloc dentro de my_malloc