69 lines
4.8 KiB
Markdown
69 lines
4.8 KiB
Markdown
[allocator.adaptor.syn]
|
||
|
||
# 20 Memory management library [[mem]](./#mem)
|
||
|
||
## 20.6 Class template scoped_allocator_adaptor [[allocator.adaptor]](allocator.adaptor#syn)
|
||
|
||
### 20.6.1 Header <scoped_allocator> synopsis [allocator.adaptor.syn]
|
||
|
||
[ð](#header:%3cscoped_allocator%3e)
|
||
|
||
namespace std {// class template scoped_allocator_adaptortemplate<class OuterAlloc, class... InnerAlloc>class scoped_allocator_adaptor; // [[scoped.adaptor.operators]](scoped.adaptor.operators "20.6.5 Operators"), scoped allocator operatorstemplate<class OuterA1, class OuterA2, class... InnerAllocs>bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;}
|
||
|
||
[1](#1)
|
||
|
||
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/memory.tex#L8608)
|
||
|
||
The class template scoped_allocator_adaptor is an allocator template that
|
||
specifies an allocator resource (the outer allocator) to be used by a container (as any
|
||
other allocator does) and also specifies an inner allocator resource to be passed to the
|
||
constructor of every element within the container[.](#1.sentence-1)
|
||
|
||
This adaptor is instantiated with one
|
||
outer and zero or more inner allocator types[.](#1.sentence-2)
|
||
|
||
If instantiated with only one allocator
|
||
type, the inner allocator becomes the scoped_allocator_adaptor itself, thus
|
||
using the same allocator resource for the container and every element within the
|
||
container and, if the elements themselves are containers, each of their elements
|
||
recursively[.](#1.sentence-3)
|
||
|
||
If instantiated with more than one allocator, the first allocator is the
|
||
outer allocator for use by the container, the second allocator is passed to the
|
||
constructors of the container's elements, and, if the elements themselves are
|
||
containers, the third allocator is passed to the elements' elements, and so on[.](#1.sentence-4)
|
||
|
||
If
|
||
containers are nested to a depth greater than the number of allocators, the last
|
||
allocator is used repeatedly, as in the single-allocator case, for any remaining
|
||
recursions[.](#1.sentence-5)
|
||
|
||
[*Note [1](#note-1)*:
|
||
|
||
The scoped_allocator_adaptor is derived from the outer
|
||
allocator type so it can be substituted for the outer allocator type in most
|
||
expressions[.](#1.sentence-6)
|
||
|
||
â *end note*]
|
||
|
||
[ð](#lib:scoped_allocator_adaptor)
|
||
|
||
namespace std {template<class OuterAlloc, class... InnerAllocs>class scoped_allocator_adaptor : public OuterAlloc {private:using OuterTraits = allocator_traits<OuterAlloc>; // *exposition only* scoped_allocator_adaptor<InnerAllocs...> inner; // *exposition only*public:using outer_allocator_type = OuterAlloc; using inner_allocator_type = *see below*; using value_type = typename OuterTraits::value_type; using size_type = typename OuterTraits::size_type; using difference_type = typename OuterTraits::difference_type; using pointer = typename OuterTraits::pointer; using const_pointer = typename OuterTraits::const_pointer; using void_pointer = typename OuterTraits::void_pointer; using const_void_pointer = typename OuterTraits::const_void_pointer; using propagate_on_container_copy_assignment = *see below*; using propagate_on_container_move_assignment = *see below*; using propagate_on_container_swap = *see below*; using is_always_equal = *see below*; template<class Tp> struct rebind {using other = scoped_allocator_adaptor< OuterTraits::template rebind_alloc<Tp>, InnerAllocs...>; };
|
||
|
||
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& operator=(const scoped_allocator_adaptor&) = default;
|
||
scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default; ~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 T>void destroy(T* p);
|
||
|
||
scoped_allocator_adaptor select_on_container_copy_construction() const; }; template<class OuterAlloc, class... InnerAllocs> scoped_allocator_adaptor(OuterAlloc, InnerAllocs...)-> scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>;}
|