Wie können Sie ein „std::shared_ptr' des aktuellen Objekts (dieses) erstellen, um es an untergeordnete Objekte zu übergeben, wenn „std::shared_ptr' für den Besitz verwendet wird?

Das Rätsel von „std::shared_ptr of this“

Im Bereich der intelligenten Zeiger müssen sich Programmierer oft mit dem Komplizierten auseinandersetzen Netz aus Objektbesitz und Lebensdauerverwaltung. Eine solche Herausforderung entsteht, wenn versucht wird, einen std::shared_ptr des aktuellen Objekts an sein Kind zu übergeben.

Stellen Sie sich das folgende Szenario vor: Ein Objekt der Klasse A enthält eine Liste von Kindern der Klasse B, während jedes Kind benötigt um einen Verweis auf das übergeordnete Element aufrechtzuerhalten. Diese scheinbar unkomplizierte Aufgabe stellt ein Hindernis dar, wenn wir versuchen, einen std::shared_ptr zu erstellen, der auf das übergeordnete Objekt zeigt.

<code class="cpp">class A {
private:
    std::list<std::shared_ptr<B>> children;
};

class B {
public:
    void setParent(std::shared_ptr<A> parent) { ... }
};</code>

Wie übergeben wir einen std::shared_ptr des aktuellen A-Objekts an seine untergeordneten Objekte?

Die Antwort: std::enable_shared_from_this

Die Lösung liegt in der Vorlagenklasse std::enable_shared_from_this. Indem es davon erbt, erhält ein Objekt die Fähigkeit, über die Methode shared_from_this einen shared_ptr für sich selbst zu erstellen.

Um unser Dilemma zu lösen, ändern wir unsere A-Klasse entsprechend:

<code class="cpp">class A : public std::enable_shared_from_this<A> {
    // ...
    void addChild(std::shared_ptr<B> child) {
        children.push_back(child);
        child->setParent(shared_from_this());
    }
};</code>

Jetzt Wir können mühelos einen shared_ptr des übergeordneten Objekts an seine untergeordneten Objekte übergeben.

Ein Vorbehalt: Zirkuläre Abhängigkeiten und Ressourcenlecks

Unsere Lösung bringt jedoch ein potenzielles Problem mit sich: zirkulär Abhängigkeiten. Indem wir Verweise sowohl auf das übergeordnete als auch auf die untergeordneten Objekte halten, schaffen wir einen Kreislauf, in dem jedes Objekt auf die Existenz des anderen angewiesen ist. Dies kann zu Ressourcenlecks führen, wenn die Objekte nicht ordnungsgemäß freigegeben werden.

Um dieses Problem zu mildern, verwenden wir std::weak_ptr für die Verweise der untergeordneten Elemente auf ihre übergeordneten Objekte. Schwache Zeiger verhindern nicht das Löschen des referenzierten Objekts und werden beim Löschen automatisch ungültig gemacht.

<code class="cpp">class A {
private:
    std::list<std::weak_ptr<B>> children;
};</code>

Mit dieser Anpassung wird die zirkuläre Abhängigkeit aufgehoben, wodurch eine ordnungsgemäße Objektzerstörung sichergestellt und Speicherlecks verhindert werden.

Einschränkungen: Eigentum und Timing

Es ist wichtig zu beachten, dass der Aufruf von shared_from_this() erfordert, dass das aktuelle Objekt zum Zeitpunkt des Aufrufs im Besitz von std::shared_ptr ist. Dies bedeutet, dass das Objekt nicht auf dem Stapel erstellt oder innerhalb eines Konstruktors oder Destruktors aufgerufen werden kann.

Das obige ist der detaillierte Inhalt vonWie können Sie ein „std::shared_ptr' des aktuellen Objekts (dieses) erstellen, um es an untergeordnete Objekte zu übergeben, wenn „std::shared_ptr' für den Besitz verwendet wird?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!