C++ named requirements: Allocator

Encapsula estrategias para acceso/direccionamiento, asignación/liberación y construcción/destrucción de objetos.

Cada componente de la biblioteca estándar que pueda necesitar asignar o liberar almacenamiento, desde std::string , std::vector , y cada contenedor , excepto std::array (desde C++11) y std::inplace_vector (desde C++26) , hasta std::shared_ptr y std::function (hasta C++17) , lo hace a través de un Allocator : un objeto de tipo clase que satisface los siguientes requisitos.

La implementación de muchos requisitos de asignadores es opcional porque todos los AllocatorAwareContainer acceden a los asignadores indirectamente a través de std::allocator_traits , y std::allocator_traits proporciona la implementación predeterminada de esos requisitos.

Requisitos

Dado

• T , un tipo no constante y no referencia (hasta C++11) de objeto no constante (desde C++11) (hasta C++17) de objeto sin calificación cv (desde C++17) ,
• A , un tipo Allocator para el tipo T ,
• a , un objeto de tipo A ,
• B , el tipo Allocator correspondiente para algún tipo de objeto sin calificación cv U (obtenido mediante rebinding de A ),
• b , un objeto de tipo B ,
• p , un valor de tipo std:: allocator_traits < A > :: pointer , obtenido llamando a std:: allocator_traits < A > :: allocate ( ) ,
• cp , un valor de tipo std:: allocator_traits < A > :: const_pointer , obtenido mediante conversión de p ,
• vp , un valor de tipo std:: allocator_traits < A > :: void_pointer , obtenido mediante conversión de p ,
• cvp , un valor de tipo std:: allocator_traits < A > :: const_void_pointer , obtenido mediante conversión de cp o de vp ,
• xp , un puntero dereferenciable a algún tipo de objeto sin calificación cv X ,
• r , un valor-l de tipo T obtenido mediante la expresión * p ,
• n , un valor de tipo std:: allocator_traits < A > :: size_type .

Notas:

1. ↑ Véase también fancy pointers a continuación.
2. ↑ rebind es solo opcional (proporcionado por std::allocator_traits ) si este allocator es una plantilla de la forma SomeAllocator<T, Args> , donde Args es cero o más parámetros de tipo de plantilla adicionales.

Dado

• x1 y x2 , objetos de tipos (posiblemente diferentes) X::void_pointer , X::const_void_pointer , X::pointer , o X::const_pointer

Entonces, x1 y x2 son valores de puntero equivalentes , si y solo si tanto x1 como x2 pueden convertirse explícitamente a los dos objetos correspondientes px1 y px2 de tipo X::const_pointer , usando una secuencia de static_cast s usando solo estos cuatro tipos, y la expresión px1 == px2 se evalúa como true .

Dado

• w1 y w2 , objetos de tipo X::void_pointer

Entonces, para la expresión w1 == w2 y w1 ! = w2 cualquiera o ambos objetos pueden ser reemplazados por un objeto de valor equivalente de tipo X::const_void_pointer sin cambio en la semántica.

Dado

• p1 y p2 , objetos de tipo X::pointer

Entonces, para las expresiones p1 == p2 , p1 ! = p2 , p1 < p2 , p1 <= p2 , p1 >= p2 , p1 > p2 , p1 - p2 uno o ambos objetos pueden ser reemplazados por un objeto de valor equivalente de tipo X::const_pointer sin cambio en la semántica.

Los requisitos anteriores hacen posible comparar los Container iterator s y const_iterator s.

Asignadores con estado y sin estado

Cada tipo de Allocator es stateful o stateless . Generalmente, un tipo de allocator stateful puede tener valores desiguales que denotan recursos de memoria distintos, mientras que un tipo de allocator stateless denota un único recurso de memoria.

Las instancias de un tipo de asignador sin estado siempre son iguales al compararse. Los tipos de asignadores sin estado normalmente se implementan como clases vacías y son adecuados para la optimización de clase base vacía .

Punteros sofisticados

Cuando el tipo miembro pointer no es un tipo de puntero crudo, comúnmente se denomina "fancy pointer" . Estos punteros se introdujeron para admitir arquitecturas de memoria segmentada y se utilizan actualmente para acceder a objetos asignados en espacios de dirección que difieren del espacio de direcciones virtual homogéneo al que se accede mediante punteros crudos. Un ejemplo de fancy pointer es el puntero independiente de dirección de mapeo boost::interprocess::offset_ptr , que permite asignar estructuras de datos basadas en nodos como std::set en memoria compartida y archivos mapeados en memoria asignados en direcciones diferentes en cada proceso. Los fancy pointers pueden utilizarse independientemente del asignador que los proporcionó , mediante la plantilla de clase std::pointer_traits (desde C++11) . La función std::to_address puede utilizarse para obtener un puntero crudo desde un fancy pointer. (desde C++20)

Biblioteca estándar

Los siguientes componentes de la biblioteca estándar satisfacen los Allocator requisitos:

Ejemplos

#include <cstdlib>
#include <iostream>
#include <limits>
#include <new>
#include <vector>
template<class T>
struct Mallocator
{
    typedef T value_type;
    Mallocator() = default;
    template<class U>
    constexpr Mallocator(const Mallocator <U>&) noexcept {}
    [[nodiscard]] T* allocate(std::size_t n)
    {
        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T))
            throw std::bad_array_new_length();
        if (auto p = static_cast<T*>(std::malloc(n * sizeof(T))))
        {
            report(p, n);
            return p;
        }
        throw std::bad_alloc();
    }
    void deallocate(T* p, std::size_t n) noexcept
    {
        report(p, n, 0);
        std::free(p);
    }
private:
    void report(T* p, std::size_t n, bool alloc = true) const
    {
        std::cout << (alloc ? "Alloc: " : "Dealloc: ") << sizeof(T) * n
                  << " bytes at " << std::hex << std::showbase
                  << reinterpret_cast<void*>(p) << std::dec << '\n';
    }
};
template<class T, class U>
bool operator==(const Mallocator <T>&, const Mallocator <U>&) { return true; }
template<class T, class U>
bool operator!=(const Mallocator <T>&, const Mallocator <U>&) { return false; }
int main()
{
    std::vector<int, Mallocator<int>> v(8);
    v.push_back(42);
}

Alloc: 32 bytes at 0x2020c20
Alloc: 64 bytes at 0x2023c60
Dealloc: 32 bytes at 0x2020c20
Dealloc: 64 bytes at 0x2023c60

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

1. ↑ Los tipos miembro reference y const_reference de std::allocator se definen como T& y const T& respectivamente.
   • Si T es un tipo referencia, reference y const_reference son incorrectos porque no se puede formar una referencia a referencia ( colapso de referencias se introdujo en C++11).
   • Si T está calificado con const, reference y const_reference son iguales, y el conjunto de sobrecargas de address() es incorrecto.