shared_ptr 主要的功能是,管理动态创建的对象的销毁。它的基本原理就是记录对象被引用的次数,当引用次数为 0 的时候,也就是最后一个指向某对象的共享指针析构的时候,共享指针的析构函数就把指向的内存区域释放掉。
共享指针对象重载了 operator* 和 operator-> , 所以你可以像通常的指针一样使用它。这部分不再赘述。
目前,Visual C++ 2010 的 <memory> 库里,已经包含了 shared_ptr 模板类,也就是说,你可以直接这样写:
#include <memory>
而 GNU G++ 的标准库中还没有支持(毕竟是将来的标准),如果在 G++ 中想使用 shared_ptr, 还是得用到 Boost 库,就是说,在 G++ 里,你得这样写:
#include <boost/shared_ptr.hpp>
保险起见,你应该仅从以下几种途径构造一个共享指针(以下例子中若没特殊说明,T 就代表共享指针所指向的对象的类型):
也就是说,你可以直接定义一个 shared_ptr 而不指定构造函数的内容:
1 |
shared_ptr
<T
> ptr
;
|
这样做的话,ptr 的意义就相当于一个 NULL 指针。当你试图在一个空指针上做类似于 *ptr 或者 ptr->xx 之类的东西的时候,应该会收到异常的。
用代码来表示,就是可以这样使用:
1 |
shared_ptr
<T
> ptr
(
new T
(
)
)
;
|
一种显然的情况是这样的:
1 2 |
shared_ptr
<T
> ptr1
(
new T
(
)
)
;
// 本行与 3.1. 中的构造方法是一样的
shared_ptr <T > ptr2 (ptr1 ) ; // 这就是使用复制构造函数的方法,会让引用计数加 1 |
还有,shared_ptr 可以当作函数的参数传递,或者当作函数的返回值返回,这个时候其实也相当于使用复制构造函数。
shared_ptr 也可以类型转换,有关类型转换的详情参见下面的 5. 此处假设 B 是 A 的子类,那么,在 C 语言中 B 的指针当然是可以转换成 A 的指针的。在共享指针里,应该这样做:
1 2 |
shared_ptr
<B
> ptrb
(
new B
(
)
)
;
shared_ptr <A > ptra ( dynamic_pointer_cast <A > (ptrb ) ) ; |
shared_ptr 也可以直接赋值,但是必须是赋给相同类型的 shared_ptr 对象,而不能是普通的 C 指针或 new 运算符的返回值。当共享指针 a 被赋值成 b 的时候,如果 a 原来是 NULL, 那么直接让 a 等于 b 并且让它们指向的东西的引用计数加 1; 如果 a 原来也指向某些东西的时候,如果 a 被赋值成 b, 那么原来 a 指向的东西的引用计数被减 1, 而新指向的对象的引用计数加 1. 就是说以下代码是允许的:
1 2 3 |
shared_ptr
<T
> a
(
new T
(
)
)
;
shared_ptr <T > b ( new T ( ) ) ; a = b ; // 此后 a 原先所指的对象会被销毁,b 所指的对象引用计数加 1 |
shared_ptr 的对象在构造之后,可以被赋予空值,此时使用的应该是 reset() 函数,如:
1 2 |
shared_ptr
<T
> a
(
new T
(
)
)
;
a. reset ( ) ; // 此后 a 原先所指的对象会被销毁,并且 a 会变成 NULL |
当然理论上也可以这样写:
1 2 |
shared_ptr
<T
> a
(
new T
(
)
)
;
a = shared_ptr <T > ( ) ; // 相当于给 a 赋一个新构造的 shared_ptr, 也就是 NULL |
shared_ptr 有两种类型转换的函数,一个是 static_pointer_cast, 一个是 dynamic_pointer_cast. 其实用法真的和 C++ 提供的 static_cast 和 dynamic_cast 很像,再结合 3.3. 的代码和以下类似的代码,几乎没什么好讲的:
1 2 3 |
shared_ptr
<A
> ptra
;
shared_ptr <B > ptrb ( new B ( ) ) ; ptra = dynamic_pointer_cast <A > (ptrb ) ; |
很简单,可以这样用:
1 2 |
shared_ptr
<T
> ptr
(
new T
(
)
)
;
T *p = ptr. get ( ) ; // 获得传统 C 指针 |
比如,“我想让一个已经构造好的共享指针,丢弃掉原来所指的对象(或者让其引用计数减 1),然后指向一个新的 new 出来的对象,该怎么办?”参考如下代码:
1 2 |
shared_ptr
<T
> ptr
(
new T
(
)
)
;
ptr. reset ( new T ( ) ) ; // 原来所指的对象会被销毁 |
一定要注意,本节所述所有方法,都是错误的!
所谓在中途,指的就是不从 new 的返回值直接构造共享指针,比如从 this 指针构造自己的共享指针等。
其实这种和 8.1. 也是类似的,或者说,这种情况是 8.1. 的一种具体情况,比如,下面的代码是错误的:
1 2 3 |
T
*a
=
new T
(
)
;
shared_ptr <T > ptr1 (a ) ; shared_ptr <T > ptr2 (a ) ; |
这样的话,ptr1 和 ptr2 的引用计数是单独算的,它们任意一个对象在析构的时候,都会销毁 a 所指的对象,所以,这个对象会被“销毁两次”。
有关运行效率的问题在这里就不讨论了。其它方面,shared_ptr 的构造要求比较高,如果对象在创建的时候没有使用共享指针存储的话,之后也不能用共享指针管理这个对象了。如果有引用循环 (reference cycle), 也就是对象 a 有指向对象 b 的共享指针,对象 b 也有指向对象 a 的共享指针,那么它们都不会被析构。当然的,shared_ptr 也没有办法和 Garbage Collecting 比较,毕竟如果运行库能够干预,还是有算法可以检查到引用循环的。(例如求强连通分量的算法。)
尤其,在类的成员函数的编写的时候,有时我们经常希望得到“自己”的共享指针,但是这往往是无法得到的。此时也不能够从 this 指针构造自己的共享指针(参见 8.1.),所以有时很憋闷。
实际上上面这么多注意事项,中心思想就是一个:让 shared_ptr 正确地记录对象被引用次数。如果能悟出一点 shared_ptr 的工作原理,基本上不会弄出太危险的事情来。
转载于:http://euyuil.com/2344/
boost::shared_ptr的特点:
和前面介绍的boost::scoped_ptr相比,boost::shared_ptr可以共享对象的所有权,因此其使用范围基本上没有什么限制(还是有一些需要遵循的使用规则,下文中介绍),自然也可以使用在stl的容器中。另外它还是线程安全的,这点在多线程程序中也非常重要。
boost::shared_ptr的使用规则:
boost::shared_ptr并不是绝对安全,下面几条规则能使我们更加安全的使用boost::shared_ptr: