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

This is the documentation for a snapshot of the develop branch, built from commit 08e0dd6d5c.
PrevUpHomeNext

Class template allocator

boost::interprocess::allocator

Synopsis

// In header: <boost/interprocess/allocators/allocator.hpp>

template<typename T, typename SegmentManager> 
class allocator {
public:
  // types
  typedef SegmentManager                                                                       segment_manager;
  typedef SegmentManager::void_pointer                                                         void_pointer;   
  typedef T                                                                                    value_type;     
  typedef boost::intrusive::pointer_traits< cvoid_ptr >::template rebind_pointer< T >::type    pointer;        
  typedef boost::intrusive::pointer_traits< pointer >::template rebind_pointer< constT >::type const_pointer;  
  typedef unspecified                                                                          reference;      
  typedef unspecified                                                                          const_reference;
  typedef segment_manager::size_type                                                           size_type;      
  typedef segment_manager::difference_type                                                     difference_type;
  typedef boost::interprocess::version_type< allocator, 2 >                                    version;        

  // member classes/structs/unions
  template<typename T2> 
  struct rebind {
    // types
    typedef allocator< T2, SegmentManager > other;
  };

  // public member functions
  segment_manager * get_segment_manager() const;
  allocator(segment_manager *);
  allocator(const allocator &);
  template<typename T2> allocator(const allocator< T2, SegmentManager > &);
  pointer allocate(size_type, cvoid_ptr = 0);
  void deallocate(const pointer &, size_type);
  size_type max_size() const;
  size_type size(const pointer &) const;
  pointer allocation_command(boost::interprocess::allocation_type, size_type, 
                             size_type &, pointer &);
  void allocate_many(size_type, size_type, multiallocation_chain &);
  void allocate_many(const size_type *, size_type, multiallocation_chain &);
  void deallocate_many(multiallocation_chain &);
  pointer allocate_one();
  void allocate_individual(size_type, multiallocation_chain &);
  void deallocate_one(const pointer &);
  void deallocate_individual(multiallocation_chain &);
  pointer address(reference) const;
  const_pointer address(const_reference) const;

  // friend functions
  void swap(self_t &, self_t &);
};

Description

An STL compatible allocator that uses a segment manager as memory source. The internal pointer type will of the same type (raw, smart) as "typename SegmentManager::void_pointer" type. This allows placing the allocator in shared memory, memory mapped-files, etc...

allocator public member functions

  1. segment_manager * get_segment_manager() const;

    Returns the segment manager. Never throws

  2. allocator(segment_manager * segment_mngr);

    Constructor from the segment manager. Never throws

  3. allocator(const allocator & other);

    Constructor from other allocator. Never throws

  4. template<typename T2> allocator(const allocator< T2, SegmentManager > & other);

    Constructor from related allocator. Never throws

  5. pointer allocate(size_type count, cvoid_ptr hint = 0);

    Allocates memory for an array of count elements. Throws boost::interprocess::bad_alloc if there is no enough memory

  6. void deallocate(const pointer & ptr, size_type);

    Deallocates memory previously allocated. Never throws

  7. size_type max_size() const;

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

  8. size_type size(const pointer & p) const;

    Returns maximum the number of objects the previously allocated memory pointed by p can hold. This size only works for memory allocated with allocate, allocation_command and allocate_many.

  9. pointer allocation_command(boost::interprocess::allocation_type command, 
                               size_type limit_size, 
                               size_type & prefer_in_recvd_out_size, 
                               pointer & reuse);
  10. void allocate_many(size_type elem_size, size_type num_elements, 
                       multiallocation_chain & chain);

    Allocates many elements of size elem_size in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. The elements must be 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]in a contiguous block of memory. The elements must be deallocated

  12. void deallocate_many(multiallocation_chain & chain);

    Allocates many elements of size elem_size in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. The elements must be deallocated with deallocate(...)

  13. pointer allocate_one();

    Allocates just one object. Memory allocated with this function must be deallocated only with deallocate_one(). Throws boost::interprocess::bad_alloc if there is no enough memory

  14. void allocate_individual(size_type num_elements, 
                             multiallocation_chain & chain);

    Allocates many elements of size == 1 in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. Memory allocated with this function must be deallocated only with deallocate_one().

  15. void deallocate_one(const pointer & p);

    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

  16. void deallocate_individual(multiallocation_chain & chain);

    Allocates many elements of size == 1 in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. Memory allocated with this function must be deallocated only with deallocate_one().

  17. pointer address(reference value) const;

    Returns address of mutable object. Never throws

  18. const_pointer address(const_reference value) const;

    Returns address of non mutable object. Never throws

allocator friend functions

  1. void swap(self_t & alloc1, self_t & alloc2);

    Swap segment manager. Does not throw. If each allocator is placed in different memory segments, the result is undefined.


PrevUpHomeNext