动态内存管理

在学习动态内存之前，我们开辟空间的方式是通过数组或者定义变量的形式来进行的。

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

但是这样子开辟空间的大小都是固定的，在程序运行的时候不能改变其大小，但是并不是任何程序使用空间的大小都是已知的，有时候需要的空间大小在运行后才知道，那么这个时候就需要用到动态内存，那么如何使用动态内存来开辟空间呢，听我细细道来。

动态内存函数

malloc()函数

malloc()函数是动态内存开辟的基本函数，它的声明是这样的：

malloc()函数向内存申请一块连续可用的空间，并且返回指向这块空间的地址，用指针变量来进行接收。
例如：

int main()
{
	//用malloc开辟4个整形的空间，并把地址返回给arr
	int* arr = (int*)malloc(sizeof(int) * 4);
	if(arr == NULL)
	{
		printf("内存开辟失败\n");
		exit(-1);
	}
}

从上面的代码中，我要说一下使用malloc()函数要注意的几个问题：
1.malloc()函数开辟成功会返回一个指向该空间的指针；如果返回失败，则会返回空指针。因此，在使用malloc()函数后，一定要对返回值进行检查，避免对NULL指针进行使用。
2.malloc()函数的返回值是void*，在使用时要对返回值进行强制类型转换，否则malloc()函数不知道返回值的类型。
3.避免使用malloc(0)，因为这种行为是C语言标准未定义的，能否执行成功要取决于编译器。

calloc()函数

calloc()函数也是用来进行动态内存分配的。

从定义中能够看出，calloc()函数和malloc()函数最大的不同就是它能够对分配的空间初始化为0。
例如：

同样，calloc()函数对返回值也要进行强制类型转换以及返回值的判断。
如果对开辟的空间有初始化的要求，就可以用calloc()函数来完成。

realloc()函数

对于上面两个函数，其实对于内存的开辟还是不够灵活，它们都只能进行一次性开辟，如果在程序中需要扩大或者缩小空间的容量，malloc()和calloc()函数就无法做到。但是接下来介绍的realloc()函数却可以做到这一点，使动态内存的开辟更加灵活，这也决定了进行动态内存开辟的时候，realloc()函数成为我们最常用的函数。

realloc()函数用两个参数，第一个参数memblock是之前开辟的内存的地址，size是调整之后的新的内存大小；
而它的返回值是调整之后新的空间的起始地址。
realloc()函数最大的好处就是调整空间之后，原有的数据会复制到调整后的空间中，然后释放掉原来的空间。
既然realloc()函数能够灵活的对空间的大小进行放大和缩小，那么它是怎样来进行这样的操作呢？

realloc()调整内存空间分为两种情况：
ptr是之前开辟的空间地址
第一种：原有空间之后有足够的空间。
如下图：

第二种：原有空间之后没有足够的空间

如果原有空间之后没有足够的空间，那么realloc()函数会在堆空间上另找一个合适大小的连续空间来进行调整。

这就是realloc()函数内存调整的过程，但是这其中有一个问题，我通过下面的代码来说明一下：

//用realloc()函数这样开辟内存可以吗？
int main()
{
	int *ptr = malloc(100);
	ptr = realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？）
}

就是说，如果用指向原来开辟空间的指针变量来接收新调整空间的地址可以吗？
答案当然是不行的，如果成功了自然没什么影响，但是如果开辟失败了，realloc()函数会返回空指针，这样就会使指向原来空间的指针变为空指针，这就得不偿失了，会丢收原来空间中存储的数据，而且也无法找到以前的那片空间，导致内存无法回收，也就是常见的内存泄漏。因此，在使用时应采用下面的写法：

int main()
{
	int *ptr = malloc(100);
	int*p = NULL;
	p = realloc(ptr, 1000);
	if(p != NULL)
	{
	ptr = p;
	}
}

对返回值进行判断，开辟成功再将新的地址赋给原来的指针变量，这样就会避免上述情况的发生。

释放函数

free()函数

动态开辟的内存使用完之后是必须要回收的，因为计算机的内存是有限的，如果只开辟不释放，就会不断消耗内存，直到计算机的内存被耗干，这就是所谓的内存泄漏，对程序的运行是非常不利的。因此，我们要通过free()函数来回收开辟的空间。

free()函数的参数只有一个，就是所开辟空间的地址。
使用的时候要注意两点：

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

初学者容易犯的几个错误

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

如果用malloc()或者其他动态内存函数开辟了一块空间，但是没有判断返回值直接使用，如果开辟的空间超过能够开辟的内存大小，就会开辟失败返回空指针。此时解引用就会造成对空指针解引用的错误。

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

2. 对动态开辟的内存越界访问

假设用malloc()函数开辟了10个整形的一块连续的空间，但是在使用的时候用到了第11个，这块内存不属于你，就会造成越界访问。

void test()
{
int i = 0;
int *p = (int *)malloc(10*sizeof(int));
if(NULL == p)
{
exit(EXIT_FAILURE);
}
for(i=0; i<=10; i++)
{
*(p+i) = i;//当i是10的时候越界访问
}
free(p);
}

3. 对非动态开辟的内存进行释放

free()函数回收的只是动态开辟的空间，也就是只在堆上进行回收(动态开辟的内存是在堆上进行开辟的)；如果我们用free()去回收一个指针变量是无法做到的。

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

使用free()释放动态内存的一部分

如果要用free()进行释放，必须一次性释放全部的内存，不能只释放一部分，因为这样未释放的那部分就无法找到，从而导致内存泄漏的发生。因此，free()的参数必须是所开辟空间的起始地址。

void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
} 

5. 对一块空间的多次释放

动态开辟的内存释放后，就会把这部分空间还给操作系统，但是接收返回地址的变量仍然记得开辟内存的地址，也就是说，释放的只是内存，而不是地址。正因为这样，在第一次释放以后，如果再次释放，这部分的空间就是系统的，属于非法操作。

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

6. 动态开辟的内存忘记释放(内存泄漏)

这个是在刚开始了解动态内存的时候最容易犯的错误有，就是在开辟了之后忘记释放。正所谓一时开辟一时爽，在最后却忘了释放，结果程序崩溃了才开始意识到是忘记释放。所以我们要记住，开辟和释放相互依赖，只要开辟了，就在后面先把释放的语句写好再去写别的，这样养成习惯。

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

这个程序在test函数中开辟了100个内存，但是函数返回的时候忘了释放，后面的while(1)不断运行，就会使内存耗干，程序崩溃。

一定要注意：开辟的空间一定要记得释放，并且以正确的方式释放。