基于链表的方法实现静态内存管理

最新推荐文章于 2024-07-27 19:46:42 发布
最新推荐文章于 2024-07-27 19:46:42 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： 编程 文章标签： 内存管理 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xikangsoon/article/details/72811339
版权
注：这篇博客主要讲了我用C语言实现静态内存池管理的算法和思想。首先建立这些内存块的结构体索引。然后用malloc申请我们需要管理的内存块。在申请好的内存池里，进行内存使用。申请用户需要的内存，用的是轮询的方式，根据内存块的大小在几种不同的内存块中依次查找是否被使用的标志。申请、释放内存操作就是改变每块内存的flag。在程序结束后，free全部的内存，销毁内存池。我暂时还想不到更快的方法来申请内存，因为申请释放内存的操作不是有序进行的，所以要使用轮询的方式。总而言之，思想最重要，无论算法还是数据结构都是一种解决问题的思想。我们可以借鉴常用的链表、树、图等数据结构，但也不必拘泥于它的形式，可以适当进行变换。欢迎大家参考和指导。


静态内存池管理要求：

32字节的内存块数量100块
64字节的内存块数量100块
256字节的内存块数量50块
1024字节的内存块数量10块
4096字节的内存块数量3块

实现要求（给出函数原型，请大家实现函数体）：
内存池初始化函数：int initMem(void)，返回1成功，其他值失败
内存块申请函数：void *getMem(unsigned int size)，成功返回内存块地址，失败返回NULL
内存块释放函数：int retMem(void *buf)，返回1成功，其他值失败
内存池统计函数：void showMem(void)，各内存当前申请数、释放数、成功失败情况统计，用printf输出显示即可

验证用测试用例（最低要求）：
1、把32字节的内存块全部申请完->接着归还一块->再申请一块->全部释放完。要求showMem显示结果正确！
2、4096字节内存块全部申请再全部释放
3、5000字节内存块申请
4、所有提供的内存（各种大小）全部申请完，再全部释放完

5、申请一块32字节，对该内存块释放两次

#ifndef __MEMORY_POLL_H__
#define __MEMORY_POLL_H__

#define true  1
#define false 0

//定义内存块
struct Mem_Chunk {
    int num;
    int size;
};

//定义内存池
struct Mem_Pool {
    struct Mem_Chunk *MemChunk32;
    struct Mem_Chunk *MemChunk64;
    struct Mem_Chunk *MemChunk256;
    struct Mem_Chunk *MemChunk1024;
    struct Mem_Chunk *MemChunk4096;
};

typedef struct p_Mem_Block_32 {
    char data[32];
    char flag; //use or not
    char *next;
}p_Mem_Block_32;

typedef struct p_Mem_Block_64 {
    char data[64];
    char flag; //use or not
    char *next;
}p_Mem_Block_64;

typedef struct p_Mem_Block_256 {
    char data[256];
    char flag; //use or not
    char *next;
}p_Mem_Block_256;

typedef struct p_Mem_Block_1024 {
    char data[1024];
    char flag; //use or not
    char *next;
}p_Mem_Block_1024;

typedef struct p_Mem_Block_4096 {
    char data[4096];
    char flag; //use or not
    char *next;
}p_Mem_Block_4096;

extern int initMem(void);
extern void *getMem(unsigned int size);
extern int retMem(void *buf);
extern void showMem(void);
extern int freeMem(void);

#endif

#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      
#include "memory_pool.h"

//初始化内存块的大小、数量
struct Mem_Chunk MemChunk32 = {100, 32};
struct Mem_Chunk MemChunk64 = {100, 64};
struct Mem_Chunk MemChunk256 = {50, 256};
struct Mem_Chunk MemChunk1024 = {10, 1024};
struct Mem_Chunk MemChunk4096 = {3, 4096};

struct Mem_Pool MemPool = {&MemChunk32, &MemChunk64, &MemChunk256, &MemChunk1024, &MemChunk4096};

