std::shared_ptr<T>:: shared_ptr

Konstruiert einen neuen shared_ptr aus verschiedenen Zeigertypen, die auf ein zu verwaltendes Objekt verweisen.

Wenn T kein Array-Typ ist, ermöglichen die Überladungen (3,4,6) shared_from_this mit ptr , und die Überladung (13) ermöglicht shared_from_this mit dem von r. release ( ) zurückgegebenen Zeiger.

Parameter

Nachbedingungen

Exceptions

Hinweise

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.

Die Überladungen für rohe Zeiger übernehmen die Eigentümerschaft des gezeigten Objekts. Daher führt die Konstruktion eines shared_ptr unter Verwendung der Überladung für rohe Zeiger für ein Objekt, das bereits von einem shared_ptr verwaltet wird, wie etwa durch shared_ptr ( ptr. get ( ) ) , wahrscheinlich zu undefiniertem Verhalten, selbst wenn das Objekt von einem von std::enable_shared_from_this abgeleiteten Typ ist.

Da der Standardkonstruktor constexpr ist, werden statische shared_ptrs als Teil der statischen Nicht-Lokal-Initialisierung initialisiert, bevor jegliche dynamische Nicht-Lokal-Initialisierung beginnt. Dies macht es sicher, einen shared_ptr im Konstruktor eines beliebigen statischen Objekts zu verwenden.

In C++11 und C++14 ist es gültig, einen std:: shared_ptr < T > aus einem std:: unique_ptr < T [ ] > zu konstruieren:

std::unique_ptr<int[]> arr(new int[1]);
std::shared_ptr<int> ptr(std::move(arr));

Da der shared_ptr seinen Deleter (ein std:: default_delete < T [ ] > Objekt) vom std::unique_ptr übernimmt, wird das Array korrekt freigegeben.

Dies ist in C++17 nicht mehr erlaubt. Stattdessen sollte die Array-Form std:: shared_ptr < T [ ] > verwendet werden.

Beispiel

#include <iostream>
#include <memory>
struct Foo
{
    int id{0};
    Foo(int i = 0) : id{i} { std::cout << "Foo::Foo(" << i <<  ")\n"; }
    ~Foo() { std::cout << "Foo::~Foo(), id=" << id << '\n'; }
};
struct D
{
    void operator()(Foo* p) const
    {
        std::cout << "Call delete from function object. Foo::id=" << p->id << '\n';
        delete p;
    }
};
int main()
{
    {
        std::cout << "1) constructor with no managed object\n";
        std::shared_ptr<Foo> sh1;
    }
    {
        std::cout << "2) constructor with object\n";
        std::shared_ptr<Foo> sh2(new Foo{10});
        std::cout << "sh2.use_count(): " << sh2.use_count() << '\n';
        std::shared_ptr<Foo> sh3(sh2);
        std::cout << "sh2.use_count(): " << sh2.use_count() << '\n';
        std::cout << "sh3.use_count(): " << sh3.use_count() << '\n';
    }
    {
        std::cout << "3) constructor with object and deleter\n";
        std::shared_ptr<Foo> sh4(new Foo{11}, D());
        std::shared_ptr<Foo> sh5(new Foo{12}, [](auto p)
        {
            std::cout << "Call delete from lambda... p->id=" << p->id << '\n';
            delete p;
        });
    }
}

1) constructor with no managed object
2) constructor with object
Foo::Foo(10)
sh2.use_count(): 1
sh2.use_count(): 2
sh3.use_count(): 2
Foo::~Foo(), id=10
3) constructor with object and deleter
Foo::Foo(11)
Foo::Foo(12)
Call delete from lambda... p->id=12
Foo::~Foo(), id=12
Call delete from function object. Foo::id=11
Foo::~Foo(), id=11

Fehlerberichte

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

Siehe auch