devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言进阶--动态内存管理_c语言 free链表维护动态内存

作者：菜鸟追梦旅行 | 2024-05-19 09:04:24

赞

踩

c语言 free链表维护动态内存

目录

一.为什么使用动态内存分配？

二.动态内存函数

2.1.malloc和free

malloc函数

free函数

2.2.calloc和realloc

calloc函数

realloc函数

三.常见的动态内存错误

对NULL指针的解引用

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

对非动态开辟内存使用free释放

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

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

动态开辟内存忘记释放

内存泄漏

四.经典笔试题

题一：

题二：

题三：

题四：

五.C/C++程序的内存开辟

六.柔性数组

6.1.柔性数组的特点

6.2.柔性数组的使用

6.3.柔性数组的优势

6.4.柔性数组的优势

一.为什么使用动态内存分配？

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

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

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

  1. 空间开辟大小是固定的；
  2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组编译时开辟空间的方式就不能满足了。这时候就只能试试动态内存开辟了。

二.动态内存函数

2.1.malloc和free

C语言库函数提供了两个函数：malloc和free，分别用于执行动态内存分配和释放。这些函数维护一个可用内存池。当一个程序另外需要一些内存时，它就调用malloc函数，malloc从内存池中提取一块合适的内存，并向该函数返回一个指向这块内存的指针。这块内存此时并没有以任何方式进行初始化。如果对这块内存进行初始化非常重要，你要么自己动手对它进行初始化，要么使用calloc函数。当一块以前分配的内存不再使用时，程序调用free函数把它归还给内存池供以后之需。

malloc函数

函数原型：void* malloc(size_t size);

头文件：#include<stdlib.h>

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

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

free函数

函数原型：void free(void* ptr);

头文件：#include<stdlib.h>

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

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

free函数的实际参数必须是先前由内存分配函数返回的指针。(参数也可以是空指针，此时free调用不起作用。)如果参数是指向其他对象(比如变量或数组元素)的空指针，可能会导致未定义的行为。虽然free函数允许收回不再需要的内存，但是使用此函数会导致一个新的问题：悬空指针。 调用free(p)函数会释放p指向的内存块，但是不会改变p本身。如果忘记了p不再指向有效内存块，混乱可能随即而来。试图访问或修改释放掉的内存块会导致未定义的行为。试图修改释放掉的内存块可能会引起程序崩溃等损失惨重的后果。

在C语言中，指针测试真假的方法和数的测试一样。所有非空指针都为真，而只有空指针为假。因此，语句if (p == NULL)可以写成if(!p)，if (p != NULL)可以写成if(p)。

案例一：

  1. int main()
  2. {
  3. 	//申请空间
  4. 	int* ptr = (int*)malloc(40);
  5. 	
  6. 	if (ptr == NULL)
  7. 	{
  8. 		perror("malloc");
  9. 		return 1;
  10. 	}
  11.  
  12. 	int i = 0;
  13. 	for (i = 0; i < 10; i++)
  14. 	{
  15. 		*(ptr + i) = i;//ptr的指向并没有发生变化
  16. 	}
  17.  
  18. 	//释放空间
  19. 	free(ptr);
  20. 	ptr = NULL;
  21.  
  22. 	return 0;
  23. }

分析：

在调用完free函数之后，如果不加上ptr==NULL，虽然free(ptr)函数会释放ptr指向的内存块，但是不会改变ptr本身。这就将导致一个新问题：悬空指针。

为了避免这个问题的发生，我们可以在free(ptr)之后将其置为NULL即可。

不加ptr==NULL释放前：

不加ptr==NULL释放后：

加ptr==NULL释放后：

