动态内存

int val = 20;
char arr[10] = {0};

但是上述的开辟空间的方式有两个特点:
空间开辟大小是固定的。
数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

动态内存开辟
malloc 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数size为0，malloc的行为是标准是未定义的，取决于编译器。
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的
free函数用来释放动态开辟的内存。
void free(void * ptr);
如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数ptr是NULL指针，则函数什么事都不做。
malloc 和 free 都是成对使用的

# include <stdlib.h>

int main()
{
	// 动态内存开辟
	int * p = (int*)malloc(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 \n", p[i]);
	}

	// 回收空间
	free(p);

	// 手动设置空指针
	p = NULL;

	return 0;
}

calloc 在内存开辟空间，所有初始化为 0.
函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0.
与函数ma1loc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。
malloc 在初始化时会给随机值
所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

int main()
{
	// 所有初始化为 0
	int* p = calloc(10, sizeof(int));

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

	for (int i = 0; i < 10; i++)
	{
		printf("%d \n", *(p + i));
		// 0 0 0 0 0 0 0 0 0 0 
	}

	return 0;
}

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。

void* rea11oc (void" ptr， size_t size);

ptr是要调整的内存地址size调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况:
- 情况1∶原有空间之后有足够大的空间
- 情况2：原有的空间之后没有足够大的空间

int main()
{
	// 初始化内存
	int* p = calloc(10, sizeof(int));

	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	// 使用
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = 5;
	}

	// 这里需要的空间更大，需要20个int空间
	// realloc调整空间
	// realloc 又可能找不到合适的空间，来调整大小
	// 这时会返回 NULL
	// 临时指针接收
	int * ptr = realloc(p, 20 * sizeof(int));

	if (ptr != NULL)
	{
		p = ptr;
	}

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

int main()
{
	// 和 malloc 共能相似
	// 直接在堆开辟 40 个字节
	int* p = (int*)realloc(NULL, 40);
	return 0;
}

动态内存开辟常见的错误

对NULL指着的解引用操作

int main()
{
	int* p = (int*)malloc(1000000000);
	// 对malloc返回值做判空处理
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;// 非法访问内存
	}
	return 0;
}

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)return 0;

	// 越界访问
	for (int i = 0; i < 40; i++)
	{
		*(p + i) = i;
	}

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

使用free释放非动态开辟的空间

int main()
{
	int arr[10] = { 0 };// 栈区
	int* p = arr;
	// 使用

	free(p);// 使用free释放非动态空间 不可以
	p = NULL;
	return 0;
}

使用free释放动态内存中的一部分

int main()
{
	int* p = malloc(10 * sizeof(int));
	if (p == NULL) return 1;
	for (int i = 0; i < 5; i++)
	{
		*p++ = i;
	}
	// 不能在中途释放空间
	// 只能在起始点开始释放
	free(p);
	p = NULL;
	return 0;
}

对同一块动态开辟的空间，多次释放

int main()
{
	int* p = malloc(10 * sizeof(int));
	// 使用

	// 释放
	free(p);
	p = NULL;// 第一次释放完把指针置为空 就没问题


	// 再次释放 会有问题
	free(p);
	return 0;
}

动态开辟的空间忘记释放

动态开辟的空间两种回收方式：
- 主动free
- 程序结束
- 忘记释放，又没办法进行释放，造成内存泄漏

void test()
{
	int* p = (int*)malloc(10 * sizeof(int));
	// 使用

	// 忘记释放
}

int main()
{
	test();
	// ... ...
	// 造成内存释放
	
	return 0;
}

柔性数组

柔性数组(flexible array)这个概念，但是它确实是存在的。c99中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
结构中的柔性数组成员前面必须至少一个其他成员。
sizeof返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

struct S
{
	int i;
	int arr[];// 大小是未知的 柔性数组
};

int main()
{
	// 期望 arr的大小是 10个整型
	struct S * ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	
	ps->i = 100;

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));

	if (ptr == NULL)
	{
		perror("main");
		return 0;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d \n", ps->arr[i]);
	}

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

保证数据都在堆上开辟

struct S
{
	int i;
	int *arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));

	if (ps == NULL) return 1;
	ps->i = 10;
	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL) return 1;
	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	// 增加
	struct S * ptr = realloc(ps->arr,20*sizeof(int));

	if (ptr != NULL)
	{
		ps->arr = ptr;
	}

	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

柔性数组的好处
- 方便内存释放
  - 如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，关把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
- 这样有利于访问速度.
  - 连续的内存有益于提高访问速度，也有益于减少内存碎片(其买，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址)

c语言动态内存分配

动态内存

动态内存开辟常见的错误

柔性数组