本代码适用于无操作系统的STM32单片机开发，功能强大。

    可申请到地址空间连续的不同大小的内存空间，且用户接口简单，使用方便。

    直接复制粘贴如下代码即可：

memory.h：

1. #ifndef __MEMORY_H__
   
2. #define __MEMORY_H__
   # E# x' x5 t- X$ R+ {2 T# {  ]1 x
3. 
   
4. #include "stdio.h"
   ' V0 L: E$ _- y9 X/ y9 }
5. #include "string.h"
   . _+ Y$ \; c* `- D; \# x* {
6. #include "includes.h"
   + d; n) M5 l+ {# t; v: d
7. //用户使用
   9 W" |: p* {9 ?( `9 V( C
8. typedef struct
   
9. {
   * P* B0 S: _, @1 f. n
10.     void    *addr;//申请到的内存的起始地址
    
11.     uint32_t size;//申请到的内存的大小，按照块大小分配，大于等于申请大小
    
12.     uint16_t  tb; //申请表序号，申请内存时分配，释放内存时使用，用户不使用
    
13. }DMEM;
      q8 B; f9 w7 ]
14. 
    & q: D( V) s& F( A& L
15. //若返回空，则申请失败
    & K$ Q8 |6 t: }2 E0 b+ }& @* s* l
16. DMEM *DynMemGet(uint32_t size);
    ) ]5 X  `3 g9 V
17. void DynMemPut(DMEM *pDmem);
    
18. 
    ( o; D. U  z$ P1 p* W" n$ F: B
19. #endif //__MEMORY_H__

复制代码

memory.c：

1. #include "memory.h"
   - m( {9 K9 ^9 w; k3 g" z
2. 
   # o) w/ X3 W* e8 |( A9 @( D
3. #define DMEM_BLOCK_SIZE         256      //内存块大小为128字节
   
4. #define DMEM_BLOCK_NUM          20       //内存块个数为40个
   9 q' C3 n/ a& A( k, n7 v) e
5. #define DMEM_TOTAL_SIZE         (DMEM_BLOCK_SIZE*DMEM_BLOCK_NUM)    //内存总大小
   7 ~- @3 m/ ?! V6 h; n
6. 
   
7. typedef enum
   " o9 W& K0 _! j) E- x
8. {
   
9.     DMEM_FREE   = 0,
   2 C9 m1 S* V4 J1 X& F0 Z' [8 V
10.     DMEM_USED   = 1,
    / @; ?2 v3 Q9 u0 i0 d
11. }DMEM_USED_ITEM;
    
12. 
      }* G, e! m- x4 B3 X
13. typedef struct
    
14. {
    6 H* ^% U+ v7 R' |3 L$ q# M) A% t
15.     DMEM_USED_ITEM   used;       //使用状态
    
16.     uint16_t         blk_s;      //起始块序号
    9 A, Y4 |5 r3 R" I2 Z, \8 j4 P
17.     uint16_t         blk_num;    //块个数
    5 Z9 Y, k2 R  u( s7 w
18. }DMEM_APPLY;
    5 O8 R; s; x: L4 b4 ?2 c
19. 
    ! Y3 ?* M. j+ n. C$ ~
20. typedef struct
    
21. {
    . ]# f5 P7 F6 F$ z0 P' s+ d
22.     DMEM_USED_ITEM  tb_blk[DMEM_BLOCK_NUM];
    
23.     DMEM            tb_user[DMEM_BLOCK_NUM];        //用户申请内存信息
    
24.     DMEM_APPLY      tb_apply[DMEM_BLOCK_NUM];       //系统分配内存信息
    
25.     uint16_t        apply_num;      //内存申请表占用数目
    
26.     uint16_t        blk_num;        //内存块占用数目
    ) b0 g5 f( P& f# p8 a& C, `0 v) A8 ?
27. }DMEM_STATE;
    & S+ m+ C0 {) H. T
28. 
    * G" |3 B; c! `. W
29. static uint8_t DMEMORY[DMEM_TOTAL_SIZE];
    ( C9 O6 I/ Q% s; s
30. static DMEM_STATE DMEMS = {0};
      r! F5 E8 R/ U6 \. I
31. 
    - a. i' `9 H% S
32. DMEM *DynMemGet(uint32_t size)
    9 n* w/ K9 v" a9 Z9 A; M
33. {
    3 U* d; c3 Z. w# |( e! m# _/ _
34.     uint16_t loop = 0;
    
35.     uint16_t find = 0;
    
36.     uint16_t blk_num_want = 0;
    4 X- \/ Y4 l  s1 h5 @7 V4 y( M
37.     DMEM * user = NULL;
    
38.     DMEM_APPLY *apply = NULL;
    9 A" T0 H4 O& r
39.    
    
40.     //申请内存大小不能为0
      P8 y9 t% n) h' Y2 i
41.     if(size == 0)               {   return NULL;    }
    
42.     //申请内存不可超过总内存大小
    $ P( c  g8 _. C* Z
43.     if(size > DMEM_TOTAL_SIZE)  {   return NULL;    }
    
44.     //申请内存不可超过剩余内存大小
    4 I" u9 a4 h: l7 [
45.     if(size > (DMEM_BLOCK_NUM - DMEMS.blk_num) * DMEM_BLOCK_SIZE)   {   return NULL;    }
    
46.     //申请表必须有空余
    
47.     if(DMEMS.apply_num >= DMEM_BLOCK_NUM)   {   return NULL;    }
    - I2 z. F8 F% _, A; Q7 {0 f# r
48.    
    
49.     //计算所需连续块的个数
    
50.     blk_num_want = (size + DMEM_BLOCK_SIZE - 1) / DMEM_BLOCK_SIZE;
    
51.    
    
52.     //寻找申请表
    : \5 R* N! W' w1 B& f' U& Z: `
53.     for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)
    : c& _7 q7 \5 F5 M
54.     {
    # z7 w# e+ k9 l' a/ ^6 T
55.         if(DMEMS.tb_apply[loop].used == DMEM_FREE)
    
56.         {
    
57.             apply = &DMEMS.tb_apply[loop];                  //申请表已找到
      `% ^1 x8 I- M, I* }5 |. L
58.             user = &DMEMS.tb_user[loop];                    //用户表对应找到
    
59.             user->tb = loop;                                //申请表编号记录
    8 i7 s" D7 O# ^
60.             user->size = blk_num_want * DMEM_BLOCK_SIZE;    //分配大小计算
    
61.             break;
    ( A( I1 A2 z' `/ P5 V
62.         }
    
63.     }
    
64.    
    + H% z5 L. [4 A4 s$ k
65.     //没有找到可用申请表，理论上是不会出现此现象的，申请表剩余已在上面校验
    
66.     if(loop == DMEM_BLOCK_NUM)  {   return NULL;    }
    
67.    
    
68.     //寻找连续内存块
    
69.     for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)
    
70.     {
    4 a  o! H4 i4 M$ L, V
71.         if(DMEMS.tb_blk[loop] == DMEM_FREE)
    
72.         {//找到第一个空闲内存块
    4 n+ s3 A2 J: }/ Q6 P/ r. e$ i  C9 ~
73.             for(find = 1; (find < blk_num_want) && (loop + find < DMEM_BLOCK_NUM); find ++)
    
74.             {//找到下一个空闲内存块
    
75.                 if(DMEMS.tb_blk[loop + find] != DMEM_FREE)
    
76.                 {//发现已使用内存块
    
77.                     break;
    7 S3 Z, T$ k* M1 w" {
78.                 }
    
79.             }
    
80.             if(find >= blk_num_want)
    
81.             {//寻找到的空闲内存块数目已经够用
    # ^/ Z: V) ?, h; _
82.                 user->addr = DMEMORY + loop * DMEM_BLOCK_SIZE;  //计算申请到的内存的地址
    3 G6 {9 a+ V& N$ H- x3 M" a
83.                 apply->blk_s = loop;                            //记录申请到的内存块首序号
    9 o1 w/ U8 F* B0 Z, s& B
84.                 apply->blk_num = blk_num_want;                  //记录申请到的内存块数目
    
85.                 for(find = 0 ; find < apply->blk_num; find++)
    ! c( ?* d6 ~( H
86.                 {
    : U: n8 S/ q0 r
87.                     DMEMS.tb_blk[loop + find] = DMEM_USED;
    
88.                 }
    
89.                 apply->used = DMEM_USED;                        //标记申请表已使用
    , `! n7 j% Q4 U$ s0 N
90.                 DMEMS.apply_num += 1;
    ' ], b9 ?0 r" m6 ~7 c8 A
91.                 DMEMS.blk_num += blk_num_want;
    1 s) D" e: x9 y8 M6 C( h
92.                
    * m0 j4 t2 C% ?. A& C, |% b1 {
93.                 return user;
    
94.             }
    
95.             else
    ' {, u  L( `+ X2 |
96.             {//寻找到的空闲内存块不够用，从下一个开始找
    
97.                 loop += find;
    5 A& J; a# @2 E( w' T# x/ n0 C
98.             }
    . d, x) w1 n# ^0 p8 Y4 r4 ?
99.         }
      x) `+ N5 l/ i
100.     }
     
101.    
     + C+ ~/ B" k! C/ K- [
102.     //搜索整个内存块，未找到大小适合的空间
     ) b3 ?4 C; S9 R6 t
103.     return NULL;
     
104. }
     
105. 
     6 J" Q7 i& j3 f: u: K' q# F- v& o2 c
106. void DynMemPut(DMEM *user)
     
107. {
     # n7 |; q1 G% Q4 g) d& J  s, ~6 w
108.     uint16_t loop = 0;
     ! b0 K$ F" k5 @- P2 j3 Q
109.     //若参数为空，直接返回
     : C, k9 ?. ]3 U$ Z. D
110.     if(NULL == user)    {   return; }
     1 @1 B. G3 l3 k- K3 r
111.    
     
112.     //释放内存空间
     ! m3 Z" E) c, y2 T
113.     for(loop = DMEMS.tb_apply[user->tb].blk_s; loop < DMEMS.tb_apply[user->tb].blk_s + DMEMS.tb_apply[user->tb].blk_num; loop++)
     
114.     {
     0 Y. ?) n  s! c- I+ }, s
115.         DMEMS.tb_blk[loop] = DMEM_FREE;
     
116.         DMEMS.blk_num -= 1;
     ; h6 m. k3 u. V+ Y
117.     }
     ! z% i/ t5 v8 F% C
118.     //释放申请表
     
119.     DMEMS.tb_apply[user->tb].used = DMEM_FREE;
     
120.     DMEMS.apply_num -= 1;
     
121. }

复制代码