【C语言】C语言中的动态内存_c语言动态内存

---

一、为什么存在动态内存分配

首先要了解动态内存分配，就要知道空间的分配。
空间中可大致分为栈区、堆区和静态区。
栈区：栈区中主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
堆区：主要存放动态内存开辟的空间，动态内存分配便是在堆区完成的。
静态区：主要存放静态变量和全局变量。

那么为什么存在动态内存呢？

我们所知在栈区开辟的空间是固定的，而在实际应用中，对于空间的寻求是不够的，甚至有时候我们需要的空间大小在程序运行的时候才能知道，这时候就需要动态内存开辟的空间了。

---

二、动态内存函数的介绍

2.1、malloc和free

• 在C语言中提供了一个动态内存开辟的函数：

void * malloc (size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

注意：

• 如果开辟空间成功，则返回一个指向开辟好空间的指针，但是若开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
• 由于malloc函数的返回值是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由自己来决定是什么类型

• 由于动态内存分配是在堆区完成的，所以用完要及时释放。这时C语言提供了另一个函数free，专门用来做动态内存的释放和回收的：

void free (void * ptr);

free函数就是用来释放和回收动态开辟的内存

注意：

• 如果参数ptr指向的空间不是动态内存开辟的，那么free函数的行为是未定义的
• 如果参数ptr是NULL指针，则函数什么都不做。

下面我们举个例子加深对函数的理解：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	//向内存申请40个字节
	int* p = (int*)malloc(40);
	int* ptr = p;
	if (p == NULL)
		return 1;

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*ptr = i;
		ptr++; 
	}

	//释放
	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

注意：

每次向内存申请空间，使用完后都要释放空间，否则会造成内存泄漏
当释放空间后要把所指向这个空间的指针置为空指针，否则会非法访问内存，产生野指针。

---

2.2、calloc

• C语言中还提供了一个动态内存开辟的函数：

void * calloc (size_t num, size_t size);

其中，num表示为开辟元素的个数，size表示为每个元素的大小。

与malloc函数的区别在于，calloc函数会在返回地址之前把申请的空间的每个字节初始化为全0。
可理解为 calloc = malloc + memset

下面我们举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	//向内存申请空间
	int* p = (int*)calloc(10, sizeof(int));
	int* ptr = p;
	if (p == NULL)
		return 1;

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 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

注意：

这次p没有改变，还是指向开辟空间的起始位置，所以释放空间，是从开辟空间起始位置开始释放。
malloc free和calloc free 都是成对出现

---

2.3、realloc

• 为了让动态内存管理更加灵活，C语言还提供了一个函数：

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

注意事项：

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

下面我们举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	//向内存申请空间
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 1;

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
		printf("%d ", *(p + i));
	}

	//增加空间
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}

	//使用
	for (i = 10; i < 20; i++)
	{
		*(p + i) = 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

realloc函数在调试空间时，还会存在两种情况：

情况一：原有空间之后有足够大的空间
情况二：原有空间之后没有足够大的空间

1、当是情况一时，要扩展空间，就直接在原有内存空间之后追加空间，原来的空间数据不发生变化
2、当是情况二时，后续空间不够，扩展的方法是：在堆空间上再去找一个合适大小的连续空间，把原空间的数据拷贝到新空间里去，释放原空间，然后返回到新空间的起始位置。

---

三、常见的动态内存错误

1、NULL指针的解引用操作

void text()
{
	int* p = (int*)malloc(20);
	*p = 5;
}
1
2
3
4
5

一旦malloc函数开辟失败，就会返回NULL指针，我们无法知道malloc返回的是不是空指针，这里有可能会对NULL指针解引用操作，所以要对malloc返回值进行判断

void text()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
		return 1;
}
1
2
3
4
5
6

---

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

void text()
{
	//向内存申请空间
	int* p = (int*)malloc(20);
	if (p == NULL)
		return 1;

	//使用
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p + i) = 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

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

void test()
{
	int n = 10;
	int* p = #
	//释放
	free(p);
	p = NULL;
}
1
2
3
4
5
6
7
8

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

void test()
{
	//向内存申请空间
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 1;

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}

	//释放
	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

在释放的时候，p指向的不是动态内存空间的起始位置

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

void test()
{
	//向内存申请空间
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 1;

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	//释放
	free(p);
	free(p);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

若在释放之后把指针置为NULL，第二个free就不会产生效果。
free( p);
p = NULL;
free( p);

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

void text()
{
	int* p = (int*)malloc(40);
	if(NULL == p)
		return 1;
	return 0;
}
1
2
3
4
5
6
7

用函数申请动态内存空间，使用之后要释放指向该函数的空间

int* get_memory()
{
	int* p = (int*)malloc(40);
	return p;
}
int main()
{
	int* ptr = get_memory();
	//使用
	//释放
	free(ptr);
	ptr = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14