C语言-动态内存管理

什么是动态内存分配

在我们创建一个变量或数组时，就会在内存中开辟一块空间，但是这样开辟空间的方式有两个特点：

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

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

动态内存函数

在我们开辟动态内存的方法是用动态内存函数，下面我们来介绍一些这些函数。头文件是<stdlib.h>

malloc

malloc  开辟内存块
void* malloc(size_t size);

malloc的参数是一个size_t的数，是指我们要开辟空间的大小，单位是字节。
返回值是我们开辟的空间的起始地址，当内存开辟失败时，则返回NULL。
开辟的空间里放的是随机值。

calloc

calloc  开辟内存块
void* calloc(size_t num,size_t size);

calloc函数与malloc函数类似都是创建一个内存块，但是callor函数有两个参数。
第一个参数是我们开辟的空间里的元素个数。
第二个参数是每个元素的长度，单位也是字节。
返回值也是开辟的空间的起始地址，当内存开辟失败时，则返回NULL。
它与malloc的另一个区别是在创建时，空间里的元素都被初始化为0。
下面我们分别用malloc与calloc创建一个包含十个int的空间，来感受一下他们之间的区别

int* p1=(int*)malloc(10*sizeof(int));
int* p2=(int*)calloc(10,sizeof(int));

malloc在开辟动态内存时不需要对内容进行初始化，所以malloc的效率会比calloc高一些。

free

在我们使用动态内存开辟时，当我们不再需要这个空间时，我们需要用到free函数把开辟的空间还给操作系统。

free  释放一个内存块
void free(void* memblock);

free函数的参数是要释放空间的起始地址,如果我们不释放我们创建的内存，那么只要程序如果在运行中时，那块被我们创建出来的内存就无法被别的地方使用，这种情况叫做内存泄漏，如果长时间泄漏，内存就会被耗干。
注意：在我们用free函数把一个指针指向的空间释放以后，虽然这个空间被释放了，但是我们的指针并没有变，它仍然指向刚刚被释放的空间，而为了防止这个指针以后被再次使用造成野指针的问题，我们一般会在内存释放后把这个指针赋为空指针。

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

free(p);
p=NULL;

realloc

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

realloc  对动态内存的大小进行调整
void* realloc(void* ptr,size_t size);

realloc函数的作用是调整一个动态内存
ptr是要调整的内存的地址
size是调整之后的新的大小
返回值为内存调整之后的位置，如果调整失败，也返回一个空指针。
那么realloc在调整内存大小的时候还会改变内存的位置吗？答案是有可能，因为在realloc调整动态内存大小时可能有这么两种情况：

1.在我们调整一个动态内存的大小时，在这个动态内存的后面有足够大的空间来让我们调整，那么在我们扩展内存时，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
2.当原有的空间后面没有足够的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

所以当我们使用realloc时，就要注意它的返回值可能发生改变。

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	int i;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	int* ptr=(int*)realloc(p, 20 * sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
	}
	else
	{
		p = ptr;
		ptr = NULL;
	}
	for (i = 10; i < 20; i++)
	{
		p[i] = i + 1;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

如上图我们对开辟的动态内存进行了调整，而调整过后我们需要判断指针是否有效确定我们的调整是否成功，所以我们创建了一个新的指针变量来维护我们调整之后的内存，因为如果我们调整失败，那么假如我们仍然使用之前的指针来维护它，那么之前的指针就会被置为空指针，那么非但没有调整成功，连我们之前的哪个内存也找不到了，而且还会造成内存泄漏，所以我们建议在调整内存后，不要直接使用之前的指针来维护它，而是尽量使用一个新的指针来维护调整后的内存，如果判断没有问题了，再使用之前的指针来维护它。

使用动态内存需要注意的地方

对NULL指针的解引用操作

在我们对内存开辟或调整后，要对内存指针的有效性进行判断。

int main()
{
    int *p = (int *)malloc(INT_MAX/4);
    *p = 20;//如果p的值是NULL，就会有问题
    free(p);
    return 0;
}

如上图，如果malloc创建内存失败，那么就相当于是把20赋值给了空指针，出现问题，所以我们应该这样写：

int main()
{
    int *p = (int *)malloc(INT_MAX/4);
    if(p==NULL)
    {
        perror("malloc");//perror的作用是报错，报告malloc出现错误。
        return 0;
    }    
    *p = 20;
    free(p);
    return 0;
}

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

我们知道，我们开辟的动态内存是一块连续的空间，那么就与数组类似，也可能出现越界访问

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	int i;
	for (i = 0; i <= 10; i++)
	{
		p[i] = i + 1;
	}
	return 0;
}

如上图，我们用malloc创建的动态内存只有10个元素，但是当我们访问时却访问到了第11个元素，出现了越界访问，这时代码也会报错

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

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?
}

这里的a是一个局部变量，不是动态内存，所以我们使用free对p进行释放是不允许的，这是C语言未定义的。

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

int main()
{
    int* p=(int*)malloc(100);
    p++;
    free(p);
    return 0;

p是指向我们开辟的动态内存的，但是当p++之后，它就不再指向开辟的动态内存的起始位置，而是后面一个元素的位置，这时候我们再用p去释放这块内存就会报错，而释放动态内存的一部分也是不允许的。

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

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

当我们对一块动态内存重复释放时，代码就会报错，所以为了避免这种情况，我们可以在每次释放后都把指针置成空指针，这样即使我们不小心在后面再次用p释放了内存，但是这时的p已经是空指针了，所以用free时什么事都不发生。

动态开辟内存忘记释放（内存泄漏）

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

如果我们在使用完这个动态内存后没有释放，那么当我们不用这块空间时，别人也不能用，造成内存泄漏。

以上就是动态内存管理的内容，如果大家觉得我的文章对您有帮助，还请多多点赞，关注支持一下！！