Breaking zyklische Referenzen mit std :: weak_ptr und Alias-Konstruktor: Sound oder problematisch?

Question

Ich habe noch nicht den folgenden Weg gefunden, zyklische Referenzen zu brechen, die in irgendeinem großen C++ Forum/Blog erklärt werden, wie auf GotW, also wollte ich fragen, ob die Technik bekannt ist, und was sind ihre Vor- und Nachteile?

class Node : public std::enable_shared_from_this<Node> { 
public: 
    std::shared_ptr<Node> getParent() { 
     return parent.lock();  
    } 

    // the getter functions ensure that "parent" always stays alive! 
    std::shared_ptr<Node> getLeft() { 
     return std::shared_ptr<Node>(shared_from_this(), left.get()); 
    } 

    std::shared_ptr<Node> getRight() { 
     return std::shared_ptr<Node>(shared_from_this(), right.get()); 
    } 

    // add children.. never let them out except by the getter functions! 
public: 
    std::shared_ptr<Node> getOrCreateLeft() { 
     if(auto p = getLeft()) 
      return p; 
     left = std::make_shared<Node>(); 
     left->parent = shared_from_this(); 
     return getLeft(); 
    } 

    std::shared_ptr<Node> getOrCreateRight() { 
     if(auto p = getRight()) 
      return p; 
     right = std::make_shared<Node>(); 
     right->parent = shared_from_this(); 
     return getRight(); 
    } 

private: 
    std::weak_ptr<Node> parent; 
    std::shared_ptr<Node> left; 
    std::shared_ptr<Node> right; 
}; 

Von außen bemerkt der Benutzer von Node nicht den Trick mit den Aliasing-Konstruktor in getLeft mit und getRight, aber dennoch kann der Benutzer sicher sein, dass getParent immer einen nicht leeren freigegebenen Zeiger zurückgibt, weil alle Zeiger, die von p->get{Left,Right} zurückgegeben werden, behalten das Objekt *p für die Lebensdauer des zurückgegebenen untergeordneten Zeigers am Leben.

Werde ich hier etwas übersehen, oder ist dies ein offensichtlicher Weg, zyklische Referenzen zu brechen, die bereits dokumentiert wurden?

int main() { 
    auto n = std::make_shared<Node>(); 
    auto c = n->getOrCreateLeft(); 
    // c->getParent will always return non-null even if n is reset()! 
} 

Answer 1

The shared_ptr<Node> von Ihrem getParent zurück besitzt die Eltern, nicht die Eltern der Eltern.

Auf diese Weise shared_ptr wieder getParent aufrufen kann eine leere (und null) shared_ptr zurückgeben. Zum Beispiel:

int main() { 
    auto gp = std::make_shared<Node>(); 
    auto p = gp->getOrCreateLeft(); 
    auto c = p->getOrCreateLeft(); 
    gp.reset(); 
    p.reset(); // grandparent is dead at this point 
    assert(c->getParent()); 
    assert(!c->getParent()->getParent()); 
} 

(Die geerbt shared_from_this geht aus auch shared_ptr s, die den Knoten anstatt seine Eltern besitzen, aber ich nehme an, Sie es schwieriger zu vermasseln von einer privaten mit Erklärung und es verbieten vertraglich zu machen.)