Shared_ptr:保存真实对象。

weak_ptr:使用lock连接到真正的所有者，否则返回NULL shared_ptr。

大致来说，weak_ptr角色类似于房屋中介的角色。如果没有中介，要想租到房子，我们可能得在城里随机找房子。中介会确保我们只去那些还能租到的房子。

Here's one example, given to me by @jleahy: Suppose you have a collection of tasks, executed asynchronously, and managed by an std::shared_ptr<Task>. You may want to do something with those tasks periodically, so a timer event may traverse a std::vector<std::weak_ptr<Task>> and give the tasks something to do. However, simultaneously a task may have concurrently decided that it is no longer needed and die. The timer can thus check whether the task is still alive by making a shared pointer from the weak pointer and using that shared pointer, provided it isn't null.

http://en.cppreference.com/w/cpp/memory/weak_ptr Std::weak_ptr是一个智能指针，它持有对Std::shared_ptr管理的对象的非所有(“弱”)引用。它必须转换为std::shared_ptr才能访问被引用的对象。

Std::weak_ptr建模临时所有权:当一个对象只有在它存在时才需要访问，并且它可能在任何时候被其他人删除时，Std::weak_ptr用于跟踪该对象，并将其转换为Std::shared_ptr以承担临时所有权。如果原始的std::shared_ptr在此时被销毁，对象的生命周期将被延长，直到临时的std::shared_ptr也被销毁。

此外，std::weak_ptr用于打破std::shared_ptr的循环引用。

缓存就是一个很好的例子。

对于最近访问的对象，您希望将它们保存在内存中，因此可以保留一个指向它们的强指针。定期扫描缓存，确定最近没有访问哪些对象。你不需要把它们保存在内存中，所以你去掉强指针。

但是，如果该对象正在使用，而其他一些代码持有指向它的强指针，该怎么办?如果缓存删除了指向该对象的唯一指针，就再也找不到它了。因此，缓存保留了一个弱指针，指向它需要找到的对象，如果它们碰巧留在内存中。

这正是弱指针所做的——它允许你在一个对象仍然在附近时定位它，但如果没有其他东西需要它，它就不会保留它。

Weak_ptr也可以很好地检查对象的正确删除——特别是在单元测试中。典型的用例可能是这样的:

std::weak_ptr<X> weak_x{ shared_x };
shared_x.reset();
BOOST_CHECK(weak_x.lock());
... //do something that should remove all other copies of shared_x and hence destroy x
BOOST_CHECK(!weak_x.lock());

我看到std::weak_ptr<T>作为std::shared_ptr<T>的句柄:它允许我 获取std::shared_ptr<T>(如果它仍然存在)，但是它不会扩展它的 一生。在以下几种情况下，这种观点是有用的:

// Some sort of image; very expensive to create.
std::shared_ptr< Texture > texture;

// A Widget should be able to quickly get a handle to a Texture. On the
// other hand, I don't want to keep Textures around just because a widget
// may need it.

struct Widget {
    std::weak_ptr< Texture > texture_handle;
    void render() {
        if (auto texture = texture_handle.get(); texture) {
            // do stuff with texture. Warning: `texture`
            // is now extending the lifetime because it
            // is a std::shared_ptr< Texture >.
        } else {
            // gracefully degrade; there's no texture.
        }
    }
};

另一个重要的场景是打破数据结构中的循环。

// Asking for trouble because a node owns the next node, and the next node owns
// the previous node: memory leak; no destructors automatically called.
struct Node {
    std::shared_ptr< Node > next;
    std::shared_ptr< Node > prev;
};

// Asking for trouble because a parent owns its children and children own their
// parents: memory leak; no destructors automatically called.
struct Node {
    std::shared_ptr< Node > parent;
    std::shared_ptr< Node > left_child;
    std::shared_ptr< Node > right_child;
};

// Better: break dependencies using a std::weak_ptr (but not best way to do it;
// see Herb Sutter's talk).
struct Node {
    std::shared_ptr< Node > next;
    std::weak_ptr< Node > prev;
};

// Better: break dependencies using a std::weak_ptr (but not best way to do it;
// see Herb Sutter's talk).
struct Node {
    std::weak_ptr< Node > parent;
    std::shared_ptr< Node > left_child;
    std::shared_ptr< Node > right_child;
};

赫布·萨特有一篇精彩的演讲，解释了语言的最佳使用 特性(在这种情况下是智能指针)，以确保默认情况下的泄漏自由 (意思是:所有的东西都是通过建设来实现的;你很难搞砸它 )。这是必看的节目。