Заголовочный файл стандартной библиотеки <memory_resource> (C++17)

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов(C++20)

Библиотека метапрограммирования(C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов(C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения(C++11)

Атомарные операции(C++11)

Библиотека поддержки конкуренции(C++11)

Библиотека файловой системы(C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Заголовочные файлы стандартной библиотеки

Языковая поддержка
<cstddef> <cstdlib> <version>(C++20) <limits> <climits>	<cfloat> <cstdint>(C++11) <stdfloat>(C++23) <new> <typeinfo>	<source_location>(C++20) <exception> <initializer_list>(C++11) <compare>(C++20)	<coroutine>(C++20) <csignal> <csetjmp> <cstdarg>
Концепты
<concepts>(C++20)
Диагностика
<stdexcept> <stacktrace>(C++23)	<cassert>	<cerrno>	<system_error>(C++11)
Управление памятью
<memory>	<memory_resource>(C++17)	<scoped_allocator>(C++11)
Метапрограммирование
<type_traits>(C++11)	<ratio>(C++11)
Общие утилиты
<utility> <tuple>(C++11) <optional>(C++17) <variant>(C++17)	<any>(C++17) <expected>(C++23) <bitset>	<functional> <typeindex>(C++11) <execution>(C++17)	<charconv>(C++17) <format>(C++20) <bit>(C++20)
Строки
<string_view>(C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar>(C++11)
Контейнеры
<array>(C++11) <deque> <forward_list>(C++11) <list>	<vector> <map> <set> <unordered_map>(C++11)	<unordered_set>(C++11) <queue> <stack> <flat_map>(C++23)	<flat_set>(C++23) <span>(C++20) <mdspan>(C++23)
Итераторы
<iterator>
Диапазоны
<ranges>(C++20)	<generator>(C++23)
Алгоритмы
<algorithm>	<numeric>
Числа
<cfenv>(C++11) <complex>	<random>(C++11) <valarray>	<cmath>	<numbers>(C++20)
Время
<chrono>(C++11)	<ctime>
Локализация
<locale>	<clocale>	<codecvt>(C++11/17*)
Ввод/вывод
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print>(C++23)	<sstream> <spanstream>(C++23) <fstream> <syncstream>(C++20)	<filesystem>(C++17) <cstdio> <cinttypes>(C++11) <strstream>(C++98*)
Регулярные выражения
<regex>(C++11)
Поддержка конкуренции
<stop_token>(C++20) <thread>(C++11) <atomic>(C++11)	<stdatomic.h>(C++23) <mutex>(C++11) <shared_mutex>(C++14)	<condition_variable>(C++11)   <semaphore>(C++20) <latch>(C++20)	<barrier>(C++20) <future>(C++11)
Совместимость с C
<cstdbool>(C++11/17/20*)   <ccomplex>(C++11/17/20*)	<ctgmath>(C++11/17/20*)	<cstdalign>(C++11/17/20*)	<ciso646>(до C++20)

 

Классы
Определены в пространстве имён std::pmr
polymorphic_allocator (C++17)	аллокатор, который поддерживает полиморфизм времени выполнения на основе std::pmr::memory_resource, с использованием которого он построен (шаблон класса)
memory_resource (C++17)	абстрактный интерфейс для классов, которые инкапсулируют ресурсы памяти (класс)
pool_options (C++17)	набор параметров конструктора для пула ресурсов (класс)
synchronized_pool_resource (C++17)	потокобезопасный std::pmr::memory_resource для управления выделениями в пулах блоков с разными размерами (класс)
unsynchronized_pool_resource (C++17)	небезопасный для потока std::pmr::memory_resource для управления выделениями памяти в пулах с разными размерами блоков (класс)
monotonic_buffer_resource (C++17)	специальный std::pmr::memory_resource, который освобождает выделенную память только при уничтожении ресурса (класс)
Функции
Определены в пространстве имён std::pmr
new_delete_resource (C++17)	возвращает статический общепрограммный std::pmr::memory_resource, который использует глобальные operator new и operator delete для выделения и освобождения памяти (функция)
null_memory_resource (C++17)	возвращает статический std::pmr::memory_resource, который не выполняет выделение памяти (функция)
get_default_resource (C++17)	получает значение по умолчанию std::pmr::memory_resource (функция)
set_default_resource (C++17)	устанавливает std::pmr::memory_resource по умолчанию (функция)

Краткое описание

namespace std::pmr{// класс memory_resourceclass memory_resource;   bool operator==(const memory_resource& a, const memory_resource& b)noexcept;   // шаблонный класс polymorphic_allocatortemplate<class Tp>class polymorphic_allocator;   template<class T1, class T2>bool operator==(const polymorphic_allocator<T1>& a, const polymorphic_allocator<T2>& b)noexcept;   // глобальные ресурсы памяти 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;   // пул ресурсов классовstruct pool_options;class synchronized_pool_resource;class unsynchronized_pool_resource;class monotonic_buffer_resource;}

Класс std::pmr::memory_resource

namespace std::pmr{class memory_resource {staticconstexpr size_t max_align = alignof(max_align_t);// только для описания   public: memory_resource()=default; memory_resource(const memory_resource&)=default;virtual ~memory_resource();   memory_resource& operator=(const memory_resource&)=default;   [[nodiscard]]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)constnoexcept;   private:virtualvoid* do_allocate(size_t bytes, size_t alignment)=0;virtualvoid do_deallocate(void* p, size_t bytes, size_t alignment)=0;   virtualbool do_is_equal(const memory_resource& other)constnoexcept=0;};}

Шаблон класса std::pmr::polymorphic_allocator

namespace std::pmr{template<class Tp = byte>class polymorphic_allocator { memory_resource* memory_rsrc;// только для описания   public:using value_type = Tp;   // конструкторы 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&)= delete;   // функции-элементы[[nodiscard]] Tp* allocate(size_t n);void deallocate(Tp* p, size_t n);   [[nodiscard]]void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));void deallocate_bytes(void* p, size_t nbytes, size_t alignment = alignof(max_align_t));template<class T>[[nodiscard]] T* allocate_object(size_t n =1);template<class T>void deallocate_object(T* p, size_t n =1);template<class T, class... CtorArgs>[[nodiscard]] T* new_object(CtorArgs&&... ctor_args);template<class T>void delete_object(T* p);   template<class T, class... Args>void construct(T* p, Args&&... args);   template<class T>void destroy(T* p);// устарело   polymorphic_allocator select_on_container_copy_construction()const;   memory_resource* resource()const;};}

Класс std::pmr::pool_options

namespace std::pmr{struct pool_options { size_t max_blocks_per_chunk =0; size_t largest_required_pool_block =0;};}

Класс std::pmr::synchronized_pool_resource

namespace std::pmr{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)constnoexcept override;};}

Класс std::pmr::unsynchronized_pool_resource

namespace std::pmr{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)constnoexcept override;};}

Класс std::pmr::monotonic_buffer_resource

namespace std::pmr{class monotonic_buffer_resource :public memory_resource { memory_resource* upstream_rsrc;// только для поясненияvoid* current_buffer;// только для пояснения size_t next_buffer_size;// только для пояснения   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)constnoexcept override;};}