C语言 动态内存管理

引言

C/C++程序的内存开辟

1. 栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，所以有时候会出现栈溢出的情况。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区：一般由程序员分配、释放， 若程序员不释放，程序结束时可能由操作系统回收，分配方式类似于链表。

3. 数据段 ( 静态区 static ) 存放全局变量、静态数据，程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

声明

在我们平时写程序时，创建的变量都会在底层开辟内存。C语言 的内存布局分为三大块：栈区、堆区、静态区。其中栈区是我们平时使用最多的区域，栈区的使用习惯：先使用高地址处的空间，再使用低地址处的空间。然而栈区的使用总是有限的，所以本篇博客重点介绍如何使用堆区的内存。

一、动态内存管理函数

1. malloc 和 free

malloc - memory allocate - 分配一段连续的内存空间

void* malloc (size_t size);

// 返回值：申请内存成功，则返回开辟好空间的头指针；申请内存失败，则返回 NULL
// 参数：以字节为单位的申请值
1
2
3
4

free - 释放并回收内存

void free (void* ptr);

// 参数：ptr 为先前用 malloc、calloc 或 realloc分配的内存块的头指针
// 注意：一定要是头指针，而不是中间的指针，否则就会出现释放内存不干净的情况
1
2
3
4

使用示例

#include 
#include 

