c++ weak_ptr

 weak_ptr

（1）weak_ptr指向一个shared_ptr指向的对象，且不会改变对象的引用计数。

（2）weak_ptr不控制所指对象的生命周期，不拥有所有权。

（3）不能调用->和解引用*

weak_ptr使用场景

 （1）A类中有一个需求需要存储其它A类的对象信息，如果使用shared_ptr，这样会造成循环依赖，所以我们需要使用一个不需要拥有所有权的指针来标记这个同类对象。

可以通过lock来提升为shared_ptr（类型装换）。

通过一个示例简单认识一下

int main() {

    shared_ptr<Person> s1 = make_shared<Person>();
    // weak_ptr是需要和shared_ptr一起来用的
    weak_ptr<Person> w1{ s1 };

    // 结果都是1 计数器不会增加
    cout << "s1->count=" << s1.use_count() << endl;
    cout << "w1->count=" << w1.use_count() << endl;
    // 结果都是2 lock将其提升为shared_ptr（类型装换）。计数器会增加
    shared_ptr<Person> s2 = w1.lock();
    cout << "s1->count=" << s1.use_count() << endl;
    cout << "w1->count=" << w1.use_count() << endl;
    cout << "s2->count=" << s2.use_count() << endl; 
    return 0;
}

结果：

 

 

 比如A类中有一个需求需要存储其它A类的对象信息，如果使用shared_ptr，这样会造成循环依赖，通过例子看一下：

 

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include<Windows.h>  
using namespace std;


//自定义数据类型
class Person {
public:
    Person(string name, int age) {
        mName = name;
        mAge = age;
    }

    Person();

    ~Person()
    {
        cout << mName << "调用析构函数" << endl;
    }

    void Set_Name(string name)
    {
        this->mName = name;
    }

    void Info()
    {
        std::cout << "name:" << this->mName << endl;
    }

    // 在这里定义一个unique_ptr的别名UniquePtr
    using UniquePtr = unique_ptr<Person>; 
    string mName;
    int mAge;
    void Set_Friend(shared_ptr<Person> s) {
        _friend = s;
    }

private: 
    shared_ptr<Person> _friend;
};

unique_ptr<Person> GetUniquePtr()
{
    unique_ptr<Person> u1 = make_unique<Person>();
    u1->Set_Name("测试");
    return u1;
}

int main() {

    shared_ptr<Person> s1 = make_shared<Person>();
    s1->mName = "s1";
    shared_ptr<Person> s2 = make_shared<Person>();
    s2->mName = "s2";
    shared_ptr<Person> s3 = make_shared<Person>();
    s3->mName = "s3";
    s2->Set_Friend(s3);
    s3->Set_Friend(s2);

    return 0;
}

Person::Person()
{
}

结果：

 

 就会发现s2,s3没有释放

我们通过weak_ptr来解决：

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include<Windows.h>  
using namespace std;


//自定义数据类型
class Person {
public:
    Person(string name, int age) {
        mName = name;
        mAge = age;
    }

    Person();

    ~Person()
    {
        cout << mName << "调用析构函数" << endl;
    }

    void Set_Name(string name)
    {
        this->mName = name;
    }

    void Info()
    {
        std::cout << "name:" << this->mName << endl;
    }

    // 在这里定义一个unique_ptr的别名UniquePtr
    using UniquePtr = unique_ptr<Person>; 
    string mName;
    int mAge;
    void Set_Friend(shared_ptr<Person> s) {
        _friend = s;
    }

private: 
    weak_ptr<Person> _friend;
};

unique_ptr<Person> GetUniquePtr()
{
    unique_ptr<Person> u1 = make_unique<Person>();
    u1->Set_Name("测试");
    return u1;
}

int main() {

    shared_ptr<Person> s1 = make_shared<Person>();
    s1->mName = "s1";
    shared_ptr<Person> s2 = make_shared<Person>();
    s2->mName = "s2";
    shared_ptr<Person> s3 = make_shared<Person>();
    s3->mName = "s3";
    s2->Set_Friend(s3);
    s3->Set_Friend(s2);

    return 0;
}

Person::Person()
{
}

 

 结果：

 

 

总结：shared_ptr在环形引用中，带来了循环引用的弊端，所以，需要将其中一个设置为弱引用（根据实际情况确定，一般将管理者使用shared_ptr，)weak_ptr。