p_Mem_Block_32 *Block_32_Node = NULL;
p_Mem_Block_64 *Block_64_Node = NULL;
p_Mem_Block_256 *Block_256_Node = NULL;
p_Mem_Block_1024 *Block_1024_Node = NULL;
p_Mem_Block_4096 *Block_4096_Node = NULL;

int Block_32_Node_Init(struct Mem_Chunk MemChunk32)
{
    char i; 
    
    p_Mem_Block_32 *pBlock_32 = NULL;
    
    for(i = 0; i < MemChunk32.num; i++)
    {
    Block_32_Node = (p_Mem_Block_32 *)malloc(sizeof(p_Mem_Block_32));
    if(NULL == Block_32_Node) return false;
    
    memset(Block_32_Node, 0, sizeof(p_Mem_Block_32));
    Block_32_Node ->next = pBlock_32;
    pBlock_32 = Block_32_Node;
    }
    return true;
}


int Block_64_Node_Init(struct Mem_Chunk MemChunk64)
{
    char i; 
    p_Mem_Block_32 *pBlock_64 = NULL;
    
    
    for(i = 0; i < MemChunk64.num; i++)
    {
    Block_64_Node = (p_Mem_Block_64 *)malloc(sizeof(p_Mem_Block_64));
    if(NULL == Block_64_Node) return false;
    memset(Block_64_Node, 0, sizeof(p_Mem_Block_64));
    Block_64_Node ->next = pBlock_64;
    pBlock_64 = Block_64_Node;
    }
    return true;
}


int Block_256_Node_Init(struct Mem_Chunk MemChunk256)
{
    char i; 
    p_Mem_Block_256 *pBlock_256 = NULL;
    for(i = 0; i < MemChunk256.num; i++)
    {
    Block_256_Node = (p_Mem_Block_256 *)malloc(sizeof(p_Mem_Block_256));
    if(NULL == Block_256_Node) return false;
    memset(Block_256_Node, 0, sizeof(p_Mem_Block_256));
    Block_256_Node ->next = pBlock_256;
    pBlock_256 = Block_256_Node;
    }
    return true;
}


int Block_1024_Node_Init(struct Mem_Chunk MemChunk1024)
{
    char i; 
    p_Mem_Block_1024 *pBlock_1024 = NULL;
    for(i = 0; i < MemChunk1024.num; i++)
    {
    Block_1024_Node = (p_Mem_Block_1024 *)malloc(sizeof(p_Mem_Block_1024));
    if(NULL == Block_1024_Node) return false;
    memset(Block_1024_Node, 0, sizeof(p_Mem_Block_1024));
    Block_1024_Node ->next = pBlock_1024;
    pBlock_1024 = Block_1024_Node;
    }
    return true;
}


int Block_4096_Node_Init(struct Mem_Chunk MemChunk4096)
{
    char i; 
    p_Mem_Block_4096 *pBlock_4096 = NULL;
    
    for(i = 0; i < MemChunk4096.num; i++)
    {
    Block_4096_Node = (p_Mem_Block_4096 *)malloc(sizeof(p_Mem_Block_4096));
    if(NULL == Block_4096_Node) return false;
    memset(Block_4096_Node, 0, sizeof(p_Mem_Block_4096));
    Block_4096_Node ->next = pBlock_4096;
    pBlock_4096 = Block_4096_Node;
    }
    return true;
}


//用malloc申请内存，并将地址赋给定义的内存块结构体变量
int initMem(void)
{
    if(!Block_32_Node_Init(MemChunk32))return false;
    if(!Block_64_Node_Init(MemChunk64))return false;
    if(!Block_256_Node_Init(MemChunk256))return false;
    if(!Block_1024_Node_Init(MemChunk1024))return false;
    if(!Block_4096_Node_Init(MemChunk4096))return false;
    
    printf("Memory Initialize Successfully!\n");
    return true;
}

