default_allocator

Overview

The header <boost/core/default_allocator.hpp> provides the class template boost::default_allocator to serve as a minimal default allocator that:

Like C++2a's 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.
Supports BOOST_NO_EXCEPTIONS in allocation.
Does not have std as an associated namespace.

Examples

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)...);
}

Reference

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 */

Members

constexpr std::size_t max_size() const noexcept;

Returns: The largest value N for which the call allocate(N) might succeed.

T* allocate(std::size_t n);

Returns: A pointer to the initial element of an array of storage of size n * sizeof(T), aligned appropriately for objects of type T.
Remarks: The storage is obtained by calling ::operator new.
Throws: std::bad_alloc if the storage cannot be obtained.

void deallocate(T* p, std::size_t n);

Requires: 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.
Effects: Deallocates the storage referenced by p.
Remarks: Uses ::operator delete.

Operators

template<class T, class U> constexpr bool operator==(const default_allocator<T>&, const default_allocator<U>&) noexcept;

Returns: true.

template<class T, class U> constexpr bool operator!=(const default_allocator<T>&, const default_allocator<U>&) noexcept;

Returns: false.

Boost C++ Libraries