案例二：

  1. int main()
  2. {
  3. 	//申请空间
  4. 	int* ptr = (int*)malloc(40);
  5. 	int* p = ptr;
  6.  
  7. 	if (p == NULL)
  8. 	{
  9. 		perror("malloc");
  10. 		return 1;
  11. 	}
  12.  
  13. 	//使用
  14. 	int i = 0;
  15. 	for (i = 0; i < 10; i++)
  16. 	{
  17. 		*p = i;
  18. 		p++;//p的指向发生变化
  19. 	}
  20.  
  21. 	//释放空间
  22. 	free(ptr);
  23. 	ptr = NULL;
  24.  
  25. 	if (ptr != NULL)
  26. 	{
  27. 		*ptr = 100;
  28. 	}
  29.  
  30. 	return 0;
  31. }

案例三：失败案例

  1. int main()
  2. {
  3. 	int* ptr = (int*)malloc(40);
  4. 	int* p = ptr;
  5.  
  6. 	if (p == NULL)
  7. 	{
  8. 		perror("malloc");
  9. 		return 1;
  10. 	}
  11.  
  12. 	free(p);
  13. 	p=NULL;
  14.  
  15. 	return 0;
  16. }

分析：

free函数的实际参数必须是先前由内存分配函数返回的指针ptr。如果参数是指向其他对象(比如变量或数组元素)的空指针，可能会导致未定义的行为。

总结：

  1. 当我们不释放动态申请的内存时；
  2. 如果程序结束，动态申请的内存由操作系统自动回收；
  3. 如果程序不结束，动态内存是不会自动回收的，就会形成内存泄漏的问题。

2.2.calloc和realloc

calloc函数

函数原型：void* calloc(size_t num, size_t size);

头文件：#include<stdlib.h>

calloc函数为num个元素的数组分配内存空间，其中每个元素的长度都是size个字节。如果要求的空间无效，那么此函数返回空指针。在分配了内存之后，calloc函数会通过把所有位设置为0的方式进行初始化。

malloc和calloc之间的主要区别是后者在返回指向内存的指针之前把它初始化为0。calloc和malloc之间另一个较小的区别是它们请求内存数量的方式不同。calloc的参数包括所需元素的数量和每个元素的字节数。

案例：

  1. int main()
  2. {
  3. 	//malloc申请的空间不会被初始化为0
  4. 	//int* p = (int*)malloc(40);
  5. 	//申请10个整型的空间
  6.  
  7. 	//calloc申请的空间会被初始化为0
  8. 	int* p = calloc(10, sizeof(int));//10为元素的个数，sizeof(int)为元素的大小
  9. 	
  10. 	if (p == NULL)
  11. 	{
  12. 		perror("calloc");
  13. 		return 1;
  14. 	}
  15.  
  16. 	//使用
  17. 	int i = 0;
  18. 	for (i = 0; i < 10; i++)
  19. 	{
  20. 		printf("%d ",*(p+i));
  21. 	}
  22.  
  23. 	free(p);
  24. 	p = NULL;
  25.  
  26. 	return 0;
  27. }

调试分析：

realloc函数

函数原型：void* realloc(void* ptr, size_t size);

头文件：#include<stdlib.h>

当调用realloc函数时，ptr必须指向先前通过malloc，calloc或realloc的调用获得的内存块。size表示内存块的新尺寸，新尺寸可能会大于或小于原有尺寸。

realloc函数用于修改一个原先已经分配的内存块的大小。使用这个函数，你可以使一块内存扩大或缩小。如果它用于扩大一个内存块，那么这块内存原来的的内容依然保留，新增的内容添加到原先内存块的后面，新内存并未以任何方法进行初始化。如果它用于缩小一个内存块，该内存块尾部的部分内存便被拿掉，剩余部分内存的原先内容依然保留。

如果原先的内存块无法改变大小，realloc将分配另一块正确的大小，并把原来那块内存的内容复制到新的块上。因此，在使用realloc之后，你就不能再使用指向旧内存的指针，而是应该改用realloc所返回的新指针。

最后，如果realloc函数的第1个参数是NULL，那么它的行为就和malloc一模一样。如果realloc函数被调用时以0作为第二个实际参数，那么它会释放掉内存块。

