动态内存管理（含柔性数组的讲解和经典笔试题的讲解）

GD_small_bit

已于 2022-11-07 21:05:50 修改

阅读量385

点赞数 5

CC 4.0 BY-SA版权

分类专栏： C语言初阶和进阶的学习文章标签： c语言

于 2022-11-07 10:43:49 首次发布

本文链接：https://blog.youkuaiyun.com/gd_small_bit/article/details/127712084

C语言初阶和进阶的学习专栏收录该内容

24 篇文章

订阅专栏

本文深入讲解了C/C++中的动态内存管理技术，包括malloc、calloc、realloc和free等函数的使用方法及注意事项，并探讨了常见错误及其解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在今天的讲解中，我将为大家带来动态内存的知识。

为什么要存在动态内存分配

int val = 20;//在栈空间开辟四个字节的空间
char arr[10] = {0};//在栈空间开辟十个字节的连续空间
但是上述的开辟空间的方式有两个特点
1.空间开辟大小是固定的
2.数组在声明的时候，必须制定数组的长度，它所需要的内存在编译时分配。
但是，有时候我们需要的空间大小是在程序运行之后才知道，并且在内存空间不足时，还要进行追加空间，那么我们就要使用动态开辟了。

动态内存函数的介绍

1.malloc函数和free函数

请添加图片描述
这个函数是向内存申请一块连续可用的空间，并返回指向这块空间的起始位置的指针。

在msdn查询可以得知，malloc函数的声明：void* malloc(size_t size)。

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

请添加图片描述
同样在msdn查询可以得知，free函数的声明:void free(void* memblock )。

free函数是用来释放动态开辟的内存

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

下面，我来举一个例子。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int i = 0;
	//申请空间
	int* p = (int*)malloc(40);    //开辟40个字节的空间，malloc的返回类型是void*类型 ，所以要强制转换为int*类型
	if(p == NULL)    //检查空间是否正常开辟，如果开辟失败直接结束程序
	{
		printf("%s\n",strerror(errno));
		return 1;
	}
    //使用空间
	for(i = 0;i < 10;i++)
	{
	    p[i] = i;
		printf("%d ",p[i]);
	}
	printf("\n");
	//释放空间
	free(p);
	p = NULL;    //接受动态开辟的初始地址的指针要置为空指针
	return 0;
}

运行结果如下:
请添加图片描述
在阅读了上面例子中的代码，我们便对于动态开辟空间的步骤有了基本的了解，基本确定了三个步骤，先申请空间，再使用空间，最后释放空间。

另外需要注意的是，malloc函数与free函数是成对存在的，也就是有malloc函数开辟空间，就要有free函数释放空间。

2.calloc函数和free函数

请添加图片描述
依然在msdn查询可以得知，calloc函数的声明是:void* calloc（size_t num,size_t size）;

num:开辟元素的个数
size:每个元素的大小

该函数的功能是开辟num个大小为size的元素一块空间。

开辟空间失败，返回NULL
开辟空间成功，返回指向这个空间的起始位置

free函数我在前面已经有所介绍。

接下来，我来举一个calloc函数的使用例子。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int i = 0;
	//开辟空间
	int* p = (int*)calloc(10,sizeof(int));     //开辟10个大小为sizeof(int)的空间，calloc返回类型是void*,所以要强制类型转换为int*
	if(p == NULL)   //检查空间是否开辟成功，失败直接结束程序
	{
		printf("%s\n",strerror(errno));
		return 1;
	}
	//使用空间
    for(i = 0;i < 10;i++)
	{
		p[i] = i;
		printf("%d ",p[i]);
	}
	printf("\n");
	//释放空间
	free(p);
	p = NULL;         //指向动态开辟空间的初始地址的指针必须置为NULL
    return 0;
}

运行结果如下:
请添加图片描述
由上面的例子，我们可以发现calloc函数的使用步骤与malloc函数是差不多的，依然是开辟空间、使用空间、释放空间的三个步骤，唯一有所不同的就是参数的不同，所以以后在使用malloc和calloc函数时，要注意它们的参数类型，不要混淆。

在使用calloc函数时，我们一样也要使用free函数释放空间，如果未能及时的释放空间，将会导致堆区的空间过度消耗。

3.free函数不起作用导致的错误

在编写程序的代码时，我们即使在动态开辟空间后加上free函数释放内存空间，依然可能造成空间未能释放的错误。

