用单链表实现的内存管理

用单链表实现的内存管理

   
   在C语言论坛中看了dgarc发表的一个贴子后，按要求写了一段代码，可以实现内存分配的管理，避免内存泄漏，欢迎各位测试，如遇bug，敬请指出，我将进行有针对性的改进，然后重新贴出来。

要求如下：

    题目：监控应用程序的内存申请和释放 
    描述：
         不考虑多线程，使用动态单链表的方式进行操作，在应用程序申请内存时，需要把该内存节点信息插入链表进行记录，应用程序释放内存，把相应内存节点的信息从 链表中删除，在应用程序退出时，如果链表仍然存在节点，说明存在内存泄露，应用程序不存在内存泄露，则链表为空。
MLCmalloc（）  封装了malloc ，同时将信息插入链表操作
MLCfree（）    封装了free ，同时将信息从链表中删除

程序代码：
    下列代码在满足题目要求的同时，增加了对泄漏空间的检测和释放功能。

1. #include <stdio.h>
2. #include <string.h>
3. #include <windows.h>
4. 
   
5. #define   _MC    1     // MLCmalloc()的标志
6. #define   _FE    0     // MLCfree()的标志
7. #define  _Check  -1    //检测内存的标志
8. 
   
9. 
   
10. typedef struct _Memory         //单向链表结构
11. {
12.     unsigned int address;
13.     struct _Memory *next;
14. }Mem, *LinkMem;

1. 
   
2. 
   
3.  ///内存管理//
4. int MemoryContrl(size_t addr,char flag) 
5. {
6.     static Mem head;        //保存链表头     
7.     LinkMem tmp=head.next, node=&head ; 
8.     if( _MC==flag )         //增加链表节点
9.     {
10.         while(tmp)              
11.         {
12.             node=tmp;
13.             tmp=tmp->next;
14.         }
15.         node->next=(LinkMem)malloc(sizeof(Mem));
16.         if(node->next==NULL)
17.             return 1;   //分配失败!
18.         node=node->next;
19.         node->address=addr;
20.         node->next=NULL;
21.     }
22.     else if( _FE==flag)     //删除节点
23.     {
24.         while(tmp && (tmp->address!=addr))
25.         {
26.             node=tmp;
27.             tmp=tmp->next;
28.         }
29.         if(tmp==NULL)
30.             return -1;  //free地址出错!
31.         else
32.         {
33.             node->next=tmp->next;
34.             free(tmp);
35.         }
36.     }
37.     else                           //有泄漏返回地址，无则返回null
38.         return (int)( head.next? head.next->address :0 );  
39.     return 0;
40. }
41. 
    
42.  ///内存分配//
43. 
    
44. void *MLCmalloc(size_t size)  
45. {
46.     void *pMalc=malloc(size);
47.     if(pMalc==NULL)
48.         return NULL;
49.     else if(MemoryContrl((size_t)pMalc, _MC)==1)
50.     {
51.         free(pMalc);   //动态链建立失败时释放此次分配的空间
52.         return NULL;
53.     }       
54.     else
55.         return pMalc;
56. }

1. ///内存释放//

1. void MLCfree(void *ptr)       
2. {
3.     if(MemoryContrl((size_t)ptr, _FE)==-1)
4.     {
5.         printf("%s/n","被释放的内存地址错误!");
6.         return ;
7.     }
8.     else
9.         free(ptr);
10. }
11. 
    

1. //检查泄漏//
   
2. size_t CheckLeak()  
3. {
4.     return (size_t)(MemoryContrl((size_t)0, _Check));
5. }
6. 
   
7. int main()
8. {
9.     char **p=NULL;
10.     char *str="1234567890098765432";
11.     char *tmp,i;
12.     p=(char **)MLCmalloc(10*sizeof(char*));
13.     printf("分配p=%#x/n",p);
14.     for( i=0;i<10; i++)
15.     {
16.         p[i]=(char *)MLCmalloc(20*sizeof(char));
17.         sscanf(str,"%s",p[i]);
18.     }
19.     for(i=0; i<10; i++)
20.         printf("&p[%d]=%#x  *p[%d]=%s/n",i,p[i],i,p[i]);
21.     printf("释放p=%#x/n",p);   //不安正常顺序释放
22.     MLCfree(p);
23.     while((tmp=(char*)CheckLeak())!=0)  //检测是否有泄漏空间
24.     {
25.         MLCfree(tmp);               //释放检测到的泄漏空间
26.         printf("tmp=%#x/n",tmp);
27.     }
28.     return 0;
29. 
    
30. }