Was ist der Nutzen von `enable_shared_from_this`?

Ich bin enable_shared_from_thisbeim Lesen der Boost.Asio-Beispiele darauf gestoßen, und nachdem ich die Dokumentation gelesen habe, bin ich immer noch verloren, wie dies richtig verwendet werden sollte. Kann mir bitte jemand ein Beispiel geben und erklären, wann die Verwendung dieser Klasse sinnvoll ist.

Es ermöglicht Ihnen, eine gültige shared_ptrInstanz zu erhalten this, wenn alles, was Sie haben, ist this. Ohne sie hätten Sie keine Möglichkeit, einen Zugang shared_ptrzu erhalten this, es sei denn, Sie hätten bereits einen als Mitglied. Dieses Beispiel aus der Boost-Dokumentation für 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 zurück shared_ptr, obwohl sie keine Mitgliedsinstanz hatte. Beachten Sie, dass Sie dies nicht einfach tun können:

class Y: public enable_shared_from_this<Y>
{
public:

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

Der gemeinsam genutzte Zeiger, den dieser zurückgegeben hat, hat eine andere Referenzanzahl als der "richtige", und einer von ihnen verliert und hält eine baumelnde Referenz, wenn das Objekt gelöscht wird.

enable_shared_from_thisist Teil des C ++ 11-Standards geworden. Sie können es auch von dort sowie von Boost bekommen.

Aus dem Artikel von Dr. Dobbs über schwache Zeiger geht hervor, dass dieses Beispiel leichter zu verstehen ist (Quelle: http://drdobbs.com/cpp/184402026 ):

... Code wie dieser funktioniert nicht richtig:

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

Keines der beiden shared_ptrObjekte kennt das andere, daher versuchen beide, die Ressource freizugeben, wenn sie zerstört werden. Das führt normalerweise zu Problemen.

Wenn eine Mitgliedsfunktion ein shared_ptrObjekt benötigt, das das Objekt besitzt, für das sie aufgerufen wird, kann sie nicht einfach ein Objekt im laufenden Betrieb 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 vorherige Beispiel, allerdings in einer subtileren Form. Wenn es erstellt wird, besitzt das shared_ptr-Objekt sp1die neu zugewiesene Ressource. Der Code in der Member-Funktion S::dangerouskennt dieses shared_ptrObjekt nicht, daher unterscheidet sich das zurückgegebene shared_ptrObjekt von sp1. Das Kopieren des neuen shared_ptrObjekts nach sp2hilft nicht. Wenn sp2der Gültigkeitsbereich verlassen wird, wird die Ressource freigegeben, und wenn sp1der Gültigkeitsbereich verlassen wird, wird die Ressource erneut freigegeben.

Um dieses Problem zu vermeiden, verwenden Sie die Klassenvorlage enable_shared_from_this. Die Vorlage verwendet ein Vorlagentypargument, bei dem es sich um den Namen der Klasse handelt, die die verwaltete Ressource definiert. Diese Klasse muss wiederum öffentlich aus der Vorlage abgeleitet werden. so was:

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;
}

Beachten Sie dabei, dass das Objekt, das Sie aufrufen shared_from_this, einem shared_ptrObjekt gehören muss. Das wird nicht funktionieren:

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

Hier ist meine Erklärung aus der Perspektive der Schrauben und Muttern (die oberste Antwort hat bei mir nicht 'geklickt'). * Beachten Sie, dass dies das Ergebnis der Untersuchung der Quelle für shared_ptr und enable_shared_from_this ist, die mit Visual Studio 2012 geliefert wird. Möglicherweise implementieren andere Compiler enable_shared_from_this anders ... *

enable_shared_from_this<T>fügt eine private weak_ptr<T>Instanz hinzu, Tdie den ' one true reference count ' für die Instanz von enthält T.

Wenn Sie also zum ersten Mal ein shared_ptr<T>auf einem neuen T * erstellen , wird das interne schwache_ptr dieses T * mit einem Refcount von 1 initialisiert. Das Neue setzt im shared_ptrGrunde darauf zurück weak_ptr.

Tkann dann in seinen Methoden aufrufen shared_from_this, um eine Instanz davon zu erhalten shared_ptr<T>, die auf denselben intern gespeicherten Referenzzähler zurückgreift . Auf diese Weise haben Sie immer einen Ort, an dem T*die Ref-Zählung gespeichert wird, anstatt mehrere shared_ptrInstanzen zu haben, die nichts voneinander wissen, und jeder denkt, dass sie shared_ptrdiejenige sind, die für das Ref-Zählen Tund Löschen verantwortlich ist, wenn ihre Ref -count erreicht Null.

Beachten Sie, dass die Verwendung von boost :: intrusive_ptr nicht unter diesem Problem leidet. Dies ist oft eine bequemere Möglichkeit, um dieses Problem zu umgehen.

In c ++ 11 und höher ist es genau dasselbe: Es soll die Möglichkeit ermöglichen, thisals gemeinsam genutzter Zeiger zurückzukehren, da thisSie einen Rohzeiger erhalten.

Mit anderen Worten, Sie können Code wie folgt drehen

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

private:

    Node * m_parent = nullptr;
};           

das sehr gut finden:

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;
};           

Eine andere Möglichkeit besteht darin, ein weak_ptr<Y> m_stubMitglied zum hinzuzufügen class Y. Dann schreibe:

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

Nützlich, wenn Sie die Klasse, aus der Sie stammen, nicht ändern können (z. B. die Bibliothek anderer Personen erweitern). Vergessen Sie nicht, das Mitglied zu initialisieren, z. B. durchm_stub = shared_ptr<Y>(this) , es ist auch während eines Konstruktors gültig.

Es ist in Ordnung, wenn mehr Stubs wie dieser in der Vererbungshierarchie vorhanden sind. Dies verhindert nicht die Zerstörung des Objekts.

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