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

目录

 

shared_ptr指针存在的问题

循环引用示例

代码

运行结果

使用weak_ptr解决循环引用问题

代码

运行结果

---

shared_ptr指针存在的问题

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

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

对于这两种情况都可以使用weak_ptr指针处理。该类允许共享但不拥有对象。此类需要共享指针才能创建。每当拥有该对象的最后一个共享指针失去其所有权时，任何weak_ptr指针都会自动变为空。因此，除了default和copy构造函数外，weak_ptr指针仅提供采用shared_ptr的构造函数。

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

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

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

循环引用示例

代码

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

using namespace std;

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

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

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

shared_ptr<Person> initFamily (const string& sName)
{
    shared_ptr<Person> pMom(new Person(sName + "的母亲"));
    shared_ptr<Person> pDad(new Person(sName + "的父亲"));
    shared_ptr<Person> 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<Person> 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 <iostream>
#include <string>
#include <vector>
#include <memory>

using namespace std;

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

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

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

shared_ptr<Person> initFamily (const string& sName)
{
    shared_ptr<Person> pMom(new Person(sName + "的母亲"));
    shared_ptr<Person> pDad(new Person(sName + "的父亲"));
    shared_ptr<Person> 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<Person> 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指针，我们可以打破共享指针的循环，以便在一个方向上（从孩子到父母）使用共享指针，而从父母到孩子，则使用弱指针，如下图所示。

一旦我们失去对创建的家庭的句柄（通过为pPerson分配新值或通过离开main()函数），孩子的对象将失去其最后一个所有者（use_count()之前产生1），这又会使父母双方都失去了最后的所有者。 因此，最初由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()不一定有效。”