浅析C\C++的动态内存管理

作者：左懒
时间：2013.5.13

声明：

　　原创文章，转载请标明原文链接。

　　个人能力有限，文章可能存在多处错误。如果您发现文中有不足或错误之处敬请批评指针。我的邮箱是： zuolanaill@gmail.com，欢迎您邮件斧正。

　　本文内容参考了KEIL C51和VS2012中的部分源码，并对其进行了简单的分析和探讨，其中不乏有不确切之处，望您的批评指正。

　　在不同的操作系统中，C\C++的内存管理实现可能并不相同，因此本文所介绍的内容可能与您需要的内容有所出入，本文仅供参考学习。

一、KEIL IDE 中的动态内存管理

　　1. KEIL IDE 安装目录中的 *\Keil\C51\LIB目录下，包含了 malloc.c , calloc.c, free.c, realloc.c, init_mem.c 等源码文件，其中内容便是KEIL IDE工具提供的动态内存分配的函数。在这里，我挑了几源文件进行了简单的分析，其中包含init_mem.c 、malloc.c 、free.c。其它的源码文件或多或少都以这几个源码文件中的数据结构和函数进行扩充，所以也就没必要深入去研究了。

　　2. 首先先分析一下init_mem.c 这个文件。其中包含了一个最重要的内存池初始化函数： int init_mempool (void *pool, unsigned int size);

　　在分析这个函数之前，先介绍一个维护管理其动态内存的一个链表，这个链表重中之重，在C51单片机开发中，调用malloc和free进行内存的分配和释放全靠这个链表。其实这个数据结构挺简单的，只有两个数据成员。下面给出这个数据结构的定义：

1 struct __mem__
2 {
3     struct __mem__    *next;　　　/* 用于link堆内存中的空闲块 */
4     unsigned int    len;      　 /* 下一个内存块的长度 */
5 };

OK，接下来我们看一下管理整个堆内存的头结点, 它是一个全局的变量。声明在init_mem.c 的源文件中。

1 typedef struct __mem__         __memt__;
2 typedef __memt__  *__memp__;
3 
4 __memt__  __mem_avail__ [2] =
5 { 
6     { NULL, 0 },    /*    用于管理堆内存的头结点，当调用完init_mempool()之后会指向首块内存块，如果堆内存已经用完，则__mem_avail__[0].next为NULL */
7     { NULL, 0 },    /* UNUSED but necessary so free doesn't join HEAD or ROVER with the pool */
8                     /*    原代码的解释如上，目前我还搞不懂这个节点有什么用    */
9 };

好，现在介绍一下重点的东西。现在看一下内存池的初始化函数，其实它的工作很简单。不过记住，内存池初始化函数只能够被调用一次。多次调用的话上几次的内存将无法被释放。

 1 /*    初始化内存池，    */
 2 int init_mempool (void  *pool, unsigned int size)
 3 {
 4     
 5     if (size < MIN_POOL_SIZE)    /*    如果内存小于定义最小的内存池，则返回内存池初始化失败    */
 6         return (0);     
 7 
 8 
 9     if (pool == NULL)
10     {
11         pool = (void *)1;       /*    如果内存池传入的是NULL，则将内存池指向地址为1的位置。    *
12                                 /*    因为C51单片机的数据段是存储在XDATA, 大小为0x0 ~ 0xffff 共64K可用    */
13         size--;                 /*    取size-1的内存大小作为堆内存    */
14                                 /*    注意的是，若是在X86兼容机不能这么写，因为X86的机子是有内存保护的    */
15     }
16 
17 
18     AVAIL.next = (__memp__)pool;        /*    指向堆内存    */
19     AVAIL.len  = size;                  /*    堆内存大小    */
20 
21 
22     (AVAIL.next)->next = NULL;            /*    当前的堆内存还是一块空闲的内存    */
23     (AVAIL.next)->len  = size - HLEN;     /*    除去管理堆内存的头结点信息，还剩下多少空间可用    */
24 
25     return (-1);                          /*    返回成功    */
26 }

看完这个其实内存初始化的工作还是挺简单的。下面我给出调用 init_mempool()后头结点大概的示意图(画得有点戳，请见谅)：

看过图应该还是挺直观的。