void *getMem(unsigned int size)
{
    int i;
    p_Mem_Block_32 *pBlock_32_Node = Block_32_Node;
    p_Mem_Block_64 *pBlock_64_Node = Block_64_Node;
    p_Mem_Block_256 *pBlock_256_Node = Block_256_Node;
    p_Mem_Block_1024 *pBlock_1024_Node = Block_1024_Node;
    p_Mem_Block_4096 *pBlock_4096_Node = Block_4096_Node;
    
    if(size > 4096) return NULL;
    if(size > 1024)
    {
    for(i = 0; i < MemChunk4096.num; i++)
    {
    if(pBlock_4096_Node == NULL)return pBlock_4096_Node;
    if(pBlock_4096_Node ->flag == 1)
    {
    pBlock_4096_Node = pBlock_4096_Node->next;
    continue;
    }
    if(pBlock_4096_Node ->flag == 0)
    {
    pBlock_4096_Node ->flag = 1;
    return pBlock_4096_Node;
    }
    }
    return NULL;
    }
    
    if(size > 256)
    {
    for(i = 0; i < MemChunk1024.num; i++)
    {
    if(pBlock_1024_Node == NULL)return pBlock_1024_Node;
    if(pBlock_1024_Node ->flag == 1)
    {
    pBlock_1024_Node = pBlock_1024_Node->next;
    continue;
    }
    if(pBlock_1024_Node ->flag == 0)
    {
    pBlock_1024_Node ->flag = 1;
    return pBlock_1024_Node;
    }
    }
    return NULL;
    }
    
    if(size > 64)
    {
    for(i = 0; i < MemChunk256.num; i++)
    {
    if(pBlock_256_Node == NULL)return pBlock_256_Node;
    if(pBlock_256_Node ->flag == 1)
    {
    pBlock_256_Node = pBlock_256_Node->next;
    continue;
    }
    if(pBlock_256_Node ->flag == 0)
    {
    pBlock_256_Node ->flag = 1;
    return pBlock_256_Node;
    }
    }
    
    return NULL;
    
    }
    
    
    if(size > 32)
    {
    for(i = 0; i < MemChunk64.num; i++)
    {
    if(pBlock_64_Node == NULL)return pBlock_64_Node;
    
    if(pBlock_64_Node ->flag == 1)
    {
    pBlock_64_Node = pBlock_64_Node->next;
    continue;
    }
    
    if(pBlock_64_Node ->flag == 0)
    {
    pBlock_64_Node ->flag = 1;
    return pBlock_64_Node;
    }
    }
    return NULL;
    }
    
    if(size > 0)
    {
    for(i = 0; i < MemChunk32.num; i++)
    {
    if(pBlock_32_Node == NULL)return pBlock_32_Node;
    
    if(pBlock_32_Node ->flag == 1)
    {
    pBlock_32_Node = pBlock_32_Node->next;
    continue;
    }
    
    if(pBlock_32_Node ->flag == 0)
    {
    pBlock_32_Node ->flag = 1;
    return pBlock_32_Node;
    }
    }
    return NULL;
    }
    return NULL; 
}

int retMem(void *buf)
{
    int i;
    p_Mem_Block_32 *pBlock_32_Node = Block_32_Node;
    p_Mem_Block_64 *pBlock_64_Node = Block_64_Node;
    p_Mem_Block_256 *pBlock_256_Node = Block_256_Node;
    p_Mem_Block_1024 *pBlock_1024_Node = Block_1024_Node;
    p_Mem_Block_4096 *pBlock_4096_Node = Block_4096_Node;
    
    for(i = 0; i < MemChunk4096.num; i++)
    {
    if(pBlock_4096_Node == buf)
    {
    pBlock_4096_Node ->flag = 0;
    return true;
    }
    pBlock_4096_Node = pBlock_4096_Node->next;
    }
    for(i = 0; i < MemChunk1024.num; i++)
    {
    if(pBlock_1024_Node == buf)
    {
    pBlock_1024_Node ->flag = 0;
    return true;
    }
    pBlock_1024_Node = pBlock_1024_Node->next;
    }
    
    for(i = 0; i < MemChunk256.num; i++)
    {
    if(pBlock_256_Node == buf)
    {
    pBlock_256_Node ->flag = 0;
    return true;
    }
    pBlock_256_Node = pBlock_256_Node->next;
    }
    
    for(i = 0; i < MemChunk64.num; i++)
    {
    if(pBlock_64_Node == buf)
    {
    pBlock_64_Node ->flag = 0;
    return true;
    }
    pBlock_64_Node = pBlock_64_Node->next;
    }
    
    for(i = 0; i < MemChunk32.num; i++)
    {
    if(pBlock_32_Node == buf)
    {
    pBlock_32_Node ->flag = 0;
    return true;
    }
    pBlock_32_Node = pBlock_32_Node->next;
    }
    return false;
}

