C++:重载全局new/delete实现跨平台多线程内存检测

Reference: https://blog.csdn.net/u014023615/article/details/39551191

Reference: https://blog.csdn.net/u014023615/article/details/39551191

实现类：

DumpMemoryLeaks.h

/**

* @file DumpMemoryLeaks.h

* @brief 跟踪内存分配并定时输到文件，以协助检查有无内存泄漏

*

* 修订记录

* @author jack3z

* @version 1.00

* @date 2014-05-18

*

*/



#ifndef DUMPMEMORYLEAKS_H

#define DUMPMEMORYLEAKS_H



#ifdef __linux__

# include

#else

# include

#endif



#include

#include



#include



#include



#include

#include

DumpMemoryLeaks.cpp

#include "DumpMemoryLeaks.h"



#ifndef localtime_r



#if _MSC_VER >= 1400

//Visual C++ 2005 以及更高版本

# define localtime_r(_Time_ptr,_Tm_ptr) (localtime_s((_Tm_ptr),(_Time_ptr)) == 0 ? (_Tm_ptr) : NULL)

#else

# define localtime_r(_Time_ptr,_Tm_ptr) ( *(_Tm_ptr) = *localtime(_Time_ptr), (_Tm_ptr))

#endif //#if _MSC_VER >= 1500



#endif //#ifndef localtime_r



#ifdef _MSC_VER

# ifndef snprintf

# define snprintf _snprintf

# endif//snprintf

#endif //_MSC_VER



CDumpMemoryLeaks::CDumpMemoryLeaks(void)

{

m_bInit = false;



m_fpDumpFile = NULL;



m_timeDump = NULL;



memset(m_szBuf,0,sizeof(m_szBuf));



#ifdef __linux__

pthread_mutexattr_t mattr;

pthread_mutexattr_init(&mattr);

pthread_mutexattr_settype(&mattr , PTHREAD_MUTEX_RECURSIVE);

pthread_mutex_init(&m_mtx,&mattr);

#else

InitializeCriticalSection(&m_mtx);

#endif



}



CDumpMemoryLeaks::~CDumpMemoryLeaks(void)

{

if (m_fpDumpFile)

{

fclose(m_fpDumpFile);

m_fpDumpFile = NULL;

}



#ifdef __linux__

pthread_mutex_destroy(&m_mtx);

#else

DeleteCriticalSection(&m_mtx);

#endif

}



void CDumpMemoryLeaks::Init()

{

lock();



if (!m_bInit)

{

ResetDumpTime();



m_bInit = true;

}



unlock();



}



void CDumpMemoryLeaks::AddTrack(void* addr, size_t asize, const char *fname, int lnum)

{

lock();



if (!m_bInit)

{

Init();

}



CAllocLocalInfo alloc_local;

alloc_local.m_strFile = fname;

alloc_local.m_nLine = lnum;



StMemAllocRec mem_alloc_rec;

mem_alloc_rec.addr = addr;

mem_alloc_rec.nSize = asize;



m_mapAllocRec[alloc_local].push_back(mem_alloc_rec);



m_mapAddr2AllocLocal[addr] = alloc_local;



if (IsTheTime2Dump())

{

Dump();



ResetDumpTime();

}



unlock();

}



void CDumpMemoryLeaks::RemoveTrack(void* addr)

{

lock();



if (!m_bInit)

{

Init();

}



bool bRemoveSuccess = false;



std::map::iterator itorAddr2AllocLocal = m_mapAddr2AllocLocal.find(addr);



if (itorAddr2AllocLocal == m_mapAddr2AllocLocal.end())

{

unlock();

return;

}

else

{

std::map >::iterator itorAllocRec = m_mapAllocRec.find(itorAddr2AllocLocal->second);

assert(itorAllocRec != m_mapAllocRec.end());



std::list& listAllocRec = itorAllocRec->second;



for (std::list::iterator itor = listAllocRec.begin();

itor != listAllocRec.end();

++itor)

{

if ((*itor).addr == addr)

{

listAllocRec.erase(itor);

bRemoveSuccess = true;



break;

}

}



if (listAllocRec.empty())

{

m_mapAllocRec.erase(itorAllocRec);

m_mapAddr2AllocLocal.erase(itorAddr2AllocLocal);

}

}



assert(bRemoveSuccess);



if (IsTheTime2Dump())

{

Dump();



ResetDumpTime();

}



unlock();

}



void CDumpMemoryLeaks::Dump()

