编写内存泄露检测器的方法选择以及实现方式 c++

/* Prototypes for our hooks.  */
static void my_init_hook(void);
static void *my_malloc_hook(size_t, const void *);
/* Variables to save original hooks. */
static void *(*old_malloc_hook)(size_t, const void *);
/* Override initializing hook from the C library. */
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;
    /* Restore all old hooks */
    __malloc_hook = old_malloc_hook;
    /* Call recursively */
    result = malloc(size);
    /* Save underlying hooks */
    old_malloc_hook = __malloc_hook;
    /* printf() might call malloc(), so protect it too. */
    printf("malloc(%u) called from %p returns %p\n",
            (unsigned int) size, caller, result);
    /* Restore our own hooks */
    __malloc_hook = my_malloc_hook;
    return result;
}

功能：
根据动态链接库操作句柄与符号，返回符号对应的地址。

包含头文件：
#include<dlfcn.h>
函数定义：
void* dlsym(void* handle,const char*symbol)
函数描述：
根据 动态链接库 操作句柄(handle)与符号(symbol)，返回符号对应的地址。使用这个函数不但可以获取函数地址，也可以获取变量地址。
handle：由dlopen打开动态链接库后返回的指针；
symbol：要求获取的函数或全局变量的名称。
返回值：
void* 指向函数的地址，供调用使用。

extern "C" void* malloc(size_t size)
{
	void * ptr=sys_malloc(size);
	handle extra behavior...
	return ptr;
}

static bool performance_enabled_ = false;
static void* (*sys_malloc)(size_t) = 0;
static void* (*sys_realloc)(void*,size_t) = 0;
static void* (*sys_calloc)(size_t,size_t) = 0;
static void (*sys_free)(void*) = 0;
 
static void initialize_functions()
{	
	sys_malloc = reinterpret_cast<void*(*)(size_t)>(dlsym(RTLD_NEXT, "malloc"));
	sys_realloc = reinterpret_cast<void*(*)(void*,size_t)>(dlsym(RTLD_NEXT, "realloc"));
	sys_calloc = reinterpret_cast<void*(*)(size_t,size_t)>(dlsym(RTLD_NEXT, "calloc"));
	sys_free = reinterpret_cast<void(*)(void*)>(dlsym(RTLD_NEXT, "free"));
}

extern "C" void* malloc(size_t size)
{
    if(sys_malloc==0)
		initialize_functions()；
	void * ptr=sys_malloc(size);
	handle extra behavior...
	return ptr;
}

char tmpbuff[1024];
unsigned long tmppos = 0；
unsigned long tmpallocs = 0;
extern "C" void* malloc(size_t size)
{
	static bool is_initializing = false;
	if(sys_malloc == 0)
	{
		if(!is_initializing)
		{
			is_initializing = true;
			initialize_functions();
			is_initializing = false;
		}
		else
		{
			if(tmppos+size<sizeof(tmpbuff))
			{
				void *retptr = tmpbuff + tmppos;
				tmppos += size;
				++tmpallocs;
				return retptr;
			}
			else
				exit(1);
		}
	}
	void* ptr = sys_malloc(size);
	handle extra behaviors....
	return ptr；
}

static __thread bool is_external = true;
extern "C" void* malloc(size_t size)
{
	static bool is_initializing = false;
	if(sys_malloc == 0)
	{
		if(!is_initializing)
		{
			is_initializing = true;
			initialize_functions();
			is_initializing = false;
		}
		else
		{
			if(tmppos+size<sizeof(tmpbuff))
			{
				void *retptr = tmpbuff + tmppos;
				tmppos += size;
				++tmpallocs;
				return retptr;
			}
			else
				exit(1);
		}
	}
	void* ptr = sys_malloc(size);
	if(is_external)
	{
		is_external=false;
		handle extra behaviors....
		is_external=true;
	}
	return ptr；
}

	//record general performance info
 	struct General_Performance
    {
        int64_t used_memory_;
        std::vector<void *> stack_trace_;
    };
	//record general performance info by address
	struct General_Performance_Map: public std::unordered_map<uint64_t, General_Performance>
    {
    };
	//record specific performance info
 	struct Specific_Performance
    {
        size_t count_;
        int64_t duration_; //mili seconds
        int64_t hold_memory_; //the memory change size during a monitor life time
        int64_t allocated_memory_;//the memory allocation size during a monitor life time
        int64_t start_time_; //mili seconds
        int64_t end_time_;  //mili seconds
        General_Performance_Map detail_;
    };
	//record specific performance info by guard's tag
	struct Specific_Performance_Map: public std::unordered_map<Ads_String, Specific_Performance>
    {
    };
	//record the specific & general info for each thread
    struct Thread_Performance_Info
    {
        int guards_num_; //the number of guards in current thread
        General_Performance_Map general_performance_map_;//record the general performance by address
        std::list<void*> stack_guard_father_call_names_;//record the father function called Guard as a stack
        std::list<Specific_Performance> stack_specific_performance_;//record the specific performance as a stack, each only manipulate the back element,
        Specific_Performance_Map specific_performance_map_;//record the specific performance by guard's tag
        Thread_Performance_Info();
        ~Thread_Performance_Info();//do merge work when destruct a thread info 
    };
	//when a guard object exist, the corresponding specific monitor will be at working status
    struct Guard
    {
        Ads_String tag_;
        int64_t start_time_;
        int64_t end_time_;
        Guard(const Ads_String& tag);
        ~Guard();
    };