@TOC

动态内存管理

前言

动态内存管理是非常重要的，以后会用到的地方非常多，主要重点内容有：

1. 动态内存函数的介绍

• malloc
• free
• calloc
• realloc

1. 常见的动态内存错误
2. C/C++动态内存开辟
3. 柔性数组

为什么要存在动态内存分配

像我们这样平时使用的变量定义，数组定义等等，这些有以下特点：

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

但是对于空间的需求，很多时候我们并不知道要使用多少，所以就引入了动态内存开辟。

动态内存函数介绍

动态内存函数开辟空间

首先要记住一点:动态内存函数开辟的空间是在堆区上

malloc和free

我们先看函数信息：

大致意思就是告诉malloc你要开辟多大内存空间，malloc给你申请，返回一个void*的指针，指向为你开辟好的空间地址。如果开辟失败则返回空指针。

我们可以用一个简单例子来说明malloc用法：

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

int main()
{
   
   
    //开辟10个整型大小
    int* p = (int*)malloc(10 * sizeof(int));
    //如果开辟失败打印错误信息
    if (p == NULL)
    {
   
   
        printf("%s\n", strerror(errno));
        return 1;
    }
    //打印开辟好的空间内容
    for (int i = 0; i < 10; i++)
    {
   
   
        printf("%d\n", *(p + i));
    }
    return 0;
}

我们可以看一下打印结果：

这样写看起来是没有任何问题的，开辟好的空间里面都是随机值并且很好的打印了出来。但实际上这样是有问题的，这就要引出free函数了

我们看函数信息：

在我们malloc向操作系统申请空间在使用完之后我们最好还给操作系统，虽然从结果上来看，这个程序结束后空间也会被操作系统回收，那如果你写出的代码出现了问题一直不结束呢？所以我们最好手动释放空间，这就要用到free这个函数了，只要将地址传给free即可。除此之外我们还有一个需要注意的点：

可以看到即使我们free之后，p的值没有改变，注意这时候我们已经将空间还给操作系统了，但是p还是指向那个地址，这时候如果有胆子比较大的通过p去访问那块空间就出大问题了，这时候就是非法访问了，所以在free之后我们还需要手动将p置为空指针才行。

以上就是我们对malloc和free的分析，所以上面那个例子的正确代码应该是：

以上就是malloc和free的用法。

我们可以总结一下：

1.malloc为你申请一定大小的空间，成功则返回void*的指针，失败则返回空指针；

2.由于返回的是void*，所以需要强制转换一下才可以使用；

3.在使用完之后要使用free手动释放空间；

4.释放后要将旧指针置为空指针；

calloc

calloc和malloc其实差不多但是有几点区别：

我们先看函数信息：

和malloc类似，但是我们要告诉calloc我们需要几个元素，每个元素大小是多少，函数参数这点和malloc有些区别，我们通过代码来举例如何使用：

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

int main()
{
   
   
    //开辟10个整型空间
    int* p = (int*)calloc(10, sizeof(int));
    //如果开辟失败打印错误信息
    if (p == NULL)
    {
   
   
        perror("calloc");
        return 1;
    }
    //打印空间的内容
    for (int i = 0; i < 10; i++)
    {
   
   
        printf("%d\n", *(p + i));
    }
    free(p);
    p = NULL;
    return 0;
}

输出：

诶，可以看到结果似乎并不是随机值，而是全部初始化为了0，没错，这也是calloc和malloc的区别，这时候我们就可以总结一下了：

以上就是calloc的介绍。

realloc

上面我们只是介绍了如何动态开辟空间，但是如果空间不够大或者过大需要调整怎么办呢，这就要用到realloc来调整了，

函数信息有些复杂，我们先简单看函数参数：

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

解释一下就是将需要调整的空间地址传过去，然后是需要调整的大小。调整成功则返回void*的指针，失败返回NULL。

但需要注意的是我们不能用旧的指针p直接接受返回值，什么意思呢？举个例子：

可以看到编译器也是给报警告了，这就是拿原来的指针直接接受，可以会造成原来空间没有回收，造成内存泄漏问题。为什么会出现这种情况呢？

我们要明白realloc的工作原理：

看懂这里我想你就明白了为什么不能直接用旧的指针来接收了，

• 第一种原因是：原来空间没有回收，会造成内存泄漏
• 第二种原因是：如果没有扩容成功，返回一个空指针原来的数据也搞丢了

所以我们只能用一个新的指针来接受realloc的返回值，然后判断不为再空赋给p，并且将p置为空指针。

正确代码如下：

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

int main()
{
   
   
    //开辟10个整型空间
    int* p = (int*)calloc(10, sizeof(int));
    //如果开辟失败打印错误信息
    if (p == NULL)
    {
   
   
        perror("calloc");
        return 1;
    }
    //假设我们要扩容到20个整型空间
    int* str = (int*)realloc(p, 20 * sizeof(int));
    if (str != NULL)
    {
   
   
        p = str;
        str = NULL;
    }
    free(p);
    p = NULL;
    return 0;
}

