As far as I understand, you need to maintain a malloc'ed "your own" heap with some pool, but need to keep the heap alive if some objects are still in use but the pool is destroyed. boost::shared_ptr constructor that accepts deleter can be useful I guess. Sorry for abusing with bad formatted code:
class PoolObjectDeleter { shared_ptr<void> pool_mem; weak_ptr<Pool> pool; PoolObjectDeleter(shared_ptr<Pool> & p, shared_ptr<void> & mem) : pool(p), pool_mem(mem) {} // provide copy constructor if customization needed void operator()(T* p) { // placement delete could go here shared_ptr<Pool> sp_pool = pool.lock(); if(sp_pool) sp_pool->deallocate(p); } }
class Pool : enable_shared_from_this<Pool> { // ...implementation details... shared_ptr<void> pool_mem; shared_ptr<T> allocate() { T *obj; // ... find usable object... use palcement new if needed I guess PoolObjectDeleter d(shared_from_this(), this->pool_mem); shared_ptr<T> ret_value(obj, d); return ret_value; } void deallocate(T *p) { /* implementation */ } }
Pool holds shared_ptr to memory, so if pool is destroyed and no objects are allocated / in use, memory released. It looks that one had to provide class to wrap malloc'ed memory malloc/free so that new/delete would work. When object is created, copy of deleter holds shared_ptr to memory protecting it from destruction, and weak_ptr to pool allowing user to destroy it. When pool is destroyed and some objects are still shared_pointed by user deleter could not deallocate it with pool, but still placement delete the object and reduce refcounter on memory, destroying it with last used object removal. I like your concept for deallocating the object that pool handed out. I am using a private static class within pool to provide the function to
Igore Dmit. wrote: the shared_ptr destructor. This allowed the object to be delete if the pool was destroyed but causes a bottleneck for other pools of the same type. I have two questions. One, shouldn't the PoolObjectDeleter should be a template class? Two, why is the PoolObjectDeleter passed a shared_ptr<void>? It seems the pool_mem is to help with reference counting to determine if the pool is destroyed. Yet, I thought the enable_shared_from_this took care of the reference counting with the pool.lock(). Ryan