BIT-5-动态内存

1.为什么存在动态内存分配

我们已经掌握内存开辟的方式 ：

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

上述的开辟空间的方式有两个特点：

1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
   即：内存是固定的；
   下面我们就来介绍一下：不固定的内存；

2.动态内存函数的介绍

2.1动态内存开辟的地址

2.2malloc和free

2.2.1malloc函数

size：是开辟内存的大小；
void*：是该内存的首地址；
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

1.如果开辟成功，则返回一个指向开辟好空间的指针。
2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。 （如开辟的空间太大使得开辟失败）
3.返回值的类型是void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己 来决定。
4.如果参数 size为0，malloc的行为是标准是未定义的，取决于编译器。

注意事项
判断开出创的内存的首地址的指针；是否为空；

2.2.2free函数

free函数用来释放动态开辟的内存。
ptr是释放内存(动态内存）的首地址；

1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。 即：free函数只可以释放动态内存）
2**.如果参数 ptr 是NULL指针**，则函数什么事都不做。

free的错误使用方法
1.使用free函数释放后指针的指向没有改变；这时这个指针变成了野指针；

free函数的正确使用方法

2.2calloc

num是开辟元素的个数，size是一个元素的内存大小；

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

和malloc函数相比，
1.calloc函数会在返回地址之前把申请的内存初始化为0;
2.两者相比，各有好处malloc可以提高效率，calloc可以初始化内存

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//创建
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用

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

2.3 realloc

使用条件：动态内存创建小了，导致内存不够；这时就可以使用realloc函数来添加内存空间；

void* realloc (void*ptr，size_t size)

ptr 是要调整的内存地址；size是调整后的新地址；返回值是调整内存的起始地址；

2.3.1函数的两种使用原理

1.（条件：原内存的空间不充足）内存直接在之前的动态内存中后添加内存；

2.**(条件：原内存的空间充足）**另开辟空间；

1.realloc寻找更大的空间；
2.将原来的数据拷贝到新的空间
3.释放旧空间（原来的地址空间将清空）
4.返回新空间的地址
内存创建失败：将返回一个NULL指针；

正确示范

int main()
{
	//创建
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int* pr = (int*)realloc(p, 80);
	if (pr != NULL)
	{
		p = pr;
	}
	else
	{
		return 1;
	}
	//释放
	free(p);
	p = NULL;
	return  0;
}

错误示范

错误原因：如果添加内存失败，将会返回一个NULL指针；原本的p指针将改变；
后面加的空间不赋初值

realloc函数模拟malloc函数

int *p=（int *)realoc(NULL,40);

该种使用方法效果和malloc函数完全相同；

小点：

malloc和calloc和realloc函数都需要使用free函数来释放；

动态内存的释放方法

1.使用free函数来释放
2.由操作系统来回收（即程序结束）

3.常见的动态内存错误

两种：
一种是指针
另一种是内存

3.1对NULL指针的解引用操作

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

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

3.4 使用free释放一块动态开辟内存的一部分

这种情况会出现警报；

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

3.6 动态开辟内存忘记释放（内存泄漏）

内存泄漏：不使用free函数释放，程序也不结束；（在该程序员的 函数范围内，他没有释放，别人也不知道）
例子：

避免方法：

自己释放，或告诉别人释放；

4.例题

4.1

void GetMemory(char *p)
{
 p = (char *)malloc(100);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(str);//这里是值传递
 strcpy(str, "hello world");
 printf(str);
}

4.2

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

4.3

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函数释放内存

4.4

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

str指针没有制为空指针
重点：
1.判断动态内存的返回指针；
2.释放内存；
3.制0空指针；

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

C/C++程序内存分配的几个区域：

1.栈区（stack）:在执行函数时，函数内部变量的储存单位都可以，函数执行结束这些储存单元自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，**但是分配的内存容量有限。**栈区主要存放运行的函数而分配的局部变量，函数参数，返回数据，返回地址等；
2.堆区：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS（即vs弹出的黑框)回收 。(将黑框关闭）分配方式类似于链表。
3.数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

6.柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。 C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

例如：

//1
struct p
{
	int p;
	int arr[];
//2
};
struct p
{
	int p;
	int arr[0];

};

6.1柔性数组的特点

1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

解释：
1.

2.

不占内存的原因是：数组固定的元素个数；
3.由于数组元素个数不确定，所以使用动态内存来实现内存的分配；

6.2 柔性数组的使用

//代码1
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{
 p->a[i] = i;
}
free(p);
p=NULL；

6.3柔性数组的优势

1.方便内存释放

柔性数组法

//柔性数组法
struct pa
{
	int p;
	int arr[];

};

int main()
{
	//创建
	struct pa* s =(struct pa*)malloc(sizeof(struct pa) + 10 * sizeof(int));
	if (s == NULL)
	{
		printf("创建失败");
		return 1;
	}
	//使用

	s->p = 12;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		s->arr[i] = i + 1;
	}
	struct pa* pr=realloc(s, sizeof(struct pa) + 20 * sizeof(int));
	if (s == NULL)
	{
		printf("扩建失败");
		return 1;
	}
	s = pr;
	//释放
	free(s);
	s = NULL;
	printf("%d", sizeof(struct pa));
	return 0;
}

结构中指针方案（实现结构体数组的同台变化）

//结构中指针方案
struct pa
{
	int a;
	int * p;

};
int main()
{
	//开辟
	struct pa* pr = (struct pa*)malloc(sizeof(struct pa));
	if (pr == NULL)
	{
		perror("内存开辟失败");
		return 1;
	}

	int* pc = (int*)malloc(20 * sizeof(int));
	if (pc == NULL)
	{
		perror("扩容失败");
		return 1;
	}
	pr->p = pc;
	//使用
	
	for (int i = 0; i < 20; i++)
	{
		pr->p[i] = i;
	}
	for (int i = 0; i < 20; i++)
	{
		printf("%d", pr->p[i]);
	}
	//扩增
	int * pe = (int*)realloc(pr->p, 40 * sizeof(int));
	if (pe == NULL)
	{
		perror("扩容失败");
		return 1;
	}
	pr->p = pe;
	//使用

	//释放
	//动态地址释放从后向前释放；
	free(pr->p);
	pr->p = NULL;
	free(pr);
	pr = NULL;
	return 0;
}

两种方法进行比较： 方案1
1.malloc 1次，free1次，容易维护空间，不易出错；
2.内存碎片就会减少，内存的使用率就较高一些 方案2
1.malloc2次，free2次，维护难度加大，容易出错，
2.内存碎片就会增加，内存的使用率就较低一些

内存碎片

像①②这种的（位于两个堆创建的空间之间的内存）这些空间十分小，无法使用；

2.有利于访问的速度

1.连续的内存有益于提高访问速度。
2.也有益于减少内存碎片。
（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

1的原因：cpu会提前把正在处理变量内存的后一个地址内存拷贝到cpu中，以提高效率。而不连续这会浪费时间；