[技术手册] C语言的动态内存申请

[复制链接]
168|5

1. 动态分配内存的概述
如果数组的长度是预先定义好的,在整个程序中固定不变,但是在实际的编程中,往往会发生这种情况,即所需的内存空间取决于实际输入的数据,而无法预先确定 。为了解决上述问题,C语言提供了一些内存管理函数,这些内存管理函数可以按需要动态的分配内存空间,也可把不再使用的空间回收再次利用。

静态分配:
1、在程序编译或运行过程中,按事先规定大小分配内存空间的分配方式。inta[10]
2、必须事先知道所需空间的大小。
3、分配在栈区或全局变量区,一般以数组的形式。
4、按计划分配。

动态分配:
1、在程序运行过程中,根据需要大小自由分配所需空间。
2、按需分配。
3、分配在堆区,一般使用特定的函数进行分配。

 楼主| 星辰大海不退缩 发表于 2025-10-22 15:01 | 显示全部楼层

2. 动态分配的函数
使用动态分配的函数,需要 #include<stdlib.h>

(1) malloc 函数

函数原型: void* malloc(unsigned int size);

功能说明:在内存的动态存储区(堆区)中分配一块长度为size字节的连续区域,用来存放类型说明符指定的类型。函数原型返回 void* 指针,使用时必须做相应的强制类型转换 ,分配的内存空间内容不确定,一般使用memset 初始化。

返回值:返回分配空间的起始地址 ( 分配成功 ),返回NULL( 分配失败 ) 。

注意:在调用malloc之后,一定要判断一下,是否申请内存成功。如果多次malloc申请的内存,第1次和第2次申请的内存不一定是连续的。

举例:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<string.h>


  5. int main()
  6. {
  7.         int i, * array, n;
  8.         printf("请输入您要申请的数组元素个数\n");
  9.         scanf_s("%d", &n);
  10.         array = (int*)malloc(n * sizeof(int));
  11.         if (array == NULL)
  12.         {
  13.                 printf("申请内存失败\n");
  14.                 return 0;
  15.         }
  16.         else
  17.         {
  18.                 memset(array, 0, n * sizeof(int));
  19.                 for (i = 0; i < n; i++)
  20.                 {
  21.                         array[i] = i;
  22.                 }
  23.                 for (i = 0; i < n; i++)
  24.                 {
  25.                         printf("array[%d]=%d\n", i,array[i]);
  26.                 }
  27.                 free(array);//释放array指向的内存
  28.                 return 0;
  29.         }
  30. }


(2) free函数(释放内存函数)
函数原型:void free(void*ptr)
函数说明:free函数释放ptr指向的内存。注意ptr指向的内存必须是malloc、calloc、relloc动态申请的内存。

举例:

  1. char* p=(char*)malloc(100);
  2. free(p);


注意 : free后,因为没有给p赋值,所以p还是指向原先动态申请的内存。但是内存已经不能再用了,p 变成野指针了。一块动态申请的内存只能free一次,不能多次free。

(3) calloc 函数

函数原型:void* calloc(size_t nmemb,size_t size);

函数的功能:在内存的堆中,申请nmemb 块,每块的大小为size个字节的连续区域。

函数的返回值:返回 申请的内存的首地址(申请成功),返回 NULL(申请失败)。

注意:malloc 和 calloc 函数都是用来申请内存的。

区别:

函数的名字不一样
参数的个数不一样
malloc 申请的内存,内存中存放的内容是随机的,不确定的,而calloc函数申请的内存中的内容为0
  1. char *p=(char *)calloc(3,100);


上面代码 在堆中申请了3块,每块大小为100个字节,即300个字节连续的区域。

(4) realloc 函数(重新申请内存)

咱们调用malloc和calloc 函数,单次申请的内存是连续的,两次申请的两块内存不一定连续。

有些时候有这种需求,即我先用malloc或者calloc申请了一块内存,我还想在原先内存的基础上挨着继续申请内存。或者我开始时候使用malloc或calloc申请了一块内存,我想释放后边的一部分内存。为了解决这个问题,发明了realloc这个函数。

函数原型:void* realloc(void *s,unsigned int new_size);

函数的功能:在原先s指向的内存基础上重新申请内存,新的内存的大小为 new_size 个字节,如果原先内存后面有足够大的空间,就追加,如果后边的内存不够用,则relloc函数会在堆区找一个new_size 个字节大小的内存申请,将原先内存中的内容拷贝过来,然后释放原先的内存,最后返回新内存的地址。

如果new_size 比原先的内存小,则会释放原先内存的后面的存储空间,只留前面的newsize个字节。

返回值:新申请的内存的首地址。

举例:

  1. char *p;
  2. p=(char *)malloc(100);
  3. //咱们想在100个字节后面追加50个字节
  4. p=(char *)realloc(p,150); //p 指向的内存的新的大小为 150 个字节


注意:malloc、 calloc、 relloc 动态申请的内存,只有在free或程序结束的时候才释放。
 楼主| 星辰大海不退缩 发表于 2025-10-22 15:02 | 显示全部楼层
3. 内存泄露
内存泄露的概念:申请的内存,首地址丢了,找不了,再也没法使用了,也没法释放了,这块内存就被泄露了。

内存泄露 例1:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>

  4. int main()
  5. {
  6.         char* p;
  7.         p = (char*)malloc(100);
  8.         //接下来,可以用p指向的内存了
  9.         p = "hello world"; // p指向别的地方去了
  10.         //从此以后,再也找不到你申请的100个字节了。则动态申请的100个字节就被泄露了
  11.         return 0;
  12. }


内存泄露 例2:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>

  4. void fun() {
  5.         char* p;
  6.         p = (char*)malloc(100);
  7.         //接下来,可以用p指向的内存了
  8.         p = "hello world"; // p指向别的地方去了
  9. }

  10. int main()
  11. {
  12.         fun();
  13.         fun();
  14.         //从此以后 ,每调用一次fun泄露100个字节
  15.         return 0;
  16. }


内存泄露 解决方案1:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>

  4. void fun() {
  5.         char* p;
  6.         p = (char*)malloc(100);
  7.         //接下来,可以用p指向的内存了
  8.         p = "hello world"; // p指向别的地方去了
  9.         // 释放内存       
  10.         free(p);
  11. }

  12. int main()
  13. {
  14.         fun();
  15.         fun();
  16.         return 0;
  17. }


内存泄露 解决方案2:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>

  4. char* fun() {
  5.         char* p;
  6.         p = (char*)malloc(100);
  7.         //接下来,可以用p指向的内存了
  8.         p = "hello world"; // p指向别的地方去了

  9.         return p;
  10. }

  11. int main()
  12. {
  13.         char* q;
  14.         q = fun();
  15.         //释放内存
  16.         free(q);
  17.         return 0;
  18. }


总结:申请的内存,一定不要把首地址给丢了,在不用的时候一定要释放内存。

OKAKAKO 发表于 2025-10-22 20:24 | 显示全部楼层
申请的内存,一定不要把首地址给丢了,在不用的时候一定要释放内存
AdaMaYun 发表于 2025-10-23 15:04 | 显示全部楼层
C语言提供了一些内存管理函数方便内存管理
中国龙芯CDX 发表于 2025-10-24 13:48 | 显示全部楼层
在程序运行过程中,根据需要大小自由分配所需空间。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

309

主题

2870

帖子

6

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