【C】​动态内存管理

  所谓动态内存管理，就是使得内存可以动态开辟，想使用的时候就开辟空间，使用完之后可以销毁，将内存的使用权还给操作系统，那么动态开辟内存有什么用呢？

  假设有这么一种情况，你在一家公司中工作，该公司开发了一款app，要有用户来使用这款app，那么添加用户信息的时候需要开辟内存空间，但是该开辟的内存空间又是不确定的，开辟小了不够用，开辟多了又会浪费内存空间，以后如果继续有用户使用该app，又需要开辟内存空间，所以这个时候就需要动态开辟内存空间，要用的时候就开辟，不用的时候就销毁，这就是动态内存管理存在的意义。

  学习动态内存管理主要是学习 4 个函数，分别是malloc，free，calloc，realloc 这四个函数，这几个函数都被包含在 stdlib.h 头文件里，使用的时候需要包含头文件stdlib.h。接下来就来依次讲解这四个函数。

  值得注意的一点是，动态内存管理对于以后学习数据结构是必要知识，只有学好了动态内存管理，才能学好数据结构。

目录

1  malloc函数

2  free函数

3  calloc函数

4  realloc函数

5  动态内存的注意事项

1） 一定要检查动态开辟内存是否成功

2） 防止对非动态开辟的内存进行释放

 3） 要避免使用free函数释放一部分动态开辟内存

4） 防止对同一块内存空间进行多次释放 

5） 动态开辟内存后，一定要记得使用free函数释放

6  柔性数组

1） 柔性数组的定义

2） 柔性数组的特点

 3） 柔性数组的使用

4） 柔性数组的优势

7  C/C++在内存中的区域划分

1  malloc函数

使用malloc函数时，需要注意以下几点：

使用malloc函数的例子如下：

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

int main()
{ 
  //malloc返回值需要强转为int*
  int num = 0;
  scanf("%d", &num);
  int* arr = (int*)malloc(sizeof(num) * 20);//参数为字节
  //使用malloc的时候一定要判断返回值，如果开辟失败，那么退出程序
  if (arr == NULL)
  {
    //perror函数的功能为打印错误信息
    perror("malloc fail！\n");
    //exit为退出函数
    exit(1);
  }
  //开辟成功
  for (int i = 0; i < num; i++)
  {
    scanf("%d", &arr[i]);
  }
  for (int i = 0; i < num; i++)
  {
    printf("%d ", arr[i]);
  }

  return 0;
}

运行结果：

  在上述代码中， 共开辟了10个空间，依次向arr数组里面输入了1,2,3,4,5,6,7,8,9,10这10个数据。

  在代码中最关键的一段代码就是判断malloc返回值与强转的那两段代码，在动态开辟数据时，一定要判断​malloc函数返回值，也就是判断有没有成功动态开辟内存空间。

2  free函数

  free函数的功能主要是用来释放动态开辟的空间，也就是将内存空间的使用权归还给操作系统，其注意事项有以下两条：

  free函数一般是配合其他动态开辟内存的函数使用，如malloc函数，还有之后的calloc，realloc函数，值得注意的一点是，动态开辟的内存一定要使用free函数释放掉内存，否则可能会出现内存泄露的情况，正确使用free函数的例子如下：

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

int main()
{ 
  //malloc返回值需要强转为int*
  int num = 0;
  scanf("%d", &num);
  int* arr = (int*)malloc(sizeof(num) * 20);//参数为字节
  //使用malloc的时候一定要判断返回值，如果开辟失败，那么退出程序
  if (arr == NULL)
  {
    //perror函数的功能为打印错误信息
    perror("malloc fail！\n");
    //exit为退出函数
    exit(1);
  }
  //开辟成功
  for (int i = 0; i < num; i++)
  {
    scanf("%d", &arr[i]);
  }
  for (int i = 0; i < num; i++)
  {
    printf("%d ", arr[i]);
  }
  
  //使用完之后用free函数销毁动态开辟的空间
  free(arr);
  //释放完之后记得要把指针置为NULL，否则arr会变成野指针
  arr = NULL;
  return 0;
}

  在上述代码中，使用完free函数释放了arr指针所指向的动态开辟的空间，也就是把动态开辟的空间还给了操作系统，但是arr指针本身还是指向原来动态开辟的空间，所以释放完之后，要把arr置为NULL，否则arr就变成了野指针，会越界访问。

