动态内存管理

动态内存函数

在堆区申请的空间，动态开辟的空间不要忘了释放

malloc

参数是无符号的整型，表示的是多少字节数。当参数为0时，这是标准没有定义的。取决于编译器。
返回类型为void*的指针。
当空间开辟成功的时候，返回指向该空间的地址。
当空间开辟失败的时候，返回空指针。
malloc开辟是一个连续的空间。开辟完成之后都要判断一下有没有成功

例：

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

int main()
{
	char* p = (char*)malloc(10 * sizeof(char));
	if (p == NULL)
	{
		printf("%s", strerror(errno));
		return 0;
	}
	char* arr = p;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*arr++ = i;
	}
	free(p);
	p = NULL;
	return 0;
}

calloc

开辟动态内存空间的同时初始化空间为0，每个字节都初始化为0。
num是元素的个数，size每个元素的大小。
开辟空间成功返回指向该空间的指针
开辟空间失败返回空指针NULL。

例：

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

int main()
{
	int* p = (int*)calloc(5, sizeof(int));;
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

realloc

重新分配动态内存的函数.。
第一个参数为指向动态开辟空间的指针，第二个参数为从新开辟内存的大小，单位字节。
当第一个参数为空指针NULL时。和malloc一样。
开辟成功返回，返回从新开辟空间的地址。
开辟失败返回空指针。

有两种情况：
1. 以前动态开辟的空间后面的空间够再次开辟，那么realloc直接在以前开辟的后面进行开辟。

2. 以前动态开辟的空间后面的空间不够再次开辟，会重新找一块空间进行开辟，同时把以前的数据拷贝新开辟的里面。以前动态开辟的空间被销毁。

例：

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

int main()
{
	char* p = (char*)malloc(10 * sizeof(char));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	char* str = (char*)realloc(p, 20 * sizeof(char));
	if (str == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	p = str;
	free(p);
	p = NULL;
	return 0;
}

free

释放动态开辟的内存空间。参数是指向动态内存的指针，是首地址。
当参数为NULL的时候，什么都不发生。

常见的动态内存错误

对NULL指针的解引用操作

这里的p万一是空指针，下面这种就是错误

	char* p = (char*)malloc(10 * sizeof(char));
	*p = 1;

正确的做法是开辟完成之后，需要判断是不是空指针。

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

其实和数组一样，动态内存开辟的空间也有边界，也是不能越界的。

	char* p = (char*)malloc(10 * sizeof(char));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	int i = 0;
	for (i = 0; i <= 10; i++)//当i=10的时候就越界了
	{
		*(p + i) = i;
	}

释放非动态内存开辟的空间

int a = 10;
int* p = &a;
free(p);
p = NULL;

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

free一定要释放指向动态内存开辟的那个首地址。

	char* p = (char*)malloc(10 * sizeof(char));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	int i = 0;
	for (i = 0; i <5; i++)
	{
		*p++ = i;
	}
	//这里释放一部分，这是错误的。
	free(p);

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

	char* p = (char*)malloc(10 * sizeof(char));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	free(p);
	free(p);

解决方法为：释放空间之后就制成空指针。

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

一定一定不要忘了释放

char* f()
{
	char* p = (char*)malloc(10);
	return p;
}
int main()
{
	char* ret = f();
	return 0;
}

柔性数组

结构体中允许最后一个成员为未知大小的数组，该数组就是柔性数组成员。

例：

struct s
{
	int i;
	int arr[];
	下面的这种也是可以的
	int arr[0];
};

柔性数组的特点

1.结构体至少包括一个非柔性数组成员
2.sizeof求这种类型的时候，不包括柔性数组。
3.动态开辟的时候，其开辟的大小要大于这种类型的大小。以满足可以给柔性数组进行开辟空间。

使用：

struct s
{
	int i;
	int arr[];
	//int arr[0];
};

int main()
{
	struct s* p = (struct s*)malloc(sizeof(struct s) + 20);
	if (p == NULL)
	{
		return 0;
	}
	p->i = 6;
	int n;
	for (n = 0; n < 5; n++)
	{
		p->arr[n] = n;
	}
	free(p);
	p = NULL;
	return 0;
}

像上面那样，我们还可以用其他的方式进行实现：
如

struct s
{
	int i;
	int* arr;
};
int main()
{
	struct s* p = (struct s*)malloc(sizeof(struct s));
	if (p == NULL)
	{
		return 0;
	}
	p->i = 6;
	p->arr = (int*)malloc(5 * sizeof(int));
	free(p->arr);
	p->arr = NULL;
	free(p);
	p = NULL;
	return 0;
}

虽然这样也可以实现，但是两次开辟的空间不是连续。要注意释放的顺序，否则会造成内存泄漏。
使用柔性数组不会出现这种情况。