【C语言】深度解析：动态内存管理的机制与实践

请添加图片描述

🔥引言

本篇将深度解析:动态内存管理的机制。为了更加灵活分配内存中的空间，库中为了我们提供了一些的函数，去动态开辟和释放堆上的空间。

请添加图片描述
Alt

🌈个人主页：是店小二呀
🌈C语言笔记专栏：C语言笔记
🌈C++笔记专栏： C++笔记

🌈喜欢的诗句:无人扶我青云志我自踏雪至山巅
请添加图片描述

文章目录

【前文】
【正文】
一、动态内存开辟函数
- 1.1 malloc
- 1.2 calloc
- 1.3 malloc和calloc区别
- 1.4 realloc（动态内存扩容）
- - 1.4.1 关于realloc扩展空间的两种情况:
二、free(释放动态开辟内存)
三、动态内存的常见错误
四、柔性数组(flexible array)
- 4.1 柔性数组的特点
- 4.2 柔性数组的使用
五、C/C++中程序内存区域规划

【前文】

目前我们掌握申请内存的方式有两种:
int a=0;//直接开辟空间

int arr[10]={0};//连续开辟空间

上面两种开辟空间的方式存在一些问题:

栈空间开辟的空间大小是固定的
数组在声明时，必须指定数组的长度(一定确定大小不能被调整)

以上不能够灵活地处理内存问题，有时候是需要的空间大小在程序运行时才能知道，那么数组在编译时开辟空间的方式就不能得到满足。

对此，为了更灵活地使用空间，C语言标准库提供了程序员在堆上申请和释放空间的函数

【正文】

C语言标准库提供申请和释放动态内存空间的库函数，声明在stdlib.h头文件中。

一、动态内存开辟函数

【温馨提示】:

以下三种动态内存开辟函数，都有可能会出现开辟失败的情况，对此返回值为空，通过判断指针是否为空，做出及时的处理。在OJ需要开辟空间时，一般不需要判断，一般不会开辟失败。

1.1 malloc

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *p=(int *)malloc(10*sizeof(int))
        if(p==NULL)
        {
            perror("malloc fail!!!")
                return 1;
        }
    free(p)
        p=NULL;
    return 0;
}

【说明】:

向内存申请空间不完成初始化，返回指向这块空间的大小
malloc是void*类型，当我们申请空间时候，需要知道申请空间交给什么类型去维护
如果参数size为0，malloc可能会报错(取决于编译器)
同时申请空间有时候不一定会成功。如果失败的话，将会返回一个空指针，比如申请的空间太大，就会申请失败，这一点使用的时候要去注意。

1.2 calloc

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *p=(int *)calloc(10,sizeof(int))
        if(p==NULL)
        {
            perror("calloc fail!!!")
                return 1;
        }
    free(p)
        p=NULL;
    return 0;
}

【说明】:

向内存申请空间完成初始化为0，并且返回指向这块空间的指针
因为calloc是void*类型，当我们申请空间时候，需要知道申请空间交给什么类型去维护
同时申请空间有时候不一定会成功。如果失败的话，将会返回一个空指针，比如申请的空间太大，就会申请失败，这一点使用的时候要去注意。

1.3 malloc和calloc区别

都是向堆上申请空间
参数部分不同
malloc申请空间没有初始化，calloc申请空间初始化为0

1.4 realloc（动态内存扩容）

在这里插入图片描述

int main()
{
    int *p=(int *)malloc(10*sizeof(int));
    if(p=NULL)
    {
        perror("malloc fail！！！");
        return 0;
    }
    int *pe=(int *)realloc(p,20*sizeof(int));
    if(pe=NULL)
    {
        perror("realloc fail！！！");
        return 0;
    }
    p=pe;
    free(p)
        p=NULL;
    pe=NULL;
    return 0;
}

【说明】：

申请扩展空间并返回指向扩展空间的地址
一般realloc函数的使用，是在开辟好空间的基础上进行进一步的扩容
如果第一个参数部分为空指针，那么realloc等价于malloc。同时需要注意是否开辟空间成功

【问题】:realloc需要扩容大小，是在malloc开辟空间大小的基础上追加，还是直接申请整个空间的大小

【回答】:直接申请整个空间的大小

1.4.1 关于realloc扩展空间的两种情况:

【情况一】：当内存空间足够的时候，直接在申请好的空间追加

在这里插入图片描述

【情况二】；当内存空间不够的时候，会在内存中寻找一块更大的空间存放，将目前的数据拷贝一份到新的空间位置中，再将原来的空间释放掉.

在这里插入图片描述

二、free(释放动态开辟内存)

在这里插入图片描述

【说明】:

释放动态内存空间
使用方法在上面都有体现
free参数部分是空指针，则函数什么事都不做
free非动态内存就会报错重复，行为是未定义的
重复释放同一块动态内存空间，会报错

【注意】:如果忘记去free指针指向空间，操作系统会自动的回收使用权，但是尽量能写就写，万一出现内存泄漏危险了。

三、动态内存的常见错误

对空指针的解引用操作
对动态开辟的空间越界访问
对非动态开辟的空间使用free释放
对free释放一块动态开辟空间的一部分（空间只能一整块还）
多次对一块动态内存空间使用free释放
动态开辟内存忘记释放(内存泄漏)

四、柔性数组(flexible array)

在C99中，结构体最后一个成员为未知大小的数组，这个被称为柔性数组的成员，帮助用户根据要求自己给大小，更加轻松地处理可变长度的数据结构。

typedef struct st_type
{
    int i;
    int nums[0];
}type_a;
有些编译器可能会编译失败，可以化成nums[]
    typedef struct st_type
    {
        int i;
        int nums[];
    }type_a;

4.1 柔性数组的特点

结构体中至少有一个成员在柔性数组前面(如果顺序错了，也会报错)
sizeof返回的这种结构大小是不包含柔性数组的内存，编译器在计算结构体大小时会忽略柔性数组成员
对包含柔性数组的结构体，申请空间的时候适度大于结构体的大小，以便于适应柔性数组的大小

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
int main()
{
    printf("%d\n", sizeof(type_a));//输出的是4
    return 0;
}

4.2 柔性数组的使用

【代码一】:

typedef struct st_type
{
    int i;
    int *p_a;
}type_a;
int main() 
{
    int i = 0;
    type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
    p->i = 100;

    for(i=0; i<100; i++)
    {
        p->a[i] = i;
    }
    free(p);
    return 0;
}

【代码二】:

typedef struct st_type
{
    int i;
    int *p_a;
}type_a;
int main()
{
    type_a *p = (type_a *)malloc(sizeof(type_a));
    p->i = 100;
    p->p_a = (int *)malloc(p->i*sizeof(int));

    //业务处理
    for(i=0; i<100; i++)
    {
        p->p_a[i] = i;
    }

    //释放空间
    free(p->p_a);
    p->p_a = NULL;
    free(p);
    p= NULL;
    return 0;
}