C语言中的动态内存

1、动态内存和静态内存

1.1静态内存：例如：int arr[10],int b = 1;这种申请空间的方式申请到的是静态内存，这种内存的大小是不能改变的。

静态内存的特点：

1） 空间开辟大小是固定的。

2.） 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

void* malloc ( size_t size );

这个函数可以申请一段连续的空间，并返回该空间的起始地址

该函数的使用需要注意的细节：

1）如果开辟成功，则返回一个指向开辟好空间的指针。

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

3）返回值的类型是 void* ，所以 malloc 函数并不知道开辟空间的类型，具体在使用的时候使用者自己 来决定。

4）如果参数 size 为 0 ， malloc 的行为是标准是未定义的，取决于编译器。

        free函数时一种释放空间的函数，常常和动态开辟类的函数成对使用，以避免造成空间上出现使用完的情况

void free (void* ptr); 

free函数使用的细节

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

2）如果参数 ptr 是 NULL 指针，则函数什么事都不做。

2.2calloc函数

calloc函数原型

void* calloc (size_t num, size_t size) 

calloc函数的使用细节

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

        当我们使用动态开辟空间时，如果有初始化的需要是，使用calloc函数会十分方便

2.3 realloc函数

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

函数原型

void* realloc (void* ptr, size_t size)

calloc函数的使用细节：

1、ptr是需要调整的内存地址

2、size_t是调整之后内存中元素的大小

3、返回值是调整之后的内存的起始地址

4、这个函数在调整大小的时候还会将原来内存中的数据转移到新的内存中

5、realloc调整内存有两种情况

情况一：原有空间之后又充足的内存，则直接在原有内存之后追加内存

情况二：原有空间之后没有充足的内存，在堆区中开辟一块足够大小的内存空间来使用，将原有空间的数据转移过来。

3、动态内存函数使用时经常碰到的错误

3.1对NULL指针的解引用

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

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

3.4使用free函数释放动态开辟的内存的一部分，这样会丢失动态开辟空间的起始地址

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

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

4、柔性数组

结构体中的的最后一个元素允许是未知大小的数组，这就是柔性数组

4.1柔性数组的特点

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

4.2柔性数组的使用

#include<stdio.h>
#include<stdlib.h>
struct S1
{
	int num;
	int arr[];
};
int main()
{
	struct S1* ps = (struct S1*)malloc(sizeof(struct S1) + 40);
	if (ps == NULL)
	{
		free(ps);
		return 1;
	}
	ps->num = 13;
	int i = 0;
	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	struct S1* ptr = (struct S1*)realloc(ps, sizeof(struct S1) + 80);
	for (i = 10; i < 20; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	return 0;
}

4.3柔性数组的好处

上述代码可以改写为

struct S2
{
	int num;
	int* arr;
};
int main()
{
	struct S2* ps = (struct S2*)malloc(sizeof(struct S2));
	if (ps == NULL)
	{
		free(ps);
		return 1;
	}
	ps->arr = (int*)malloc(sizeof(int) * 40);
	if (ps->arr == NULL)
	{
		free(ps);
		ps = NULL;
		return 1;
	}
	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i] = i);
	}
	return 0;
}

 两者相比可以看出柔性数组的优点有

1、方便内存释放

2、有利于提高访问速度