　　如果您你自己查看KEIL 安装目录里的 init_mem.c 源码会发现跟我贴出来的内容有所区别，它可能如下：

 1 /*-----------------------------------------------------------------------------
 2 INIT_MEM.C is part of the C51 Compiler package from Keil Software.
 3 Copyright (c) 1995-2002 Keil Software.  All rights reserved.
 4 -----------------------------------------------------------------------------*/
 5 #include <stdlib.h>
 6 
 7 /*-----------------------------------------------
 8 Memory pool block structure and typedefs.
 9 Memory is laid out as follows:
10 
11 {[NXT|LEN][BLK (LEN bytes)]}{[NXT|LEN][BLK]}...
12 
13 Note that the size of a node is:
14 __mem__.len + sizeof (__mem__)
15 -----------------------------------------------*/
16 struct __mem__
17 {
18     struct __mem__ _MALLOC_MEM_ *next;    /* single-linked list */
19     unsigned int                len;      /* length of following block */
20 };
21 
22 typedef struct __mem__         __memt__;
23 typedef __memt__ _MALLOC_MEM_ *__memp__;
24 
25 #define    HLEN    (sizeof(__memt__))
26 
27 /*-----------------------------------------------
28 Memory pool headers.  AVAIL points to the first
29 available block or is NULL if there are no free
30 blocks.  ROVER is a roving header that points to
31 a block somewhere in the list.
32 
33 Note that the list is maintained in address
34 order.  AVAIL points to the block with the
35 lowest address.  That block points to the block
36 with the next higher address and so on.
37 -----------------------------------------------*/
38 __memt__ _MALLOC_MEM_ __mem_avail__ [2] =
39 { 
40     { NULL, 0 },    /* HEAD for the available block list */
41     { NULL, 0 },    /* UNUSED but necessary so free doesn't join HEAD or ROVER with the pool */
42 };
43 
44 #define AVAIL    (__mem_avail__[0])
45 
46 #define MIN_POOL_SIZE    (HLEN * 10)
47 
48 /*-----------------------------------------------------------------------------
49 int init_mempool (
50 void _MALLOC_MEM_ *pool,    address of the memory pool
51 unsigned int size);           size of the pool in bytes
52 
53 Return Value
54 ------------
55 0        FAILURE:  Memory pool is not large enough
56 NZ        SUCCESS:  Memory pool management initialized.
57 -----------------------------------------------------------------------------*/
58 int init_mempool (
59     void _MALLOC_MEM_ *pool,
60     unsigned int size)
61 {
62     /*-----------------------------------------------
63     Verify that the pool is large enough to actually
64     do something.  If it is too small, exit with 0.
65     -----------------------------------------------*/
66     if (size < MIN_POOL_SIZE)
67         return (0);                     /* FAILURE */
68 
69     /*-----------------------------------------------
70     If the pool points to the beginning of a memory
71     area (NULL), change it to point to 1 and decrease
72     the pool size by 1 byte.
73     -----------------------------------------------*/
74     if (pool == NULL)
75     {
76         pool = 1;
77         size--;
78     }
79 
80     /*-----------------------------------------------
81     Set the AVAIL header to point to the beginning
82     of the pool and set the pool size.
83     -----------------------------------------------*/
84     AVAIL.next = pool;
85     AVAIL.len  = size;
86 
87     /*-----------------------------------------------
88     Set the link of the block in the pool to NULL
89     (since it's the only block) and initialize the
90     size of its data area.
91     -----------------------------------------------*/
92     (AVAIL.next)->next = NULL;
93     (AVAIL.next)->len  = size - HLEN;
94 
95     return (-1);                       /* SUCCESS */
96 }

KEIL 工具所带的源文件跟我贴出来的代码有所不同。其原因如下：

　　第一：其中在数据结构的声明和头结点的定义都多出了一个 _MALLOC_MEM_ ，但是这个_MALLOC_MEM_标识符在我的KEIL中是没办法跟踪出来的，据我个人理解这个_MALLOC_MEM_ 可能是用#define _MALLOC_MEM_ 定义的一个空的宏定义，用于标识这个数据结构用于动态分配所用。所以在我贴出来的代码中去除了这个_MALLOC_MEM_标识符。尽量让代码看起来简洁舒服。

　　第二：里面一些不同类型的指针直接赋值也被我用上了强制转换后再赋值，避免某些编译器会报错。

