##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <scoped_allocator>

From cppreference.com
< cpp‎ | header

This header is part of the dynamic memory management library.

### Classes
scoped_allocator_adaptor (C++11) | implements multi-level allocator for multi-level containers (class template) [edit]
### Functions
operator==operator!= | 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;
    }

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/scoped_allocator&oldid=63999"