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

最新推荐文章于 2023-03-16 16:20:42 发布
最新推荐文章于 2023-03-16 16:20:42 发布
阅读量191 收藏
点赞数
文章标签： 数据结构与算法 c/c++ 内存管理
原文链接：http://www.cnblogs.com/xiaochi/p/8399211.html
版权

运行截图:

 

  • 创建记录分配的内存地址大小和地址的结构体 
    1 struct MEM
2 {
3     void *p;
4     int size;
5 };

     

  • 创建管理内存结构体的链表 
    1 typedef struct LinkNode
2 {
3     struct MEM *pmem;;//保存指针
4     struct LinkNode *pNext;//指向下一个结点
5 }node,*PNODE;

     

  • 设置全局变量 
    1 extern struct LinkNode *phead;

     

  • 向链表中插入一个内存结构体,便于malloc的时候调用 
     1 PNODE addback(PNODE phead, struct MEM *pmem)
 2 {
 3     //开辟一个结点
 4     PNODE pnew = (PNODE)malloc(sizeof(node));
 5     pnew->pmem = pmem;
 6     pnew->pNext = NULL;
 7 
 8     if (phead == NULL)
 9     {
10         phead = pnew;
11     }
12     else
13     {
14         //备份首地址
15         PNODE ptemp = phead;
16         while (ptemp->pNext != NULL)
17         {
18             ptemp = ptemp->pNext;
19         }
20         ptemp->pNext = pnew;
21     }
22     return phead;
23 }

     

  • 修改一个指定的内存结构体,便于realloc的时候调用 
     1 PNODE change(PNODE phead, void *pfind, struct MEM *pnewmem)
 2 {
 3     for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
 4     {
 5         if (ptmp->pmem->p == pfind)
 6         {
 7             ptmp->pmem->p = pnewmem->p;
 8             ptmp->pmem->size = pnewmem->size;
 9             return phead;
10         }
11     }
12     return phead;
13 }

     

  • 删除一个内存结构体,便于free的时候调用 
     1 PNODE deletenode(PNODE phead, void *paddr)
 2 {
 3     //p2保存p1的前一个地址
 4     PNODE p1, p2;
 5     p1 = p2 = NULL;
 6     //遍历寻找内存地址是paddr的内存结构体
 7     p1 = phead;
 8     while (p1 != NULL)
 9     {
10         if (p1->pmem->p == paddr)
11         {
12             break;
13         }
14         else
15         {
16             p2 = p1;
17             p1 = p1->pNext;//备份上一个
18         }
19     }
20 
21     if (p1 != phead)
22     {
23         p2->pNext = p1->pNext;
24         free(p1);
25     }
26     else
27     {
28         phead = phead->pNext;
29         free(p1);
30     }
31 
32     return phead;
33 }

     

  • 查找指定内存的结构体,并返回找到的地址 
     1 PNODE findit(PNODE phead, void *pfind)
 2 {
 3     for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
 4     {
 5         if (ptmp->pmem->p == pfind)
 6         {
 7             return ptmp;
 8         }
 9     }
10     return NULL;
11 }

     

  • 显示内存链表的所有数据 
     1 void getinfo(PNODE phead)
 2 {
 3     if (phead == NULL)
 4     {
 5         printf("目前一共0个地址在堆上,一共消耗0个字节的内存\n");
 6         printf("-------------------------------------------------------------------------\n\n");
 7         return;
 8     }
 9 
10     int i = 0;//多少个地址
11     int j = 0;//多少个字节
12     for (PNODE p = phead; p != NULL; p = p->pNext)
13     {
14         i++;
15         j += p->pmem->size;
16         printf("内存地址=%p     内存大小=%d\n", p->pmem->p, p->pmem->size);
17     }
18     printf("目前一共%d个地址在堆上,一共消耗%d个字节的内存\n", i, j);
19     printf("-------------------------------------------------------------------------\n\n");
20 }

     

  • 释放链表的所有内存 
     1 PNODE deleteall(PNODE phead)
 2 {
 3     printf("释放所有内存\n");
 4     printf("-------------------------------------------------------------------------\n\n");
 5     PNODE p1 = NULL;
 6     PNODE p2 = NULL;
 7     p1 = phead;
 8     while (p1 != NULL)
 9     {
10         p2 = p1->pNext;
11         free(p1->pmem->p);
12         p1->pmem->p = NULL;
13         free(p1);
14         p1 = p2;
15     }
16 
17     return NULL;
18     
19 }

     

  • mymalloc函数,向链表中插入数据 
     1 void *mymalloc(size_t size)
 2 {
 3     void *p = malloc(size);
 4     printf("分配内存        分配的地址%p    大小%d\n", p, size);
 5     printf("-------------------------------------------------------------------------\n\n");
 6     //创建一个结点,并且初始化,出入内存管理链表
 7     struct MEM *pmem = (struct MEM*)malloc(sizeof(struct MEM));
 8     pmem->p = p;
 9     pmem->size = size;
10     phead = addback(phead, pmem);
11     return p;
12 }

     

  • myfree函数,在链表中删除数据 
     1 void myfree(void *p)
 2 {
 3     printf("\n内存地址%p释放\n", p);
 4     printf("-------------------------------------------------------------------------\n\n");
 5     PNODE px = findit(phead, p);
 6     if (px == NULL)
 7     {
 8         return;
 9     }
10     else
11     {
12         phead = deletenode(phead, p);//删除
13         free(p);
14     }
15 }

     

  • myrealloc在链表中修改一个数据 
     1 void *myrealloc(void *p, size_t size)
 2 {
 3     
 4     void *pt = realloc(p, size);
 5     printf("内存地址%p重新分配到%p,大小%d\n",p, pt,size);
 6     printf("-------------------------------------------------------------------------\n\n");
 7     struct MEM mymem;
 8     mymem.p = pt;
 9     mymem.size = size;
10     phead = change(phead, p, &mymem);
11     return pt;
12 }

     

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

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

