Does it exist: smart pointer, owned by one object allowing access

I'm wondering if anyone's run across anything that exists which would fill this need.

Object A contains an object B. It wants to provide access to that B to clients through a pointer (maybe there's the option it could be 0, or maybe the clients need to be copiable and yet hold references...whatever). C开发者_StackOverflow中文版lients, lets call them object C, would normally, if we're perfect developers, be written carefully so as to not violate the lifetime semantics of any pointer to B they might have...but we're not perfect, in fact we're pretty dumb half the time.

So what we want is for object C to have a pointer to object B that is not "shared" ownership but that is smart enough to recognize a situation in which the pointer is no longer valid, such as when object A is destroyed or it destroys object B. Accessing this pointer when it's no longer valid would cause an assertion/exception/whatever.

In other words, I wish to share access to data in a safe, clear way but retain the original ownership semantics. Currently, because I've not been able to find any shared pointer in which one of the objects owns it, I've been using shared_ptr in place of having such a thing. But I want clear owneship and shared/weak pointer doesn't really provide that.

Would be nice further if this smart pointer could be attached to member variables and not just hold pointers to dynamically allocated memory regions.

If it doesn't exist I'm going to make it, so I first want to know if someone's already released something out there that does it.

And, BTW, I do realize that things like references and pointers do provide this sort of thing...I'm looking for something smarter.

boost::weak_ptr is what you are looking for. Maybe with some minor tweaks though, like prohibiting creation of shared_ptr from it. Also, this can hold anything, including pointer to memory that is not dynamically allocated.

The semantics you want is similar to Qt's QPointer. This is a pointer that can hold QObjects and nulls itself when the corresponding QObject is deleteed (ordinarily, eg. by operator delete).

However, similar approach has inherent problems - such that the client cannot be sure he isn't using a dangling pointer. eg.

QPointer<T> smart_ptr = original_obj;
T* tmp = smart_ptr; // this might be a function argument etc.

... // later
delete original_obj;

... // even later
tmp->do_something(); // CRASH

This can be avoided using some "hard" references that don't allow object deletion, which is exactly what shared_ptr/weak_ptr do.

BTW, AFAIK, shared_ptr can point to member variables, except it can't manage them. That is, you must provide a custom deleter that doesn't do anything.