关于realloc还有一点需要补充的是如果给realloc传递的为NULL，那么此时realloc的功能和malloc一样。

例如：

int* p=(int* )realloc(NULL,10*sizeof(int));

此时realloc相当于malloc。

常见的动态内存错误

对空指针的解引用操作

#include <stdio.h>
#include <stdlib.h>
int main()
{
   
   
    int* p = (int*)malloc(10 * sizeof(int));
    //这里一定要注意判断是否是空指针
    for (int i = 0; i < 10; i++)
    {
   
   
        printf("%d ", *(p + i));
    }
    return 0;
}

这时候没有加判断是否为空的话，下面使用就有可能是野指针。

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

int main()
{
   
   
    int* p = (int*)malloc(100);
    if (p == NULL)
    {
   
   
        perror("malloc");
        return 1;
    }
    //越界访问
    for (int i = 0; i < 100; i++)
    {
   
   
        *(p + i) = 0;
    }
    free(p);
    p = NULL;
    return 0;
}

这段代码看起来一气呵成，但是你要是运行的话，就出问题了，你会发现程序直接挂了，卡死关都关不掉，点好几下才可以。因为这里是越界访问了，注意我们malloc开辟的空间大小是100字节，而不是100个整型的大小。

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

#include <stdlib.h>
int main()
{
   
   
    int a = 10;
    int* p=&a;
    free(p);
    return 0;
}

对于这样非动态开辟的内存空间是不可以用free来释放的，可以看到这个程序挂的还是挺严重的，直接卡死退都退不出去。

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

int main()
{
   
   
    int* p = (int*)malloc(100);
    if (p == NULL)
    {
   
   
        perror("malloc");
        return 1;
    }
    for (int i = 0; i < 25; i++)
    {
   
   
        *p = i;
        p++;//注意p移动了
    }
    free(p);
    p = NULL;
    return 0;
}

注意到p是已经移动了，我们后面free释放的是一部分空间。像这种动态内存开辟的函数你使用出问题了，大部分都是上面那种程序直接卡死的情况。

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

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

原因是p已经是释放过一次了，这时候p还是指向原来的位置，这时候已经是野指针了，再去free就会出问题

所以我们在第一次free时一定要将p置为空指针，下面如果再次free就不会出问题，free的参数为NULL什么事都不做。

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

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

这种情况一定要注意，这时候如果你发现问题，想释放都来不及了，因为在函数里面的参数一出函数就销毁了，你找都找不到那个地址。

为了避免这种情况我们要注意的有：

malloc和free一定要成对出现使用，

如果在函数内部使用且不想在函数内部释放要写清楚注释：

例如：

//test函数内部进行了malloc操作，返回了开辟空间的起始地址，记得释放
int* test()
{
   
   
    int* p = (int*)malloc(100);
    if (NULL != p)
    {
   
   
        *p = 20;
    }
    return p;
}
int main()
{
   
   
    int* ptr=test();
    free(ptr);
    ptr = NULL;
    while (1);
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

C/C++程序的内存开辟

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

柔性数组

柔性数组定义

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员 。

typedef struct st_type
{
   
   
int i;
int a[];//柔性数组成员--有些编译器可能要写成a[0]
}type_a;

柔性数组的特点

• 柔性数组成员的前面至少有一个成员
• sizeof计算结构体大小不包括柔型数组的大小
• 包含柔型数组的结构应该用malloc动态分配内存

使用举例：

struct S
{
   
   
    int n;
    char arr[];//柔型数组成员
};
int main()
{
   
   
    //柔型数组空间的开辟
    struct S* pc = (struct S*)malloc(sizeof(int) + 10 * sizeof(char));
    if (pc == NULL)
    {
   
   
        perror("malloc");
        return 1;
    }
    //使用
    for (int i = 0; i < 10; i++)
    {
   
   
        printf("%d\n", pc->arr[i]);
    }
    //释放空间
    free(pc);
    pc = NULL;
    return 0;
}

柔型数组优势

以上面例子，我们使用另外一种方式同样可以达到效果，如：

struct S
{
   
   
    int n;
    char* str;
};

int main()
{
   
   
    struct S* pc = (struct S*)malloc(sizeof(struct S));
    if (pc == NULL)
    {
   
   
        perror("malloc->pc");
        return 1;
    }
    char* ps = (char*)malloc(10 * sizeof(char));
    if (ps == NULL)
    {
   
   
        perror("malloc->ps");
        return 1;
    }
    pc->str = ps;
    ps = NULL;
    for (int i = 0; i < 10; i++)
    {
   
   
        printf("%d\n", *(pc->str + i));
    }
    free(ps);
    ps = NULL;
    free(pc);c
    pc = NULL;
    return 0;
}

我们来对比一下两种方法

首先一点就是两次malloc在实际场景中肯定要比使用一次容易出错，你可能忘记释放空间或者多种情况。

其次还有一个概念叫做内存碎片，

所以我们可以总结一下，

• 第一个好处是：方便内存释放
  如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

• 第二个好处是：这样有利于访问速度

  连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）