动态内存管理

已于 2023-04-30 09:31:57 修改
阅读量546 收藏 1
点赞数 2
分类专栏： 呕心沥血C语言 文章标签： c# c++ 算法
于 2023-04-26 23:33:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/130395977
版权

文章目录

1.动态内存函数

1.1free

#include<stdlib.h>
void free(void* ptr);

释放动态开辟的内存空间

  ptr 指向空间不是动态开辟的， free 函数行为未定义。

  ptr 是 NULL ， free 不会执行任何动作。

  一定要使用 free 函数释放所开辟的内存空间。

  free 之后要将其置为空指针。

1.2malloc

#include<stdlib.h>
void* malloc(size_t size);
int* p = (int*)malloc(10*sizeof(int));

C语言动态内存开辟函数
向内存申请一块连续可用空间
返回指向这块空间的指针

     ① 开辟成功，返回一个指向开辟空间的指针。
 
     ② 开辟失败，返回一NULL 指针。

     ③ 返回值类型 void* ，使用者决定开辟空间类型

     ④  size == 0的行为标准未定义，结果取决于编译器。

1.3calloc

#include<stdio.h>
void* calloc(size_t num,size_t size);

为num 个， size大小的元素开辟空间
把每个字节初始化 0
返回一个指向此内存的指针。

1.4realloc

#include<stdio.h>
void* realloc(void* ptr,size_t size);

函数讲解：

重新调整 malloc 或 calloc 分配内存块的大小
对动态开辟的内存进行大小调整
ptr 指向要调整的内存地址
size 为调整之后的大小
返回调整之后内存起始位置，失败返回空指针
调整原内存空间大小
将原来内存中数据移动到新空间

调整内存空间时三种情况：

  情况1：原空间后有足够空间：直接追加

  情况2：原空间后无足够空间，在堆空间上找一块大小合适的连续空间存放

  情况3：找不到合适空间：返回空指针

2.动态内存错误

2.1解引用空指针–非法访问内存

错误示例：

int main()
{
    int* p = (int*)malloc(9999999999);
    for (int  = 0; i < 10; i++) 
        *(p + i) = i; 
    return 0;
}

解决办法：

int main()
{
    int* p = (int*)malloc(9999999999);
    if (p == NULL) 
    {
        perror("malloc");
        return 1;
    }
    for (int  = 0; i < 10; i++) 
        *(p + i) = i; 
    return 0;
}

2.2越界访问动态空间

错误示例：

int main()
{
    int* p = (int*)malloc(10*sizeof(int)); 
    if (p == NULL)
     {
        perror("malloc");
        return 1;
    }
    int i = 0;
    for (int i = 0; i < 40; i++) 
        *(p + i) = i;
    free(p);
    p = NULL;
    return 0;
}

解决办法：

使用空间时，注意所开辟空间大小。

2.3free释放非动态空间

错误示例：

int main()
{
    int arr[10] = {0}; 
    int* p = arr;
    free(p); 
    p = NULL;
    return 0;   
    代码卡死
}

解决办法：

分清所用空间是否为动态开辟空间

2.4free释放部分动态空间

错误示例：

int main()
{
    int* p = malloc(10*sizeof(int));
    if (p == NULL)
        return 1;
     for (int i = 0; i < 5; i++) 
        *p++ = i;
    free(p);
    p = NULL;
    程序崩溃，原内存起始位置遗忘，存在内存泄漏风险
    return 0;
}

解决办法：

定义临时指针变量tmp记录起始位置。

2.5free多次释放动态空间

错误示例：

int main()
{
    int* p = malloc(10*sizeof(int));
    if (p == NULL) 
        return 1;
    for (int i = 0; i < 10; i++) 
        p[i] = i;
    free(p);
    free(p);
    代码卡死
    return 0;
}

解决办法：

free(p);
p = NULL;
free(p); // p为空，free无操作

2.6未释放动态内存

错误示例：

void test()
{
    int* p = (int*)malloc(100);
    if (p == NULL) 
        return;
}
 int main()
{
    test();
    free(p); 
   // test()函数调用结束后，p被销毁，所申请的100个字节内存块地址被遗忘。
    p = NULL;
}

