C++2.0新特性(七)——<Smart Pointer(智能指针)之weak_ptr>

一、weak_ptr出现的意义

　　上一节提到过shared_ptr，它会自动释放“不再需要使用的对象”的相应的资源，但是它不是万能的，在某些时候(比如说循环引用)，它会显得力不从心，这就是weak_ptr出现的意义；

1.1 weak_ptr 使用特性

　　weak_ptr也是一个模板，只提供能接受一个shared_ptr的构造函数或者另一个weak_ptr的赋值，也就是说不能直接用它定义一个智能指针对象，它是为了搭配shared_ptr使用的，weak_ptr提供lock、swap、reset、expired、operator=、use_count等函数，相对shared_ptr多了lock、expired函数，却少了get函数，也不支持operator* 和 operator->

二、weak_ptr使用测试

2.1 以下例子在shared_ptr循环引用时的弊端

#include <iostream>
#include <string>
#include <vector>
#include <memory>
using namespace std;

class Person {
public:
    string name;
    shared_ptr<Person> mother;
    shared_ptr<Person> father;
    vector<shared_ptr<Person>> kids;

    Person(const string& n,
        shared_ptr<Person> m = nullptr,
        shared_ptr<Person> f = nullptr)
        : name(n), mother(m), father(f) {
    }

    ~Person() {
        cout << "delete " << name << endl;
    }
};

shared_ptr<Person> initFamily(const string& name)
{
    shared_ptr<Person> mom(new Person(name + "'s mom"));
    shared_ptr<Person> dad(new Person(name + "'s dad"));
    shared_ptr<Person> kid(new Person(name, mom, dad));
    //以下是为了统计引用次数
    cout << "1 mom is shared " << mom.use_count() << " times" << endl;
    cout << "1 dad is shared " << dad.use_count() << " times" << endl;
    cout << "1 kid is shared " << kid.use_count() << " times" << endl;
    mom->kids.push_back(kid);
    dad->kids.push_back(kid);
    cout << "mom is shared " << mom.use_count() << " times" << endl;
    cout << "dad is shared " << dad.use_count() << " times" << endl;
    cout << "kid is shared " << kid.use_count() << " times" << endl;
    return kid;
}

int main()
{
    shared_ptr<Person> p = initFamily("nico");

    cout << "nico's family exists" << endl;
    cout << "- nico is shared " << p.use_count() << " times" << endl;
    cout << "- name of 1st kid of nico's mom: "
        << p->mother->kids[0]->name << endl;

    p = initFamily("jim");
    cout << "jim's family exists" << endl;
}

 　　上述例子解释：首先我们initFamily函数建立Person：mom 、dad和kid，根据传入的实参将所有姓名初始化，并且还将kid插入到其父母的容器中，最终initFamily函数返回kid并赋值给p，p其实指向上述家庭的最后一个handle，因此在p被赋值之前nico共被共享3次，现在如果我们释放这个p（释放方式：（1）给p指向一个新的person或者赋值为nullptr;（2）main()函数结束时离开p的作用域），但是我们看到程序输出的结果是没有任何person被释放（没有执行析构函数），因为他们都至少被一个shared_ptr指向，于是析构函数都无法执行，这就是循环指向的问题。

　　如下是引入weak_ptr来解决循环指向的问题：我们可以把kid申明为一个类型为weak_ptr类型的vector。

#include <iostream>
#include <string>
#include <vector>
#include <memory>
using namespace std;

class Person {
public:
    string name;
    shared_ptr<Person> mother;
    shared_ptr<Person> father;
    vector<weak_ptr<Person>> kids;  // weak pointer !!!

    Person(const string& n,
        shared_ptr<Person> m = nullptr,
        shared_ptr<Person> f = nullptr)
        : name(n), mother(m), father(f) {
    }

    ~Person() {
        cout << "delete " << name << endl;
    }
};

shared_ptr<Person> initFamily(const string& name)
{
    shared_ptr<Person> mom(new Person(name + "'s mom"));
    shared_ptr<Person> dad(new Person(name + "'s dad"));
    shared_ptr<Person> kid(new Person(name, mom, dad));
    //以下是为了统计引用次数
    cout << "1 mom is shared " << mom.use_count() << " times" << endl;
    cout << "1 dad is shared " << dad.use_count() << " times" << endl;
    cout << "1 kid is shared " << kid.use_count() << " times" << endl;
    mom->kids.push_back(kid);
    dad->kids.push_back(kid);
    cout << "mom is shared " << mom.use_count() << " times" << endl;
    cout << "dad is shared " << dad.use_count() << " times" << endl;
    cout << "kid is shared " << kid.use_count() << " times" << endl;
    return kid;
}

int main()
{
    shared_ptr<Person> p = initFamily("nico");

    cout << "nico's family exists" << endl;
    cout << "- nico is shared " << p.use_count() << " times" << endl;
    cout << "- name of 1st kid of nico's mom: "
        << p->mother->kids[0].lock()->name << endl;
//上述使用了lock函数，lock函数来获取其对应的shared_ptr对象,下面详细解释

    p = initFamily("jim");
    cout << "jim's family exists" << endl;
}

 　　上述解析：关键就在于使用的weak_ptr相比于shared_ptr，没有增加kid的引用计数，所以再最后离开main作用域后能准确调用析构函数，上面例子重要的函数时lock，我们可以将mon（shared_ptr）指针直接赋值给weak_ptr（反之不行），其实weak_ptr 最重要的函数只有lock和expired两个函数，因为weak_ptr本身不会增加引用计数，所以当我们要使用时就要用lock函数，lock()会产生出一个shared_ptr（也就说使用之前必须复制到 shared_ptr）进而像普通指针一样使用。

　　关键函数解析：

• operator=

void operator=(std::weak_ptr<T> desired) noexcept;为weak_ptr赋值，weak_ptr接受shared_ptr类型的变量赋值，但是反过来是行不通的，需要使用lock函数。

• reset

void reset() noexcept；释放被管理对象的所有权。调用后 *this 不管理对象。

• swap

void swap( weak_ptr& r ) noexcept;交换 *this 与 r 的内容。

• use_count

long use_count() const noexcept；返回共享被管理对象所有权的 shared_ptr 实例数量，或 ​0​ ，若被管理对象已被删除，即 *this 为空。

• expired

bool expired() const noexcept;检查被引用的对象是否已删除,等价于 use_count() == 0，但是比use_count快,若被管理对象已被删除则为 true ，否则为 false 。由于不知道对象是否已经被析构，最好使用之前先使用expired函数检测一下。

• lock

std::shared_ptr<T> lock() const noexcept;创建新的 std::shared_ptr 对象，它共享被管理对象的所有权。若无被管理对象，即 *this 为空，则返回亦为空的 shared_ptr ,等效地返回 expired() ? shared_ptr<T>() : shared_ptr<T>(*this) ，原子地执行。

2.2 常见成员函数以及分类介绍