{

time_t timeNow = time(NULL);

struct tm tmNow;

if (NULL == localtime_r(&timeNow,&tmNow))

{

assert(false);

}



if (m_strMsg.empty())

{//生成信息



size_t nTotalAlloc = 0;



std::list listLocal;//按内存大到小排序



std::map mapLocal2Size;



for (std::map >::iterator itor = m_mapAllocRec.begin();

itor != m_mapAllocRec.end();

++itor)

{

const CAllocLocalInfo& local = itor->first;



std::list& listAllocRec = itor->second;



for (std::list::iterator itor = listAllocRec.begin();

itor != listAllocRec.end();

++itor)

{

nTotalAlloc += itor->nSize;



mapLocal2Size[local] += itor->nSize;

}

}



for (std::map::iterator itor = mapLocal2Size.begin();

itor != mapLocal2Size.end();

++itor)

{

std::list::iterator itorLocalList = listLocal.begin();



for (;

itorLocalList != listLocal.end();

++itorLocalList)

{

if (itor->second >= mapLocal2Size[*itorLocalList])

{

break;

}

}



listLocal.insert(itorLocalList,itor->first);

}



snprintf(m_szBuf,sizeof(m_szBuf)-1,"Total unfree:%lu \n",(unsigned long)nTotalAlloc);



m_strMsg += "\n";



m_strMsg += m_szBuf;



m_strMsg += "--------------------------------------------------------------------------\n";



snprintf(m_szBuf,sizeof(m_szBuf)-1,

"Time: %04u-%02u-%02u %02u:%02u:%02u\n\n",

tmNow.tm_year + 1900,

tmNow.tm_mon + 1,

tmNow.tm_mday,

tmNow.tm_hour,

tmNow.tm_min,

tmNow.tm_sec

);



m_strMsg += m_szBuf;



double dTotalReciprocal = 1.0/(double)nTotalAlloc;



for (std::list::iterator itorLocalList = listLocal.begin();

itorLocalList != listLocal.end();

++itorLocalList)

{

size_t nSize = mapLocal2Size[*itorLocalList];



snprintf(m_szBuf,sizeof(m_szBuf)-1,

"%s:line %d, unfreed size:%lu, percentage:%lf %%; alloc times:%lu\n",

itorLocalList->m_strFile.c_str(),

itorLocalList->m_nLine,

nSize,

nSize*dTotalReciprocal*100,

(unsigned long)m_mapAllocRec[*itorLocalList].size()

);



m_strMsg += m_szBuf;

}



m_strMsg += "--------------------------------------------------------------------------\n";



}



//////////////////////////////////////////////////////////////////////////

//文件操作：打开文件,分割文件并写入



snprintf(m_szBuf,sizeof(m_szBuf)-1,

"MemoryAllocReport_%04u-%02u-%02u.txt",

tmNow.tm_year + 1900,

tmNow.tm_mon + 1,

tmNow.tm_mday

);



if (!m_fpDumpFile)

{

m_fpDumpFile = fopen(m_szBuf,"a");



m_strDumpFile = m_szBuf;



fprintf(m_fpDumpFile, "\n\n---------------- DumpMemoryLeaks begin! ----------------\n");



}

else

{

if (m_strDumpFile != m_szBuf)

{

fclose(m_fpDumpFile);



m_fpDumpFile = fopen(m_szBuf,"w");



m_strDumpFile = m_szBuf;

}

}



fwrite(m_strMsg.c_str(),m_strMsg.length(),1,m_fpDumpFile);



//文件操作结束

//////////////////////////////////////////////////////////////////////////



m_strMsg.clear();

}

实现方法：把文件保存到项目源文件目录下并在全局头文件添加# include "DumpMemoryLeaks.h"

如在win32工程中的stdafx.h文件内添加：

#ifdef _DEBUG

# include "DumpMemoryLeaks.h"

#endif // _DEBUG

测试：

// DbgMemLeak.cpp : 定义控制台应用程序的入口点。

//



#include "stdafx.h"

#include

using namespace std;



class A

{

public:

A()

{

m_i = 9;

}



~A()

{

if (m_i != 9)

{

assert(false);

}



m_i = 1;

}



int m_i;

};



class B

{

public:

B()

{

printf("new B instance %p \n", this);

}



~B()

{

printf("delete B instance %p \n", this);

}

};



int main(int argc, _TCHAR* argv[])

{

/*

{//测试构造和析构

B* pB = new B();



delete pB;



Sleep(3*1000);//方便观察终端输出内容

}

*/



{//测试数组构造和析构

B* pArray = new B[4];

delete[] pArray;

pArray = NULL;



Sleep(3*1000);//方便观察终端输出内容

}



/*

{//测试new和delete基础类型数组

char* pChArr = new char[1024];

delete pChArr;

}

*/



//模拟内存泄漏

for (int i = 0; i <60*30*10; ++i)

{

A* p = new A ;



Sleep(100);



if (i%2 == 0)

{

delete p;

}

}





for (int i = 0; ; ++i)

{

A* p = new A ;



Sleep(1);



if (i%4 == 0)

{

delete p;

}



}



return 0;

}

--------------------- 本文来自 jack3z 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/u014023615/article/details/39551191?utm_source=copy