21ic电子技术开发论坛 › 单片机与嵌入式系统 › 芯源CW32 MCU › C语言的内存池使用
返回列表 发新帖我要提问

[技术手册] C语言的内存池使用

[复制链接]
1206|7
 楼主| jf101 发表于 2024-4-7 16:25 | 显示全部楼层 |阅读模式
内存管理, 应用层, 函数, C语言, 内存


C语言的内存管理，从来都是一个让人头秃的问题。要想更自由地管理内存，就必须去堆中申请，然后还需要考虑何时释放，万一释放不当，或者没有及时释放，造成的后果都是难以估量的。

当然如果就这些，那倒也还不算什么。问题就在于，如果大量地使用malloc和free函数来申请内存，首先使要经历一个从应用层切入系统内核层，调用完成之后，再返回应用层的一系列步骤，实际上使非常浪费时间的。更重要的是，还会产生大量的内存碎片。比如，先申请了一个1KB的空间，紧接着又申请了一个8KB的空间。而后，这个1KB使用完了，被释放，但是这个空间却只有等到下一次有刚好1KB的空间申请，才能够被重新调用。这么一来，极限情况下，整个堆有可能被弄得支离破碎，最终导致大量内存浪费。

那么这种情况下，我们解决这类问题的思路，就是创建一个内存池。

内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。同样的道理，下一次程序申请空间的时候，先检查下内存池里面有没有合适的内存，如果有，则直接拿出来调用，如果没有，那么再使用malloc。

其实内存池我们就可以使用单链表来进行维护，下面通过一个通讯录的程序来说明内存池的运用。

普通的版本：

