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

 

[Michael DOUBEZ]

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.

 

[Soumen]

Soumen a écrit :


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.


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.

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

 

[Michael DOUBEZ]

Soumen a écrit :

OK. The pointer I want to observe say is of class A and class A is
singleton.

I assume you mean a global.

the creation and destruction of A not managed by different module
(legacy).

I don't understand. You mean the module don't care that A can be replaced ?

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 assume you are un multithreaded environment, otherwise, there is no
problem (just check the pointer you have is the same as the singleton's).

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

If you can do it, it seems as good solution but hen, I don't know your
problem space.

An alternative (perhaps more clumsy) is to provide an observer pattern
that calls you if the singleton is replaced and then you can act
accordingly.

 

[Soumen]

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...


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]

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.