pool pool Sınıfı

Giriş
boost::simple_segregated_storage sınıfından kalıtır. C kodlarında malloc(), free() işlemleri için kullanılır. Her seferinde kaç byte döndüreceği bellidir.

Tanımlama
Şöyle yaparız.

using Pool = boost::pool<boost::default_user_allocator_malloc_free>;

Constructor
Şöyle yaparız.

Pool pool(32);

Diğer
Elimizde şöyle bir kod olsun

struct A { char data[7];  };
struct B { char data[29]; };

Bu sınıfı C++ container'ları ile kullanmak için şöyle yaparız.

using Pool = boost::pool<boost::default_user_allocator_malloc_free>;

template <typename T> struct my_pool_alloc {
  using value_type = T;

  my_pool_alloc(Pool& pool) : _pool(pool) {
    assert(pool_size() >= sizeof(T));
  }

  template <typename U>
  my_pool_alloc(my_pool_alloc<U> const& other) : _pool(other._pool) {
    assert(pool_size() >= sizeof(T));
  }

  T *allocate(const size_t n) {
    T* ret = static_cast<T*>(_pool.ordered_malloc(n));
    if (!ret && n) throw std::bad_alloc();
      return ret;
  }

  void deallocate(T* ptr, const size_t n) {
    if (ptr && n) _pool.ordered_free(ptr, n);
  }

  // for comparing
  size_t pool_size() const { return _pool.get_requested_size(); }

private:
  Pool& _pool;
};

template <class T, class U>
bool operator==(const my_pool_alloc<T> &a, const my_pool_alloc<U> &b) {
  return a.pool_size()==b.pool_size();
}
template <class T, class U>
bool operator!=(const my_pool_alloc<T> &a, const my_pool_alloc<U> &b) {
  return a.pool_size()!=b.pool_size();
}

Şöyle yaparız.

using std::vector;

Pool pool(32); // 32 should fit both sizeof(A) and sizeof(B)
{
  vector<A, my_pool_alloc<A> > v(1024, pool);
  v.resize(20480);
};

// pool.release_memory();

{
  vector<B, my_pool_alloc<B> > v(1024, pool);
  v.resize(20480);
}

// pool.release_memory();

// sharing the pool between multiple live containers
{
  vector<A, my_pool_alloc<A> > v(512, pool);
  vector<B, my_pool_alloc<B> > w(512, pool);
  v.resize(10240);
  w.resize(10240);
};