devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言进阶⑰(动态内存管理)四个动态内存函数+动态通讯录+柔性数组_malloc+free_简述动态内存分配的四个函数的用法c语言

作者：Cpp五条 | 2024-06-04 05:01:05

赞

踩

简述动态内存分配的四个函数的用法c语言

1. 为什么存在动态内存分配

我们已经掌握的内存开辟方式有：

  1.  
  2. int val = 20;//在栈空间上开辟四个字节
  3. char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的方式有两个特点：

1. 空间开辟大小是固定的。

2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。

有时候我们需要的空间大小在程序运行的时候才能知道，

那数组的编译时开辟空间的方式就不能满足了。

这时候就只能试试动态存分配了。

所谓动态内存分配(Dynamic Memory Allocation) 就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。

2. 动态内存函数的介绍

以下四个动态内存函数头文件都是：stdlib.h

2.1 malloc和free

C语言提供了一个动态内存开辟的函数：void* malloc (size_t size);

size是要开辟的总字节数

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

① 如果开辟成功，则返回一个指向开辟好空间的指针。

② 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

③ 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，

具体在使用的时候使用者自己决定。（所以接收时要强制转换）

④ 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

(有的笔试题：malloc(0)是允许的，也会返回一个指针，只是没有空间所以不可使用而已。)

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

free函数用来释放动态开辟的内存。

① 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

② 如果参数 ptr 是NULL指针，则函数什么事都不做。

注意事项：

① 使用完动态开辟的内存之后一定要记得使用 free 函数释放所开辟的内存空间。

② 使用指针指向动态开辟的内存，使用完并 free 之后一定要记得将其置为空指针。

举个例子：

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int main(void)
  5. {
  6.     // 假设开辟10个整型空间
  7.     int arr[10]; // 在栈区上开辟
  8.     // 动态内存开辟
  9.     int* p = (int*)malloc(10 * sizeof(int)); // 开辟10个大小为int（40字节）的空间
  10.     // 使用这些空间的时候
  11.     if (p == NULL) 
  12.     {
  13.         perror("main"); // main: 错误信息
  14.         return 0;
  15.     }
  16.     // 使用
  17.     int i = 0;
  18.     for (i = 0; i < 10; i++) 
  19.     {
  20.         *(p + i) = i;// p[i]=i;也行
  21.     }
  22.     for (i = 0; i < 10; i++) 
  23.     {
  24.         printf("%d ", p[i]);
  25.     }
  26.     // 回收空间
  27.     free(p);
  28.     p = NULL; // 需要手动置为空指针
  29.     return 0;
  30. }

为什么 free 之后，一定要把 p 置为空指针？

解析：因为 free 之后那块开辟的内存空间已经不在了，

free的功能只是把开辟的空间回收掉，但是 p 仍然还指向那块内存空间的起始位置，

这时p就是一个野指针。所以我们需要使用 p = NULL ;手动把他置成空指针。

为什么 malloc 前面要进行强制类型转换呢？

int* p = (int*)malloc(10*sizeof(int));

解析：为了和 int* p 类型相呼应，所以要进行强制类型转换。你可以试着把强转删掉，

其实也不会有什么问题。但是因为有些编译器要求强转，所以最好进行一下强转，避免不必要的麻烦。

2.2 calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

calloc 函数的功能实为 num 个大小为 size 的元素开辟一块空间，并把空间的每个字节初始化为 0 ，和malloc一样：

① 如果开辟成功，则返回一个指向开辟好空间的指针。

② 如果开辟失败，则返回一个NULL指针，因此calloc的返回值也要做检查。

③ 返回值的类型是 void* ，所以calloc函数并不知道开辟空间的类型，

具体在使用的时候使用者自己决定。（所以接收时要强制转换）

④ 如果参数 size 为0，calloc的行为是标准是未定义的，取决于编译器。

（这里的size是一个num的字节）

和malloc的区别：

① malloc 只有一个参数，而 calloc 有两个参数，分别为元素的个数和元素的大小。

② 与函数 malloc 的区别在于 calloc 会在返回地址前把申请的空间的每个字节初始化为 0 。

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. int main()
  6. {
  7.     // calloc
  8.     int* p = (int*)calloc(10, sizeof(int)); // 开辟10个大小为int的空间，40
  9.     if (p == NULL)
  10.     {
  11.         perror("main");
  12.         return 0;
  13.     }
  14.     int i = 0;
  15.     for (i = 0; i < 10; i++)
  16.     {
  17.      printf("%d ", *(p + i)); //这里打印了十个0，换成malloc开辟的就打印十个一样的随机值
  18.     }
  19.     free(p);
  20.     p = NULL;
  21.     return 0;
  22. }

