Was ist der Nutzen von `enable_shared_from_this`?

Question

Ich lief über enable_shared_from_this beim Lesen der Boost.Asio Beispiele und nach dem Lesen der Dokumentation bin ich immer noch verloren, wie dies richtig verwendet werden sollte. Kann mir bitte jemand ein Beispiel geben und/oder eine Erklärung für die Verwendung dieser Klasse sinnvoll ist.

Answer 1

Es ermöglicht Ihnen, eine gültige shared_ptr Instanz zu this zu erhalten, wenn alles, was Sie haben, this ist. Ohne sie hätten Sie keine Möglichkeit, einen zu this zu bekommen, es sei denn, Sie hatten bereits einen als Mitglied. Dieses Beispiel aus dem boost documentation for enable_shared_from_this:

class Y: public enable_shared_from_this<Y> 
{ 
public: 

    shared_ptr<Y> f() 
    { 
     return shared_from_this(); 
    } 
} 

int main() 
{ 
    shared_ptr<Y> p(new Y); 
    shared_ptr<Y> q = p->f(); 
    assert(p == q); 
    assert(!(p < q || q < p)); // p and q must share ownership 
} 

Die Methode f() gibt eine gültige shared_ptr, obwohl es kein Mitglied Instanz hatte. Beachten Sie, dass dies nicht einfach tun:

class Y: public enable_shared_from_this<Y> 
{ 
public: 

    shared_ptr<Y> f() 
    { 
     return shared_ptr<Y>(this); 
    } 
} 

Der gemeinsame Zeiger, der diese ein anderen Referenzzähler haben aus dem „richtigen“ einem zurückgegeben wird, und einer von ihnen wird am Ende verlieren und hielt eine baumelnde Referenz, wenn das Objekt ist gelöscht.

enable_shared_from_this wird auch ein Teil des neuen C++ 0x-Standards sein, so dass Sie es auch von dort sowie von boost bekommen können.

Answer 2

Eine andere Möglichkeit besteht darin, ein weak_ptr<Y> m_stub Element in hinzuzufügen. Dann schreiben:

shared_ptr<Y> Y::f() 
{ 
    return m_stub.lock(); 
} 

Nützlich, wenn Sie nicht die Klasse ändern können, von dem Sie ableiten (z anderer Leute Bibliothek erstreckt). Vergessen Sie nicht, das Mitglied zu initialisieren, z. von m_stub = shared_ptr<Y>(this), ist es auch während eines Konstruktors gültig.

Es ist in Ordnung, wenn es mehr Stubs wie dieses in der Vererbungshierarchie gibt, es wird die Zerstörung des Objekts nicht verhindern.

Bearbeiten: Wie von Benutzer nobar richtig angezeigt, würde der Code Y-Objekt zerstören, wenn die Zuweisung abgeschlossen ist und temporäre Variablen zerstört werden. Daher ist meine Antwort falsch.

Answer 3

