Class template node_allocator . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Indexes and Reference

Class template node_allocator

boost::interprocess::node_allocator

Synopsis

// In header: <boost/interprocess/allocators/node_allocator.hpp>
template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
class node_allocator {
public:
  // types
  typedef implementation_defined::segment_manager segment_manager;
  typedef segment_manager::void_pointer           void_pointer;   
  typedef implementation_defined::pointer         pointer;        
  typedef implementation_defined::const_pointer   const_pointer;  
  typedef T                                       value_type;     
  typedef unspecified                             reference;      
  typedef unspecified                             const_reference;
  typedef segment_manager::size_type              size_type;      
  typedef segment_manager::difference_type        difference_type;
  // member classes/structs/unions
  template<typename T2> 
  struct rebind {
    // types
    typedef node_allocator< T2, SegmentManager, NodesPerBlock > other;
  };
  // construct/copy/destruct
  node_allocator(segment_manager *);
  node_allocator(const node_allocator &);
  template<typename T2> 
    node_allocator(const node_allocator< T2, SegmentManager, NodesPerBlock > &);
  template<typename T2, typename SegmentManager2, std::size_t N2> 
    node_allocator & 
    operator=(const node_allocator< T2, SegmentManager2, N2 > &);
  ~node_allocator();
  // public member functions
  void * get_node_pool() const;
  segment_manager * get_segment_manager() const;
  size_type max_size() const;
  pointer allocate(size_type, cvoid_pointer = 0);
  void deallocate(const pointer &, size_type);
  void deallocate_free_blocks();
  pointer address(reference) const;
  const_pointer address(const_reference) const;
  void construct(const pointer &, const_reference);
  void destroy(const pointer &);
  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 &);
  // friend functions
  friend void swap(self_t &, self_t &);
};

Description

Аллокатор узла STL, который использует менеджер сегментов в качестве источника памяти. Внутренний тип указателя будет того же типа (сырой, умный), что и тип «типовое имя SegmentManager::void_pointer». Это позволяет разместить распределитель в общей памяти, карт памяти-файлы и т.д. Этот распределитель узлов разделяет сегрегированное хранилище между всеми экземплярамиnode_allocatorс равным размером (T), помещенным в одну и ту же группу сегментов. Узлы PerBlock - это количество узлов, выделенных одновременно, когда у распределителя заканчиваются узлы.

`node_allocator` public construct/copy/destruct

<
```
node_allocator(segment_manager*segment_mngr);
```
>
Не присваивается другим<node_allocator>Конструктором от менеджера сегмента. Если его нет, то строится узел. Увеличивает количество ссылок на соответствующий пул узлов. Может бросать<boost::interprocess::bad_alloc>
<
```
node_allocator(constnode_allocator&other);
```
>
Копировать конструктор из других<node_allocator>. Увеличивает количество ссылок на соответствующий пул узлов. Никогда не бросайте
<
```
template<typenameT2>
 node_allocator(constnode_allocator<T2,SegmentManager,NodesPerBlock>&other);
```
>
Копировать конструктор из родственных<node_allocator>. Если его нет, то строится узел. Увеличивает количество ссылок на соответствующий пул узлов. Способен к броску<boost::interprocess::bad_alloc>

template<typenameT2,typenameSegmentManager2,std::size_tN2>
 node_allocator&
 operator=(constnode_allocator<T2,SegmentManager2,N2>&);

Не присваивается из родственных<node_allocator>

<
```
~node_allocator();
```
>
Деструктор удаляет из памяти node_pool_t, если его опорное число достигает нуля. Никогда не бросайте

`node_allocator` public member functions

