c++ - Is there a faster way or optimization I can apply to my improvised memory pool? -

i have couple different objects allocate objects communicate each other , decided give them each locally managed memory pool node can tagged free merely setting flag within it.

the idea this:

struct cat {/**couple data fields*/}; struct rat { rat() : poolindex_(0), poolsize_(initial_size), pool_(new cat *[poolsize_]) { (size_t = 0; < poolsize_; ++i) pool_[i] = new cat; } size_t poolindex_; size_t poolsize_; cat** pool_; }; 

i provide non-member function rat , friends resize pool whenever run out of free cat nodes (giving out nodes done via poolindex_++ % poolsize_;). non-member function follows:

void quadruplepool(cat*** pool, size_t& poolindex, size_t& poolsize) { poolindex = poolsize; cat** tmp = new cat *[poolsize*4]; (size_t = 0; < poolsize; ++i) tmp[i] = (*pool)[i]; delete[] (*pool); (*pool) = tmp; poolsize = poolsize*4; (size_t = poolindex; < poolsize; ++i) (*pool)[i] = new cat; } 

is there in code give me speedup have right now? (speed far critical me)

i think far more efficient array allocation of cats, , when freed, place them in free list.

struct catpool { size_t poolsize_; size_t i_; cat *pool_; cat *free_; typedef std::unique_ptr<cat[]> poolptr; std::list<poolptr> cleanup_; catpool (size_t pool_size) : poolsize_(pool_size), free_(0) { grow(); } void grow () { i_ = 0; pool_ = new cat[poolsize_]; cleanup_.push_back(poolptr(pool_)); } cat * () { cat *c = free_; if (c) { free_ = free_->next_; return c; } (;;) { if (i_ < poolsize_) return &pool_[i_++]; grow(); } } void put (cat *c) { c->next_ = free_; free_ = c; } }; 

but, should consider using existing pool allocator implementation. example, boost's object_pool.