Struct template allocator

Struct template allocator_traits

allocator_traits

Synopsis

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

template<typename Alloc> 
struct allocator_traits {
  // types
  typedef Alloc             allocator_type;                        
  typedef Alloc::value_type value_type;                            
  typedef unspecified       pointer;                               
  typedef unspecified       const_pointer;                         
  typedef unspecified       reference;                             
  typedef unspecified       const_reference;                       
  typedef unspecified       void_pointer;                          
  typedef unspecified       const_void_pointer;                    
  typedef unspecified       difference_type;                       
  typedef unspecified       size_type;                             
  typedef unspecified       propagate_on_container_copy_assignment;
  typedef unspecified       propagate_on_container_move_assignment;
  typedef unspecified       propagate_on_container_swap;           

  // member classes/structs/unions
  template<typename T> 
  struct portable_rebind_alloc {
    // types
    typedef unspecified_type type;
  };

  // public static functions
  static pointer allocate(Alloc &, size_type);
  static void deallocate(Alloc &, pointer, size_type);
  static pointer allocate(Alloc &, size_type, const_void_pointer);
  template<typename T> static void destroy(Alloc &, T *);
  static size_type max_size(const Alloc &);
  static Alloc select_on_container_copy_construction(const Alloc &);
  template<typename T, class... Args> 
    static void construct(Alloc &, T *, Args &&...);
};

Description

The class template allocator_traits supplies a uniform interface to all allocator types. This class is a C++03-compatible implementation of std::allocator_traits

`allocator_traits` public types

typedef unspecified pointer;

Alloc::pointer if such a type exists; otherwise, value_type*
typedef unspecified const_pointer;

Alloc::const_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<const
typedef unspecified reference;

Non-standard extension Alloc::reference if such a type exists; otherwise, value_type&
typedef unspecified const_reference;

Non-standard extension Alloc::const_reference if such a type exists ; otherwise, const value_type&
typedef unspecified void_pointer;

Alloc::void_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<void>.
typedef unspecified const_void_pointer;

Alloc::const_void_pointer if such a type exists ; otherwis e, pointer_traits<pointer>::rebind<const
typedef unspecified difference_type;

Alloc::difference_type if such a type exists ; otherwise, pointer_traits<pointer>::difference_type.
typedef unspecified size_type;

Alloc::size_type if such a type exists ; otherwise, make_unsigned<difference_type>::type
typedef unspecified propagate_on_container_copy_assignment;

Alloc::propagate_on_container_copy_assignment if such a type exists, otherwise an integral_constant type with internal constant static member `value` == false.
typedef unspecified propagate_on_container_move_assignment;

Alloc::propagate_on_container_move_assignment if such a type exists, otherwise an integral_constant type with internal constant static member `value` == false.
typedef unspecified propagate_on_container_swap;

Alloc::propagate_on_container_swap if such a type exists, otherwise an integral_constant type with internal constant static member `value` == false.

`allocator_traits` public static functions

static pointer allocate(Alloc & a, size_type n);

Returns: `a.allocate(n)`

static void deallocate(Alloc & a, pointer p, size_type n);

Returns: `a.deallocate(p, n)`

Throws: Nothing

```
static pointer allocate(Alloc & a, size_type n, const_void_pointer p);
```
Effects: calls `a.construct(p, std::forward<Args>(args)...)` if that call is well-formed; otherwise, invokes `::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)`
```
template<typename T> static void destroy(Alloc & a, T * p);
```
Effects: calls `a.destroy(p)` if that call is well-formed; otherwise, invokes `p->~T()`.
```
static size_type max_size(const Alloc & a);
```
Returns: `a.max_size()` if that expression is well-formed; otherwise, `numeric_limits<size_type>::max()`.
```
static Alloc select_on_container_copy_construction(const Alloc & a);
```
Returns: `a.select_on_container_copy_construction()` if that expression is well-formed; otherwise, a.
```
template<typename T, class... Args> 
  static void construct(Alloc & a, T * p, Args &&... args);
```
Effects: calls `a.construct(p, std::forward<Args>(args)...)` if that call is well-formed; otherwise, invokes `::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)`

Struct template allocator_traits

Synopsis

Description

allocator_traits public types

allocator_traits public static functions

`allocator_traits` public types

`allocator_traits` public static functions