Archivo de encabezado de la biblioteca estándar <memory_resource>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare>(C++20) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) Conceptos <concepts>(C++20) Diagnósticos <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Gestión de memoria <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramación <type_traits>(C++11) <ratio>(C++11)

Servicios generales <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Contenedores <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iteradores <iterator> Rangos <generator>(C++23) <ranges>(C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Procesamiento de texto <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numéricos <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <valarray> Tiempo <chrono>(C++11) <ctime> Compatibilidad con C <ccomplex>(C++11/17/20*) <ciso646>(hasta C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Entrada/Salida <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) Apoyo para concurrencia <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) Apoyo de ejecución <execution>(C++17)

 

Este archivo de encabezado es parte de la biblioteca de administración de memoria dinámica.

Clases
Definido en el espacio de nombres std::pmr
polymorphic_allocator (C++17)	Un asignador que admite polimorfismo en tiempo de ejecución basado en el recurso de memoria std::memory_resource con el que se construye. (plantilla de clase)
memory_resource (C++17)	Una interfaz abstracta para clases que encapsulan recursos de memoria. (clase)
pool_options (C++17)	Un conjunto de opciones de constructor para reservas de recursos. (clase)
synchronized_pool_resource (C++17)	Un recurso de memoria std::pmr::memory_resource seguro contra hilos para gestionar asignaciones en reservas con diferentes tamaños de bloques. (clase)
unsynchronized_pool_resource (C++17)	Un recurso de memoria std::pmr::memory_resource que no es seguro contra hilos para gestionar asignaciones en reservas con diferentes tamaños de bloques. (clase)
monotonic_buffer_resource (C++17)	Un recurso de memoria std::pmr::memory_resource de propósito especial, que libera la memoria asignada solamente cuando el recurso se destruye. (clase)
Funciones
Definido en el espacio de nombres std::pmr
new_delete_resource (C++17)	Devuelve un recurso de memoria std::pmr::memory_resource estático a lo largo del programa que utiliza los operadores globales operator new y operator delete para asignar y desasignar memoria. (función)
null_memory_resource (C++17)	Devuelve un recurso de memoria std::pmr::memory_resource estático que no realiza asignaciones. (función)
get_default_resource (C++17)	Obtiene el recurso de memoria std::pmr::memory_resource por defecto. (función)
set_default_resource (C++17)	Establece el recurso de memoria std::pmr::memory_resource por defecto. (función)

Sinopsis

namespace std::pmr{// clase memory_resourceclass memory_resource;   bool operator==(const memory_resource& a, const memory_resource& b)noexcept;   // plantilla de clase 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;   // recursos de memoria globales 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;   // clases de reservas de recursosstruct pool_options;class synchronized_pool_resource;class unsynchronized_pool_resource;class monotonic_buffer_resource;}

Clase std::pmr::memory_resource

namespace std::pmr{class memory_resource {staticconstexpr size_t max_align = alignof(max_align_t);// solo exposición   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;};}

Plantilla de clase std::pmr::polymorphic_allocator

namespace std::pmr{template<class Tp = byte>class polymorphic_allocator { memory_resource* memory_rsrc;// solo exposición   public:using value_type = Tp;   // constructores 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;   // funciones miembro[[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;};}

Clase std::pmr::pool_options

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

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

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

Clase std::pmr::monotonic_buffer_resource

namespace std::pmr{class monotonic_buffer_resource :public memory_resource { memory_resource* upstream_rsrc;// solo exposiciónvoid* current_buffer;// solo exposición size_t next_buffer_size;// solo exposición   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;};}