...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
boost::fast_pool_allocator — A C++ Standard Library conforming allocator geared towards allocating single chunks.
// In header: <boost/pool/pool_alloc.hpp> template<typename T, typename UserAllocator, typename Mutex, unsigned NextSize, unsigned MaxSize> class fast_pool_allocator { public: // types typedef T value_type; typedef UserAllocator user_allocator; typedef Mutex mutex; typedef value_type * pointer; typedef const value_type * const_pointer; typedef value_type & reference; typedef const value_type & const_reference; typedef pool< UserAllocator >::size_type size_type; typedef pool< UserAllocator >::difference_type difference_type; // member classes/structs/unions // Nested class rebind allows for transformation from fast_pool_allocator<T> to fast_pool_allocator<underline>. </underline> template<typename U> struct rebind { // types typedef fast_pool_allocator< U, UserAllocator, Mutex, NextSize, MaxSize > other; }; // public member functions fast_pool_allocator(); template<typename U> fast_pool_allocator(const fast_pool_allocator< U, UserAllocator, Mutex, NextSize, MaxSize > &); void construct(const pointer, const value_type &); void destroy(const pointer); bool operator==(const fast_pool_allocator &) const; bool operator!=(const fast_pool_allocator &) const; // public static functions static pointer address(reference); static const_pointer address(const_reference); static size_type max_size(); static pointer allocate(const size_type); static pointer allocate(const size_type, const void * const); static pointer allocate(); static void deallocate(const pointer, const size_type); static void deallocate(const pointer); // public data members static const unsigned next_size; };
While class template pool_allocator
is a more general-purpose solution geared towards efficiently servicing requests for any number of contiguous chunks, fast_pool_allocator
is also a general-purpose solution, but is geared towards efficiently servicing requests for one chunk at a time; it will work for contiguous chunks, but not as well as pool_allocator
.
If you are seriously concerned about performance, use fast_pool_allocator
when dealing with containers such as std::list
, and use pool_allocator
when dealing with containers such as std::vector
.
The template parameters are defined as follows:
T Type of object to allocate/deallocate.
UserAllocator. Defines the method that the underlying Pool will use to allocate memory from the system. See User Allocators for details.
Mutex Allows the user to determine the type of synchronization to be used on the underlying singleton_pool
.
NextSize The value of this parameter is passed to the underlying Pool when it is created.
MaxSize Limit on the maximum size used.
Important | |
---|---|
The underlying singleton_pool used by the this allocator constructs a pool instance that is never freed. This means that memory allocated by the allocator can be still used after main() has completed, but may mean that some memory checking programs will complain about leaks. |
fast_pool_allocator
public member functionsfast_pool_allocator();
Ensures construction of the underlying singleton_pool IFF an instance of this allocator is constructed during global initialization. See ticket #2359 for a complete explanation at http://svn.boost.org/trac/boost/ticket/2359 .
template<typename U> fast_pool_allocator(const fast_pool_allocator< U, UserAllocator, Mutex, NextSize, MaxSize > &);
Ensures construction of the underlying singleton_pool IFF an instance of this allocator is constructed during global initialization. See ticket #2359 for a complete explanation at http://svn.boost.org/trac/boost/ticket/2359 .
void construct(const pointer ptr, const value_type & t);
void destroy(const pointer ptr);
Destroy ptr using destructor.
bool operator==(const fast_pool_allocator &) const;
bool operator!=(const fast_pool_allocator &) const;
fast_pool_allocator
public static functionsstatic pointer address(reference r);
static const_pointer address(const_reference s);
static size_type max_size();
static pointer allocate(const size_type n);
static pointer allocate(const size_type n, const void * const);
Allocate memory .
static pointer allocate();
Allocate memory.
static void deallocate(const pointer ptr, const size_type n);
Deallocate memory.
static void deallocate(const pointer ptr);
deallocate/free