Именованные требования C++: Allocator

Инкапсулирует стратегии доступа/адресации, выделения/освобождения памяти и конструирования/уничтожения объектов.

Каждый компонент стандартной библиотеки, которому может потребоваться выделить или освободить память, от std::string, std::vector и каждого контейнера, кроме std::array(начиная с C++11) и std::inplace_vector(начиная с C++26), до std::shared_ptr и std::function(до C++17), делает это через Allocator: объект типа класса, удовлетворяющего следующим требованиям.

Реализация многих требований к аллокатору необязательна, поскольку все AllocatorAwareContainer обращаются к аллокаторам косвенно через std::allocator_traits, а std::allocator_traits предоставляет реализацию этих требований по умолчанию.

Требования

Пусть заданы

• T, неконстантный тип, не являющийся ссылочным(до C++11)неконстантный объектный тип(начиная с C++11)(до C++17)объектный тип без cv-квалификаторов(начиная с C++17),
• A, тип Allocator для типа T,
• a, объект типа A,
• B, соответствующий тип Allocator для некоторого объектного типа U без cv-квалификаторов (полученный посредством переназначения A),
• b, объект типа B,
• p, значение типа std::allocator_traits<A>::pointer, полученное вызовом std::allocator_traits<A>::allocate(),
• cp, значение типа std::allocator_traits<A>::const_pointer, полученное преобразованием из p,
• vp, значение типа std::allocator_traits<A>::void_pointer, полученное преобразованием из p,
• cvp, значение типа std::allocator_traits<A>::const_void_pointer, полученное преобразованием из cp или из vp,
• xp, разыменовываемый указатель на некоторый объектный тип X без cv-квалификаторов,
• r, lvalue типа T, полученный выражением *p,
• n, значение типа std::allocator_traits<A>::size_type.

Примечания:

Пусть заданы

• x1 и x2, объекты (возможно, разных) типов X::void_pointer, X::const_void_pointer, X::pointer или X::const_pointer

Пусть заданы

• w1 и w2, объекты типа X::void_pointer

Пусть заданы

• p1 и p2, объекты типа X::pointer

Приведенные выше требования позволяют сравнивать iterator и const_iterator контейнера Container.

Состояние-содержащие и не содержащие состояние аллокаторы

Каждый тип Allocator либо содержит состояние, либо не содержит состояния. Как правило, тип аллокатора, содержащий состояние, может иметь неравные значения, обозначающие различные ресурсы памяти, тогда как тип аллокатора без состояния обозначает единственный ресурс памяти.

Экземпляры типа аллокатора без состояния всегда сравниваются как равные. Типы аллокаторов без состояния обычно реализуются как пустые классы и подходят для оптимизации пустого базового класса.

Указатели с дополнительной функциональностью

Если тип-член pointer не является обычным указателем, его обычно называют «указателем с дополнительной функциональностью». Такие указатели появились для поддержки сегментированных архитектур памяти и сегодня используются для доступа к объектам, размещенным в адресных пространствах, отличных от однородного виртуального адресного пространства, доступного обычным указателям. Пример такого указателя — отображаемый адресонезависимый указатель boost::interprocess::offset_ptr, позволяющий размещать структуры данных на основе узлов, такие как std::set, в общей памяти и файлах, отображаемых в память по разным адресам в каждом процессе. Указатели с дополнительной функциональностью можно использовать независимо от предоставившего их аллокаторас помощью шаблона класса std::pointer_traits(начиная с C++11). Функцию std::to_address можно использовать для получения обычного указателя из указателя с дополнительной функциональностью.(начиная с C++20)

template<class Alloc>
concept /*simple-allocator*/ = requires(Alloc alloc, std::size_t n)
{
    { *alloc.allocate(n) } -> std::same_as<typename Alloc::value_type&>;
    { alloc.deallocate(alloc.allocate(n), n) };  
} && std::copy_constructible<Alloc>
  && std::equality_comparable<Alloc>;

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

Следующие компоненты стандартной библиотеки удовлетворяют требованиям Allocator:

Примеры

#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

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.