　　3. malloc.c 源文件分析

　　　　在malloc.c源文件中malloc函数原型是：void * malloc(unsigned int size); size为需要申请动态内存的字节大小。但是实际上它在分配内存的时候不仅仅只分配size个字节内存，它还会多为它分配一个管理这个分配内存块的管理节点。所以它分配的内存字节数应该是： size+sizeof(__mem__); 其中__mem__便是init_mem.c源文件中的链表节点。

　　　　malloc的算法大概是：查找AVAIL链表中next域下各个节点空闲的内存块，如果发现这个空闲块>=size的大小，则停止查找并进行内存分配。如果找不到合适的内存块，则返回NULL。

　　　　如果所找到的空闲块分配size个字节之后所剩的内存并不多，则将空闲块分配给应用程序后，然后将这一块从AVAIL链表中直接除去。如果空闲块所剩较多，则分割这个空闲块，将分割出来的空闲块链在AVAIL链表中。

　　　　malloc 的源码如下：

 1 void * _malloc ( unsigned int size)
 2 {
 3     __memp__ q;                /* 指向的是内存空闲块 */
 4     __memp__ p;                /* q->next */
 5     unsigned int k;            /* 剩下的空闲内存块大小 */
 6 
 7 
 8     q = &AVAIL;
 9 
10 
11     /*    在AVATL链表中查找空闲的堆内存    */
12     while (1)
13     {
14         if ((p = q->next) == NULL)
15         {
16             return (NULL);                             /* 没有空闲的堆内存，返回NULL */
17         }
18 
19         if (p->len >= size)                            /*    找到一个空闲的内存块，并且这个内存块大于所要分配的大小    */
20             break;
21 
22         q = p;
23     }
24 
25     k = p->len - size;                                /* 申请内存后还剩下多少内存 */
26 
27     if (k < MIN_BLOCK)                                /* 如果分配的内存太大，超过了最小堆内存块的定义，则一次性把堆内存给分配完，并把AVAIL结点的next域置NULL，表示没有堆内存可再次分配了 */
28     {
29         q->next = p->next;
30         return (&p[1]);                                /* 返回分配的内存指针 */
31     }
32 
33 
34     k -= HLEN;                                        /*    多分配一个管理分配内存的节点，所以k要多减去一个节点的字节数    */
35     p->len = k;                                       /*    p所指的是空闲块    */
36 
37     
38     q = (__memp__) (((char *) (&p [1])) + k);        /*    q指向分配内存的起始地址。注意，这里的q所指向的地址是有加上管理分配内存节点的。    */
39     q->len = size;                                   /*    分配内存的大小，也就是malloc 参数中size的大小，它不包含管理节点的大小    */
40 
41     return (&q[1]);                                  /* 返回分配的内存的指针 */
42 }

　　　　当你调用 int *p = (int *)malloc(40); 之后它的内存分布情况可能如下：

