Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext

Class template node_allocator

boost::container::node_allocator

Synopsis

// 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 unspecified    reference;      
  typedef unspecified    const_reference;
  typedef std::size_t    size_type;      
  typedef std::ptrdiff_t difference_type;
  typedef unspecified    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;
  std::pair< pointer, bool > 
  allocation_command(allocation_type, size_type, size_type, size_type &, 
                     pointer = 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
  std::pair< pointer, bool > 
  priv_allocation_command(allocation_type, std::size_t, std::size_t, 
                          std::size_t &, void *);
};

Description

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/destruct

  1. node_allocator() noexcept;
    Default constructor.
  2. node_allocator(const node_allocator &) noexcept;
    Copy constructor from other node_allocator.
  3. template<typename T2> 
      node_allocator(const node_allocator< T2, NodesPerBlock > &) noexcept;
    Copy constructor from related node_allocator.
  4. ~node_allocator();
    Destructor.

node_allocator public member functions

  1. size_type max_size() const;

    Returns the number of elements that could be allocated. Never throws

  2. 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

  3. void deallocate(const pointer & ptr, size_type count) noexcept;

    Deallocate allocated memory. Never throws

  4. std::pair< pointer, bool > 
    allocation_command(allocation_type command, size_type limit_size, 
                       size_type preferred_size, size_type & received_size, 
                       pointer reuse = pointer());
  5. size_type size(pointer p) const noexcept;

    Returns maximum the number of objects the previously allocated memory pointed by p can hold.

  6. 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

  7. 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()

  8. 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

  9. void deallocate_individual(multiallocation_chain & chain) noexcept;
  10. 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()

  11. 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()

  12. void deallocate_many(multiallocation_chain & chain) noexcept;

node_allocator public static functions

  1. static void deallocate_free_blocks() noexcept;
    Deallocates all free blocks of the pool.

node_allocator friend functions

  1. friend 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.

  2. 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

  3. 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

node_allocator private member functions

  1. std::pair< pointer, bool > 
    priv_allocation_command(allocation_type command, std::size_t limit_size, 
                            std::size_t preferred_size, 
                            std::size_t & received_size, void * reuse_ptr);

PrevUpHomeNext