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.