如下:

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
int test()
{
	int i = 0;
	//开辟空间
	 int* p = (int*)calloc(10,sizeof(int));
	 if(p == NULL)
	 {
		strerror(errno);
		return -1;
	 }
	 //使用空间
	 for(i = 0;i < 10;i++)
	 {
		 p[i] = i;
		 i++;
	 }
	 if(i == 10)
	 {
		return 0;
	 }
	 //释放空间
	 free(p);
	 p = NULL;
	 return 1;
}
int main()
{
	test();
	return 0;
}

如上面的代码中，我已经加上了free函数去释放动态开辟的空间，但是这个程序依然是没有释放空间的。

因为前面有个if判断语句，如果成立，test函数的调用直接结束，自然就不会实行下面的free函数。

我们在动态开辟内存时，要注意的是需要使用free函数并且保证free函数能够被调用，才能让我们的程序不会产生错误。

4.malloc函数和calloc函数的区别

malloc函数与calloc函数除了参数个数和参数类型的不同外，还有一个容易忽略的就是malloc函数在开辟空间时，不会把空间里的内容进行初始化，而calloc函数在开辟空间时，会把空间的每个字节初始化为全0。

我举个例子。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;
	//开辟空间
	int* p = (int*)malloc(10 * sizeof(int));
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	//使用空间
	for(i = 0;i < 10;i++)
	{
		p[i] = i;
		printf("%d ",p[i]);
	}
	printf("\n");
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

我通过调试，观察指针p指向的空间的内容是什么。
请添加图片描述
由上面调试的窗口可以发现，当我用malloc函数开辟空间时，指针p指向的空间内容是随机值。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;
	//开辟空间
	int* p = (int*)calloc(10 , sizeof(int));
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	//使用空间
	for(i = 0;i < 10;i++)
	{
		p[i] = i;
		printf("%d ",p[i]);
	}
	printf("\n");
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

请添加图片描述
由上面的调试的监视窗口可以发现，当我使用calloc函数开辟空间时，指针p指向的空间内容会被改为0。

总结:calloc函数与malloc函数除了参数不同以外，calloc还会在返回地址之前把申请的空间的每个字节初始化为全0，而malloc不会进行初始化。

5.realloc函数

1.realloc函数的出现让动态内存管理更加灵活。
2.有时候我们会发现过去申请的空间太大或者太小，需要对内存大小做灵活的调整。那malloc函数就可以对动态开辟的内存进行大小的调整。

请添加图片描述
由msdn查询可以得知，realloc函数的声明:void* realloc（void* memblock，size_t size）。

1.memblock就是要调整的内存地址
2.size是调整之后的新大小
3.返回值为调整之后的内存起始位置
4.realloc函数在调整内存空间存在两种情况。
情况1:原有空间之后有足够大的空间
realloc在判断是情况1之后，要扩展内存就直接在原有内存之后直接追加空间，原来的空间的数据不发生变化。
情况2:原有空间之后没有足够大的空间
realloc在判断是情况2之后，原有空间之后没有足够多的空间，扩展的方法是:在堆空间上寻找另外一个合适大小的连续空间来使用，并且在追加内存空间大小的基础上，还会将原来内存中的数据移动到新空间。这样函数返回的是一个新的内存地址（旧的空间要释放掉）。

接下来，我举一个realloc函数的使用例子。

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
void print(int* p,int begin,int end)
{
	int i = 0;
	for(i = begin;i < end;i++)
	{
		printf("%d ",p[i]);
	}
	printf("\n");
}
int main()
{
	int i = 0;
	int* ptr = NULL;
	//开辟空间
	int* p = (int*)malloc(10 * sizeof(int));
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	//使用空间
	for(i = 0;i < 10;i++)
	{
	    p[i] = i;
	}
	print(p,0,10);
	//追加空间
	ptr = (int*)realloc(p,20 * sizeof(int));
	if(ptr == NULL)
	{
		strerror(errno);
		return 1;
	}
	p = ptr;
	for(i = 10;i < 20;i++)
	{
		p[i] = i; 
	}
	print(p,10,20);
	//释放空间
	free(p);
	p = NULL;
	ptr = NULL;
	return 0;
}

运行结果如下:
请添加图片描述
由上面的代码可以得知，realloc函数的使用依然是开辟空间、使用空间、释放空间的三个步骤，但是需要注意的是realloc函数的前面如果有开辟空间的话，不用提前释放，等到程序最后与realloc新开辟的空间一起释放即可。

确定调整空间时是哪一种情况
我还是在上面的代码下进行调试，观察是哪一种情况。
请添加图片描述

