C语言内存堆

已于 2023-06-17 10:29:37 修改
阅读量173 收藏
点赞数 1
分类专栏： C语言 文章标签： c语言 数据结构
于 2023-06-16 21:15:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48995611/article/details/131244256
版权

本文提供一种管理零散内存的方法，该方法封装了一个内存堆（heap）结构体，并提供对应的接口。使用时先创建一个heap，然后每次内存申请都从heap中申请，最后统一释放heap。适用于短时间存在大量内存申请的情况，且这些申请的内存生命周期相同或相近。
引用：
C语言通用双向链表

  • heap内部采用预分配大块内存的方式，然后分配时从中切割，减少系统函数malloc的调用次数，极大提高了效率。
  • 申请时从大块内存中连续切割出小内存使用，空间利用率高。
  • 多次申请内存，统一释放，降低内存管理成本。

一、数据结构

在这里插入图片描述

heap只需管理内存块的链表，每个内存块记录自己的使用信息。

typedef struct heap_block_struct heap_block_t;
struct heap_block_struct
{
    byte*       data;   /* 数据区 */
    uint32      size;   /* 数据总大小 */
    uint32      used;   /* 已使用大小 */
    LIST_NODE_T(heap_block_t) link;
};
typedef LIST_BASE_NODE_T(heap_block_t)  heap_block_lst_t;

typedef struct heap_struct heap_t;
struct heap_struct
{
    heap_block_lst_t    lst_blocks;
};

添加一个新的块：

#define HEAP_BLOCK_EXTEND_SIZE      (128 * 1024)	/* 扩展的内存块大小 */
/* 功能: 添加一个块 */
heap_block_t* heap_add_block(
    IN heap_t*      heap,
    IN uint32       size
)
{
    heap_block_t*   block;

    assert(size > 0);
    size = (size + 8- 1) & (~(8- 1));	/* 按8字节对齐 */

    block = malloc(sizeof(heap_block_t) + size);
    block->data = (byte*)(block + 1);
    block->size = size;
    block->used = 0;
    LIST_ADD_LAST(link, heap->lst_blocks, block);
    return block;
}

二、基础接口

1. 创建堆

/* 功能: 创建一个堆 */
heap_t* heap_create(
    OPT IN uint32   size	/* 可选参数, 第一个块的初始大小, 为0则使用默认大小 */
)
{
    heap_t*         heap;

    heap = malloc(sizeof(heap_t));
    LIST_INIT(heap->lst_blocks);
    heap_add_block(heap, max(size, HEAP_BLOCK_EXTEND_SIZE));
    return heap;
}

2. 释放堆

/* 功能: 释放一个堆 */
void heap_free(
    IN heap_t*      heap
)
{
    heap_block_t*   block;

    block = LIST_GET_FIRST(heap->lst_blocks);
    while (block)
    {
        LIST_REMOVE(link, heap->lst_blocks, block);
        free(block);
        block = LIST_GET_FIRST(heap->lst_blocks);
    }
    free(heap);
}

3. 从堆中申请内存（带初始化0）

/* 功能: 从堆中申请内存 */
void* heap_alloc(
    IN heap_t*      heap,
    IN uint32       size
)
{
    heap_block_t*   cur_block;
    void*           mem;

    size = (size + 8- 1) & (~(8- 1));	/* 按8字节对齐 */
    cur_block = LIST_GET_LAST(heap->lst_blocks);
    /* 如果空间不够要扩展一个块 */
    if (cur_block->used + size > cur_block->size)
    {
        cur_block = heap_add_block(heap, max(size, HEAP_BLOCK_EXTEND_SIZE));
    }
    /* 获取内存, 初始化后返回 */
    mem = cur_block->data + cur_block->used;
    cur_block->used += size;
    memset(mem, 0x00, size);
    return mem;
}

4. 从堆中申请内存（不带初始化）

/* 功能: 从堆中申请内存 */
void* heap_alloc_fast(
    IN heap_t*      heap,
    IN uint32       size
)
{
    heap_block_t*   cur_block;
    void*           mem;

    size = (size + 8- 1) & (~(8- 1));	/* 按8字节对齐 */
    cur_block = LIST_GET_LAST(heap->lst_blocks);
    /* 如果空间不够要扩展一个块 */
    if (cur_block->used + size > cur_block->size)
    {
        cur_block = heap_add_block(heap, max(size, HEAP_BLOCK_EXTEND_SIZE));
    }
    /* 获取内存, 直接返回 */
    mem = cur_block->data + cur_block->used;
    cur_block->used += size;
#ifdef DEBUG
    memset(mem, 0xCD, size);
#endif
    return mem;
}

