Erstellen und Teilen von Shared Pointers

Genau wie eindeutige Zeiger können wir gemeinsame Zeiger auf zwei Arten erstellen: mit std::make_shared oder dem new Operator. Letzterer wird nicht empfohlen, aber der Verständlichkeit halber werden wir beide Ansätze behandeln.

Der empfohlene Ansatz

Der empfohlene Weg, einen gemeinsamen Zeiger zu erstellen, ist die std::make_shared Funktion. Dieser Ansatz ist im Allgemeinen effizienter und ausdrucksstärker im Vergleich zur Verwendung von new. Er allokiert Speicher für das Objekt und den Kontrollblock (Referenzzähler) in einem einzigen Schritt. Zum Beispiel:

Die obige Zeile allokiert einen dynamischen Integer und initialisiert auch einen Shared Pointer darauf mit einem Referenzzähler von 1.

Der abgeratene Ansatz

Sie können auch Shared Pointers mit new erstellen, aber diese Methode wird nicht empfohlen, da sie weder ausdrucksstark noch effizient ist. Die Syntax für diesen Ansatz erfordert, dass Sie das Objekt an den Konstruktor des Shared Pointers übergeben.

Im obigen Code allokieren wir einen dynamischen Integer und übergeben ihn dann dem Konstruktor des Shared Pointers. Der Kontrollblock (Referenzzähler) wird jedoch innerhalb des Konstruktors initialisiert.

Das bedeutet, dass wir zwei separate Initialisierungen durchführen, was ineffizient und fehleranfällig ist.

Weitergabe von Shared Pointers

Shared Pointers sind speziell für sicheres Teilen konzipiert. Lassen Sie uns einige Möglichkeiten erkunden, wie wir sie weitergeben können.

Durch direkte Zuweisung

Sie können einen Shared Pointer teilen, indem Sie ihn direkt einem anderen Shared Pointer zuweisen. Dies erhöht den Referenzzähler.

Im obigen Code weisen wir einen dynamischen Integer zu, der von ptr1 besessen wird. In der nächsten Zeile erstellen wir einen weiteren Shared Pointer ptr2, der ebenfalls beginnt, auf denselben dynamischen Integer zu verweisen.

Rückgabe aus einer Funktion

Wenn Sie einen Shared Pointer auf folgende Weise aus einer Funktion zurückgeben, erhält der Aufrufer dessen Besitz.

In der obigen Funktion allokieren wir eine dynamische Ganzzahl innerhalb einer Funktion und übertragen dann deren Besitz an den Aufrufer.

Teilen benutzerdefinierter Objekte

Es ist auch möglich, benutzerdefinierte Objekte mit Shared Pointers zu teilen. Betrachten Sie dieses Beispiel:

main


              123456789101112131415161718192021222324
            
#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass(int value) : data(value) {} //constructor

    int getData() { return data; }
private:
    int data;
};

int main() 
{
    // Creating a shared pointer to a custom object using make_shared
    std::shared_ptr<MyClass> obj1 = std::make_shared<MyClass>(42);

    // Creating another shared pointer that shares ownership with obj1
    std::shared_ptr<MyClass> obj2 = obj1;

    // Both obj1 and obj2 now own the  same custom object
    std::cout << "Data from obj1: " << obj1->getData() << std::endl; //prints 42
    std::cout << "Data from obj2: " << obj2->getData() << std::endl; //also prints 42
}

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 2