所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

2.3 realloc

realloc函数的出现让动态内存管理更加灵活。

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，

那为了合理的使用内存，我们一定会对内存的大小做灵活的调整。

那 realloc 函数就可以做到对动态开辟内存大小的调整。

函数原型如下：

void* realloc (void* ptr, size_t size);

① ptr 为指针要调整的内存地址。

② size 为调整之后的新大小。

③ 返回值为调整之后的内存起始位置，请求失败则返回空指针。

④ realloc 函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

(有的笔试题里：realloc函数可以调整动态申请内存的大小，可大可小)

realloc 函数在调整内存空间时存在的三种情况：

情况1：原有空间之后有足够大的空间。

情况2：原有空间之后没有足够大的空间。

情况3：realloc 有可能找不到合适的空间来调整大小。

情况1：当原有空间之后没有足够大的空间时，直接在原有内存之后直接追加空间，

原来空间的数组不发生变化。

情况2：当原有空间之后没有足够大的空间时，会在堆空间上另找一个合适大小的连续的空间来使用。

函数的返回值将是一个新的内存地址。

情况3：如果找不到合适的空间，就会返回一个空指针。

代码演示：realloc 调整内存大小

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int main()
  5. {
  6.     int* p = (int*)calloc(10, sizeof(int));
  7.     if (p == NULL) 
  8.     {
  9.         perror("main");
  10.         return 0;
  11.     }
  12.     for (int i = 0; i < 10; i++)
  13.     {
  14.         *(p + i) = 5;
  15.     }
  16.     // 此时，这里需要p指向的空间更大，需要20个int的空间
  17.     // realloc 调整空间
  18.     //p = (int*)realloc(p, 20 * sizeof(int)); // 调整为20个int的大小的空间
  19.  
  20.     /*刚才提到的第三种情况，如果 realloc 找不到合适的空间，就会返回空指针。
  21.     我们想让它增容，他却存在返回空指针的危险，然后我们就找不到原来的空间了
  22.     解决方案：不要拿指针直接接收 realloc，可以使用临时指针判断一下。*/
  23.     int* tmp = (int*)realloc(p, 20 * sizeof(int));// 调整为20个int的大小的空间
  24.     // 如果ptmp不等于空指针，再把p交付给它
  25.     if (tmp != NULL) 
  26.     {
  27.         p = tmp;
  28.     }
  29.  
  30.     free(p); // 释放
  31.     p = NULL; // 置空
  32. }

有趣的是，其实你可以把 realloc 当 malloc 用：

  1.  
  2. // 在要调整的内存地址部分，传入NULL：
  3. int* p = (int*)realloc(NULL, 40); // 这里功能类似于malloc，就是直接在堆区开辟40个字节

插入练习：把上篇通讯录改成动态的

思考后发现，我们只需要先该存放联系人的结构体，再改初始化通讯录函数和增加联系人函数，其它函数都可以不用动，最后在选0退出程序之前写一个销毁通讯录函数，释放开辟的空间就行了。

以下是基于上篇最后的代码改的：

test.c：

  1.  
  2. //通讯录-静态版本
  3. //1.通讯录中能够存放1000个人的信息
  4. //每个人的信息：
  5. //名字+年龄+性别+电话+地址
  6. //2. 增加人的信息
  7. //3. 删除指定人的信息
  8. //4. 修改指定人的信息
  9. //5. 查找指定人的信息
  10. //6. 排序通讯录的信息
  11. //
  12. //版本2：
  13. //动态增长的版本
  14. //1.通讯录初始化后，能存放3个人的信息
  15. //2.当我们空间的存放满的时候，我们增加2个信息
  16. //3+2+2+2+...
  17. #include"contact.h"
  18.  
  19. void menu()
  20. {
  21.     printf("****************************************\n");
  22.     printf("******     1.add      2.del     ********\n");
  23.     printf("******     3.search   4.modify  ********\n");
  24.     printf("******     5.sort     6.print   ********\n");
  25.     printf("******     0.exit               ********\n");
  26.     printf("****************************************\n");
  27. }
  28. enum option
  29. {
  30.     EXIT,
  31.     ADD,
  32.     DEL,
  33.     SEARCH,
  34.     MODIFY,
  35.     SORT,
  36.     PRINTF
  37. };
  38. int main()
  39. {
  40.     int input = 0;
  41.     //创建通讯录  info(信息)
  42.     contact con;
  43.     //初始化通讯录函数
  44.     init_contact(&con);
  45.     do
  46.     {
  47.         menu();
  48.         printf("请选择：");
  49.         scanf("%d", &input);
  50.         switch (input)
  51.         {
  52.         case ADD:
  53.             add_contact(&con);
  54.             break;
  55.         case DEL:
  56.             del_contact(&con);
  57.             break;
  58.         case SEARCH:
  59.             find_contact(&con);
  60.             break;
  61.         case MODIFY:
  62.             modify_contact(&con);
  63.             break;
  64.         case SORT:
  65.             sort_contact(&con);
  66.             break;
  67.         case PRINTF:
  68.             print_contact(&con);
  69.             break;
  70.         case EXIT:
  71.             destroy_contact(&con);
  72.             printf("退出程序\n");
  73.             break;
  74.         default:
  75.             printf("选择错误，重新选择\n");
  76.             break;
  77.         }
  78.     } while (input);
  79.     return 0;
  80. }