三、封装其他常用接口

1. 字符串拷贝1

/* 功能: 从堆中申请内存并填充字符串 */
schar* heap_strdup(
    IN heap_t*      heap,
    IN schar*       str
)
{
    schar*          new_str;

    new_str = heap_alloc_fast(heap, strlen(str) + 1);
    strcpy(new_str, str);
    return new_str;
}

2. 字符串拷贝2

/* 功能: 从堆中申请内存并填充字符串 */
schar* heap_strndup(
    IN heap_t*      heap,
    IN schar*       str,
    IN uint32       n
)
{
    schar*          new_str;

    new_str = heap_alloc_fast(heap, n + 1);
    memcpy(new_str, str, n);
    new_str[n] = ‘\0’;
    return new_str;
}

3. 内存拷贝

/* 功能: 从堆中申请内存并填充 */
byte* heap_memcpy(
    IN heap_t*      heap,
    IN byte*        data,
    IN uint32       n
)
{
    byte*           new_data;

    new_data = heap_alloc_fast(heap, n);
    memcpy(new_data, data, n);
    return new_data;
}

4. 获取当前堆顶的指针

/* 功能: 获取当前堆顶 */
byte* heap_get_top(
    IN heap_t*      heap
)
{
    heap_block_t*   last_block;

    last_block = LIST_GET_LAST(heap->lst_blocks);
    return last_block->data + last_block->used;
}

5. 释放指定堆顶之后的内存

该接口配合 heap_get_top 使用，类似通过 heap_get_top 记录heap的某个状态，后续无论申请多少次内存，调用 heap_free_top 都可以直接恢复至该状态，在该状态之前申请的内存不受影响，便于某些数据结构的重用。

/* 功能: 释放指定堆顶后的内存 */
void heap_free_top(
    IN heap_t*      heap,
    IN byte*        top
)
{
    heap_block_t*   block;

    /* 定位所处的内存块, 往前遍历, 这个块之后的块全部释放掉 */
    block = LIST_GET_LAST(heap->lst_blocks);
    while (block)
    {
        if ((block->data <= top) && (top <= block->data + (uint3264)block->size))
            break;
        /* 释放后重新获取 */
        LIST_REMOVE(link, heap->lst_blocks, block);
        free(block);
        block = LIST_GET_LAST(heap->lst_blocks);
    }
    assert(block);
    /* 重置可用大小 */
    block->used = (uint32)(top - block->data);
}

测例

简单用法测试：

#define MEGA_BYTES          ((uint32)(1024 * 1024))
void test_heap1()
{
    heap_t*     heap;
    byte*       data[100]; /* 指针数组, 指针指向的内存从heap中申请 */
    schar*      str[100];
    uint32      i, j;
    byte*       heap_top;
    int32       ct = 100;
	
	/* 创建默认初始大小的堆 */
    heap = heap_create(0);
    /* 为数组前50个申请内存, 并设置值 */
    for (i = 0; i < 50; i++)
    {
        data[i] = heap_alloc(heap, 1 * MEGA_BYTES);
        memset(data[i], (int32)(i + 1), 1 * MEGA_BYTES);
        str[i] = heap_strdup(heap, "data");
    }
    /* 记录当前heap top的位置(状态) */
    heap_top = heap_get_top(heap);
    /* 反复给数组后50个申请内存, 并设置值, 每次申请前都恢复到记录的状态 */
    /* ct不论取多少, 内存都不会无限增长 */
    while (ct--)
    {
        heap_free_top(heap, heap_top);
        for (i = 50; i < 100; i++)
        {
            data[i] = heap_alloc(heap, 1 * MEGA_BYTES);
            memset(data[i], (int32)(i + 1), 1 * MEGA_BYTES);
            str[i] = heap_strdup(heap, "data");
        }
    }
	/* 数据校验 */
    for (i = 0; i < 100; i++)
    {
        for (j = 0; j < 1 * MEGA_BYTES; j++)
        {
            assert(data[i][j] == (i + 1));
        }
        assert(strcmp(str[i], "data") == 0);
    }
    /* 统一释放heap */
    heap_free(heap);
}

