小型内存池

我们都知道，不管是用new还是用malloc，每次系统分配内存的时候都要占用系统资源的。而且每次我们向操作系统分配内存的时候，得到的都是包含cookie的内存块，其实际大小要大于我们所申请的内存大小。
对于频繁申请内存的情况，我们可以一次向系统申请一大块内存，然后自己管理，这样既能节省系统调用的时间，能节省多个cookie所占用的空间。

pre-class allocator

第一版最简单的实现

#include <cstddef>
#include <iostream>
using namespace std;

class Scree
{
public:
    Screen(int x) : i(x) { };
    int get() { return i; }

    void *operator new(size_t);
    void operator delete(void *);

private:
    Screen *next;
    static Screen *freeStore;
    static const int screenChunk;

private:
    int i;
};

Screen *Screen::freeStore = 0;
const int Screen::screenChunk = 24;

void *Screen::operator new(size_t size)
{
    Screen *p;
    if(!freeStore)
    {
        size_t chunk = screenChunk * size;
        freeStore = p = reinterpret_cast<Screen *>(new char[chunk]);
        
        // 分割内存，转成链表形式使用
        for (; p != &freeStore[screenChunk - 1]; ++p)
            p->next = p + 1;
        p->next = 0;
    }

    p = freeStore;
    freeStore = freeStore->next;
    return p;
}

void Screen::operator delete(void *p)
{
    // freeStore指向下一块未使用的内存
    // 这里将自身设置为下一块未使用，就是删除了
    (static_cast<Screen *>(p))->next = freeStore;
    freeStore = static_cast<Screen *>(p);
}

第二个版本

class Airplane
{
private:
    struct AirplanceRep
    {
        unsigned long miles;
        char type;
    };

private:
    // 这个联合体的用法叫嵌入式指针
    union
    {
        AirplaneRep rep;
        Airplane *next;
    };

public:
    unsigned long getMiles() { return rep.miles; }
    char getType() { return rep.type; }
    void set(unsigned long m, char t)
    {
        rep.miles = m;
        rep.type = t;
    }

public:
    static void *operator new(size_t size);
    static void operator delete(void *deadObject);

private:
    static const int BLOCK_SIZE;
    static Airplane *headOfFreeList;
};

Airplance *Airplane::headOfFreeList;
const int Airplane::BLOCK_SIZE = 512;

void *Airplane::operator new(size_t size)
{
    // 如果是继承的子类，此处可能会有问题，所以需要判断一下
    if(size != sizeof(Airplance))
        return ::operator new(size);

    Airplane *p = headOfFreeList;
    if (p) 
    {
        headOfFreeList = p->next;
    }
    else
    {
        Airplane *newBlock = static_cast<Airplane *>
        (::operator new(BLOCK_SIZE * sizeof(Airplane)));

        // 跳过0，不知道为什么，应该是用第0号元素干些别的事
        for(int i = 1; i < BLOCK_SIZE - 1; ++i)
            newBlock[i].next = &newBlock[i + 1];
        
        newBlock[BLOCK_SIZE - 1].next = 0;
        p = newBlokc;
        headOfFreeList = &newBlock[1];
    }

    return p;
}

void Airplane::operator delete(void *deadObject)
{
    if(deadObject == 0) return;
    if(size != sizeof(Airplane))
    {
        ::operator delete(deadObject);
        return;
    }

    Airplane *carcass = static_cast<Airplane *>(deadObject);
    carcass->next = headOfFreeList;
    headOfFreeList = carcass;
}

与第一版最大的区别是用union中使用了嵌套指针。

static allocator

这个就是对上面内存管理部分给抽象出来，以后可以直接调用

class allocator
{
private:
    // 这个用法类似于内核中链表的用法
    // 把数据域完全从元素中删除，采用数据包裹指针的形式使用链表
    struct obj
    {
        struct obj *next;
    };

public:
    void *allocate(size_t);
    void deallocate(void *);

private:
    obj * freeStore = nullptr;
    const int CHUNK = 5;
};

void *allocator::allocate(size_t size)
{
    obj *p;
    if(freeStore)
    {
        size_t chunk = CHUNK * size;
        freeStore = p = (obj*)malloc(chunk);

        for(int i = 0; i < (CHECK - 1); ++i)
        {
            p->next = (obj *)((char *)p + size);
            p = p->next
        }

        p->next = nullptr;
    }

    p = freeStore;
    freeStore = freeStore->next;
    return = p;
}

void allocator::deallocate(void *p)
{
    ((obj *)p)->next = freeStore;
    freeStore = (obj *)p;
}

// 下面是用法距离

class Foo
{
public:
    long L;
    string str;
    static allocator myAlloc;

public:
    Foo(long l):L(l) { }
    static void *operator new(size_t size)
    {
        return myAlloc.allocate(size);
    }
    static void operator delete(void *p)
    {
        return myAlloc.deallocate(p);
    }
}

allocator Foo::myAlloc;

macro for static allocator

再懒一点，改写成宏

#define DECLARE_POOL_ALLOC() \
public : \
    void *operator new(size_t size) { return myAlloc.allocate(size); } \
    void operator delete(void *p) { myAlloc.deallocate(p); } \
protected: \
    static allocator myAlloc;

#define IMPLEMENT_POOL_ALLOC(class_name) \
allocator class_name::myAlloc;

class Foo
{
    DECLARE_POOL_ALLOC();
public:
    long L;
    string str;
public:
    Foo(long l):L(l) {}
};

IMPLEMENT_POOL_ALLOC(Foo);