...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
boost::container::node_allocator
// In header: <boost/container/node_allocator.hpp> template<typename T, std::size_t NodesPerBlock = NodeAlloc_nodes_per_block> class node_allocator { public: // types typedef T value_type; typedef T * pointer; typedef const T * const_pointer; typedef ::boost::container::dtl::unvoid_ref< T >::type reference; typedef ::boost::container::dtl::unvoid_ref< const T >::type const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef boost::container::dtl::version_type< self_t, Version > version; // member classes/structs/unions template<typename T2> struct rebind { // types typedef node_allocator< T2, NodesPerBlock > other; }; // construct/copy/destruct node_allocator() noexcept; node_allocator(const node_allocator &) noexcept; template<typename T2> node_allocator(const node_allocator< T2, NodesPerBlock > &) noexcept; ~node_allocator(); // public member functions size_type max_size() const; pointer allocate(size_type, const void * = 0); void deallocate(const pointer &, size_type) noexcept; pointer allocation_command(allocation_type, size_type, size_type &, pointer &); size_type size(pointer) const noexcept; pointer allocate_one(); void allocate_individual(std::size_t, multiallocation_chain &); void deallocate_one(pointer) noexcept; void deallocate_individual(multiallocation_chain &) noexcept; void allocate_many(size_type, std::size_t, multiallocation_chain &); void allocate_many(const size_type *, size_type, multiallocation_chain &); void deallocate_many(multiallocation_chain &) noexcept; // public static functions static void deallocate_free_blocks() noexcept; // friend functions friend void swap(self_t &, self_t &) noexcept; friend bool operator==(const node_allocator &, const node_allocator &) noexcept; friend bool operator!=(const node_allocator &, const node_allocator &) noexcept; // private member functions pointer priv_allocation_command(allocation_type, std::size_t, size_type &, pointer &); };
An STL node allocator that uses a modified DlMalloc as memory source.
This node allocator shares a segregated storage between all instances of node_allocator with equal sizeof(T).
NodesPerBlock is the number of nodes allocated at once when the allocator runs out of nodes
node_allocator
public
construct/copy/destructnode_allocator() noexcept;Default constructor.
node_allocator(const node_allocator &) noexcept;Copy constructor from other
node_allocator
. template<typename T2> node_allocator(const node_allocator< T2, NodesPerBlock > &) noexcept;Copy constructor from related
node_allocator
. ~node_allocator();Destructor.
node_allocator
public member functionssize_type max_size() const;
Returns the number of elements that could be allocated. Never throws
pointer allocate(size_type count, const void * = 0);
Allocate memory for an array of count elements. Throws std::bad_alloc if there is no enough memory
void deallocate(const pointer & ptr, size_type count) noexcept;
Deallocate allocated memory. Never throws
pointer allocation_command(allocation_type command, size_type limit_size, size_type & prefer_in_recvd_out_size, pointer & reuse);
size_type size(pointer p) const noexcept;
Returns maximum the number of objects the previously allocated memory pointed by p can hold.
pointer allocate_one();
Allocates just one object. Memory allocated with this function must be deallocated only with deallocate_one(). Throws bad_alloc if there is no enough memory
void allocate_individual(std::size_t num_elements, multiallocation_chain & chain);
Allocates many elements of size == 1. Elements must be individually deallocated with deallocate_one()
void deallocate_one(pointer p) noexcept;
Deallocates memory previously allocated with allocate_one(). You should never use deallocate_one to deallocate memory allocated with other functions different from allocate_one(). Never throws
void deallocate_individual(multiallocation_chain & chain) noexcept;
void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain & chain);
Allocates many elements of size elem_size. Elements must be individually deallocated with deallocate()
void allocate_many(const size_type * elem_sizes, size_type n_elements, multiallocation_chain & chain);
Allocates n_elements elements, each one of size elem_sizes[i] Elements must be individually deallocated with deallocate()
void deallocate_many(multiallocation_chain & chain) noexcept;
node_allocator
friend functionsfriend void swap(self_t &, self_t &) noexcept;
Swaps allocators. Does not throw. If each allocator is placed in a different memory segment, the result is undefined.
friend bool operator==(const node_allocator &, const node_allocator &) noexcept;
An allocator always compares to true, as memory allocated with one instance can be deallocated by another instance
friend bool operator!=(const node_allocator &, const node_allocator &) noexcept;
An allocator always compares to false, as memory allocated with one instance can be deallocated by another instance