|  | Home | Libraries | People | FAQ | More | 
        The header <boost/core/default_allocator.hpp> provides the class template
        boost::default_allocator to serve as a minimal
        default allocator that:
      
std::allocator, does not provide members
            such as construct()
            and destroy()
            to be eligible for optimizations by allocator-aware code that detects
            the absence of these members to provide more optimal construction.
          BOOST_NO_EXCEPTIONS
            in allocation.
          std as
            an associated namespace.
          The following snippet shows the use of this allocator as the default allocator for a container.
template<class Key, class Compare = std::less<Key>, class Allocator = boost::default_allocator<Key> > class FlatSet;
        Facilities like make_shared
        can be implemented using allocate_shared
        with default_allocator.
      
template<class T, class... Args> enable_if_t<!is_array_v<T>, shared_ptr<T> > make_shared(Args&&... args) { return allocate_shared<T>(boost::default_allocator<remove_cv_t<T> >(), std::forward<Args>(args)...); }
namespace boost { template<class T> struct default_allocator { typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef std::add_lvalue_reference_t<T> reference; typedef std::add_lvalue_reference_t<const T> const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef true_type propagate_on_container_move_assignment; typedef true_type is_always_equal; template<class U> struct rebind { typedef default_allocator<U> other; }; constexpr default_allocator() = default; template<class U> constexpr default_allocator(const default_allocator<U>&) noexcept { } constexpr std::size_t max_size() const noexcept; T* allocate(std::size_t n); void deallocate(T* p, std::size_t); }; template<class T, class U> constexpr bool operator==(const default_allocator<T>&, const default_allocator<U>&) noexcept; template<class T, class U> constexpr bool operator!=(const default_allocator<T>&, const default_allocator<U>&) noexcept; } /* boost */
constexpr std::size_t
            max_size()
            const noexcept;
                      The largest value N
                      for which the call allocate(N) might succeed.
                    
T*
            allocate(std::size_t n);
                      A pointer to the initial element of an array of storage of
                      size n *
                      sizeof(T),
                      aligned appropriately for objects of type T.
                    
                      The storage is obtained by calling ::operator new.
                    
                      std::bad_alloc if the storage
                      cannot be obtained.
                    
void deallocate(T* p, std::size_t
            n);
                      p shall be
                      a pointer value obtained from allocate(). n
                      shall equal the value passed as the first argument to the invocation
                      of allocate
                      which returned p.
                    
                      Deallocates the storage referenced by p.
                    
                      Uses ::operator
                      delete.
                    
template<class T, class U> constexpr bool
            operator==(const default_allocator<T>&, const
            default_allocator<U>&)
            noexcept;
                      true.
                    
template<class T, class U> constexpr bool
            operator!=(const default_allocator<T>&, const
            default_allocator<U>&)
            noexcept;
                      false.