动态内存管理与柔性数组

为什么要有动态内存分配

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

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

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

1.空间开辟大小是固定的。
2.数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。

所以C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

程序内存区域的划分

我们动态内存开辟的区域都是在堆区上开辟的。

malloc

C语言提供了一个动态内存开辟的函数：

void* malloc (size_t size);

这个函数向内存申请⼀块连续可用的空间，并返回指向这块空间的指针。

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
malloc返回值之所以是void* 是因为不知道程序员需要什么类型的空间，于是在开辟的时候需要 程序员强转为自己需要的空间类型。
如果参数size为0，malloc的行为是未定义的，如何执行取决于编译器。

int main()
{
	int* p = (int*)malloc(40);//开辟40个字节
	if (p == NULL)
	{
		perror("malloc");
		return -1;
	}
	free(p);
	p = NULL;
	//malloc(0)该行为未定义
	return 0;
}

free

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

free函数用来释放动态开辟的内存。必须是动态开辟的内存，我们自己定义的变量和数组不能使用free释放。

如果参数ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数ptr是NULL指针，则函数什么事都不做。

我们也不能对一个刚free过的指针再次free，否则程序就会崩溃

calloc

C语言还提供了一个函数叫 calloc ，calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

1.函数的功能是开辟 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。（size_t 为无符号整型）
2.与函数malloc 的区别只在于calloc 会在返回地址之前把申请的空间的每个字节初始化为全0，还有就是参数的区别了。

int *p = (int*)calloc(10, sizeof(int));

网上其他文章的介绍都是上面这种写法，但是我试的时候下面这种写法也对，可能是为了方便区分需要的内存大小吧，所以第二个参数是一个类型的大小

int *p = (int*)calloc(10, 5);//开辟50个字节

realloc

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

函数原型如下：

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址
size 调整之后新大小，可以扩容也可以缩小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

如果原有后续空间足够大，就在后续继续分配，返回的还是原来的地址，如果后续空间不够，就会新开辟一份空间，返回新的地址，原有地址被释放。
注意事项：
我们realloc的时候不能直接赋值给原有的指针，因为如果开辟失败，原来的数据将丢失，应重新创建一个变量，承接realloc的返回值，如果不是NULL，就再赋值给p，但是不能free掉ptr，因为ptr和p指向的同一块空间，free掉以后，原来的p指向的空间的数据将丢失。

int main()
{
	int* p = (int*)malloc(40);//开辟40个字节
	if (p == NULL)
	{
		perror("malloc");
		return -1;
	}
	int* ptr = (int*)realloc(p, 100);
	if (ptr != NULL)
	{
		p = ptr;
		//不能执行free(ptr)，否则原有数据将丢失
		ptr = NULL;
	}
	return 0;
}

如果relloc参数为NULL的话就相当于malloc了。

realloc（NULL,40） = malloc(40)

柔性数组

什么是柔性数组

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

struct st_type
{
	int i;
	int a[0];//柔性数组成员,也可以写int a[];
};

结构体成员a数组，它的数组大小是没有确定的，将来如果需要可以大也可以小。
有些编译器支持a[0]这种写法，有些编译器支持a[ ]这种写法，具体取决编译器。

柔性数组的特点

结构体中柔性数组成员前面必须至少有一个其他成员

struct st_type
{
	int i;
	int a[0];//柔性数组成员前面必须有一个成员
};

sizeof返回的这种结构大小不包括柔性数组的内存

struct st_type
{
	int i;//4字节
	int a[0];//柔性数组成员,也可以写int a[];
	//因为是柔性数组，无法确认a占几个字节
};
int main()
{
	printf("%d\n", sizeof(struct st_type));//打印4
	return 0;
}

包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小

struct st_type
{
	int i;//4字节
	int a[0];//柔性数组成员,也可以写int a[];
};
int main()
{
    //假设我现在需要a里有10个元素
	struct st_type* ps=(struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
	if (ps == NULL)
	{
		perror("malloc");
		return -1;
	}
	for (int j = 0;j < 10;j++)
	{
		ps->a[j] = j;
	}
	for (int j = 0;j < 10;j++)
	{
		printf("%d ", ps->a[j]);//打印0-9
	}
	printf("\n");
	//如果想继续用柔性数组a进行打印
	//比如现在a里只有10个元素，我用完10个了，我还要继续来10个,用realloc追加
	struct st_type*ptr=realloc(ps, sizeof(struct st_type) + 20 * sizeof(int));//ps:realloc第二个参数是调整后的整体大小
	if (ptr == NULL)
	{
		perror("malloc");
		return -1;
	}
	else
	{
		ps = ptr;
	}
	for (int k = 10; k < 20; k++)
	{
		ps->a[k] = k;
	}
	for (int j = 0; j < 20; j++)
	{
		printf("%d ", ps->a[j]);//打印0-19
	}
	//释放空间
	free(ps);
	ps = NULL;
	return 0;
}

有一点需要强调的是，我们柔性数组开辟了空间以后，变量也是按照对齐规则存储的

可以看到首地址后面还是默认的值，0存在了首地址偏移4的地方。

上述代码中只有ps指针是在栈上创建的，结构体是在malloc申请的空间里面存储的，所以是在堆上面存储的。

柔性数组的优点

上述结构也可以设计为下面的结构，也能完成同样的效果。

//用指针也可以做到a指向的空间动态变化
struct st_type
{
	int i;//4字节
	int *a;//4字节，这里计算结构体大小恰好是8字节
};
int main()
{
	struct st_type*ps = (struct st_type*)malloc(sizeof(struct st_type));
	ps->i = 100;
	ps->a = (int*)malloc(10 * sizeof(int));//a指向40个字节的空间，该空间由int*进行管理
	int j = 0;
	for (j = 0;j < 10;j++)
	{
		ps->a[j] = j;
	}
	for (j = 0;j < 10;j++)
	{
		printf("%d", ps->a[j]);
	}
	//a指向的空间不够了，希望调整大小
	int *ptr = (int*)realloc(ps->a, 20 * sizeof(int));
	if (ptr == NULL)
	{
		perror("malloc");
		return -1;
	}
	else
	{
		ps->a = ptr;
	}
	//使用...
	//释放
	free(ps->a);//必须先释放a，否则将会内存泄漏
	ps->a = NULL;
	free(ps);
	ps = NULL;
}

这里需要注意的是，在释放空间时，你要先释放指针a指向的空间，然后释放结构体指针
如果你先释放掉ps，a就没了，你就没法找到a指向的那块空间了。

这里对比柔性数组，柔性数组和上述的指针都可以实现一块空间大小的调整，但是柔性数组有两个好处：

第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。以上，如果我把结构体的内存及其成员要的内存一次性分配好，并返回给用户一个结构体指针，用户做一次free就可以把所有内存都释放掉，并且不用考虑前面说的释放的顺序。
第二个好处是：加快访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。

附大佬的文章链接: C语言结构体里的成员数组和指针

C/C++程序在内存区域中的划分

内核空间是留给操作系统的，用户无法使用。
其中数据段就是最开始说的静态区。
代码段存的就是我们的代码，我们代码编译为二进制指令后，存放在代码段里，其中只读常量也会存在代码段中。
栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。就像递归，如果一直进行下去，那么就会发生栈溢出。
栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。