这里是图片:
这里是目录
前言
为什么要有动态内存管理?
int a = 10;//固定的向内存申请4个字节
int arr [10];//申请连续的一块空间
//缺点:一旦空间申请完毕就不能在修改空间大小
上述的开辟空间的方式有两个特点:
- 空间开辟大小是固定的。
- 数组在声明的时候,必须指定数组的长度,它所需要的内存在编译时分配。
那么C语言中能不能有一种方式让我们来申请空间,空间不足时可以增加,空间过大时可以减小?这时就出现了动态内存管理。
1.动态内存函数介绍
1.1 malloc
我们今天要学的函数都是针对堆区的。
malloc: 用来申请一块内存空间。
malloc:
申请一块大小为size个字节的内存块,然后返回一个指针,指向这个块的起始地址。
因为不知道未来这个内存会放什么类型的数据,所以返回类型为:void*
如果内存申请失败,将返回一个空指针。
malloc函数的使用:
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
int main()
{
//申请40个字节(连续的空间),未来存放10个整形
int* p = (int*)malloc(40);//因为已经知道存放的类型为int所以直接转换成int*的指针接收返回值
//注:有可能开辟空间失败
//开辟失败
if (p == NULL)
{
printf("%s\n", strerror(errno));//如果开辟失败,生成失败原因
return 1;
}
//开辟成功
//存放1~10
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i + 1;
}
//打印
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
上述代码还存在一定的问题,因为我们在堆区上申请的空间,还的时候也需要亲自还一下(如果不还,在程序运行结束时空间也会被操作系统回收),但是这个程序如果一直不结束,又不主动归还空间,那么就会导致这块空间一直被占用。
所以当这块空间不使用的时候我们需要主动归还这块空间。
1.2 free
free: 是释放申请的内存
ptr – 指针指向一个要释放内存的内存块
如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。
如果参数 ptr 是NULL指针,则函数什么事都不做。
free(p);
p = NULL;//因为free执行并不会把p置为空指针,所以我们需要手动置为NULL
在上述代码中加入此句就可以释放内存空间。
空间释放前:
空间释放后(未置p为NULL):
如果不手动置为NULL,如果之后再访问p就会出现非法访问
空间释放(手动将p置为NULL):
空间申请失败:
其实空间也会有申请失败的时候的,比如我们试着申请INT_MAX
int main()
{
int* p = (int*)malloc(INT_MAX);
if (p == NULL)
{
printf("%s\n", strerror(errno));//如果开辟失败,生成失败原因
return 1;
}
return 0;
}
运行效果:
如果开辟成功,则返回一个指向开辟好空间的指针。
如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。
如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
malloc和free都声明在 stdlib.h 头文件中。
1.3 calloc
calloc和malloc是有所差异的
num – 要被分配的元素个数。
size – 元素的大小。
开辟num个大小为size的空间。
calloc函数的使用:
int main()
{
//malloc,calloc 都是在堆区上申请空间
//空间使用完都要释放
int* p = (int*)calloc(10, sizeof(int));
//calloc也有可能开辟空间失败
//开辟失败也会返回空指针
if (NULL == p)
{
perror("calloc");//如果失败,打印失败原因
return 1;
}
//开辟成功
//使用
int i = 0;
for (i = 0; i < 10;i++)
{
printf("%d ", * (p + i));
}
//使用完后释放
free(p);
p = NULL;
return 0;
}
运行效果:
malloc和calloc的区别:
malloc申请到的空间,没有初始化,直接返回起始地址。
calloc申请好空间后,会把空间初始化为0,然后返回起始地址。
如果我们不希望申请到的空间被初始化,可以使用malloc,希望被初始化就用calloc
1.4 realloc
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时候内存,我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
realloc:尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。
ptr – 指针指向一个要重新分配内存的内存块,该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针,则会分配一个新的内存块,且函数返回一个指向它的指针。
size – 内存块的新的大小,以字节为单位。如果大小为 0,且 ptr 指向一个已存在的内存块,则 ptr 所指向的内存块会被释放,并返回一个空指针。
realloc函数的使用:
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(5 * sizeof(int));
if (NULL == p)
{
perror("malloc");
return 1;
}
//开辟成功
//使用
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = 1;
}
//空间不够,增加10个整形的空间
//调整
int* ptr = (int*)realloc(p, 10 * sizeof(int));//临时指针接收
//防止扩容失败p指向的内容丢失
if (ptr != NULL)
{
p = ptr;
ptr = NULL;//防止出现野指针
}
//继续使用
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
//使用完,释放空间
free(p);
p = NULL;
return 0;
}
realloc在调整内存空间的是存在两种情况:
realloc扩容失败时,会返回NULL,如果不用新指针(ptr)接收,万一扩容失败,p就会被置为NULL。
所以我们最好创建一个新的指针来接收他的返回值。
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间
realloc传递空指针
int main()
{
//当传递NULL时其功能和malloc一致
int* p = (int*)realloc(NULL, 40);// = malloc(40);
return 0;
}
2.常见的动态内存错误
2.1 对NULL指针的解引用操作
我们来看以下代码:
int main()
{
int* p = (int*)malloc(100);//正常情况需要判断指针是否为空
//未判断直接使用
int i = 0;
for (i = 0; i < 20; i++)
{
*(p + i) = 0;
}
return 0;
}
这种写法其实是非常危险的,如果malloc函数开辟空间失败了,那么p就是一个野指针(NULL),所以malloc的返回值一定要判断。
2.2 对动态开辟空间的越界访问
动态开辟的空间也是一块连续的空间,所以在访问的时候也是有可能出现越界访问的。
int main()
{
int* p = (int*)malloc(100);
//开辟了100个字节(25个整形)
if (p == NULL)
{
return 1;
}
int i = 0;
//访问了100个整形
//越界访问
for (i = 0; i < 100; i++)
{
p[i] = 0;
}
free(p);
p = NULL;
return 0;
}
编译器也会报出相应的警告,所以一定要注意编译器上的警告,不要出现越界访问的现象。
2.3 对非动态开辟内存使用free释放
int main()
{
int a = 10;//栈区
int* p = &a;
free(p);
p = NULL;
return 0;
}
free释放的是堆区上的空间,但是p指向的空间是栈区上的,当我们这样去运行代码的时候这个程序就会挂掉。
所以我们在使用free的时候要注意,不能对非动态开辟的空间使用。
2.4使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 25; i++)
{
*p = i;
p++;
}
//使用完释放
free(p);//p不再指向动态内存的起始位置
p = NULL;
return 0;
}
这段代码,当我们使用完空间进行释放的时候,想想p指针还指向原来的位置吗。
2.5对同一块动态内存多次释放
如果我们释放已经被释放的内存空间,那么这时的程序也是会有问题的。
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
//使用
//释放
free(p);
//p未置空指针,为野指针
//释放后在进行释放
free(p);
return 0;
}
如果运行这段代码我们的程序最后也会挂掉。
但是如果我们在第一次释放内存空间的时候把p设置成NULL,这时我们的代码就不会出现任何问题了。
如下:
int main()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return 1;
}
//使用
//释放
free(p);
p = NULL;
//释放后在进行释放
free(p);
return 0;
}
所以我们一定要记得,在free使用完之后一定要把指针置为空指针。
2.6 动态开辟内存忘记释放(内存泄漏)
void test()
{
int* p = (int*)malloc(100);
//使用
//使用完后未进行释放
}
int main()
{
test();
//函数调用结束之后,p指针将被销毁,那么这100个字节就会出现无法释放的问题
//只有当程序结束/挂掉时,内存才会释放
return 0;
}
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记:
动态开辟的空间一定要释放,并且正确释放。
注意一些使用问题:
void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return;
}
//使用
//假设某个条件被满足
if (1)
{
return;//程序提前结束
}
//释放
free(p);
p = NULL;
}
int main()
{
test();
return 0;
}
这段代码中虽然有free,但是程序运行的过程中提前结束了,没有进行释放操作,这也会导致内存的泄露。
所以在设计代码的时候需要注意这种情况。
以上就是本篇文章的全部内容了,希望大家看完能有所收获。