Standard library header <memory_resource>

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Standard Library headers

Language Support
<cstddef> <limits> <climits> <contract>	<cfloat> <cstdint> <new> <version>	<typeinfo> <exception> <initializer_list>	<csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>     <compare>	<bitset> <tuple> <optional> <any> <variant>	<type_traits> <ratio> <chrono> <typeindex> <functional>	<ctime> <cstdlib>
Strings
<string> <string_view>	<cctype> <cwctype>	<cwchar> <cuchar>	<cstring> <charconv>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Ranges
<ranges>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<cfenv> <cmath>	<bit>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic>	<mutex> <shared_mutex>	<condition_variable> <future>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

Classes

Defined in namespace pmr
polymorphic_allocator (C++17)	an allocator that supports run-time polymorphism based on the std::memory_resource it is constructed with (class template)
memory_resource (C++17)	an abstract interface for classes that encapsulate memory resources (class)
pool_options (C++17)	a set of constructor options for pool resources (class)
synchronized_pool_resource (C++17)	a thread-safe std::pmr::memory_resource for managing allocations in pools of different block sizes (class)
unsynchronized_pool_resource (C++17)	a thread-unsafe std::pmr::memory_resource for managing allocations in pools of different block sizes (class)
monotonic_buffer_resource (C++17)	a special-purpose std::pmr::memory_resource that releases the allocated memory only when the resource is destroyed (class)

Functions

Defined in namespace pmr
new_delete_resource (C++17)	returns a static program-wide std::pmr::memory_resource that uses the global operator new and operator delete to allocate and deallocate memory (function)
null_memory_resource (C++17)	returns a static std::pmr::memory_resource that performs no allocation (function)
get_default_resource (C++17)	gets the default std::pmr::memory_resource (function)
set_default_resource (C++17)	sets the default std::pmr::memory_resource (function)

Synopsis

namespace std::pmr {
  // class memory_resource
  class memory_resource;
  bool operator==(const memory_resource& a, const memory_resource& b) noexcept;
  bool operator!=(const memory_resource& a, const memory_resource& b) noexcept;
  // class template polymorphic_allocator
  template <class Tp> class polymorphic_allocator;
  template <class T1, class T2>
  bool operator==(const polymorphic_allocator<T1>& a,
  const polymorphic_allocator<T2>& b) noexcept;
  template <class T1, class T2>
  bool operator!=(const polymorphic_allocator<T1>& a,
  const polymorphic_allocator<T2>& b) noexcept;
  // global memory resources
  memory_resource* new_delete_resource() noexcept;
  memory_resource* null_memory_resource() noexcept;
  memory_resource* set_default_resource(memory_resource* r) noexcept;
  memory_resource* get_default_resource() noexcept;
  // pool resource classes
  struct pool_options;
  class synchronized_pool_resource;
  class unsynchronized_pool_resource;
  class monotonic_buffer_resource;
}

Class std::pmr::memory_resource

class memory_resource {
  static constexpr size_t max_align = alignof(max_align_t); // exposition only
public:
  virtual ~memory_resource();
  void* allocate(size_t bytes, size_t alignment = max_align);
  void deallocate(void* p, size_t bytes, size_t alignment = max_align);
  bool is_equal(const memory_resource& other) const noexcept;
private:
  virtual void* do_allocate(size_t bytes, size_t alignment) = 0;
  virtual void do_deallocate(void* p, size_t bytes, size_t alignment) = 0;
  virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
};

Class template std::pmr::polymorphic_allocator

template <class Tp> 
class polymorphic_allocator {
  memory_resource* memory_rsrc; // exposition only
public:
  using value_type = Tp;
  // constructors
  polymorphic_allocator() noexcept;
  polymorphic_allocator(memory_resource* r);
  polymorphic_allocator(const polymorphic_allocator& other) = default;
  template <class U>
  polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;
  polymorphic_allocator&
  operator=(const polymorphic_allocator& rhs) = delete;
  // member functions
  Tp* allocate(size_t n);
  void deallocate(Tp* p, size_t n);
  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>& pr);
  template <class T1, class T2, class U, class V>
  void construct(pair<T1,T2>* p, pair<U, V>&& pr);
  template <class T>
  void destroy(T* p);
  polymorphic_allocator select_on_container_copy_construction() const;
  memory_resource* resource() const;
};

