Smarter Smart Pointer

Question

Ich denke, das Konzept eines Zeigers, der nach sich selbst wie std::shared_ptr aufräumt, ist cool, aber ich frage mich, ob es einen besseren Smart Pointer von Drittanbietern da draußen gibt.

Das Problem mit der shared_ptr ist die von rekursiven Referenzen. Dies geschieht, wenn Sie so etwas wie dieses:

class A{ 
    public: 
    std::shared_ptr<A> other; 

    A() { } 
}; 

//Later 
std::shared_ptr<A> a = std::make_shared<A>(); 
std::shared_ptr<A> b = std::make_shared<A>(); 
a->other = b; //Memory leak 
b->other = a; //Memory leak 

Gibt es ein intelligenter Smart-Pointer aus, dass es spüren kann, wenn ich einen schwachen Zeiger verwendet haben sollte und leckt nicht (oder zumindest gibt eine Warnung aus)? (Nach einer kurzen Google-Suche kann ich nichts finden)

Answer 1

Ein schwacher Zeiger ist genau das, was hier verwendet werden sollte.

Die Tatsache, dass std::shared_ptr grundlegende Referenzzählung implementiert, und nichts, mehr ist nicht etwas, das kürzlich entdeckt wurde. C++ ist keine verwaltete Sprache und verfügt nicht über Funktionen für die automatische Speicherbereinigung. Somit sind zirkulare Referenzen über std::shared_ptr problematisch. Die Lösung ist der schwache Zeiger.

Answer 2

Die Lösung ist das nicht:

class A{ 
    std::weak_ptr<A> self; 
    public: 
    A() : self(*this) { } 
}; 

die Lösung ist dies:

class A : std::enable_shared_from_this<A> 
{ 

    void use_me() 
    { 
    // say i need to pass a shared_ptr to myself to some other function... 
    foo(this->shared_from_this()); 
    } 
}; 

auto var = std::make_shared<A>();