18.链表管理内存实现c语言自动释放内存

运行截图:

• 创建记录分配的内存地址大小和地址的结构体

   struct MEM
   {
       void *p;
       int size;
   };

• 创建管理内存结构体的链表

   typedef struct LinkNode
   {
       struct MEM *pmem;;//保存指针
       struct LinkNode *pNext;//指向下一个结点
   }node,*PNODE;

• 设置全局变量

   extern struct LinkNode *phead;

• 向链表中插入一个内存结构体,便于malloc的时候调用

   PNODE addback(PNODE phead, struct MEM *pmem)
   {
       //开辟一个结点
       PNODE pnew = (PNODE)malloc(sizeof(node));
       pnew->pmem = pmem;
       pnew->pNext = NULL;
  
       if (phead == NULL)
       {
           phead = pnew;
       }
       else
       {
           //备份首地址
           PNODE ptemp = phead;
           while (ptemp->pNext != NULL)
           {
               ptemp = ptemp->pNext;
           }
           ptemp->pNext = pnew;
       }
       return phead;
   }

• 修改一个指定的内存结构体,便于realloc的时候调用

   PNODE change(PNODE phead, void *pfind, struct MEM *pnewmem)
   {
       for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
       {
           if (ptmp->pmem->p == pfind)
           {
               ptmp->pmem->p = pnewmem->p;
               ptmp->pmem->size = pnewmem->size;
               return phead;
           }
       }
       return phead;
   }

• 删除一个内存结构体,便于free的时候调用

   PNODE deletenode(PNODE phead, void *paddr)
   {
       //p2保存p1的前一个地址
       PNODE p1, p2;
       p1 = p2 = NULL;
       //遍历寻找内存地址是paddr的内存结构体
       p1 = phead;
       while (p1 != NULL)
       {
           if (p1->pmem->p == paddr)
           {
               break;
           }
           else
           {
               p2 = p1;
               p1 = p1->pNext;//备份上一个
           }
       }
  
       if (p1 != phead)
       {
           p2->pNext = p1->pNext;
           free(p1);
       }
       else
       {
           phead = phead->pNext;
           free(p1);
       }
  
       return phead;
   }

• 查找指定内存的结构体,并返回找到的地址

   PNODE findit(PNODE phead, void *pfind)
   {
       for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
       {
           if (ptmp->pmem->p == pfind)
           {
               return ptmp;
           }
       }
       return NULL;
   }

• 显示内存链表的所有数据

   void getinfo(PNODE phead)
   {
       if (phead == NULL)
       {
           printf("目前一共0个地址在堆上,一共消耗0个字节的内存\n");
           printf("-------------------------------------------------------------------------\n\n");
           return;
       }
  
       int i = ;//多少个地址
       int j = ;//多少个字节
       for (PNODE p = phead; p != NULL; p = p->pNext)
       {
           i++;
           j += p->pmem->size;
           printf("内存地址=%p     内存大小=%d\n", p->pmem->p, p->pmem->size);
       }
       printf("目前一共%d个地址在堆上,一共消耗%d个字节的内存\n", i, j);
       printf("-------------------------------------------------------------------------\n\n");
   }

• 释放链表的所有内存

   PNODE deleteall(PNODE phead)
   {
       printf("释放所有内存\n");
       printf("-------------------------------------------------------------------------\n\n");
       PNODE p1 = NULL;
       PNODE p2 = NULL;
       p1 = phead;
       while (p1 != NULL)
       {
           p2 = p1->pNext;
           free(p1->pmem->p);
           p1->pmem->p = NULL;
           free(p1);
           p1 = p2;
       }
  
       return NULL;
  
   }

• mymalloc函数,向链表中插入数据

   void *mymalloc(size_t size)
   {
       void *p = malloc(size);
       printf("分配内存        分配的地址%p    大小%d\n", p, size);
       printf("-------------------------------------------------------------------------\n\n");
       //创建一个结点,并且初始化,出入内存管理链表
       struct MEM *pmem = (struct MEM*)malloc(sizeof(struct MEM));
       pmem->p = p;
       pmem->size = size;
       phead = addback(phead, pmem);
       return p;
   }

• myfree函数,在链表中删除数据

   void myfree(void *p)
   {
       printf("\n内存地址%p释放\n", p);
       printf("-------------------------------------------------------------------------\n\n");
       PNODE px = findit(phead, p);
       if (px == NULL)
       {
           return;
       }
       else
       {
           phead = deletenode(phead, p);//删除
           free(p);
       }
   }

• myrealloc在链表中修改一个数据

   void *myrealloc(void *p, size_t size)
   {
  
       void *pt = realloc(p, size);
       printf("内存地址%p重新分配到%p,大小%d\n",p, pt,size);
       printf("-------------------------------------------------------------------------\n\n");
       struct MEM mymem;
       mymem.p = pt;
       mymem.size = size;
       phead = change(phead, p, &mymem);
       return pt;
   }

main函数宏定义替换 malloc,free,realloc

#define malloc mymalloc
#define free myfree
#define realloc myrealloc

完整代码:

