std::allocator
| Definiert in Header <memory> |
||
| template< class T > struct allocator; |
(1) | |
| template<> struct allocator<void>; |
(2) | (veraltet in C++17) (in C++20 entfernt) |
Die Klasse std::allocator ist die Standard-Allocator-Vorlage, die von allen Standardbibliothekscontainern verwendet wird, wenn kein benutzerspezifischer Allocator bereitgestellt wird. Der Standard-Allocator ist zustandslos, d. h. alle Instanzen des gegebenen Allocators sind austauschbar, vergleichen sich gleich und können Speicher freigeben, der von jeder anderen Instanz desselben Allocator-Typs zugewiesen wurde.
|
Die explizite Spezialisierung für void verzichtet auf die Member-Typedefs |
(bis C++20) |
|
Der Standard-Allocator erfüllt die Anforderungen an die Vollständigkeit von Allocators. |
(seit C++17) |
Inhalt |
[bearbeiten] Member types
| Typ | Definition |
value_type
|
T
|
pointer (in C++17 veraltet)(in C++20 entfernt) |
T*
|
const_pointer (in C++17 veraltet)(in C++20 entfernt) |
const T* |
reference (in C++17 veraltet)(in C++20 entfernt) |
T&
|
const_reference (in C++17 veraltet)(in C++20 entfernt) |
const T& |
size_type
|
std::size_t |
difference_type
|
std::ptrdiff_t |
propagate_on_container_move_assignment (C++11) |
std::true_type |
rebind (in C++17 veraltet)(in C++20 entfernt) |
template< class U > struct rebind |
is_always_equal (C++11)(in C++23 veraltet)(in C++26 entfernt) |
std::true_type |
[bearbeiten] Member functions
| erstellt eine neue Allocator-Instanz (public member function) | |
| zerstört eine Allocator-Instanz (public member function) | |
| (bis C++20) |
holt die Adresse eines Objekts, auch wenn operator& überladen ist (public member function) |
| alloziiert uninitialisierten Speicher (public member function) | |
| (C++23) |
weist uninitialisierten Speicher zu, der mindestens so groß ist wie die angeforderte Größe (public member function) |
| gibt Speicher frei (public member function) | |
| (bis C++20) |
gibt die maximal unterstützte Allokationsgröße zurück (public member function) |
| (bis C++20) |
konstruiert ein Objekt im allokierten Speicher (public member function) |
| (bis C++20) |
destruiert ein Objekt im allokierten Speicher (public member function) |
[bearbeiten] Non-member functions
| (in C++20 entfernt) |
vergleicht zwei Allocator-Instanzen (public member function) |
[bearbeiten] Notes
Die Member-Template-Klasse rebind bietet eine Möglichkeit, einen Allocator für einen anderen Typ zu erhalten. Zum Beispiel weisen std::list<T, A> Knoten eines internen Typs Node<T> zu, wobei der Allocator A::rebind<Node<T>>::other(bis C++11)std::allocator_traits<A>::rebind_alloc<Node<T>>, der auf Basis von A::rebind<Node<T>>::other implementiert ist, falls A ein std::allocator ist(seit C++11) verwendet wird.
Der Member-Typ is_always_equal ist über LWG issue 3170 veraltet, da er benutzerdefinierte von std::allocator abgeleitete Allocators standardmäßig als immer gleich behandelt. std::allocator_traits<std::allocator<T>>::is_always_equal ist nicht veraltet und sein Member-Konstante value ist true für jedes T.
[bearbeiten] Example
#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); }
Ausgabe
7 foo bar
[bearbeiten] Defect reports
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| LWG 2103 | C++11 | redundanter Vergleich zwischen allocator möglicherweise erforderlich |
propagate_on_container_move_assignment bereitgestellt |
| LWG 2108 | C++11 | es gab keine Möglichkeit zu zeigen, dass allocator zustandslos ist |
is_always_equal bereitgestellt |
[bearbeiten] See also
| (C++11) |
liefert Informationen über Allocator-Typen (Klassen-Template) |
| (C++11) |
implementiert mehrstufige Allokatoren für mehrstufige Container (Klassen-Template) |
| (C++11) |
prüft, ob der angegebene Typ Uses-Allocator-Konstruktion unterstützt (Klassen-Template) |
