C语言 四个常用动态内存操作函数(free、malloc、calloc、realloc) 及其常见使用错误

目录

一、free 函数

二、malloc 函数

三、calloc 函数

四、realloc 函数

五、常见的动态内存错误

1.对NULL指针的解引用操作

2.对动态开辟空间的越界访问

3.对非动态开辟内存使用free释放

4.只使用free释放了动态开辟内存的一部分

5.对同一块动态内存多次释放

6.动态开辟内存因各种原因未被释放(内存泄漏)

6.1忘记释放

6.2在程序运行过程中，被其他程序跳过了释放的代码

6.3交错使用开辟的内存空间，导致空间被忘记释放

---

一、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 
#include 
#include 
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 
#include 
#include 
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 
#include 
#include 
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 --）