观察（p）和（p，20）的地址（注意观察（p，20）的原因是realloc函数追加后新增加的内存的其中一个字节），如果相等，证明是情况1，如果不相等，证明是情况2。

由上面的监视窗口截图可以得知，这次realloc函数调整空间是情况1。

在空指针处开辟空间

int* p = (int*)realloc(NULL,40);//等价于malloc（40）；

这一串代码是没多大意义的，建议不要写这样的代码，但也要知道的这串代码的作用。

常见的动态内存错误

1.对NULL的指针解引用操作

如下:

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(4 * sizeof(int));     //错误代码的例子
	*p = 5;
    free(p);
    p = NULL;
	return 0;
}

在上面的代码中存在着错误，这个错误大家能不能一眼看出来呢？答案是:没有检查malloc函数是否成功开辟空间，因为在开辟空间失败时，malloc函数会返回NULL，对NULL进行赋值本身是一种错误。

改正后的代码:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(4 * sizeof(int));     //代码改正后的样子
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	else
	{
		*p = 5;
	}
	free(p);
	p = NULL;
	return 0;
}

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

例如:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;
	int* p = (int*)malloc(20);    //错误代码展示
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	for(i = 0;i < 20;i++)
	{
		p[i] = i;
	}
	free(p);
	p = NULL;
	return 0;
}

越界访问是一个比较危险的操作，可能造成十分严重的后果，如上面的代码运行起来，程序直接崩溃。上面的代码中，是怎么造成越界访问的呢？观察可得，malloc函数开辟20个字节的空间，也就是5个整形的内存空间，而for循环中却用到了20个整形内存的空间，也就是80个字节，导致了越界访问。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;
	int* p = (int*)malloc(80);    //改进后的代码展示
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	for(i = 0;i < 20;i++)
	{
		p[i] = i;
	}
	free(p);
	p = NULL;
	return 0;
}

将malloc函数开辟的空间改为80个字节后，程序就不会越界访问了。

3.对非动态开辟的内存使用free函数

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int num = 10;    //错误代码展示
	int* p = &num;
	free(p);
	p = NULL;
	return 0;
}

对非动态开辟的内存使用free函数进行释放，程序会直接崩溃。

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;						//错误代码展示
	int* p = (int*)malloc(40);
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	for(i = 0;i< 5;i++)
	{
		*p = i;
		p++;
	}
	free(p);
	p = NULL;
	return 0;
}

该程序运行的过程中会直接崩溃，因为free函数是一次性释放所有动态开辟的空间的，但是在上面代码的for循环里，指向动态开辟空间的起始地址的指针一直在向后走，最后指向了动态开辟的空间的中间位置，那么free函数释放指针p指向的空间时，只是释放动态开辟空间的后半部分，没有一次性释放所有动态开辟的空间，造成了错误。

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;                                  //错误代码展示
	int* p = (int*)malloc(10 * sizeof(int));
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	for(i=0;i<10;i++)
	{
		p[i] = i;
	}
	free(p);
	free(p);
	return 0;
}

如上面的代码中，对p指向的动态开辟的空间进行了两次释放，造成了程序的错误，使程序崩溃。

在前面，我已经讲过free函数遇到NULL是不会有任何操作的。如果在上面的代码中，我在第一个free函数后面将p指针置为NULL，那么即使在后面不小心又使用一次free函数，也不造成程序崩溃。

所以，当我们在free函数后，一定要将指针置为空指针，既能防止野指针的产生，也能防止再次使用free函数带来程序崩溃。

6.动态开辟的内存忘记释放

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int i = 0;                                  //错误代码展示
	int* p = (int*)malloc(10 * sizeof(int));
	if(p == NULL)
	{
		strerror(errno);
		return 1;
	}
	for(i=0;i<10;i++)
	{
		p[i] = i;
	}
	return 0;
}

如上面的代码中，动态开辟了内存，却在程序结束时，没有将该内存释放掉。

忘记释放掉不再使用的动态开辟的空间，会造成内存的泄露。

经典笔试题讲解

在下面的几道笔试题中，分析错误的原因。
1.

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void GetMemory(char* p)
{
	p = (char*)malloc(30);
}
void test()
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str,"hello world");
	printf(str);
}
int main()
{
	test();
	return 0;
}

指针p指向的动态开辟的空间的地址没有返还给指针str，指针str是空指针
strcpy函数往空指针拷贝东西，造成程序的崩溃
动态开辟的p没有释放空间。
动态开辟空间时，并没有检验是否开辟成功

