Standard library header <scoped_allocator>

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Standard Library header files

Language Support
<cstddef> <limits> <climits> <cfloat> <cstdint> <new> <typeinfo> <exception> <ciso646>	<initializer_list> <csignal> <csetjmp> <cstdalign> <cstdarg> <cstdbool> <cstdlib> <ctime>
Diagnostics
<stdexcept> <cassert>	<cerrno> <system_error>
General utilities
<utility> <tuple> <bitset> <memory> <cstdlib> <cstring> <functional>	<type_traits> <ratio> <chrono> <ctime> <scoped_allocator> <typeindex>
Strings
<string> <cctype> <cwctype> <cstring>	<cwchar> <cstdlib> <cuchar>
Localization
<locale> <codecvt> <clocale>

Containers
<array> <deque> <forward_list> <list> <vector>	<map> <set> <unordered_map> <unordered_set> <queue> <stack>
Iterators
<iterator>
Algorithms
<algorithm>	<cstdlib>
Numerics
<cfenv> <complex> <random> <valarray>	<numeric> <cmath> <ctgmath> <cstdlib>
Input/Output
<iosfwd> <iostream> <ios> <streambuf> <istream> <ostream>	<iomanip> <sstream> <fstream> <cstdio> <cinttypes>
Regular expressions
<regex>
Thread support
<thread> <mutex> <atomic>	<shared_mutex> <condition_variable> <future>

 

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)
Functions
operator==operator!=	compares two scoped_allocator_adaptor instances (public member function of std::scoped_allocator_adaptor)

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

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