案例：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(40);
  4.  
  5. 	if (p == NULL)
  6. 	{
  7. 		perror("malloc");
  8. 		return 1;
  9. 	}
  10.  
  11. 	int i = 0;
  12. 	for (i = 0; i < 10; i++)
  13. 	{
  14. 		*(p + i) = i;
  15. 	}
  16.  
  17. 	//空间不够，希望能放20个元素，考虑扩容
  18. 	int* ptr = realloc(p, 80);
  19.  
  20. 	if (ptr != NULL)
  21. 	{
  22. 		p = ptr;
  23. 	}
  24.  
  25. 	//扩容成功，开始使用
  26. 	for (i = 10; i < 20; i++)
  27. 	{
  28. 		*(p + i) = i;
  29. 	}
  30.  
  31. 	//不再使用，释放
  32. 	free(p);
  33. 	p = NULL;
  34.  
  35. 	return 0;
  36. }

 调试分析：

1.首先malloc分配40位的空间，也就是10个int型大小：

2.然后进行扩容，该扩容是在原空间的基础上进行的：

3.扩容成功后，则开始使用该空间：

4.使用完之后，则开始释放空间：

小结：

如何接收realloc的返回值？如果用旧地址去接收，那么当realloc找不到合适的空间进行内存分配时，这时realloc的返回值将变成NULL。此时不仅空间没有开辟好，原有空间的内容也可能丢失。那么我们应该打印错误信息然后结束程序，不要再往下执行。所以建议先用新地址接收，如果开辟成功再把它赋值给旧地址，这样就可以避免原有内存块数据的丢失。

三.常见的动态内存错误

对NULL指针的解引用

案例：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4.  
  5. 	int i = 0;
  6. 	for (i = 0; i < 250; i++)
  7. 	{
  8. 		*(p + i) = i;
  9. 	}
  10. 	
  11. 	free(p);
  12. 	p=NULL;
  13.  
  14. 	return 0;
  15. }

分析：

malloc的返回值可能为NULL，此时将NULL赋值给指针p，则p的值也为NULL。然而后面又对p进行解引用，也就是对指针NULL进行解引用，此时的编译器将会发生警告。

解决办法：对malloc函数的返回值进行判断

改正：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4.  
  5. 	//对p进行判空操作
  6. 	if (p == NULL)
  7. 	{
  8. 		perror("malloc");
  9. 		return 1;
  10. 	}
  11.  
  12. 	int i = 0;
  13. 	for (i = 0; i < 250; i++)
  14. 	{
  15. 		*(p + i) = i;
  16. 	}
  17. 	
  18. 	free(p);
  19. 	p=NULL;
  20.  
  21. 	return 0;
  22. }

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

案例：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4.  
  5. 	if (p == NULL)
  6. 	{
  7. 		perror("malloc");
  8. 		return 1;
  9. 	}
  10.  
  11. 	int i = 0;
  12. 	//可能越界访问
  13. 	for (i = 0; i <= 250; i++)
  14. 	{
  15. 		*(p + i) = i;
  16. 	}
  17.  
  18. 	free(p);
  19. 	p = NULL;
  20.  
  21. 	return 0;
  22. }

分析：

i <= 250这个条件判断错误，数组产生越界，i的值应该小于250。

解决办法：对内存边界要检查

改正：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4.  
  5. 	if (p == NULL)
  6. 	{
  7. 		perror("malloc");
  8. 		return 1;
  9. 	}
  10.  
  11. 	int i = 0;
  12. 	//可能越界访问
  13. 	for (i = 0; i < 250; i++)
  14. 	{
  15. 		*(p + i) = i;
  16. 	}
  17.  
  18. 	free(p);
  19. 	p = NULL;
  20.  
  21. 	return 0;
  22. }

对非动态开辟内存使用free释放

