c++11特新：弱引用智能指针
弱引用智能指针std::weak_ptr可以看做是shared_ptr的助手，它不管理shared_ptr内部的指针。std::weak_ptr没有重载操作符*和->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视shared_ptr中管理的资源是否存在。
1. 初始化
// 默认构造函数
constexpr weak_ptr() noexcept;
// 拷贝构造
weak_ptr (const weak_ptr& x) noexcept;
template weak_ptr (const weak_ptr& x) noexcept;
// 通过shared_ptr对象构造
template weak_ptr (const shared_ptr& x) noexcept;
在C++11中，weak_ptr的初始化可以通过以上提供的构造函数来完成初始化，具体使用方法如下：
#include
#include
using namespace std;
int main()
{
shared_ptr sp(new int);
weak_ptr wp1;
weak_ptr wp2(wp1);
weak_ptr wp3(sp);
weak_ptr wp4;
wp4 = sp;
weak_ptr wp5;
wp5 = wp3;
return 0;
}
1. weak_ptr
2. weak_ptr
3. weak_ptr
4. wp4 = sp;通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象（这是一个隐式类型转换）
5. wp5 = wp3;通过一个weak_ptr对象构造了一个可用的weak_ptr实例对象
2. 其他常用方法
2.1 use_count()：
通过调用std::weak_ptr类提供的use_count()方法可以获得当前所观测资源的引用计数，函数原型如下：
// 函数返回所监测的资源的引用计数
long int use_count() const noexcept;修改一下上面的测试程序，添加打印资源引用计数的代码：
#include
#include
using namespace std;
int main()
{
shared_ptr sp(new int);
weak_ptr wp1;
weak_ptr wp2(wp1);
weak_ptr wp3(sp);
weak_ptr wp4;
wp4 = sp;
weak_ptr wp5;
wp5 = wp3;
cout << "use_count: " << endl;
cout << "wp1: " << wp1.use_count() << endl;
cout << "wp2: " << wp2.use_count() << endl;
cout << "wp3: " << wp3.use_count() << endl;
cout << "wp4: " << wp4.use_count() << endl;
cout << "wp5: " << wp5.use_count() << endl;
return 0;
}
测试程序输出的结果为:
use_count:
wp1: 0
wp2: 0
wp3: 1
wp4: 1
wp5: 1通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
2.2 expired()：
通过调用std::weak_ptr类提供的expired()方法来判断观测的资源是否已经被释放，函数原型如下：
// 返回true表示资源已经被释放, 返回false表示资源没有被释放
bool expired() const noexcept;函数的使用方法如下:
#include
#include
using namespace std;
int main()
{
shared_ptr shared(new int(10));
weak_ptr weak(shared);
cout << "1. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;
shared.reset();
cout << "2. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;
return 0;
}
测试代码输出的结果:
1. weak is not expired
2. weak is expiredweak_ptr监测的就是shared_ptr管理的资源，当共享智能指针调用shared.reset();之后管理的资源被释放，因此weak.expired()函数的结果返回true，表示监测的资源已经不存在了。
2.3 lock()：
通过调用std::weak_ptr类提供的lock()方法来获取管理所监测资源的shared_ptr对象，函数原型如下：
shared_ptr lock() const noexcept; 函数的使用方法如下:
#include
#include
using namespace std;
int main()
{
shared_ptr sp1, sp2;
weak_ptr wp;
sp1 = std::make_shared(520);
wp = sp1;
sp2 = wp.lock();
cout << "use_count: " << wp.use_count() << endl;
sp1.reset();
cout << "use_count: " << wp.use_count() << endl;
sp1 = wp.lock();
cout << "use_count: " << wp.use_count() << endl;
cout << "*sp1: " << *sp1 << endl;
cout << "*sp2: " << *sp2 << endl;
return 0;
}
测试代码输出的结果为:
use_count: 2
use_count: 1
use_count: 2
*sp1: 520
*sp2: 5201. sp2 = wp.lock();通过调用lock()方法得到一个用于管理weak_ptr对象所监测的资源的共享智能指针对象，使用这个对象初始化sp2，此时所监测资源的引用计数为2
2. sp1.reset();共享智能指针sp1被重置，weak_ptr对象所监测的资源的引用计数减1
3. sp1 = wp.lock();sp1重新被初始化，并且管理的还是weak_ptr对象所监测的资源，因此引用计数加1
4. 共享智能指针对象sp1和sp2管理的是同一块内存，因此最终打印的内存中的结果是相同的，都是520
2.4 reset()：
通过调用std::weak_ptr类提供的reset()方法来清空对象，使其不监测任何资源，函数原型如下：
void reset() noexcept;函数的使用是非常简单的，示例代码如下：
#include
#include
using namespace std;
int main()
{
shared_ptr sp(new int(10));
weak_ptr wp(sp);
cout << "1. wp " << (wp.expired() ? "is" : "is not") << " expired" << endl;
wp.reset();
cout << "2. wp " << (wp.expired() ? "is" : "is not") << " expired" << endl;
return 0;
}
测试代码输出的结果为:
1. wp is not expired
2. wp is expiredweak_ptr对象sp被重置之后wp.reset();变成了空对象，不再监测任何资源，因此wp.expired()返回true
3. 返回管理this的shared_ptr
如果在一个类中编写了一个函数，通过这个得到管理当前对象的共享智能指针，我们可能会写出如下代码：
#include
#include
using namespace std;
/*
shared_ptr使用的注意事项：
1. 不能使用一个原始地址初始化多个共享指针
2. 函数不能返回管理了this的共享智能指针对象
3. 共享智能指针不能循环引用
*/
struct Test
{
shared_ptr getSharedPtr()
{
return shared_ptr(this);
}
~Test()
{
cout << "class Test is distruct..." << endl;
}
};
int main()
{
//Test* t = new Test;
//shared_ptr ptr1(t);
因为两个智能指针对象互相不知道对方存在，各自引用计数肯定都是1，
各自释放各自的,所以这种方式是错误的
shared_ptr ptr2(t);// error 注意事项1
//shared_ptr ptr2 = ptr1;
// sp1和sp2管理的是同一块内存，但是根据注意事项1所以该操作是不允许的
// 在析构的时候这块内存就会被析构两次
shared_ptr sp1(new Test);
cout << "use_count：" << sp1.use_count() << endl;
shared_ptr sp2 = sp1->getSharedPtr();// error
cout << "use_count：" << sp1.use_count() << endl;
} 执行上面的测试代码，运行中会出现异常，在终端还是能看到对应的日志输出：
use_count: 1
use_count: 1
class Test is disstruct ...
class Test is disstruct ...通过输出的结果可以看到一个对象被析构了两次，其原因是这样的：在这个例子中使用同一个指针this构造了两个智能指针对象sp1和sp2，这二者之间是没有任何关系的，因为sp2并不是通过sp1初始化得到的实例对象。在离开作用域之后this将被构造的两个智能指针各自析构，导致重复析构的错误。
这个问题可以通过weak_ptr来解决，通过wek_ptr返回管理this资源的共享智能指针对象shared_ptr。C++11中为我们提供了一个模板类叫做std::enable_shared_from_this
修改之后的代码为：
#include
#include
using namespace std;
/*
shared_ptr使用的注意事项：
1. 不能使用一个原始地址初始化多个共享指针
2. 函数不能返回管理了this的共享智能指针对象
3. 共享智能指针不能循环引用
*/
struct Test : public enable_shared_from_this
{
shared_ptr getSharedPtr()
{
return shared_from_this();
}
~Test()
{
cout << "class Test is disstruct ..." << endl;
}
};
int main()
{
//Test* t = new Test;
//shared_ptr ptr1(t);
因为两个智能指针对象互相不知道对方存在，各自引用计数肯定都是1，
各自释放各自的,所以这种方式是错误的
shared_ptr ptr2(t);// error 注意事项1
//shared_ptr ptr2 = ptr1;
// sp1和sp2管理的是同一块内存，但是根据注意事项1所以该操作是不允许的
// 在析构的时候这块内存就会被析构两次
shared_ptr sp1(new Test);
cout << "use_count：" << sp1.use_count() << endl;
shared_ptr sp2 = sp1->getSharedPtr();
cout << "use_count：" << sp1.use_count() << endl;
} 测试代码输出的结果为:
use_count: 1
use_count: 2
class Test is disstruct ...这样就对了，引用计数为2，且只析构了一次。
最后需要强调一个细节：在调用enable_shared_from_this类的shared_from_this()方法之前，必须要先初始化函数内部weak_ptr对象，否则该函数无法返回一个有效的shared_ptr对象（具体处理方法可以参考上面的示例代码）。
过程：初始化发生在shared_ptr
4. 解决循环引用问题
智能指针如果循环引用会导致内存泄露，比如下面的例子：
#include
#include
using namespace std;
struct TA;
struct TB;
struct TA
{
shared_ptr bptr;
~TA()
{
cout << "class TA is disstruct ..." << endl;
}
};
struct TB
{
shared_ptr aptr;
~TB()
{
cout << "class TB is disstruct ..." << endl;
}
};
void testPtr()
{
shared_ptr ap(new TA);
shared_ptr bp(new TB);
cout << "TA object use_count: " << ap.use_count() << endl;
cout << "TB object use_count: " << bp.use_count() << endl;
ap->bptr = bp;
bp->aptr = ap;
cout << "TA object use_count: " << ap.use_count() << endl;
cout << "TB object use_count: " << bp.use_count() << endl;
}
int main()
{
testPtr();
return 0;
}
测试程序输出的结果如下:
TA object use_count: 1
TB object use_count: 1
TA object use_count: 2
TB object use_count: 2
在测试程序中，共享智能指针ap、bp对TA、TB实例对象的引用计数变为2，在共享智能指针离开作用域之后引用计数只能减为1，这种情况下不会去删除智能指针管理的内存，导致类TA、TB的实例对象不能被析构，最终造成内存泄露。通过使用weak_ptr可以解决这个问题，只要将类TA或者TB的任意一个成员改为weak_ptr，修改之后的代码如下：
#include
#include
using namespace std;
struct TA;
struct TB;
struct TA
{
weak_ptr bptr;
~TA()
{
cout << "class TA is disstruct ..." << endl;
}
};
struct TB
{
shared_ptr aptr;
~TB()
{
cout << "class TB is disstruct ..." << endl;
}
};
void testPtr()
{
shared_ptr ap(new TA);
shared_ptr bp(new TB);
cout << "TA object use_count: " << ap.use_count() << endl;
cout << "TB object use_count: " << bp.use_count() << endl;
ap->bptr = bp;
bp->aptr = ap;
cout << "TA object use_count: " << ap.use_count() << endl;
cout << "TB object use_count: " << bp.use_count() << endl;
}
int main()
{
testPtr();
return 0;
}
测试程序输出的结果如下:
TA object use_count: 1
TB object use_count: 1
TA object use_count: 2
TB object use_count: 1
class TB is disstruct ...
class TA is disstruct ...
通过输出的结果可以看到类TA或者TB的对象被成功析构了。
上面程序中，在对类TA成员赋值时ap->bptr = bp;由于bptr是weak_ptr类型，这个赋值操作并不会增加引用计数，所以bp的引用计数仍然为1，在离开作用域之后bp的引用计数减为0，类TB的实例对象被析构。
在类TB的实例对象被析构的时候，内部的aptr也被析构，其对TA对象的管理解除，内存的引用计数减为1，当共享智能指针ap离开作用域之后，对TA对象的管理也解除了，内存的引用计数减为0，类TA的实例对象被析构。
本文章参考：弱引用智能指针 | 爱编程的大丙 (subingwen.cn)