3  calloc函数

  calloc函数不同于以上两个函数，calloc函数有两个参数，第一个参数是想要动态开辟空间的元素个数，另一个参数是想要动态开辟的每个元素的字节大小，如开辟10个整型空间，就可以这样写：

calloc(10, sizeof(int))

使用calloc函数的例子如下：

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

int main()
{
  int* arr = (int*)calloc(10, sizeof(int));
  //开辟失败
  if (arr == NULL)
  {
    perror("calloc fail！\n");
    exit(1);
  }
  //开辟成功
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", arr[i]);
  }
  //使用完之后要释放
  free(arr);
  //释放完之后置为NULL
  arr = NULL;
  return 0;
}

运行结果：

4  realloc函数

  realloc函数是这四个函数里面最复杂的一个函数，其最复杂就是因为其能够实现增容。

  不管是前面的malloc函数，还是calloc函数都只能实现动态开辟一块空间，并不能根据已有空间来实现增容的效果，而realloc函数可以在原有空间的基础上实现对原有空间的扩大，所以有了realloc函数就可以对内存空间做灵活的调整了。

   使用realloc函数的注意事项如下：

  对于realloc函数增容，有两种情况：

 1） 如果原有空间之后有足够的空间来进行增容，那么就会在原有空间之后追加空间，原有空间数据不变，返回值与第一个参数相同。

  2） 如果原有空间后面的空间不够要增容的空间大小，那么就会在内存的堆区上另找一块内存空间大小（原有空间 + 要增容的空间）足够的连续空间，并把原有空间的数据复制到新开辟的空间上，然后释放旧空间，返回新开辟空间的首元素地址。

  使用realloc函数的例子如下：

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

int main()
{
  int n = 0;
  scanf("%d", &n);
  int* arr = (int*)malloc(sizeof(int) * n);
  //先用一个中间变量来接收增容后的地址
  int* tmp = (int*)realloc(arr, sizeof(int) * 2 * n);
  //开辟失败
  if (tmp == NULL)
  {
    perror("realloc fail！\n");
    exit(1);
  }
  //开辟成功，将增容后空间地址赋给原有空间地址
  arr = tmp;
  n = 2 * n;
  for (int i = 0; i < n; i++)
  {
    scanf("%d", arr + i);
  }
  for (int i = 0; i < n; i++)
  {
    printf("%d ", arr[i]);
  }
  
  //使用完之后要销毁
  free(arr);
  //销毁之后置为NULL
  arr = NULL;
  return 0;
}

运行结果：

  需要注意的一点是，在使用realloc函数增容的时候，一定要先用一个中间变量接受增容后的地址，一定要在确保开辟成功之后，再把增容后的地址赋给旧空间的地址，要是直接赋给旧空间的地址，一旦开辟失败，那么旧空间就找不到了。

5  动态内存的注意事项

1） 一定要检查动态开辟内存是否成功

  如果不检查动态开辟空间函数的返回值，如果开辟失败就会造成NULL指针的解引用，如：

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

int main()
{
  int* arr = (int*)malloc(sizeof(int));
  *arr = 10;
  
  free(arr);
  arr = NULL;
  return 0;
}

  在上述代码里面，开辟成功了还好，一旦开辟失败就会造成对NULL指针的解引用，势必会报错，正确的代码应该这样写：

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

int main()
{
  int* arr = (int*)malloc(sizeof(int));
  //检查返回值是否为NULL
  if (arr == NULL)
  {
    perror("malloc fail！\n");
    exit(1);
  }
  //开辟成功
  *arr = 10;
  
  free(arr);
  arr = NULL;
  return 0;
}

2） 防止对非动态开辟的内存进行释放

  对非动态开辟的内存进行free函数释放，其行为是未知的，如以下这个代码：

#include<stdlib.h>

int main()
{
  int arr[] = {1, 2, 4};
  free(arr);

  return 0;
}

在运行的时候会出现下面这种情况：

 3） 要避免使用free函数释放一部分动态开辟内存

  在使用free函数释放动态开辟空间时，很容易让指向动态开辟空间的指针改变指向位置，如：

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

int main()
{
  int* ptr = (int*)malloc(sizeof(int) * 10);
  if (ptr == NULL)
  {
    exit(1);
  }
  for (int i = 0;i < 10; i++)
  {
    scanf("%d", ptr + i);
  }
  
  printf("%p ", ++ptr);
  free(ptr);
  ptr = NULL;
}

  在上述代码里面，在释放空间的时候，ptr指针已经不再指向原来动态开辟空间的首元素的地址，而是指向的是第二个元素的地址，在运行代码时，vs编译器也会发生错误：

  所以在动态开辟内存后，我们要避免改变动态开辟内存指针的指向。

