Class template node

Class template node_allocator

boost::container::node_allocator

Synopsis

// In header: <boost/container/node_allocator.hpp>

template<typename T,  NodesPerBlock = > 
class node_allocator {
public:
  // types
  typedef                                                                             ;           
  typedef                                              ;                    
  typedef                                                                                        ;                
  typedef                                                                                      ;                   
  typedef                                                                                ;             
  typedef ::::type                                          ;                 
  typedef ::::type                                     ;           
  typedef                                                                              ;                 
  typedef                                                                           ;           
  typedef                     ;                   
  typedef                             ;
  typedef  ;     

  // member classes/structs/unions
  template<typename T,  NodesPerBlock = > 
  struct rebind {
    // types
    typedef  ;
  };

  // construct/copy/destruct
  ();
  ();
  template<typename T2> 
    ();
  template<typename T2,  N2> 
     ();
  ~();

  // public member functions
   (();
   () ;
   (,  = );
   (, );
   (, , , 
                             );
   () ;
   ();
   (, );
   ();
   ();
   (, , );
   (, , );
   ();

  // private member functions
   (, , , 
                                  );

  // public static functions
   ();

  // friend functions
   (, );
   (, );
   (, );

  // public data members
  static  nodes_per_block;
};

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 types

typedef ;

If Version is 1, the allocator is a STL conforming allocator. If Version is 2, the allocator offers advanced expand in place and burst allocation capabilities.

`node_allocator` public construct/copy/destruct

```
();
```
Default constructor.
```
();
```
Copy constructor from other node_allocator.
```
template<typename T2> 
  ();
```
Copy constructor from related node_allocator.
```
template<typename T2,  N2> 
   ();
```
Not assignable from related node_allocator.
```
~();
```
Destructor.

`node_allocator` public member functions

```
 (();
```
```
 () ;
```
Returns the number of elements that could be allocated. Never throws
```
 ( count,  = );
```
Allocate memory for an array of count elements. Throws bad_alloc if there is no enough memory
```
 ( ptr,  count);
```
Deallocate allocated memory. Never throws

 ( command,  limit_size, 
                            prefer_in_recvd_out_size, 
                            reuse);

```
 ( p) ;
```
Returns maximum the number of objects the previously allocated memory pointed by p can hold.
```
 ();
```
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
```
 ( num_elements, 
                          chain);
```
Allocates many elements of size == 1. Elements must be individually deallocated with deallocate_one()
```
 ( 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
```
 ( chain);
```
```
 ( elem_size,  n_elements, 
                    chain);
```
Allocates many elements of size elem_size. Elements must be individually deallocated with deallocate()
```
 ( elem_sizes,  n_elements, 
                    chain);
```
Allocates n_elements elements, each one of size elem_sizes[i] Elements must be individually deallocated with deallocate()
```
 ( chain);
```

`node_allocator` private member functions

 ( command, 
                                 limit_size, 
                                 prefer_in_recvd_out_size, 
                                 reuse);

`node_allocator` public static functions

```
 ();
```
Deallocates all free blocks of the pool.

`node_allocator` friend functions

```
 (, );
```
Swaps allocators. Does not throw. If each allocator is placed in a different memory segment, the result is undefined.
```
 (, );
```
An allocator always compares to true, as memory allocated with one instance can be deallocated by another instance
```
 (, );
```
An allocator always compares to false, as memory allocated with one instance can be deallocated by another instance

Class template node_allocator

Synopsis

Description

node_allocator public types

node_allocator public construct/copy/destruct

node_allocator public member functions

node_allocator private member functions

node_allocator public static functions

node_allocator friend functions