## weak_ptr
### 头文件: `"boost/weak_ptr.hpp"`
`weak_ptr` 是 `shared_ptr` 的观察员。它不会干扰`shared_ptr`所共享的所有权。当一个被`weak_ptr`所观察的 `shared_ptr` 要释放它的资源时，它会把相关的 `weak_ptr`的指针设为空。这防止了 `weak_ptr` 持有悬空的指针。你为什么会需要 `weak_ptr`? 许多情况下，你需要旁观或使用一个共享资源，但不接受所有权，如为了防止递归的依赖关系，你就要旁观一个共享资源而不能拥有所有权，或者为了避免悬空指针。可以从一个`weak_ptr`构造一个`shared_ptr`，从而取得对共享资源的访问权。
以下是 `weak_ptr`的部分定义，列出并简要介绍了最重要的函数。
```
namespace boost {
template<typename T> class weak_ptr {
public:
template <typename Y>
weak_ptr(const shared_ptr<Y>& r);
weak_ptr(const weak_ptr& r);
~weak_ptr();
T* get() const;
bool expired() const;
shared_ptr<T> lock() const;
};
}
```
### 成员函数
```
template <typename Y> weak_ptr(const shared_ptr<Y>& r);
```
这个构造函数从一个`shared_ptr`创建 `weak_ptr` ，要求可以从 `Y*` 隐式转换为 `T*`. 新的 `weak_ptr` 被配置为旁观 `r`所引向的资源。`r`的引用计数不会有所改变。这意味着`r`所引向的资源在被删除时不会理睬是否有`weak_ptr` 引向它。这个构造函数不会抛出异常。
```
weak_ptr(const weak_ptr& r);
```
这个复制构造函数让新建的 `weak_ptr` 旁观与`weak_ptr r`<small class="calibre23">相关的shared_ptr</small>所引向的资源。<small class="calibre23">shared_ptr</small>的引用计数保持不变。这个构造函数不会抛出异常。
```
~weak_ptr();
```
`weak_ptr` 的析构函数，和构造函数一样，它不改变引用计数。如果需要，析构函数会把 `*this` 与共享资源脱离开。这个析构函数不会抛出异常。
```
bool expired() const;
```
如果所观察的资源已经"过期"，即资源已被释放，则返回 `True` 。如果保存的指针为非空，`expired` 返回 `false`. 这个函数不会抛出异常。
```
shared_ptr<T> lock() const
```
返回一个引向`weak_ptr`所观察的资源的 `shared_ptr` ，如果可以的话。如果没有这样指针(即 `weak_ptr` 引向的是空指针)，`shared_ptr` 也将引向空指针。否则，`shared_ptr`所引向的资源的引用计数将正常地递增。这个函数不会抛出异常。
### 用法
我们从一个示范`weak_ptr`的基本用法的例子开始，尤其要看看它是如何不影响引用计数的。这个例子里也包含了 `shared_ptr`，因为 `weak_ptr` 总是需要和 `shared_ptr`一起使用的。使用 `weak_ptr` 要包含头文件 `"boost/weak_ptr.hpp"`.
```
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
#include <iostream>
#include <cassert>
class A {};
int main() {
boost::weak_ptr<A> w;
assert(w.expired());
{
boost::shared_ptr<A> p(new A());
assert(p.use_count()==1);
w=p;
assert(p.use_count()==w.use_count());
assert(p.use_count()==1);
// 从weak_ptr创建shared_ptr
boost::shared_ptr<A> p2(w);
assert(p2==p);
}
assert(w.expired());
boost::shared_ptr<A> p3=w.lock();
assert(!p3);
}
```
`weak_ptr w` 被缺省构造，意味着它初始时不旁观任何资源。要检测一个 `weak_ptr` 是否在旁观一个活的对象，你可以使用函数 `expired`. 要开始旁观，`weak_ptr` 必须要被赋值一个 `shared_ptr`. 本例中，`shared_ptr p` 被赋值给 `weak_ptr w`, 这等于说`p` 和 `w` 的引用计数应该是相同的。然后，再从`weak_ptr`构造一个`shared_ptr`，这是一种从`weak_ptr`那里获得对共享资源的访问权的方法。如果在构造`shared_ptr`时，`weak_ptr` 已经过期了，将从`shared_ptr`的构造函数里抛出一个 `boost::bad_weak_ptr` 类型的异常。再继续，当 `shared_ptr p` 离开作用域，`w` 就变成过期的了。当调用它的成员函数 `lock` 来获得一个`shared_ptr`时，这是另一种获得对共享资源访问权的方法，将返回一个空的 `shared_ptr` 。注意，从这个程序的开始到结束，`weak_ptr` 都没有影响到共享对象的引用计数的值。
与其它智能指针不同的是，`weak_ptr` 不对它所观察的指针提供重载的 `operator*` 和 `operator->`. 原因是对`weak_ptr`所观察的资源的任何操作都必须是明显的，这样才安全；由于不会影响它们所观察的共享资源的引用计数器，所以真的很容易就会不小心访问到一个无效的指针。这就是为什么你必须要传送 `weak_ptr` 给 `shared_ptr`的构造函数，或者通过调用`weak_ptr::lock`来获得一个 `shared_ptr` 。这两种方法都会使引用计数增加，这样在 `shared_ptr` 从 `weak_ptr`创建以后，它可以保证共享资源的生存，确保在我们要使用它的时候它不会被释放掉。
### 常见问题
由于在智能指针中保存的是指针的值而不是它们所指向的指针的值，因此在标准库容器中使用智能指针有一个常见的问题，就是如何在算法中使用智能指针；算法通常需要访问实际对象的值，而不是它们的地址。例如，你如何调用 `std::sort` 并正确地排序？实际上，这个问题与在容器中保存并操作普通指针是几乎一样的，但事实很容易被忽略(可能是由于我们总是避免在容器中保存裸指针)。当然我们 不能直接比较两个智能指针的值，但也很容易解决。只要用一个解引用智能指针的谓词就可以了，所以我们将创建一个可重用的谓词，使得可以在标准库的算法里使 用引向智能指针的迭代器，这里我们选用的智能指针是 `weak_ptr`。
```
#include <functional>
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
template <typename Func, typename T>
struct weak_ptr_unary_t :
public std::unary_function<boost::weak_ptr<T>,bool> {
T t_;
Func func_;
weak_ptr_unary_t(const Func& func,const T& t)
: t_(t),func_(func) {}
bool operator()(boost::weak_ptr<T> arg) const {
boost::shared_ptr<T> sp=arg.lock();
if (!sp) {
return false;
}
return func_(*sp,t_);
}
};
template <typename Func, typename T> weak_ptr_unary_t<Func,T>
weak_ptr_unary(const Func& func, const T& value) {
return weak_ptr_unary_t<Func,T>(func,value);
}
```
`weak_ptr_unary_t` 函数对象对要调用的函数以及函数所用的参数类型进行了参数化。把要调用的函数保存在函数对象中使用使得这个函数对象很容易使用，很快我们就能看到这一点。为了使这个谓词兼容于标准库的适配器，`weak_ptr_unary_t` 要从 `std::unary_function`派生，后者保证了所有需要的 `typedefs` 都能提供(这些要求是为了让标准库的适配器可以这些函数对象一起工作)。实际的工作在调用操作符函数中完成，从`weak_ptr`创建一个 `shared_ptr` 。必须要确保在函数调用时资源是可用的。然后才可以调用指定的函数(或函数对象)，传入本次调用的参数(要解引用以获得真正的资源) 和在对象中保存的值，这个值是在构造`weak_ptr_unary_t`时给定的。这个简单的函数对象现在可以用于任意可用的算法了。为方便起见，我们还定义了一个助手函数，`weak_ptr_unary`, 它可以推出参数的类型并返回一个适当的函数对象\[14\]。我们来看看如何使用它。
> \[14\] 要使得这个类型更通用，还需要更多的设计。
```
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
int main() {
using std::string;
using std::vector;
using boost::shared_ptr;
using boost::weak_ptr;
vector<weak_ptr<string> > vec;
shared_ptr<string> sp1(
new string("An example"));
shared_ptr<string> sp2(
new string("of using"));
shared_ptr<string> sp3(
new string("smart pointers and predicates"));
vec.push_back(weak_ptr<string>(sp1));
vec.push_back(weak_ptr<string>(sp2));
vec.push_back(weak_ptr<string>(sp3));
vector<weak_ptr<string> >::iterator
it=std::find_if(vec.begin(),vec.end(),
weak_ptr_unary(std::equal_to<string>(),string("of using")));
if (it!=vec.end()) {
shared_ptr<string> sp(*++it);
std::cout << *sp << '\n';
}
}
```
本例中，创建了一个包含`weak_ptr`的 `vector`。最有趣的一行代码(是的，它有点长)就是我们为使用`find_if`算法而创建`weak_ptr_unary_t`的那行。
```
vector<weak_ptr<string> >::iterator it=std::find_if(
vec.begin(),
vec.end(),
weak_ptr_unary(
std::equal_to<string>(),string("of using")));
```
通过把另一个函数对象，`std::equal_to`, 和一个用于匹配的`string`一起传给助手函数`weak_ptr_unary`，创建了一个新的函数对象。由于 `weak_ptr_unary_t` 完全兼容于各种适配器(由于它是从`std::unary_function`派生而来的)，我们可以再从它组合出各种各样的函数对象。例如，我们也可以查找第一个不匹配`"of using"`的串：
```
vector<weak_ptr<string> >::iterator it=std::find_if(
vec.begin(),
vec.end(),
std::not1(
weak_ptr_unary(
std::equal_to<string>(),string("of using"))));
```
Boost智能指针是专门为了与标准库配合工作而设计的。我们可以创建有用的组件来帮助我们可以更简单地使用这些强大的智能指针。象 `weak_ptr_unary` 这样的工具并不是经常要用到的；有一个库提供了比`weak_ptr_unary`更好用的泛型绑定器\[15\]。弄懂这些智能指针的语义，可以让我们更清楚地使用它们。
> <a>[15] 指Boost.Bind库。
### 两种从weak_ptr创建shared_ptr的惯用法
如你所见，如果你有一个旁观某种资源的 `weak_ptr` ，你最终还是会想要访问这个资源。为此，`weak_ptr` 必须被转换为 `shared_ptr`, 因为 `weak_ptr` 是不允许访问资源的。有两种方法可以从`weak_ptr`创建`shared_ptr`：把 `weak_ptr` 传递给 `shared_ptr` 的构造函数，或者调用 `weak_ptr` 的成员函数`lock`, 它返回 `shared_ptr`. 选择哪一个取决于你认为一个空的 `weak_ptr` 是错误的抑或不是。`shared_ptr` 构造函数在接受一个空的 `weak_ptr` 参数时会抛出一个 `bad_weak_ptr` 类型的异常。因此应该在你认为空的 `weak_ptr` 是一种错误时使用它。如果使用 `weak_ptr` 的函数 `lock`, 它会在`weak_ptr`为空时返回一个空的 `shared_ptr`。这在你想测试一个资源是否有效时是正确的，一个空的 `weak_ptr` 是预期中的。此外，如果使用 `lock`, 那么使用资源的正确方法应该是初始化并同时测试它，如下：
```
#include <iostream>
#include <string>
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
int main() {
boost::shared_ptr<std::string>
sp(new std::string("Some resource"));
boost::weak_ptr<std::string> wp(sp);
// ...
if (boost::shared_ptr<std::string> p=wp.lock())
std::cout << "Got it: " << *p << '\n';
else
std::cout << "Nah, the shared_ptr is empty\n";
}
```
如你所见，[shared_ptr](../Text/content.html#ch01lev1sec6) `p` 被`weak_ptr wp` 的`lock`函数的结果初始化。然后 `p` 被测试，只有当它非空时资源才能被访问。由于 `shared_ptr` 仅在这个作用域中有效，所以在这个作用域之外不会有机会让你不小心用到它。另一种情形是当 `weak_ptr` 逻辑上必须非空的时候。那种情形下，不需要测试 `shared_ptr` 是否为空，因为 `shared_ptr` 的构造函数会在接受一个空`weak_ptr`时抛出异常，如下：
```
#include <iostream>
#include <string>
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
void access_the_resource(boost::weak_ptr<std::string> wp) {
boost::shared_ptr<std::string> sp(wp);
std::cout << *sp << '\n';
}
int main() {
boost::shared_ptr<std::string>
sp(new std::string("Some resource"));
boost::weak_ptr<std::string> wp(sp);
// ...
access_the_resource(wp);
}
```
在这个例子中，函数 `access_the_resource` 从一个`weak_ptr`构造 `shared_ptr sp` 。这时不需要测试 `shared_ptr` 是否为空，因为如果 `weak_ptr` 为空，将会抛出一个 `bad_weak_ptr` 类型的异常，因此函数会立即结束；错误会在适当的时候被捕获和处理。这样做比显式地测试 `shared_ptr` 是否为空然后返回要更好。这就是从`weak_ptr`获得`shared_ptr`的两种方法。
### 总结
`weak_ptr` 是Boost智能指针拼图的最后一块。`weak_ptr` 概念是`shared_ptr`的一个重要伙伴。它允许我们打破递归的依赖关系。它还处理了关于悬空指针的一个常见问题。在共享一个资源时，它常用于那些不参与生存期管理的资源用户。这种情况不能使用裸指针，因为在最后一个 `shared_ptr` 被销毁时，它会释放掉共享的资源。如果使用裸指针来引用资源，将无法知道资源是否仍然存在。如果资源已经不存在，访问它将会引起灾难。通过使用 `weak_ptr`, 关于共享资源已被销毁的信息会传播给所有旁观的 `weak_ptr`s，这意味着不会发生无意间访问到无效指针的情形。这就象是观察员模式(Observer pattern)的一个特例；当资源被销毁，所有表示对此感兴趣的都会被通知到。
对于以下情形使用 `weak_ptr` ：
* 要打破递归的依赖关系
* 使用一个共享的资源而不需要共享所有权
* 避免悬空的指针
- 序
- 前言
- Acknowledgments
- 关于作者
- 本书的组织结构
- Boost的介绍
- 字符串及文本处理
- 数 据结构, 容器, 迭代器, 和算法
- 函数对象及高级编程
- 泛 型编程与模板元编程
- 数学及数字处理
- 输入/输出
- 杂项
- Part I: 通用库
- Library 1. Smart_ptr
- Smart_ptr库如何改进你的程序？
- 何时我们需要智能指针？
- Smart_ptr如何适应标准库？
- scoped_ptr
- scoped_array
- shared_ptr
- shared_array
- intrusive_ptr
- weak_ptr
- Smart_ptr总结
- Library 2. Conversion
- Conversion 库如何改进你的程序？
- polymorphic_cast
- polymorphic_downcast
- numeric_cast
- lexical_cast
- Conversion 总结
- Library 3. Utility
- Utility 库如何改进你的程序？
- BOOST_STATIC_ASSERT
- checked_delete
- noncopyable
- addressof
- enable_if
- Utility 总结
- Library 4. Operators
- Operators库如何改进你的程序？
- Operators
- 用法
- Operators 总结
- Library 5. Regex
- Regex库如何改进你的程序？
- Regex 如何适用于标准库？
- Regex
- 用法
- Regex 总结
- Part II: 容器及数据结构
- Library 6. Any
- Any 库如何改进你的程序？
- Any 如何适用于标准库？
- Any
- 用法
- Any 总结
- Library 7. Variant
- Variant 库如何改进你的程序？
- Variant 如何适用于标准库？
- Variant
- 用法
- Variant 总结
- Library 8. Tuple
- Tuple 库如何改进你的程序？
- Tuple 库如何适用于标准库？
- Tuple
- 用法
- Tuple 总结
- Part III: 函数对象与高级编程
- Library 9. Bind
- Bind 库如何改进你的程序？
- Bind 如何适用于标准库？
- Bind
- 用法
- Bind 总结
- Library 10. Lambda
- Lambda 库如何改进你的程序？
- Lambda 如何适用于标准库？
- Lambda
- 用法
- Lambda 总结
- Library 11. Function
- Function 库如何改进你的程序？
- Function 如何适用于标准库？
- Function
- 用 法
- Function 总结
- Library 12. Signals
- Signals 库如何改进你的程序？
- Signals 如何适用于标准库？
- Signals
- 用法
- Signals 总结