复制
  1. //Example 04 V1
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    

  4. #include <string.h>
    


  5. 

  6. struct Person
    

  7. {
    

  8.  char name[40];
    

  9.  char phone[20];
    

  10.  struct Person* next;
    

  11. };
    


  12. 

  13. void getInput(struct Person* person);
    

  14. void printPerson(struct Person* person);
    

  15. void addPerson(struct Person** contects);
    

  16. void changePerson(struct Person* contacts);
    

  17. void delPerson(struct Person** contacts);
    

  18. struct Person* findPerson(struct Person* contacts);
    

  19. void displayContacts(struct Person* contacts);
    

  20. void releaseContacts(struct Person** contacts);
    


  21. 

  22. void getInput(struct Person* person)
    

  23. {
    

  24.  printf("请输入姓名：");
    

  25.  scanf("%s", person->name);
    

  26.  printf("请输入电话：");
    

  27.  scanf("%s", person->phone);
    

  28. }
    


  29. 

  30. void addPerson(struct Person** contacts)
    

  31. {
    

  32.  struct Person* person;
    

  33.  struct Person* temp;
    


  34. 

  35.  person = (struct Person*)malloc(sizeof(struct Person));
    

  36.  if (person == NULL)
    

  37.  {
    

  38.   printf("内存分配失败！\n");
    

  39.   exit(1);
    

  40.  }
    


  41. 

  42.  getInput(person);
    


  43. 

  44.  //将person添加到通讯录中
    

  45.  if (*contacts != NULL)
    

  46.  {
    

  47.   temp = *contacts;
    

  48.   *contacts = person;
    

  49.   person->next = temp;
    

  50.  }
    

  51.  else
    

  52.  {
    

  53.   *contacts = person;
    

  54.   person->next = NULL;
    

  55.  }
    

  56. }
    


  57. 

  58. void printPerson(struct Person* person)
    

  59. {
    

  60.  printf("联系人：%s\n", person->name);
    

  61.  printf("电话：%s\n", person->phone);
    

  62. }
    


  63. 

  64. struct Person* findPerson(struct Person* contacts)
    

  65. {
    

  66.  struct Person* current;
    

  67.  char input[40];
    


  68. 

  69.  printf("请输入联系人：");
    

  70.  scanf("%s", input);
    


  71. 

  72.  current = contacts;
    

  73.  while (current != NULL && strcmp(current->name, input))
    

  74.  {
    

  75.   current = current->next;
    

  76.  }
    


  77. 

  78.  return current;
    

  79. }
    


  80. 

  81. void changePerson(struct Person* contacts)
    

  82. {
    

  83.  struct Person* person;
    


  84. 

  85.  person = findPerson(contacts);
    

  86.  if (person == NULL)
    

  87.  {
    

  88.   printf("找不到联系人！\n");
    

  89.  }
    

  90.  else
    

  91.  {
    

  92.   printf("请输入联系电话：");
    

  93.   scanf("%s", person->phone);
    

  94.  }
    

  95. }
    


  96. 

  97. void delPerson(struct Person** contacts)
    

  98. {
    

  99.  struct Person* person;
    

  100.  struct Person* current;
    

  101.  struct Person* previous;
    


  102. 

  103.  //先找到待删除的节点的指针
    

  104.  person = findPerson(*contacts);
    

  105.  if (person == NULL)
    

  106.  {
    

  107.   printf("找不到该联系人！\n");
    

  108.  }
    

  109.  else
    

  110.  {
    

  111.   current = *contacts;
    

  112.   previous = NULL;
    


  113. 

  114.   //将current定位到待删除的节点
    

  115.   while (current != NULL && current != person)
    

  116.   {
    

  117.    previous = current;
    

  118.    current = current->next;
    

  119.   }
    


  120. 

  121.   if (previous == NULL)
    

  122.   {
    

  123.    //若待删除的是第一个节点
    

  124.    *contacts = current->next;
    

  125.   }
    

  126.   else
    

  127.   {
    

  128.    //若待删除的不是第一个节点
    

  129.    previous->next = current->next;
    

  130.   }
    


  131. 

  132.   free(person);//将内存空间释放
    

  133.  }
    

  134. }
    


  135. 

  136. void displayContacts(struct Person* contacts)
    

  137. {
    

  138.  struct Person* current;
    


  139. 

  140.  current = contacts;
    

  141.  while (current != NULL)
    

  142.  {
    

  143.   printPerson(current);
    

  144.   current = current->next;
    

  145.  }
    

  146. }
    


  147. 

  148. void releaseContacts(struct Person** contacts)
    

  149. {
    

  150.  struct Person* temp;
    


  151. 

  152.  while (*contacts != NULL)
    

  153.  {
    

  154.   temp = *contacts;
    

  155.   *contacts = (*contacts)->next;
    

  156.   free(temp);
    

  157.  }
    

  158. }
    


  159. 

  160. int main(void)
    

  161. {
    

  162.  int code;
    

  163.  struct Person* contacts = NULL;
    

  164.  struct Person* person;
    


  165. 

  166.  printf("| 欢迎使用通讯录管理程序 |\n");
    

  167.  printf("|--- 1:插入新的联系人 ---|\n");
    

  168.  printf("|--- 2:查找现有联系人 ---|\n");
    

  169.  printf("|--- 3:更改现有联系人 ---|\n");
    

  170.  printf("|--- 4:删除现有联系人 ---|\n");
    

  171.  printf("|--- 5:显示当前通讯录 ---|\n");
    

  172.  printf("|--- 6:退出通讯录程序 ---|\n");
    


  173. 

  174.  while (1)
    

  175.  {
    

  176.   printf("\n请输入指令代码：");
    

  177.   scanf("%d", &code);
    

  178.   switch (code)
    

  179.   {
    

  180.   case 1:addPerson(&contacts); break;
    

  181.   case 2:person = findPerson(contacts);
    

  182.    if (person == NULL)
    

  183.    {
    

  184.     printf("找不到该联系人！\n");
    

  185.    }
    

  186.    else
    

  187.    {
    

  188.     printPerson(person);
    

  189.    }
    

  190.    break;
    

  191.   case 3:changePerson(contacts); break;
    

  192.   case 4:delPerson(&contacts); break;
    

  193.   case 5:displayContacts(contacts); break;
    

  194.   case 6:goto END;
    

  195.   }
    

  196.  }
    


  197. 

  198. END://此处直接跳出恒循环
    

  199.  releaseContacts(&contacts);
    


  200. 

  201.  return 0;
    


  202. 

  203. }

