(1)单线程内存池---专用Rational内存管理器

来源：互联网发布：golang reflect.value 编辑：程序博客网时间：2024/04/30 17:01

为避免频繁地使用默认内存管理器，Rational类要维护一个预先分配的
Rational对象的静态链表，该表列出空闲的可用对象。当需要Rational
对象时，可以从空闲列表中取出一个，使用后在把它放回空闲列表中以便今后分配

Rational 对象的空闲列表

#include <iostream>
#include <stdlib.h>
using std::cout;
using std::endl;

class NextOnFreeList
{
public:
NextOnFreeList *next;
};

class Rational
{
public:
        Rational(int a = 0, int b = 1) : n(a), d(b) {}
        inline void *operator new(size_t size);
        inline void operator delete(void *doomed, size_t size);

static void newMemPool() { expandTheFreeList(); }
static void deleteMemPool();

private:
static NextOnFreeList *freeList;
static void expandTheFreeList();

enum { EXPANSION_SIZE = 32 };

int n;
int d;
};

inline void * Rational::operator new(size_t size)
{
        if (NULL == freeList)
        {
                expandTheFreeList();
        }

NextOnFreeList *head = freeList;
freeList = head->next;

return head;
}

inline void Rational::operator delete(void *doomed, size_t size)
{
        NextOnFreeList *head = reinterpret_cast<NextOnFreeList *>(doomed);
        if (NULL != head)
        {
                head->next = freeList;
                freeList = head;
        }
}

void Rational::expandTheFreeList()
{
size_t size = (sizeof(Rational) > sizeof(NextOnFreeList *)) ?
sizeof(Rational) : sizeof(NextOnFreeList *);

NextOnFreeList * runner = reinterpret_cast<NextOnFreeList *>(new char[size]);

        freeList = runner;
        for (int i = 0; i < EXPANSION_SIZE; ++i)
        {
                runner->next = reinterpret_cast<NextOnFreeList *>(new char[size]);
                runner = runner->next;
        }

runner->next = NULL;
}

void Rational::deleteMemPool()
{
        NextOnFreeList *nextPtr = NULL;
        for (nextPtr = freeList; nextPtr != NULL; nextPtr = freeList)
        {
                freeList = freeList->next;
                delete []nextPtr;
                nextPtr = NULL;
        }
}

NextOnFreeList *Rational::freeList = NULL;

int main()
{
Rational *arr[1000] = { NULL };
Rational::newMemPool();

        for (int j = 0; j < 500; ++j)
        {
                for (int i = 0; i < 1000; ++i)
                        arr[i] = new Rational(i);

                for (int k = 0; k < 1000; ++k)
                        delete arr[k];
        }

Rational::deleteMemPool();

return 0;
}

0 0