　　malloc.c源码分析就此告一段落，因为malloc.c源文件中主要也是这个malloc函数。当然，下面我会给出KEIL 安装目录下malloc.c的源码供大家参考对比：

  1 /*-----------------------------------------------------------------------------
  2 MALLOC.C is part of the C51 Compiler package from Keil Software.
  3 Copyright (c) 1995-2002 Keil Software.  All rights reserved.
  4 -----------------------------------------------------------------------------*/
  5 #include <stdlib.h>
  6 
  7 /*-----------------------------------------------
  8 Memory pool block structure and typedefs.
  9 Memory is laid out as follows:
 10 
 11 {[NXT|LEN][BLK (LEN bytes)]}{[NXT|LEN][BLK]}...
 12 
 13 Note that the size of a node is
 14 __mem__.len + sizeof (__mem__)
 15 -----------------------------------------------*/
 16 struct __mem__
 17 {
 18     struct __mem__ _MALLOC_MEM_ *next;    /* single-linked list */
 19     unsigned int                len;      /* length of following block */
 20 };
 21 
 22 typedef struct __mem__         __memt__;
 23 typedef __memt__ _MALLOC_MEM_ *__memp__;
 24 
 25 #define    HLEN    (sizeof(__memt__))
 26 
 27 /*-----------------------------------------------
 28 Memory pool headers.  AVAIL points to the first
 29 available block or is NULL if there are no free
 30 blocks.
 31 
 32 Note that the list is maintained in address
 33 order.  AVAIL points to the block with the
 34 lowest address.  That block points to the block
 35 with the next higher address and so on.
 36 -----------------------------------------------*/
 37 extern __memt__ _MALLOC_MEM_ __mem_avail__ [];
 38 
 39 #define AVAIL    (__mem_avail__[0])
 40 
 41 #define MIN_BLOCK    (HLEN * 4)
 42 
 43 /*-----------------------------------------------------------------------------
 44 void _MALLOC_MEM_ *malloc (
 45 unsigned int size);            number of bytes to allocate
 46 
 47 Return Value
 48 ------------
 49 NULL    FAILURE:  No free blocks of size are available
 50 NON-NULL    SUCCESS:  Address of block returned
 51 -----------------------------------------------------------------------------*/
 52 void _MALLOC_MEM_ *malloc (
 53                            unsigned int size)
 54 {
 55     __memp__ q;            /* ptr to free block */
 56     __memp__ p;            /* q->next */
 57     unsigned int k;            /* space remaining in the allocated block */
 58 
 59     /*-----------------------------------------------
 60     Initialization:  Q is the pointer to the next
 61     available block.
 62     -----------------------------------------------*/
 63     q = &AVAIL;
 64 
 65     /*-----------------------------------------------
 66     End-Of-List:  P points to the next block.  If
 67     that block DNE (P==NULL), we are at the end of
 68     the list.
 69     -----------------------------------------------*/
 70     while (1)
 71     {
 72         if ((p = q->next) == NULL)
 73         {
 74             return (NULL);                /* FAILURE */
 75         }
 76 
 77         /*-----------------------------------------------
 78         Found Space:  If block is large enough, reserve
 79         if.  Otherwise, copy P to Q and try the next
 80         free block.
 81         -----------------------------------------------*/
 82         if (p->len >= size)
 83             break;
 84 
 85         q = p;
 86     }
 87 
 88     /*-----------------------------------------------
 89     Reserve P:  Use at least part of the P block to
 90     satisfy the allocation request.  At this time,
 91     the following pointers are setup:
 92 
 93     P points to the block from which we allocate
 94     Q->next points to P
 95     -----------------------------------------------*/
 96     k = p->len - size;        /* calc. remaining bytes in block */
 97 
 98     if (k < MIN_BLOCK)        /* rem. bytes too small for new block */
 99     {
100         q->next = p->next;
101         return (&p[1]);                /* SUCCESS */
102     }
103 
104     /*-----------------------------------------------
105     Split P Block:  If P is larger than we need, we
106     split P into two blocks:  the leftover space and
107     the allocated space.  That means, we need to
108     create a header in the allocated space.
109     -----------------------------------------------*/
110     k -= HLEN;
111     p->len = k;
112 
113     q = (__memp__ ) (((char _MALLOC_MEM_ *) (&p [1])) + k);
114     q->len = size;
115 
116     return (&q[1]);                    /* SUCCESS */
117 }

　　实际上里面核心的东西就malloc这个函数而已。

　　4. free.c源文件的分析

　　　　free函数在free.c源文件中的声明是： void _free ( void *memp); 其中memp参数是要进行内存释放的指针。

　　　　free函数的基本算法是：在AVAIL链表中查找一个合适的节点，然后将它挂到链表中。在将memp挂到链表之前，会检查memp相邻之间是否有空闲的内存块，如果有，则将两则合并后再挂到链表中，如果没有，则直接挂到链表中。

　　free函数源码如下：

void _free ( void  *memp)
{

    __memp__ q;                    /* 指向空闲块 */
    __memp__ p;                    /* q->next */
    __memp__ p0;                /* 要被释放的指针 */

    if ((memp == NULL) || (AVAIL.len == 0))
        return;

    p0 = (__memp__)memp;
    p0 = &p0 [-1];    


    q = &AVAIL;



    /*    查找一个可以挂载memp的合适的挂载节点    */
    /*    经过这个算法查找，空闲内存块的开始地址会按升序排序    */
    while (1)
    {
        p = q->next;

        if ((p == NULL) || (p > memp))
            break;

        q = p;
    }


    /*    memp之后是否有空闲内存，若有则合并内存块        */
    if ((p != NULL) && ((((char *)memp) + p0->len) == (char *)p))
    {
        p0->len += p->len + HLEN;
        p0->next = p->next;
    }
    else
    {
        p0->next = p;
    }

    /*    memp之前是否有空闲内存，若有则合并后挂到链表中，若没有则直接挂到链表    */
    if ( ( ((char  *)q) + q->len + HLEN ) == (char *)p0 )
    {
        q->len += p0->len + HLEN;
        q->next = p0->next;
    }
    else
    {
        q->next = p0;
    }
}

