std:: allocate_shared, std:: allocate_shared_for_overwrite

Reserviert Speicher für ein Objekt unter Verwendung einer Kopie von alloc (umgebunden für einen nicht spezifizierten value_type ) und initialisiert das Objekt mit den bereitgestellten Argumenten. Gibt ein std::shared_ptr -Objekt zurück, das das neu erstellte Objekt verwaltet.

Parameter

Rückgabewert

std::shared_ptr zu einem Objekt vom Typ T oder std:: remove_extent_t < T > [ N ] falls T ein unbegannter Array-Typ ist (seit C++20) .

Für den zurückgegebenen std::shared_ptr r gibt r. get ( ) einen nicht-null Zeiger zurück und r. use_count ( ) gibt 1 zurück.

Exceptions

Kann die Ausnahmen werfen, die von Alloc :: allocate ( ) oder vom Konstruktor von T geworfen werden. Wenn eine Ausnahme geworfen wird, (1) hat keine Wirkung. Wenn eine Ausnahme während der Konstruktion des Arrays geworfen wird, werden bereits initialisierte Elemente in umgekehrter Reihenfolge zerstört (since C++20) .

Hinweise

Diese Funktionen werden typischerweise mehr Speicher allokieren als sizeof ( T ) , um Platz für interne Verwaltungsstrukturen wie Referenzzähler zu ermöglichen.

Wie std::make_shared führt diese Funktion typischerweise nur eine Speicherallokation durch und platziert sowohl das T -Objekt als auch den Kontrollblock im allozierten Speicherblock (der Standard empfiehlt dies, schreibt es aber nicht vor, alle bekannten Implementierungen tun dies). Eine Kopie von alloc wird als Teil des Kontrollblocks gespeichert, damit sie zur Freigabe verwendet werden kann, sobald sowohl die shared- als auch weak-Referenzzähler null erreichen.

Im Gegensatz zu den std::shared_ptr constructors akzeptiert std::allocate_shared keinen separaten benutzerdefinierten Deleter: Der bereitgestellte Allokator wird für die Zerstörung des Kontrollblocks und des T -Objekts sowie für die Freigabe ihres gemeinsamen Speicherblocks verwendet.

Ein Konstruktor aktiviert shared_from_this mit einem Zeiger ptr vom Typ U* bedeutet, dass er bestimmt, ob U eine eindeutige und zugängliche (seit C++17) Basisklasse besitzt, die eine Spezialisierung von std::enable_shared_from_this ist, und falls ja, wertet der Konstruktor if ( ptr ! = nullptr && ptr - > weak_this  . expired ( ) )
ptr - > weak_this = std:: shared_ptr < std:: remove_cv_t < U >>
( * this, const_cast < std:: remove_cv_t < U > * > ( ptr ) ) ; aus.

Die Zuweisung an weak_this ist nicht atomar und steht in Konflikt mit jedem potenziell gleichzeitigen Zugriff auf dasselbe Objekt. Dies stellt sicher, dass zukünftige Aufrufe von shared_from_this() den Besitz mit dem std::shared_ptr teilen, der durch diesen Rohzeiger-Konstruktor erstellt wurde.

Der Test ptr - > weak_this  . expired ( ) im obigen Code stellt sicher, dass weak_this nicht neu zugewiesen wird, falls es bereits auf einen Besitzer verweist. Dieser Test ist ab C++17 erforderlich.

Beispiel

#include <cstddef>
#include <iostream>
#include <memory>
#include <memory_resource>
#include <vector>
class Value
{
    int i;
public:
    Value(int i) : i(i) { std::cout << "Value(), i = " << i << '\n'; }
    ~Value() { std::cout << "~Value(), i = " << i << '\n'; }
    void print() const { std::cout << "i = " << i << '\n'; }
};
int main()
{
    // Erstellen eines polymorphen Allokators mit der monotonen Pufferressource
    std::byte buffer[sizeof(Value) * 8];
    std::pmr::monotonic_buffer_resource resource(buffer, sizeof(buffer));
    std::pmr::polymorphic_allocator<Value> allocator(&resource);
    std::vector<std::shared_ptr<Value>> v;
    for (int i{}; i != 4; ++i)
        // Verwenden von std::allocate_shared mit dem benutzerdefinierten Allokator
        v.emplace_back(std::allocate_shared<Value>(allocator, i));
    for (const auto& sp : v)
        sp->print();
} //< Alle Shared Pointer werden automatisch bereinigt, wenn sie den Gültigkeitsbereich verlassen.

Value(), i = 0
Value(), i = 1
Value(), i = 2
Value(), i = 3
i = 0
i = 1
i = 2
i = 3
~Value(), i = 0
~Value(), i = 1
~Value(), i = 2
~Value(), i = 3

Fehlerberichte

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

Siehe auch