改正如下:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(30);
	if(*p == NULL)             //检查是否开辟成功
	{
		strerror(errno);
		exit(1);
	}
}
void test()
{
	char* str = NULL;
	GetMemory(&str);         //传地址，让GetMemoey函数将str修改为动态开辟空间的初始地址
	strcpy(str,"hello world");
	printf(str);
	free(str);               //释放空间
	str = NULL;
}
int main()
{
	test();
	return 0;
}

经过改动，上面的代码就满足了我们的要求。

#include<stdio.h>
char* GetMemory()
{
	char p[] = "hello world";
	return p;
}
int main()
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
	return 0;
}

变量p是局部变量，在GetMemory函数调用结束后，变量p的空间就还给了操作系统，而str仍然接受了变量p的起始地址，此时str是一个野指针，打印野指针的内容，结果是乱码。

总结:在传参的过程中，要注意是传值还是传地址，传地址会因为函数的调用完，空间释放造成野指针的使用，而传值并不会受空间释放的影响。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void GetMemory(char** p,int num)
{
	*p = (char*)malloc(num);
	if(*p == NULL)
	{
		strerror(errno);
		exit(1);
	}
}
int main()
{
	char* str = NULL;				//错误代码展示
	GetMemory(&str,100);
	strcpy(str,"hello");
	printf(str);
	return 0;
}

在不再使用该动态开辟的空间时，没有对该空间进行释放。

改正如下:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void GetMemory(char** p,int num)
{
	*p = (char*)malloc(num);
	if(*p == NULL)
	{
		strerror(errno);
		exit(1);
	}
}
int main()
{
	char* str = NULL;				//改正代码展示
	GetMemory(&str,100);
	strcpy(str,"hello");
	printf(str);
	free(str);
	str = NULL;
	return 0;
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void test()
{
	char* str = (char*)malloc(100);
	if(str == NULL)
	{
		strerror(errno);
		exit(1);
	}
	strcpy(str,"hello");
	free(str);                   //str指向的动态开辟的空间已经被释放，str为野指针
	if(str != NULL)
	{
		strcpy(str,"world");
		printf(str);
	}
}
int main()
{
	test();		        		//错误代码展示
	return 0;
}

在上面的代码中，str指向的动态开辟的空间已经被释放掉了，str变成了空指针，而后面对野指针str进行写入，导致程序崩溃。

如果现在有人拷贝上面的代码到编辑器去运行，可能出现不会报错的情况，比如vs2010就不会报错，这就是编辑器的检查存在的小缺点了。

我们在改进代码的时候，只需要在free函数的后面将str置为NULL，就可以了。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void test()
{
	char* str = (char*)malloc(100);
	if(str == NULL)
	{
		strerror(errno);
		exit(1);
	}
	strcpy(str,"hello");
	free(str);                     //释放空间
	str = NULL;                    //释放空间后将str置为NULL
	if(str != NULL)
	{
		strcpy(str,"world");
		printf(str);
	}
}
int main()
{
	test();		        		
	return 0;
}

如上面的代码，在释放完str指向的动态开辟的空间后，将str置为NULL。

c/c++程序的内存开辟

1.c/c++程序内存分配的几个区域

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

2.对于static关键词修饰局部变量的理解

实际上，普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁，但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束时才销毁，所以生命周期变长。

3.变量所属区域分析

在内存当中，被分为几个区域，如下图:
请添加图片描述
接下来，我来创建几个变量，并且分析这些变量分别在哪里开辟空间。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int globalvar = 1;
static int StaticGlobalvar = 1;
void test()
{
	static int StaticVar = 1;
	int localVar = 1;
	char num1[10] = {1,2,3,4};
	char num2[] = "abcd";
	char* p = "abcd";
	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)calloc(4,sizeof(int));
	int* ptr3 = (int*)realloc(ptr2,sizeof(int)*8);
	free(ptr1);
	ptr1 = NULL;
	//free(ptr2);这里不能释放空间，等到释放ptr3时会一起释放，后面图片里的代码麻烦自行改正
	ptr2 = NULL;
	free(ptr3);
	ptr3 = NULL;
}
int main()
{
	test();
	return 0;
}

请添加图片描述数据段，也就是静态区存储着全局变量、静态全局变量、静态局部变量。

所以图片中三个变量（即橙色方框）都在数据段开辟空间。

请添加图片描述
栈区，存放着局部变量、局部数组、指针变量。

所以，图中三种变量（即蓝色方框）都在栈区开辟空间。

