驾驭代码的无形疆界:动态内存管理揭秘

目录

1.:为什么要有动态内存分配

2.malloc和free

2.1:malloc

 2.2:free

3.calloc和realloc

3.1:calloc

3.1.1:代码1(malloc)

3.1.2:代码2(calloc)

3.2:realloc

3.2.1:原地扩容

3.2.2:异地扩容

3.2.3:代码1(原地扩容)

3.2.3:代码2(异地扩容)

4:常见的动态内存的错误

4.1:对NULL指针的解引用操作

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

4.3:对非动态开辟的内存使用free释放

4.4:使用free释放动态开辟内存的一部分

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

4.6:对动态内存忘记释放(内存泄漏)

5:动态内存经典笔试题分析

5.1:题目1(问运行test函数有什么样的结果)

5.1.1:改法1:传二级指针

5.1.2:改法2:以return的形式返回

5.2:题目2(问运行test函数有什么样的结果)

5.3:题目3(问运行test函数有什么样的结果)

5.3.1:修改后

5.4:题目4(问运行test函数有什么样的结果)

5.4.1:修改后

6:C/C++程序的内存开辟区域划分

---

嘿嘿,uu们, 今天咱们来详细剖析动态内存管理,好啦,废话不多讲,开干！

---

1.:为什么要有动态内存分配

通过之前的学习,我们已经掌握的内存开辟方式有

//在栈区上开辟四个字节.
int value = 25;
//在栈空间上开辟40个字节的连续空间.
int arr[10] = {0};

但是上面的开辟空间的方式有两个特点:

1.空间开辟大小是固定的.

2.在C99之前,数组在声明的时候，必须指定数组的长度，数组空间⼀旦确定了大小不能调整

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候 才能知道,那么数组的编译时开辟空间的⽅式就不能满足了.

那么C语言引入了动态内存开辟,让我们能够自己开辟和释放空间,这样子的话,就相对来讲比较灵活了.

2.malloc和free

2.1:malloc

C语言提供了一个动态内存开辟的函数, 我们首先来看看官方的解释

void* malloc (size_t size);

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

​​​​​1: 如果开辟成功,则返回⼀个指向开辟好空间的指针.

2: 如果开辟失败,则返回⼀个NULL指针, 因此malloc的返回值⼀定要做检查。

3:返回值的类型是 void*, 所以malloc函数并不知道开辟空间的数据类型，因此具体在使⽤的时候由使用者自己来决定.

4:如果参数 size 为0,malloc的⾏为是标准是未定义的,取决于编译器.   

 2.2:free

当我们自己向内存空间申请了空间后,在使用完后要对其进行释放与回收,那么C语言提供了另外一个函数free,专门用来针对动态内存的释放与回收的.

void free (void* ptr);

free函数⽤来释放动态开辟的内存。

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

如果参数 ptr 是NULL指针,那么该函数什么事都不做.

PS:malloc和free在使用时需要包含stdlib.h头文件.

了解了malloc和free函数后,我们来看个例子.

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//申请一块空间,用来存放10个整型*/
	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];
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}

	/*
	* 由于p指针还会指向原本的地址,此时如果不赋为空指针的话, 那就是野指针了
	* 释放ptr所指向的动态内存
	*/
	free(p);
	p = NULL;
	return 0;
}

3.calloc和realloc

3.1:calloc

C语言还提供了一个函数叫做calloc，calloc函数也可以用来进行动态内存分配,我们来看看其原型

 void* calloc (size_t num, size_t size);

第一个参数是:元素的个数.

第二个参数是:元素占据内存空间的大小. 

• 该函数的功能是为num个大小为size的元素开辟一块空间,并且把空间的每个字节都初始化为0.
• 与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0.        

了解了calloc函数后,我们来看个例子

3.1.1:代码1(malloc)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//申请一块空间,用来存放10个整型*/
	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];
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}

	/*
	* 由于p指针还会指向原本的地址,此时如果不赋为空指针的话, 那就是野指针了
	* 释放ptr所指向的动态内存
	*/
	free(p);
	p = NULL;
	return 0;
}

3.1.2:代码2(calloc)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//申请一块空间,用来存放10个整型*/
	int* p = (int*)calloc(10,4);
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		//p[i];
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}

	/*
	* 由于p指针还会指向原本的地址,此时如果不赋为空指针的话, 那就是野指针了
	* 释放ptr所指向的动态内存
	*/
	free(p);
	p = NULL;
	return 0;
}

3.2:realloc

• realloc函数的出现让动态内存管理更加灵活
• 有时候我们会发现过去申请的空间过小或者过大了,那么为了合理的分配内存,我们就会对内存的大小做出灵活的调整.那么realloc函数就可以对动态开辟的内存进行调整.

• 第一个参数ptr为要调整的起始内存地址.
• 第二个参数size为调整之后新大小.
• 返回值为调整之后的内存起始地址.
• realloc函数在调整原内存空间大小的基础上,还会将原来内存中的数据拷贝到新的空间.
• realloc在调整内存空间存在两种情况
  • First:原有空间有足够大的空间那么会原地扩容.
  • Second:原有空间之后没有足够的空间,那么会异地扩容.

3.2.1:原地扩容

当是情况1的时候,要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

3.2.2:异地扩容

当是情况2的时候,原有空间之后没有⾜够多的空间时,扩展的方法是:在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是⼀个新的内存地址.

综合上述的两种情况,那么realloc函数的使用就要略微注意一些.

3.2.3:代码1(原地扩容)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = calloc(10, sizeof(int));
	if (NULL == p)
	{
		perror("molloc");
		return 1;
	}
	printf("\n");
	/*
	* 原有空间足够则在原有的空间进行扩展
	* 如果原有空间后面的空间不足够,则realloc函数会在堆区重新开辟一块足够的空间
	*/
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	return 0;
}