void showMem(void)
{
    int i = 0;
    int request_number = 0;
    int free_number = 0;
    
    
    p_Mem_Block_32 *pBlock_32_Node = Block_32_Node;
    p_Mem_Block_64 *pBlock_64_Node = Block_64_Node;
    p_Mem_Block_256 *pBlock_256_Node = Block_256_Node;
    p_Mem_Block_1024 *pBlock_1024_Node = Block_1024_Node;
    p_Mem_Block_4096 *pBlock_4096_Node = Block_4096_Node;
    
    for(i = 0; i < MemChunk32.num; i++)
    {
    if(pBlock_32_Node ->flag == 1)request_number++;
    else free_number++;
    
    pBlock_32_Node = pBlock_32_Node->next;
    
    
    }
    printf("The Memory_Chunk_32 pMemBlock32 number: %d\n", MemChunk32.num);
    printf("request_number: %d     free_number: %d\n",request_number, free_number);
    
    request_number = 0;
    free_number = 0;
    
    
    for(i = 0; i < MemChunk64.num; i++)
    {
    if(pBlock_64_Node ->flag == 1)request_number++;
    else free_number++;
    
    pBlock_64_Node = pBlock_64_Node->next;
    
    
    }
    printf("The Memory_Chunk_64 pMemBlock64 number: %d\n", MemChunk64.num);
    printf("request_number: %d     free_number: %d\n",request_number, free_number);
    
    request_number = 0;
    free_number = 0;
    
    for(i = 0; i < MemChunk256.num; i++)
    {
    if(pBlock_256_Node ->flag == 1)request_number++;
    else free_number++;
    
    pBlock_256_Node = pBlock_256_Node->next;
    }
    printf("The Memory_Chunk_256 pMemBlock256 number: %d\n", MemChunk256.num);
    printf("request_number: %d     free_number: %d\n",request_number, free_number);
    
    request_number = 0;
    free_number = 0;
    
    for(i = 0; i < MemChunk1024.num; i++)
    {
    if(pBlock_1024_Node ->flag == 1)request_number++;
    else free_number++;
    pBlock_1024_Node = pBlock_1024_Node->next;
    }
    printf("The Memory_Chunk_1024 pMemBlock1024 number: %d\n", MemChunk1024.num);
    printf("request_number: %d     free_number: %d\n",request_number, free_number);
    request_number = 0;
    free_number = 0;
    
    
    for(i = 0; i < MemChunk4096.num; i++)
    {
    if(pBlock_4096_Node ->flag == 1)request_number++;
    else free_number++;
    
    pBlock_4096_Node = pBlock_4096_Node->next;
    }
    
    printf("The Memory_Chunk_4096 pMemBlock4096 number: %d\n", i);
    printf("request_number: %d     free_number: %d\n",request_number, free_number);
}