案例：

  1. int main()
  2. {
  3. 	int a = 10;
  4. 	int* p = &a;
  5.  
  6. 	free(p);
  7. 	p = NULL;
  8.  
  9. 	return 0;
  10. }

分析：

free只能释放由malloc，calloc和realloc所开辟的内存空间，这些空间都是在堆区上进行开辟的。而变量a是在栈区开辟的，因此并不能让free来释放。

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

案例：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4. 	if (p == NULL)
  5. 	{
  6. 		perror("malloc");
  7. 		return 1;
  8. 	}
  9.  
  10. 	int i = 0;
  11. 	for (i = 0; i < 10; i++)
  12. 	{
  13. 		*p = i;
  14. 		p++;
  15. 	}
  16.  
  17. 	//释放空间
  18. 	free(p);
  19. 	p = NULL;
  20.  
  21. 	return 0;
  22. }

分析：

随着p++的执行，指针p的位置已经发生了变化，不再指向所开辟内存空间的起始位置，而是指向中间的某个位置。而free又是从所开辟内存空间的起始位置开始释放的，所以free(p)用在这里显然是不合适的。

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

案例：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4. 	if (p == NULL)
  5. 	{
  6. 		perror("malloc");
  7. 		return 1;
  8. 	}
  9.  
  10. 	free(p);
  11. 	
  12. 	//...
  13.  
  14. 	free(p);
  15.  
  16. 	return  0;
  17. }

分析：

第一次free(p)时，此时所开辟的内存空间将会被释放，但是不会改变p本身，它还保存着之前所开辟内存空间的起始地址。所以我们要及时将p置为NULL，才能避免多次释放所带来的问题。

改正：

  1. int main()
  2. {
  3. 	int* p = (int*)malloc(1000);
  4. 	if (p == NULL)
  5. 	{
  6. 		perror("malloc");
  7. 		return 1;
  8. 	}
  9.  
  10. 	free(p);
  11. 	p = NULL;
  12.  
  13. 	//...
  14.  
  15. 	free(p);//当参数为NULL时，此时free调用不起作用
  16.  
  17. 	return  0;
  18. }

动态开辟内存忘记释放

案例：

  1. void test()
  2. {
  3. 	int* p = (int*)malloc(100);
  4. 	if (NULL != p)
  5. 	{
  6. 		*p = 20;
  7. 	}
  8. }
  9.  
  10. int main()
  11. {
  12. 	test();
  13. 	while (1)
  14. 	{
  15. 		;
  16. 	}
  17.  
  18. 	return 0;
  19. }

分析：

p是一个局部变量，本来存放的是malloc所开辟内存空间的起始地址，但是当test函数调用完之后，变量p将会被释放。所以后面就没人再记得之前所开辟内存的起始地址，这将会导致内存泄漏。忘记释放不再使用的动态开辟的空间会造成内存泄漏。切记：动态开辟的空间一定要释放，并且正确释放。

改正：

  1. void test()
  2. {
  3. 	int* p = (int*)malloc(100);
  4.  
  5. 	if (NULL != p)
  6. 	{
  7. 		*p = 20;
  8. 	}
  9.  
  10. 	free(p);
  11. 	p = NULL;
  12. }
  13.  
  14. int main()
  15. {
  16. 	test();
  17. 	while (1)
  18. 	{
  19. 		;
  20. 	}
  21.  
  22. 	return 0;
  23. }

内存泄漏

当动态分配的内存不再需要使用时，它应该被释放，这样它以后可以被重新分配使用。分配内存但在使用完毕后不释放将引起内存泄漏。在那些所有执行程序共享一个通用内存池的操作系统中，内存泄漏将一点点地榨干可用内存，最终使其一无所有。要摆脱这个困境，只能重启系统。

四.经典笔试题

题一：

  1. void GetMemory(char* p)
  2. {
  3. 	p = (char*)malloc(100);
  4. }
  5.  
  6. void Test(void)
  7. {
  8. 	char* str = NULL;
  9. 	GetMemory(str);
  10. 	strcpy(str, "hello world\n");
  11. 	printf(str);
  12. }
  13.  
  14. int main()
  15. {
  16. 	Test();
  17.  
  18. 	return 0;
  19. }

