C语言学习系列-＞动态内存管理

前言

要想学好数据结构，在C语言学习过程中就需要把指针、结构体和动态内存管理学好。在前面的文章，小编已总结了指针和结构体，本篇水文 小编为大家整理了一下C语言中的动态内存管理。

概述

已经掌握了开辟空间，为什么还要有动态内存分配？

int a=1;    //申请4个字节
char c='g';     //申请1个字节
int arr[30]={0};   //申请120个字节
1
2
3

这些申请好了之后，空间大小就是固定的，不能再去做调整，并不能满足实际生活需要。

long long ago 我们说过变长数组，变长数组的大小可以由变量来指定，但是一旦创建好之后，依然还是不能调整大小，而且只适用于C99中。

总的来说，申请的空间大小不能灵活调整。

因此，在C语言中：动态内存管理就给了程序员一个权限，自己申请，自己使用，使用完自己释放。

🚩malloc and free

🔜malloc

malloc是C语言中的动态内存开辟函数：

头文件：stdlib.h

malloc申请函数是在堆区上申请的

void* malloc (size_t size);
1

Allocates a block of size bytes of memory, returning a pointer to the
beginning of the block.

The content of the newly allocated block of memory is not initialized,
remaining with indeterminate values.

If size is zero, the return value depends on the particular library
implementation (it may or may not be a null pointer), but the returned
pointer shall not be dereferenced.

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

code

#include 
#include 
#include 
#include 

int main()
{
	//申请10个整型空间，即40个字节
	int *p = (int*)malloc(10 * sizeof(int));
	//开辟失败
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//开辟成功，则使用空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;   //0 1 2 3 4 5 6 7 8 9 
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", 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
23
24
25
26
27
28
29

🔜free

开辟完内存后，在结束后需要释放

有两种释放方式：
1.free
2.程序结束后，操作系统自己释放

void free (void* ptr);
1

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

code

#include 
#include 
#include 
#include 

int main()
{
	//申请10个整型空间，即40个字节
	int *p = (int*)malloc(10 * sizeof(int));
	//开辟失败
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//开辟成功，则使用空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;   //0 1 2 3 4 5 6 7 8 9 
	}
	//打印
	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

free( p ) 仅仅是把 p 指针指向的这块空间归还给了操作系统

free只能释放动态申请的空间

🚩calloc and realloc

🔜calloc

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

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

code

#include 
#include 
int main()
{
	int *p = (int*)calloc(10, sizeof(int));
	if(NULL != p)
	{
		int i = 0;
		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

输出结果

0 0 0 0 0 0 0 0 0 0
1

如果我们对申请的内存空间的内容要求初始化，那么可以很⽅便的使⽤calloc函数来完成任务。

🔜realloc

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

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

• ptr 是要调整的内存地址
• size 调整之后新⼤⼩
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到 新 的空间。
• realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有⾜够⼤的空间
情况2：原有空间之后没有⾜够⼤的空间

情况1
当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。
情况2
当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。

code

#include 
#include 
int main()
{
	int *ptr = (int*)malloc(100);
	if(ptr != NULL)
	{
		//业务处理
	}
	else
	{
		return 1;
	}
	//扩展容量
	//代码1 - 直接将realloc的返回值放到ptr中
	ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
	//代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
	int*p = NULL;
	p = realloc(ptr, 1000);
	if(p != NULL)
	{
		ptr = p;
	}
	//业务处理
	free(ptr);
	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