行业知识
【C语言】C语言通用链表的设计与实现(附详细讲解、图示和源码)
作者���介:阿里巴巴嵌入式技术专家,深耕嵌入式+人工智能领域,具备多年的嵌入式硬件产品研发管理经验。
博客介绍:分享嵌入式开发领域的相关知识、经验、思考和感悟,欢迎关注。提供嵌入式方向的学习指导、简历面试辅导、技术架构设计优化、开发外包等服务,有需要可私信联系。
C语言通用链表的设计与实现(附详细讲解、图示和源码)
前言
数组与链表比较
链表的分类
单链表
双链表
循环链表
非循环链表
链表数据结构
常见链表算法
各算法的详解与实现
链表的初始化
链表节点的插入
1. 第一种情况:空链表
2. 第二种情况:非空链表
2.1 头插法
2.2 尾插法
2.3 定插法
链表节点的删除
链表的遍历
链表的搜索
链表的排序
链表逆序
求链表长度
获取链表某节点的数据
链表的注销
测试程序
源码下载
后记
前言
- 本文用到一个很重要的思想--泛型编程思想;不熟悉泛型的话,请自行搜索相关资料学习(void *,如memcpy,memmove,qsort,memset等库函数均使用到了泛型思想) 。
- 本文最后会提供一个demo程序附件,该demo程序以c99标准进行编写的,在Linux-gcc下调试通过,vc6下可能会有错误。
- 本文图示中,红色实线表示要添加的地方,黑色虚线表示要断开的地方,黑色实线保持原样。
- 本文链表设计为最简单的非循环单链表。
- 每一步都有配图讲解链表指针走向,再也不用担心硬啃代码了!!!
数组与链表比较
| 数组 | 链表 | |
| 优点 | 存取速度快 操作方便 | 不限制大小 插入删除易于实现 空间无需连续 |
| 缺点 | 插入删除等操作不易实现 需要连续空间存储 数组元素需要类型相同 | 存取速度慢 操作复杂 |
通过比较可以发现,数组的优点正好就是链表的缺点,而链表的缺点正好是数组的优点。
链表的分类
单链表
每个节点有1个指针域,指向后继(next)
双链表
每个节点都有2个指针域,一个指向前驱(previous),一个指向后继(next)
循环链表
首尾相接,tail->next = head; 能通过任意一个节点找到其他所有的节点
非循环链表
首尾不相接,tail->next = NULL;通过head可以找到所有节点。
链表数据结构
typedef struct node{ //节点结构 void *data; struct node *next;} node;typedef struct { //链表结构 struct node *head; struct node *tail; long len;} List; 常见链表算法
void list_init(List *list); //初始化void list_destroy(List *list, void (*destroy)(void *)); //销毁void list_insert(List *list, void *data); //插入void list_insert_at_head(List *list, void *data); //头插法void list_insert_at_index(List *list, void *data); //随插法void list_insert_at_tail(List *list, void *data, long idx); //定插法void *list_delete(List *list, void *key, int (*compare)(const void *, const void *)); //删除void *list_search(List *list, void *key, int (*compare)(const void *, const void *));//搜索void *list_sort(List *list, void *key, int (*compare)(const void *, const void *)); //排序void list_traverse(List *list, void (*handle)(void *)); //遍历void list_reverse(List *list); //逆序long get_lenth(List *list); //求长度void *list_get_element(List *list, long index); //获取链表节点bool is_empty(List *list); //判断空链表
各算法的详解与实现
已知链表结构如下所示
typedef struct{ //链表结构 struct node *head; struct node *tail; long len;}List; 该链表有具有3个属性,头指针head,尾指针tail以及链表长度len;
首先,定义一个链表,
List list;
此时链表结构如下所示:
链表的初始化
链表刚建立的时候,是不含任何有效数据的,也就是说不含有效节点。因此头指针head和尾指针tail无指向,即指向NULL,此时链表长度为0。即此时链表结构如下所示:
程序实现
void list_init(List *list){ list->head = NULL; list->tail = NULL; list->len = 0;} 刚初始化完的链表是一个空链表,空链表的头指针必定为NULL,该特征可以作为判定空链表的依据,由此实现判断空链表的程序
#include bool is_empty(List *list){ return (list->head == NULL);} 链表节点的插入
链表初始化完成之后,就可以进行各种操作(如插入删除节点,求长度,销毁链表等)了,下面来解释一下链表插入的操作方法;
插入节点需要分2种情况讨论:
-
链表为空时,插入的第一个节点(首节点);
-
在非空链表上插入一个节点。
1. 第一种情况:空链表
该种情况可用下图表示
此时,只有一个节点A,此时节点A既是首节点(因此head指向节点A),又是尾节点(因此tail也指向节点A,并且A->next = NULL);同时,链表长度要相应的+1(插入程序中,len始终呈++的状态,下文不再赘述)。
程序实现(假设n为待插入的节点)
struct node *new;list->head = new;list->tail = new;new->next = NULL;list->len++;
2. 第二种情况:非空链表
第二种情况又分为3种情况,根据新节点的插入位置,分别如下所示:
2.1 头插法
在头部插,头插法:list_insert_at_head(...);
分析图例可知,已有链表(左侧),list->head = A;现在要在head处插入一个节点N,需要断开head与A的连接,使N->next = A;然后list->head = N(这两步不可调换顺序,可以想想为什么?)。
程序实现如下:
struct node *new;new->next = list->head->next;list->head = new;list->len++;
2.2 尾插法
在尾部插,尾插法:list_insert_at_tail(...);
分析图例可知,已有链表(左侧),list->tail = Z;现在要在tail处插入一个节点N,需要断开tail与Z的连接,使Z->next = N;(即list->tail->next = N;)然后list->tail = N(这两步可以调换顺序吗?想想为什么?),然后再使N->next = NULL。
程序实现如下:
struct node *new;list->tail->next = new; list->tail = new; new->next = NULL;list->len++;
2.3 定插法
在第index个节点处插,定插法:list_insert_at_index(...)。
分析图例可知,已有链表(左侧),A->next= B;现在要在A处插入一个节点N,需要断开A与B的连接,使N->next = B;(即N->next = A->next;)然后使A->next = N(这两步可以调换顺序吗?想想为什么?)。
随插法由于插入位置不确定,所以不一定在图中的A节点处插入,有可能是B、C、D甚至Z。所以此处需要通过用户给定的index值配合list->head来找到插入位置。
代码实现如下:
static struct node *make_node(void *data) //把用户传递过来的数据打包为一个链表节点{ struct node *n; n = malloc(sizeof(struct node)); assert(n != NULL); n->next = NULL; n->data = data; return n;}void list_insert_at_head(List *list, void *data) //头插法{ struct node *n; n = make_node(data); if(list->head == NULL){ //如果是空链表 list->head = n; list->tail = n; } else{ //如果不是非空链表 n->next = list->head; list->head = n; } list->len++;}void list_insert_at_tail(List *list, void *data) //尾插法{ struct node *n; n = make_node(data); if(list->head == NULL){ //如果是空链表 list->head = n; list->tail = n; n->next = NULL; } else{ //如果不是非空链表 list->tail->next = n; list->tail = n; n->next = NULL; } list->len++;}void list_insert_at_index(List *list, void *data, long index){ long i = 1; //从1开始算 struct node *p, *n; p = list->head; while(p && i next; i++; } if(p){ //如果链表遍历完了,计数i还没到index,说明第index个节点不存在。 n = make_node(data); n->next = p->next; p->next = n; list->len++; }}void list_insert(List *list, void *data) //默认采用尾插法{ list_insert_at_tail(list, data);} 链表节点的删除
删除链表中的一个已有节点,如下图所示:
分析图例可知,已有链表(左侧),A->next= B;B->next = C;现在要删除节点B,那么需要断开节点AB和BC之间的关系,然后把AC连接起来。即A->next = A->next->next;然后根据需要f释放节点B即可。
程序实现:
void * list_delete(List *list, void *key, int (*compare)(const void *, const void *)) //以key为删除关键词,compare为节点数据比较机制,由用户自己编写 { void *data; struct node *n, *t; n = list->head; if(!compare(n->data, key)){ //如果要删除的节点为首节点 printf("list_delete\n"); t = n; data = n->data; list->head = n->next; free(t); list->len--; return data; } while(n->next != NULL){ //遍历查找符合条件的节点,删除之 if(compare(n->next->data, key) == 0){ //只删除第一个符合条件的节点。 t = n->next; if(n->next == list->tail){ list->tail = n; } n->next = n->next->next; data = t->data; free(t); list->len--; return data; //把删除的数据返回给用户,供用户后续的处理使用。 } n = n->next; } return NULL; //没找到匹配的节点,返回NULL} 链表的遍历
使用node = node->next的方式,依次得到各个节点,对各个节点使用handle方法,即实现了链表的遍历。
程序实现:
void list_traverse(List *list, void (*handle)(void *)) //handle为节点遍历策略,由用户自己编写{ struct node *p; p = list->head; while(p){ handle(p->data); p = p->next; }} 链表的搜索
根据用户给点的数据遍历匹配节点,如果找到了,则将该节点的数据域返回给用户;找不到返回NULL。
程序实现:
void *list_search(List *list, void *key, int (*compare)(const void *, const void *)) //以key为搜索关键词,compare为节点数据比较机制,由用户自己编写{ struct node *n; n = list->head; while(n){ if(!compare(n->data, key)){ //找到了,返回找到的数据 return n->data; } n = n->next; } return NULL; //找不到,返回NULL} 链表的排序
排序思想:新建一个链表tmp,然后依次取出原链表list中的最小节点,以头插法或者尾插法的机制插入到tmp链表中,直到原链表list为空。然后再把list指向tmp,此时list即为排序好的链表。当然也可以采用选择排序、冒泡排序等其它方式实现。
static struct node * find_min_node(List *list, int (*compare)(const void *, const void *)) //找最小节点,链表排序用;以compare为比较机制,由用户自己编写{ struct node *min, *n; n = list->head; min = list->head; while(n) { if(compare(min->data, n->data) > 0) { min = n; } n = n->next; } return min;}static void delete_node(List *list, struct node *key) //以节点数据key为关键词,删除匹配的节点,链表排序用;{ struct node *n; n = list->head; if(n == key){ list->head = n->next; return; } while(n->next){ if(n->next == key){ if(key == list->tail){ list->tail = n; } n->next = n->next->next; return; } n = n->next; }}static void insert_node(List *list, struct node *key)//以节点数据key为关键词,插入匹配的节点,链表排序用;{ if(list->head == NULL){ list->head = key; list->tail = key; }else{ list->tail->next = key; list->tail = key; }}void list_sort(List *list, int (*compare)(void *, void *)){ List tmp; struct node *n; list_init(&tmp); while(! is_empty(list)) { n = find_min_node(list, compare); delete_node(list, n); n->next = NULL; insert_node(&tmp, n); } list->head = tmp.head; list->tail = tmp.tail;} 链表逆序
如下图所示:
基本思想:遍历一遍链表,依次处理每个节点的next指针指向;遍历完一遍链表,链表的顺序就倒置过来了。见下列程序实现:
void list_reverse(List *list){ struct node *pre = NULL, *next, *p = list->head; list->tail = list->head; //tail指向head;第一次head到tail的倒置。 while(p){ next = p->next; if(!next){ //当p->next为最后一个节点时,让head指向p->next;最后一次tail到head的倒置。 list->head = p; } //备份当前节点为pre,作为其下一个节点的next(第一个节点为NULL,初始化时已定义);中间部分节点的倒置。 p->next = pre; pre = p; p = next; }} 求链表长度
由于链表结构中添加了len属性,因此获取链表长度,直接读取len即可。如果链表结构中不实用len属性,则需要遍历一遍链表,统计循环次数。
程序实现:
long get_lenth(List *list){ return (list->len);} 获取链表某节点的数据
遍历链表到第idx个节点,将该节点处的数据返回给用户即可。
程序实现:
void *list_get_element(List *list, int idx){ int i = 0; struct node *n; n = list->head; while(n && i next; } if(n){ return n->data; } return NULL;} 链表的注销
使用完链表之后,需要销毁链表来释放资源;秉着谁的数据谁负责的原则,需要传递一个函数指针到list_destroy中,用于销毁节点的数据;
void list_destroy(List *list, void (*destroy)(void *)) //destroy为销毁链表时对节点数据的处理函数,由用户自己编写。传递NULL时表示不做处理{ list->len = 0; struct node *n, *tmp; n = list->head; while(n){ tmp = n->next; //tmp只起一个记录n->next的功能,否则后面把n free掉之后,就找不到n->next了。 if(destroy){ //传递用户自定义的数据处理函数,为0时不执行 destroy(n->data); //使用用户提供的destroy函数来释放用户的数据。 } free(n); n = tmp; //把n free掉之后,再把tmp给n,相当于把n->next给n,如此循环遍历链表,挨个删除。 }} 测试程序
简单的接口测试函数:
#include #include "list.h"typedef struct test{ int val1; float val2;}test_t;void handle(void *data){ test_t *test = (test_t *)data; printf("val1:%d, val2:%f\n", test->val1, test->val2);}int compare_int(const void *s1, const void *s2){ test_t *data1 = (test_t *)s1; int *data2 =(int *)s2; return (data1->val1 - *data2);}int compare_int_sort(const void *s1, const void *s2){ test_t *data1 = (test_t *)s1; test_t *data2 = (test_t *)s2; return (data1->val1 - data2->val1);}void print(List *list){ printf("list len = %ld\n", list_get_lenth(list)); if(!is_empty(list)){ //test list_reverse list_traverse(list, handle); } else{ printf("\tthe list is empty\n"); }}int main(int argc, char *argv[]){ List list; list_init(&list); test_t test1 = {10, 10.5}; test_t test2 = {20, 20.5}; test_t test3 = {30, 30.5}; test_t test4 = {40, 40.5}; test_t test5 = {50, 50.5}; //test list_insert printf("------insert(_at_tail)----\n"); list_insert(&list, &test1); list_insert(&list, &test2); list_insert(&list, &test3); print(&list); //test list_delete printf("------delete----\n"); list_delete(&list, &test1.val1, compare_int); print(&list); //test list_insert_at_head printf("------insert_at_head----\n"); list_insert_at_head(&list, &test4); print(&list); //test list_insert_at_index printf("------insert_at_index(2)----\n"); list_insert_at_index(&list, &test5, 2); print(&list); //test list_reverse printf("------reverse----\n"); list_reverse(&list); print(&list); //test list_search int key = 20; test_t *ret; printf("------search----\n"); ret = list_search(&list, &key, compare_int); printf("%d:%f\n", ret->val1, ret->val2); key = 50; ret = list_search(&list, &key, compare_int); printf("%d:%f\n", ret->val1, ret->val2); //test list_get_element printf("------list_get_element----\n"); ret = list_get_element(&list, 2); printf("%d:%f\n", ret->val1, ret->val2); ret = list_get_element(&list, 3); printf("%d:%f\n", ret->val1, ret->val2); //test list_sort printf("-----sort----\n"); list_sort(&list, compare_int_sort); print(&list); //test list_destroy printf("-----destroy----\n"); list_destroy(&list, NULL); return 0;} 输出结果如下所示:
------insert(_at_tail)----list len = 3val1:10, val2:10.500000val1:20, val2:20.500000val1:30, val2:30.500000------delete----list len = 2val1:20, val2:20.500000val1:30, val2:30.500000------insert_at_head----list len = 3val1:40, val2:40.500000val1:20, val2:20.500000val1:30, val2:30.500000------insert_at_index(2)----list len = 4val1:40, val2:40.500000val1:20, val2:20.500000val1:50, val2:50.500000val1:30, val2:30.500000------reverse----list len = 4val1:30, val2:30.500000val1:50, val2:50.500000val1:20, val2:20.500000val1:40, val2:40.500000------search----20:20.50000050:50.500000------list_get_element----50:50.50000020:20.500000-----sort----list len = 4val1:20, val2:20.500000val1:30, val2:30.500000val1:40, val2:40.500000val1:50, val2:50.500000-----destroy----
源码下载
链表实现(list.h、list.c)、测试程序(main.c),makefile(Makefile)源代码分别如下所示:
/***文件名:list.h ***/#ifndef _LIST_H_#define _LIST_H_#ifdef __cplusplusextern "C" {#endif#include typedef struct node{ //节点结构 void *data; struct node *next;}node;typedef struct{ //链表结构 struct node *head; struct node *tail; long len;}List;extern void list_init(List *list);extern bool is_empty(List *list);extern void list_insert(List *list, void *data); //默认采用尾插法extern void list_insert_at_head(List *list, void *data); //头插法extern void list_insert_at_tail(List *list, void *data); //尾插法extern void list_insert_at_index(List *list, void *data, long idx);//定插法extern void *list_delete(List *list, void *key, int (*compare)(const void *, const void *));extern void *list_search(List *list, void *key, int (*compare)(const void *, const void *));extern void list_sort(List *list, int (*compare)(const void *, const void *));extern void list_traverse(List *list, void (*handle)(void *));extern void list_reverse(List *list);extern long list_get_lenth(List *list);extern void *list_get_element(List *list, int idx);extern void list_destroy(List *list, void (*destroy)(void *data));#endif#ifdef __cplusplus}#endif /***文件名:list.c ***/#include #include #include #include "list.h"void list_init(List *list){ list->head = NULL; list->tail = NULL; list->len = 0;}bool is_empty(List *list){ return (list->head == NULL);}static struct node *make_node(void *data) //把用户传递过来的数据打包为一个链表节点{ struct node *n; n = malloc(sizeof(struct node)); assert(n != NULL); n->next = NULL; n->data = data; return n;}void list_insert_at_head(List *list, void *data) //头插法{ struct node *n; n = make_node(data); if(list->head == NULL){ //如果是空链表 list->head = n; list->tail = n; } else{ //如果不是非空链表 n->next = list->head; list->head = n; } list->len++;}void list_insert_at_index(List *list, void *data, long index) //定插法{ long i = 1; //从1开始算 struct node *p, *n; p = list->head; while(p && i next; i++; } if(p){ //如果链表遍历完了,计数i还没到index,说明第index个节点不存在。 n = make_node(data); n->next = p->next; p->next = n; list->len++; }}void list_insert_at_tail(List *list, void *data) //尾插法{ struct node *n; n = make_node(data); if(is_empty(list)){ //如果是空链表 list->head = n; list->tail = n; } else{ //如果不是非空链表 list->tail->next = n; list->tail = n; } list->len++;}/*void list_insert(List *list, void *data) //默认采用尾插法{#if 0 list_insert_at_tail(list, data);#else struct node *n; n = make_node(data); if(list->head == NULL){ list->head = n; list->tail = n; } else { list->tail->next = n; list->tail = n; } list->len++;#endif}*/void list_insert(List *list, void *data){ struct node *n; n = make_node(data); if(list->head == NULL){ list->head = n; list->tail = n; } else { list->tail->next = n; list->tail = n; } list->len++;}void * list_delete(List *list, void *key, int (*compare)(const void *, const void *)){ void *data; struct node *n, *t; n = list->head; if(!compare(n->data, key)){ //如果要删除的节点为首节点 t = n; data = n->data; list->head = n->next; free(t); list->len--; return data; } while(n->next != NULL){ //遍历查找符合条件的节点,删除之 if(compare(n->next->data, key) == 0){ //只删除第一个符合条件的节点。 t = n->next; if(n->next == list->tail){ list->tail = n; } n->next = n->next->next; data = t->data; free(t); list->len--; return data; //把删除的数据返回给用户,供用户后续的处理使用。 } n = n->next; } return NULL; //没找到匹配的节点,返回NULL}void *list_search(List *list, void *key, int (*compare)(const void *, const void *)){ struct node *n; n = list->head; while(n){ if(!compare(n->data, key)){ //找到了,返回找到的数据 return n->data; } n = n->next; } return NULL; //找不到,返回NULL}static struct node *find_min_node(List *list, int (*compare)(const void *, const void *)){ struct node *min, *n; n = list->head; min = list->head; while(n){ if(compare(min->data, n->data) > 0){ min = n; } n = n->next; } return min;}static void delete_node(List *list, struct node *key){ struct node *n; n = list->head; if(n == key){ list->head = n->next; return; } while(n->next){ if(n->next == key){ if(key == list->tail){ list->tail = n; } n->next = n->next->next; return; } n = n->next; }}static void insert_node(List *list, struct node *key){ if(list->head == NULL){ list->head = key; list->tail = key; }else{ list->tail->next = key; list->tail = key; }}void list_sort(List *list, int (*compare)(const void *, const void *)){ List tmp; struct node *n; list_init(&tmp); while(! is_empty(list)){ n = find_min_node(list, compare); delete_node(list, n); n->next = NULL; insert_node(&tmp, n); } list->head = tmp.head; list->tail = tmp.tail;}void list_traverse(List *list, void (*handle)(void *)){ struct node *p; p = list->head; while(p){ handle(p->data); p = p->next; }}void list_reverse(List *list){ struct node *pre = NULL, *next, *p = list->head; list->tail = list->head; //tail指向head; while(p){ next = p->next; if(!next){ //当p->next为最后一个节点时,让head指向p->next list->head = p; } //记录当前节点为pre,作为下一个节点的next.第一个节点为NULL,初始化时已定义。 p->next = pre; pre = p; p = next; }}long list_get_lenth(List *list){ return (list->len);}void *list_get_element(List *list, int idx){ int i = 1; struct node *n; n = list->head; while(n && i next; } if(n){ return n->data; } return NULL;}void list_destroy(List *list, void (*destroy)(void *)){ list->len = 0; struct node *n, *t; n = list->head; while(n){ t = n->next; //t只起一个记录n->next的功能,否则后面把n free掉之后,就找不到n->next了。 if(destroy){ //传递用户自定义的数据处理函数,为0时不执行 destroy(n->data); //使用用户提供的destroy函数来释放用户传递过来的数据。 } free(n); n = t; //把n free掉之后,再把t给n,相当于把n->next给n,如此循环遍历链表,挨个删除, }} /***文件名(测试程序源码):main.c***/#include #include "list.h"typedef struct test{ int val1; float val2;}test_t;void handle(void *data){ test_t *test = (test_t *)data; printf("val1:%d, val2:%f\n", test->val1, test->val2);}int compare_int(const void *s1, const void *s2){ test_t *data1 = (test_t *)s1; int *data2 =(int *)s2; return (data1->val1 - *data2);}int compare_int_sort(const void *s1, const void *s2){ test_t *data1 = (test_t *)s1; test_t *data2 = (test_t *)s2; return (data1->val1 - data2->val1);}void print(List *list){ printf("list len = %ld\n", list_get_lenth(list)); if(!is_empty(list)){ //test list_reverse list_traverse(list, handle); } else{ printf("\tthe list is empty\n"); }}int main(void){ List list; list_init(&list); test_t test1 = {10, 10.5};test_t test2 = {20, 20.5};test_t test3 = {30, 30.5};test_t test4 = {40, 40.5};test_t test5 = {50, 50.5}; //test list_insert printf("------insert(_at_tail)----\n"); list_insert(&list, &test1); list_insert(&list, &test2); list_insert(&list, &test3); print(&list); //test list_delete printf("------delete----\n"); list_delete(&list, &test1.val1, compare_int); print(&list); //test list_insert_at_head printf("------insert_at_head----\n"); list_insert_at_head(&list, &test4); print(&list); //test list_insert_at_index printf("------insert_at_index(2)----\n"); list_insert_at_index(&list, &test5, 2); print(&list); //test list_reverse printf("------reverse----\n"); list_reverse(&list); print(&list); //test list_search int key = 20; test_t *ret; printf("------search----\n"); ret = list_search(&list, &key, compare_int); printf("%d:%f\n", ret->val1, ret->val2); key = 50; ret = list_search(&list, &key, compare_int); printf("%d:%f\n", ret->val1, ret->val2); //test list_get_element printf("------list_get_element----\n"); ret = list_get_element(&list, 2); printf("%d:%f\n", ret->val1, ret->val2); ret = list_get_element(&list, 3); printf("%d:%f\n", ret->val1, ret->val2); //test list_sort printf("-----sort----\n"); list_sort(&list, compare_int_sort); print(&list); //test list_destroy printf("-----destroy----\n"); list_destroy(&list, NULL); return 0;} # 文件名:Makefileall:gcc main.c list.c -o app -Wall -gclean:-rm -f appcheck:valgrind --tool=memcheck ./app.PHONY: all clean
后记
通过valgrind这个工具可以检测内存泄漏,ubuntu下安装命令:
$ sudo apt-get install valgrind
使用方法:
valgrind --tool=memcheck ./app
示例程序的检查结果如下所示:
$ valgrind --tool=memcheck ./app==4298== Memcheck, a memory error detector==4298== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.==4298== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info==4298== Command: ./app==4298== ............==4298== ==4298== HEAP SUMMARY:==4298== in use at exit: 0 bytes in 0 blocks==4298== total heap usage: 5 allocs, 5 frees, 40 bytes allocated==4298== ==4298== All heap blocks were freed -- no leaks are possible==4298==
通过valgrind的检测,我们发现,程序退出时,仍有0个内存块上的0字节未释放,即程序所申请的内存已经全部释放;堆内存一共申请了5次,释放了5次,共申请了40个字节;所有堆内存都释放了,没有内存泄漏。推荐你也使用一下,与之功能相同的软件有很多,不再一一赘述。
上一篇:抖音外卖服务器怎么运营?
下一篇:服务器扩容提示文案怎么写?