用于将weak_ptr应用于unique_ptr的内容

Question

I'm trying to understand the unique_ptr , shared_ptr , and weak_ptr that came in with c++11.

I've heard that weak_ptr 's would be nice for things like caching, and breaking cycles, and so on. I've heard that they work well with shared_ptrs .

But in this regard, what's the difference between shared_ptrs and unique_ptrs ? Why does weak_ptr only get to be used with one and not the other? Why wouldn't I want to have a weak reference to something owned by someone else?

Answer 1

A weak_ptr is technically a means to hang on to the reference counter of a set of shared_ptr s that manage some shared object. When the last shared_ptr is destroyed the object is destroyed, but its reference counter lives on as long as there are weak_ptr s to it. Thus via any still exising weak_ptr you can check whether the object still exists, or has been destroyed.

If it still exists then from the weak_ptr you can obtain a shared_ptr that lets you reference the object.

The main usage of this is to break cycles.

In particular, an object can contain a weak_ptr holding on to its own reference counter, which allows you to obtain a shared_ptr to the object from the object itself. That is, a shared_ptr that uses the same reference counter as other shared_ptr s to this object. Which is how enable_shared_from_this works.

unique_ptr doesn't have any reference counter, so it doesn't make sense to hang on to that non-existent reference counter.

Answer 2

The major point of a weak pointer is that you can try to make the pointer strong, that is owning:

auto strongPtr = weakPtr.lock();

if (strongPtr)
{
    // still existed, now have another reference to the resource
}
else
{
    // didn't still exist
}

Note the first path: making a weak pointer stronger requires we take ownership of the object .

This is why it doesn't make sense with unique_ptr : the only way to make the weak pointer strong is to take the resource from somewhere else, and for unique_ptr that would mean leaving that somewhere else with an unexpected null pointer. shared_ptr gets a pass because taking it really means sharing it.

Answer 3

I'm new to C++11 as well, so if someone knows better I would appreciate any corrections.

I think that there wouldn't be much of a reason to, otherwise, you'd use a shared_ptr since it would defeat the whole purpose of a unique_ptr . A unique_ptr has implied semantics that it has complete control over the object to which it points.