讨论一内存分配算法

[nightfallrove]

实现一个类，构造函数传入一个指针，指向一个预先分配好的内存块，大小已知设为5M，
除了使用一个成员变量来保存该指针外，不可以再使用任何其它成员变量。也就是说所有使用的数据
结构都必须在这5M内存里面调配，我的想法是把五M中的前200K用来管理内存块，记录已分配、未分配
以其它数据。
现在要实现两成员个函数，一个可以从这五M内存中分配指定大小的内存块，给用户使用。
另一个用来释放已分配的内存。
算法的设计目的是提供最快速的算法（会连续分配/释放，平均效率最高），能够分配出最多的内存。
请大家提供思路！

[cxjddd]

方法很多，看书是最快的办法：）

[nightfallrove]

static Header mem[MAXSIZE]
、、、、、、、、、、、、、、、、、、、、、
除了记下那个初始地址外不可以再使用全局变量，把这个变量分配在给定的内存里面还差不多
楼上，哪本书里有比较好的算法？
或者网上有、、

[carylin]

程序好长啊，看不下来，呵呵

[freezingfire]

用new (place_address) class_name可以将对象生成在指定地址。

[game_zhang]

gz

[ywfscu]

我弄了一个，你看看嘛！
#define NULL 0
#define MAXSIZE 1024

typedef double Align;
typedef union header
{
struct { union header * next;
unsigned usedsize;
unsigned freesize;
} s;
Align a ;
}Header ;

static Header mem[MAXSIZE] ;
static Header * memptr = NULL ;

void * malloc (unsigned nbytes)
{
Header * p, *newp ;
unsigned nunits ;
nunits = (nbytes + sizeof (Header) - 1) / sizeof (Header) + 1 ;
if (memptr == NULL)
{
memptr -> s.next = memptr = mem ;
memptr -> s.usedsize = 1 ;
memptr -> s.freesize = MAXSIZE -1 ;
}
for (p = memptr ;
(p->s.next!= memptr) && (p->s.freesize < nunits) ;
p = p->s.next );
if (p->s.freesize < nunits) return NULL ;
newp = p+p->s.usedsize ;
newp->s.usedsize = nunits ;
newp->s.freesize = p->s.freesize - nunits ;
newp->s.next = p->s.next ;
p->s.freesize = 0 ;
p->s.next = newp ;
memptr = newp ;
return (void *) (newp +1) ;
}

void free (void * ap)
{
Header * bp,*p,*prev ;
bp = (Header *) ap - 1 ;
for (prev =memptr ,p=memptr->s.next ;
(p!=bp)&& (p!= memptr); prev=p,p=p->s.next);
if (p!=bp) return ;
prev->s.freesize += p->s.usedsize + p->s.freesize ;
prev->s.next = p->s.next ;
memptr = prev ;
}

[shenailin]

我现在也搞了个二级内存管理!
好烦哦 !

[DentistryDoctor]

看看STL的源代码有关内存池(memory pool）的部分，boost也有memory pool.

[Visual_Li]

。。

[huaguli]

看STL的源代码有关内存池(memory pool）的部分