#define - это замена макроса. Вызов malloc (size) заменяется на my_malloc (size).

#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; 
} 

Здесь внутри функции my_malloc, #define my_malloc (X) будет работать malloc ((X)). Вне этой функции это не имеет никакого эффекта. Поэтому функция C malloc будет вызываться внутри my_malloc

Вы должны использовать LD_PRELOAD для перезаписи такого рода функции (Library Interposer - это реальное имя, которое я не мог вспомнить) ..

объяснениеВот

Если вы попытаетесь#define malloc (зарезервированный идентификатор), тогда поведение вашей программы не определено, поэтому вы должны попытаться найти другой способ решения вашей проблемы. Если вам действительно нужно это сделать, то это может сработать.

#include <stdlib.h>

#define malloc(x) my_malloc(x)

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

Такие функции, как макросы, раскрываются только в том случае, если они найдены какmacro-name с последующим(, Дополнительные скобки вокругmalloc означает, что он не имеет такой формы, поэтому он не заменен препроцессором. Полученный синтаксис все еще является допустимым вызовом функции, поэтому реальный malloc будет по-прежнему вызываться.

Что, если вы реализовали my_malloc () в другом файле, который не видит #Define?

В отличие от new / delete, нет стандартного способа переопределить malloc и free в стандарте C или C ++.

Тем не менее, большинство платформ так или иначе позволят вам изменить эти стандарты библиотека функционирует самостоятельно, например, во время ссылки.

Если это не работает, а переносимость необходима, сначала объявите функции, затем объявите определения:

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

СGlibc, Существуетmalloc_hook(3) какproper способ глобально вставить свой собственный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!

(Мы могли бы использовать__attribute__((constructor)), но этот трюк не нужен: Glibc легко предоставляет__malloc_initialize_hook как еще один способ загрузить код запуска доmain.)

Чтобы исправить и проблему с заменой макросов, и сделатьLINE и т. д. работают так, как вы надеетесь:

#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;
}

(СюдаLINE и друзья будут оцениваться там, где развернут макрос, в противном случае они всегда будут одинаковыми).

Вложение имени(malloc) в парантезах мешает макросmalloc от расширения, так как это функциональный макрос.