contact.h

  1.  
  2. #include<stdio.h>
  3. #include<string.h>
  4. #include<stdlib.h>//qsort，perror，动态内存开辟函数
  5.  
  6. #define MAX_NAME 20
  7. #define MAX_SEX 10
  8. #define MAX_TELE 20
  9. #define MAX_ADDR 30
  10. #define DEFAULT_SZ 3 //default 默认
  11. #define INC_SZ 2 //sz增量
  12. //类型的定义
  13. typedef struct peoinfo
  14. {
  15.     char name[MAX_NAME];
  16.     char sex[MAX_SEX];
  17.     int age;
  18.     char tele[MAX_TELE];
  19.     char addr[MAX_ADDR];
  20. }peoinfo;
  21.  
  22. 静态版本通讯录
  23. //typedef struct contact
  24. //{
  25. //    peoinfo data[MAX];//存放添加进来的人的信息     
  26. //    int sz;//记录的是当前通讯录中有效信息的个数
  27. //}contact;
  28.  
  29. //动态版本通讯录
  30. typedef struct contact
  31. {
  32.     peoinfo* data;//指向动态开辟的空间，存放添加进来的人的信息
  33.     int sz;//记录的是当前通讯录中有效信息的个数
  34.     int capacity;//记录当前通讯录的最大容量，方便增容
  35. }contact;
  36.  
  37. //初始化通讯录函数
  38. void init_contact(contact* p);
  39.  
  40. //增加联系人函数
  41. void add_contact(contact* p);
  42.  
  43. //销毁联系人函数
  44. void destroy_contact(contact* p);
  45.  
  46. //打印联系人函数
  47. void print_contact(const contact* p);
  48.  
  49. //删除联系人函数
  50. void del_contact(contact* p);
  51.  
  52. //查找联系人函数
  53. void find_contact(const contact* p);
  54.  
  55. //修改联系人函数
  56. void modify_contact(contact* p);
  57.  
  58. //排序联系人函数
  59. void sort_contact(contact* p);

