Namespaces
Variants

std:: allocator

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::allocator
Definiert im Header <memory>
template < class T >
struct allocator ;
(1)
template <>
struct allocator < void > ;
(2) (veraltet in C++17)
(entfernt in C++20)

Die std::allocator Klassenvorlage ist der Standard- Allocator , der von allen Standardbibliothekscontainern verwendet wird, falls kein benutzerdefinierter Allocator angegeben wurde. Der Standard-Allocator ist zustandslos, das bedeutet, alle Instanzen des gegebenen Allocators sind austauschbar, vergleichen gleich und können Speicher freigeben, der von jeder anderen Instanz desselben Allocator-Typs allokiert wurde.

Die explizite Spezialisierung für void fehlen die Member-Typdefinitionen reference , const_reference , size_type und difference_type . Diese Spezialisierung deklariert keine Member-Funktionen.

(until C++20)

Der Standard-Allokator erfüllt die Allokator-Vollständigkeitsanforderungen .

(since C++17)

Inhaltsverzeichnis

Mitgliedertypen

Typ Definition
value_type T
pointer (veraltet in C++17) (entfernt in C++20) T*
const_pointer (veraltet in C++17) (entfernt in C++20) const T *
reference (veraltet in C++17) (entfernt in C++20) T&
const_reference (veraltet in C++17) (entfernt in C++20) const T &
size_type std::size_t
difference_type std::ptrdiff_t
propagate_on_container_move_assignment (C++11) std::true_type
rebind (veraltet in C++17) (entfernt in C++20) template < class U >

struct rebind
{
typedef allocator < U > other ;
} ;

is_always_equal (C++11) (veraltet in C++23) (entfernt in C++26) std::true_type

Memberfunktionen

erstellt eine neue Allokator-Instanz
(öffentliche Elementfunktion)
zerstört eine Allokator-Instanz
(öffentliche Elementfunktion)
(until C++20)
ermittelt die Adresse eines Objekts, selbst wenn operator & überladen ist
(öffentliche Elementfunktion)
allokiert nicht initialisierten Speicher
(öffentliche Elementfunktion)
(C++23)
allokiert nicht initialisierten Speicher mit mindestens der angeforderten Größe
(öffentliche Elementfunktion)
gibt Speicher frei
(öffentliche Elementfunktion)
(until C++20)
gibt die größte unterstützte Allokationsgröße zurück
(öffentliche Elementfunktion)
(until C++20)
konstruiert ein Objekt im allokierten Speicher
(öffentliche Elementfunktion)
(until C++20)
zerstört ein Objekt im allokierten Speicher
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(removed in C++20)
vergleicht zwei Allokator-Instanzen
(öffentliche Elementfunktion)

Hinweise

Die Member-Template-Klasse rebind bietet eine Möglichkeit, einen Allokator für einen anderen Typ zu erhalten. Zum Beispiel, std:: list < T, A > allokiert Knoten eines internen Typs Node<T> , unter Verwendung des Allokators A::rebind<Node<T>>::other (bis C++11) std:: allocator_traits < A > :: rebind_alloc < Node < T >> , was implementiert wird durch A::rebind<Node<T>>::other falls A ein std::allocator (seit C++11) ist.

Der Member-Typ is_always_equal ist veraltet gemäß LWG-Issue 3170 , da er benutzerdefinierte Allokatoren, die von std::allocator abgeleitet sind, standardmäßig als immer gleich behandelt. std:: allocator_traits < std :: allocator < T >> :: is_always_equal ist nicht veraltet und seine Member-Konstante value ist true für jeden T .

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <memory>
#include <string>
int main()
{
    // Standard-Allokator für Ganzzahlen
    std::allocator<int> alloc1;
    // Demonstration der wenigen direkt verwendbaren Member
    static_assert(std::is_same_v<int, decltype(alloc1)::value_type>);
    int* p1 = alloc1.allocate(1); // Speicherplatz für eine Ganzzahl
    alloc1.deallocate(p1, 1);     // und er ist weg
    // Diese können jedoch auch über Traits verwendet werden, daher nicht notwendig
    using traits_t1 = std::allocator_traits<decltype(alloc1)>; // Der passende Trait
    p1 = traits_t1::allocate(alloc1, 1);
    traits_t1::construct(alloc1, p1, 7);  // die Ganzzahl konstruieren
    std::cout << *p1 << '\n';
    traits_t1::deallocate(alloc1, p1, 1); // Speicherplatz für eine Ganzzahl freigeben
    // Standard-Allokator für Zeichenketten
    std::allocator<std::string> alloc2;
    // Passende Traits
    using traits_t2 = std::allocator_traits<decltype(alloc2)>;
    // Rebind des Allokators mit dem Trait für Zeichenketten ergibt denselben Typ
    traits_t2::rebind_alloc<std::string> alloc_ = alloc2;
    std::string* p2 = traits_t2::allocate(alloc2, 2); // Speicherplatz für 2 Zeichenketten
    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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2103 C++11 redundanter Vergleich zwischen allocator könnte erforderlich sein 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

Siehe auch

(C++11)
stellt Informationen über Allokator-Typen bereit
(Klassen-Template)
(C++11)
implementiert mehrstufigen Allokator für mehrstufige Container
(Klassen-Template)
(C++11)
prüft, ob der angegebene Typ Uses-Allocator-Konstruktion unterstützt
(Klassen-Template)