完整代码:

mem.h

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 //记录分配的内存地址大小和地址
 5 struct MEM
 6 {
 7     void *p;
 8     int size;
 9 };
10 
11 typedef struct LinkNode
12 {
13     struct MEM *pmem;;//保存指针
14     struct LinkNode *pNext;//指向下一个结点
15 }node,*PNODE;
16 
17 extern struct LinkNode *phead;
18 
19 //向链表中插入一个数据
20 PNODE addback(PNODE phead, struct MEM *pmem);
21 //修改一个数据
22 PNODE change(PNODE phead, void *pfind, struct MEM *pnewmem);
23 //删除一个结点
24 PNODE deletenode(PNODE phead, void *paddr);
25 //显示
26 void showall(PNODE phead);
27 //查找
28 PNODE findit(PNODE phead,void *pfind);
29 //获取内存信息
30 void getinfo(PNODE phead);
31 //释放所有内存
32 PNODE deleteall(PNODE phead);
33 
34 void *mymalloc(size_t size);
35 void myfree(void *p);
36 void *myrealloc(void *p, size_t size);

mem.cpp

  1 #include "mem.h"
  2 struct LinkNode *phead = NULL;
  3 
  4 //插入一个数据
  5 PNODE addback(PNODE phead, struct MEM *pmem)
  6 {
  7     //开辟一个结点
  8     PNODE pnew = (PNODE)malloc(sizeof(node));
  9     pnew->pmem = pmem;
 10     pnew->pNext = NULL;
 11 
 12     if (phead == NULL)
 13     {
 14         phead = pnew;
 15     }
 16     else
 17     {
 18         //备份首地址
 19         PNODE ptemp = phead;
 20         while (ptemp->pNext != NULL)
 21         {
 22             ptemp = ptemp->pNext;
 23         }
 24         ptemp->pNext = pnew;
 25     }
 26     return phead;
 27 }
 28 
 29 //修改一个指定的内存结构体
 30 PNODE change(PNODE phead, void *pfind, struct MEM *pnewmem)
 31 {
 32     for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
 33     {
 34         if (ptmp->pmem->p == pfind)
 35         {
 36             ptmp->pmem->p = pnewmem->p;
 37             ptmp->pmem->size = pnewmem->size;
 38             return phead;
 39         }
 40     }
 41     return phead;
 42 }
 43 
 44 //删除一个结点
 45 PNODE deletenode(PNODE phead, void *paddr)
 46 {
 47     //p2保存p1的前一个地址
 48     PNODE p1, p2;
 49     p1 = p2 = NULL;
 50 
 51     p1 = phead;
 52     while (p1 != NULL)
 53     {
 54         if (p1->pmem->p == paddr)
 55         {
 56             break;
 57         }
 58         else
 59         {
 60             p2 = p1;
 61             p1 = p1->pNext;//备份上一个
 62         }
 63     }
 64 
 65     if (p1 != phead)
 66     {
 67         p2->pNext = p1->pNext;
 68         free(p1);
 69     }
 70     else
 71     {
 72         phead = phead->pNext;
 73         free(p1);
 74     }
 75 
 76     return phead;
 77 }
 78 
 79 //显示所有数据
 80 void showall(PNODE phead)
 81 {
 82     if (phead == NULL)
 83     {
 84         printf("-------------------------------------------------------------------------\n\n");
 85         return;
 86     }
 87     else
 88     {
 89         printf("内存地址=%p     内存大小=%d\n", phead->pmem->p, phead->pmem->size);
 90         showall(phead->pNext);
 91     }
 92 }
 93 
 94 //查找
 95 PNODE findit(PNODE phead, void *pfind)
 96 {
 97     for (PNODE ptmp = phead; ptmp != NULL; ptmp = ptmp->pNext)
 98     {
 99         if (ptmp->pmem->p == pfind)
100         {
101             return ptmp;
102         }
103     }
104     return NULL;
105 }
106 
107 //获取信息
108 void getinfo(PNODE phead)
109 {
110     if (phead == NULL)
111     {
112         printf("目前一共0个地址在堆上,一共消耗0个字节的内存\n");
113         printf("-------------------------------------------------------------------------\n\n");
114         return;
115     }
116 
117     int i = 0;//多少个地址
118     int j = 0;//多少个字节
119     for (PNODE p = phead; p != NULL; p = p->pNext)
120     {
121         i++;
122         j += p->pmem->size;
123         printf("内存地址=%p     内存大小=%d\n", p->pmem->p, p->pmem->size);
124     }
125     printf("目前一共%d个地址在堆上,一共消耗%d个字节的内存\n", i, j);
126     printf("-------------------------------------------------------------------------\n\n");
127 }
128 
129 //释放所有内存
130 PNODE deleteall(PNODE phead)
131 {
132     printf("释放所有内存\n");
133     printf("-------------------------------------------------------------------------\n\n");
134     PNODE p1 = NULL;
135     PNODE p2 = NULL;
136     p1 = phead;
137     while (p1 != NULL)
138     {
139         p2 = p1->pNext;
140         free(p1->pmem->p);
141         p1->pmem->p = NULL;
142         free(p1);
143         p1 = p2;
144     }
145 
146     return NULL;
147     
148 }
149 
150 
151 void *mymalloc(size_t size)
152 {
153     void *p = malloc(size);
154     printf("分配内存        分配的地址%p    大小%d\n", p, size);
155     printf("-------------------------------------------------------------------------\n\n");
156     //创建一个结点,并且初始化,出入内存管理链表
157     struct MEM *pmem = (struct MEM*)malloc(sizeof(struct MEM));
158     pmem->p = p;
159     pmem->size = size;
160     phead = addback(phead, pmem);
161     return p;
162 }
163 
164 void myfree(void *p)
165 {
166     printf("\n内存地址%p释放\n", p);
167     printf("-------------------------------------------------------------------------\n\n");
168     PNODE px = findit(phead, p);
169     if (px == NULL)
170     {
171         return;
172     }
173     else
174     {
175         phead = deletenode(phead, p);//删除
176         free(p);
177     }
178 }
179 
180 void *myrealloc(void *p, size_t size)
181 {
182     
183     void *pt = realloc(p, size);
184     printf("内存地址%p重新分配到%p,大小%d\n",p, pt,size);
185     printf("-------------------------------------------------------------------------\n\n");
186     struct MEM mymem;
187     mymem.p = pt;
188     mymem.size = size;
189     phead = change(phead, p, &mymem);
190     return pt;
191 }

