动态内存管理

---

一、前言

我们在通过变量或是数组进行内存分配时，都是固定了所要开辟的内存空间的大小。但是对于空间的需求，不仅仅是上述的情况。有时我们需要的空间大小需要在程序运行时才能知晓，那这个时候数组的编译时开辟空间的方式就不能满足了，只能尝试通过动态内存开辟解决这个问题。

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

二、 动态内存函数

2.1 malloc 函数

2.1.1 malloc 函数原型

C语言提供了一个动态内存开辟的函数，这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

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

2.1.2 malloc 函数的使用

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int arr[10] = { 0 };
	int *p = (int*)malloc(40);
	if(p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//开辟成功
	int i = 0;
	for(i = 0 ;i < 10 ; i++)
	{
		printf("%d\n",*(p + i));
	}
	return 0;
}

//malloc 函数申请到内存空间后，直接返回这块空间的起始地址，不会初始化空间的内容。

结果如下：

2.1.3 malloc 函数学习小贴士

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

2.2 free 函数

2.2.1 free 函数原型

C语言提供了另外一个专门用来动态内存释放和回收的函数free。
函数原型如下：void free (void* ptr);

2.2.2 free 函数的使用

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int arr[10] = { 0 };
	int *p = (int*)malloc(40);
	if(p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//开辟成功
	int i = 0;
	for(i = 0 ;i < 10 ; i++)
	{
		printf("%d\n",*(p + i));
	}

	free(p);
	p = NULL;
//malloc 函数申请到的动态内存空间，直到程序结束后才会还给操作系统。如果程序没有结束，是不会主动释放空间的，这个时候需要使用free函数才能释放。
	return 0;
}

结果如下：

2.2.3 free 函数学习小贴士

1、free函数用来释放动态开辟的内存。
2、如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
3、如果参数ptr 是NULL指针，则函数什么事都不做。
4、malloc和free都声明在 stdlib.h 头文件中。

2.3 calloc 函数

2.3.1 calloc 函数原型

C语言还提供了一个函数叫 calloc 函数， calloc 函数也用来动态内存分配。
原型如下：void* calloc (size_t num, size_t size);

2.3.2 calloc 函数的使用

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = (int*)calloc(10, sizeof(int));

	if (NULL != p)
	{
		perror("calloc");
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}
//当我们想要对申请的内存空间的内容进行初始化时，使用calloc函数即可完成任务。

结果如下：

2.2.3 calloc 函数学习小贴士

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

2.4 realloc 函数

realloc函数的出现让动态内存管理更加灵活。
有时我们会发现之前申请的空间太小了，有时我们又会觉得申请的空间过大。为了合理的使用内存，我们一定会对内存的大小做灵活的调整。realloc
函数就可以做到对动态开辟内存大小的调整。

2.4.1 realloc 函数原型

函数原型如下：void* realloc (void* ptr, size_t size);
ptr 是要调整的内存地址
size调整之后新大小 返回值为调整之后的内存起始位置。

2.4.2 realloc 函数的使用

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = (int*)malloc(40);

	if (NULL != p)
	{
		perror("malloc");
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}

	int* ptr = (int*)realloc(p, 80);
//开辟新内存空间，如果空间不够，会将旧空间的数据拷贝到新的内存空间，再将旧内存空间释放，最后返回新内存空间的起始地址。

	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
	else
	{
		perror("realloc");
		return 1;
	}

	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}

	free(p);
	p = NULL;

	return 0;
}
//当我们想要对申请的内存空间的内容进行初始化时，使用calloc函数即可完成任务。

结果如下：

2.4.3 realloc 函数学习小贴士

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

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

情况1：原有空间之后有足够大的空间，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2：原有空间之后没有足够大的空间，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

三、 常见的动态内存错误

3.1 对NULL指针的解引用操作

3.1.1错误代码示例

#include <stdio.h>
#include <stdlib.h>

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

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

3.2.1错误代码示例

#include <stdio.h>
#include <stdlib.h>

int main()
{
    
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        perror(malloc);
        return 1;
    }
    
    int i = 0;

    for (i = 0; i < 20; i++)
    {
        p[i] = i ;//当i是11的时候越界访问
    }

    free(p);
    p == NULL;

    return 0;
}

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

3.3.1错误代码示例

#include <stdio.h>
#include <stdlib.h>

int main()
{
 	int a = 10;
 	int *p = &a;
 	free(p);//ok?
 	p == NULL;

	return 0;
}

结果如下：

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

3.4.1错误代码示例

#include <stdio.h>
#include <stdlib.h>

int main()
{
  int *p = (int *)malloc(10);
  if(NULL == p)
  {
  	perror("malloc");
  	return1;
  }
  for(i = 0; i < 5; i++)
  {
  	*p = i;
  	p++;
  }
 	free(p);//p不再指向动态内存的起始位置
	p == NULL;
	return 0;
}

结果如下：

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

3.5.1错误代码示例

#include <stdio.h>
#include <stdlib.h>

int main()
{
 	int *p = (int *)malloc(100);
 	 if(NULL == p)
  {
  	perror("malloc");
  	return1;
  }
	free(p);
	//p == NULL; 解决方法：指针置空
 	free(p);//重复释放
	return 0;
}

结果如下：

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

3.6.1错误代码示例

#include <stdio.h>
#include <stdlib.h>

void test()
{
	int *p = (int *)malloc(100);
 	if(NULL != p)
 	{
		 *p = 20;
 }//忘记释放不再使用的动态开辟的空间会造成内存泄漏。
	}
	int main()
	{
		 test();
		 while(1);
	}
	return 0;
}

结果如下：

3.6.2 学习小贴士

切记： 动态开辟的空间一定要释放，并且正确释放

总结