Namespaces
Variants
Views
Actions

Standard library header <scoped_allocator>

From cppreference.com
< cpp‎ | header
Revision as of 19:38, 5 August 2013 by Cubbi (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

This header is part of the dynamic memory management library.

Contents

Classes

implements multi-level allocator for multi-level containers
(class template) [edit]

Functions

compares two scoped_allocator_adaptor instances
(public member function of std::scoped_allocator_adaptor) [edit]

[edit] Synopsis

namespace std {
 
    template <class OuterAlloc, class... InnerAlloc>
    class scoped_allocator_adaptor;
 
    template <class OuterA1, class OuterA2, class... InnerAllocs>
    bool operator==(const scoped_allocator_adaptor<OuterA1,
                                                   InnerAllocs...>& a,
                    const scoped_allocator_adaptor<OuterA2,
                                                   InnerAllocs...>& b) noexcept;
    template <class OuterA1, class OuterA2, class... InnerAllocs>
    bool operator!=(const scoped_allocator_adaptor<OuterA1,
                                                   InnerAllocs...>& a,
                    const scoped_allocator_adaptor<OuterA2,
                                                   InnerAllocs...>& b) noexcept;
}

[edit] Class std::scoped_allocator_adaptor

template <class OuterAlloc, class... InnerAllocs>
class scoped_allocator_adaptor : public OuterAlloc {
 private:
    typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only
    scoped_allocator_adaptor<InnerAllocs...> inner; // exposition only
 
 public:
    typedef OuterAlloc outer_allocator_type;
    typedef /*see description*/ inner_allocator_type;
    typedef typename OuterTraits::value_type value_type;
    typedef typename OuterTraits::size_type size_type;
    typedef typename OuterTraits::difference_type difference_type;
    typedef typename OuterTraits::pointer pointer;
    typedef typename OuterTraits::const_pointer const_pointer;
    typedef typename OuterTraits::void_pointer void_pointer;
    typedef typename OuterTraits::const_void_pointer const_void_pointer;
    typedef /*see description*/ propagate_on_container_copy_assignment;
    typedef /*see description*/ propagate_on_container_move_assignment;
    typedef /*see description*/ propagate_on_container_swap;
    template <class Tp>
    struct rebind {
        typedef scoped_allocator_adaptor<
                          OuterTraits::template rebind_alloc<Tp>,
                          InnerAllocs...
                > other;
    };
 
    scoped_allocator_adaptor();
    template <class OuterA2>
    scoped_allocator_adaptor(OuterA2&& outerAlloc,
                             const InnerAllocs&... innerAllocs) noexcept;
    scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept;
    scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept;
    template <class OuterA2>
    scoped_allocator_adaptor(const scoped_allocator_adaptor<
                                          OuterA2,
                                          InnerAllocs...
                                   >& other) noexcept;
    template <class OuterA2>
    scoped_allocator_adaptor(scoped_allocator_adaptor<
                                    OuterA2,
                                    InnerAllocs...
                             >&& other) noexcept;
 
    ~scoped_allocator_adaptor();
 
    inner_allocator_type& inner_allocator() noexcept;
    const inner_allocator_type& inner_allocator() const noexcept;
    outer_allocator_type& outer_allocator() noexcept;
    const outer_allocator_type& outer_allocator() const noexcept;
    pointer allocate(size_type n);
    pointer allocate(size_type n, const_void_pointer hint);
    void deallocate(pointer p, size_type n);
    size_type max_size() const;
 
    template <class T, class... Args>
    void construct(T* p, Args&&... args);
    template <class T1, class T2, class... Args1, class... Args2>
    void construct(pair<T1, T2>* p,
                   piecewise_construct_t,
                   tuple<Args1...> x,
                   tuple<Args2...> y);
    template <class T1, class T2>
    void construct(pair<T1, T2>* p);
    template <class T1, class T2, class U, class V>
    void construct(pair<T1, T2>* p, U&& x, V&& y);
    template <class T1, class T2, class U, class V>
    void construct(pair<T1, T2>* p, const pair<U, V>& x);
    template <class T1, class T2, class U, class V>
    void construct(pair<T1, T2>* p, pair<U, V>&& x);
    template <class T>
    void destroy(T* p);
 
    scoped_allocator_adaptor select_on_container_copy_construction() const;
}