前言：

 在前面的静态库通讯录这篇博客中，我们发现我们申请的空间是一定的，这样一定会存在内存浪费或者内存不够用的情况。数组大小一旦确定好，就会向内存申请一块固定大小的连续空间，后面再想增加或者减少空间是非常麻烦的。而今天要介绍的动态内存管理就会很好的帮助大家解决这一窘境，我们可以根据自己的需求向内存申请空，那接下来就让我们一起来看看动态内存管理都有哪些有趣的知识吧。

一、动态内存🥺：

  我们先来复习一下C语言程序编译环境下的系统内存。

当然，最常见的是这三个：

  其实实际上有5个：

栈区（Stack）：编译系统自动分配释放，主要存放 函数参数,局部变量 等 .

堆区（heap）：由程序员分配释放管理，一般由 malloc,new等内部存储函数使用， 如果没收回，程序结束时由操作系统收回。创建堆时，一般在堆的头部 用一个字节存放堆的大小；回收堆时，通过查看这个 字节的内容，可得知需要释放的多大的内存。

全局区或静态区：存放 全局变量 和 静态变量 ，程序结束时由系统释放，分为全局初始化区和全局未初始化区。

常量区：存放 常量 ，程序结束时由系统释放 。

程序代码区（上面4个区统称数据区）：存放运行 或准备运行的程序代码，由系统调度

 举一个栗子🌰大家看一看自己是否认识这些变量所属区域：

1.什么是动态内存分配：

  所谓动态内存分配，就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。

2.动态内存分配的意义：

 动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。

二、常用的动态内存函数👀：

1. malloc函数：

函数格式 ：

void* malloc (size_t size);

从它的使用格式中我们可以看出，该函数向堆区申请了一块连续的空间，同时返回的是这块空间的 指针 。

注意事项 ：

如果开辟成功，则返回一个指向开辟好空间的指针。

如果开辟失败，则返回一个 NULL 指针，故我们在使用时一定要仔细检查 malloc 函数的返回值。

返回值的类型是 void* ，即 malloc 函数并不了解开辟空间的类型，至于空间的具体类型将在使用时由使用者自己决定。

如果参数 size 为 0，则 malloc 函数的行为是标准未定义的，将会取决于编译器。 (正常人不会这么干）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
  //申请40个字节，用来存放10个整型
  int* p = (int*)malloc(40);
  if (p == NULL)//判断是否申请成功
  {
    printf("%s\n", strerror(errno));
    return 1;//申请失败就直接返回
  }
  //存放1~10
  int i = 0;
  for (i = 0; i < 10; i++)//malloc申请的是一块连续的内存空间，因此可以把它当成数组来使用。
  {
    *(p + i) = i + 1;
  }
  //打印
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(p + i));
  }
  return 0;
}

  判断是否为空指针特别重要⭐⭐⭐⭐

2.free 函数：

函数格式

void free (void* ptr);

与 malloc 函数恰好相反，free函数的作用为释放动态开辟的内存，同时没有返回值

注意事项 ：

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。很可能程序崩溃。

如果参数 ptr 是NULL指针，则 free 函数将什么都不会做。

下面的realloc，calloc都需要用free释放空间！

还有一个特别重要的点，我们先来看看下图：

 通过上图我们发现，free（p）仅仅是把 p 指针指向的这块空间归还给了操作系统，但是 p 指针还是指向这块空间，为了避免之后的非法访问，我们还需把 p 置为空指针。

3. calloc 函数：

函数格式

void* calloc (size_t num, size_t size);

calloc 函数的功能就是:为 num 个大小为 size 的元素开辟一块动态内存空间，并将空间内每个字节都初始化为 0。

与malloc的区别：

 与函数 malloc 的区别仅在于 calloc 函数在返回地址前会把申请的空间内每个字节都初始化为 0 ，其它方面完全相同。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
  int* p = (int*)calloc(10, sizeof(int));//开辟10个整型大小的空间
  if (p == NULL)
  {
    perror("aclloc");//判断是否开辟成功
    return 1;
  }
  //使用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(p + i));
  }
  //使用完了，释放空间
  free(p);
  p = NULL;
  return 0;
}
//结果：
0 0 0 0 0 0 0 0 0 0

4. realloc 函数：

函数原型

void* realloc (void* ptr， size_t size);

注意事项

ptr 指向要调整的内存地址

size 是调整之后的大小

返回值是一个指向调整之后内存起始位置的指针

若扩容失败，则返回一个空指针。这里也要对于空指针进行判断！

无论扩容还是开辟，都不初始化

4.1.realloc函数开辟空间功能：

  如果传给realloc函数的是一个空指针，此时就像调用malloc,而且不会将动态内存空间初始化。

void* realloc (NULL， size_t size);

4.2.realloc函数重新分配内存块功能：

realloc 函数的出现，使得动态内存管理更加的灵活。例如有些时侯我们觉得前面申请的空间太小了不够用，或者我们会觉得申请的空间过大了太浪费，这个时候我们就可以通过使用 realloc 函数对之前开辟的动态内存空间的大小再次进行合理的调整。

&emso;  换句话说，正是 realloc 函数才使得动态内存空间真正变得“ 动态 ”起来。

 例如,当我们在使用过程中发现我们申请来的动态内存空间不够用时，我们就可以通过使用 realloc 函数来对我们申请来的动态内存空间进行扩容：`

int main()
{
  int* ptr = NULL;
  ptr = (int*)malloc(40);
  int* p = ptr;
  if (p == NULL)
  {
    perror("malloc");
    return 1;
  }
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *p = i;
    p++;
  }
  realloc(ptr, 80);
  //空间不够用，重新分配更大的空间
    //将指针ptr指向的空间扩容至80字节
  free(ptr);
  PTR = NULL;
  return 0;
}

但哪怕是在成功扩容时，也仍会出现两种情况：当前空间与后相邻空间之间的空间是否足够 realloc 函数进行扩容操作。

扩容情况一：

 若空间足够，则直接执行扩容操作，并在扩容完成后返回指向起始位置的指针。

扩容情况二：

 若后续空间不够，则将会在堆区中重新寻找合适的空间（足以容纳下扩容后的全部空间），并将原空间内的数据全部拷贝过来，接着释放原空间，并在扩容完成后返回指向新空间起始位置的指针。

int main()
{
  int* p = (int*)malloc(5 * sizeof(int));//先用malloc申请5个整型大小的内存空间
  if (p == NULL)//判断是否开辟成功
  {
    perror("malloc");
    return 1;
  }
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    *(p + i) = 1;//把5个整型全部初始化为1
  }
  //不够用了，要再增加5个整型
  int* ptr = (int*)realloc(p, 10 * sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(ptr + i));
  }
  free(ptr);
  p = NULL;
  ptr = NULL;
  return 0;
}