C++内存检测(定位到确定地址，并且用hash表来保存提高了搜索效率)

    #include <iostream>  
    #include <malloc.h>  
    #include <string.h>  
    #include <stdio.h>  
    #define DefaultSize 7  
    using namespace std;  
    struct Node  
    {  
        char *pname;//文件名字  
        int line;//行号  
        int size;//大小  
        long long save;//存储地址ip  
        Node *next;  
    };  
      
    struct HashNode  
    {  
      Node *adj;  
        HashNode():adj(NULL){}//向量数组，保存指定向量。  
    };  
      
    class HashList  
    {  
        public:  
        HashList()  
        {  
        }  
        void Insert(Node *p)  
        {  
            int index = Find(p->save&((long long)0x111));  
            p->next=data[index].adj;  
            data[index].adj=p;  
        }  
        int Find(int x)  
        {  
            return x%DefaultSize;//获取存储下标。  
        }  
    ~HashList()  
        {  
            Check();//进程结束时会调用析构函数，由此起到检测的作用。  
        }  
        void Check()  
        {  
            for(int i=0;i<DefaultSize;i++)  
            {  
                Node *p = data[i].adj;    
                while(p!=NULL)  
                {  
                    printf("start address:%p",(int*)p->save);  
                    //cout<<"start address :"<<std::hex<<p->save;  
                    cout<<"  "<<"file name:"<<p->pname<<"  "<<"line number:"<<p->line<<"  "<<"what size:"<<"  "<<p->size;  
                    cout<<endl;  
                    p=p->next;  
                }  
            }  
        }  
        void Delete(int *p)  
        {     
            long long a = (int)p;     
        #ifdef __DEBUG__  
            cout<<a<<endl;//g++ -D __DUBUG__就会在执行时默认执行到这里来并且显示a的值，不然这个开关不会打开。  
        #endif  
            int index = Find(a&0x111);//取最后3位的值来确定下标。  
            Node *q = data[index].adj;  
            Node *m = NULL;   
            while(q!=NULL)  
                {     
    //              m=q;  
                    if(q->save==a)  
                        break;  
                    m=q;  
                    q=q->next;  
                }  
                if(m==NULL)  
                {  
                      
                    data[index].adj=q->next;  
                    free(q);  
                    return;  
                }  
                if(q!=NULL)  
                {  
                m->next = q->next;  
                free(q);  
                }  
        }  
        private:  
        HashNode data[DefaultSize];//向量数组，包含一个节点指针adj.  
    };  
    HashList list;  
    void *operator new(size_t sz,const char *pname,int line)  
    {  
        Node *p = (Node *)malloc(sizeof(Node));  
        p->pname = (char *)malloc(20);  
        strcpy(p->pname,pname);  
        p->size=sz;  
        p->line=line;  
        void *q = (void *)malloc(sz);  
        p->save=(int)(q);//将地址转化为整形并且存储，在删除的时候会用到。  
        list.Insert(p);  
        return q;//返回的q使用。  
    }  
    void operator delete(void *p)  
    {  
        list.Delete((int *)p);  
        free(p);//这里要将p进行释放.  
    }  
    void *operator new [](size_t sz,const char* pname ,int line)  
    {  
        Node *p = (Node *)malloc(sizeof(Node));  
        p->pname = (char *)malloc(20);  
        strcpy(p->pname,pname);  
        p->size=sz;  
        p->line=line;  
        void *q = (void *)malloc(sz);  
        p->save = (int)(q);  
        list.Insert(p);  
        return q;//反谁开辟内存大小。  
    }  
    void operator delete[](void *p)   
    {  
        list.Delete((int *)p);  
        free(p);//必须返回。  
    }  
    #define new new(__FILE__,__LINE__)//define new  
    int main()  
    {  
        int *p = new int();  
        int *q = new int();  
        char *c = new char();  
        int *p1 = new int[10];  
        delete q;  
        delete []p1;      
        delete c;  
        int *a = new int();   
        return 0;  
    }  

感想：记录内存需要占用大量的内存，虽然在定位地址时加快了速度，是一种侵入式的方法，因为你重载了new及delete，需要引入大量源文件的头部来满足重载new及delete的需求.

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点！
本站所提供的图片等素材，版权归原作者所有，如需使用，请与原作者联系。