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

码农世界 2024-06-04 后端 109 次浏览 0个评论

🔥引言

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

🌈个人主页：是店小二呀

🌈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 #include 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 #include 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; }
        
        【说明】:
        
        就是在一块空间内再开辟一块空间使用。
        第一种和第二种都能实现相同的效果，但是第一种有两个好处
        【第一个好处】:
        
        如果里面做了二次内存分配，并把整个结构体返回给用户。当用户需要释放空间时候，并不知道这个结构体内成员也需要free。
        如果结构体的内存以及其成员要的内存一次性分配好，返回一个结构体指针，用户只需要一次free就可以把所有的内存也给释放掉了。
        【第二个好处】:连续的内存有益于提高访问速度，也有益于减少内存碎片
        
        五、C/C++中程序内存区域规划
        
        内存分配的几个区域:
        
        栈区(stack):
        
        在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。
        栈内存分配运算内置于处理器的指令集中，效率很高，但是分的内存容量有限
        栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等
        堆区(heap)：
        一般由程序员分配释放，若程序员不释放，程序结束时可能由OS(操作系统)回收。
        
        数据段(静态区):(static)存放全局变量、静态数据。程序结束后由系统释放。
        
        代码段:存放函数体(类成员函数和全局函数)的二进制代码
        
        以上就是本篇文章的所有内容，在此感谢大家的观看！这里是店小二C语言笔记，希望对你在学习C语言中有所帮助！