spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Moin zusammen.
Ich wage mich seit kurzer Zeit mal wieder an C++, nachdem ich D den Rücken gekehrt habe, und habe schon binnen weniger Tage ein kleine Frage.
Und zwar: Eine Klasse Foo benutzt eine Instanz von Bar. Derzeit handhabe ich es so, dass Foo einfach einen Raw Pointer auf Bar hält, während Bar als lvalue Referenz an Foo übergeben wird.
In etwa so:

Doch es ist etwas mühselig geworden, ständig darauf zu achten, dass Foo einen Pointer auf ein lebendes Bar hält. Man muss sich ständig darum kümmern, dass das übergeben Bar Objekt die gleiche oder längere Lebenszeit hat, wie Foo.
In den meisten fällen ist das nicht schwer,aber ich habe mittlerweile ein paar mal erlebt, das es mich doch gestört hat.
Ich dachte dann zunächst, ich übergebe es by value und scheiß auf die Kopie (ist ja eh relativ billig). Eine andere Idee war, dass es mit einem eventually owning pointer geht. Gibt es so natürlich (glaube ich zumindest) nicht. Dieser "smart pointer" würde dann den Pointer sowie ein bool halten, der angibt, ob der Pointer geowned wird, oder ob er auf etwas zeigt, dass sich selbst um seine Lebenszeit kümmert. Je nachdem gibt dieser smart pointer seinen verwalteten Zeiger am Ende seines scopes frei, oder eben nicht.
Dann würde ich etwa bei Bar& b davon Ausgehen, dass sich extern um Bar gekümmert wird, während ich bei Bar&& b mich dann selbst um die Lebenszeit kümmern würde.
Ist natürlich etwas mehr Aufwand. Ich wollte einfach fragen ob jemand schon selbst so ein Problem hatte und was er dann getan hat.
Für mich ergeben sich 3 Lösungen:

1. Es so lassen, Foo hält nur einen Raw Pointer auf Bar und man sieht zu, dass Bar eben mindestens genauso lange existiert
   
2. By value
   
3. Per eventually owning pointer
   

Danke.

Und wenn es ein Bar& ist, es also woanders eig schon existiert, habe ich dann entweder undefiniertes Verhalten wegen Stack Pointer, oder aber einen Heap Zeiger, egal ob Bar schon existierte. Das wäre ja eine pessimistische Annahme. :/

Habe ich mich etwa so schlecht ausgedrückt?
Wenn es als Bar& übergeben wird, handelt es sich logischerweise um ein lvalue, also existiert außerhalb von Foo ein Bar. Und das wird wohl noch leben. Mit Bar&& habe ich ein rvalue, also etwas, was demnächst verfällt (sobald die Funktion endet). Und in diesem Fall würde ich einen Bar Zeiger auf dem Heap erstellen in den ich das rvalue kopiere. Für den Fall, dass Bar ein lvalue ist, möchte ich es nicht besitzen, weil es ohnehin schon existiert und ein Raw Pointer darauf ausreicht. Ich muss mich nicht darum kümmern, dass es am Lebens bleibt. Doch bei einem rvalue muss ich das ja quasi. Das ist auch eher eine Frage also ein fester Design Entwurf, derzeit hält Foo eben nur einen Raw Pointer und die Lebenszeit von Bar muss extern gehandhabt werden. Ich weiß nicht wieso bei jeder kleineren Frage in diesem Forum "schlechtes" Design als präventiv Antwort einfließt. Das Forum ist wirklich kein schöner Ort mehr, an dem man einfach so eine Frage stellt, habe selbst 3 mal überlegt, ob ich wirklich hier diese Frage stellen sollte.
Ich werd mal selbst noch etwas damit experimentieren und wähle mir sonst Möglichkeit 1 oder 2 aus. Kann also geclosed werden.

Es ging mir viel mehr um den theoretischen Aspekt. Mein Design ist ja momentan so aufgebaut, dass Foo nur einen Raw Pointer hält, also nicht dafür zuständig ist. Denke dabei werde ich es auch belassen. Aber ja, dann hast du es richtig verstanden, ich wollte, dass Foo sich abhängig von der Übergabe entweder selbst um Bar kümmert, oder nicht.