C++智能指针3——弱指针weak_ptr详解

目录

 

shared_ptr指针存在的问题

循环引用示例

代码

运行结果

使用weak_ptr解决循环引用问题

代码

运行结果

---

共享指针shared_ptr指针存在的问题

使用共享指针shared_ptr指针的主要原因是避免手动管理指针所关联的资源。但是，在某些情况下共享指针shared_ptr不能实现预期的行为：

• 一种情况是循环引用。如果两个对象使用shared_ptr指针相互引用，并且不存在对这些对象的其他引用，若要释放这些对象及其关联的资源，则共享指针shared_ptr不会释放数据，因为每个对象的引用计数仍为1。在这种情况下，可能想使用普通的指针，但是这样做需要手动管理相关资源的释放。
• 另一种情况是当明确想要共享但不拥有对象。这种情况下引用的生存期超过了它所引用的对象的生命周期。如果使用共享指针shared_ptr指针则其将永远不会释放对象。如果使用普通指针则可能出现指针所引用的对象不再有效，这会带来访问已释放数据的风险。

对于这两种情况都可以使用弱指针weak_ptr指针处理。弱指针weak_ptr是共享指针shared_ptr的辅助类。该类允许共享但不拥有对象。它的use_count()返回对象的共享指针shared_ptr拥有者数量，共享该对象的弱指针weak_ptr指针不计入该数量。

弱指针weak_ptr需要共享指针shared_ptr才能创建。每当拥有该对象的最后一个共享指针失去其所有权时，任何弱指针weak_ptr都会自动变为空。因此，除了default和copy构造函数外，弱指针weak_ptr指针仅提供采用共享指针shared_ptr的构造函数。

使用初始指针所指对象的类型来对weak_ptr<>类进行模板化：

namespace std {
    template 
    class weak_ptr
    {
        public:
            typedef T element_type;
            ...
    };
}

不能使用运算符*和->直接访问weak_ptr的引用对象。相反，必须从中创建一个共享指针。这有两个原因：

1. 根据弱指针创建共享指针，以检查是否存在（仍然）关联对象。如果不是，此操作将引发异常或创建一个空的共享指针（实际发生的情况取决于所使用的操作）。
2. 在处理引用的对象时，共享指针无法释放。

因此，弱指针weak_ptr仅提供少量操作：足以创建，复制和赋值一个弱指针，并将其转换为共享指针或检查它是否指向对象。

循环引用示例

代码

#include 
#include 
#include 
#include 

using namespace std;

class Person {
  public:
    string m_sName;
    shared_ptr m_pMother;
    shared_ptr m_pFather;
    vector> m_oKids;

    Person (const string& sName,
            shared_ptr pMother = nullptr,
            shared_ptr pFather = nullptr)
     : m_sName(sName), m_pMother(pMother), m_pFather(pFather) {
    }

    ~Person() {
      cout << "删除 " << m_sName << endl;
    }
};

shared_ptr initFamily (const string& sName)
{
    shared_ptr pMom(new Person(sName + "的母亲"));
    shared_ptr pDad(new Person(sName + "的父亲"));
    shared_ptr pKid(new Person(sName, pMom, pDad));
    pMom->m_oKids.push_back(pKid);
    pDad->m_oKids.push_back(pKid);
    return pKid;
}

int main()
{
    string sName = "张三";
    shared_ptr pPerson = initFamily(sName);

    cout << sName << "家存在" << endl;
    cout << "- " << sName << "被分享" << pPerson.use_count() << "次" << endl;
    cout << "- " << sName << "母亲第一个孩子的名字是："
         << pPerson->m_pMother->m_oKids[0]->m_sName << endl;

    sName = "李四";
    pPerson = initFamily(sName);
    cout << sName << "家已存在" << endl;
}

运行结果

张三家存在
- 张三被分享3次
- 张三母亲第一个孩子的名字是：张三
李四家已存在

以上代码中一个类Person具有名称和对其他Person的可选引用，即父母（母亲和父亲）和孩子。

首先，initFamily()创建三个Person对象：pMom，pDad和pKid，并根据传递的参数使用相应的名称进行初始化。另外，将孩子与父母一起初始化，并且对于两个父母，将孩子插入父母对象的孩子列表中。最后，initFamily()返回孩子对象的共享指针shared_ptr。

下图显示了initFamily()末尾以及调用并将结果赋给pPerson之后的结果情况。

pPerson是家庭的最后一个句柄。但是，在内部，每个对象都有从孩子到每个父对象的引用。例如，在pPerson获得新值之前，张三被共享了3次。现在，如果我们释放该家族的最后一个句柄（通过为pPerson分配一个新的Person对象或nullptr），则不会释放任何Person对象，因为每个Person对象仍然至少具有一个共享的指针指向它。结果，每个Person对象的析构函数（将显示“删除名称”）都不会被调用。

使用weak_ptr解决循环引用问题

代码

#include 
#include 
#include 
#include 

using namespace std;

class Person {
  public:
    string m_sName;
    shared_ptr m_pMother;
    shared_ptr m_pFather;
    vector> m_oKids; //弱指针

    Person (const string& sName,
            shared_ptr pMother = nullptr,
            shared_ptr pFather = nullptr)
     : m_sName(sName), m_pMother(pMother), m_pFather(pFather) {
    }

    ~Person() {
      cout << "删除 " << m_sName << endl;
    }
};

shared_ptr initFamily (const string& sName)
{
    shared_ptr pMom(new Person(sName + "的母亲"));
    shared_ptr pDad(new Person(sName + "的父亲"));
    shared_ptr pKid(new Person(sName, pMom, pDad));
    pMom->m_oKids.push_back(pKid);
    pDad->m_oKids.push_back(pKid);
    return pKid;
}

int main()
{
    string sName = "张三";
    shared_ptr pPerson = initFamily(sName);

    cout << sName << "家存在" << endl;
    cout << "- " << sName << "被分享" << pPerson.use_count() << "次" << endl;
    cout << "- " << sName << "母亲第一个孩子的名字是："
         << pPerson->m_pMother->m_oKids[0].lock()->m_sName << endl;

    sName = "李四";
    pPerson = initFamily(sName);
    cout << sName << "家已存在" << endl;
}

运行结果

张三家存在
- 张三被分享1次
- 张三母亲第一个孩子的名字是：张三
删除 张三
删除 张三的父亲
删除 张三的母亲
李四家已存在
删除 李四
删除 李四的父亲
删除 李四的母亲

通过将vector中的共享指针shared_ptr指针换成弱指针weak_ptr指针，可以打破共享指针shared_ptr的循环，以便在一个方向上（从孩子到父母）使用共享指针，而从父母到孩子，则使用弱指针，如下图所示。

一旦失去对创建的家庭的句柄（通过为pPerson分配新值或通过离开main()函数），孩子的对象将失去其最后一个所有者，这又会使父母双方都失去了最后的所有者。因此，最初由new创建的所有对象现在都将被删除，以便调用它们的析构函数。

请注意，要使用弱指针，必须稍微修改通过弱指针访问对象的方式。需要在表达式中插入lock()函数如下所示

pPerson->mother->kids[0].lock()->name

而不是调用

pPerson->mother->kids[0]->name

lock()函数从kids的向量所包含的弱指针weak_ptr中产生一个共享指针shared_ptr。如果无法进行此修改（例如，由于该对象的最后所有者同时释放了该对象），则lock()函数会生成一个空的shared_ptr。在这种情况下，调用运算符*或->将导致未定义的行为。

如果不确定弱指针指向的对象是否仍然存在，则可以使用以下几种方法：

1. 调用expired()，如果弱指针weak_ptr不再共享对象，则返回true。此选项等效于检查use_count()是否等于0，但可能更快。
2. 通过使用相应的共享指针shared_ptr构造函数将弱指针weak_ptr显式转换为共享指针shared_ptr。如果没有有效的引用对象，则此构造方法将引发bad_weak_ptr异常。这个异常是从std::exception派生的类的异常，其中what()会返回“ bad_weak_ptr”。
3. 调用use_count()来询问关联对象拥有的所有者数量。如果返回值为0，则不再有有效的对象。但是请注意，通常只应出于调试目的调用use_count()，因为C++标准库明确指出：“use_count()不一定有效。”

接口列表

下表为弱指针提供的所有操作。

操作	结果
weak_ptr wp	默认构造函数；创建一个空的弱指针
weak_ptr wp(sp)	创建一个弱指针，共享由sp拥有的指针的所有权
weak_ptr wp(wp2)	创建一个弱指针，共享由wp2拥有的指针的所有权
wp.~weak_ptr()	析构函数；销毁弱指针，但对拥有的对象无效
wp = wp2	赋值（wp之后共享wp2的所有权，放弃先前拥有的对象的所有权）
wp = sp	用共享指针sp进行赋值（wp之后共享sp的所有权，放弃先前拥有的对象的所有权）
wp.swap(wp2)	交换wp和wp2的指针
swap(wp1,wp2)	交换wp1和wp2的指针
wp.reset()	放弃拥有对象的所有权（如果有的话），并重新初始化为空的弱指针
wp.use_count()	返回共享所有者的数量（拥有对象的shared_ptr数目）；如果弱指针为空，则返回0
wp.expired()	返回wp是否为空（等同于wp.use_count() == 0，但可能更快）
wp.lock()	返回共享指针，该共享指针共享弱指针拥有的指针的所有权（如果没有共享指针，则为空共享指针）
wp.owner_before(wp2)	提供严格的弱排序和另一个弱指针
wp.owner_before(sp)	通过共享指针提供严格的弱排序

构造函数创建一个空的弱指针，调用它的expired()会返回true。因为lock()会返回一个共享指针，所以对象的使用计数在共享指针的生命周期内会增加。这是处理弱指针共享对象的唯一方法。