提醒：

1.内存泄漏（Memory Leak）： 程序中已动态分配的堆内存由于某种原因，程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。
2.动态开辟的内存空间回收方式：
主动释放（free）
程序结束

3.动态内存题目

3.1形参不影响实参

错误示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char *p) 
{
    p = (char*)malloc(100);
}
void Test() 
{
    char *str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
int main() 
{
    Test();
    return 0;
}

str 传给 GetMemory 函数时为值传递，GetMemory 函数的形参 p 是 str 的一份临时拷贝。GetMemory 函数内部动态开辟的内存空间地址存放在 p 中，不影响 str。当 GetMemory 函数返回后
1.str 仍是 NULL，导致 strcpy 拷贝失败。
2.形参 p 销毁，没有及时使用 free 释放，导致动态开辟的100个字节存在内存泄露问题
程序卡死。

解决办法：
1：str传参，str接收p

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory(char *p) 
{
    p = (char*)malloc(100);
    return p;
}
 void Test() 
 {
    char *str = NULL;
    str = GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL; 
}
 int main() 
 {
    Test();
    return 0;
}

2：值传递改为址传递

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char** p) 
{
    *p = (char*)malloc(100);
}
 void Test()
  {
    char *str = NULL;
    GetMemory(&str); 
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL; 
}
 int main() 
 {
    Test();
    return 0;
}

3.2地址返回，空间已无

#include <stdio.h>
#include <stdlib.h>
 char* GetMemory(void) 
 {
    char p[] = "hello world";
    return p;
}
 void Test(void)
  {
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
int main() 
{
    Test();
    return 0;
}

GetMemory 函数内部数组p在栈区上创建，函数调用结束， 数组p的空间还给操作系统。返回的地址没有实际意义，若通过返回的地址访问内存，导致非法访问内存问题。

3.3忘记释放动态内存

错误示例：

#include <stdio.h>
#include <stdlib.h>
void GetMemory(char **p, int num) 
{
    *p = (char *)malloc(num);
}
 void Test(void) 
 {
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
} 
int main() 
 {
    Test();
    return 0;
}

解决办法：

#include <stdio.h>
#include <stdlib.h>
 void GetMemory(char **p, int num) 
{
    *p = (char *)malloc(num);
}
 void Test(void) 
 {
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
   
    free(str);
    str = NULL;
    
}
 int main() 
 {
    Test();
    return 0;
}

3.4free后未置空

错误示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 void Test(void) 
 {
    char *str = (char *) malloc(100);
    strcpy(str, "hello");
    free(str);
    //if为真，非法访问已释放内存
    if(str != NULL) 
    {
        strcpy(str, "world");
        printf(str);
    }
}
 int main() 
{
    Test();
    return 0;
}

解决办法：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 void Test(void) 
 {
    char *str = (char *) malloc(100);
    strcpy(str, "hello");
    free(str);
    str = NULL; 
    if(str != NULL) 
    {
        strcpy(str, "world");
        printf(str);
    }
}
 int main() 
 {
    Test();
    return 0;
}

4.C/C++程序内存开辟

1．栈区（stack）

执行函数时，函数内部局部变量的存储单元在栈上创建。函数执行结束后这些存储单元自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配内存容量是有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2．堆区（heap）

一般由程序员自主分配释放，若程序员不主动不释放，程序结束时可能由操作系统回收。分配方式类似于链表。

3．数据段（data segment）

静态存储区，存放全局变量和静态数据，程序结束后由系统释放。

4．代码段（code segment）

存放函数体（类成员函数和全局函数）的二进制代码。

5.图解

图片来自于比特科技C语言进阶课件

在这里插入图片描述

5.柔性数组

5.1介绍

柔性数组（Flexible Array），又称可变长数组。一般数组长度在编译时确定，而柔性数组长度在运行时确定。在定义结构体时创建一个空数组（例如：arr [ 0 ] ），该数组的大小可程序运行过程中按照需求变动。

struct S {
    int n;      至少一个其他成员
    int arr[];  柔性数组成员
    int arr[0]; 柔性数组成员
};
int main() 
{   此结构大小不包含柔性数组成员
    struct S s = {0};
    printf("%d\n", sizeof(s));//4
    此结构用 malloc 函数分配的内存应大于结构大小，以适应柔性数组预期大小
    struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int));
    return 0;
}

