我的内存分配器

#include <stddef.h>

class ObjectPool
{
private:
    ObjectPool(unsigned int step, unsigned int size);
    ~ObjectPool();
public:
    static ObjectPool& getSingleton();
    void* alloc(size_t size);
    void dealloc(void *ptr, size_t size);
private:
    class ObjectPoolImpl;
    ObjectPoolImpl *pool;
    unsigned int size;
    unsigned int step;
};
#define USEOBJECTPOOL static void* operator new(size_t size){ return ObjectPool::getSingleton().alloc(size); }static void operator delete(void *ptr, size_t size){ ObjectPool::getSingleton().dealloc(ptr, size); }

#include "ObjectPool.h"
#include "KRYMalloc.h"
#include <stdio.h>

struct ChunkData
{
    unsigned int freeNodeSize;
    ChunkData *next;
};
struct FreeNode
{
    unsigned int id;
    int flag;
    FreeNode *next;
};
static unsigned int freeNodeOffect = offsetof(FreeNode, next);
static unsigned int numNodePerChunk = 256;
class ObjectPool::ObjectPoolImpl
{
public:
    ObjectPoolImpl(){}
    void init(unsigned int size)
    {
        chunkHead = 0;
        freeHead = 0;
        freeNodeSize = freeNodeOffect + size;
        if (sizeof(FreeNode*) > size)
        {
            freeNodeSize = freeNodeOffect + sizeof(FreeNode*);
        }
        chunkDataSize = sizeof(ChunkData) + freeNodeSize * numNodePerChunk;
    }
    ~ObjectPoolImpl()
    {
        ChunkData *cur = 0;
        while (chunkHead)
        {
            cur = chunkHead;
            chunkHead = chunkHead->next;
            KRY_free(cur);
        }
    }
    void* alloc()
    {
        FreeNode *node;
        ChunkData *chunk;
        char *temp;
        if (0 == freeHead)
        {
            chunk = (ChunkData*)KRY_malloc(chunkDataSize);
            chunk->freeNodeSize = numNodePerChunk;
            chunk->next = chunkHead;
            chunkHead = chunk;
            temp = (char*)chunk + sizeof(ChunkData);

            for (unsigned int i = 0; i < numNodePerChunk; ++i)
            {
                node = (FreeNode*)temp;
                node->id = i;
                node->flag = 0;
                node->next = freeHead;
                freeHead = node;
                temp += freeNodeSize;
            }
        }
        node = freeHead;
        freeHead = freeHead->next;

        temp = (char*)node - sizeof(ChunkData) - node->id * freeNodeSize;
        chunk = (ChunkData*)temp;
        chunk->freeNodeSize -= 1;

        if (0 != node->flag)
        {
            int error = 0;
            printf("object alloc error\n");
        }
        node->flag += 1;
        return &node->next;
    }
    void dealloc(void *ptr)
    {
        char *temp = (char*)ptr - freeNodeOffect;
        FreeNode *node = (FreeNode*)temp;

        temp -= sizeof(ChunkData) + node->id * freeNodeSize;
        ChunkData *chunk = (ChunkData*)temp;
        chunk->freeNodeSize += 1;

        if (1 != node->flag)
        {
            int error = 0;
            printf("object dealloc error\n");
        }
        node->flag -= 1;
        node->next = freeHead;
        freeHead = node;
    }
private:
    ChunkData *chunkHead;
    FreeNode *freeHead;
    unsigned int freeNodeSize;
    unsigned int chunkDataSize;
};

ObjectPool::ObjectPool(unsigned int step, unsigned int size)
{
    this->step = step;
    this->size = size;
    pool = new ObjectPoolImpl[size];
    for (unsigned int i = 0; i < size; ++i)
    {
        pool[i].init(step * i + step);
    }
}
ObjectPool::~ObjectPool()
{
    delete[] pool;
}
ObjectPool& ObjectPool::getSingleton()
{
    static ObjectPool singleton(sizeof(int*), 64);
    return singleton;
}
void* ObjectPool::alloc(size_t size)
{
    //return KRY_malloc(size);
    void *data = 0;
    if (size > this->step * this->size)
    {
        data = KRY_malloc(size);
    }
    else
    {
        data = pool[(size + step - 1) / step - 1].alloc();
    }
    return data;
}
void ObjectPool::dealloc(void *ptr, size_t size)
{
    //KRY_free(ptr); return;
    if (size > this->step * this->size)
    {
        KRY_free(ptr);
    }
    else
    {
        pool[(size + step - 1) / step - 1].dealloc(ptr);
    }
}