Gemeinsamer Zeiger der Liste mit geteilten Zeigern

Question

Ich implementiere große Strukturen (etwas wie Struktur A hat Struktur B und Struktur B hat Struktur C und so weiter ...). In einer der verschachtelten Ebenen hat eine Struktur einen Zeiger auf sich selbst. Welche Lösung wird damit besser umgehen?

Ich weiß, dass die Verwaltung von rohen Zeigern kümmern müssen Erstellen und Löschen von Objekten. Was ist mit intelligenten Zeigern? Gibt es etwas Gefährliches, indem man so etwas erstellt?

EDIT

Dies ist, wie diese Struktur verwendet wird:

void createStruct() 
{ 
    //Here will be created pointer to main struct 
    std::shared_ptr<StructA> structA = fillStruct(); 

    //Here get everything what is needed from this struct and this struct wont be used nymore 
} 

fillStruct Funktion:

std::shared_ptr<StructA> fillStruct() 
{ 
    std::shared_ptr<StructA> structA = std::make_shared<StructA>(); 
    //Here fill whole structA 
    //Somewhere create struct B included in struct A 
    structA->structB = std::make_shared<StructB>(); 
    //Now fill struct B 
    //and so on... 
    //Now somewhere in nested struct create MyStruct 

    //return this whole created struct 
    return structA; 
} 

Vielen Dank für Ihre Antworten.

Answer 1

Das große Problem mit "Zeiger auf sich selbst" ist, dass Sie mit einem Objekt enden können, das den letzten Zeiger auf sich selbst hält. Da dieses Objekt keine anderen Zeiger hat, ist es nicht erreichbar und nicht löschbar.

Eine etwas komplexere Variante ist, wenn zwei Objekte einen Zeiger zueinander haben, aber keine anderen Zeiger auf sie existieren. Einer der beiden würde den anderen runter nehmen, aber es gibt keine Möglichkeit, den ersten der beiden zu löschen.

Ich spreche hier nicht über intelligente oder dumme Zeiger, das Problem ist grundlegend. Wenn Sie Garbage Collection-Algorithmen schreiben, werden Sie dies als das "Zyklus" -Problem kennen. Objektbeziehungen können unter Verwendung der Graphentheorie ausgedrückt werden, und im Allgemeinen sind diese Beziehungen gerichtet. A besitzt B, und das bedeutet normalerweise, dass B nicht eigene A hat. Aber wenn es das tut, hast du einen Zyklus A-> B-> A.

Ein weit verbreiteter Ansatz, das Problem zu umgehen, ist ein zweite Graph zu haben, das tut nicht Zyklen enthalten. Sie sagen, Sie haben eine verschachtelte Struktur. Vielleicht kann der Eltern-Level alle MyStruct besitzen? Und wenn es kein eindeutiges Elternteil gibt, das als Eigentümer agieren könnte, könnten mehrere Eltern vielleicht shared_ptr<myStruct> verwenden, um Besitz zu teilen - immer noch auf einem höheren Niveau.