std::allocator

Определён в заголовке `<memory>`
template< class T > struct allocator;	(1)
template<> struct allocator<void>;	(2)	(устарело в C++17) (удалено в C++20)

Шаблон класса std::allocator — это аллокатор по умолчанию, используемый всеми контейнерами стандартной библиотеки, если пользователь не указал другой аллокатор. Аллокатор по умолчанию не имеет состояния: все экземпляры данного аллокатора взаимозаменяемы, считаются равными и могут освобождать память, выделенную любым другим экземпляром того же типа аллокатора.

Явная специализация для void не содержит определений типов-членов reference, const_reference, size_type и difference_type. Эта специализация не объявляет функций-членов.

(до C++20)

Аллокатор по умолчанию удовлетворяет требованиям полноты аллокатора.

(начиная с C++17)

Типы-члены

Тип	Определение
`value_type`	`T`
`pointer` (устарело в C++17)(удалено в C++20)	`T*`
`const_pointer` (устарело в C++17)(удалено в C++20)	constT*
`reference` (устарело в C++17)(удалено в C++20)	`T&`
`const_reference` (устарело в C++17)(удалено в C++20)	constT&
`size_type`	`std::size_t`
`difference_type`	`std::ptrdiff_t`
`propagate_on_container_move_assignment` (C++11)	`std::true_type`
`rebind` (устарело в C++17)(удалено в C++20)	`template< class U > struct rebind { typedef allocator<U> other; };`
`is_always_equal` (C++11)(устарело в C++23)(удалено в C++26)	`std::true_type`

Функции-члены

(конструктор)	создаёт новый экземпляр аллокатора (открытая функция-член)
(деструктор)	уничтожает экземпляр аллокатора (открытая функция-член)
address (до C++20)	получает адрес объекта, даже если operator& перегружен (открытая функция-член)
allocate	выделяет неинициализированное хранилище (открытая функция-член)
allocate_at_least (C++23)	выделяет неинициализированное хранилище размером не менее запрошенного (открытая функция-член)
deallocate	освобождает хранилище (открытая функция-член)
max_size (до C++20)	возвращает наибольший поддерживаемый размер выделения памяти (открытая функция-член)
construct (до C++20)	создаёт объект в выделенном хранилище (открытая функция-член)
destroy (до C++20)	уничтожает объект в выделенном хранилище (открытая функция-член)

Функции, не являющиеся членами

operator==operator!=

(удалено в C++20)

сравнивает два экземпляра аллокатора
(открытая функция-член)

Примечания

Шаблон класса-члена rebind позволяет получить аллокатор для другого типа. Например, std::list<T,A> выделяет память для узлов некоторого внутреннего типа Node<T> с помощью аллокатора A::rebind<Node<T>>::other(до C++11)std::allocator_traits<A>::rebind_alloc<Node<T>>, который реализован на основе A::rebind<Node<T>>::other, если A является std::allocator(начиная с C++11).

Тип-член is_always_equal объявлен устаревшим согласно предложению LWG 3170, поскольку из-за него пользовательские аллокаторы, производные от std::allocator, по умолчанию считаются всегда равными. std::allocator_traits<std::allocator<T>>::is_always_equal не объявлен устаревшим, а его константа-член value равна true для любого T.

Пример

#include <iostream>
#include <memory>
#include <string>

int main()
{
    // default allocator for ints
    std::allocator<int> alloc1;
    
    // demonstrating the few directly usable members
    static_assert(std::is_same_v<int, decltype(alloc1)::value_type>);
    int* p1 = alloc1.allocate(1); // space for one int
    alloc1.deallocate(p1, 1);     // and it is gone
    
    // Even those can be used through traits though, so no need
    using traits_t1 = std::allocator_traits<decltype(alloc1)>; // The matching trait
    p1 = traits_t1::allocate(alloc1, 1);
    traits_t1::construct(alloc1, p1, 7);  // construct the int
    std::cout << *p1 << '\n';
    traits_t1::deallocate(alloc1, p1, 1); // deallocate space for one int
    
    // default allocator for strings
    std::allocator<std::string> alloc2;
    // matching traits
    using traits_t2 = std::allocator_traits<decltype(alloc2)>;
    
    // Rebinding the allocator using the trait for strings gets the same type
    traits_t2::rebind_alloc<std::string> alloc_ = alloc2;
    
    std::string* p2 = traits_t2::allocate(alloc2, 2); // space for 2 strings
    
    traits_t2::construct(alloc2, p2, "foo");
    traits_t2::construct(alloc2, p2 + 1, "bar");
    
    std::cout << p2[0] << ' ' << p2[1] << '\n';
    
    traits_t2::destroy(alloc2, p2 + 1);
    traits_t2::destroy(alloc2, p2);
    traits_t2::deallocate(alloc2, p2, 2);
}

Вывод:

7
foo bar

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

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

Отчёт об ошибке	Применён к	Опубликованное поведение	Исправленное поведение
LWG 2103	C++11	могло потребоваться избыточное сравнение между `allocator`	предоставлен `propagate_on_container_move_assignment`
LWG 2108	C++11	не было способа показать, что `allocator` не имеет состояния	предоставлен `is_always_equal`

См. также

allocator_traits (C++11)	предоставляет сведения о типах аллокаторов (шаблон класса)
scoped_allocator_adaptor (C++11)	реализует многоуровневый аллокатор для многоуровневых контейнеров (шаблон класса)
uses_allocator (C++11)	проверяет, поддерживает ли указанный тип конструирование с использованием аллокатора (шаблон класса)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/memory/allocator