运行结果如下：

复制
  1. //Consequence 04 V1
    

  2. | 欢迎使用通讯录管理程序 |
    

  3. |--- 1:插入新的联系人 ---|
    

  4. |--- 2:查找现有联系人 ---|
    

  5. |--- 3:更改现有联系人 ---|
    

  6. |--- 4:删除现有联系人 ---|
    

  7. |--- 5:显示当前通讯录 ---|
    

  8. |--- 6:退出通讯录程序 ---|
    


  9. 

  10. 请输入指令代码：1
    

  11. 请输入姓名：HarrisWilde
    

  12. 请输入电话：0101111
    


  13. 

  14. 请输入指令代码：1
    

  15. 请输入姓名：Jack
    

  16. 请输入电话：0101112
    


  17. 

  18. 请输入指令代码：1
    

  19. 请输入姓名：Rose
    

  20. 请输入电话：0101113
    


  21. 

  22. 请输入指令代码：2
    

  23. 请输入联系人：HarrisWilde
    

  24. 联系人：HarrisWilde
    

  25. 电话：0101111
    


  26. 

  27. 请输入指令代码：2
    

  28. 请输入联系人：Mike
    

  29. 找不到该联系人！
    


  30. 

  31. 请输入指令代码：5
    

  32. 联系人：Rose
    

  33. 电话：0101113
    

  34. 联系人：Jack
    

  35. 电话：0101112
    

  36. 联系人：HarrisWilde
    

  37. 电话：0101111
    


  38. 

  39. 请输入指令代码：3
    

  40. 请输入联系人：HarrisWilde
    

  41. 请输入联系电话：0101234
    


  42. 

  43. 请输入指令代码：5
    

  44. 联系人：Rose
    

  45. 电话：0101113
    

  46. 联系人：Jack
    

  47. 电话：0101112
    

  48. 联系人：HarrisWilde
    

  49. 电话：0101234
    


  50. 

  51. 请输入指令代码：6

下面加入内存池：