<
```
void*get_node_pool()const;
```
>
Возвращает указатель в узел бассейна. Никогда не бросайте
<
```
segment_manager*get_segment_manager()const;
```
>
Возвращает менеджера сегмента. Никогда не бросайте
<
```
size_typemax_size()const;
```
>
Возвращает число элементов, которые можно было бы выделить. Никогда не бросайте
<
```
pointerallocate(size_typecount,cvoid_pointerhint=0);
```
>
Выделить память для массива счетных элементов. Бросает<boost::interprocess::bad_alloc>, если не хватает памяти
<
```
voiddeallocate(constpointer&ptr,size_typecount);
```
>
Выделить выделенную память. Никогда не бросайте
<
```
voiddeallocate_free_blocks();
```
>
Выделяет все свободные блоки бассейна
<
```
pointeraddress(referencevalue)const;
```
>
Возвращает адрес изменяемого объекта. Никогда не бросайте
<
```
const_pointeraddress(const_referencevalue)const;
```
>
Возвращает адрес неизменяемого объекта. Никогда не бросайте
<
```
voidconstruct(constpointer&ptr,const_referencev);
```
>
Копии строят объект. Бросает, если копировальный конструктор Т бросает
<
```
voiddestroy(constpointer&ptr);
```
>
Уничтожает объект. Бросает, если разрушитель объекта бросает
<
```
size_typesize(constpointer&p)const;
```
>
Возвращает максимальное количество объектов, которые может удерживать ранее выделенная память, указанная p. Этот размер работает только для памяти, выделенной с выделением, выделением_командой и выделением_многими.

pointerallocation_command(boost::interprocess::allocation_typecommand,
                          size_typelimit_size,
                          size_type&prefer_in_recvd_out_size,
                          pointer&reuse);

<
```
voidallocate_many(size_typeelem_size,size_typenum_elements,
                  multiallocation_chain&chain);
```
>
Выделяет множество элементов размера elem_size в смежный блок памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Элементы должны быть размещены с помощью соглашения (...)
<
```
voidallocate_many(constsize_type*elem_sizes,size_typen_elements,
                  multiallocation_chain&chain);
```
>
Выделяет элементы n_элементов, каждый из которых размером elem_sizes[i] в смежный блок памяти. Элементы должны быть размещены
<
```
voiddeallocate_many(multiallocation_chain&chain);
```
>
Выделяет множество элементов размера elem_size в смежный блок памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Элементы должны быть размещены с помощью соглашения (...)
<
```
pointerallocate_one();
```
>
Выделяют только один объект. Память, выделенная с этой функцией, должна быть размещена только с помощью deallocate_one(). Бросает<boost::interprocess::bad_alloc>, если не хватает памяти
<
```
voidallocate_individual(size_typenum_elements,
                        multiallocation_chain&chain);
```
>
Выделяет множество элементов размера == 1 в смежном блоке памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Память, выделенная с этой функцией, должна быть размещена только с помощью deallocate_one().
<
```
voiddeallocate_one(constpointer&p);
```
>
Выделяет память, ранее выделенную с выделением_one(). Вы никогда не должны использовать deallocate_one для обработки памяти, выделенной с другими функциями, отличными от allocate_one(). Никогда не бросайте
<
```
voiddeallocate_individual(multiallocation_chain&chain);
```
>
Выделяет множество элементов размера == 1 в смежном блоке памяти. Минимальное число, которое должно быть выделено, - это min_элементы, предпочтительное и максимальное число - предпочтительные_элементы. Количество фактически выделенных элементов будет присвоено для receive_size. Память, выделенная с этой функцией, должна быть размещена только с помощью deallocate_one().

`node_allocator` friend functions

<
```
friendvoidswap(self_t&alloc1,self_t&alloc2);
```
>
Распределители свопов. Не бросает. Если каждый распределитель помещается в отдельный сегмент памяти, результат не определен.

Статья Class template node_allocator раздела The Boost C++ Libraries BoostBook Documentation Subset Indexes and Reference может быть полезна для разработчиков на c++ и boost.

Class template node_allocator

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Indexes and Reference

Boost C++ Libraries

Class template node_allocator

Synopsis

Description

node_allocator public construct/copy/destruct

node_allocator public member functions

node_allocator friend functions

`node_allocator` public construct/copy/destruct

`node_allocator` public member functions

`node_allocator` friend functions