int *p = (int *)_malloc (sizeof(int)*10);
int *q = (int *)_malloc (sizeof(int));
_free (p);

当调用以上代码之后，它的内存分布情况可能如下：

从代码之中也可以发现，内存释放之后，管理p内存块的内容并不会做任何处理。所以下一次分配内存的时候再被分配到这一块内存的时候，内存的内容还可能残留着上一次分配后使用过的内容。

下面给出free.c中的源码内容

  1 /*-----------------------------------------------------------------------------
  2 FREE.C is part of the C51 Compiler package from Keil Software.
  3 Copyright (c) 1995-2002 Keil Software.  All rights reserved.
  4 -----------------------------------------------------------------------------*/
  5 #include "stdlib.h"
  6 
  7 /*-----------------------------------------------
  8 Memory pool block structure and typedefs.
  9 Memory is laid out as follows:
 10 
 11 {[NXT|LEN][BLK (LEN bytes)]}{[NXT|LEN][BLK]}...
 12 
 13 Note that the size of a node is:
 14 __mem__.len + sizeof (__mem__)
 15 -----------------------------------------------*/
 16 struct __mem__
 17 {
 18     struct __mem__ _MALLOC_MEM_ *next;    /* single-linked list */
 19     unsigned int                 len;    /* length of following block */
 20 };
 21 
 22 typedef struct __mem__         __memt__;
 23 typedef __memt__ _MALLOC_MEM_ *__memp__;
 24 
 25 #define    HLEN    (sizeof(__memt__))
 26 
 27 /*-----------------------------------------------
 28 Memory pool headers.  AVAIL points to the first
 29 available block or is NULL if there are no free
 30 blocks.  ROVER is a roving header that points to
 31 a block somewhere in the list.
 32 
 33 Note that the list is maintained in address
 34 order.  AVAIL points to the block with the
 35 lowest address.  That block points to the block
 36 with the next higher address and so on.
 37 -----------------------------------------------*/
 38 extern __memt__ _MALLOC_MEM_ __mem_avail__ [];
 39 
 40 #define AVAIL    (__mem_avail__[0])
 41 
 42 /*-----------------------------------------------------------------------------
 43 -----------------------------------------------------------------------------*/
 44 void free (
 45            void _MALLOC_MEM_ *memp)
 46 {
 47     /*-----------------------------------------------
 48     FREE attempts to organize Q, P0, and P so that
 49     Q < P0 < P.  Then, P0 is inserted into the free
 50     list so that the list is maintained in address
 51     order.
 52 
 53     FREE also attempts to consolidate small blocks
 54     into the largest block possible.  So, after
 55     allocating all memory and freeing all memory,
 56     you will have a single block that is the size
 57     of the memory pool.  The overhead for the merge
 58     is very minimal.
 59     -----------------------------------------------*/
 60     __memp__ q;        /* ptr to free block */
 61     __memp__ p;        /* q->next */
 62     __memp__ p0;        /* block to free */
 63 
 64     /*-----------------------------------------------
 65     If the user tried to free NULL, get out now.
 66     Otherwise, get the address of the header of the
 67     memp block (P0).  Then, try to locate Q and P
 68     such that Q < P0 < P.
 69     -----------------------------------------------*/
 70     if ((memp == NULL) || (AVAIL.len == 0))
 71         return;
 72 
 73     p0 = memp;
 74     p0 = &p0 [-1];        /* get address of header */
 75 
 76     /*-----------------------------------------------
 77     Initialize.
 78     Q = Location of first available block.
 79     -----------------------------------------------*/
 80     q = &AVAIL;
 81 
 82     /*-----------------------------------------------
 83     B2. Advance P.
 84     Hop through the list until we find a free block
 85     that is located in memory AFTER the block we're
 86     trying to free.
 87     -----------------------------------------------*/
 88     while (1)
 89     {
 90         p = q->next;
 91 
 92         if ((p == NULL) || (p > memp))
 93             break;
 94 
 95         q = p;
 96     }
 97 
 98     /*-----------------------------------------------
 99     B3. Check upper bound.
100     If P0 and P are contiguous, merge block P into
101     block P0.
102     -----------------------------------------------*/
103     if ((p != NULL) && ((((char _MALLOC_MEM_ *)memp) + p0->len) == p))
104     {
105         p0->len += p->len + HLEN;
106         p0->next = p->next;
107     }
108     else
109     {
110         p0->next = p;
111     }
112 
113     /*-----------------------------------------------
114     B4. Check lower bound.
115     If Q and P0 are contiguous, merge P0 into Q.
116     -----------------------------------------------*/
117     if ((((char _MALLOC_MEM_ *)q) + q->len + HLEN) == p0)
118     {
119         q->len += p0->len + HLEN;
120         q->next = p0->next;
121     }
122     else
123     {
124         q->next = p0;
125     }
126 }
127 \

