C语言进阶笔记(动态内存管理)

1.内容一览图

2.为什么要使用动态内存分配？

我们已经知道的开辟方式：在栈上开辟空间
int a = 10;//在栈上开辟4个字节
int arr[4] = {0,1,2,3,4};//在栈上开辟4个4个字节的连续的空间。
但是大家想一想，开辟的空间我们是否会全部用完，用不完是不是就等于空间浪费，而且影响代码执行效率，在栈上开辟的空间是固定的。
还有一种就是用些情况向要在代码执行的/过程中，动态开辟空间。这样在栈上是做不了的。
所以为了更好地分配空间，所以要使用动态内存分配。
数据在内存中的存储情况：

3.动态内存函数介绍

1.malloc

✒️void * malloc(szie_t szie)

这是C语言提供的一个动态内存函数
size_t szie :表示分配空间得大小
void*:表示要返回一个地址
头文件：stdlib.h
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针.
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自
己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器

2.free

C语言提供了另外一个函数专门用来做 动态内存释放和回收的。
✒️ void free(void*ptr)
free函数用来释放动态开辟的内存。
如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的。
如果参数ptr是空指针，那么free函数什么都不做
malloc和free函数都声明在strlib.h文件中

代码演示

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(sizeof(int) * 10);//申请10个动态空间
	//做判空处理
	if (p == NULL)
	{
		perror("main");
		return;
	}
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

运行结果：

3.calloc

calloc函数也是C语言提供的一个动态内存分配函数
✒️ void* calloc(szie_t num,szie_t size)
szie_t num:表示的是分配空间得个数
szie_t size:表示的是一个具体类型占的大小
函数功能：是为num个大小为szie的元素开辟一块空间，并且把空间得每一个字节初始化为0
与函数malloc比较，calloc函数只是在返回地址之前把申请空间上的每一个字节都初始化为0

代码演示：

 #include <stdio.h>
 #include <stdlib.h>