//销毁内存池，将申请的内存全部释放掉。
int freeMem(void)
{
    int i; 
    
    p_Mem_Block_32 *pBlock_32_Node = Block_32_Node;
    p_Mem_Block_64 *pBlock_64_Node = Block_64_Node;
    p_Mem_Block_256 *pBlock_256_Node = Block_256_Node;
    p_Mem_Block_1024 *pBlock_1024_Node = Block_1024_Node;
    p_Mem_Block_4096 *pBlock_4096_Node = Block_4096_Node;
    
    for(i = 0; i < MemChunk32.num; i++)
    {
    pBlock_32_Node = Block_32_Node;
    free(Block_32_Node);
    Block_32_Node = pBlock_32_Node ->next;
    }
    
    for(i = 0; i < MemChunk64.num; i++)
    {
    pBlock_64_Node = Block_64_Node;
    free(Block_64_Node);
    Block_64_Node = pBlock_64_Node ->next;
    }
    
    for(i = 0; i < MemChunk256.num; i++)
    {
    pBlock_256_Node = Block_256_Node;
    free(Block_256_Node);
    Block_256_Node = pBlock_256_Node ->next;
    }
    
    for(i = 0; i < MemChunk1024.num; i++)
    {
    pBlock_1024_Node = Block_1024_Node;
    free(Block_1024_Node);
    Block_1024_Node = pBlock_1024_Node ->next;
    }
    
    for(i = 0; i < MemChunk4096.num; i++)
    {
    pBlock_4096_Node = Block_4096_Node;
    free(Block_4096_Node);
    Block_4096_Node = pBlock_4096_Node ->next;
    }
    
    printf("Memory Freed Successfully!\n");
    return true;
}
     
     
    
    
   
   

#include 
    
    
     
     
#include "memory_pool.h"

int test1(void)
{
int i, j;
char *pBlock[100];

for(i = 0; i < 100; i++)
{
pBlock[i] = (char*)getMem(32);
if(pBlock[i] == NULL){
printf("Error: The request of Block[%d] failed!\n", i);
return false;
}
}
showMem();


if(retMem(pBlock[99]))
{
printf("The 100th Block is freed.\n");
}else 
{
printf("Error: The 100th Block can't be freed!\n");
return false;
}

showMem();

pBlock[99] = (char*)getMem(32);

if(pBlock[99] == NULL){
printf("Error: The request of Block[99] failed!\n");
return false;
}

showMem();

for(i = 99; i >= 0; i--)
{
retMem(pBlock[i]);
}
showMem();
return 0;


}

int test2(void)
{
int i;
char *pBlock[3];

for(i = 0; i < 3; i++)
{
pBlock[i] = (char*)getMem(4096);
if(pBlock[i] == NULL){
printf("Error: The request of Block[%d] failed!\n", i);
return false;
}
}
showMem();


for(i = 3; i >= 0; i--)
{
retMem(pBlock[i]);
}

showMem();
return true;
}

int test3(void)
{
char *pBlock;
pBlock = (char*)getMem(5000);
if(pBlock == NULL)
{
printf("Error: The request of Block 5000 failed!\n");
return true;
}
return false;
}

int test4(void)
{
int i;
int j = 0;
char *pBlock[263];

for(i = 0; i < 100; i++)
{
pBlock[j] = (char*)getMem(32);
if(pBlock[j] == NULL)
{
printf("Error: The request of Block32[%d] failed!\n", i);
return false;
}
j++;
}

for(i = 0; i < 100; i++)
{
pBlock[j] = (char*)getMem(64);
if(pBlock[j] == NULL)
{
printf("Error: The request of Block64[%d] failed!\n", i);
return false;
}
j++;
}

for(i = 0; i < 50; i++)
{
pBlock[j] = (char*)getMem(256);
if(pBlock[j] == NULL)
{
printf("Error: The request of Block256[%d] failed!\n", i);
return false;
}
j++;
}

for(i = 0; i < 10; i++)
{
pBlock[j] = (char*)getMem(1024);


if(pBlock[j] == NULL)
{
printf("Error: The request of Block1024[%d] failed!\n", i);
return false;
}
j++;
} 

for(i = 0; i < 3; i++)
{
pBlock[j] = (char*)getMem(4096);
if(pBlock[j] == NULL)
{
printf("Error: The request of Block4096[%d] failed!\n", i);
return false;
}
j++;
} 

showMem();

for(j = 262; j >= 0; j--)
{
retMem(pBlock[j]);
}
showMem();
return true;
}

