how to use a pool
I am interested to allocate and deallocate lots of objects of same
type (and of course size). As the deallocation will take place in
random order and also the maximum number of objects at any time is not
known (though i have a hint), i can't use a vector for this purpose.
Thus i developed a memory pool for fixed objects(an allocator).
i can make the pool as a template of object type or object size.
at present what i am doing is,
1)
template<size_t sz>struct mypool;
struct myobj;
mypool<sizeof(myobj)> pool(1024);///1024 -> typical pool size
void* ptr = pool.allocate();
myobj* obj = new(ptr)(x,y,z);////where x,y,z are myobj constructor
params.
similarly te destruction is done as,
obj->~myobj();
pool.deallocate(obj);
if i want to have a single step solution for them like
2)
template<typename T> struct mypool;
myobj* ptr = pool.create(x,y,z);
pool.drop(ptr);
Here he first step (ie create ) i can't write as i can't forward the
x,y,z to the class constructor.
I have to use a copy constructor like,
myobj* ptr = pool.create(myobj(x,y,z));
any myobj doesn't have one!.
The most simplistic i wanted to write is of course overloading new &
delete for myobj like
3)
sruct myobj{
public:
static void* new(size_t sz,mypool<sizeof(myobj)>& p){
return p.allocate();
}
static void delete(void* ptr,mypool<sizeof(myobj)>& p){
p.deallocate(ptr);
}
};
and using it as,
mypool<sizeof(myobj)> pool(1024);
myobj* obj = new (pool)(x,y,z);
delete (pool) obj;
However this fancy syntax is not supported by C++ .
(Note: i can't make mypool<sizeof(myobj)> a static member of myobj.
They are to be allocated
from different thread with each one has its own private pool.)
So my choice is option 2, but any way can i make that forwarding take
place without copy constructor ? something like boost inplace factory?
Or can i have any more elegant method to solve this ?
A side question,
I was using boost lambda & function combination something as
function<bool(int)> f = _1 < 5;
or function<void(myobj)> print = std::cout<<_1;
recently wen i was testing it with gcc c++0x mode (also MSVC TR1)
all complains lambda is not overloaded with those operators.Was those
fancy things are BLL specific and not present in std?
Thanks in advance
abir