3.2.3:代码2(异地扩容)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = calloc(10, sizeof(int));
	if (NULL == p)
	{
		perror("molloc");
		return 1;
	}
	printf("\n");
	/*
	* 原有空间足够则在原有的空间进行扩展
	* 如果原有空间后面的空间不足够,则realloc函数会在堆区重新开辟一块足够的空间
	*/
	int* ptr = (int*)realloc(p, 1000 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	return 0;
}

4:常见的动态内存的错误

4.1:对NULL指针的解引用操作

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	//不对返回值作判断,就可能使用NULL指针,对空指针进行解引用
	int* p = (int*)malloc(INT_MAX);
	*p = 20;
	return 0;
}

上面的代码,由于动态开辟的内存过大,那么因此开辟空间是失败的,那么malloc开辟空间失败的话,就会返回NULL指针.那么此时再对其进行解引用操作的话,就会发生对NULL指针的解引用操作.

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

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = calloc(10, sizeof(int));
	if (NULL == p)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	//赋值
	for (i = 0; i <= 10; i++)
	{
		p[i] = i;
	}
	//打印
	for (i = 0; i <= 10; i++)
	{
		printf("%d ", *(p + i));
	}

	//释放
	free(p);
	p = NULL;
	return 0;
}

上述代码则发生对动态开辟空间的越界访问,在开辟空间的时候,是只开辟了数量为10个,大小为4字节的空间,但是在赋值和打印的时候,对第11个空间进行了访问,那么则发生了对动态开辟空间的越界访问.

4.3:对非动态开辟的内存使用free释放

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int a = 10;
	int* p = &a;

	//对非动态内存开辟进行释放
	free(p);
	p = NULL;
	return 0;
}

上面的代码则发生对非动态开辟的内存使用了free释放,指针变量p指向的是变量a,指向的区域是栈区,而动态开辟的内存是在堆区,因此发生了对非动态开辟的内存使用了free释放.

4.4:使用free释放动态开辟内存的一部分

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	//赋值
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	// 0 1 2 3 4 0 0 0 0
	//此时p指向第六个位置

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

上述的代码是发生了对动态开辟的内存只释放了一部分.

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

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = malloc(40);
	if (NULL == p)
	{
		return 1;
	}
	free(p);


	free(p);
	return 0;
}

上述代码则发生了对同一块动态内存多次释放,对于动态开辟的内存只能够释放一次,这就好比,我们日常去住酒店,当我们退了酒店房间后,是不能够再一次退酒店房间的.

4.6:对动态内存忘记释放(内存泄漏)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void test()
{
	int* p = (int*)malloc(40);
	if (3)
	{
		return;
	}
	free(p);
	p = NULL;
}

int main()
{
	test();
	return 0;
}

总结:忘记释放不再使用的动态开辟的空间会造成内存泄漏

切记:动态开辟的空间一定要正确释放.

5:动态内存经典笔试题分析

5.1:题目1(问运行test函数有什么样的结果)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void GetMemory(char* p)
{
	//这个形参出了函数之后就会被销毁外加返回类型为void
	//malloc开辟的空间没有释放,因此发生了内存泄漏
	p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	//发生对空指针的解引用操作,导致了程序崩溃
	strcpy(str, "hello world");
	printf(str);
}

int main()
{
	Test();
	return 0;
}

5.1.1:改法1:传二级指针

//改法1
 #define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//传址调用,因此使用二级指针
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	//进行传址调用
	GetMemory(&str);
	//发生对空指针的解引用操作,导致了程序崩溃
	strcpy(str, "hello world");
	//打印的时候,从字符串的首字符地址开始打印
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

5.1.2:改法2:以return的形式返回

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//改法2,以return返回的形式
char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	strcpy(str, "hello world");
	printf(str);
	//开辟了动态内存之后要进行释放并且置为NULL,因为此时str还会指向原本的地址,如果不放置为NULL,那就是野指针了
	free(str);
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

5.2:题目2(问运行test函数有什么样的结果)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
char* GetMemory(void)
{
	//为局部变量,出了函数就被销毁了
	 char p[] = "hello world";
	//返回的是地址值
	return p;
}
void Test(void)
{
	char* str = NULL;
	//str非法访问了空间,此时str为野指针
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

5.3:题目3(问运行test函数有什么样的结果)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//开辟的动态内存未进行释放,因此会发生内存泄漏
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

5.3.1:修改后

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//修改后
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;
}

int main()
{
	Test();
	return 0;
}

5.4:题目4(问运行test函数有什么样的结果)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void Test()
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");

	//释放了开辟动态内存空间后,指针str还是会指向原本的值,因此此时str为野指针
	free(str);

	if (str != NULL)
	{
		//对野指针的非法访问
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{
	Test();
	return 0;
}

5.4.1:修改后

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//修改
void Test()
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");

	/*
	* 释放了开辟动态内存空间后, 指针str还是会指向原本的值, 因此此时str为野指针,
	释放了以后要对其进行置NULL
	*/
	free(str);
	str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{
	Test();
	return 0;
}

6:C/C++程序的内存开辟区域划分

• 1.栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。 栈区主要存放运行函数⽽分配的局部变量、函数参数、返回数据、返回地址等。
• 2.堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
• 3. 数据段(静态区)：存放全局变量、静态数据。程序结束后由系统释放。
• 4. 代码段:存放函数体(类成员函数和全局函数)的⼆进制代码。

好啦,uu们,动态内存管理这部分滴详细知识博主就讲到这里啦,如果uu们觉得博主讲的不错的话,请动动你们滴小手给博主点点赞,你们滴鼓励将成为博主源源不断滴动力,同时也欢迎大家来指正博主滴错误~