【C语言】动态内存管理

1. 动态内存函数

（1）malloc和free

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

malloc向内存申请一块连续可用的空间，当然，申请完后要归还给操作系统，这时候就要使用free函数归还了；

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

eg:

			int main()
			{
				//开辟一个大小为4*整型个字节的空间大小
				int* p = (int*)malloc(4 * sizeof(int));
				//如果开辟空间失败，p为空指针，断言判断p是否为空，为空则报错
				assert(p);
				int i = 0;
				//赋值并打印
				for (i = 0; i < 4; i++)
				{
					//两种都可以
					//*(p + i) = i;
					//printf("%d ", *(p + i));
					p[i] = i;
					printf("%d ", p[i]);
				}
				//归还空间
				free(p);
				//并把p置空，如果不置空，p将成为野指针
				p = NULL;
				return 0;
			}

（2）calloc

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

eg:

			int main()
			{
				//向空间申请sizeof(int)*10个空间，并初始化为0
				int* p = (int*)calloc(10, sizeof(int));
				assert(p);
				int i = 0;
				for (i = 0; i < 10; i++)
				{
					printf("%d ", *(p + i));
				}
				free(p);
				p = NULL;
				return 0;
			}

（3）realloc

1. ptr 是要调整的内存地址

2. size 调整之后新大小

3. 返回值为调整之后的内存起始位置。

4. 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新的空间。

5. realloc在调整内存空间的是存在两种情况

(1) 情况1：原有空间之后有足够大的空间

当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化；而且realloc返回的是旧地址p；

（2）情况2：原有空间之后没有足够大的空间

当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址ptr.

eg：

			int main()
			{
				//先开辟一块大小为10*sizeof(int)的空间
				int* p = (int*)malloc(10 * sizeof(int));
				assert(p);
				int i = 0;
				for (i = 0; i < 10; i++)
				{
					*(p + i) = i + 1;
					printf("%d ", *(p + i));
				}
				//拓展p的空间，拓展后的大小为20 * sizeof(int)
				int* ptr = (int*)realloc(p, 20 * sizeof(int));
				assert(ptr);
				p = ptr;
				for (i = 10; i < 20; i++)
				{
					*(p + i) = i + 1;
					printf("%d ", *(p + i));
				}
				free(p);
				p = NULL;
				return 0;
			}

二、笔试题

笔试题1

			void GetMemory(char *p)
			{
			 	p = (char *)malloc(100);
			}
				void Test(void)
			{
			 	char *str = NULL;
			 	GetMemory(str);
			 	strcpy(str, "hello world");
			 	printf(str);
			}

（1）调用GetMemory函数时，str的传参为值传递，将空指针传过去（是将str变量本身传过去），p是str的临时拷贝，所以在GetMemory函数内部将动态开辟空间的地址存放在p中的时候，不会影响str。所以在GetMemory函数返回之后，str仍然是NULL指针。strcpy就会调用失败，原因是对NULL的解引用操作，程序会崩溃。
（2）GetMemory函数内向malloc申请的空间没有机会释放，造成内存泄漏。

改造1：

			//返回一个指针
			char* GetMemory()
			{
				char* p = (char*)malloc(100);
				return p;
			}
			
			void Test(void)
			{
				char* str = NULL;
				//用指针接收
				str = GetMemory();
				strcpy(str, "hello world");
				printf(str);
				free(str);
				str = NULL;
			}
			
			int main()
			{
				Test();
				return 0;
			}

改造2：

			//用二级指针接收
			void GetMemory(char** p)
			{
				*p = (char*)malloc(100);
			}
			
			void Test(void)
			{
				char* str = NULL;
				//传地址过去
				GetMemory(&str);
				strcpy(str, "hello world");
				printf(str);
				free(str);
				str = NULL;
			}
			
			int main()
			{
				Test();
				return 0;
			}

笔试题2

返回栈空间地址问题：

GetMemory函数内部创建的数组是临时的，虽然返回了数组的起始地址给了str，但是数组的内存出了GetMemory函数就被回收了，而str依然保存了数组的起始地址，这时如果使用str，str就是野指针

			char* GetMemory(void)
			{
				char p[] = "hello world";
				return p;
			}
			void Test(void)
			{
				char* str = NULL;
				str = GetMemory();
				printf(str);
			}
			
			int main()
			{
				Test();
				return 0;
			}	

三、柔性数组

1.柔性数组的定义

结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员，例如：

			typedef struct st_type
			{
			 int i;
			 int a[0];//柔性数组成员
			}type_a;

也可以写成：

			typedef struct st_type
			{
			 int i;
			 int a[];//柔性数组成员
			}type_a;

2. 柔性数组的特点

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

3. 柔性数组的使用

在这里举两个例子，一个是使用柔性数组，第二个是使用结构体中指针方案，两个效果一样，但是也有所差异，我们可以对比一下；

柔性数组的方案（方案1）：

			struct S
			{
				int a;
				char ch;
				int arr[];   //柔性数组成员
			};
			
			int main()
			{
				//为柔性数组开辟空间
				//                 8                           +         40    = 48
				struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
				assert(ps);
			
				int i = 0;
				for (i = 0; i < 10; i++)
				{
					ps->arr[i] = i + 1;
					printf("%d ", ps->arr[i]);
				}
				printf("\n");
			
				ps->a = 10;
				ps->ch = 'w';
			
				printf("%d\n%c\n", ps->a, ps->ch);
				free(ps);
				ps = NULL;
				return 0;
			}

结构体中指针方案（方案2）：

			struct S
			{
				int a;
				char ch;
				int* arr;
			};
			
			int main()
			{
				//为结构体开辟空间
				struct S* ps = (struct S*)malloc(sizeof(struct S));
				assert(ps);
				//为结构体中的数组指针开辟空间
				struct S* ptr = (int*)malloc(10 * sizeof(int));
				assert(ptr);
				ps->arr = ptr;
			
				int i = 0;
				for (i = 0; i < 10; i++)
				{
					ps->arr[i] = i + 1;
					printf("%d ", ps->arr[i]);
				}
			
				free(ptr);
				free(ps);
				ptr = NULL;
				ps = NULL;
				return 0;
			}

以上两种方案的效果都一样，但是方案1，malloc一次，free一次，容易维护空间，不易出错；而且malloc次数少，内存碎片就会较少，内存的使用率就会较高一些；

方案2，malloc两次，free两次，维护难度加大，容易出错；而且malloc次数多，内存碎片就会增加，内存的使用率就下降了；