5.2使用

#include <stdio.h>
#include <stdlib.h>
struct S 
{
    int n;
    int arr[0];
};
 int main() 
 {
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
    ps->n = 10;
    for (int i = 0; i < 10; i++) 
        ps->arr[i];
    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20*sizeof(int));
    if (ptr != NULL) 
        ps = ptr;
    free(ps);
    ps = NULL;
    return 0;
}

5.3优点

5.3.1使用柔性数组

#include <stdio.h>
#include <stdlib.h>
struct S 
{
    int n;
    int arr[0];
};
 int main() 
 {
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(int));
    ps->n = 10;
    for (int i = 0; i < 10; i++) 
        ps->arr[i];
    struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20*sizeof(int));
    if (ptr != NULL) 
        ps = ptr;
    free(ps);
    ps = NULL;
    return 0;
}

5.3.2使用指针

#include <stdio.h>
#include <stdlib.h>
struct S 
{
    int n;
    int* arr;
};
int main() 
{
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if (ps == NULL)
        return 1;
    ps->n = 10;
    ps->arr = (int*)malloc(10 * sizeof(int));
    if (ps->arr == NULL)
        return 1;
    for (int i = 0; i < 10; i++) 
        ps->arr[i] = i;
    int* ptr = (struct S*)realloc(ps->arr, 20 * sizeof(int));
    if (ptr != NULL) 
        ps->arr = ptr;
    free(ps->arr); 
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}

5.3.3代码分析

使用柔性数组的优势：
1.利于内存释放

2使用指针完成，两次 malloc ，两次 free ，更易出错。若整个结构体返回用户，用户调用 free 释放结构体，但用户不知道结构体内成员也需要 free。把内存一次性分配好，返回用户一个结构体指针，用户只需使用一次 free 就可以把所有内存释放，间接减少内存泄露可能性。

2.利于访问速度，减少内存碎片

连续内存益于提高访问速度，减少内存碎片。
malloc 次数越多，产生的内存碎片越多，这些内存碎片再被利用的可能性很低。内存碎片越多，内存的利用率越低。频繁的开辟空间效率变低，碎片增加。

