Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | header
 
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
 

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

Contenido

Clases

Definido en el espacio de nombres std::pmr
(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) [editar]
(C++17)
 Una interfaz abstracta para clases que encapsulan recursos de memoria.
(clase) [editar]
(C++17)
 Un conjunto de opciones de constructor para reservas de recursos.
(clase) [editar]
(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) [editar]
(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) [editar]
(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) [editar]

Funciones

Definido en el espacio de nombres std::pmr
(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) [editar]
(C++17)
 Devuelve un recurso de memoria std::pmr::memory_resource estático que no realiza asignaciones.
(función) [editar]
(C++17)
 Obtiene el recurso de memoria std::pmr::memory_resource por defecto.
(función) [editar]
(C++17)
 Establece el recurso de memoria std::pmr::memory_resource por defecto.
(función) [editar]

[editar] Sinopsis

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

[editar] Clase std::pmr::memory_resource

namespace std::pmr {
  class memory_resource {
    static constexpr 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) 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;
  };
}

[editar] 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;
  };
}

[editar] 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;
  };
}

[editar] 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) const noexcept override;
  };
}

[editar] 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) const noexcept override;
  };
}

[editar] Clase std::pmr::monotonic_buffer_resource

namespace std::pmr {
  class monotonic_buffer_resource : public memory_resource {
    memory_resource* upstream_rsrc;     // solo exposición
    void* 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) const noexcept override;
  };
}
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/memory_resource&oldid=43613»