Smart pointer for observe only behavior

[Soumen]

Hi,

I've requirement to observe a raw pointer (i.e. I should be able to
query if the pointer I'm using is still valid or not but when the
observer goes out of scope, the resource -- memory -- shouldn't be
released). Is there any boost way (or using any other smart pointer)
to achieve this? Since I've a raw pointer, probably I cannot use
weak_ptr.

Is there a way to do this using shared_ptr with custom deleter?

Regards,
~ Soumen

[Soumen]

On Jul 10, 4:26*pm, Michael DOUBEZ <[e-mail]:

Soumen a écrit :

I've requirement to observe a raw pointer (i.e. I should be able to
query if the pointer I'm using is still valid or not but when the
observer goes out of scope, the resource -- memory -- shouldn't be
released). Is there any boost way (or using any other smart pointer)
to achieve this? Since I've a raw pointer, probably I cannot use
weak_ptr.

Your can only ask if a pointer is valid to the owner of this pointer. If
your pointer is not owned then you have no way to know if it is still
valid.

Is there a way to do this using shared_ptr with custom deleter?

In the case of shared_ptr/weak_ptr, it is the shared_ptr that owns the
pointer and it is what makes weak_ptr possible. Using a shared_ptr
without destructor won't save you.

--
Michael

OK. The pointer I want to observe say is of class A and class A is
singleton.
the creation and destruction of A not managed by different module
(legacy).
But my module (new) needs to use some member functions of A. My module
cannot
manage A but is dependent on A. During course of execution, there're
chances that
A's object is recreated. And I need to be aware of it. Is there a
solution?

I can at most change A::instance() to return shared_ptr<A>.

Regards,
~ Soumen

[Daniel T.]

Soumen <so******@gmail.comwrote:

I've requirement to observe a raw pointer (i.e. I should be able to
query if the pointer I'm using is still valid or not but when the
observer goes out of scope, the resource -- memory -- shouldn't be
released). Is there any boost way (or using any other smart
pointer) to achieve this? Since I've a raw pointer, probably I
cannot use weak_ptr.

Is there a way to do this using shared_ptr with custom deleter?

No. You would have to write some sort of observable pointer. I've done
this before but be advised that such a pointer is quite smart and kind
of expensive. You would need two classes, a "master_pointer" that owns
the object in question and "observer_pointers". observer_pointers log
themselves with the master_pointer as holders of pointers to the object
and the master_pointer notifies all the observers when the object is
deleted so they will know the object is no longer valid.

I expect there is a better way to solve your problem though...

OK. The pointer I want to observe say is of class A and class A is
singleton. the creation and destruction of A not managed by
different module (legacy). But my module (new) needs to use some
member functions of A. My module cannot manage A but is dependent
on A. During course of execution, there're chances that A's object
is recreated. And I need to be aware of it. Is there a solution?

Yes and the solution is simple. Don't keep any pointers to the A
singleton. Every time you need to call a member-function on the
singleton object, get the pointer from the A::instance() member-function.

[Soumen]

On Jul 11, 7:40*am, "Daniel T." <[e-mail]:

Soumen <[e-mail]:

I've requirement to observe a raw pointer (i.e. I should be able to
query if the pointer I'm using is still valid or not but when the
observer goes out of scope, the resource -- memory -- shouldn't be
released). Is there any boost way (or using any other smart
pointer) to achieve this? Since I've a raw pointer, probably I
cannot use weak_ptr.

Is there a way to do this using shared_ptr with custom deleter?

No. You would have to write some sort of observable pointer. I've done
this before but be advised that such a pointer is quite smart and kind
of expensive. You would need two classes, a "master_pointer" that owns
the object in question and "observer_pointers". observer_pointers log
themselves with the master_pointer as holders of pointers to the object
and the master_pointer notifies all the observers when the object is
deleted so they will know the object is no longer valid.

Could you please elaborate a bit more? Is it not shared_ptr and
weak_ptr
combo type soln?

I expect there is a better way to solve your problem though...

OK. The pointer I want to observe say is of class A and class A is
singleton. the creation and destruction of A not managed by
different module (legacy). But my module (new) needs to use some
member functions of A. My module cannot manage A but is dependent
on A. During course of execution, there're chances that A's object
is recreated. And I need to be aware of it. Is there a solution?

Yes and the solution is simple. Don't keep any pointers to the A
singleton. Every time you need to call a member-function on the
singleton object, get the pointer from the A::instance() member-function.

Not quite clear as in my problem domain I need to know if A's object
is
recreated or not. If recreated, I need to do something, else not.
Observer
is probably a better soln. I'd though of it. But I's exploring there's
any
alternate quick soln to my problem rather than spending time to
implement
observer.

Anyway, thanks for all your inputs.

[Noah Roberts]

Soumen wrote:

Not quite clear as in my problem domain I need to know if A's object
is
recreated or not. If recreated, I need to do something, else not.
Observer
is probably a better soln. I'd though of it. But I's exploring there's
any
alternate quick soln to my problem rather than spending time to
implement
observer.

Anyway, thanks for all your inputs.

An object can implement both the singleton and observer pattern.

[Daniel T.]

Soumen <so******@gmail.comwrote:

"Daniel T." <[e-mail]:

Soumen <[e-mail]:

I've requirement to observe a raw pointer (i.e. I should be
able to query if the pointer I'm using is still valid or not
but when the observer goes out of scope, the resource -- memory
-- shouldn't be released). Is there any boost way (or using any
other smart pointer) to achieve this? Since I've a raw pointer,
probably I cannot use weak_ptr.
>
Is there a way to do this using shared_ptr with custom deleter?

No. You would have to write some sort of observable pointer. I've
done this before but be advised that such a pointer is quite
smart and kind of expensive. You would need two classes, a
"master_pointer" that owns the object in question and
"observer_pointers". observer_pointers log themselves with the
master_pointer as holders of pointers to the object and the
master_pointer notifies all the observers when the object is
deleted so they will know the object is no longer valid.

Could you please elaborate a bit more?

Think of a Pointer class that has a "kill" method. When any owner of a
Pointer object calls kill, the object is deleted and all the Pointers
that point to the same object are set to NULL.

Is it not shared_ptr and weak_ptr combo type soln?

I don't know.

OK. The pointer I want to observe say is of class A and class A
is singleton. the creation and destruction of A not managed by
different module (legacy). But my module (new) needs to use
some member functions of A. My module cannot manage A but is
dependent on A. During course of execution, there're chances
that A's object is recreated. And I need to be aware of it. Is
there a solution?

Yes and the solution is simple. Don't keep any pointers to the A
singleton. Every time you need to call a member-function on the
singleton object, get the pointer from the A::instance()
member-function.

Not quite clear as in my problem domain I need to know if A's
object is recreated or not. If recreated, I need to do something,
else not.

In that case, keep a pointer to the last instance of A that you used,
call A::instance() again and compare the pointers to see if they are the
same...