动态内存管理

1.为什么要有动态内存分配

我们已经掌握的内存开辟方式有：

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的方式有两个特点：
• 空间开辟大小是固定的。
• 数组在申明的时候，必须指定数组的长度，数组空间⼀旦确定了大小不能调整
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知
道，那数组的编译时开辟空间的方式就不能满足了。
C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

PS:

栈区	局部变量；形式参数
堆区	malloc;free;calloc;realloc
静态区	静态变量；全局变量

2.malloc

C语言提供了⼀个动态内存开辟的函数：

 void* malloc (size_t size);

这个函数向内存申请⼀块连续使用的空间，并返回指向这块空间的指针。
• 如果开辟成功，则返回⼀个指向开辟好空间的指针。
• 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
malloc声明在 stdlib.h 头文件中。

以下是一个案例：

#include <stdlib.h>

int main()
{
	//20 个字节 - 存放5个整数
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	
	return 0;
}

我们想要int*，那就强制类型转化。
每次我们开辟内存的时候我们事先都无法判断是否会失败，直接进行赋值是件有风险的事。我们应该进行判断，如果开辟失败（即为NULL），那么用perror函数返回相关错误信息。

3.free

C语言提供了另外⼀个函数free，专⻔是⽤来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

free函数用来释放动态开辟的内存。
• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。
free声明在 stdlib.h 头文件中。

以下是一个案例：

#include <stdlib.h>

int main()
{
	//20 个字节 - 存放5个整数
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)//注意开5个用5个，别越界
	{
		*(p + i) = i + 1;
	}

	//释放内存
	free(p);//传递给free函数的是要释放的内存空间的起始地址
	p = NULL;

	return 0;
}

使用空间：

释放内存：

传给free的是要释放的内存空间的起始地址。
但是free§执行完之后，p就变成了野指针，应该给他赋值NULL，避免其成为空指针。

4.calloc

C语言还提供了⼀个函数叫 calloc ， calloc 函数也⽤来动态内存分配。原型如下：

 void* calloc (size_t num, size_t size);

• 函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

举个例子：

int*p = (int*)malloc(5 * sizeof(int));//不会初始化
if (p == NULL)
{
	perror("malloc");
	return 1;
}


int* p = (int*)calloc(5, sizeof(int));//初始化为0
if (p == NULL)
{
	perror("malloc");
	return 1;
}

所以这两个函数在使用上有一定的相似性。
如果想初始化，用calloc，慢一些些。
没意向，用malloc,快一些些。

5.realloc

realloc函数的出现让动态内存管理更加灵活。
• 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时
候内存，我们⼀定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下：

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址
• size 调整之后新大小
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

使用方式如下：

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//20
	//1 2 3 4 5
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i+1;
	}
	//希望将空间调整为40个字节
	realloc(p, 40);
	return 0;
}

有三种可能会遇到的情况

情况一：一切顺利。
有足够的空间再分配

情况二：有些阻碍。
如果紧接着的空间不够了，那么函数会在堆区的内存中再找一个新的空间，并且会将原来空间的数据拷贝一份到新的空间。
之后释放旧的空间，返回新的内存空间的起始地址。

情况三：完全失败
情况一成功不了，情况二也调节不了，那么就返回NULL。

完整使用如下：

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//20
	//1 2 3 4 5
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i+1;
	}
	//希望将空间调整为40个字节
	int*ptr = (int*)realloc(p, 4000);
	if (ptr != NULL) //调整成功
	{
		p = ptr;
		int i = 0;
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i + 1;
		}

		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
		free(p);
		p = NULL;
	}
	else //调整失败
	{
		perror("realloc");
		free(p);
		p = NULL;
	}

	return 0;
}

PS:

//realloc函数可以完成和malloc一样的功能


int main()
{
	realloc(NULL, 20);//=== malloc(20);
	return 0;
}

两者在这种方式上是等同的，就是找一个地方开辟一块20字节的空间。

6.常见的动态内存的错误

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

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

正确使用：

#include <assert.h>
#include<stdio.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	/*if (p == NULL)
	{
		perror("malloc");
		return 1;
	}*/

	assert(p);
	//
	*p = 20;

	return 0;
}

if与assert选一种即可

6.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);
 }

申请了10个却使用了11个（0~10）不合理。

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

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

free只能释放动态开辟的内存，不能用于非动态开辟的~

6.4.使用free释放⼀块动态开辟内存的⼀部分

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

这里的p不再指向起始地址，这是不可取的。

6.5.对同⼀块动态内存多次释放

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

都放没了重复操作没意义。这在代码过长时可能会粗心犯错。

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

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

出了test()函数之后，局部变量被销毁，我们就找不到p指向开辟的空间在哪了，找也找不到，释放也释放不了。
自己不能用，也不还给操作系统，别人也用不了。内存泄漏指的就是这种申了不还的情况。

PS：其实malloc/calloc/realloc申请的内存，如果不想使用的时候可以用free释放。
但如果没有使用free释放，当程序结束的时候，也会由操作系统进行回收。

但是，我们在写程序时一一定要明确谁申请谁释放。
如果不能释放，要告诉使用的人，记得释放。