contact.c

  1.  
  2. #include"contact.h"
  3.  
  4. 初始化通讯录函数   静态版本
  5. //void init_contact(contact* p)
  6. //{
  7. //    p->sz = 0;
  8. //    memset(p->data, 0, sizeof(p->data));
  9. //}
  10.  
  11. //初始化通讯录函数    动态版本
  12. void init_contact(contact* p)
  13. {
  14.     p->data = (peoinfo*)calloc(DEFAULT_SZ, sizeof(peoinfo));
  15.     if (p->data == NULL)
  16.     {
  17.         perror("init_contact");
  18.         return;
  19.     }
  20.     p->sz = 0;//初始化后默认是0
  21.     p->capacity = DEFAULT_SZ;
  22. }
  23.  
  24. 增加联系人函数      静态版本
  25. //void add_contact(contact* p)
  26. //{
  27. //    if (p->sz == MAX)
  28. //    {
  29. //        printf("通讯录已满，无法添加");
  30. //        return;
  31. //    }
  32. //    printf("请输入要添加人的姓名：");
  33. //    scanf("%s", p->data[p->sz].name);
  34. //    printf("请输入要添加人的性别：");
  35. //    scanf("%s", p->data[p->sz].sex);
  36. //    printf("请输入要添加人的年龄：");
  37. //    scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
  38. //    printf("请输入要添加人的电话：");
  39. //    scanf("%s", p->data[p->sz].tele);
  40. //    printf("请输入要添加人的住址：");
  41. //    scanf("%s", p->data[p->sz].addr);
  42. //
  43. //    p->sz++;
  44. //    printf("添加成功\n");
  45. //}
  46.  
  47. //增加联系人函数      动态版本
  48. void add_contact(contact* p)
  49. {
  50.     if (p->sz == p->capacity)
  51.     {
  52.         peoinfo* tmp = (peoinfo*)realloc(p->data, (p->capacity + INC_SZ) * sizeof(peoinfo));
  53.         if (tmp == NULL)
  54.         {
  55.             perror("add_contact");
  56.             printf("增容失败\n");
  57.             return;
  58.         }
  59.         p->data = tmp;
  60.         p->capacity += INC_SZ;
  61.         printf("增容成功\n");
  62.     }
  63.     printf("请输入要添加人的姓名：");
  64.     scanf("%s", p->data[p->sz].name);
  65.     printf("请输入要添加人的性别：");
  66.     scanf("%s", p->data[p->sz].sex);
  67.     printf("请输入要添加人的年龄：");
  68.     scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
  69.     printf("请输入要添加人的电话：");
  70.     scanf("%s", p->data[p->sz].tele);
  71.     printf("请输入要添加人的住址：");
  72.     scanf("%s", p->data[p->sz].addr);
  73.  
  74.     p->sz++;
  75.     printf("添加成功\n");
  76. }
  77.  
  78. //销毁联系人函数
  79. void destroy_contact(contact* p)
  80. {
  81.     free(p->data);
  82.     p->data = NULL;
  83.     p->sz = 0;
  84.     p->capacity = 0;
  85. }
  86.  
  87. //打印联系人函数
  88. void print_contact(const contact* p)
  89. {
  90.     if (p->sz == 0)
  91.     {
  92.         printf("通讯录为空，无法打印\n");
  93.     }
  94.     else
  95.     {
  96.         printf("%-10s  %-10s  %-10s  %-15s  %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
  97.         for (int i = 0;i < p->sz;i++)
  98.         {
  99.             printf("%-10s  %-10s  %-10d  %-15s  %-10s\n",
  100.                 p->data[i].name,
  101.                 p->data[i].sex,
  102.                 p->data[i].age,
  103.                 p->data[i].tele,
  104.                 p->data[i].addr);
  105.         }
  106.     }
  107. }
  108.  
  109. //查找函数的一部分，删除和修改也要用，只放在这就行
  110. static int find_by_name(contact* p, char name[])
  111. {
  112.     for (int i = 0;i < p->sz;i++)
  113.     {
  114.         if (strcmp(p->data[i].name,name)==0)
  115.         {
  116.             return i;
  117.         }
  118.     }
  119.     return -1;
  120. }
  121.  
  122. //删除联系人函数
  123. void del_contact(contact* p)
  124. {
  125.     if (p->sz == 0)
  126.     {
  127.         printf("通讯录为空，无法删除\n");
  128.     }
  129.     else
  130.     {
  131.         char name[MAX_NAME] = { 0 };
  132.         printf("请输入要删除人的名字：");
  133.         scanf("%s", name);
  134.         int pos = find_by_name(p, name);
  135.         if (pos == -1)
  136.         {
  137.             printf("要删除的人不存在\n");
  138.         }
  139.         else
  140.         {
  141.             for (int i = pos;i < p->sz - 1;i++)
  142.             {
  143.                 p->data[i] = p->data[i + 1];
  144.             }
  145.             p->sz--;
  146.             printf("删除成功\n");
  147.         }
  148.     }
  149. }
  150.  
  151. //查找联系人函数
  152. void find_contact(const contact* p)
  153. {
  154.     if (p->sz == 0)
  155.     {
  156.         printf("通讯录为空，无法查找\n");
  157.     }
  158.     else
  159.     {
  160.         char name[MAX_NAME] = { 0 };
  161.         printf("请输入要查找人的名字：");
  162.         scanf("%s", name);
  163.         int pos = find_by_name(p, name);
  164.         if (pos == -1)
  165.         {
  166.             printf("要查找的人不存在\n");
  167.         }
  168.         else
  169.         {
  170.             printf("%-10s  %-10s  %-10s  %-15s  %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
  171.             printf("%-10s  %-10s  %-10d  %-15s  %-10s\n",
  172.                 p->data[pos].name,
  173.                 p->data[pos].sex,
  174.                 p->data[pos].age,
  175.                 p->data[pos].tele,
  176.                 p->data[pos].addr);
  177.         }
  178.     }
  179. }
  180.  
  181. //修改联系人函数
  182. void modify_contact(contact* p)
  183. {
  184.     if (p->sz == 0)
  185.     {
  186.         printf("通讯录为空，无法查找\n");
  187.     }
  188.     else
  189.     {
  190.         char name[MAX_NAME] = { 0 };
  191.         printf("请输入要修改人的姓名：");
  192.         scanf("%s", name);
  193.         int pos = find_by_name(p, name);
  194.         if (pos == -1)
  195.         {
  196.             printf("要修改的人不存在\n");
  197.         }
  198.         else
  199.         {
  200.             printf("以下是输入要修改人的新信息：\n");
  201.             printf("请输入姓名：");
  202.             scanf("%s", p->data[pos].name);
  203.             printf("请输入性别：");
  204.             scanf("%s", p->data[pos].sex);
  205.             printf("请输入年龄：");
  206.             scanf("%d", &p->data[pos].age);
  207.             printf("请输入电话：");
  208.             scanf("%s", p->data[pos].tele);
  209.             printf("请输入住址：");
  210.             scanf("%s", p->data[pos].addr);
  211.  
  212.             printf("修改成功\n");
  213.         }
  214.     }
  215. }
  216.  
  217. //排序联系人函数
  218. int cmp(void* e1, void* e2)
  219. {
  220.     return strcmp(((peoinfo*)e1)->name, ((peoinfo*)e2)->name);
  221. }
  222. void sort_contact(contact* p)
  223. {
  224.     if (p->sz == 0)
  225.     {
  226.         printf("通讯录为空，无法排序\n");
  227.     }
  228.     else
  229.     {
  230.         qsort(p->data, p->sz, sizeof(peoinfo), cmp);
  231.         printf("按照姓名排序成功\n");
  232.     }
  233. }
  234.  
  235. void sort_contact2(contact* p)//冒泡，比较麻烦，就用qsort了
  236. {
  237.     if (p->sz == 0)
  238.     {
  239.         printf("通讯录为空，无法排序\n");
  240.     }
  241.     else
  242.     {
  243.         for (int i = 0; i < p->sz; i++)
  244.         {
  245.             for (int j = 0; j < p->sz - i - 1; j++)
  246.             {
  247.                 if (strcmp((p->data[j].name), (p->data[j + 1].name)) > 0)
  248.                 {
  249.                     peoinfo data = p->data[j];
  250.                     p->data[j] = p->data[j + 1];
  251.                     p->data[j + 1] = data;
  252.                 }
  253.             }
  254.         }
  255.         printf("按照姓名排序成功\n");
  256.     }
  257. }

完成静态或动态通讯录后想到怎么能把内容保存下次用呢？

这时就要用到后面学的文件操作，（放到文件只是学C语言的一种临时方法，后面学得更多会放到数据库中）

3. 常见的动态内存错误

3.1 对空指针的解引用操作

  1.  
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. int main()
  5. {
  6.     int* p = (int*)malloc(9999999999);//开辟失败，返回空指针
  7.     int i = 0;
  8.     for (i = 0; i < 10; i++) 
  9.     {
  10.         *(p + i) = i; // 对空指针进行解引用操作，非法访问内存
  11.     }
  12.     return 0;
  13. }
  14. //解决方案：对 malloc 函数的返回值做判空处理
  15. #include <stdlib.h>
  16. #include <stdio.h>
  17. int main()
  18. {
  19.     int* p = (int*)malloc(9999999999);
  20.     // 对malloc函数的返回值做判空处理
  21.     if (p == NULL) 
  22.     {
  23.         perror("main")
  24.         return 1;
  25.     }
  26.     int i = 0;
  27.     for (i = 0; i < 10; i++) 
  28.     {
  29.         *(p + i) = i;
  30.     }
  31.     return 0;
  32. }

记得对 malloc 函数的返回值做判空处理

3.2 对动态开辟空间的越界访问

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int main()
  5. {
  6.     int* p = (int*)malloc(10 * sizeof(int)); // 申请10个整型的空间
  7.     if (p == NULL) 
  8.     {
  9.         perror("main");
  10.         return 1;
  11.     }
  12.     int i = 0;
  13.     // 越界访问 - 指针p只管理10个整型的空间，根本无法访问40个
  14.     for (i = 0; i < 40; i++)
  15.     {
  16.         *(p + i) = i;
  17.     }
  18.     free(p);
  19.     p = NULL;
  20.     return 0;
  21. }

为了防止越界访问，使用空间时一定要注意开辟的空间大小。

3.3 对非动态开辟内存使用free释放

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int main()
  5. {
  6.     int arr[10] = { 0 }; // 在栈区上开辟
  7.     int* p = arr;
  8.     // 使用  略
  9.     free(p); // 使用free释放非动态开辟的空间
  10.     p = NULL;
  11.     return 0;
  12. }

不要对非动态开辟的内存使用 free，否则会出现难以意料的错误。（程序可能会卡死）

3.4 使用free释放一块动态开辟内存的一部分

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int main()
  5. {
  6.     int* p = malloc(10 * sizeof(int));
  7.     if (p == NULL) 
  8.     {
  9.         return 1;
  10.     }
  11.     int i = 0;
  12.     for (i = 0; i < 5; i++) 
  13.     {
  14.         *p++ = i; // p指向的空间被改变了
  15.         //而且存在内存泄露风险
  16.     }
  17.     free(p);//error  p不再指向动态内存的起始位置
  18.     p = NULL;
  19.     return 0;
  20. }

注意事项：这么写代码会导致 p 只释放了后面的空间。没人记得这块空间的起始位置，

再也没有人找得到它了，这是很件很可怕的事情，会存在内存泄露的风险。

释放内存空间的时候一定要从头开始释放。

3.5 对同一块动态内存多次释放

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int main()
  5. {
  6.     int* p = malloc(10 * sizeof(int));
  7.     if (p == NULL) 
  8.     {
  9.         return 1;
  10.     }
  11.     int i = 0;
  12.     for (i = 0; i < 10; i++) 
  13.     {
  14.         p[i] = i;
  15.     }
  16.     // 释放
  17.     free(p);
  18.     // 一时脑热或者出了函数后忘了，再一次释放（程序可能会卡死）
  19.     free(p);//error
  20.     return 0;
  21. }

解决方案：在第一次释放后紧接着将 p 置为空指针，free对空指针释放什么都不会做

3.6 动态开辟内存忘记释放（内存泄漏）

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. void test()
  5. {
  6.     int* p = (int*)malloc(100);
  7.     if (p == NULL)
  8.     {
  9.         return;
  10.     }
  11.     // 使用 略
  12.     
  13.     // 此时忘记释放了
  14. }
  15. int main()
  16. {
  17.     test();
  18.     free(p); // 此时释放不了了，没人知道这块空间的起始位置在哪了
  19.     p = NULL;
  20. }

malloc 这一系列函数 和 free 一定要成对使用，记得及时释放。

你自己申请的空间，用完之后不打算给别人用，就自己释放掉即可。

如果你申请的空间，想传给别人使用，传给别人时一定要提醒别人用完之后记得释放。

动态开辟的内存空间有两种回收方式： 1. 主动释放（free） 2. 程序结束
如果这块程序在服务器上 7x24 小时运行，如果你不主动释放或者你找不到这块空间了，
最后就会导致内存泄漏问题。内存泄漏（Memory Leak）是指程序中已动态分配的堆内存
由于某种原因程序未释放或无法释放，造成系统内存的浪费，
导致程序运行速度减慢甚至系统崩溃等严重后果。

4. 几道经典的笔试题

题目选自高质量的C++/C编程指南、Nice2016校招笔试题。（可以当做对应练习使用）

（所以这篇在最后只留了没那么有关的几道编程题，）

（编程题已发解析在该专栏第21篇穿越回来贴个链接：C语言进阶21收尾(编程作业)(atoi，strncpy,strncat,offsetof模拟实现+找单身狗+宏交换二进制奇偶位）_从右向左奇数位和减偶数位和编程-CSDN博客）

4.1 题目1：

下列代码存在什么问题？请指出问题并做出相应的修改。

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. void GetMemory(char* p)
  6. {
  7.     p = (char*)malloc(100);
  8. }
  9. void Test() 
  10. {
  11.     char* str = NULL;
  12.     GetMemory(str);
  13.     strcpy(str, "hello world");
  14.     printf(str);
  15. }
  16. int main() 
  17. {
  18.     Test();
  19.     return 0;
  20. }

解析：（笔试和面试时要能把问题用语言说出来）

str 传给 GetMemory 函数时为值传递，所以 GetMemory 函数的形参 p 是 str 的一份临时拷贝。

在 GetMemory 函数内部动态开辟的内存空间的地址存放在了 p 中，并不会影响 str。

所以当 GetMemory 函数返回之后， str 仍然是 NULL，导致 strcpy 拷贝失败。

其次，随着 GetMemory 函数的返回，形参 p 随即销毁并且没有及时的使用 free 释放，

从而导致动态开辟的100个字节存在内存泄露问题。根据经验，程序会出现卡死的问题。

代码改法1：

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. // ↓ 修改返回类型为char*
  6. char* GetMemory(char* p) 
  7. {
  8.     p = (char*)malloc(100);
  9.     return p; // 将p带回来
  10. }
  11. void Test() 
  12. {
  13.     char* str = NULL;
  14.     str = GetMemory(str); // 用str接收，此时str指向刚才开辟的空间
  15.     strcpy(str, "hello world"); // 此时copy就没有问题了
  16.     printf(str);//printf("hello world");传给printf函数的也是h的地址，所以没问题
  17.     // 用完之后记得free，就可以解决内存泄露问题
  18.     free(str);
  19.     str = NULL; // 还要将str置为空指针
  20. }
  21. int main() 
  22. {
  23.     Test();
  24.     return 0;
  25. }

代码改法2：

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. //              ↓ 用char**接收
  6. void GetMemory(char** p) 
  7. {
  8.     *p = (char*)malloc(100);
  9. }
  10.  
  11. void Test() 
  12. {
  13.     char* str = NULL;
  14.     GetMemory(&str); // 址传递，就可以得到地址
  15.     strcpy(str, "hello world");
  16.     printf(str);
  17.     // 记得free，就可以解决内存泄露问题
  18.     free(str);
  19.     str = NULL; // 还要将str置为空指针
  20. }
  21. int main() 
  22. {
  23.     Test();
  24.     return 0;
  25. }

4.2 题目2：

请问运行Test 函数会有什么样的结果？

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. char* GetMemory(void) 
  5. {
  6.     char p[] = "hello world";
  7.     return p;
  8. }
  9. void Test(void) 
  10. {
  11.     char* str = NULL;
  12.     str = GetMemory();
  13.     printf(str);
  14. }
  15. int main() 
  16. {
  17.     Test();
  18.     return 0;
  19. }

解析：

GetMemory 函数内部创建的数组实在栈区上创建的，出了函数 p 数组的空间就还给了操作系统，

返回的地址是没有实际意义的，如果通过返回的地址去访问内存，就会导致非法访问内存问题。

4.3 题目3：

请问运行Test 函数会有什么样的结果？

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. void GetMemory(char** p, int num) 
  5. {
  6.     *p = (char*)malloc(num);
  7. }
  8. void Test(void) 
  9. {
  10.     char* str = NULL;
  11.     GetMemory(&str, 100);
  12.     strcpy(str, "hello");
  13.     printf(str);
  14. }
  15. int main() 
  16. {
  17.     Test();
  18.     return 0;
  19. }

解析：

就是对第一题的修改，但是没有 free和置空，导致内存泄露。

4.4 题目4：

请问运行Test 函数会有什么样的结果？

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. void Test(void) 
  6. {
  7.     char* str = (char*)malloc(100);
  8.     strcpy(str, "hello");
  9.     free(str);
  10.     if (str != NULL) 
  11.     {
  12.         strcpy(str, "world");
  13.         printf(str);
  14.     }
  15. }
  16. int main() 
  17. {
  18.     Test();
  19.     return 0;
  20. }

解析：

free 之后没有将 str 置为空指针，

导致 if 为真，对已经释放掉的内存进行了访问，引发非法访问的问题。

改法:free 后将 str 置为空指针

5. C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，

函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，

效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、

函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。

分配方式类似于链表。

3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

内存区域划分图：

有了这幅图，我们就可以更好的理解在前面讲的static关键字修饰局部变量的例子了。

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。

但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，

直到程序结束才销毁，所以生命周期变长。

栈区的特点：在上面创建的变量出了作用域就销毁。

数据段的特点：在上面创建的变量直到程序结束才销毁。

6. 柔性数组 flexible array

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

定义：柔性数组（Flexible Array），又称可变长数组。一般数组的长度是在编译时确定，而柔性数组对象的长度在运行时确定。在定义结构体时允许你创建一个空数组（例如：arr [ 0 ] ），该数组的大小可在程序运行过程中按照你的需求变动。

【百度百科】在 ANSI 的标准确立后，C语言的规范在一段时间内没有大的变动，
然而C++在自己的标准化创建过程中继续发展壮大。《标准修正案一》在1994年为C语言创建了一个新标准，但是只修正了一些C89标准中的细节和增加更多更广的国际字符集支持。不过，这个标准引出了1999年ISO 9899:1999的发表。被称为C99，C99被ANSI于2000年3月采用。

演示：

  1.  
  2. typedef struct st_type
  3. {
  4.  int i;
  5.  int a[0];//柔性数组成员
  6. }type_a;

部分编译器可能会报错，可以试着将 a [ 0 ] 改为 a [ ] ：

  1.  
  2. typedef struct st_type
  3. {
  4.  int i;
  5.  int a[];//柔性数组成员
  6. }type_a;

6.1 柔性数组的特点：

1.结构中的柔性数组成员的前面必须至少有一个其他成员：

  1.  
  2. typedef struct st_type
  3. {
  4.     int i;//必须至少有一个其他成员
  5.     int a[0];//柔性数组成员
  6. }type_a;

2.sizeof 计算这种结构的大小是不包含柔性数组成员的：

  1.  
  2. #include <stdio.h>
  3. struct S 
  4. {
  5.     int n; // 4
  6.     int arr[]; // 大小是未知的
  7. };
  8. int main() 
  9. {
  10.     struct S s = { 0 };
  11.     printf("%d\n", sizeof(s));//4
  12.     return 0;
  13. }

3.包含柔性数组成员的结构，用 malloc 函数进行内存分配，

并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小：

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. struct S
  5. {
  6.     int n;
  7.     int arr[0];
  8. };
  9. int main()
  10. {
  11.     //期望arr的大小是10个整型           给n的                 给arr[]的
  12.     struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
  13.     // 后面+的大小就是给柔性数组准备的
  14.     return 0;
  15. }

6.2 柔性数组的使用

代码1：使用柔性数组

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. struct S
  5. {
  6.     int n;
  7.     int arr[0];
  8. };
  9. int main()
  10. {
  11.     // 期望arr的大小是10个整型
  12.     struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
  13.     if (ps == NULL)
  14.     {
  15.         printf("malloc fail\n");
  16.         return -1;
  17.     }
  18.     ps->n = 10;
  19.     // 使用
  20.     for (int i = 0; i < 10; i++)
  21.     {
  22.         ps->arr[i] = i;
  23.     }
  24.     for (int i = 0; i < 10; i++)
  25.     {
  26.         printf("%d ", ps->arr[i]);
  27.     }
  28.     // 增容
  29.     struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
  30.     if (ptr != NULL)
  31.     {
  32.         ps = ptr;
  33.     }
  34.     // 再次使用 （略）
  35.     // 释放
  36.     free(ps);
  37.     ps = NULL;
  38.     return 0;
  39. }

6.3 柔性数组的优势

代码2：直接使用指针

想让n拥有自己的空间，其实不使用柔性数组也可以实现。

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. struct S 
  5. {
  6.     int n;
  7.     int* arr;
  8. };
  9. int main() 
  10. {
  11.     struct S* ps = (struct S*)malloc(sizeof(struct S));
  12.     if (ps == NULL)
  13.     {
  14.         printf("malloc fail\n");
  15.         return -1;
  16.     }
  17.     ps->n = 10;
  18.     ps->arr = (int*)malloc(10 * sizeof(int));
  19.     if (ps->arr == NULL)
  20.     {
  21.         printf("malloc fail\n");
  22.         return -1;
  23.     }
  24.     // 使用
  25.     for (int i = 0; i < 10; i++)
  26.     {
  27.         ps->arr[i] = i;
  28.     }
  29.     for (int i = 0; i < 10; i++)
  30.     {
  31.         printf("%d ", ps->arr[i]);
  32.     }
  33.     // 增容
  34.     int* ptr = (struct S*)realloc(ps->arr, 20 * sizeof(int));
  35.     if (ptr != NULL) 
  36.     {
  37.         ps->arr = ptr;
  38.     }
  39.     // 再次使用 （略）
  40.     // 释放
  41.     free(ps->arr); // 先free第二块空间
  42.     ps->arr = NULL;
  43.     free(ps);
  44.     ps = NULL;
  45.     return 0;
  46. }

虽然 代码2 实现了相应的功能，但是和 代码1 比还是有很多不足之处的。代码2 使用指针完成，

进行了两次 malloc ，而两次 malloc 对应了两次 free ，相比于 代码1 更容易出错

上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：

第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，
所以你不能指望用户来发现这个事。所以，如果把结构体的内存以及其成员要的内存一次性分配好，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.

连续内存多多少少有益于提高访问速度，还能减少内存碎片。malloc 的次数越多，
产生的内存碎片越多，这些内存碎片不大不小，再次被利用的可能性很低。内存碎片越多，
内存的利用率就会降低。频繁的开辟空间效率会变低，碎片也会增加。
（其实也没多高了，反正跑不了要用做偏移量的加法来寻址）

内存碎片和内存池：

扩展阅读：

C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell

本篇完。

可以自己模拟实现：atoi + strncat + strncpy。

穿越回来贴个链接：

C语言进阶21收尾(编程作业)(atoi，strncpy,strncat,offsetof模拟实现+找单身狗+宏交换二进制奇偶位）-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/670472
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号