目录
- 为什么要有动态内存分配
- malloc和free
- malloc
- free
- calloc和realloc
- calloc
- realloc
感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐓🏀 python
为什么要有动态内存分配
在学动态内存分布时我们先了解一下内存的一点知识
内存是分栈区,堆区和静态区
我们已经掌握的内存开辟⽅式有
int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点：
• 空间开辟大小是固定的。
• 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整
但是对于空间的需求，不仅仅是上述的情况。
有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。
而如果我们一次性就开辟很大的空间,比如我只明明只需要开辟4个字节的空间,而最后却开辟了100个字节的空间,那么多出来的空间就浪费掉了
因此C语言引人了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。(注意必须最后要释放,如果只申请不释放的话内存会越来越大)
malloc和free
malloc
C语言提供了一个动态内存开辟的函数malloc:
void* malloc (size_t size);
这个函数向内存申请一块连续可用的空间，并返回指向这块空间起始地址的指针。
• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个 NULL 指针，因此malloc的返回值一定要做检查(用perror(“malloc”)来检查)。
• 返回值的类型是 void ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定*。
• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
什么情况会使内存开辟失败呢?
来看看下面的一个代码
#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(INT_MAX*10);
if (p == NULL)
{
perror("malloc");
return 1;//非0表示异常返回
}
return 0;//0表示正常返回
}
INT_MAX是整形的最大值,他的值如图
在我们还没有运行的时候系统就已经报错了
我们再看看perror输出的结果
显然我们开辟的空间过大,导致没有了足够的空间
如果我们申请0个字节会怎么样
并没有报错
那我们再申请-1个字节又会怎么样
我们可以看到输出的结果是没有足够的空间
我们再看一个代码
#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
for (int i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}
这里的p指向malloc开辟的起始地址,由于内存中存放的都是int类型的元素,那么p+i就表示p跳过i个元素,对其解引用就是内存中的具体值,这里就非常像数组
free
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下
void free (void* ptr);
free函数用来释放动态开辟的内存。
• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。
malloc和free都声明在 stdlib.h 头文件中。
在之前有提到,每次都要释放内存,而在malloc的代码中却没有释放,这里需要解释一下
#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
for (int i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}
由于这个程序是运行完了的,所以系统会自动回收内存,因此并不需要我们主动去回收(当然了主动回收也是一个好习惯),而有些程序是一直运行的,或者会运行很久,这样导致开辟的空间一直没有释放,而在运行的过程中不断的开辟新的内存空间,导致内存越来越大,所以需要自己去主动释放内存
最后结论就是如果程序运行完,就会自己回收内存空间,这是被动回收
而用free回收的话,就是可以在程序还没有运行完就可以回收,这是主动回收
举个例子：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num = 0;
scanf("%d", &num);
int arr[num] = { 0 };
int* ptr = NULL;
ptr = (int*)malloc(num * sizeof(int));
if (NULL != ptr)//判断ptr指针是否为空
{
int i = 0;
for (i = 0; i < num; i++)
{
*(ptr + i) = 0;
}
}
free(ptr);
ptr = NULL;
return 0;
}
这里free时我们只是回收了arr的内存空间,但是ptr却仍然保存着arr的地址,因此在最后我们需要让ptr==NULL变成空指针,否则就会变成野指针
calloc和realloc
calloc
C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下
void* calloc (size_t num, size_t size);
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0
举个例子：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)calloc(10, sizeof(int));//10表示申请多少个元素,sizeof(int)表示申请一个元素有多大
if (NULL != p)
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
}
free(p);
p = NULL;
return 0;
}
由于calloc初始化,使空间中的元素全为0,所以输出的结果都是0
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(10*sizeof(int));
if (NULL != p)
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
}
free(p);
p = NULL;
return 0;
}
malloc没有初始话,导致输出的结果就是这样
所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务
realloc
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们⼀定会对内存的大小做灵活的调整。
那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下
void* realloc (void* ptr, size_t size);
•ptr 是要调整的内存地址
• size 调整之后新大小
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
• realloc在调整内存空间的是存在两种情况：
◦ 情况1：原有空间之后有足够大的空间
◦ 情况2：原有空间之后没有足够大的空间
情况1
当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2
当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小
的连续空间来使用。这样函数返回的是一个新的内存地址。
我们具体举个例子
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* ptr = (int*)malloc(100 * sizeof(int));
//扩展容量
int* p = NULL;
p = realloc(ptr, 10000 * sizeof(int));
ptr = p;
free(ptr);
return 0;
}
显然这里的realloc是重新找了一块新的内存空间,并返回的
因此由于上述的两种情况，realloc函数的使用就要注意⼀些。
//代码1
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* ptr = (int*)malloc(100);
if (ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
free(ptr);
return 0;
}
//代码2
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* ptr = (int*)malloc(100*sizeof(int));
if (ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
int* p = NULL;
p = realloc(ptr, 1000*sizeof(int));
if (p != NULL)
{
ptr = p;
}
free(ptr);
return 0;
}
代码一和代码二的区别就在于一个是直接用ptr接收realloc的返回值
一个是判断realloc的返回值是否为空
为什么需要判断返回值是否为空呢?
如果返回值为空,那么让ptr等于空指针的话,之前内存所保存的所有元素都被消失(也可以说是之前申请的内存都没有了,当然就没有保存的元素了)
而如果判断返回值不为空之后,再将返回值传给ptr,那么内存保存的所以元素都不会消失
此外realloc还可以当成malloc使用
#include<stdio.h>
int main()
{
realloc(NULL,sizeof(int))//==malloc(1*sizeof(int))
return 0;
}
