动态内存管理

1.前言

目前来回顾一下想要在内存中开辟空间有哪些方法？

• 创建变量： int a = 0;//在栈上开辟了4字节的空间
• 创建数组： int arr[10] = { 0 };//在栈上开辟40字节的空间

但是这两种开辟方式都有两个特点：

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

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

2.动态内存函数的介绍

2.1 [malloc函数](malloc - C++ Reference (cplusplus.com))和free函数

用于开辟内存的函数：

void* malloc(size_t size);

这个函数能申请一块连续的指定大小为 size字节大小的内存，同时返回指向该内存的指针。

• 假若内存开辟成功，则返回一个指向开辟好的内存的指针。
• 假如内存开辟失败，则返回NULL指针，所以在使用malloc函数的时候，一定要对函数的返回进行检查，不为NULL才能继续使用。
• 要注意函数的返回值是一个空指针，可以指向任何类型空间，所以在接收返回值时，需要将其转换成我们需要的类型，再进行接收。
• 假设给malloc函数的size参数传递的值为0，此时该函数的行为是未定义的，取决于编译器。

注意：malloc函数是在堆上开辟的空间，堆上的空间的释放只能通过两种方式：

1. 等待程序运行结束自动释放。
2. 使用free函数主动释放。

用于释放内存的函数：

void free(void* ptr);

free函数用于释放在堆上开辟的内存。

• 假如ptr所指向的空间不是动态开辟的，那么该行为是未定义的，极有可能报错。
• 假若ptr的值为NULL，那么此时free函数什么都不做。

malloc和free函数的声明都在 stdlib.h头文件中。

接下来看几个例子：

int main()
{
  //代码1
  int num = 0;
  scanf("%d", &num);
  int arr[num] = { 0 };
  return 0;
}

这里的代码是会报错的，因为数组的创建方括号里的值必须是常量。要特别注意。

再看一个例子：

int main()
{
  //代码2
  int* ptr = NULL;
  ptr = (int*)malloc(num * sizeof(int));
  if (NULL != ptr)//判断ptr指针是否为空
  {
    int i = 0;
    for (i = 0; i < num; i++)
    {
      *(ptr + i) = 0;
    }
  }
  free(ptr);//释放ptr所指向的动态内存
  ptr = NULL;//是否有必要？
  return 0;
}

这里在释放了动态开辟的空间之后，是否要将指向该内存的指针变量置为空呢？这里一定是要置为空的，可以有效防止后面对该指针进行解引用操作等。这是一种较好的习惯。

看看下一段代码：

int main()
{
  int* arr = (int*)malloc(sizeof(int) * 10);
  for (int i = 0; i<10; i++)
  {
    printf("%d\n", arr[i]);
  }
  printf("\n");
  return 0;
}

通过运行结果不难发现，malloc函数开辟的空间的值是随机值。经过malloc函数开辟的空间中的值都会是默认值。这里就可以使用接下来要介绍的calloc函数了。

2.2 calloc函数

用于动态开辟内存的函数：

void* calloc (size_t num, size_t size);

• 函数的功能是：为num个大小为size的元素开辟空间，并且可以将开辟出的每个字节都初始化为0。
• calloc函数与malloc函数的差别就是：malloc函数会在返回空间首地址之前将每个字节都初始化为0。

例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *p = (int*)calloc(10, sizeof(int));
    if(NULL != p)
    {
    //使用空间，这里忽略内容。
    }
    free(p);
    p = NULL;
    return 0;
}

2.3realloc函数

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

• realloc函数可以让动态内存管理更加灵活。

• size变量的值是重新调整之后的内存空间的大小。

• realloc函数的返回值是开辟的空间的起始地址。

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

• realloc函数在对内存空间进行调整时，分为两种情况：

1. 在原空间之后有足够的空间。
2. 原有空间之后没有足够的空间。

情况1：当是第一种情况时，就会直接在原来的内存空间之后追加空间，原本内存空间中的值不发生变化，函数的返回值仍然是原来内存空间的起始地址。

情况2：由于realloca在内存中开辟的空间是连续的。所以就有可能存在在原来的空间之后没有足够的空间的情况。此时realloc函数就会在堆内存中寻找另一个合适的位置开辟空间，函数会返回新开辟的空间的起始地址，并且将原来内存中的数据拷贝进这零开辟的空间中，拷贝之后就会将原来的空间还给操作系统。

注意：当realloc开辟的空间较大时，就存在内存开辟失败的情况，此时realloc函数会返回一个空指针，所以在使用realloc函数时，一定要对其返回值是否为空进行检查。

3.常见的动态内存错误

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

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

这段代码中并没有对返回值进行检查，假若返回值为NULL那么就会有问题的。

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

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);
}

这段代码中，当i的值为10时，就会出现越界访问的问题。

3.对非动态开辟的空间进行free释放操作

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

注意：非动态开辟的空间是不能使用free函数进行释放的。

4.使用free释放动态内存开辟的空间的一部分

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

注意：不能使用free函数释放动态开辟的空间的一部分，编译器会报错的，也无法成功。

5.对同一块动态开辟的空间进行多次释放操作

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

注意：当使用free函数对动态开辟的空间释放之后，要将该指针赋值为NULL，这样以后对该指针进行操作时，就会通过报错来提示我们。就比如这段代码，当第一次free之后，就对p指针赋值为空，那么下一次进行free操作时，就不会发生任何变化。

6.动态开辟的空间忘记释放（内存泄漏）

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

注意：当动态开辟的空间我们不会再对其进行使用时，一定及时释放该内存空间，否则会造成内存泄漏的问题。虽然程序结束会自动释放动态开辟的内存，但是对于那些长期运行的服务器来讲，它们中的程序几乎一直都在运行，不会停止。那么内存泄漏就是一个致命的问题了。