4） 防止对同一块内存空间进行多次释放 

#include<stdlib.h>

int main()
{
  int* ptr = (int*)malloc(40);
  if (ptr == NULL)
  {
    exit(2);
  }
  free(ptr);
  free(ptr);
  return 0;
}

 运行后，同样会发生错误：

  所以在使用free函数释放完空间之后，一定要记得把指针置为NULL，防止对其多次释放。

5） 动态开辟内存后，一定要记得使用free函数释放

  动态开辟的内存会在以下两种情况下归还给操作系统：

（1） 程序运行结束时

（2） 使用free函数释放时

  所以一旦一个程序不停止运行，而又没有free函数主动释放内存，就会造成动态开辟的空间一直占用，内存空间越来越少，就会造成内存空间的浪费，也就是内存泄露。

6  柔性数组

1） 柔性数组的定义

  在一个结构体里面，最后一个元素允许是未知大小的数组，这个数组就叫做柔性数组成员。注意，柔性数组一定是在结构体里面创建的。

  上述定义可能比较抽象，下面举个例子：

struct A
{
  int i;
  int a[0];
};

  上述代码里面的a数组就是柔性数组成员，数组元素个数为0，代表没有成员。如果上述代码在编译器报错的话，也可以写成以下代码：

struct A
{
  int i;
  int a[];
};

  上述代码的a数组也是柔性数组，数组里面的元素个数不写，也代表数组里面没有元素。

2） 柔性数组的特点

  柔性数组的特点如下：

如：

#include<stdio.h>

typedef struct A
{
  int i;
  int a[0];
}A;

int main()
{
  int size = sizeof(A);
  printf("%d ", size);

  return 0;
}

运行结果为：

通过上述代码，可以看到，含有柔性数组成员的结构体A，其大小确实为4个字节，不包含柔性数组成员a数组的大小。 

 3） 柔性数组的使用

  对于含有一个柔性数组成员的结构体，应该使用malloc函数来动态开辟空间，例如：

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

typedef struct A
{
  int x;
  int a[0];
}A;

int main()
{
  A* pa = (A*)malloc(sizeof(A) + 10 * sizeof(int));
  //判断是否开辟成功
  if (pa == NULL)
  {
    perror("malloc fail！\n");
    exit(1);
  }
  pa->x = 10;
  for (int i = 9;i >= 0; i--)
  {
    pa->a[i] = i;
  }
  printf("%d ", pa->x);
  for (int i = 0;i < 10;i++)
  {
    printf("%d ", pa->a[i]);
  }
  //使用完不要忘记销毁
  free(pa);
  //释放后要置为NULL
  pa = NULL;

  return 0;
}

运行结果为：

上述代码在使用malloc函数开辟带有柔性数组结构体成员的内存空间时，malloc函数里面的参数应写的是 sizeof(A) + sizeof(int) * 10 ，而不是直接写字节个数，这样写不仅不用计算结构体的大小（结构体存在内存对齐现象，计算起来比较麻烦），而且比较直观，后面的 sizeof(int) * 10 就是为柔性数组成员开辟的空间。

4） 柔性数组的优势

  其实上述柔性数组的功能也可以通过在结构体里添加一个指针变量来达到，如：

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

typedef struct A
{
  int x;
  int* pi;
}A;

int main()
{
  A* pa = (A*)malloc(sizeof(A));
  if (pa == NULL)
  {
    perror("malloc1 fail！\n");
    exit(1);
  }
  pa->x = 10;
  pa->pi = (int*)malloc(sizeof(int) * 10);
  if (pa->pi == NULL)
  {
    perror("malloc2 fail！\n");
    exit(2);
  }
  for (int i = 9;i >= 0;i--)
  {
    pa->pi[i] = i;
  }
  printf("%d ", pa->x);
  for (int i = 0;i < 10;i++)
  {
    printf("%d ", pa->pi[i]);
  }
  //一定要先释放结构体里开辟的数组空间
  free(pa->pi);
  //再释放开辟的结构体空间
  free(pa);
  pa = NULL;

  return 0;
}

运行结果为：

可以看到在结构体里添加一个指针变量同样可以达到类似于柔性数组的功能，那么柔性数组相比于用指针来实现有什么优势呢？

7  C/C++在内存中的区域划分

  C语言或者C++语言共将内存空间划分为以下几个区域：