C语言之动态内存管理

1.引言，需要动态内存管理的原因：在之前所学的内容中，定义一个整型或者数组，都是向内存申请一片空间，但是这些申请方式一旦申请好空间，大小就无法调整，那么这时候就需要一种灵活地申请空间的功能。

2.相关函数：（1）malloc函数：用于动态内存开辟的函数。

函数原型：void* malloc(size_t size);  里面的size是需要申请的空间，单位是字节，最后返回申请出来的空间的起始地址，但是指针类型是void，原因malloc函数并不知道是开辟的空间用处是什么，是存整型还字符型，所以最后的决定权在使用者手中，其实实际使用中，使用者就已经想好申请的内存空间用于什么了，所以通常需要强制类型转换。最后再做个判断，如果开辟失败了，malloc会返回空地址，就报错：perror("malloc")，开辟成功就使用空间了。举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
	}
	//使用： 
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	return 0;
}

调试一下：

最后也是成功地把值赋进了p地址。 

多提一嘴，malloc函数申请的空间在堆区，还有free、calloc、realloc所关联的内存空间都是在堆区上的。

（2）free函数：使用完内存中如果不使用了就可以使用free，用来释放和回收内存空间。

函数原型：void free(void* ptr); 参数是一个指针变量，所以要传一个要释放的内存空间的地址,而且是起始地址。但是，如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。如果传的是空指针的话，那么free函数就什么都不做。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
	}
	//使用： 
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//释放内存：
	free(p); 
    p = NULL;
 
	return 0;
}

而且是这一整块空间的使用权限都还给操作系统，一旦free执行后，p就是一个野指针了，最后就赋一个空指针。

（3）calloc函数：功能是为num个大小为size的元素开辟一块空间并且把每个字节初始化为0。

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

//向内存申请5个整型的空间
#include <stdlib.h>
int main()
{
	/*int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
	}*/
	int* p = (int*)calloc(5 , sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
	}
	//使用： 
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//释放内存：
	free(p); 
 
	return 0;
}

（4）realloc：对开辟出来的内存空间进行大小的调整。

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

ptr是要调整的内存的地址，size是调整之后的大小，返回值是调整之后的内存的起始地址 

但是在调整大小的时候会有两种情况：

已经开辟出来的20个字节里后面刚好还有多于20个字节的空间尚未分配。

后面的空间不够用了。

情况一就是直接在后面续上了，情况二是重新在堆区找一块满足大小要求的空间，再把原来的数据重新拷贝一份放到新的空间里面，然后把原来的那块给释放掉，返回新的空间地址。 

但如果是空间调整失败的话就会返回空指针。最后完善一下:

#include <stdio.h>
#include <stdlib.h>
int main()
{
	/*int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
	}*/
	int* p = (int*)calloc(5 , sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
	}
	//使用： 
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//希望将内存调整为40个字节：
	int* ptr = (int*)realloc(p, 40);
	if (ptr != NULL)
	{
		p = ptr;
		//使用四十个空间的字节：
		int i = 0;
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
 
		//释放内存：
		free(p);
		p = NULL; 
	}
	else perror("realloc");
 
	return 0;
}

其实realloc函数不仅有上面的用法,还可以实现和malloc函数一样的功能,如果把需要传递的地址换成空指针,realloc就会开辟一块新空间。

下面演示空间开辟失败的案例：

3.常见的动态内存错误：

（1）对空指针的解引用操作：在使用时应该对返回的指针值进行判断，如果不做判断直接使用，就有可能会对空指针进行解引用操作。

（2）对动态开辟空间的越界访问： 

int main()
{
	int i = 0;
	int* p = (int*)malloc(10 * sezeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i + 1;
	}
	free(p);
	p = NULL;
	return 0;
}

当i=10时，p指向了第十一个，这样就会越界，类似于数组。

（3）对非动态开辟的内存释放：就像是下面这样：

int main()
{
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
 
	return 0;
}

这样写是错误的。

（4）使用free释放动态内存空间的一部分。就比如：

int main()
{
	int* p = (int*)malloc(100);
	{
		return 1;
	}
 
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i + 1;
		p++;
	}
	free(p);
	return 0;
}

p++已经指向了偏移原来位置五个整型的位置了，然后现在free的意思是从这个位置开始释放内存，不包含前面的内存。这种行为是不允许的。

（5）对同一块动态内存多次释放：就是写了两次free(p)，除非这两次释放中间有给p赋值为空指针，free(NULL)是什么都不做。

（6）动态开辟内存最后忘记释放：

void test()
{
	int* p = (int*)malloc(100);
	if (NULL!=p)
	{
		*p = 20;
	}
}
int main()
{
	test();
	while (1);
	return 0;
}

开辟这个内存既不使用也不释放，程序运行到while时就会死循环，然后一直占有着这块内存不还给操作系统，这样会造成内存泄漏的情况。

其实malloc和realloc申请的内存如果不想使用的话可以使用free函数，如果没有使用free来释放当程序运行结束时也会由操作系统回收的。

4.柔性数组：结构体中最后一个成员而且还是数组且没有指定大小

（1）特点：sizeof返回的结构体大小不包含柔性数组的内存

（2）包含柔性数组的结构体成员用malloc函数进行动态的内存分配并且分配的内存应该大于结构体以适应柔性数组的预期大小。具体例子：

struct S
{
	int n = 0;
	int arr[];
};
int main()
{
	malloc(sizeof(struct S) + 10 * sizeof(int));
 
	return 0;
}

假设你希望这个柔性数组的大小有十个整型元素，那么在动态内存分配的时候就应该加上期望的柔性数组的大小，最后用一个结构体的指针接收。这个时候动态内存分配好了之后就可以使用realloc去调整，realloc可以使这个内存变成变短，前面的那个整型大小又不变，所以后面的那个数组就也会跟着变长变短，就实现了柔性。

（2）使用：

struct S
{
	int n = 0;
	int arr[];
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
    int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 15 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	//......
 
	//释放：
 
	return 0;
}

还有一个方式，将数组转化为指针，然后先结构体整体开辟，再开辟指针里面的空间。

第一次开辟成功了的话就开辟arr的，需要十个整型，就用malloc函数开辟。最后就是：

struct S
{
	int n = 0;
	int* arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->arr = (int*)malloc(5 * sizeof(int));
	if (ps->arr == NULL)
	{
		return 1;
	}
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	int* ptr = (int*)realloc(ps->arr, 15 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	//......
 
	//释放：
 
	return 0;
}

大概就是这样。

全部内容，over。