【C语言】动态内存管理

void* malloc (size_t size);
这个函数向内存申请一块可连续可用的空间，并返回指向这块内存的指针。

如果开辟成功，则返回一个指向开辟好空间的指针。

如果开辟失败，则返回一个NULL指针，因此使用malloc一定要检查返回值。

返回值的类型是void*，malloc函数不知道开辟的空间的类型，使用者使用此函数时自己决定。

如果size为0，malloc的行为是标准未定义的，取决于编译器。

C语言提供了另一个函数用来动态内存的释放和回收free：

void free (void* ptr);
如果ptr指向的空间不是动态开辟的，则free函数的行为标准未定义。

如果ptr是NULL指针，则函数什么都不做。

malloc和free函数的使用如下：

malloc和free都声明在stdlib.h头文件中

#include <stdio.h>
#include <stdlib.h>
int main()
{	
    int* ptr = (int*)malloc(40); //开辟整型40个字节
	if (ptr == NULL)             //判断开辟是否成功，不成功则返回空指针
	{
		perror("malloc");        //如果开辟失败，显示错误信息
		return 1;
	}



	free(ptr);                   //用完释放开辟的空间
	ptr = NULL;                  //ptr指向的空间不存在，是野指针，所以将ptr化为空指针
	return 0;
}

2.2 calloc函数

void* calloc (size_t num, size_t size);
功能是将num个大小为size的的元素元素开辟一块空间，并将每个字节初始化为0。

与malloc不同是，calloc会在返回地址前把申请空间的每个字节初始化为0。

calloc开辟后也要用free将开辟空间其释放。

2.3 realloc

void* realloc (void* ptr, size_t size);
更改所指向内存的大小。

ptr是要调整的内存地址。

size是调整后的新大小。

返回值为调整后内存的起始位置。

扩容失败，返回NULL。

这个函数调整原内存空间大小的基础上，还会将内存中的数据移动到新的空间。

realloc在调整内存空间有两种情况

情况1：原有空间后有足够大的空间时，要扩展的内存就直接在原有内存之后之后追加空间，原来空间的数据不发生变化

情况2：原有空间后没有足够大的空间，需要在堆区上重新开辟一个适合的内存空间使用，将原有空间的数据拷贝到新的内存空间，并且返回新的内存空间的地址，拷贝完成后，realloc函数将原有的内存空间销毁

两种情况如下图所示

由于不确定realloc函数扩容是否成功，所以需要将realloc函数的返回值进行判断，如果不为NULL，则扩容成功。

具体使用如下

int main()
{
	int* p = NULL;
	int* ptr = (int*)malloc(100);//在ptr处开辟100个字节
	p = (int*)realloc(ptr, 1000);//在ptr处扩容为1000个字节，先赋给p，防止原有的ptr内存被NULL覆盖
	if (p != NULL)               //判断realloc是否开辟成功，
	{
		ptr = p;                 //开辟成功，记住ptr地址
	}
	

	return 0;
}

3.常见的动态内存错误

3.1对NULL指针的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;   //如果p的值是NULL，就会有问题
 free(p);
}

malloc函数开辟失败，返回值是NULL，对NULL解引用操作，程序会崩溃。

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

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;           //当i是10的时候越界访问
 }
 free(p);
}

开辟的空间只有40个字节，10个整型，越界访问到不属于动态开辟的空间。

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

void test()
{
 int a = 10;
 int *p = &a;
 free(p);  
}

此内存不是动态开辟的空间，却使用free来释放。

3.4 使用free释放一块动态开辟内存的一部分

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置
}

程序开始p指向动态内存开辟的起始位置，p++将p指向的位置向后移动了一个整型，不指向原来动态开辟内存的起始位置。

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

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

重复释放。

3.6 动态开辟内存忘记释放（内存泄漏）

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

动态开辟的内存没有用free函数进行释放，导致计算机内存泄漏减少，程序不合理。

切记：

动态开辟的空间一定要释放，并且正确释放 。

4. 几个经典的笔试题

4.1 题目1：

void GetMemory(char *p)
{
 p = (char *)malloc(100);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

形参是实参的一份临时拷贝，p是str的一份临时拷贝，当出了GetMeory函数后，p变量销毁，str还是NULL，strcpy中有NULL，程序会报错。

4.2 题目2：

har *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

GetMemory函数内部创建一个数组，return p返回的数组首元素地址，GetMemory函数调用结束后，函数内部创建的数组空间还给操作系统，不属于我们，此时的str指向是一个不属于我们的地址

str是野指针，程序错误。

4.3 题目3：

void GetMemory(char **p, int num)
{
 *p = (char *)malloc(num);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);
}

该程序会打印h“hello”，p指向的是str，*p找到str，最后打印“hello”，但是没有用free函数释放malloc开辟的内存。

4.4 题目4：

void Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}

“hello”拷贝到动态开辟的内存赋给str，当free（str）后，原来开辟的内存还给操作系统，此时的str记得原来的地址，只是该内存不属于我们，无法进行strcpy，如需修正，应该在free后将str变为NULL，所以该程序错误。

5.结语

本文对于C语言动态内存开辟进行了详细的介绍和应用，对于动态开辟内存的函数也进行的详细介绍，记得收藏加关注噢，感谢观看。