So far, the answer seems to involve referring to boost implementation details, which doesn't thrill me.I just wanted to create some memory-pools that could be used to allocate objects referred to through boost:shared_ptr<>.I want to avoid non-pool memory-allocation, and for each shared-object allocation to involve one (and only one) allocation from one pool, i.e. to be as predictable and compact as possible. This hand-written definition for a pool and an allocator seem to do what I want: ---------- template<typename T> class my_pool { private: char *rawStorage; T *storage; T *nextFree; public: my_pool(size_t S) : storage(nullptr), nextFree(nullptr) { // Allocate memory. rawStorage = new char[sizeof(T) * S]; storage = reinterpret_cast<T*>( rawStorage ); // All objects are free, initially. for (size_t i = 0; i < S; ++i) { T **pFreeObject = reinterpret_cast<T**>(&storage[i]); *pFreeObject = nextFree; nextFree = reinterpret_cast<T*>(&storage[i]); } } ~my_pool() { // TODO: Verify that all allocated objects have been freed. delete[] rawStorage; } T *allocate() { T *freeObject = nextFree; if (nextFree != nullptr) { T **pFreeObject = reinterpret_cast<T**>(nextFree); nextFree = *pFreeObject; } return freeObject; } void deallocate(T *obj) { T **pFreeObject = reinterpret_cast<T**>(obj); *pFreeObject = nextFree; nextFree = obj; } }; template<typename T> class my_allocator : public at_boost::detail::sp_ms_deleter<T> { public: typedef at_boost::detail::sp_counted_impl_pda<T *, at_boost::detail::sp_ms_deleter<T>, my_allocator<T> > shared_type; typedef my_pool<shared_type> pool_type; private: pool_type &m_rPool; void operator=(my_allocator const &other); // Disallow assignment. public: explicit my_allocator(pool_type &a_rPool) : m_rPool(a_rPool) { } my_allocator(my_allocator const &other) : m_rPool(other.m_rPool) { } template <typename U> struct rebind { typedef my_allocator/*<U>*/ other; }; shared_type *allocate(int iCount) { if (iCount == 1) // Only expected to allocate single objects. return m_rPool.allocate(); return nullptr; } void deallocate(shared_type *obj, size_t iCount) { m_rPool.deallocate(obj); } }; ---------- It still needs polish, but it's just a proof of concept. Here's some code that uses the pool/allocator: ---------- my_allocator<int>::pool_type myPool (1024); my_allocator<int> myAllocator(myPool); boost::shared_ptr<int> pTest = boost::allocate_shared<int, my_allocator<int> >(myAllocator); int iVal0 = *pTest; *pTest = sizeof(my_allocator<int>::shared_type); int iVal1 = *pTest; ---------- No big deal. Mostly, the test is to make sure that ::operator new() doesn't get called after the construction of the pool, and that seems to be true. I'm surprised that my expected usage of memory-pools isn't more common.Maybe using boost in an environment with constraints on dynamic memory allocation is unusual? Also, at some point, I need to figure out why my definition of my_allocator<T>::rebind can't use <U> in the way that the standard boost allocators do.I get an incomprehensible error-message when I do that: ---------- boost\smart_ptr\detail\sp_counted_impl.hpp(237): error C2664: 'my_allocator<T>::my_allocator(my_pool<at_boost::detail::sp_counted_impl_pda<P,D,A>> &)' : cannot convert parameter 1 from 'my_allocator<T>' to 'my_pool<T> &'---------- Any comments on what I'm trying to do here? -Steven