C++内存泄漏处理

/*
功能： 我们重载了operator new是全局的，new运算符先调用我们重载的operator new，再调用相应的构造函数，
一般来讲都是使用placement new直接在operator new返回的指针上调用相应的构造函数。
这里如果我们重载的是类的operator new会优先调用类内的，而不是全局的，即使类内的调用错误也不会向外找了。
*/
【memchecker.h】
struct MemIns
{
void* pMem;
int m_nSize;
char m_szFileName[256];
int m_nLine;
MemIns* pNext;
};
class MemManager
{
public:
MemManager();
~MemManager();
private:
MemIns *m_pMemInsHead;
int m_nTotal;
public:
static MemManager* GetInstance();
void Append(MemIns *pMemIns);
void Remove(void *ptr);
void Dump();
};
void* operator new(size_t size, const char* szFile, int nLine);
void operator delete(void* ptr, const char* szFile, int nLine);
void operator delete(void* ptr);
void* operator new[] (size_t size, const char* szFile, int nLine);
void operator delete[](void* ptr, const char* szFile, int nLine);
void operator delete[](void* ptr);

【memchecker.cpp】
#include"memchecker.h"
#include<stdio.h>
#include <stdlib.h>
#include<malloc.h>
#include<string.h>

MemManager::MemManager()
{
m_pMemInsHead=NULL;
m_nTotal=NULL;
}

MemManager::~MemManager()
{

}

void MemManager::Append(MemIns* pMemIns)
{
pMemIns->pNext=m_pMemInsHead;
m_pMemInsHead = pMemIns;
m_nTotal+= m_pMemInsHead->m_nSize;
}

void MemManager::Remove(void* ptr)
{
MemIns* pCur = m_pMemInsHead;
MemIns* pPrev = NULL;
while(pCur)
{
if(pCur->pMem == ptr)
{
if(pPrev)
{
pPrev->pNext = pCur->pNext;
}
else
{
m_pMemInsHead = pCur->pNext;
}
m_nTotal -= pCur->m_nSize;
free(pCur);
break;
}
pPrev = pCur;
pCur = pCur->pNext;
}
}

void MemManager::Dump()
{
MemIns* pp = m_pMemInsHead;
while(pp)
{
printf( "File is %s\n", pp->m_szFileName );
printf( "Size is %d\n", pp->m_nSize );
printf( "Line is %d\n\n", pp->m_nLine );
pp = pp->pNext;
}
}

void PutEntry(void *ptr, int size, const char* szFile, int nLine)
{
MemIns* p = (MemIns*)(malloc(sizeof(MemIns)));
if(p)
{
strcpy(p->m_szFileName, szFile);
p->m_nLine = nLine;
p->pMem = ptr;
p->m_nSize = size;
MemManager::GetInstance()->Append(p);
}
}

void RemoveEntry(void* ptr)
{
MemManager::GetInstance()->Remove(ptr);
}

void* operator new(size_t size, const char* szFile, int nLine)
{
void* ptr = malloc(size);
PutEntry(ptr, size, szFile, nLine);
return ptr;
}

void operator delete(void *ptr)
{
RemoveEntry(ptr);
free(ptr);
}

void operator delete(void* ptr, const char* file, int line)
{
RemoveEntry(ptr);
free(ptr);
}

void* operator new[](size_t size, const char* szFile, int nLine)
{
void * ptr = malloc(size);
PutEntry(ptr, size, szFile, nLine);
return ptr;
}

void operator delete[](void *ptr)
{
RemoveEntry(ptr);
free(ptr);
}

void operator delete[](void* ptr ,const char* szFile, int nLine)
{
RemoveEntry(ptr);
free(ptr);
}

/*
重载new思想：
operator new的重载是可以有自定义参数的，那么我们如何利用自定义参数获取更多的信息呢，这里一个很有用的做法
就是给operator new添加两个参数:char* file, int line,这两个参数记录new运算符的位置，然后再在new时
将文件名和行号传入，这样我们就能在分配内存失败时给出提示：输出文件名和行号。
那么如何获取当前语句所在文件名和行号呢，windows提供两个宏：__FILE__和__LINE__。
利用它们可以直接获取到文件名和行号，也就是 new(__FILE__, __LINE__) 由于这些都是不变的，
因此可以再定义一个宏：#define new new(__FILE__, __LINE__)。这样我们就只需要定义这个宏，
然后重载operator new即可。
*/

#define new new(__FILE__,__LINE__)
MemManager m_memTracer;

MemManager* MemManager::GetInstance()
{
return &m_memTracer;
}

int main()
{
int *plen =new int ;
*plen=10;
//delete plen;          //注意这两次delete走的都是delete重载void*参数的，没有走参数多的那项
char *pstr=new char[35];
strcpy(pstr,"hello memory leak");
//delete[] pstr;        //同上
m_memTracer.Dump();
system("pause");
return 0;
}