分析：

  1. GetMemory(str)：属于值传递，实参str传给形参p，形参p其实是实参的一份临时拷贝，所以对形参p的修改并不会影响到实参str，形参p调用完之后会自动销毁，所以str的值仍为NULL；
  2. p = (char*)malloc(100)：会造成内存泄漏，因为malloc之后没有free。malloc分配的内存空间的地址存放在形参p中，所以当形参p销毁之后，也就没人知道malloc所分配的内存空间的起始地址，因而也就无法释放，最终会造成内存泄漏。

改正：

方案一：

  1. void GetMemory(char** p)
  2. {
  3. 	*p = (char*)malloc(100);
  4. }
  5.  
  6. void Test()
  7. {
  8. 	char* str = NULL;
  9. 	GetMemory(&str);
  10.  
  11. 	strcpy(str, "hello world");
  12.  
  13. 	printf(str);
  14.  
  15. 	free(str);
  16. 	str = NULL;
  17. }
  18.  
  19. int main()
  20. {
  21. 	Test();
  22.  
  23. 	return 0;
  24. }

方案二：

  1. char* GetMemory(char* p)
  2. {
  3. 	p = (char*)malloc(100); 	
  4. 	return p;
  5. }
  6.  
  7. void Test(void)
  8. {
  9. 	char* str = NULL;
  10. 	str = GetMemory(str);
  11. 	strcpy(str, "hello world");
  12. 	printf(str);
  13. 	free(str);
  14. 	str = NULL;
  15. }
  16.  
  17. int main02()
  18. {
  19. 	Test();
  20.  
  21. 	return 0;
  22. }

题二：

  1. char* GetMemory(void)
  2. {
  3. 	char p[] = "hello world";
  4. 	return p;
  5. }
  6.  
  7. void Test(void)
  8. {
  9. 	char* str = NULL;
  10. 	str = GetMemory();
  11. 	printf(str);
  12. }
  13.  
  14. int main()
  15. {
  16. 	Test();
  17.  
  18. 	return 0;
  19. }

运行结果：

分析：

  1. char p[] = "hello world"：p是数组名，是一个临时变量，表示的是数组首元素的地址。而局部变量是在栈区开辟，函数调用完之后就会自动销毁，此时变量p将返回这个字符串的起始地址，但是该起始地址所指向的字符串的内容已销毁；
  2. str = GetMemory()：此时将变量p赋值给变量str，而变量p已经变成野指针，它所指向的空间并不存放字符串"hello world"，因此会造成非法访问内存；
  3. 返回栈空间地址的问题：栈空间的地址不要随意返回，会产生野指针。

改正：

  1. char* GetMemory(void)
  2. {
  3. 	char* p = "hello world";
  4. 	return p;
  5. }
  6.  
  7. void Test(void)
  8. {
  9. 	char* str = NULL;
  10. 	str = GetMemory();
  11. 	printf(str);
  12. }
  13.  
  14. int main()
  15. {
  16. 	Test();
  17.  
  18. 	return 0;
  19. }

题三：

  1. void GetMemory(char** p, int num)
  2. {
  3. 	*p = (char*)malloc(num);
  4. }
  5.  
  6. void Test(void)
  7. {
  8. 	char* str = NULL;
  9. 	GetMemory(&str, 100);
  10. 	strcpy(str, "hello");
  11. 	printf(str);
  12. }
  13.  
  14. int main()
  15. {
  16. 	Test();
  17.  
  18. 	return 0;
  19. }

分析：

在调用GetMemory()函数时，由malloc函数开辟的内存空间在使用完后并没有及时地使用free进行释放，因而造成了内存泄漏。

