内存管理工具

将c++中动态申请的内存地址放入到内存链表中，重载了全局new，new[]，delete，delete[],用来检测是否重复释放内存、是否有未释放的内存、自动释放未释放的内存。

#ifndef _MEMLIST_H_
#define _MEMLIST_H_ 

#include <iostream>
using namespace std;

class MemListNode
{
public:
    friend class MemList;
    MemListNode();
    ~MemListNode();
private:
    void *p;
    MemListNode *pNext;
};

class MemList
{
public:
    MemList();
    ~MemList();
    void InsertChild(void *p);
    void Delete(void *pDel);
    bool IsEmpty( );
    bool Find(void *pFind);
    void Print();
    void Clear();        //释放掉用户未释放的内存
    void Destroy();
private:
    MemListNode *pList;
};
#endif

实现文件：
#include "MemList.h"

//全局链表
MemList pList;

MemListNode::MemListNode()
{
    p = NULL;
    pNext = NULL;
}

MemListNode::~MemListNode()
{
    free (p);
    free (pNext);
};

MemList::MemList()
{
    pList = (MemListNode *)malloc(sizeof(MemListNode));
    pList->p = NULL;
    pList->pNext = NULL;
}

MemList::~MemList()
{
    Destroy();
}

void MemList::InsertChild(void *p)
{
    if (!p)
    {
        return;
    }
    MemListNode *pTmp = (MemListNode *)malloc(sizeof(MemListNode));
    pTmp->p = p;
    pTmp->pNext = NULL;

    pTmp->pNext = pList->pNext;
    pList->pNext = pTmp;
}

void MemList::Delete(void *pDel)
{
    if (!Find(pDel))
    {
        return;
    }
    MemListNode *pCur = pList;
    while(pCur->pNext)
    {
        if(pCur->pNext->p == pDel)
        {
            MemListNode *pTmp = pCur->pNext;
            pCur->pNext = pTmp->pNext;
            free(pTmp);
        }
        else
        {
            pCur = pCur->pNext;
        }
    }
}

bool MemList::Find(void *pFind)
{
    if (NULL == pFind)
    {
        return false;
    }
    MemListNode *pCur = pList->pNext;
    while(pCur)
    {
        if (pCur->p == pFind)
        {
            return true;
        }
        pCur = pCur->pNext;
    }

    return false;
}

bool MemList::IsEmpty()
{
    return pList->pNext == NULL;
}

void MemList::Print()
{
    MemListNode *pCur = pList->pNext;
    while(pCur)
    {
        cout<<pCur->p<<endl;
        pCur = pCur->pNext;
    }
}

void MemList::Clear()
{
    if (IsEmpty())
    {
        return;
    }
    MemListNode *pCur = pList->pNext;
    while(pCur)
    {
        if (pCur->p != NULL)
        {
            free(pCur->p);
        }
        pCur = pCur->pNext;
    }
}
void MemList::Destroy()
{
    while(pList->pNext)
    {
        MemListNode *pTmp = pList->pNext;
        pList->pNext = pTmp->pNext;
        free(pTmp);
    }

    free(pList);
}

//重载全局new
void* operator new (size_t size)
{
    void *p =malloc(size);
    pList.InsertChild(p);

    return p;
}

//重载全局new[]
void* operator new[] (size_t size)
{
    return operator new(size);
}

//重载全局delete
void operator delete (void *p)
{
    if (pList.Find(p))
    {
        pList.Delete(p);
        free(p);
        p = NULL;
    }
    else
    {
        cout<<"重复释放内存"<<endl;
    }
}

//重载全局delete[]
void operator delete[] (void *p)
{
    delete(p);
}

测试用例：
#include <iostream>
#include "MemList.h"
using namespace std;
extern MemList pList;

class Point
{
public:
    Point(int a = 0, int b = 0):m_x(a), m_y(b)
    { 
        cout<<"构造函数"<<endl;
    }
    ~Point()
    { 
        cout<<"析构函数"<<endl;
    }
    void SetValue(int a, int b)
    {
        m_x = a;
        m_y = b;
    }
private:
    int m_x;
    int m_y;
};

int main()
{
    Point *pTest = new Point[2];
    pTest[0].SetValue(1, 2);
    pTest[1].SetValue(10, 20);

    delete[] pTest;

    int *pInt = new int(12);
    double *pDouble = new double(10.0);
    delete pDouble;
    delete pDouble;
    if (!pList.IsEmpty())
    {
        cout<<"内存未释放完全,我帮你释放掉吧!"<<endl;
        pList.Clear();
    }

    system("pause");
    return 0;
}