efficient c++,单线程内存池

基于 http://www.cnblogs.com/diegodu/p/4555018.html operator new的知识基础上 介绍这个章节的内容

对于一般直接 new 与delete 性能较差，可以自己管理写内存的申请与释放。其实一般的operator new 和operator delete 直接调用 malloc 和 free的。

版本0：

class Rational
{
public:
    Rational(int a=, int b = ): n(a),d(b){}
private:
    int n;
    int d;
};

版本1：专用的内存管理器

#include <stddef.h> // for size_t
#include <iostream>

using namespace std;

class NextOnFreeList {
    public:
        NextOnFreeList *next;
};

class Rational {
    public:
        Rational (int a = , int b =  ) : 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; // A free list of Rational objects.
        static void expandTheFreeList();
        enum { EXPANSION_SIZE = };

        int n; // Numerator
        int d; // Denominator
};

inline
void * Rational::operator new(size_t size)
{
    if ( == freeList) {// If the list is empty, fill it up.
        expandTheFreeList();
    }

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

    return head;
}

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

void Rational::expandTheFreeList()
{
    // We must allocate an object large enough to contain the next
    // pointer.
    size_t size = (sizeof(Rational) > sizeof(NextOnFreeList *)) ?
        sizeof(Rational) : sizeof(NextOnFreeList *);

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

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

    runner->next = ;

    cout << "expand" << endl;
}

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

NextOnFreeList *Rational::freeList = ;

int main()
{
    Rational *array[];

    Rational::newMemPool();

    // Start timing here

    for (int j = ; j < ; j++) {
        for (int i = ; i < ; i++) {
            array[i] = new Rational(i);
        }
        for (int i = ; i < ; i++) {
            delete array[i];
        }
    }

    // Stop timing here

    Rational::deleteMemPool();

    return ;
}

这版本是通过重载 目标类 中的new 与delete 实现内存管理，只适用于目标类，但是速度是最快的。

实现方式是维护一个链表，类中静态声明链表头，链表维护一串空间，通过类型转换在  目标类 和 链表指针 之间转换。

如果内存不够（freelist=NULL）是一次申请较多内存进行维护。

链表的添加删除（对于函数释放空间与申请空间）是在链首操作。

书上47 行 52行通过 静态类型转换不成功，改为了 强制转换，在 g++ 中能够编译运行。

主要在主函数中调用静态函数 链表的申请与释放。

版本2：固定大小对象的内存池

考虑版本1，可以通过模板实现管理特定的对象。最主要的参数是类的大小。

实现是专门声明一个管理内存的内存池类，使用模板实现，提供alloc（） free（） 接口，给类申请与释放内存。

内存池类的实现是自身有一个MemoryPool<T>* next 指针用来指向维护的链表，内存的操作都在链首位置。

#include <stddef.h>
#include <iostream>

using namespace std;

template <class T>
class MemoryPool {
    public:
        MemoryPool (size_t size = EXPANSION_SIZE);
        ~MemoryPool ();

        // Allocate a T element from the free list.
        inline void* alloc (size_t size);

        // Return a T element to the free list.
        inline void free (void *someElement);
    private:
        // next element on the free list.
        MemoryPool<T> *next;

        // If the freeList is empty, expand it by this amount.
        enum { EXPANSION_SIZE = };

        // Add free elements to the free list
        void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template <class T>
MemoryPool <T> :: MemoryPool (size_t size)
{
    expandTheFreeList(size);
}

    template < class T >
MemoryPool < T > :: ~MemoryPool ()
{
    MemoryPool<T> *nextPtr = next;
    for (nextPtr = next; nextPtr != NULL; nextPtr = next) {
        next = next->next;
        cout << nextPtr << endl;
        //delete [] nextPtr;
        //delete  nextPtr;
        delete [](char*)nextPtr;  //不太明白为什么这样是对的，上面的方法不行。。
　　　　　　　　　　　　　　　　　　　　//明白了，因为new的时候就是用char字节的方法申请的，delete的时候要对应。。
    }
}

template < class T >
    inline
void* MemoryPool < T > :: alloc (size_t)
{
    if (!next) {
        expandTheFreeList();
    }

    MemoryPool<T> *head = next;
    next = head->next;

    return head;
}

template < class T >
    inline
void MemoryPool < T > :: free (void *doomed)
{
    MemoryPool<T> *head = static_cast <MemoryPool<T> *> (doomed);

    head->next = next;
    next = head;
}

    template < class T >
void MemoryPool < T > :: expandTheFreeList(int howMany)
{
    // We must allocate an object large enough to contain the
    // next pointer.
    size_t size = (sizeof(T) > sizeof(MemoryPool<T> *)) ?
        sizeof(T) : sizeof(MemoryPool<T> *);

    //MemoryPool<T> *runner = static_cast <MemoryPool<T> *>(new char [size]);
    MemoryPool<T> *runner = (MemoryPool<T> *)(new char [size]);

    next = runner;
    for (int i = ; i < howMany ; i++) {
        //runner->next = static_cast <MemoryPool<T> *> new char [size];
        runner->next = (MemoryPool<T> *)( new char [size]);
        runner = runner->next;
    }
    runner->next = NULL;
}

class Rational {
    public:
        Rational (int a = , int b =  ) : n(a), d(b) {}

        void *operator new(size_t size) { return memPool->alloc(size); }
        void operator delete(void *doomed,size_t size)
        { memPool->free(doomed); }

        static void newMemPool() { memPool = new MemoryPool <Rational>; }
        static void deleteMemPool() { delete memPool; }
    private:
        int n; // Numerator
        int d; // Denominator

        static MemoryPool <Rational> *memPool;
};

MemoryPool <Rational> *Rational::memPool = ;

int main()
{
    Rational *array[];

    Rational::newMemPool();

    // Start timing here

    for (int j = ; j < ; j++) {
        for (int i = ; i < ; i++) {
            array[i] = new Rational(i);
        }
        for (int i = ; i < ; i++) {
            delete array[i];
        }
    }

    // Stop timing here

    Rational::deleteMemPool();

}