std::experimental::pmr::resource_adaptor

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Experimental

Technical Specification

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals TS v2)

Library fundamentals 3 (library fundamentals TS v3)

Extensions for parallelism (parallelism TS)

Extensions for parallelism 2 (parallelism TS v2)

Extensions for concurrency (concurrency TS)

Extensions for concurrency 2 (concurrency TS v2)

Concepts (concepts TS)

Ranges (ranges TS)

Reflection (reflection TS)

Mathematical special functions (special functions TR)

Experimental Non-TS

Pattern Matching

Linear Algebra

std::execution

Contracts

2D Graphics

 

Library fundamentals

experimental::optional

experimental::any

experimental::basic_string_view

experimental::sample

experimental::shared_ptr

experimental::weak_ptr

experimental::apply

experimental::invocation_typeexperimental::raw_invocation_type

experimental::search

experimental::default_searcherexperimental::make_default_searcher

experimental::boyer_moore_searcherexperimental::make_boyer_moore_searcher

experimental::boyer_moore_horspool_searcherexperimental::make_boyer_moore_horspool_searcher

Type-erased and polymorphic allocators

Variable templates for type traits

 

Polymorphic allocator library

polymorphic_allocator

Convenience aliases for containers using polymorphic_allocator

Memory resource classes

memory_resource

synchronized_pool_resource

unsynchronized_pool_resource

monotonic_buffer_resource

resource_adaptor

Global memory resources

new_delete_resource

null_memory_resource

get_default_resource

set_default_resource

Type-erased allocator support for existing classes

function

packaged_task

promise

 

Defined in header <experimental/memory_resource>
template < class Alloc > class resource_adaptor_imp : public memory_resource; // for exposition only template < class Allocator > using resource_adaptor = resource_adaptor_imp<                              typename std::allocator_traits<Allocator>::                              template rebind_alloc<char>>;		(library fundamentals TS)

The alias template resource_adaptor adapts the allocator type Allocator with a memory_resource interface. The allocator is rebound to a char value type before it is actually adapted (using the resource_adaptor_imp class template), so that adapting specializations of the same allocator template always yields the same type, regardless of the value type the allocator template is originally instantiated with.

resource_adaptor_imp is a class template whose members are described below. The name resource_adaptor_imp is for exposition purposes only and not normative.

In addition to meeting the Template:concept requirements, Allocator must additionally satisfy the following requirements:

• Its pointer shall be identical to value_type*.
• Its const_pointer shall be identical to value_type const*.
• Its void_pointer shall be identical to void*.
• Its const_void_pointer shall be identical to void const*.

Member types of resource_adaptor_imp

Member type	Definition
allocator_type	Alloc

Member functions of resource_adaptor_imp

std::experimental::pmr::resource_adaptor_imp::resource_adaptor_imp

resource_adaptor_imp() = default;	(1)	(library fundamentals TS)
resource_adaptor_imp(const resource_adaptor_imp& other) = default;	(2)	(library fundamentals TS)
resource_adaptor_imp(resource_adaptor_imp&& other) = default;	(3)	(library fundamentals TS)
explicit resource_adaptor_imp(const Alloc& a2);	(4)	(library fundamentals TS)
explicit resource_adaptor_imp(Alloc&& a2);	(5)	(library fundamentals TS)

1) Default constructor. Default constructs the wrapped allocator.

2) Copy constructor. Copy constructs the wrapped allocator from the allocator wrapped by other.

3) Move constructor. Move constructs the wrapped allocator from the allocator wrapped by other.

4) Initializes the wrapped allocator with a2.

5) Initializes the wrapped allocator with std::move(a2).

Parameters

other	-	another resource_adaptor_imp object to copy or move from
a2	-	another Allocator object to copy or move from

std::experimental::pmr::resource_adaptor_imp::get_allocator

allocator_type get_allocator() const;		(library fundamentals TS)

Returns a copy of the wrapped allocator.

std::experimental::pmr::resource_adaptor_imp::operator=

resource_adaptor_imp& operator=(const resource_adaptor_imp& other) = default;		(library fundamentals TS)

Defaulted copy assignment operator. Copy assigns the wrapped allocator from that of other.

std::experimental::pmr::resource_adaptor_imp::do_allocate

virtual void* do_allocate(std::size_t bytes, std::size_t alignment);		(library fundamentals TS)

Allocates memory using the allocate member function of the wrapped allocator.

std::experimental::pmr::resource_adaptor_imp::do_deallocate

virtual void do_deallocate(void *p, std::size_t bytes, std::size_t alignment);		(library fundamentals TS)

Deallocates the storage pointed to by p using the deallocate member function of the wrapped allocator. p must have been allocated using the allocate member function of an allocator that compares equal to the wrapped allocator, and must not have been subsequently deallocated.

std::experimental::pmr::resource_adaptor_imp::do_is_equal

virtual bool do_is_equal(const memory_resource& other);		(library fundamentals TS)

Let p be dynamic_cast<const resource_adaptor_imp*>(&other). If p is nullptr, returns false. Otherwise, return the result of comparing the allocators wrapped by *p and *this using operator==.