使用的示例：
实际情况下，mydata结构会非常复杂，不一定所有的成员都会使用到，于是使用指针保存，用到了再去申请。而这些结构体指针可能还有指针的嵌套，或者链表等等。
这种复杂数据一般都是统一释放，但释放时如果采用malloc/free的方式，就非常麻烦，需要很多的判断，此外使用过程中可能还会临时申请内存，都需要考虑。
这时候使用heap就能有效减少管理成本，而且申请时的效率极高。

/* my data结构体 */
typedef struct my_data_struct my_data_t;
struct my_data_struct
{
    heap_t*     heap;
    byte*       heap_top;

    schar*      name;
    byte*       data;
    uint32      data_len;
};

/* 功能: 创建my data */
my_data_t* my_data_create()
{
    heap_t*     heap;
    my_data_t*  mydata;

    /* 创建heap, my data的所有内存都将从heap中申请 */
    heap = heap_create(0);
    mydata = heap_alloc(heap, sizeof(my_data_t));
    mydata->heap = heap;
    /* 记录初始状态 */
    mydata->heap_top = heap_get_top(heap);
    return mydata;
}

/* 功能: 释放my data */
void my_data_free(
	my_data_t* 	mydata
)
{
    heap_free(mydata->heap);
}

/* 功能: 设置my data的数据 */
void my_data_set(
    my_data_t*      mydata,
    schar*          name,
    byte*           data,
    uint32          data_len
)
{
    heap_t*         heap;

    heap = mydata->heap;
    mydata->name = heap_strdup(heap, name);
    mydata->data = heap_memcpy(heap, data, data_len);
    mydata->data_len = data_len;
}

/* 功能: 清空my data数据, 便于重复使用 */
void my_data_clear(
	my_data_t* 	mydata
)
{
    heap_free_top(mydata->heap, mydata->heap_top);
}