改正：

  1. void GetMemory(char** p, int num)
  2. {
  3. 	*p = (char*)malloc(num);
  4. }
  5.  
  6. void Test(void)
  7. {
  8. 	char* str = NULL;
  9. 	GetMemory(&str,100);
  10. 	strcpy(str,"hello world");
  11. 	printf(str);
  12. 	
  13. 	free(str);
  14. 	str = NULL;
  15. }
  16.  
  17. int main()
  18. {
  19. 	Test();
  20.  
  21. 	return 0;
  22. }

题四：

  1. void Test(void)
  2. {
  3. 	char* str = (char*)malloc(100);
  4. 	strcpy(str, "hello");
  5. 	free(str);
  6.  
  7. 	if (str != NULL)
  8. 	{
  9. 		strcpy(str, "world");
  10. 		printf(str);
  11. 	}
  12. }
  13.  
  14. int main()
  15. {
  16. 	Test();
  17. 	return 0;
  18. }

分析：

在使用free释放由malloc所开辟的空间，虽然所开辟的空间已被释放，但是str依旧保存着所开辟空间的起始地址，这将导致指针悬空。如果忘记str不再指向有效内存块，此时刻试图访问或修改释放掉的内存块会导致未定义的行为。试图修改释放掉的内存块可能会引起程序崩溃等损失惨重的后果。

改正：

  1. void Test(void)
  2. {
  3. 	char* str = (char*)malloc(100);
  4. 	strcpy(str,"hello");
  5. 	free(str);
  6.  
  7. 	//指针置为空
  8. 	str = NULL;
  9.  
  10. 	if (str != NULL)
  11. 	{
  12. 		strcpy(str," world");
  13. 		printf(str);
  14. 	}
  15. }
  16.  
  17. int main()
  18. {
  19. 	Test();
  20. 	return 0;
  21. }

五.C/C++程序的内存开辟

规定：

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

六.柔性数组

C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员，但结构中的柔性数组成员前面必须至少有一个其他成员。

例如：

  1. struct S
  2. {
  3. 	int num;
  4. 	double d;
  5. 	int arr[0];//柔性数组成员
  6. };

有些编译器会报错无法编译，可以改成：

  1. struct S
  2. {
  3. 	int num;
  4. 	double d;
  5. 	int arr[];//柔性数组成员
  6. };

6.1.柔性数组的特点

1.结构中的柔性数组成员前面必须至少一个其他成员；

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

  1. struct S3
  2. {
  3. 	int num;
  4. 	int arr[0];//柔性数组成员
  5. };
  6.  
  7. int main()
  8. {
  9. 	printf("%d\n",sizeof(struct S3));//4
  10.  
  11. 	return 0;
  12. }

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

6.2.柔性数组的使用

柔性数组可以结合malloc进行使用，用以动态开辟内存空间；同时也可以结合realloc进行使用，用以内存空间的扩容。

案例：

  1. struct S3
  2. {
  3. 	int num;
  4. 	int arr[0];//柔性数组成员
  5. };
  6.  
  7. int main()
  8. {
  9. 	printf("%d\n",sizeof(struct S3));//4
  10.  
  11. 	//开辟空间
  12. 	struct S3* ps = (struct S3*)malloc(sizeof(struct S3) + 40);//40用于柔性数组成员
  13.  
  14. 	//判空
  15. 	if (ps == NULL)
  16. 	{
  17. 		perror("malloc");
  18. 		return 1;
  19. 	}
  20.  
  21. 	//使用
  22. 	ps->num = 100;
  23. 	int i = 0;
  24. 	for (i = 0; i < 10; i++)
  25. 	{
  26. 		ps->arr[i] = i;
  27. 	}
  28.  
  29. 	//打印
  30. 	for (i = 0; i < 10; i++)
  31. 	{
  32. 		printf("%d ",ps->arr[i]);
  33. 	}
  34.  
  35. 	//扩容
  36. 	struct S3* ptr = (struct S3*)realloc(ps, sizeof(struct S3) + 80);
  37.  
  38. 	//判空
  39. 	if (ptr == NULL)
  40. 	{
  41. 		perror("realloc");
  42. 		return 1;
  43. 	}
  44. 	else
  45. 	{
  46. 		ps = ptr;
  47. 	}
  48.  
  49. 	//使用
  50. 	for (i = 10; i < 20; i++)
  51. 	{
  52. 		ps->arr[i] = i;
  53. 	}
  54.  
  55. 	//继续打印
  56. 	for (i = 10; i < 20; i++)
  57. 	{
  58. 		printf("%d ", ps->arr[i]);
  59. 	}
  60.  
  61.  
  62. 	//释放
  63. 	free(ps);
  64. 	ps = NULL;
  65.  
  66. 	return 0;
  67. }

