目录
共享指针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 <typename T>
class weak_ptr
{
public:
typedef T element_type;
...
};
}
不能使用运算符*和->直接访问weak_ptr的引用对象。相反,必须从中创建一个共享指针。这有两个原因:
- 根据弱指针创建共享指针,以检查是否存在(仍然)关联对象。如果不是,此操作将引发异常或创建一个空的共享指针(实际发生的情况取决于所使用的操作)。
- 在处理引用的对象时,共享指针无法释放。
因此,弱指针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指针,可以打破共享指针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。在这种情况下,调用运算符*或->将导致未定义的行为。
如果不确定弱指针指向的对象是否仍然存在,则可以使用以下几种方法:
- 调用expired(),如果弱指针weak_ptr不再共享对象,则返回true。此选项等效于检查use_count()是否等于0,但可能更快。
- 通过使用相应的共享指针shared_ptr构造函数将弱指针weak_ptr显式转换为共享指针shared_ptr。如果没有有效的引用对象,则此构造方法将引发bad_weak_ptr异常。这个异常是从std::exception派生的类的异常,其中what()会返回“ bad_weak_ptr”。
- 调用use_count()来询问关联对象拥有的所有者数量。如果返回值为0,则不再有有效的对象。但是请注意,通常只应出于调试目的调用use_count(),因为C++标准库明确指出:“use_count()不一定有效。”
接口列表
下表为弱指针提供的所有操作。
操作 | 结果 |
weak_ptr<T> wp | 默认构造函数;创建一个空的弱指针 |
weak_ptr<T> wp(sp) | 创建一个弱指针,共享由sp拥有的指针的所有权 |
weak_ptr<T> 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()会返回一个共享指针,所以对象的使用计数在共享指针的生命周期内会增加。这是处理弱指针共享对象的唯一方法。