std:: make_shared, std:: make_shared_for_overwrite

Reserviert Speicher für ein Objekt 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 std::bad_alloc oder jede Exception werfen, die vom Konstruktor von T geworfen wird. Wenn eine Exception geworfen wird, haben die Funktionen keine Wirkung. Wenn eine Exception während der Konstruktion des Arrays geworfen wird, werden bereits initialisierte Elemente in umgekehrter Reihenfolge zerstört. (seit 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.

Diese Funktionen können als Alternative zu std:: shared_ptr < T > ( new T ( args... ) ) verwendet werden. Die Kompromisse sind:

• std:: shared_ptr < T > ( new T ( args... ) ) führt mindestens zwei Allokationen durch (eine für das Objekt T und eine für den Kontrollblock des Shared Pointers), während std :: make_shared < T > typischerweise nur eine Allokation durchführt (der Standard empfiehlt dies, verlangt es aber nicht; alle bekannten Implementierungen tun dies).
• Wenn irgendein std::weak_ptr auf den von std::make_shared erstellten Kontrollblock verweist, nachdem die Lebensdauer aller Shared-Besitzer beendet ist, bleibt der von T belegte Speicher bestehen, bis auch alle Weak-Besitzer zerstört werden, was unerwünscht sein kann, wenn sizeof ( T ) groß ist.
• std:: shared_ptr < T > ( new T ( args... ) ) kann einen nicht-öffentlichen Konstruktor von T aufrufen, wenn er in einem Kontext ausgeführt wird, in dem er zugänglich ist, während std::make_shared öffentlichen Zugang zum ausgewählten Konstruktor erfordert.
• Im Gegensatz zu den std::shared_ptr Konstruktoren erlaubt std::make_shared keinen benutzerdefinierten Deleter.
• std::make_shared verwendet :: new , daher unterscheidet es sich von std:: shared_ptr < T > ( new T ( args... ) ) , falls ein spezielles Verhalten mittels eines klassen-spezifischen operator new eingerichtet wurde.

Ein Konstruktor, der shared_from_this mit einem Zeiger ptr vom Typ U* aktiviert, 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 <iostream>
#include <memory>
#include <type_traits>
#include <vector>
struct C
{
    // Konstruktoren benötigt (bis C++20)
    C(int i) : i(i) {}
    C(int i, float f) : i(i), f(f) {}
    int i;
    float f{};
};
int main()
{
    // Verwendung von "auto" für den Typ von "sp1"
    auto sp1 = std::make_shared<C>(1); // Überladung (1)
    static_assert(std::is_same_v<decltype(sp1), std::shared_ptr<C>>);
    std::cout << "sp1->{ i:" << sp1->i << ", f:" << sp1->f << " }\n";
    // explizite Angabe des Typs von "sp2"
    std::shared_ptr<C> sp2 = std::make_shared<C>(2, 3.0f); // Überladung (1)
    static_assert(std::is_same_v<decltype(sp2), std::shared_ptr<C>>);
    static_assert(std::is_same_v<decltype(sp1), decltype(sp2)>);
    std::cout << "sp2->{ i:" << sp2->i << ", f:" << sp2->f << " }\n";
    // shared_ptr zu einem wertinitialisierten float[64]; Überladung (2):
    std::shared_ptr<float[]> sp3 = std::make_shared<float[]>(64);
    // shared_ptr zu einem wertinitialisierten long[5][3][4]; Überladung (2):
    std::shared_ptr<long[][3][4]> sp4 = std::make_shared<long[][3][4]>(5);
    // shared_ptr zu einem wertinitialisierten short[128]; Überladung (3):
    std::shared_ptr<short[128]> sp5 = std::make_shared<short[128]>();
    // shared_ptr zu einem wertinitialisierten int[7][6][5]; Überladung (3):
    std::shared_ptr<int[7][6][5]> sp6 = std::make_shared<int[7][6][5]>();
    // shared_ptr zu einem double[256], wobei jedes Element 2.0 ist; Überladung (4):
    std::shared_ptr<double[]> sp7 = std::make_shared<double[]>(256, 2.0);
    // shared_ptr zu einem double[7][2], wobei jeder double[2]
    // element ist {3.0, 4.0}; Überladung (4):
    std::shared_ptr<double[][2]> sp8 = std::make_shared<double[][2]>(7, {3.0, 4.0});
    // shared_ptr zu einem vector<int>[4], wobei jeder vector
    // enthält Inhalte {5, 6}; Überladung (4):
    std::shared_ptr<std::vector<int>[]> sp9 =
        std::make_shared<std::vector<int>[]>(4, {5, 6});
    // shared_ptr zu einem float[512], wobei jedes Element 1.0 ist; Überladung (5):
    std::shared_ptr<float[512]> spA = std::make_shared<float[512]>(1.0);
    // shared_ptr zu einem double[6][2], wobei jedes double[2]-Element
    // ist {1.0, 2.0}; Überladung (5):
    std::shared_ptr<double[6][2]> spB = std::make_shared<double[6][2]>({1.0, 2.0});
    // shared_ptr zu einem vector<int>[4], wobei jeder vector
    // enthält Inhalte {5, 6}; Überladung (5):
    std::shared_ptr<std::vector<int>[4]> spC =
        std::make_shared<std::vector<int>[4]>({5, 6});
}

sp1->{ i:1, f:0 }
sp2->{ i:2, f:3 }

Fehlerberichte

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

Siehe auch