好，keil 中附带的源码也差不多分析到这里了。下面给出我移植到VS2008的内存管理源码：

  1 #include <iostream>
  2 #include <vector>
  3 using namespace std;
  4 
  5 
  6 static char heap_mem[1024];                        /*    模拟堆内存    */
  7 
  8 #define    HLEN            (sizeof(__memt__))
  9 #define AVAIL            (__mem_avail__[0])        /*    用于代替__mem_avail__[0]的宏定义    */
 10 #define MIN_POOL_SIZE    (HLEN * 10)                
 11 #define MIN_BLOCK        (HLEN * 4)    
 12 
 13 
 14 struct __mem__
 15 {
 16     struct __mem__    *next;    /* 用于连接堆内存中的空闲块 */
 17     unsigned int    len;      /* 下一个内存块的长度 */
 18 };
 19 
 20 typedef struct __mem__         __memt__;
 21 typedef __memt__  *__memp__;
 22 
 23 __memt__  __mem_avail__ [2] =
 24 { 
 25     { NULL, 0 },    /*    用于管理堆内存的头结点，当调用完init_mempool()之后会指向首块内存块，如果堆内存已经用完，则__mem_avail__[0].next为NULL */
 26     { NULL, 0 },    /* UNUSED but necessary so free doesn't join HEAD or ROVER with the pool */
 27                     /*    原文的解释如上    */
 28 };
 29 
 30 
 31 
 32 /*    初始化内存池，    */
 33 int init_mempool (void  *pool, unsigned int size)
 34 {
 35 
 36     if (size < MIN_POOL_SIZE)    /*    如果内存小于定义最小的内存池，则返回内存池初始化失败    */
 37         return (0);     
 38 
 39 
 40     if (pool == NULL)
 41     {
 42         pool = (void *)1;        /*    如果内存池传入的是NULL，则将内存池指向地址为1的位置。    *
 43                                 /*    因为C51单片机的数据段是存储在XDATA, 大小为0x0 ~ 0xffff 共64K可用    */
 44         size--;                    /*    取size-1的内存大小作为堆内存    */
 45         /*    注意的是，若是在X86兼容机不能这么写，因为X86的机子是有内存保护的    */
 46     }
 47 
 48 
 49     AVAIL.next = (__memp__)pool;        /*    指向堆内存    */
 50     AVAIL.len  = size;                    /*    堆内存大小    */
 51 
 52 
 53     (AVAIL.next)->next = NULL;            /*    当前的堆内存还是一块空闲的内存    */
 54     (AVAIL.next)->len  = size - HLEN;    /*    除去管理堆内存的头结点信息，还剩下多少空间可用    */
 55 
 56     return (-1);                           /*    返回成功    */
 57 }
 58 
 59 void * _malloc ( unsigned int size)
 60 {
 61     __memp__ q;                /* 指向的是内存空闲块 */
 62     __memp__ p;                /* q->next */
 63     unsigned int k;            /* 剩下的空闲内存块大小 */
 64 
 65 
 66     q = &AVAIL;
 67 
 68 
 69     /*    在AVATL链表中查找空闲的堆内存    */
 70     while (1)
 71     {
 72         if ((p = q->next) == NULL)
 73         {
 74             return (NULL);                            /* 没有空闲的堆内存，返回NULL */
 75         }
 76 
 77         if (p->len >= size)                            /*    找到一个空闲的内存块，并且这个内存块大于所要分配的大小    */
 78             break;
 79 
 80         q = p;
 81     }
 82 
 83     k = p->len - size;                                /* 申请内存后还剩下多少内存 */
 84 
 85     if (k < MIN_BLOCK)                                /* 如果分配的内存太大，超过了最小堆内存块的定义，则一次性把堆内存给分配完，并把AVAIL结点的next域置NULL，表示没有堆内存可再次分配了 */
 86     {
 87         q->next = p->next;
 88         return (&p[1]);                                /* 返回分配的内存指针 */
 89     }
 90 
 91 
 92     k -= HLEN;                                        /*    多分配一个管理分配内存的节点，所以k要多减去一个节点的字节数    */
 93     p->len = k;                                        /*    p所指的是空闲块    */
 94 
 95     
 96     q = (__memp__) (((char *) (&p [1])) + k);        /*    q指向分配内存的起始地址。注意，这里的q所指向的地址是有加上管理分配内存节点的。    */
 97     q->len = size;                                    /*    分配内存的大小，也就是malloc 参数中size的大小，它不包含管理节点的大小    */
 98 
 99     return (&q[1]);                                    /* 返回分配的内存的指针 */
100 }
101 
102 void _free ( void  *memp)
103 {
104 
105     __memp__ q;                    /* 指向空闲块 */
106     __memp__ p;                    /* q->next */
107     __memp__ p0;                /* 要被释放的指针 */
108 
109     if ((memp == NULL) || (AVAIL.len == 0))
110         return;
111 
112     p0 = (__memp__)memp;
113     p0 = &p0 [-1];    
114 
115 
116     q = &AVAIL;
117 
118 
119 
120     /*    查找一个可以挂载memp的合适的挂载节点    */
121     /*    经过这个算法查找，空闲内存块的开始地址会按升序排序    */
122     while (1)
123     {
124         p = q->next;
125 
126         if ((p == NULL) || (p > memp))
127             break;
128 
129         q = p;
130     }
131 
132 
133     /*    memp之后是否有空闲内存，若有则合并内存块        */
134     if ((p != NULL) && ((((char *)memp) + p0->len) == (char *)p))
135     {
136         p0->len += p->len + HLEN;
137         p0->next = p->next;
138     }
139     else
140     {
141         p0->next = p;
142     }
143 
144     /*    memp之前是否有空闲内存，若有则合并后挂到链表中，若没有则直接挂到链表    */
145     /*    加上 q != &AVAIL是为了不让当q == AVAIL时丢失pool内存池         */
146     if ( ( q != &AVAIL ) && ( ((char  *)q) + q->len + HLEN ) == (char *)p0 )
147     {
148         q->len += p0->len + HLEN;
149         q->next = p0->next;
150     }
151     else
152     {
153         q->next = p0;
154     }
155 }
156 
157 
158 int main (void)
159 {
160 　　//只可以调用一次。
161     init_mempool(heap_mem, sizeof(heap_mem));
162 
163     int *p = (int *)_malloc (sizeof(int)*10);
164     int *q = (int *)_malloc (sizeof(int));
165     
166 
167     _free (p);
168 
169 
170     
171 
172 
173     return 0;
174 }

　　5.回顾总结一下C\C++中内存管理：

　　　　a) 在调用 void* malloc(unsigned int size) 函数进行内存分配的时候，系统(嵌入式的机子裸机跑可能没有上系统) 或者说是C运行库或分配的内容绝不仅仅是size个大小，它还要加上一个管理这个分配的内存块的节点信息，一般放在这个内存块之前(Windows中也是放在分配的内存块之前)。

　　　　b) 调用void free(void *memp) 进行内存释放的时候，其实就是将memp所指内存块挂到管理内存块的链表上去。

　　　　c) 通过例子也可以发现，当多次malloc 和free之后内存碎片的情况将会越来越严重。这也是动态分配内存的一个弱点吧。

　　　　d) 计算机中并没有将内存分为堆或栈，对内存进行分类的仅仅是我们计算机的使用者。

posted @ 2013-05-19 22:48 左懒阅读(2616) 评论(4) 编辑收藏举报

刷新页面返回顶部