动态内存管理

一：引入

为什么有动态内存管理？？？
比如我们定义了一个变量a

int a=20;
int arr[10]={0};
1
2

a是整型，在空间中占4个字节，这是固定的，
arr数组是整型数组，占40个字节，这也是固定的。
我们可以想一下我们生活中的例子，比如：原来我们班有40个人，我们可以使用一个整型数组来存放他们的年龄，但如果后来又转入我们班5个学生，那么原来创建的数组就不可以使用了。
也就是说：空间开辟的大小是固定的，不能修改的。如果我们想要修改内存的大小，那么我们程序员就可以使用动态内存管理函数，来更改内存的大小。
常见的动态内存管理函数有malloc,free,calloc,realloc,这些函数的声明都在stdlib.h中。

二：free函数

我们开辟内存成功后，经过我们的一系列使用，这个空间我们不再使用，我们就要将开辟的空间释放，这个时候就用到了free函数。
即使没用free释放，程序结束的时候也会由操作系统来回收，但如果一个程序一直运行下去，我们没有及时的回收空间，那么空间可能会被耗干。所以我们要及时的回收空间。

void free (void* ptr)
1

free函数是专门用来做动态内存的释放和回收的。
如果参数ptr指向的空间不是动态内存开辟的，则free函数的行为就是未定义的；如果ptr是NULL指针，则函数什么都不做。

三：malloc函数和calloc函数

1：malloc函数

void* malloc(size_t size)
1

malloc函数向内存申请一块连续可用的空间，
如果开辟成功，那么将返回指向这块空间的地址，如果开辟失败，则返回NULL指针，所以要检查malloc函数是否开辟成功。
因为申请的空间不知道用来存放什么类型的数据，所以malloc函数返回类型为void*,所以我们需要根据具体情况来确定返回类型。

//malloc函数的使用
#include 
#include 
int main()
{
	//申请10个整型的空间，也就是40个字节
	 int* p = (int*)malloc(40);//因为申请的是整型，
   //而malloc函数返回的是void*,所以强制类型转换成   int*
	//判断是否开辟成功
    if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放
	free(p);//p是还给操作系统了但p还记着原先的地址，p已经变成野指针了
	p = NULL;//
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2：calloc函数

void* calloc(zize_t num,size_t size);
1

calloc函数是开辟num个大小为size的一块空间，

#include 
#include 
int main()
{
	int* p = (int*)calloc(10,4);//开辟10个大小为4字节的空间
	if (p == NULL)//判断
	{
		perror(malloc);//记录错误信息
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;//赋值
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);//打印
	}
	free(p);//释放内存空间
	p = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3：malloc函数和calloc函数的比较

calloc函数和malloc函数是非常相似的。
主要有两个差别，
1：malloc函数只有一个参数，而calloc函数有两个参数
2：calloc函数会自动为申请开辟空间的每个字节初始化为0；而malloc得到的是随机值。

#include 
#include 
//malloc函数
int main()
{
	int* p = (int*)malloc(40);
	if (p==NULL)
	{
		perror(malloc);
		return 1;
 }
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include 
#include 
int main()
{
	int* p = (int*)calloc(4, 10);
	if (p == NULL)
	{
		perror(calloc);
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四：realloc函数

realloc函数会让动态内存管理起来更加灵活。
当我们申请一块内存空间时，可能申请的空间过大了，或者过小了，那么使用realloc函数就可以对内存的大小进行灵活的调整。

void* realloc(void* ptr,size_t size)

1
2

这里的ptr指的是调整后的内存地址，size为调整后的申请内存大小，返回值为调整之后的起始地址。
既然realloc函数是对之前申请内存的调整，那么就存在两种情况：
情况1：原有空间的后面有足够大的空间，可以开辟要开辟的空间大小，这种情况之间在元空间的后面直接追加空间，返回的仍是原空间的地址。
情况2：原有空间的后面空间不够开辟要开辟的空空间，这种情况，在堆空间上另开辟一个合适的大小连续的空间，将原来的数据拷贝到这个空间，返回的是新开辟空间的地址。

//realloc函数的使用
#include 
#include 
int main()
{
	int* p = (int*)malloc(20);
	if(p==NULL)
	{
		perror(malloc);
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)//赋值
	{
		*(p + i) = i + 1;
	}
	
	int* ptr = (int*)realloc(p, 40);//再申请20个字节的空间
	//此处使用新指针变量的目的是为了防止扩容失败，
	//如果扩容失败，会realloc函数会返回空指针，原来的空间也不可以用了
	if (ptr != NULL)
	{
		p = ptr;
		
		ptr = NULL;
	}


	for (i = 5; i < 10; i++)//赋值
	{
		*(p + i) = i + 1;
	}
	for (i = 0; i < 10; i++)//打印
	{
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

当realloc函数的第一个参数是NULL 时，realloc函数相当于malloc函数。

#include 
#include 
int main()
{
	int *p=(int*)realloc(NULL, 40);//开辟了10个整型的空间
	if (p == NULL)
	{
		perror("realloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", p[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include 
#include 
int main()
{
	int *p=(int*)realloc(NULL, 40);//开辟了10个整型的空间
	if (p == NULL)
	{
		perror("realloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;//赋值
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", p[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22