受到@offirmo回复的启发，我写了这段代码，然后运行visual studio诊断工具:

#include <iostream>
#include <vector>
#include <memory>

using namespace std;

struct Member;
struct Team;

struct Member {
    int x = 0;

    Member(int xArg) {
        x = xArg;
    }

    shared_ptr<Team> teamPointer;
};

struct Team {
    vector<shared_ptr<Member>> members;
};

void foo() {
    auto t1 = make_shared<Team>();
    for (int i = 0; i < 1000000; i++) {
        t1->members.push_back(make_shared<Member>(i));
        t1->members.back()->teamPointer = t1;
    }
}

int main() {
    foo();

    while (1);

    return 0;
}

当指向团队的成员指针是shared_ptr teamPointer时，在foo()完成后内存就没有空闲了，即它停留在150mb左右。

但是如果在诊断工具中将其更改为weak_ptr teamPointer，您将看到一个峰值，然后内存使用量恢复到大约2MB。

另一个答案，希望更简单。(对谷歌员工)

假设您有Team和Member对象。

显然，这是一个关系:Team对象将拥有指向其成员的指针。成员也可能有一个指向他们的Team对象的后向指针。

然后你就有了一个依赖循环。如果您使用shared_ptr，当您放弃对对象的引用时，对象将不再被自动释放，因为它们以循环的方式相互引用。这是内存泄漏。

您可以使用weak_ptr来打破这种情况。“所有者”通常使用shared_ptr，而“所有者”使用weak_ptr来访问父节点，并在需要访问父节点时临时将其转换为shared_ptr。

存储一个弱ptr:

weak_ptr<Parent> parentWeakPtr_ = parentSharedPtr; // automatic conversion to weak from shared

然后在需要的时候使用它

shared_ptr<Parent> tempParentSharedPtr = parentWeakPtr_.lock(); // on the stack, from the weak ptr
if( !tempParentSharedPtr ) {
  // yes, it may fail if the parent was freed since we stored weak_ptr
} else {
  // do stuff
}
// tempParentSharedPtr is released when it goes out of scope

共享指针有一个缺点: Shared_pointer不能处理父子周期依赖关系。如果父类使用父类的对象使用共享指针，则表示在同一文件中，如果子类使用父类的对象。共享指针将无法析构所有对象，甚至在循环依赖场景中共享指针根本不调用析构函数。基本上共享指针不支持引用计数机制。

我们可以使用weak_pointer来克服这个缺点。

当我们不想拥有对象时:

Ex:

class A
{
    shared_ptr<int> sPtr1;
    weak_ptr<int> wPtr1;
}

在上面的类中，wPtr1并不拥有wPtr1所指向的资源。如果资源被删除，那么wPtr1将过期。

避免循环依赖:

shard_ptr<A> <----| shared_ptr<B> <------
    ^             |          ^          |
    |             |          |          |
    |             |          |          |
    |             |          |          |
    |             |          |          |
class A           |     class B         |
    |             |          |          |
    |             ------------          |
    |                                   |
    -------------------------------------

现在如果我们创建类B和A的shared_ptr, both指针的use_count是2。

当shared_ptr超出作用域时，计数仍然保持1，因此A和B对象不会被删除。

class B;

class A
{
    shared_ptr<B> sP1; // use weak_ptr instead to avoid CD

public:
    A() {  cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }

    void setShared(shared_ptr<B>& p)
    {
        sP1 = p;
    }
};

class B
{
    shared_ptr<A> sP1;

public:
    B() {  cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }

    void setShared(shared_ptr<A>& p)
    {
        sP1 = p;
    }
};

int main()
{
    shared_ptr<A> aPtr(new A);
    shared_ptr<B> bPtr(new B);

    aPtr->setShared(bPtr);
    bPtr->setShared(aPtr);

    return 0;  
}

输出:

A()
B()

正如我们从输出中看到的，A和B指针永远不会被删除，从而导致内存泄漏。

为了避免这样的问题，只需在类A中使用weak_ptr而不是shared_ptr，这更有意义。

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

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

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

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

受到@offirmo回复的启发，我写了这段代码，然后运行visual studio诊断工具:

#include <iostream>
#include <vector>
#include <memory>

using namespace std;

struct Member;
struct Team;

struct Member {
    int x = 0;

    Member(int xArg) {
        x = xArg;
    }

    shared_ptr<Team> teamPointer;
};

struct Team {
    vector<shared_ptr<Member>> members;
};

void foo() {
    auto t1 = make_shared<Team>();
    for (int i = 0; i < 1000000; i++) {
        t1->members.push_back(make_shared<Member>(i));
        t1->members.back()->teamPointer = t1;
    }
}

int main() {
    foo();

    while (1);

    return 0;
}

当指向团队的成员指针是shared_ptr teamPointer时，在foo()完成后内存就没有空闲了，即它停留在150mb左右。

但是如果在诊断工具中将其更改为weak_ptr teamPointer，您将看到一个峰值，然后内存使用量恢复到大约2MB。