von Dr. Dobbs Artikel über schwache Zeiger, ich denke, das Beispiel leichter zu verstehen ist (Quelle: http://drdobbs.com/cpp/184402026):

... Code wie diesen wird nicht korrekt funktionieren:

int *ip = new int; 
shared_ptr<int> sp1(ip); 
shared_ptr<int> sp2(ip); 

Weder von den zwei shared_ptr Objekten weiß über die anderen, so werden beide versuchen, die Ressource freizugeben, wenn sie zerstört werden. Das führt normalerweise zu Problemen.

Und falls eine Elementfunktion ein shared_ptr Objekt benötigt, das das Objekt besitzt, dass es auf genannt wird, kann es nicht nur ein Objekt on the fly erstellen:

struct S 
{ 
    shared_ptr<S> dangerous() 
    { 
    return shared_ptr<S>(this); // don't do this! 
    } 
}; 

int main() 
{ 
    shared_ptr<S> sp1(new S); 
    shared_ptr<S> sp2 = sp1->dangerous(); 
    return 0; 
} 

Dieser Code hat das gleiche Problem wie das frühere Beispiel, obwohl in einer subtileren Form. Wenn es aufgebaut ist, besitzt das Objekt shared_pt r sp1 die neu zugeordnete Ressource. Der Code in der Elementfunktion S::dangerous kennt das shared_ptr Objekt nicht, so dass das shared_ptr Objekt, das zurückgegeben wird, sich von sp1 unterscheidet.Das Kopieren des neuen Objekts shared_ptr zu sp2 hilft nicht; Wenn sp2 den Gültigkeitsbereich verlässt, wird die Ressource freigegeben, und wenn sp1 den Gültigkeitsbereich verlässt, wird die Ressource erneut freigegeben.

Um dieses Problem zu vermeiden, verwenden Sie die Klassenvorlage enable_shared_from_this. Die Vorlage verwendet ein Template-Argument, das den Namen der Klasse angibt, die die verwaltete Ressource definiert. Diese Klasse muss wiederum öffentlich aus der Vorlage abgeleitet werden; dies wie:

struct S : enable_shared_from_this<S> 
{ 
    shared_ptr<S> not_dangerous() 
    { 
    return shared_from_this(); 
    } 
}; 

int main() 
{ 
    shared_ptr<S> sp1(new S); 
    shared_ptr<S> sp2 = sp1->not_dangerous(); 
    return 0; 
} 

Wenn Sie dies tun, denken Sie daran, dass das Objekt, auf dem Sie shared_from_this nennen muss von einem shared_ptr Objekt gehören. Das wird nicht funktionieren:

int main() 
{ 
    S *p = new S; 
    shared_ptr<S> sp2 = p->not_dangerous();  // don't do this 
} 

Answer 4

Beachten Sie, dass eine boost :: mit intrusive_ptr von diesem Problem nicht betroffen. Dies ist oft eine bequemere Möglichkeit, dieses Problem zu umgehen.

Answer 5

Hier ist meine Erklärung, aus der Perspektive der Schrauben und Muttern (Top-Antwort nicht mit mir "klick"). * Anmerkung, dass dies das Ergebnis einer Untersuchung der Quelle für shared_ptr und enable_shared_from_this, die mit Visual Studio kommt 2012. Vielleicht anderen Compilern enable_shared_from_this anders implementieren ... *

enable_shared_from_this<T> fügt eine private weak_ptr<T> Instanz T, die die "hält man wahre Referenzzahl 'für die Instanz T.

Also, wenn Sie zuerst ein shared_ptr<T> auf einen neuen T * schaffen, dass T * 's internen weak_ptr mit einem refcount von 1. Die neuen shared_ptr grundsätzlich auf diesen weak_ptr sichert initialisiert wird.

T kann dann in seine Methoden, shared_from_this rufen eine Instanz von shared_ptr<T> dass Rücken auf derselben intern gespeicherten Referenzzähler zu erhalten. Auf diese Weise haben Sie immer einen Platz, an dem T* 's ref-count gespeichert wird, anstatt mehrere shared_ptr Instanzen, die nicht voneinander wissen, und jeder denkt, dass sie die shared_ptr sind, die für ref-counting T zuständig ist und löschen es wenn ihre ref-count Null erreicht.

Answer 6

Es ist genau das gleiche in C++ 11 und höher: Es ist die Fähigkeit zu ermöglichen, this als gemeinsamer Zeiger zurückgeben, da this gibt Ihnen einen rohen Zeiger.

in anderen Worten, es können Sie Code wie dieser

class Node { 
public: 
    Node* getParent const() { 
     if (m_parent) { 
      return m_parent; 
     } else { 
      return this; 
     } 
    } 

private: 

    Node * m_parent = nullptr; 
};   

in diese einzuschalten:

class Node : std::enable_shared_from_this<Node> { 
public: 
    std::shared_ptr<Node> getParent const() { 
     std::shared_ptr<Node> parent = m_parent.lock(); 
     if (parent) { 
      return parent; 
     } else { 
      return shared_from_this(); 
     } 
    } 

private: 

    std::weak_ptr<Node> m_parent; 
};