void test_heap2()
{
	my_data_t*		mydata;
	byte 			data[16] = { 0 };
	
	/* 创建my data */
	mydata = my_data_create();
	/* 使用my data */
	my_data_set(mydata, "name1", data, 16);
	/* Do something... */
	/* 清空my data */
	my_data_clear(mydata);
	/* 第二次使用mydata */
	my_data_set(mydata, "name2", data, 13);
	/* Do something... */

	/* 释放mydata */
	my_data_free(mydata);
}
江小辉9914
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言入门：进阶篇03 堆内存
snowysc的博客
03-13 405
是进程的一个内存段(text,data,bss,stack,heap)由程序员手动管理特点是足够大，缺点是使用麻烦类型名*arr[n]={};i
C语言中堆内存的申请和使用
qq_58116869的博客
08-25 3018
C语言中堆内存的申请和使用
BSPlastday C语言结束(内存分配、变量声明）
weixin_48677778的博客
09-22 197
C语言结束(内存分配、变量声明）
内存管理---堆
m0_37732375的博客
02-03 3872
前言     堆内存时linux进程空间中一片可以动态扩展或者伸缩的内存区域，一般位于bss之后。 阅读《嵌入式C语言自我修养》笔记 文章目录前言一、堆内存管理二、linux堆内存管理1.mm_struct2.内存分配器3.ptmalloc2     主要有以下几个函数： #include<stdio.h> void *malloc(int size); void free(void *ptr); void
【第十一节】C语言的内存分区和堆内存使用
攻城狮7号的博客
12-04 334
堆内存的设计是为了满足程序在运行时的动态内存分配需求。在早期的计算机系统中，内存管理通常是静态的，即在编译时确定所有变量的内存分配。这种方式的缺点是缺乏灵活性，因为预先分配的内存可能会被浪费或者不足以满足程序运行时的需求。为了解决这个问题，程序员开始使用堆内存来动态地分配和释放内存。堆内存的设计使得程序员可以在运行时根据需要创建和释放内存，从而更好地适应程序运行时的需求。这种灵活性使得程序可以更加高效地使用内存资源，并且可以实现更复杂的数据结构和算法。此外，堆内存的设计也使得程序可以更加模块化。
C语言堆区（动态内存开辟）
weixin_74341685的博客
05-10 881
在内存角度（堆区）理解C语言—————动态内存开辟
C语言内存精讲.rar
03-19
通过这份“C语言内存精讲”资源，你可以系统地学习到内存管理的各种细节，包括如何有效使用栈、堆，以及如何避免和检测内存问题。熟练掌握这些知识，将使你在C语言编程中更加得心应手，提升程序的稳定性和效率。
c语言内存泄漏严重的解决方法
09-07
本文将详细介绍C语言内存泄漏的原理及其解决方法，旨在帮助开发者更好地理解和避免这类问题。 首先，我们需要理解内存泄漏的基本概念。在C语言中，内存分为栈内存和堆内存。栈内存由编译器自动管理，分配和释放都...
C语言内存泄漏及检测方法
最新发布
sunnylight218的博客
05-04 1722
C语言内存泄漏的描述、检查方法、以及解决方案介绍
c语言内存模型
01-20
我们所说的BSS段(bss segment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。 　3、栈区:由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作...
内存学习——堆（heap）
studyingdda的博客
12-09 1151
/自定义1024字节内存的数组，模拟堆//指向堆数组可用空间的首地址void *my_malloc(int size) //自定义malloc函数//记录开辟空间的首地址//malloc的空间大小//返回开辟空间的首地址void my_free(void *buf) //可用自定义malloc函数，但是无法自定义free函数，后面分析原因/* err */int i;//使用自定义的malloc函数在自定义堆数组中开辟100字节空间for (i = 0;i < 26;i++)
堆内存管理
DMWN01WLW的博客
08-07 367
堆内存是代码段当中的其中一段，特点就是大，但不能与标识符建立联系，只能与指针配合使用 C语言没有提供管理堆内存的语句，而是标准库提供了一套管理内存的函数 函数 #include<stdlib.h> void * malloc(size_t size); 功能：从堆内存中分配内存 参数： size 所申请的字节数，一般使用 sizeof 计算 返回值：所申请的内存的首地址 注意： ...
【数据结构】C语言实现堆(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
12-11 1334
使用C语言实现堆程序新手入门详解,包括堆程序每个函数的设计思路及逻辑图示物理图示,简洁明了,直观易懂,文末附程序运行完整代码.
堆内存的管理
lcxhjg的专栏
07-05 790
1.1         对于堆的管理，内核提供了两个系统调用brk和mmap。brk 用于更改堆顶地址，mmap则为进程分配虚拟地址空间。1.2         当进程向glibc申请内存时，如果申请的内存的数量大于阀值的时候，glibc会采用mmap为进程分配一块虚拟地址空间，而不是采用brk来扩展栈顶的指针。1.2.1    上述“阀值”缺省情况是128K，这个值可以通过函数来设置：int m...
堆内存的介绍及应用（含例子）
qq_45708008的博客
07-31 1193
堆内存是进程的一个内存段
RT-Thread 05内存管理
dsf031411的博客
10-05 3737
在计算系统中，变量、中间数据一般存放在系统存储空间中，只有在实际使用时才将它们从存储空间调入到中央处理器内部进行运算。通常存储空间可以分为两种：内部存储空间和外部存储空间。内部存储空间访问速度比较快，能够按照变量地址随机地访问，也就是我们通常所说的RAM（随机存储器），或电脑的内存；而外部存储空间内所保存的内容相对来说比较固定，即使掉电后数据也不会丢失，这就是通常所讲的ROM（只读存储器），也可以把
堆（C语言实现）
cw412524的博客
11-30 1371
数据结构 堆（C语言实现），包含丰富接口，干货满满！
C语言实现堆
weixin_66828150的博客
03-25 80
每棵子树的根结点有且只有一个前驱，可以有0个或多个后继，因此，树是递归定义的。2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。1.4堆得概念及结构。
用C语言实现------堆
ccc_bug的博客
09-28 594
堆的实现（C语言）
C语言内存布局：栈与堆的解析
在C语言中，程序的内存布局主要涉及三个关键区域：栈（Stack）、堆（Heap）以及动态链接库（Dynamic Libraries）。下面将详细阐述这三个部分。 一、栈 栈是内存管理的核心部分，主要用于存储函数调用时的上下文。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值