C++11 non-owning reference/pointer to unique_ptr?

Question

It's rather not a question "how to do it" it's rather "how to do it the right way"

I'm developing an editor in Qt where different widgets display the children and its (member) variables. Each of these widgets should hold a reference/pointer to the edited child to display and change their member variables.

The first attempt was the old ANSI C way I learned (and still kinda stuck in) with simple raw pointer to the used objects. It works fine but since the C++11 standard supports smart pointer and using them is recommended I'm trying to use them.

The problem is, I'm not quite sure what's the "best way" to use them in this case... After reading Smart Pointers: Or who owns you baby? and Which kind of pointer do I use when? and a few others I came to different conclusions:

The first is to use a*unique_ptr since the edited object is clearly the owner which creates and also deletes its children. The widgets are simply referring to the child to show or change them. The problem is how should the widgets refer to the child...

for now I'm simply still using a raw pointer I got with the get() method of the unique_ptr but this seems kinda flawed to me. I still can accidentaly call delete on the pointer and cancel the benefits of the smart pointer.

The second approach is to use a shared_ptr because many objects refer to the child and edit it. Also accidentaly deleting it in one widget would do no harm because it is still owned by other objects. The problem is they own it. When I want to delete it from the edited object I also have to signal all widgets to delete it before it is really gone. (this again seems flawed and error-prone)

I'm not really content with both ways. Is there a clean(er) way to point to the unique_ptr child of the object? Or am I missing a completely different and better approach to this problem?

Answer 1

Your use case doesn't translate directly to requirements (what if someone else deletes the widget while you're editing it?) but I'll assume you don't need anything beyond a naked pointer.

The Standard Library does not provide any strict pointer-observer class. Among observer entities:

• Nullable, mutable pointers of native type (T *)
• Non-nullable, non-mutable references of native type (T &)
• Non-nullable, mutable references/proxies of class type (std::reference_wrapper<T>)
• Nullable, self-validating, mutable pointers to managed objects (std::weak_ptr<T>)

If you want a non-nullable, mutable pointer to a non-managed object, which is a fairly reasonable thing to want, you can roll your own.

But naked pointers aren't that bad. The only difference is that it can be nullptr, and that it doesn't have a nice, long, explicit name inside namespace std.

Answer 2

You want to use a shared_ptr in place of your unique_ptr and weak_ptr's in place of your raw pointers. This will give exactly what you're after. The weak_ptr's will not interfere with the edited object's ability to delete the underlying object.