2
  1. Should I ever prevent memory leaks using shared pointers with boost::object_pool (in case of an exception inside malloc-destroy block)?

  2. If yes, what is the correct way to initialize shared_ptr?

  3. How to clean up memory afterwards?

#include <boost/pool/object_pool.hpp> #include <boost/shared_ptr.hpp> int main() { boost::object_pool<int> pool; // Which is the correct way of initializing the shared pointer: // 1) int *i = pool.malloc(); boost::shared_ptr<int> sh(i); int *j = pool.construct(2); boost::shared_ptr<int> sh2(j); // or 2) boost::shared_ptr<int> sh(pool.malloc()); // Now, how should i clean up the memory? // without shared_ptr I'd call here pool.destroy(i) and pool.destroy(j) } 

1 Answer 1

1

Does it need to be a shared pointer?

unique_ptr has the benefit to encode the deleter into the type:

#include <boost/pool/object_pool.hpp> template <typename T, typename Pool = boost::object_pool<T> > struct pool_deleter { pool_deleter(Pool& pool) : _pool(pool) {} void operator()(T*p) const { _pool.destroy(p); } private: Pool& _pool; }; #include <memory> template <typename T> using pool_ptr = std::unique_ptr<T, pool_deleter<T, boost::object_pool<T> > >; int main() { boost::object_pool<int> pool; pool_ptr<int> i(pool.construct(42), pool); std::cout << *i << '\n'; } 
Sign up to request clarification or add additional context in comments.

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.