阿猿收手吧！
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
操作系统实验：连续内存分配管理模拟
qq_64175477的博客
12-01 581
执行逻辑：若无满足要求大小的空闲区，则显示无法分配的消息并退出，否则依据最先适应分配算法找到空闲区，分配给作业（有可能需要对空闲区进行切割），并在已分配链表中进行登记。执行逻辑：在已分配链表中找到给定的作业名对应的项，将对应的内存回收，修改已分配链表和空闲区链表（有可能需要在空闲区链表中进行合并）已分配内存空间情况（作业名，起始地址, 长度）和空闲区情况（起始地址，长度）初始的内存大小为100000字节。进行空闲区和已分配空间的管理。输入：作业名 要求的内存大小。3 显示内存分配情况。
操作系统原理与实验——实验八连续存储管理方式的模拟与实现(可变分区)
最新发布
m0_62806440的博客
04-01 774
①写程序之前的逻辑思路非常重要②当遇到难理解的地方时一定要多想③调用函数创建的单链表要注意是否要return，如果是带头节点的可以不用返回值，如果不是带头节点的要返回单链表④最大的体会是在调用函数中创建的节点和调用函数中定义的变量二者的生存期不同。
【C语言】动态内存管理
2201_75406088的博客
10-15 200
1、动态内存所开辟的空间都是在堆上开辟的；
计算机操作系统——连续存储分配管理
TTTSEP9TH2244的博客
01-17 2126
一、 实验目的 1） 理解内存管理相关理论； 2） 掌握连续内存管理理论； 3） 掌握动态连续内存管理理论。 二、实验仪器设备 计算机1台、VC++ 6.0 三、实验原理或算法 连续内存分配：为一个用户程序分配一个连续的内存空间，它分为单一连续分配，固定分区分配和动态分区分配，在本实验中，我们主要讨论动态分区分配。 动态连续分配：根据进程的实际需要，动态地为之分配内存空间。在实现可变分区分配时，将涉及到分区分配中的所用的数据结构、分区分配算法和分区的分配与回收操作这几个问题。 分区分配中的数据结构 (1)
连续动态内存管理模拟实现
05-15
C语言首次适应算法实现，连续动态内存管理模拟实现，对大小为64M的内存进行分配管理
glibc动态内存管理
01-07
malloc函数有两种不同的内存分配方法，这取决于开辟空间的大小或用户传入的具体参数，最常见的分配方法是从一大块连续的内存区域分配一部分出来，并管理这些相邻的区块以优化其使用和减少浪费不可用块。传统系统的堆...
一个动态内存管理模块的实现
11-30
引言 当前，绝大多数嵌入式平台上的软件都采用C语言编写。除了代码简洁、运行高效之外，灵活操作内存的能力更是C语言的重要特色。然而，不恰当的内存操作通常也...为此，本文介绍一个增强的、可定制的动态内存管理模块
MCU动态内存管理
11-09
基于C语言在单片机上实现的动态内存管理机制，该机制不会产生内存碎片，测试通过！
[C]详解C语言动态内存分配
qq_59456417的博客
10-21 824
详解C语言动态内存管理，解析malloc、free、calloc、realloc函数的使用和注意事项。
【操作系统】实验三 存储管理的模拟程序设计
sailven的博客
10-25 2345
操作系统实验三。时间：2020-11-27。
模拟操作系统动态内存管理（c实现）
lyd0813的博客
10-29 625
操作系统对内存申请与释放（对连续的区域合并）的模拟 1 #include &lt;stdio.h&gt; 2 #include &lt;stdlib.h&gt; 3 #define N 10 //预设的内碎片的最小值 4 #define M_set 1024//预设的内存大小 5 6 struct mem_block 7 { 8 int ...
连续动态内存管理模拟实现_「巨杉数据库SequoiaDB」巨杉Tech|巨杉数据库的并发 malloc 实现...
weixin_39566593的博客
11-28 153
本文由巨杉数据库北美实验室资深数据库架构师撰写，主要介绍巨杉数据库的并发malloc实现与架构设计。原文为英文撰写，我们提供了中文译本在英文之后。SequoiaDB Concurrent malloc ImplementationIntroductionIn a C/C++ application, the dynamic memory allocation function malloc(3) ...
JavaScript 工作原理之三－内存管理及如何处理 4 类常见的内存泄漏问题(译)
weixin_34279579的博客
05-01 215
原文请查阅这里 本系列持续更新中，Github 地址请查阅这里。 这是 JavaScript 工作原理的第三章。 我们将会讨论日常使用中另一个被开发者越来越忽略的重要话题，这都是日益成熟和复杂的编程语言的锅，即内存管理问题。我们将会提供在创建 SessionStack 的时候所遵循的处理 JavaScript 内存泄漏的几条小技巧，因为我们需要保证 SessionStack 不会引起内存泄漏或...
动态内存管理详解
eternal_yy
11-29 3030
C语言中开辟内存有很多种方式，目前我们最常用的也就是数组，但数组是在我们用到他之前就得设定好它的长度，有时很不方便。 我们知道，c语言规定，不允许设定一个未知长度的数组。（但在Linux下可以设定，但也不支持这样做）下面这段代码就会报错哟！！！ int x = 5; int arr[x];  所以，为了填补这一缺口，c语言有了动态内存，c语言提供了几个函数来管理我们的动态内存，这几个函数...
c++ 动态内存管理类
03-28
C++中的动态内存管理类主要是指智能指针类，它们用于管理动态分配的内存，可以自动释放内存，避免内存泄漏和悬空指针的问题。C++标准库提供了两种主要的智能指针类：shared_ptr和unique_ptr。 1. shared_ptr：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿猿收手吧！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值