ich hab meine Daten als Baumstruktur aufgebaut.
Das funkt auch ganz gut.
Die (temporären) Objekte, die ich zurückgebe sind in std::auto_ptr bzw.
boost::shared_ptr gekapselt und garantieren mir daher die Zerstörung.
Jetzt bin ich allerdings an einer Stelle angekommen, wo ich
gerne einen Rat bezüglich des Speichermanagements hätte. Einem dieser
Objekte sage ich: Erzeuge mir ein "Kind". Dieses Kind hat allerdings einen
Verweis zum Parent. Folglich brauche ich für das Kind auch immernoch das Parent.
Jetzt hätte ich natürlich keinen Zugriff auf den boost::shared_ptr.
Wie löse ich sowas am Besten? Reference-count im Objekt und den Destrukor
private machen? Gibt es in Boost (oder so) evtl. schon eine derartige
Basis-Klasse (ähnlich dem Cocoa NSObject)?
Oder vielleicht nen zusätzlichen boost::weak_ptr ins Objekt, der mir den Zugriff
auf den shared_ptr ermöglicht und die Zerstörung nicht verhindert?

Gruß,
*Cpp-Anfänger

ich bin jetzt kein shared_ptr-Experte, aber ist der nicht genau dafür gemacht ?
Warum hält das Child nicht einfach einen shared_ptr auf den Parent ?

Gruß,

Simon2.

Warum hält das Child nicht einfach einen shared_ptr auf den Parent ?

Das einzige was der OP dabei beachten muss, ist das es keine Kreisverweise gibt die sich gegenseitig am Leben erhalten (dann kann man dies mittels boost::weak_ptr lösen, der zwar auf das gleiche Element wie ein entsprechender shared_ptr verweist, aber kein Speichermanagement übernimmt). Zudem sollte er Daten die mittels shared_ptr gehalten werden in der Regel auch so weitergeben (Dies ist ja gerade der Sinn, jede Kopie eines shared_ptr verweist auf das gleiche Objekt, das erst beim löschen des letzten shared_ptr gelöscht wird).

Zur Verwendung in die Boost-Dokumentation schauen, da existieren Beispiele (shared_ptr/weak_ptr und wie diese Zusammenhängen).

cu André

Ich bin auch kein shared_ptr-Experte

Wenn ich jetzt sage:
Erzeuge mir das Objekt.

Dann kriege ich ja einen boost::shared_ptr zurück

boost::shared_ptr<MyClass> obj = ErzeugerDesParent.create();

Jetzt brauche ich das Kind von dem Objekt.

obj->createChild();

// In der Methode hab ich allerdings keinen Zugriff auf de shared_ptr

Ein neues shared_ptr-Objekt kann ich ja auch nicht machen, denn
das reference counting findet ja in dem shared_ptr statt.

Gruß,
*Cpp-Anfänger*

an den weak_ptr hatte ich auch schon gedacht...
Aber ich benötige in dem objekt ja "eine Verknüpfung" zu dem shared_ptr.
Würdest du also in dem Objekt einen weak_ptr halten?

Gruß,
*Cpp-Anfänger*

Erzeuge mir das Objekt.
Dann kriege ich ja einen boost::shared_ptr zurück

boost::shared_ptr<MyClass> obj = ErzeugerDesParent.create();

Soweit okay,

Cpp-Anfänger schrieb:

Jetzt brauche ich das Kind von dem Objekt.

obj->createChild();

// In der Methode hab ich allerdings keinen Zugriff auf de shared_ptr

Nur hier solltest du dein Konzept überdenken. Denn entweder muss das Objekt den shared_ptr kennen (in dem Fall wohl nicht sinnvoll), oder du musst ihn übergeben...

Ich muss jetzt die Methodensignatur mal Raten:

// Vorher etwa so:
boost::shared_ptr<MyClass> ParentClass::createChild();

// Nun so:
boost::shared_ptr<MyClass> ParentClass::createChild(const boost::shared_ptr<MyClass>& parent)
{
  this->Parent = parent; // Parent: Member vom Typ boost::shared_ptr<MyClass>
  ...
}

Cpp-Anfänger schrieb:

Ein neues shared_ptr-Objekt kann ich ja auch nicht machen, denn
das reference counting findet ja in dem shared_ptr statt.

Stimmt, ein Neues nicht, aber das alte musst du doch irgendwo halten und kannst dieses übergeben und einer Member zuweisen. Die Membervariable verweist dann auf das gleiche Objekt, und "klingt sich bei dem übergebenen shared_ptr" bei der Referenzzählung mit ein.

cu André

danke für deinen Vorschlag, es funktioniert auch prima,
allerdings finde ich den Vorschlag von hustbaer design-technisch schöner.

@hustbaer: Genau so etwas habe ich gesucht. Um das zu erreichen wollte ich schon
nen boost::weak_ptr in mein Objekt packen, aber deine Lösung ist wirklich Opti.

Gruß,
*Cpp-Anfänger*

@hustbaer: Du bist einfach genial!

Meine Idee mit dem weak_ptr war scheinbar gar nicht so schlecht,
denn im Prinzip macht boost nichts anderes, nur dass dieser im Konstruktor von
shared_ptr noch automatisch initialisiert wird

Viele Grüße,
*Cpp-Anfänger*