目录
一、free 函数
//动态内存释放函数 free ,专门用于动态内存的释放和回收;
void free(void* ptr);
free 函数用于释放动态开辟的内存;
如果参数 ptr 指向的空间不是动态开辟的,此时free函数的行为是未定义的;
如果参数 ptr 是NULL指针,则函数无动作;
int main()
{
int* p = NULL;//空指针;
free(p);//free函数无动作;
return 0;
}
二、malloc 函数
//动态内存开辟函数 malloc
void* malloc (size_t size);
这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针;
如果开辟成功,返回一个指向开辟的空间的首地址的指针;
如果开辟失败,返回一个NULL指针,因此malloc函数的返回值,一定要做检查;
返回值的类型时void*,所以malloc函数并不知道开辟空间的类型,具体在使用时由使用者自己决定(强制转换);
如果参数size为0,malloc函数的行为是标准未定义的,取决于编译器;
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
int arr[10] = { 0 };
int* p = (int*)malloc(sizeof(arr));//动态内存开辟;
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));//输出
}
//没有使用 动态内存释放函数 free ,此时如果程序继续运行,则被malloc函数开辟的空间不会被回收;
//但只要程序退出,系统会自动回收内存空间;
//正常情况下,由动态内存开辟函数所开辟的内存空间,在使用完成后必须被释放并销毁;
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
return 0;
}
//错误案例演示
int main()
{
while (1)
{
malloc(1);
}
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>
int main()
{
int* p = (int*)calloc(10, sizeof(int));//动态内存开辟;
if (p == NULL)//判断是否为空指针;
{
perror("calloc");//是空指针则输出错误代码;
return 1;//终止程序;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", *(p + i));//输出为:0 0 0 0 0 0 0 0 0 0;
}
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
return 0;
}
四、realloc 函数
//动态内存调整函数 realloc ,让动态内存管理更灵活,可以做到对动态开辟内存大小的调整;
void* realloc(void* ptr,size_t size);
ptr是需要调整的内存地址,size是调整之后的空间大小;
返回值为调整后的内存的起始地址;
函数在调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间;
//对于内存空间的调整,存在两种情况:
1.原有空间之后的空间足够满足新空间的开辟;
2.原有空间之后没有足够大的空间满足新空间的开辟;
//函数调整失败的情况:
1.realloc失败的时候,返回NULL;
2.realloc失败的时候,原来的内存不改变,不会释放也不会移动;
//注意使用realloc函数改变或开辟空间,最好使用新的变量接收,再将新变量赋值给旧变量;原因是为了避免开辟空间失败返回空指针,导致的旧空间内存泄漏(指针被置空,无法找到旧空间);
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main()
{
int* p = (int*)malloc(40);//开辟40字节空间赋予p;
if (p == NULL)//判断是否开辟成功;
{
perror("malloc");
return 1;
}
for (int i = 0; i < 10; i++)//赋值;
{
*(p + i) = i + 1;
}
int* ptr = realloc(p, 80);//扩容;此时,如果后续内存空间足够,则空间首地址不会改变,但如果后续内存空间不足,则会发现空间首地址改变,即新空间的开辟;
if (ptr != NULL)
{
p = ptr;//扩容成功则将扩容后的空间赋予p;
ptr = NULL;//ptr不再指向有效空间;
}
else
{
perror("realloc");
return 1;
}
for (int i = 10; i < 20; i++)//为扩容后的空间赋值;
{
*(p + i) = i + 1;
}
ptr = realloc(p, 40);//缩容;
if (ptr != NULL)
{
p = ptr;//缩容成功则将扩容后的空间赋予p;
ptr = NULL;//将ptr置空;
}
for (int i = 0; i < 20; i++)//为扩容后的空间赋值;
{
printf("%d ", p[i]);
}
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
return 0;
}
//realloc(NULL, 40);如果将realloc函数的第一个值,置为空指针,则含函数有类似于malloc函数一样的功能,即直接开辟40字节的空间;
五、常见的动态内存错误
1.对NULL指针的解引用操作
//错误示例:
void test()
{
int* p = (int*)malloc(INT_MAX / 4);//开辟空间;//INT_MAX是指最大整数值;
*p = 20;//错误1:没有检查空间是否开辟成功,即p是否为空指针,就将p赋值,可能会导致对空指针的解引用操作,编译器报错;
free(p);//错误2:只释放了指针p指向的内存空间,没有将p置为空指针;
}
//改正:每次开辟空间后,应检查空间是否成功开辟,指针是否为空指针;在使用完开辟的空间后,应将空间释放回收,并将指针置为空指针;
void test()
{
int* p = (int*)malloc(INT_MAX / 4);//开辟空间;
if (p == NULL)//检查空间是否成功开辟,指针是否为空指针;
{
return 1;
}
*p = 20;//赋值;
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
}
2.对动态开辟空间的越界访问
//错误示例:
void test()
{
int* p = (int*)malloc(10 * sizeof(int));//开辟空间;
if (p == NULL)//检查空间是否成功开辟,指针是否为空指针;
{
exit(EXIT_FAILURE);//头文件stdlib.h中定义的常量,即#define EXIT_FAILURE 1;与之对应的有#define EXIT_SUCCESS 0;
}
for (int i = 0; i <= 10; i++)//错误:开辟的空间只有10个整型,i<=10已经越界;
{
*(p + i) = i;
}
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
}
3.对非动态开辟内存使用free释放
//错误示例:
void test()
{
int a = 10;
int* p = &a;
free(p);//将p空间中的值销毁;//程序报错;//p指向的空间不是动态开辟的空间,指向的是栈区内的空间,不能被释放;
p = NULL;//p不再指向有效空间;
}
4.只使用free释放了动态开辟内存的一部分
//错误示例:
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//将p空间中的值销毁;//程序报错;//p++后,指针没有指向已开辟空间的首地址,此时释放p只能释放部分开辟的空间,而被忽略的那部分,则会发生内存泄漏;
p = NULL;//p不再指向有效空间;
}
5.对同一块动态内存多次释放
//错误示例:
void test()
{
int* p = (int*)malloc(100);
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
free(p);//将p空间中的值销毁;//程序报错;//空间已释放,重复释放空间;
}
6.动态开辟内存因各种原因未被释放(内存泄漏)
//忘记释放不再使用的动态开辟空间会造成内存泄漏,切记动态开辟的空间一定要正确释放;
6.1忘记释放
//错误示例:
void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
//*p = 20;//使用了开辟的空间;
}
//没有将已开辟空间释放;内存泄漏;
}
6.2在程序运行过程中,被其他程序跳过了释放的代码
//错误示例:
void test()
{
int* p = (int*)malloc(100);
int n = 0;
scanf("%d", &n);//输入5;
if (n == 5)
{
return;//此时程序已经跳出,不再执行下面的代码;p未被释放;内存泄漏;
}
free(p);//将p空间中的值销毁;
p = NULL;//p不再指向有效空间;
}
6.3交错使用开辟的内存空间,导致空间被忘记释放
//错误示例:
int* test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return p;
}
return p;
}
int main()
{
int* ret = test();//接收p;
//......业务处理......
//后续没有释放空间;空间由函数开辟,但使用由主函数使用,但主函数使用后没有释放空间,造成内存泄漏;
return 0;
}
(-- end --)