|
Boost : |
From: Michael Marcin (mmarcin_at_[hidden])
Date: 2007-03-01 12:41:42
Michael Anderson wrote:
> <snip>
>
> For example I want this to work... where ptr<Bar> is some kind of
> smart (or otherwise) pointer to a bar object.
>
> {
> ptr<Bar> barPtr;
> {
> ptr<Foo> fooPtr(new Foo);
> barPtr = fooPtr->bar;
> //A
> }
> barPtr->doSomething(); //B
> //C
> }
>
> Note that fooPtr goes out of scope at line A, but if the Foo object is
> destroyed at A then line B is an error. Instead I want the Foo object
> to exist until line C where both barPtr and fooPtr go out of scope.
>
> <snip>
>
I see...
This sort of usage smells bad to me but if you have solid reasons behind it
perhaps this is a case for 2 shared pointers using the same reference count
object as was discussed on this list a while ago.
i.e. something like
class Bar {};
class Foo : enable_shared_from_this<Foo>
{
public:
Foo() : bar( shared_ptr<Bar>(new Bar, shared_from_this()) ) {}
weak_ptr<Bar> bar;
};
{
shared_ptr<Bar> barPtr;
{
shared_ptr<Foo> fooPtr(new Foo);
barPtr = fooPtr->bar.lock();
} //A
barPtr->doSomething();
} //B
where nothing gets destroyed at //A but both get destroyed at //B
hmm I don't think this will quite work but I'll post it anyways to get more
ideas.
- Michael Marcin
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk