C语言进阶：动态内存管理_内存释放不置空

常见的动态内存错误

1.不检查空指针

void test() {
	int\* p = (int\*)malloc(INT_MAX / 4);
	\*p = 20;
	free(p);
}

1
2
3
4
5
6

对指向动态开辟的空间的指针一定要做有效的判断。

2.越界访问

void test() {
	int i = 0;
	int\* p = (int\*)malloc(10 \* sizeof(int));
	if (NULL == p) {
		exit(EXIT_FAILURE);
	}
	for (int i = 0; i <= 10; i++) {
		\*(p + i) = i;
	}
	free(p);
    p = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

作为程序员必须有意识地检查所写的代码是否有越界访问的问题。

3.释放非动态开辟内存

void test() {
	int a = 10;
	int\* p = &a;
	free(p);
    p = NULL;
}

1
2
3
4
5
6
7

不可用free释放非动态开辟的空间。

4.释放部分内存

int main()
{
	int\* p = (int\*)malloc(100);
	p++;
	free(p);
	return 0;
}

1
2
3
4
5
6
7
8

改变指向动态开辟内存的指针，内存将无法管理。释放不完全导致内存泄漏。

5.重复释放内存

void test() {
	int\* p = (int\*)malloc(100);
	free(p);
	free(p);
}

1
2
3
4
5
6

使用free释放已释放的空间，即访问非法内存。建议释放内存和指针置空搭配使用。

6.忘记释放内存

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

1
2
3
4
5
6
7
8
9
10
11

使用结束不释放内存造成内存泄漏。程序不停止，系统也不会自动回收。

笔试题

调用下列test函数，解释运行结果。

Example 1

void GetMemory(char\* p) {
	p = (char\*)malloc(100);
}
void test() {
	char\* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
    free(str);
    str = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12

程序报错。

传值调用：并没有改变str的值仍为不予修改的空指针，可以使用二级指针接收str的地址。函数调用结束后指针销毁故无法释放空间以致内存泄漏。

Example 2

char\* GetMemory() {
	char p[] = "hello world";
	return p;
}
void test() {
	char\* str = NULL;
	str = GetMemory();
	printf(str);
    free(str);
    str = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12

程序打印随机值。

返回栈空间地址：数组p在函数内创建，出函数销毁，返回这部分空间的地址 ，属于访问非法空间。

Example 3

void GetMemory(char\*\* p,int num) {
	\*p = (char\*)malloc(num);
}
void test() {
	char\* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
	free(str);
    str = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12

程序运行成功，打印"hello"。

传址调用：本题是例一的正确写法。

Example 4

void test(void) {
	char\* str = (char\*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL) {
		strcpy(str, "world");
		printf(str);
	}
}

1
2
3
4
5
6
7
8
9
10

程序报错。

野指针：动态开辟的内存释放后指针不置空，造成野指针访问非法内存。释放内存和指针置空应该搭配起来使用。

释放空间，销毁空间都是将内存空间归还给操作系统，即将此空间的使用权限归还操作系统。虽不会改变空间内容以致打印出所谓的“正确结果”，但可能在之后被操作系统分配给其他程序时发生修改。但无论改变与否，一旦空间归还后再去访问就是访问非法内存。

C/C++内存划分

用例展示

根据下列创建的各种变量，分析内存的划分。

int globalVar = 1;
static int staticGlobalVar = 1;
int main()
{
	static int staticVar = 1;
	
	int localVar = 1;
	int num1[10] = { 1,2,3,4 };
	char char2[] = "abcd";
	char\* pChar3 = "abcd";
	int\* ptr1 = (int\*)malloc(4 \* sizeof(int));
	int\* ptr2 = (int\*)calloc(4, sizeof(int));
	int\* ptr3 = (int\*)realloc(ptr2, 4 \* sizeof(int));

	free(ptr1);
	free(ptr3);
	return 0;
}

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

1. globalVal,staticGobalVar,staticVar分别是全局变量和静态变量，在数据段上创建。
2. localVar和num,char2,pchar以及ptr本身都是局部变量，都是在栈区上创建的。
3. malloc,calloc,realloc都是在堆区上开辟的内存块，由指针ptr指向而已。

内存划分图示

1. 栈区（stack）：执行函数时，函数的局部变量都会在栈区上创建。压栈：从栈顶向下开辟空间，弹栈：从栈底向上释放空间。
2. 堆区（heap）：一般由程序员分配和释放，从堆低向上开辟空间，堆顶向下释放空间。在程序结束后也被操作系统会自动回收。
3. 数据段（静态区）：存放全局变量，静态数据。变量本在栈上创建，被static修饰后放在常量区，程序结束后由系统释放。
4. 代码段（常量区）：存放可执行代码和只读常量。

语言学习时期，仅对内存作此了解即可。内核空间和内存映射段会在操作系统中学习，此处不再深入研究。

柔性数组

C99中引入柔性数组。柔性数组（flexible array）面试中虽不是重要的考点，但仍需掌握最基本的使用。

柔性数组的定义

在C99中，结构中最后一个元素允许是未知大小的数组，被称为柔性数组成员。例如：

//1.
struct st\_type {
	int i;
	int a[0];//柔性数组成员
};
//2.
struct st\_type {
	int i;
	int a[];//柔性数组成员
};

1
2
3
4
5
6
7
8
9
10
11

语法规定数组大小中写0和不写都代表不指定大小。意味数组可大可小，这便是柔性的含义。

有些编译器可能只支持一种写法。当然柔性数组前必须有其他成员，类型一致是为了避免考虑内存对齐。既然把柔性数组放在动态内存管理一章，可见二者有必然的联系。

柔性数组的特点

• 结构中柔性数组成员前必须至少有一个成员。
• sizeof计算结构所占空间时不包含柔性数组的大小。
• 包含柔性数组的结构用malloc进行动态内存分配，且分配的内存应大于结构大小，以满足柔性数组的预期。

使用含柔性数组的结构体，需配合以malloc等动态内存分配函数。分配空间减去其他成员的大小，即为为柔性数组开辟的空间。

柔性数组的使用

malloc开辟的大小写成如图所示的形式，增加代码的可阅读性。

结构体所分配空间减去其他成员的大小，所剩即为为柔性数组开辟的空间大小，若不够还可以用realloc调整大小，以满足柔性数组“柔性”的需求。

struct st\_type {
	int i;
	int a[0];
};
int main() {
	printf("%d\n", sizeof(struct st\_type));
	//1.
	struct st\_type st;
	//2.
	struct st\_type\* pst = (struct st\_type\*)malloc(sizeof(struct st\_type) + 10 \* sizeof(int));
	if (pst == NULL) {
		perror("pst");
		return -1;
	}
	return 0;
}

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

含柔性数组结构体当然不可像第一种那样使用，这样结构体变量st仅有4个字节，不包含柔性数组。

Example

struct st\_type {
	int i;
	int a[0];
};
int main() {
	struct st\_type\* pst = (struct st\_type\*)malloc(sizeof(struct st\_type) + 10 \* sizeof(int));
	if (pst == NULL) {
		perror("pst");
		return -1;
	}
	pst->i = 10;
	for (int i = 0; i < 10; i++) {
		printf("%d ", pst->a[i] = i);
	}
	//调整空间大小
	struct st\_type\* ptr = (struct st\_type\*)realloc(pst, sizeof(struct st\_type) + 20 \* sizeof(int));
	if (ptr == NULL) {
		perror("ptr");
		return -1;
	}
	pst = ptr;
	for (int i = 10; i < 20; i++) {
		printf("%d ", pst->a[i] = i);
	}
	//释放
	free(pst);
	pst = 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

柔性数组的优势

柔性数组成员利用动态内存可大可小，那同样将柔性数组成员替换成指向动态开辟内存的指针也可达到同样的效果。下文将对比二者都有何优劣。（为突出对比，已省略不必要的代码）

柔性数组版本

struct st\_type {
	int i;
	int a[];
};
int main() {
	struct st\_type\* pst = (struct st\_type\*)malloc(sizeof(struct st\_type) + 10 \* sizeof(int));
	for (int i = 0; i < 10; i++) {
		printf("%d ", pst->a[i] = i);
	}
	//调整空间大小
	struct st\_type\* ptr = (struct st\_type\*)realloc(pst, sizeof(struct st\_type) + 20 \* sizeof(int));
	pst = ptr;
	for (int i = 10; i < 20; i++) {
		printf("%d ", pst->a[i] = i);
	}
	//释放
	free(pst);
	pst = NULL;	
	return 0;


**（1）Python所有方向的学习路线（新版）**  

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。



![在这里插入图片描述](https://img-blog.csdnimg.cn/1f807758e039481fa866130abf71d796.png#pic_center)



**（2）Python学习视频**



包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

![在这里插入图片描述](https://img-blog.csdnimg.cn/d66e3ad5592f4cdcb197de0dc0438ec5.png#pic_center)



**（3）100多个练手项目**

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

![在这里插入图片描述](https://img-blog.csdnimg.cn/f5aeb4050ab547cf90b1a028d1aacb1d.png#pic_center)




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里无偿获取](https://bbs.csdn.net/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57