Class std::pmr::pool_options

struct pool_options {
  size_t max_blocks_per_chunk = 0;
  size_t largest_required_pool_block = 0;
};

Class std::pmr::synchronized_pool_resource

class synchronized_pool_resource : public memory_resource {
public:
  synchronized_pool_resource(const pool_options& opts,
  memory_resource* upstream);
  synchronized_pool_resource()
  : synchronized_pool_resource(pool_options(), get_default_resource()) {}
  explicit synchronized_pool_resource(memory_resource* upstream)
  : synchronized_pool_resource(pool_options(), upstream) {}
  explicit synchronized_pool_resource(const pool_options& opts)
  : synchronized_pool_resource(opts, get_default_resource()) {}
  synchronized_pool_resource(const synchronized_pool_resource&) = delete;
  virtual ~synchronized_pool_resource();
  synchronized_pool_resource&
  operator=(const synchronized_pool_resource&) = delete;
  void release();
  memory_resource* upstream_resource() const;
  pool_options options() const;
protected:
  void *do_allocate(size_t bytes, size_t alignment) override;
  void do_deallocate(void *p, size_t bytes, size_t alignment) override;
  bool do_is_equal(const memory_resource& other) const noexcept override;
};

Class std::pmr::unsynchronized_pool_resource

class unsynchronized_pool_resource : public memory_resource {
public:
  unsynchronized_pool_resource(const pool_options& opts,
  memory_resource* upstream);
  unsynchronized_pool_resource()
  : unsynchronized_pool_resource(pool_options(), get_default_resource()) {}
  explicit unsynchronized_pool_resource(memory_resource* upstream)
  : unsynchronized_pool_resource(pool_options(), upstream) {}
  explicit unsynchronized_pool_resource(const pool_options& opts)
  : unsynchronized_pool_resource(opts, get_default_resource()) {}
  unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
  virtual ~unsynchronized_pool_resource();
  unsynchronized_pool_resource&
  operator=(const unsynchronized_pool_resource&) = delete;
  void release();
  memory_resource *upstream_resource() const;
  pool_options options() const;
protected:
  void* do_allocate(size_t bytes, size_t alignment) override;
  void do_deallocate(void* p, size_t bytes, size_t alignment) override;
  bool do_is_equal(const memory_resource& other) const noexcept override;
};

Class std::pmr::monotonic_buffer_resource

class monotonic_buffer_resource : public memory_resource {
  memory_resource *upstream_rsrc; // exposition only
  void *current_buffer; // exposition only
  size_t next_buffer_size; // exposition only
public:
  explicit monotonic_buffer_resource(memory_resource *upstream);
  monotonic_buffer_resource(size_t initial_size, memory_resource *upstream);
  monotonic_buffer_resource(void *buffer, size_t buffer_size,
  memory_resource *upstream);
  monotonic_buffer_resource()
  : monotonic_buffer_resource(get_default_resource()) {}
  explicit monotonic_buffer_resource(size_t initial_size)
  : monotonic_buffer_resource(initial_size, get_default_resource()) {}
  monotonic_buffer_resource(void *buffer, size_t buffer_size)
  : monotonic_buffer_resource(buffer, buffer_size, get_default_resource()) {}
  monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;
  virtual ~monotonic_buffer_resource();
  monotonic_buffer_resource
  operator=(const monotonic_buffer_resource&) = delete;
  void release();
  memory_resource* upstream_resource() const;
protected:
  void* do_allocate(size_t bytes, size_t alignment) override;
  void do_deallocate(void* p, size_t bytes, size_t alignment) override;
  bool do_is_equal(const memory_resource& other) const noexcept override;
};