6.3.柔性数组的优势

前面我们讲到可以使用柔性数组来动态开辟内存空间，这里我们将其改写成使用动态数组来开辟内存空间。示例如下：

  1. struct S4
  2. {
  3. 	int num;
  4. 	int* arr;
  5. };
  6.  
  7. int main()
  8. {
  9. 	//开辟空间
  10. 	struct S4* ps = (struct S4*)malloc(sizeof(struct S4));
  11.  
  12. 	//判空
  13. 	if (ps == NULL)
  14. 	{
  15. 		perror("malloc");
  16. 		return 1;
  17. 	}
  18. 	
  19. 	//为动态数组开辟空间
  20. 	ps->arr = (int*)malloc(40);
  21.  
  22. 	//判空
  23. 	if (ps->arr == NULL)
  24. 	{
  25. 		perror("malloc");
  26. 		return 1;
  27. 	}
  28.  
  29. 	//使用
  30. 	ps->num = 100;
  31. 	int i = 0;
  32. 	for (i = 0; i < 10; i++)
  33. 	{
  34. 		ps->arr[i] = i;
  35. 	}
  36.  
  37. 	//打印
  38. 	for (i = 0; i < 10; i++)
  39. 	{
  40. 		printf("%d ", ps->arr[i]);
  41. 	}
  42.  
  43. 	//扩容
  44. 	int* ptr = (int*)realloc(ps->arr, 20 * sizeof(int));
  45.  
  46. 	//判空
  47. 	if (ptr == NULL)
  48. 	{
  49. 		perror("realloc");
  50. 		return 1;
  51. 	}
  52. 	else
  53. 	{
  54. 		ps->arr = ptr;
  55. 	}
  56.  
  57.     //使用
  58. 	for (i = 10; i < 20; i++)
  59. 	{
  60. 		ps->arr[i] = i;
  61. 	}
  62.  
  63. 	//继续打印
  64. 	for (i = 10; i < 20; i++)
  65. 	{
  66. 		printf("%d ", ps->arr[i]);
  67. 	}
  68.  
  69.  
  70. 	//释放
  71. 	free(ps->arr);
  72. 	ps->arr = NULL;
  73.  
  74. 	//释放
  75. 	free(ps);
  76. 	ps = NULL;
  77.  
  78. 	return 0;
  79. }

可以发现，改用动态数组的方式同样可以达到与使用柔性数组一样的效果。那二者有何差异呢？

通过对比可以发现：

  1. 当使用柔性数组来开辟和释放内存空间时，需要一次malloc和一次free；
  2. 当使用动态数组来开辟和释放内存空间时，需要两次malloc和两次free；
  3. 当使用柔性数组时，结构体所开辟的内存空间是连续的；当使用动态数组时，结构体所开辟的内存空间不一定是连续的；
  4. 当重复多次使用malloc函数，会在内存空间产生较多的内存碎片，进而导致内存的利用率降低。

6.4.柔性数组的优势

一.方便内存释放:

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

二.有利于访问速度:

连续的内存有益于提高访问速度，也有益于减少内存碎片。(其实，也没多高，反正你跑不了要用做偏移量的加法来寻址。)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/592161
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号