main.c

#include "mem.h"

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

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

 

转载于:https://www.cnblogs.com/xiaochi/p/8399211.html

weixin_30615767
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言 动态内存分配详解
01-20
C语言 动态内存分配详解 动态内存分配涉及到堆栈的概念：堆栈是两种数据结构。堆栈都是数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 栈（操作系统）：由操作系统自动分配释放 ，...
讲解+可执行完整代码 C++ 单链表(1) 单链表的建立与动态内存的释放
北邮22级信通一枚
02-19 1065
链表是讲每个带存储数据元素看成一个数据结点，并为每个节点分配空间，最后将这些结点连接起来形成一个链式结构。单链表包括数据域和指针域。数据域里存放的是数据，指针域里存放着用于连接链表的指针。
链表内存的释放
pqw1157的专栏
11-22 1万+
 链表是一种很常用的数据结构，如果在建立的时候为其每个节点分配了堆中的内存，则在程序结束前应该释放它，下面是常有的一段释放链表内存的程序：p = plist;//p和plist是指向一段相同地址空间的两个不同指针。while(p !=NULL)...{    q=p->next;    free(p);    p=q;}plist=NULL;//只是释放了其内存空间，指向链表的指针值并没有
链表基础知识
m0_61435822的博客
10-16 389
C++链表
c语言释放链表所用内存,C语言利用链表实现有效内存管理
weixin_28808633的博客
05-21 1180
#include//记录分配的内存地址大小、地址struct MEM {void *p;int size;};typedef struct LinkNode {struct MEM *pmem;//保存指针struct LinkNode *pNext;//指向下一个节点} node,*PNODE;PNODE phead;PNODE findit(PNODE phead,void *paddr) {...
【C++项目实战】链表创建和内存释放
积流成河
07-22 1509
#include<iostream> using namespace std; struct Node{ int val; Node *next, *random; Node(int x): val(x), next(nullptr), random(nullptr){}; void DeleteList(){ Node*p=this; Node*head; if(p){ int val =
c语言stack(栈)和heap(堆)的使用详解
12-25
1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据...
C语言讲义.doc
01-27
8.7.18 atof转化为float 45 8.7.19 atol转化为long 45 9 函数 45 9.1 函数的原型和调用 45 9.2 函数的形参与实参 45 9.3 函数的返回类型与返回值 46 9.4 MAIN函数与EXIT函数与函数的RETURN语句 46 9.5 多个源代码...
学生管理资源 C语言
09-02
要求使用链表实现存储、读写以及管理学生信息。 属性：必选 描述：学生信息必须包含如下项（包括但不限于）： ● 学号（ID）； ● 姓名 ● 密码 ● 年龄 ● 班级 ● 性别 ● 数学成绩 ● 语文成绩 ● ...
程序的内存分配
02-11
1、栈区（stack）― 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） ― 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它...
C语言动态链表malloc、realloc、free函数详细介绍（附代码示例）
lbcbjtlhmjq的博客
03-16 1386
在很多情况下，我们定义一个数组时，并不知道这个数组将来会存放多少个数据元素。更普遍的情况是，数组中的元素个数一直在不断变化。 例如，一个存放学生信息的结构体数组。如果出现插班生入学、学生转学等情况，就需要往数组中增加或删除数据元素。
链表的创建，遍历，内存释放，检索，插入，删除,以及其他操作 （吉林大学 孙立鑫）
langke123654的博客
12-18 813
链表的创建，遍历，内存释放，检索，插入，删除,以及其他操作 （吉林大学 孙立鑫）
【C语言学习】——————链表的重新链接与动态内存的释放
m0_52751535的博客
03-28 1721
链表中指定结点的删除 书接上回，当时是将指定结点赋予特定指限制输出。 原文链接如下： https://editor.csdn.net/md/?articleId=114953286 转换下思路：不把该结点的地址保存在上一个结点的指针域中，相当于把指定结点之外的结点再次串为一个新链表。 遍历链表查找指定结点 int del = 0; scanf("%d", &del); struct a* cur = list; while (cur) { if (cur->data == del)
c语言链表内存释放,最简单的链表删除第一个节点时释放内存的问题
weixin_39635314的博客
05-22 318
该楼层疑似违规已被系统折叠隐藏此楼查看此楼1 #include2#include "list.h"34 int IsEmpty(List L)5 {6 return L->Next == NULL;7 }89 int IsLast(Position P, List L)10{11 return P->Next == NULL;12 }1314 Position F...
C++之内存管理：申请与释放
weixin_53472920的博客
08-17 6219
其实关于内存管理，我觉得重点就在于合理申请，及时释放，将有限的内存空间发挥出最大的价值。
（C语言版）链表（三）——实现双向链表创建、删除、插入、释放内存等简单操作
热门推荐
菜鸟学C/C++
02-23 3万+
上午写了下单向循环链表的程序，今天下午我把双向链表的程序写完了。其实双向链表和单向链表也是有很多相似的地方的，听名字可以猜到，每个节点都包含两个指针，一个指针指向上一个节点，一个指针指向下一个节点。这里有两个特殊的地方，第一就是头节点的一个指针指向NULL空指针（没有前驱节点），第二就是尾节点的一个指针指向NULL指针（没有后继节点）。 我们可以看下双向链表的示意图（自己画的比较难看）：
（C语言版）链表（四）——实现双向循环链表创建、插入、删除、释放内存等简单操作
菜鸟学C/C++
02-24 1万+
双向循环链表是基于双向链表的基础上实现的，和双向链表的操作差不多，唯一的区别就是它是个循环的链表，通过每个节点的两个指针把它们扣在一起组成一个环状。所以呢，每个节点都有前驱节点和后继节点（包括头节点和尾节点）这是和双向链表不同的地方。我们看下双向循环链表的示意图（我在网上找了张图片，自己画的实在难看，有时间真的要去学下怎么画图了，然后可以写出更好的博客）： 在程序的编写方面呢，双向循环链表有
单向链表之释放（C语言实现）
peng_fp的博客
03-19 1万+
链表的创建查看 同遍历链表类似，区别在于p_mov每指向某个节点后都将该节点释放 1、释放前要先保存下一个节点，释放后备份恢复给p_mov,否则释放了当前节点，下一个节点的地址就将失去； 2、依次将所有节点释放后，最后返回NULL（标示释放完毕）。 结构体节点： typedef struct student { int num; //学号 i
用数据结构和c语言实现自动点餐系统需要运用到什么知识
最新发布
11-24
4. 内存管理：在自动点餐系统中，需要动态地分配和释放内存来存储菜单、订单和其他相关数据。需要了解C语言中的动态内存分配和释放函数，如malloc和free等。 5. 用户界面设计：自动点餐系统需要有用户界面与用户...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值