allocator - C++ - Ответ 4890326

//Pool_alloc
#include <iostream>
using std::cout;
using std::endl;
#include <vector>
using std::vector;
#include <map>
using std::map;
#include <string>
using std::string;
#include <utility>
using std::pair;
 
class Pool
{
    struct Link{Link* next;};
 
    struct Chunk
    {
        enum{size=8*1024-16};//слегка менше 8К, чтобы кусок памяти умещался в 8К
        char mem[size];//для достижения точного выравнивания
        Chunk* next;
    };
 
    Chunk* chunks;
    const unsigned int esize;
    Link* head; 
    Pool (Pool&); //защита от копирования
    void operator=(Pool&);//защита от копирования
    void grow();//увеличить пул
 
public:
    Pool(unsigned int n);//n это размер элементов
    ~Pool();
 
    void* alloc();//выделить память под один элемент
    void free(void* b);//возвращение элемента в пул
};
 
inline void* Pool::alloc()
{
    if(head==0)grow();
    Link* p=head;//вернуть первый элемент
    head=p->next;
    return p;
}
 
inline void Pool::free(void* b)
{
    Link* p=static_cast<Link*>(b);
    p->next=head;
    head=p;
}
 
Pool::Pool(unsigned int sz)
    :esize(sz<sizeof(Link)?sizeof(Link):sz)
{
    head=0;
    chunks=0;
}
 
Pool::~Pool()//освободить все куски (chunks)
{
    Chunk* n=chunks;
    while(n)
    {
        Chunk* p=n;
        n=n->next;
        delete p;
    }
}
 
void Pool::grow()//выделяет новый 'chunk', организуя его в виде связанного
    //списка элементов размером 'esize'
{
    Chunk* n=new Chunk;
    n->next=chunks;
    chunks=n;
 
    const int nelem=Chunk::size/esize;
    char* start=n->mem;
    char* last=&start[(nelem-1)*esize];
 
    for(char*p=start;p<last;p+=esize)
        reinterpret_cast<Link*>(p)->next=reinterpret_cast<Link*>(p+esize);
 
    reinterpret_cast<Link*>(last)->next=0;
    head=reinterpret_cast<Link*>(start);
}
 
template<class T> class Pool_alloc
{
private:
    static Pool mem;//пул элементов размером sizeof(T)
 
public:
    //аналогично стандартному аллокатору(19.4.1)
    typedef unsigned int size_type;
    typedef T* pointer;
 
    Pool_alloc();
    T* allocate(size_type,void*);
    void deallocate(pointer p,size_type n);
};
 
//инициализация статического члена
template<class T> Pool Pool_alloc<T>::mem(sizeof(T));
 
template<class T> Pool_alloc<T>::Pool_alloc(){}
 
template<class T>
T* Pool_alloc<T>::allocate(size_type n,void* k)
{
    if(n==1)return static_cast<T*>(mem.alloc());
    //...
}
 
template<class T>
void Pool_alloc<T>::deallocate(pointer p,size_type n)
{
    if(n==1)
    {
        mem.free(p);
        return;
    }
    //...
}
 
int main()
{
    cout <<"Pool alloc"<<endl;
    //vector<int,Pool_alloc<int> >v;
    map<string,int,Pool_alloc<pair<const string,int> > >m;
    m["hellow"]=33;
    //m["world"]=40;
    //cout <<m["hellow"]<<m["world"]<<endl;
 
    return 0;
}