当前位置： 首页 > article >正文

动态内存管理

article 2024/11/18 17:31:23

文章目录

  • 1.动态内存函数
    • 1.1free
    • 1.2malloc
    • 1.3calloc
    • 1.4realloc
  • 2.动态内存错误
    • 2.1解引用空指针--非法访问内存
    • 2.2越界访问动态空间
    • 2.3free释放非动态空间
    • 2.4free释放部分动态空间
    • 2.5free多次释放动态空间
    • 2.6未释放动态内存
  • 3.动态内存题目
    • 3.1形参不影响实参
    • 3.2地址返回，空间已无
    • 3.3忘记释放动态内存
    • 3.4free后未置空
  • 4.C/C++程序内存开辟
    • 1．栈区（stack）
    • 2．堆区（heap）
    • 3．数据段（data segment）
    • 4．代码段（code segment）
    • 5.图解
  • 5.柔性数组
    • 5.1介绍
    • 5.2使用
    • 5.3优点
      • 5.3.1使用柔性数组
      • 5.3.2使用指针
      • 5.3.3代码分析

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 次数越多，产生的内存碎片越多，这些内存碎片再被利用的可能性很低。内存碎片越多，内存的利用率越低。频繁的开辟空间效率变低，碎片增加。


http://www.kler.cn/a/15589.html

相关文章：

  • el-table中增加校验方法（二）
  • 【MySQL】优化方向+表连接
  • Win10/11 安装使用 Neo4j Community Edition
  • 跨平台WPF框架Avalonia教程 十五
  • 【工具插件类教学】在 Unity 中使用 iTextSharp 实现 PDF 文件生成与导出
  • Spring Boot 启动时修改上下文
  • 【zotero】从知网万方维普WOS等数据库上导出格式引文-引文格式到zotero中
  • 【RPA开发】lxml 库之 etree 使用详解
  • AI智能课程：第五讲chatGPT搞定APP小程序
  • 【VM服务管家】VM4.x算法模块开发_4.2 联合OpenCV开发
  • 推荐一些免费可用的热门 API
  • JAVA面试中遇到的那些坑，80%的人都种过招
  • 【web基础】html常用标签+作品展示
  • 如何在自己的Maven工程上搭建Mybatis框架？
  • 『LogDashboard』.NET开源的日志面板——登录授权页面扩展
  • Spring Security 6.0系列【30】授权服务器篇之JOSE规范
  • 软件和信息服务业专题讲座
  • 【go】三色标记-垃圾回收机制
  • 电信运营商网络运维方案
  • FPGA入门系列12--RAM的使用
  • jsp家庭农场投入品信息管理系统Myeclipse开发mysql数据库web结构jsp编程计算机网页项目
  • python哲学
  • Vue——组合式函数
  • 流程图拖拽视觉编程-流程编辑器
  • 解决Oracle11g的SQL Loader（sqlldr）命令行中文乱码问题
  • 分享10个精美可视化模板，解决95%的大屏需求！