目录
为什么存在动态内存分配
我们目前掌握的内存开辟方式:
int a=10;//在栈空间上开辟四个字节
char arr[10]={0};//在栈空间上开辟10个字节的连续空间
上文开辟方式的特点:
1. 空间开辟大小是固定的。
2. 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配。 但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道, 那数组的编译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了
动态内存函数
malloc和free函数
malloc函数的定义:
void* malloc (size_t size);
- 这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
- 如果开辟成功,则返回一个指向开辟好空间的指针。
- 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己 来决定。
- 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
free函数的定义:
void free (void* ptr);
- free函数用来释放动态开辟的内存。
- 如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。
- 如果参数 ptr 是NULL指针,则函数什么事都不做。
代码举例:
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>
int main()
{
//申请
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno)); //判断是否为空指针,为空则打印错误信息
return 1;
}
//使用
int i = 0;
for (i = 0;i < 5;i++)
{
*(p + i) = i;
//p[i]=i;
printf("%d ", *(p + i));
}
//释放
free(p);
p = NULL;
return 0;
}
内存中的位置 :
运行结果:
calloc函数
calloc函数的定义:
void* calloc (size_t num, size_t size);
- 函数的功能是为 num 个大小为 size 的元素开辟一块空间,并且把空间的每个字节初始化为0。
- 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
代码举例:
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (NULL == p)
{
printf("%s\n", strerror(errno));
return 1;
}
//使用
int i = 0;
for (i = 0;i < 10;i++)
{
p[i] = i + 1;
printf("%d ", p[i]);
}
//释放
free(p);
p = NULL;
return 0;
}
运行结果:
初始化运行效果:
calloc和malloc的区别:
- 上面介绍calloc已经提过,这里再说一边来加深印象
- 首先,它们的参数是不一样的
- 都是在堆区上申请内存空间的,但是malloc不初始化
- 不要初始化就用malloc
- 要初始化就用calloc
realloc函数
为什么要有realloc函数呢?
- realloc函数的出现让动态内存管理更加灵活。
- 有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的使用内存,我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数realloc的定义:
void* realloc (void* ptr, size_t size);
- ptr --- 是要调整的内存地址
- size ---调整之后新大小
- 返回值为调整之后的内存起始位置
- 这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间
画图分析realloc:
代码举例:
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
//申请
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
//使用
int i = 0;
for (i = 0;i < 5;i++)
{
p[i] = i+1;
}
//要预防realloc返回空指针的情况
int*ptr=(int*)realloc(p, 40);
//判断
if (ptr != NULL)
{
p = ptr;
//扩容
for (i = 5;i < 10;i++)
{
p[i] = i + 1;
}
for (i = 0;i < 10;i++)
{
printf("%d ", p[i]);
}
}
//释放
free(p);
p = NULL;
return 0;
}
运行效果:
关于使用realloc的小提示:
我们在使用reallooc进行扩容时,如果直接让原本的p直接接受新的地址,若是扩容失败返回的地址为NULL,那么会造成原先的p也没有,所以我们可以创建一个临时变量来判断返回的地址是否为NULL,然后再将新的地址给p
动态内存常见错误
对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(20);
int i = 0;
for (i = 0;i < 5;i++)
{
p[i] = i;
}
return 0;
}
这里系统给了警告 :
警告:C6011
对动态开辟空间的越界访问
int main()
{
int* p = (int*)malloc(20);
int i = 0;
if (p == NULL)
{
printf("%s", strerror(errno));
return 1;
}
for (i = 0;i < 20;i++)
{
p[i] = i;
}
return 0;
}
这里系统给了警告:
警告:C6200
对非动态开辟内存使用free释放
int main()
{
int arr[] = { 1,2.3,4,5 };
int* p = arr;
//................................
free(p);
p= NULL;
return 0;
}
运行效果:
使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
int i = 0;
for (i = 0;i < 5;i++)
{
*p = i+1;
p++;
// 1 2 3 4 5 |" " | " " | " " | " " | " " |
}
free(p);
p = NULL;
return 0;
}
这里系统给了警告:
警告:C6011
对同一块动态内存多次释放
int main()
{
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
free(p);
//p = NULL;
free(p);
p = NULL;
return 0;
}
这里系统给了警告:
如果释放第一次就将p置为NULL,就不会有事,因为如果地址为NULL,那么free什么都不会做
动态开辟内存忘记释放(内存泄漏)
- realloc所申请的空间,如果不想使用,需要free释放
- 如果不用free释放:
- 程序结束后也会由操作系统回收
- 如果不使用free释放,程序也不结束------内存泄漏
void test()
{
int* p = (int*)malloc(20);
}
int main()
{
test();
return 0;
}
如上这种情况:20个字节的地址存放在p里,函数返回后,由于p是局部变量,p被销毁,来到主函数后主函数无法得知这20个字节的地址,进而无法进行释放
自己申请的,尽量自己释放
自己不释放的,告诉别人释放
大家也可以看看下面这个代码自己试一试
int main()
{
while (1)
{
malloc(1);
}
return 0;
}