int main() {
	
	int* p = (int*) malloc(40); // 申请空间

	if (p == NULL) {
		// 内存分配失败的情况
		perror("malloc");
		return 1;
	}

	for (int i = 0; i < 10; i++) {
		*(p + i) = i; 		// 为刚刚开辟的空间放入值
	}

	free(p);				// free 将刚刚系统开辟的空间，再回收掉
	p = NULL;				// 为了防止 ptr 成为野指针，所以将其置成 NULL
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. calloc

calloc - 分配一段连续的内存空间并清零

calloc 函数 和 malloc 函数的使用思想基本相同，只不过前者在分配内存之后，又做了清零的步骤。

void* calloc (size_t num, size_t size);

// 返回值：申请内存成功，则返回开辟好空间的头指针；申请内存失败，则返回 NULL
// 参数：num 表示元素个数，size 表示每个元素的字节大小
1
2
3
4

使用示例

#include 
#include 

int main() {

	int* p = (int*) calloc(10, sizeof(int)); // 申请 10*4 = 40 个字节
	
	if (p == NULL) {
		perror("calloc");
		return 1;
	}

	for (int i = 0; i < 10; i++) {
		printf("%d ", *(p + i));
	}
	
	free(p); 	// 释放
	p = NULL;

	return 0;
}

// 输出结果：0 0 0 0 0 0 0 0 0 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. realloc

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

使用 realloc 再次申请分配内存的时候，需要指定重新开辟内存的字节总大小。假设我们之前使用 malloc / calloc 申请内存时，内存不够用了，realloc 就会派上用场。它可以做到很人性化地开辟内存。

情况①：当 malloc / calloc 申请的内存后面，有足够的空间再次扩充，realloc 就能够直接接着上次的位置，继续开辟。最终还是返回上一次开辟的原地址。

情况②：当 malloc / calloc 申请的内存后面，没有足够的空间再次扩充，realloc 也能够另起一块内存区域，将之前申请的内存中的数据也一并放入到新的内存区域中。此时最终返回的是新的地址。

使用示例

#include 
#include 

int main() {

	int* p = (int*) malloc(40);      // 1

	if (p == NULL) {
		perror("malloc");
		return 1;
	}

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

	int* ptr = (int*)realloc(p, 80); // 2
	if (ptr != NULL) { 				 // 3
		p = ptr;
	}
	
	free(p);						 // 4			
	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

// 1. malloc 申请分配内存。

// 2. 假设空间不够，使用 realloc 再次申请。

// 3. 由于内存有限，所以 realloc 也有可能申请内存失败，当失败的时候就会返回 NULL. 只有当 ptr 不为空的时候，才能够放入 p 中，这样就能保证 p 不受影响。

// 4. 释放内存

4. 注意事项

申请内存分配后，始终需要记得使用 free. 当我们不释放动态申请的内存的时候，如果程序结束，动态申请的内存由操作系统自动回收；但如果程序不结束，动态内存是不会自动回收的，就会形成内存泄露的问题，久而久之，内存就会被 " 耗干 "。

虽然现在的操作系统很智能，能够限制一些程序的内存使用，但还是建议标准化。

二、动态内存管理函数使用时的错误示范

程序清单1

动态内存申请失败，对 NULL 直接进行了解引用操作。

#include 
#include 
#include 

int main () {

	int* p = malloc(INT_MAX); // 申请失败
	*p = 100; // error

	free(p);
	p = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

程序清单2

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

#include 
#include 

int main() {

	int* p = malloc(40); // 开辟 40 个字节的内存
	if (p == NULL) {
		perror("malloc");
		return 1;
	}

	// 越界访问 41 ~ 44
	for (int i = 0; i < 11; 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
20
21

程序清单3

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

#include 
#include 

int main() {

	int a = 10;
	int* p = &a;

	free(p); // error
	p = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

程序清单4

free 释放不完整，或者 free 函数接收的指针不处于内存开辟的头部。

#include 
#include 

int main() {

	int* p = (int*) malloc(100);
	if (p == NULL) {
		perror("malloc");
		return 1;
	}

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

	free(p); // error
	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

从第 40 个字节后面开始释放内存，那么前面的内存就未被释放完。

程序清单5

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

#include 
#include 

int main() {

	int* p = malloc(100);

	if (p == NULL) {
		perror("malloc");
		return 1;
	}
	
	free(p);
	free(p); // error
	p = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

程序清单6

内存泄漏。

如下程序，在 test 函数中，即使我们写了 free，但最终走不到释放的代码，依然会存在内存泄漏的问题。所以说，free 代码的放置位置很关键，并不是写了 free 就一定能够释放动态内存。

#include 
#include 

void test() {
	int* p = (int*)malloc(100);
	if (1) {
		return;
	}

	free(p); // 代码走不到这一行
	p = NULL;
}

int main() {

	test();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

三、经典的内存笔试题

程序清单1

#include 
#include 
#include 

void getMemory(char* p)
{
	p = (char*) malloc(100);
}

int main() {

	char* str = NULL;
	getMemory(str);
	strcpy(str, "hello world"); // 对空指针解引用

	printf(str);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

分析：

在 getMemory 函数中，在堆区申请了 100 个字节的内存大小，之后我们可以通过指针 p 来找到这些内存。然而，在主函数中，str 始终为 NULL. 也就是说，str 并没有指向任何一块区域，所以后面在使用 strcpy 函数的时候，" hello world " 就不能成功拷贝。

这题错误的主要原因就是 str 为实参，p 为形参，对形参的操作不影响实参。

程序清单2

#include 
#include 
#include 

void getMemory(char** p, int num)
{
	*p = (char*) malloc(num); // 相当于 str 指向了开辟的 100 个字节的空间
	// *(&str) <==> str = (char*) malloc(100); 
}

int main() {

	char* str = NULL;
	getMemory(&str, 100);
	
	strcpy(str, "hello");
	printf(str);

	free(str); 			
	str = NULL; 		

	return 0;
}

// 输出结果： hello
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

分析：

程序清单2 算是 对 程序清单1 的优化，在 getMemory 函数中，当我们传过去的是 str 的地址时，再次对二级指针解引用，就相当于能够通过 str 直接找到开辟的内存。上面的程序没有问题，但是我们也不要忘记 free 来帮助系统回收内存了。

程序清单3

#include 
#include 
#include 

char* getMemory()
{
	char p[] = "hello world";
	return p;
}

int main() {

	char* str = NULL;
	str = getMemory();
	printf(str);

	return 0;
}

// 输出结果：随机值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

分析：

数组 p 在栈区开辟了内存，但出了 getMemory 函数后，数组中之前所占用的空间就被操作系统销毁了，也就是说，刚刚栈区的内存还给了系统，现在出了函数后，即使知道这块内存的地址，但已经没有权限再次使用这块区域了。因为数组 p 是一个临时的局部变量。

p 表示数组的首元素地址，假设 p 的地址为 0x11223344，那么出了 getMemory 函数后，现在 0x11223344 指向的内存可能已经被其他数据占用了。所以在主函数中，当 str 再次指向 0x11223344，找到的就是一些随机存放的数据。

程序清单4

#include 

int* test() {

	int a = 10;
	return &a;
	// 出了 test 函数，a 的地址将被系统回收
}

int main() {

	int* p = test();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

程序清单4 和 程序清单3 的错误思想基本相同，这是典型的 【返回栈空间地址、野指针】的问题。a 的地址出了 test 函数后，就需要被回收，所以后续在主函数中，指针 p 就没有权限去操作这块内存区域。

为什么栈区的地址最后需要被回收？
答：因为函数和局部变量在使用时，需要在栈区开辟内存，当用完了，如果不被回收，那么操作系统的内存迟早要被耗尽。

举个例子：这就和住酒店一样，当 旅客 A 租完了房子，房子就需要打扫干净，腾出来给后面的 旅客B / 旅客C / 旅客D… 使用。否则，房子永远不够后面的旅客使用。如果 旅客A 前脚刚走，旅客B 就住进去了，那么这个房子暂时属于 旅客B 的，假设 旅客A 发现自己手机留在了刚刚的房子忘拿了，那么 旅客A 就需要和前台报备一下，如果 旅客A 直接冲进去了刚刚的房子找手机，旅客B 就会告他非法访问。

程序清单5

#include 

void test(){

	char* str = (char*) malloc(100);
	strcpy(str, "hello");
	free(str);
	
	if (str != NULL){				
		// 野指针，非法操作
		strcpy(str, "world");
		printf(str);
	}
}

int main() {

	test();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上面的代码依旧是野指针问题，当 malloc 开辟的堆区内存区域被 free 回收之后，str 指向的地址依旧是刚刚申请的头部地址，但此时却没有了操作这块内存的权限。所以将 " world " 字符串放入 str 指向的区域，最终就会造成非法访问。

综上所述，我们应该在 free 的后面添加如下代码：

str = NULL; // 防止 str 成为一个野指针
1