mem.h

 #include <stdio.h>
 #include <stdlib.h>

 //记录分配的内存地址大小和地址
 struct MEM
 {
     void *p;
     int size;
 };

 typedef struct LinkNode
 {
     struct MEM *pmem;;//保存指针
     struct LinkNode *pNext;//指向下一个结点
 }node,*PNODE;

 extern struct LinkNode *phead;

 //向链表中插入一个数据
 PNODE addback(PNODE phead, struct MEM *pmem);
 //修改一个数据
 PNODE change(PNODE phead, void *pfind, struct MEM *pnewmem);
 //删除一个结点
 PNODE deletenode(PNODE phead, void *paddr);
 //显示
 void showall(PNODE phead);
 //查找
 PNODE findit(PNODE phead,void *pfind);
 //获取内存信息
 void getinfo(PNODE phead);
 //释放所有内存
 PNODE deleteall(PNODE phead);

 void *mymalloc(size_t size);
 void myfree(void *p);
 void *myrealloc(void *p, size_t size);

mem.cpp

 #include "mem.h"
 struct LinkNode *phead = NULL;

 //插入一个数据
 PNODE addback(PNODE phead, struct MEM *pmem)
 {
     //开辟一个结点
     PNODE pnew = (PNODE)malloc(sizeof(node));
     pnew->pmem = pmem;
     pnew->pNext = NULL;

     if (phead == NULL)
     {
         phead = pnew;
     }
     else
     {
         //备份首地址
         PNODE ptemp = phead;
         while (ptemp->pNext != NULL)
         {
             ptemp = ptemp->pNext;
         }
         ptemp->pNext = pnew;
     }
     return phead;
 }

 //修改一个指定的内存结构体
 PNODE change(PNODE phead, void *pfind, struct MEM *pnewmem)
 {
     for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
     {
         if (ptmp->pmem->p == pfind)
         {
             ptmp->pmem->p = pnewmem->p;
             ptmp->pmem->size = pnewmem->size;
             return phead;
         }
     }
     return phead;
 }

 //删除一个结点
 PNODE deletenode(PNODE phead, void *paddr)
 {
     //p2保存p1的前一个地址
     PNODE p1, p2;
     p1 = p2 = NULL;

     p1 = phead;
     while (p1 != NULL)
     {
         if (p1->pmem->p == paddr)
         {
             break;
         }
         else
         {
             p2 = p1;
             p1 = p1->pNext;//备份上一个
         }
     }

     if (p1 != phead)
     {
         p2->pNext = p1->pNext;
         free(p1);
     }
     else
     {
         phead = phead->pNext;
         free(p1);
     }

     return phead;
 }

 //显示所有数据
 void showall(PNODE phead)
 {
     if (phead == NULL)
     {
         printf("-------------------------------------------------------------------------\n\n");
         return;
     }
     else
     {
         printf("内存地址=%p     内存大小=%d\n", phead->pmem->p, phead->pmem->size);
         showall(phead->pNext);
     }
 }

 //查找
 PNODE findit(PNODE phead, void *pfind)
 {
     for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
     {
         if (ptmp->pmem->p == pfind)
         {
             return ptmp;
         }
     }
     return NULL;
 }

 //获取信息
 void getinfo(PNODE phead)
 {
     if (phead == NULL)
     {
         printf("目前一共0个地址在堆上,一共消耗0个字节的内存\n");
         printf("-------------------------------------------------------------------------\n\n");
         return;
     }

     int i = ;//多少个地址
     int j = ;//多少个字节
     for (PNODE p = phead; p != NULL; p = p->pNext)
     {
         i++;
         j += p->pmem->size;
         printf("内存地址=%p     内存大小=%d\n", p->pmem->p, p->pmem->size);
     }
     printf("目前一共%d个地址在堆上,一共消耗%d个字节的内存\n", i, j);
     printf("-------------------------------------------------------------------------\n\n");
 }

 //释放所有内存
 PNODE deleteall(PNODE phead)
 {
     printf("释放所有内存\n");
     printf("-------------------------------------------------------------------------\n\n");
     PNODE p1 = NULL;
     PNODE p2 = NULL;
     p1 = phead;
     while (p1 != NULL)
     {
         p2 = p1->pNext;
         free(p1->pmem->p);
         p1->pmem->p = NULL;
         free(p1);
         p1 = p2;
     }

     return NULL;

 }

 void *mymalloc(size_t size)
 {
     void *p = malloc(size);
     printf("分配内存        分配的地址%p    大小%d\n", p, size);
     printf("-------------------------------------------------------------------------\n\n");
     //创建一个结点,并且初始化,出入内存管理链表
     struct MEM *pmem = (struct MEM*)malloc(sizeof(struct MEM));
     pmem->p = p;
     pmem->size = size;
     phead = addback(phead, pmem);
     return p;
 }

 void myfree(void *p)
 {
     printf("\n内存地址%p释放\n", p);
     printf("-------------------------------------------------------------------------\n\n");
     PNODE px = findit(phead, p);
     if (px == NULL)
     {
         return;
     }
     else
     {
         phead = deletenode(phead, p);//删除
         free(p);
     }
 }

 void *myrealloc(void *p, size_t size)
 {

     void *pt = realloc(p, size);
     printf("内存地址%p重新分配到%p,大小%d\n",p, pt,size);
     printf("-------------------------------------------------------------------------\n\n");
     struct MEM mymem;
     mymem.p = pt;
     mymem.size = size;
     phead = change(phead, p, &mymem);
     return pt;
 }

main.c

#include "mem.h"

#define malloc mymalloc
#define free myfree
#define realloc myrealloc

void main()
{
    void *p1 = malloc(**);
    void *p2 = malloc( *  * );
    void *p3 = malloc( *  * );
    getinfo(phead);
    realloc(p1, );
    getinfo(phead);
    free(p3);
    getinfo(phead);
    phead = deleteall(phead);
    getinfo(phead);
    system("pause");
}