int main()
{
    //动态申请10个int类型的空间，并且把每个字节初始化为0
	int* p = (int*)calloc(10,sizeof(int));
	//做判空处理
	if (p == NULL)
	{
		perror("main");
		return;
	}
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

运行结果：

注：malloc和calloc函数的区别：
1.函数参数不同
malloc不会对字节进行初始化
calloc对字节进行初始化，其他两个函数的功能一致

4.realloc

realloc函数的出现使动态分配变得灵活
有时我们会发现过去生情的空间太小了，有时申请的空间太大了，那么为了合理利用空间，我们一定对内存的大小进行灵活的调整，realloc函数可以做动态内存的调整
✒️ void *realloc(void *ptr,szie_t size)
ptr是调整内存的空间
szie:调整之后的大小
返回值为调整之后内存的起始位置
这个函数在调整原来空间的基础上还会将原来的内存中的数据移动到新的空间
如果realloc函数的第一个参数为空即NULL,这个函数就等同与malloc函数，并且功能一致
realloc函数在调整内存空间有两种情况：
情况一：原有空间之后有足够大的空间
情况二：原有空间之后没有足够大的空间

代码演示

 #include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(4 * sizeof(int));//开辟4个int类型的内存空间
	if (p == NULL)//做判空处理，当内存开辟失败时，就直接返回，结束程序
	{
		perror("main");
		return;
	}
	else
	{
		int* ptr = (int*)realloc(p,10*sizeof(int));//再动态开辟10个int类型的内存空间
		if (ptr != NULL)//确保开辟空间成功
		{
			p = ptr;
		}
		else
		{
			return;
		}
	}
	//打印10个int类型的数字，如果不又开辟空间内存就会溢出
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

运行结果：

4.一些常见的动态内存分配错误

📣 对NULL 指针的解引用操作
空指针是没有任何指向的指针，不能对它进行任何操作，比如解引用，乘除运算，任何的操作都是不合法的。在malloc开辟内存空间后，可能会造成空间开辟失败，这时malloc会返回NULL指针，所以要对指向开辟空间的指针进行判空

 void test()
{
	int *p = (int *)malloc(INT_MAX/4); //开辟内存空间
	//如果做判空处理，就对了
	if(p == NULL)
	{
	   perror("test");//如果开开辟内存失败，把错误码转化成错误信息并且打印
	   return;
    }
	*p = 20;//如果p的值是NULL，就会有问题
	free(p); //释放开辟的空间
}

📣 对动态开辟空间的越界访问
其实很简单，它和在静态数组中，比如说在栈上开辟的空间较小时，但是要利用更多的访问元素，显然开辟的空间不够，这样就会造成越界访问，而这个是在堆上开辟空间，一样的思想

 #include <stdio.h>
 #include <stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));//申请10个整形空间
	if (p = NULL)
	{
		perror("main");//当p为空时，打印错误信息
		return;
	}
	int i = 0;
	//开辟了10个整形空间，但是要访问20个整形，显然会造成访问越界
	for (i = 0; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

📣 对非动态开辟的空间进行free操作
非动态开辟空间，也就是静态开辟空间，在栈上开辟，free是用于在堆上释放空间，所以说用堆上释放空间的函数来释放栈是的空间，这显然是不合法的

 void test()
{
	int a = 10; //在栈上开辟一个整形空间
	int *p = &a;
	//在堆上释放空间
	free(p);//error
}

📣 使用free释放一块动态空间得一部分
p一定要指向开辟空间的起始位置，这样才能释放整个动态开辟的空间，如果在指针在使用中，发生了移动，就会指向非起始地址，起始地址就会被忽略，就会造成释放部分空间，这样的操作是不合法的，会造成内存泄漏

 void test()
{
	int *p = (int *)malloc(100);//动态申请了100个字节空间
	p++;//指针移动，起始地址被忽略，p不再指向起始空间
	free(p); 
	//free不能只释放空间的一部分
	//如果要释放空间，就必须把空间全部释放
}

📣 对同一块内存进行多次释放
这种错误我们一般不会犯，但是程序一旦复杂时，难免也会出现
对开辟的空间释放一次就行了，并且及时把指针设为NULL

 void test()
{
	int *p = (int *)malloc(100);
	free(p);
	//必须对p = NULL，以免程序后面再次利用
	free(p);//重复释放
}

📣 动态开辟内存忘记释放(内存泄漏)
动态内存释放有两种方式：一种是手动释放，一是程序结束自行释放，但是如果是在大型的服务器上，程序不可能短时间结束，忘记释放空间，就会造成内存泄漏，想一想每次泄漏一点，内存就会有时候就会被占满

 void test()
{
	int *p = (int *)malloc(100);
	if(NULL != p)
	{
		*p = 20;
	}
	//忘记释放开辟好的空间，造成内存泄漏
}
int main()
{
	test();
	while(1);
}

5. 面试题

📌ps:先看代码奥，想想它是否是对的，错了又错到哪了
📃 题目一

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

代码错误：
❌没用释放开辟的空间，造成内存泄漏
❌对空指针的使用

改为正确代码：
🚩方法一：

 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory(char* p)
{
	p = (char*)malloc(100);//申请空间，做判空处理，并且返回指向开辟空间的指针
	if (p == NULL)
	{
		return;
	}
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory(str);//str接受返回来的地址
	strcpy(str, "hello world");//在申请的100个字节空间里，拷贝字符串
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
}

运行结果：

方法二：
🚩传地址

 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory(char** p)
{
	*p = (char*)malloc(100);
	return *p;
}
void Test(void)
{
	char* str = NULL;
     GetMemory(&str);//，传地址，向函数中传一级指针的地址
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
}

📃题目二：

 char *GetMemory(void)
{
	char p[] = "hello world";//在栈上开辟空间
	return p;//出了函数作用域后，空间就会被还给操作系统
}
void Test(void)
{
	char *str = NULL;
	str = GetMemory();//返回指针，没用实际意义
	printf(str);
}

代码错误：
❌静态开辟的空间是在栈上开辟的，处理函数作用域就会自行销毁，把申请的空间还给操作系统，在堆上动态开辟空间，要么手动free释放空间，要么程序结束自行销毁。所以返回这个指针p是没有实际意义的。

📃 题目三：

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

代码错误:
❌ 看上去好像没用错呀，但是我们却忘记了最重要的一点，就是动态空间，要手动开辟手动释放，代码中缺少free释放开辟的空间

🚩修改代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.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);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

运行结果:

📃题目四：

 void Test(void)
{
	char *str = (char *) malloc(100);
	strcpy(str, "hello");
	free(str);//都已经释放了str，已经把开辟的空间换给了操作系统，
	//str != NULL 再次访问这个空间，就造成了非法访问
	if(str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

代码错误：
❌ 要释放开辟的空间，就必须用free释放后,并且把指针设置为NULL,这两个是不可分割的，因为free只释放掉了空间， str里还存储着开辟空间得首地址，free不会释放掉里面的内容
📃题目五：

 int test (void)
{
	int x = 10;
	return (&x);
}

代码错误：
❌静态开辟空间是在栈上开辟的，其地址一旦出了作用域后就会被还给操作系统
📃题目六

 int test(void)
{
	int *x;
	*x = 10;
	return x;
}

❌指针为被初始化，指针x为野指针，指向内存中未知的空间。

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

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

有了这幅图，我们就可以更好的理解static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长

7.柔型数组

📌也许你从来都没有听说过柔型数组这个概念，但是它的确存在，在c99中，结构体最后一个成员允许是未知大小的数组，这就被成为柔型数组。

 typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

柔型数组的功能：在使用数组空间时，能够动态的申请空间，改变数组的大小。
柔型数组的特点：

• 结构体成员中的柔型数组成员前面必须有一个其他成员。
• sizeof计算结构体大小时，不包括柔型数组成员大小
• 包含柔型数组成员的结构体用malloc函数进行动态内存分配，并且分配的空间大小应该大于结构体的大小，以适应柔型数组的预期大小。

 #include <stdio.h>
struct stu
{
	int a;
	int arr[];//柔型数组成员
};
int main()
{
	struct stu u;
	printf("%d", sizeof(u));//运行结果为4
	return 0;
}

柔型数组的使用：

 #include <stdio.h>
#include <stdlib.h>
typedef struct stu
{
	int a;
	int arr[];
}s;
int main()
{
	//要开辟10个整形的空间
	s* p = (s*)malloc(sizeof(s) + sizeof(int) * 10);
	if (p == NULL)
	{
		perror("main");
		return;
	}
	p->a = 10;
	//再增加5个整形空间
	s* ptr = (s*)realloc(p, sizeof(s)+sizeof(int) * 15);
	if (ptr != NULL)
	{
		p = ptr;
	}
	else
	{
		perror("main");
		return;
	}
	int i = 0;
	for (i = 0; i < 15; i++)
	{
		p->arr[i] = i;
	}
	for (i = 0; i < 15; i++)
	{
		printf("%d ", p->arr[i]);
		//打印结果：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
	}
	free(p);//释放开辟内存
	p = NULL;
	return 0;
}

🙋但是有些兄弟说不使用柔型数组也行呀，那就让我们比较一下，两者的优势

#include <stdio.h>
#include <stdlib.h>
typedef struct stu
{
	int a;
	int *arr;
}s;
int main()
{
	//开辟一个int型空间
	s* ps = (s*)malloc(sizeof(s));
	if (ps == NULL)
	{
		perror("main");
	}
	ps->a = 10;
	//设置10个整形空间
	ps->arr = (int*)malloc(sizeof(int) * 10);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	//数组
	//现在增添15个整形空间
	int* ptr = (int*)realloc(ps->arr, sizeof(int) * 15);
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	else
	{
		perror("main");
		return;
	}
	for (i = 0; i < 15; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 15; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	free(ps->arr);
	ps->arr= NULL;
	free(ps);
	ps = NULL;
	return 0;
}

✏️上面的代码1和代码2可以实现相同的功能，但是方法1实现用两个好处
**🎑第一个好处就是：**便于内存释放，并且在开辟柔性数组成员时，和不是柔型数组人员的部分，一块开辟空间，一块释放空间，这样有利于代码的可读性，和可理解性，、
**🎑第二个好处就是：**有利于访问速度，连续的内存有益于提高访问速度，也有利于减少内存碎片

🍺大佬们看完不要忘记点👍加关注哟。