复制
  1. //Example 04 V2
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    

  4. #include <string.h>
    


  5. 

  6. #define MAX 1024
    


  7. 

  8. struct Person
    

  9. {
    

  10.  char name[40];
    

  11.  char phone[20];
    

  12.  struct Person* next;
    

  13. };
    


  14. 

  15. struct Person* pool = NULL;
    

  16. int count;
    


  17. 

  18. void getInput(struct Person* person);
    

  19. void printPerson(struct Person* person);
    

  20. void addPerson(struct Person** contects);
    

  21. void changePerson(struct Person* contacts);
    

  22. void delPerson(struct Person** contacts);
    

  23. struct Person* findPerson(struct Person* contacts);
    

  24. void displayContacts(struct Person* contacts);
    

  25. void releaseContacts(struct Person** contacts);
    

  26. void releasePool(void);
    


  27. 

  28. void getInput(struct Person* person)
    

  29. {
    

  30.  printf("请输入姓名：");
    

  31.  scanf("%s", person->name);
    

  32.  printf("请输入电话：");
    

  33.  scanf("%s", person->phone);
    

  34. }
    


  35. 

  36. void addPerson(struct Person** contacts)
    

  37. {
    

  38.  struct Person* person;
    

  39.  struct Person* temp;
    


  40. 

  41.  //如果内存池不是空的，那么首先从里面获取空间
    

  42.  if (pool != NULL)
    

  43.  {
    

  44.   person = pool;
    

  45.   pool = pool->next;
    

  46.   count--;
    

  47.  }
    

  48.  //内存池为空，则直接申请
    

  49.  else
    

  50.  {
    

  51.   person = (struct Person*)malloc(sizeof(struct Person));
    

  52.   if (person == NULL)
    

  53.   {
    

  54.    printf("内存分配失败！\n");
    

  55.    exit(1);
    

  56.   }
    

  57.  }
    


  58. 


  59. 

  60.  getInput(person);
    


  61. 

  62.  //将person添加到通讯录中
    

  63.  if (*contacts != NULL)
    

  64.  {
    

  65.   temp = *contacts;
    

  66.   *contacts = person;
    

  67.   person->next = temp;
    

  68.  }
    

  69.  else
    

  70.  {
    

  71.   *contacts = person;
    

  72.   person->next = NULL;
    

  73.  }
    

  74. }
    


  75. 

  76. void printPerson(struct Person* person)
    

  77. {
    

  78.  printf("联系人：%s\n", person->name);
    

  79.  printf("电话：%s\n", person->phone);
    

  80. }
    


  81. 

  82. struct Person* findPerson(struct Person* contacts)
    

  83. {
    

  84.  struct Person* current;
    

  85.  char input[40];
    


  86. 

  87.  printf("请输入联系人：");
    

  88.  scanf("%s", input);
    


  89. 

  90.  current = contacts;
    

  91.  while (current != NULL && strcmp(current->name, input))
    

  92.  {
    

  93.   current = current->next;
    

  94.  }
    


  95. 

  96.  return current;
    

  97. }
    


  98. 

  99. void changePerson(struct Person* contacts)
    

  100. {
    

  101.  struct Person* person;
    


  102. 

  103.  person = findPerson(contacts);
    

  104.  if (person == NULL)
    

  105.  {
    

  106.   printf("找不到联系人！\n");
    

  107.  }
    

  108.  else
    

  109.  {
    

  110.   printf("请输入联系电话：");
    

  111.   scanf("%s", person->phone);
    

  112.  }
    

  113. }
    


  114. 

  115. void delPerson(struct Person** contacts)
    

  116. {
    

  117.  struct Person* person;
    

  118.  struct Person* current;
    

  119.  struct Person* previous;
    

  120.  struct Person* temp;
    

  121.  {
    


  122. 

  123.  };
    


  124. 

  125.  //先找到待删除的节点的指针
    

  126.  person = findPerson(*contacts);
    

  127.  if (person == NULL)
    

  128.  {
    

  129.   printf("找不到该联系人！\n");
    

  130.  }
    

  131.  else
    

  132.  {
    

  133.   current = *contacts;
    

  134.   previous = NULL;
    


  135. 

  136.   //将current定位到待删除的节点
    

  137.   while (current != NULL && current != person)
    

  138.   {
    

  139.    previous = current;
    

  140.    current = current->next;
    

  141.   }
    


  142. 

  143.   if (previous == NULL)
    

  144.   {
    

  145.    //若待删除的是第一个节点
    

  146.    *contacts = current->next;
    

  147.   }
    

  148.   else
    

  149.   {
    

  150.    //若待删除的不是第一个节点
    

  151.    previous->next = current->next;
    

  152.   }
    


  153. 

  154.   //判断内存池中有没有空位
    

  155.   if (count < MAX)
    

  156.   {
    

  157.    //使用头插法将person指向的空间插入内存池中
    

  158.    if (pool != NULL)
    

  159.    {
    

  160.     temp = pool;
    

  161.     pool = person;
    

  162.     person->next = temp;
    

  163.    }
    

  164.    else
    

  165.    {
    

  166.     pool = person;
    

  167.     person->next = NULL;
    

  168.    }
    

  169.    count++;
    

  170.   }
    

  171.   //没有空位，直接释放
    

  172.   else
    

  173.   {
    

  174.    free(person);//将内存空间释放
    

  175.   }
    

  176.  }
    

  177. }
    


  178. 

  179. void displayContacts(struct Person* contacts)
    

  180. {
    

  181.  struct Person* current;
    


  182. 

  183.  current = contacts;
    

  184.  while (current != NULL)
    

  185.  {
    

  186.   printPerson(current);
    

  187.   current = current->next;
    

  188.  }
    

  189. }
    


  190. 

  191. void releaseContacts(struct Person** contacts)
    

  192. {
    

  193.  struct Person* temp;
    


  194. 

  195.  while (*contacts != NULL)
    

  196.  {
    

  197.   temp = *contacts;
    

  198.   *contacts = (*contacts)->next;
    

  199.   free(temp);
    

  200.  }
    

  201. }
    


  202. 

  203. void releasePool(void)
    

  204. {
    

  205.  struct Person* temp;
    

  206.  while (pool != NULL)
    

  207.  {
    

  208.   temp = pool;
    

  209.   pool = pool->next;
    

  210.   free(temp);
    

  211.  }
    

  212. }
    


  213. 

  214. int main(void)
    

  215. {
    

  216.  int code;
    

  217.  struct Person* contacts = NULL;
    

  218.  struct Person* person;
    


  219. 

  220.  printf("| 欢迎使用通讯录管理程序 |\n");
    

  221.  printf("|--- 1:插入新的联系人 ---|\n");
    

  222.  printf("|--- 2:查找现有联系人 ---|\n");
    

  223.  printf("|--- 3:更改现有联系人 ---|\n");
    

  224.  printf("|--- 4:删除现有联系人 ---|\n");
    

  225.  printf("|--- 5:显示当前通讯录 ---|\n");
    

  226.  printf("|--- 6:退出通讯录程序 ---|\n");
    


  227. 

  228.  while (1)
    

  229.  {
    

  230.   printf("\n请输入指令代码：");
    

  231.   scanf("%d", &code);
    

  232.   switch (code)
    

  233.   {
    

  234.   case 1:addPerson(&contacts); break;
    

  235.   case 2:person = findPerson(contacts);
    

  236.    if (person == NULL)
    

  237.    {
    

  238.     printf("找不到该联系人！\n");
    

  239.    }
    

  240.    else
    

  241.    {
    

  242.     printPerson(person);
    

  243.    }
    

  244.    break;
    

  245.   case 3:changePerson(contacts); break;
    

  246.   case 4:delPerson(&contacts); break;
    

  247.   case 5:displayContacts(contacts); break;
    

  248.   case 6:goto END;
    

  249.   }
    

  250.  }
    


  251. 

  252. END://此处直接跳出恒循环
    

  253.  releaseContacts(&contacts);
    

  254.  releasePool();
    


  255. 

  256.  return 0;
    


  257. 

  258. }
回复

收藏 举报

相关帖子
中国龙芯CDX 发表于 2024-4-10 10:51 | 显示全部楼层
楼主这个管理系统项目很不错，深入了解一下
回复

收藏 举报

szt1993 发表于 2024-4-10 11:25 | 显示全部楼层
内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。
回复

收藏 举报

小夏天的大西瓜 发表于 2024-4-11 17:25 | 显示全部楼层
确实申请和释放内存对于整体的程序设计非常重要
回复

收藏 举报

 楼主| jf101 发表于 2024-4-14 14:25 | 显示全部楼层
内存池使用单链表来进行维护，非常实用
回复

收藏 举报

小小蚂蚁举千斤 发表于 2024-4-15 10:04 | 显示全部楼层
自由地管理内存就必须去堆中申请，然后还需要考虑何时释放
回复

收藏 举报

OKAKAKO 发表于 2024-4-19 18:41 | 显示全部楼层
内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。
回复

收藏 举报

星辰大海不退缩 发表于 2024-4-21 12:29 | 显示全部楼层
这个管理系统项目适合新学习C语言的新手
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

jf101

262

主题

1929

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部