| Home | Libraries | People | FAQ | More

## 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::pointer_to_other< cvoid_ptr, T >::type     pointer;
      typedef boost::pointer_to_other< pointer, const T >::type const_pointer;
      typedef unspecified                                       reference;
      typedef unspecified                                       const_reference;
      typedef std::size_t                                       size_type;
      typedef std::ptrdiff_t                                    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;
      };

      // construct/copy/destruct
      allocator(segment_manager *);
      allocator(const allocator &);
      template<typename T2> allocator(const allocator< T2, SegmentManager > &);

      // public member functions
      segment_manager * get_segment_manager() const;
      pointer allocate(size_type, cvoid_ptr = 0) ;
      void deallocate(const pointer &, size_type) ;
      size_type max_size() const;
      size_type size(const pointer &) const;
      std::pair< pointer, bool >
      allocation_command(boost::interprocess::allocation_type, size_type,
                         size_type, size_type &, const pointer & = 0) ;
      multiallocation_chain allocate_many(size_type, std::size_t) ;
      multiallocation_chain allocate_many(const size_type *, size_type) ;
      void deallocate_many(multiallocation_chain) ;
      pointer allocate_one() ;
      multiallocation_chain allocate_individual(std::size_t) ;
      void deallocate_one(const pointer &) ;
      void deallocate_individual(multiallocation_chain) ;
      pointer address(reference) const;
      const_pointer address(const_reference) const;
      void construct(const pointer &, const_reference) ;
      void construct(const pointer &) ;
      void destroy(const pointer &) ;

      // friend functions
      friend 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 construct/copy/destruct

1.     allocator(segment_manager * segment_mngr);

   Constructor from the segment manager. Never throws

2.     allocator(const allocator & other);

   Constructor from other allocator. Never throws

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

   Constructor from related allocator. Never throws

### `allocator` public member functions

1.     segment_manager * get_segment_manager() const;

   Returns the segment manager. Never throws

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

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

   Deallocates memory previously allocated. Never throws

4.     size_type max_size() const;

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

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

6.     std::pair< pointer, bool >
       allocation_command(boost::interprocess::allocation_type command,
                          size_type limit_size, size_type preferred_size,
                          size_type & received_size, const pointer & reuse = 0) ;

7.     multiallocation_chain
       allocate_many(size_type elem_size, std::size_t num_elements) ;

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

8.     multiallocation_chain
       allocate_many(const size_type * elem_sizes, size_type n_elements) ;

   Allocates n_elements elements, each one of size elem_sizes[i]in a contiguous block of memory. The elements must be deallocated

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

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

11.     multiallocation_chain allocate_individual(std::size_t num_elements) ;

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

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

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

14.     pointer address(reference value) const;

    Returns address of mutable object. Never throws

15.     const_pointer address(const_reference value) const;

    Returns address of non mutable object. Never throws

16.     void construct(const pointer & ptr, const_reference v) ;

    Copy construct an object Throws if T's copy constructor throws

17.     void construct(const pointer & ptr) ;

    Default construct an object. Throws if T's default constructor throws

18.     void destroy(const pointer & ptr) ;

    Destroys object. Throws if object's destructor throws

### `allocator` friend functions

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