int test5(void)
{
char *pBlock;
pBlock = (char*)getMem(32);

if(pBlock == NULL){
printf("Error: The request of Block32 failed!\n");
return false;
}

retMem(pBlock);
retMem(pBlock);
showMem();

return true;
}


int main()
{
if(!initMem())
{
printf("Error: Memory Pool Initialization Failed!\n");
return false;
}
//test1();
//test2();
//test3();
//test4();
//test5();

freeMem();
return 0;
}
    
    

objects = main.o memory_pool.o

main : $(objects)
    cc -o main $(objects)

.PHONY : clean
    clean :
    -rm main $(objects)



AllenSun-1990
关注
专栏目录
静态内存分配-链表管理（2）实现
yzau26的博客
07-30 553
概述静态内存为开辟若干个Buf，在每个buf增加控制头，该控制头即为链表的节点。如下图所示。 实现底层数据结构为struct hstack_mem_pool { u32 used; u8 buf[HSTACK_MEMORY_POOL_BUFFER_SIZE]; } mem_pool[HSTACK_MEMORY_POOL_ITEMS]; 此处开
静态链表 - 用数组实现链表
eaglelau的专栏
09-19 179
链表 数组 静态链表 动态链表
一个基于链表的内存管理方案
Netfilter
06-11 4506
<br />在OpenVPN中，一种很不错的内存管理方案是基于链表的，该方案的实现使用了一个gc_arena结构体，该结构体的作用就是将所有的动态分配的内存块收集汇集起来，然后就可以在一个地方统一释放，c语言对动态内存管理的劣势就是无法跟踪动态内存，因此也就将管理动态内存的事情交给了程序员来完成，然后就有了无数次的由于内存泄露导致的bug，虽然c++实现了很多内存管理方案，比如智能指针之类的，但是其复杂性无不揉进了c++这种重量级语言本身，使得本已复杂的语言带上特定的库之后更加臃肿，并且在c++中实现的动态
内存管理；链表
最新发布
qq_56797509的博客
07-27 356
1.函数体内部的局部变量会随函数结束被回收,可以考虑存放到堆区空间中避免随函数结束回收。当使用strcat、strcpy、strcmp函数时可能会产生内存越界。应该用strncat、strncpy、strncmp函数替代。注意：操作指针时,注意指针指向的空间是否存在？4.单向链表、双向链表、内核链表、循环链表。如果成功,返回指向申请空间的指针。申请size个字节的堆区空间。size:申请空间的大小。1.数组是有限个元素的集合。申请的堆区空间没有被释放。2.数组的空间必须连续。1.链表空间不需要连续。
win 驱动开发 内存链表图解
一介码农，热爱金融。
10-18 1190
Windows内存管理（1）--分配内核内存 和 使用链表   1.      分配内核内存 Windows驱动程序使用的内存资源非常珍贵，分配内存时要尽量节约。和应用程序一样，局部变量是存放在栈空间中的。但栈空间不会像应用程序那么大，所以驱动程序不适合递归调用或者局部变量是大型数据结构。如果需要大型数据结构，我们可以在堆中申请。 堆中申请的函数有以下几个： （1）PVOI
链表的C语言实现之动态内存分配(转载）
LuWei
11-22 1640
作者： 杜红超 何青青一、为什么用动态内存分配　　但我们未学习链表的时候，如果要存储数量比较多的同类型或同结构的数据的时候，总是使用一个数组。比如说我们要存储一个班级学生的某科分数，总是定义一个float型（存在0.5分）数组：float score[30];　　但是，在使用数组的时候，总有一个问题困扰着我们：数组应该有多大？　　在很多的情况下，你并不能确定要使用多大的数组，比如上例，你可能并不知
用单链表实现的内存管理
CSYNYK的专栏
09-01 4052
用单链表实现的内存管理       在C语言论坛中看了dgarc发表的一个贴子后，按要求写了一段代码，可以实现内存分配的管理，避免内存泄漏，欢迎各位测试，如遇bug，敬请指出，我将进行有针对性的改进，然后重新贴出来。要求如下：    题目：监控应用程序的内存申请和释放      描述：          不考虑多线程，使用动态单链表的方式进行操作，在应用程序申请内存时，需要把该内存节点信息插入链
StaticLinkList.rar_静态链表
09-14
静态链表在内存管理上具有一定的优势，但也有其局限性。比如，当链表长度固定后，如果需要增加节点，就必须重新分配更大的数组并迁移数据，而如果链表长度过小，可能会浪费一部分存储空间。此外，由于静态链表的节点...
基于链表和数组的学生信息管理系统（C语言）可运行.cpp文件
05-27
《基于链表和数组的学生信息管理系统（C语言）可运行》 在计算机科学领域，数据结构和算法是编程的基础，而学生信息管理系统是常见的实践项目，它有助于学习者理解和运用这些概念。本项目以C语言为开发工具，通过...
基于C语言实现的几个管理系统
03-17
标题 "基于C语言实现的几个管理系统" 涵盖了多个使用C语言开发的管理系统，这些系统涵盖了不同的应用领域，如KTV歌曲管理、产品管理、人力资源管理、学生档案管理等。C语言作为一门基础且强大的编程语言，因其高效、...
嵌入式内存管理探究-基于FreeRTOS
LinusZhao的博客
01-29 327
嵌入式内存管理探究-基于FreeRTOS 文章封面 本文基于嵌入式裸机或RTOS系统下内存管理方法的探究，灰色方块为正在使用的内存块，白色为可用内存块。 好的内存管理算法，有以下几个特征： 内存碎片化小 故障调试能力：发生内存泄漏和踩踏时，可追溯位置，便于定位故障 管理成本小：管理的代码本身占用空间小，从空间复杂度 申请和释放效率高：时间复杂度 FreeRTOS的heap_5算法 相比 heap_4 支持地址不连续的两个内存区域，比如芯片内置RAM+外挂
动态内存分配--链表
11-28
使用vc++6.0版本，新建一个工程，在工程中建立cpp,以及头文件。
C语言： 基于链表的内存管理Dome
C++++ ++
01-03 420
基于单链表（也可以用数组）实现的程序内存管理，对内存的安全释放和开辟空间大小以及地址的管理和数据展示。 头文件：mymemory.h #pragma once #include<stdio.h> #include<stdlib.h> /* 记录开辟内存 */ void* mymalloc(size_t size); /* 记录释放内存 */ void myf...
Linux C语言学习 内存管理 链表
mxyzhy的博客
07-27 336
快速学习C语言
C语言内存管理(初级)----链表
zhcosin的专栏
12-15 2456
上一篇文章里实现了二维动态数组的创建和销毁，现在来看一个稍加复杂一点的实例：链表，读者需具有链表的基本知识，本文的链表实现与读者所熟知的实现有一些差异。     假定我们要写一个计算器程序，它接受一个字符串形式的表达式，然后计算并输出其结果，我们先要解决的是它的词法分析部分，这是一个把输入的字符串分割成若干基本的表达式元素的过程，这些表达式元素包含运算符、运算数、括号，各自具有不同的属性，比如运
内存管理（采用链表）-malloc-free
weixin_39518639的博客
09-22 371
memfunction.h #include<stdio.h> #include<stdlib.h> typedef struct MemoryNode //内存结构 { int size;//内存字节数 void *paddr;//内存地址 }Mnode,*PMnode; typedef struct Memlist//双链表 { Mnode Mdata; Memlist * next;//链表下一个 Memlist * pre;//链表上一个 }Mlist,*PM
使用链表管理内存
liuguangsh的博客
07-28 1863
使用链表管理内存的使用，这儿重新定义了 malloc,realloc,free函数，使用了mymalloc,myrealloc,myfree自己重定义了函数 mem.h #include #include void * mymalloc(size_t size); void *myrealloc(void *p, size_t size); void myfree(void *p)
内存与链表
张昆
11-22 1073
内存分配与释放
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

AllenSun-1990

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

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

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

打赏作者

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

抵扣说明：

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

余额充值