请添加图片描述
动态开辟的空间是在堆区上进行的。

请添加图片描述
常量字符串在代码段存储。

柔性数组

柔性数组是什么

C99中，结构体中的最后一个元素允许是未知大小的数组，这就叫做（柔性数组）的成员。

注意是在C99的标准中，但是大部分的编辑器并不支持C99的标准，所以这个功能要想去使用还是比较困难的。

我在vs2010是可以运行起来的，所以大家可以在vs系列尝试这个功能。

struct s
{
	int n;
	float s;
	int arr[];//柔性数组成员，另外的一个写法是int arr[0],有的编辑器支持这种写法。
};
int main()
{
	return 0;
}

柔性数组的特点

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

#include<stdio.h>
struct s
{
	int n;          //4
	float s;        //4
	int arr[];//柔性数组成员
};
int main()
{
	printf("%d\n",sizeof(struct s));
	return 0;
}

运行结果如下:
请添加图片描述
由该程序就可以证明，计算结构体的大小时，是没有包含柔性数组的大小的。

柔性数组的使用

柔性数组的方案

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct s
{
	int n;
	float b;
	int arr[];
};
int main()
{
	int i = 0;
	struct s* ptr = NULL;
	//开辟空间
	struct s* ps = (struct s*)malloc(sizeof(struct s) + 4 * sizeof(int));   //记得要给柔性数组开辟空间
	if(ps == NULL)
	{
		strerror(errno);
		exit(1);
	}
	//使用空间
	ps->n = 10;
	ps->b = 1.5f;
	printf("请输入数据\n");
	for(i = 0;i < 4;i++)
	{
		scanf("%d",&ps->arr[i]);
	}
	printf("%d lf\n",ps->n,ps->b);
	for(i = 0;i < 4;i++)
	{
		printf("%d\n",ps->arr[i]);
	}
	//给柔性数组增加空间
	ptr = (struct s*)realloc(ps,sizeof(struct s) + 8 * sizeof(int));
	if(ps == NULL)
	{
		strerror(errno);
		exit(1);
	}
	ps = ptr;
	//使用空间
	ps->n = 12;
	ps->b = 1.5f;
	printf("请输入数据\n");
	for(i = 4;i < 8;i++)
	{
		scanf("%d",&ps->arr[i]);
	}
	printf("%d lf\n",ps->n,ps->b);
	for(i = 4;i < 8;i++)
	{
		printf("%d\n",ps->arr[i]);
	}
	//释放空间
	free(ps);
	ps = NULL;
	ptr = NULL;
	return 0;
}

替代柔性数组的方案

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct s
{
	int n;
	float b;
	int* a;
};
int main()
{
	int i = 0;
	int* tmp = NULL;
	//开辟空间
	struct s* ps = (struct s*)malloc(sizeof(struct s));   
	if(ps == NULL)
	{
		strerror(errno);
		exit(1);
	}
	//使用空间
	ps->n = 10;
	ps->b = 1.5f;
	tmp = (int*)malloc(4 * sizeof(int));
	if(tmp == NULL)
	{
		strerror(errno);
		exit(1);
	}
	ps->a = tmp;
	printf("请输入数据\n");
	for(i = 0;i < 4;i++)
	{
		scanf("%d",&ps->a[i]);
	}
	printf("%d lf\n",ps->n,ps->b);
	for(i = 0;i < 4;i++)
	{
		printf("%d\n",ps->a[i]);
	}
	tmp = (int*)realloc(ps->a,8 * sizeof(int));
	if(tmp == NULL)
	{
		strerror(errno);
		exit(1);
	}
	ps->a = tmp;
	//使用空间
	ps->n = 12;
	ps->b = 1.5f;
	printf("请输入数据\n");
	for(i = 4;i < 8;i++)
	{
		scanf("%d",&ps->a[i]);
	}
	printf("%d lf\n",ps->n,ps->b);
	for(i = 4;i < 8;i++)
	{
		printf("%d\n",ps->a[i]);
	}
	//释放空间
	free(ps->a);
	ps->a = NULL;
	free(ps);
	ps = NULL;
	tmp = NULL;
	return 0;
}

两种方式的方案:
1.替代柔性数组的方案中，使用多次malloc，产生了过多的内存碎片，内存碎片不好利用，导致内存的利用率下降。（两次malloc函数开辟的空间是不连续的）
请添加图片描述
2.替代柔性数组的方式采用过多malloc函数，更容易忘记增加相应数目的free函数来释放动态开辟的内存，造成内存泄露。