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

Click here to view the latest version of this page.
PrevUpHomeNext

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

  1. typedef unspecified pointer;

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

  2. typedef unspecified const_pointer;

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

  3. typedef unspecified reference;

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

  4. typedef unspecified const_reference;

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

  5. typedef unspecified void_pointer;

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

  6. typedef unspecified const_void_pointer;

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

  7. typedef unspecified difference_type;

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

  8. typedef unspecified size_type;

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

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

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

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

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

    Returns: `a.allocate(n)`

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

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

    Throws: Nothing

  3. 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)...)`

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

  5. static size_type max_size(const Alloc & a);

    Returns: `a.max_size()` if that expression is well-formed; otherwise, `numeric_limits<size_type>::max()`.

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

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


PrevUpHomeNext