程序博客网 > 爱剪辑mac版下载

shared_ptr

来源：互联网 发布：爱剪辑mac版下载 编辑：程序博客网 时间：2024/05/03 15:27

shared_ptr

shared_ptr

头文件: "boost/shared_ptr.hpp"

shared_ptr 可以从一个裸指针、另一个shared_ptr、一个std::auto_ptr、或者一个boost::weak_ptr构造。还可以传递第二个参数给shared_ptr的构造函数，它被称为删除器(deleter)。删除器稍后会被调用，来处理共享资源的释放。这对于管理那些不是用new分配也不是用delete释放的资源时非常有用(稍后将看到创建客户化删除器的例子)。shared_ptr被创建后，它就可象普通指针一样使用了，除了一点，它不能被显式地删除。

以下是shared_ptr的部分摘要；最重要的成员和相关普通函数被列出，随后是简单的讨论。

成员函数

[cpp] view plaincopyprint?
  1. template <class Y> explicit shared_ptr(Y* p);  

这个构造函数获得给定指针p的所有权。参数 p 必须是指向 Y 的有效指针。构造后引用计数设为1。唯一从这个构造函数抛出的异常是std::bad_alloc (仅在一种很罕见的情况下发生，即不能获得引用计数器所需的自由空间)。

[cpp] view plaincopyprint?
  1. template <class Y,class D> shared_ptr(Y* p,D d);  

这个构造函数带有两个参数。第一个是shared_ptr将要获得所有权的那个资源，第二个是shared_ptr被销毁时负责释放资源的一个对象，被保存的资源将以d(p)的形式传给那个对象。因此p的值是否有效取决于d。如果引用计数器不能分配成功，shared_ptr抛出一个类型为std::bad_alloc的异常。

[cpp] view plaincopyprint?
  1. shared_ptr(const shared_ptr& r);  

r中保存的资源被新构造的shared_ptr所共享，引用计数加一。这个构造函数不会抛出异常。

[cpp] view plaincopyprint?
  1. template <class Y> explicit shared_ptr(const weak_ptr<Y>& r);  

从一个weak_ptr (本章稍后会介绍)构造shared_ptr。这使得weak_ptr的使用具有线程安全性，因为指向weak_ptr参数的共享资源的引用计数将会自增(weak_ptr不影响共享资源的引用计数)。如果weak_ptr为空 (r.use_count()==0), shared_ptr 抛出一个类型为bad_weak_ptr的异常。

[cpp] view plaincopyprint?
  1. template <typename Y> shared_ptr(std::auto_ptr<Y>& r);  

这个构造函数从一个auto_ptr获取r中保存的指针的所有权，方法是保存指针的一份拷贝并对auto_ptr调用release。构造后的引用计数为1。而r当然就变为空的。如果引用计数器不能分配成功，则抛出std::bad_alloc 。

[cpp] view plaincopyprint?
  1. ~shared_ptr();  

shared_ptr析构函数对引用计数减一。如果计数为零，则保存的指针被删除。删除指针的方法是调用operator delete 或者，如果给定了一个执行删除操作的客户化删除器对象，就把保存的指针作为唯一参数调用这个对象。析构函数不会抛出异常。

[cpp] view plaincopyprint?
  1. shared_ptr& operator=(const shared_ptr& r);  

赋值操作共享r中的资源，并停止对原有资源的共享。赋值操作不会抛出异常。

[cpp] view plaincopyprint?
  1. void reset();  

reset函数用于停止对保存指针的所有权的共享。共享资源的引用计数减一。

[cpp] view plaincopyprint?
  1. T& operator*() const;  

这个操作符返回对已存指针所指向的对象的一个引用。如果指针为空，调用operator* 会导致未定义行为。这个操作符不会抛出异常。

[cpp] view plaincopyprint?
  1. T* operator->() const;  

这个操作符返回保存的指针。这个操作符与operator*一起使得智能指针看起来象普通指针。这个操作符不会抛出异常。

[cpp] view plaincopyprint?
  1. T* get() const;  

get函数是当保存的指针有可能为空时(这时 operator* 和 operator-> 都会导致未定义行为)获取它的最好办法。注意，你也可以使用隐式布尔类型转换来测试 shared_ptr 是否包含有效指针。这个函数不会抛出异常。

[cpp] view plaincopyprint?
  1. bool unique() const;  

这个函数在shared_ptr是它所保存指针的唯一拥有者时返回 true ；否则返回 false。 unique 不会抛出异常。

[cpp] view plaincopyprint?
  1. long use_count() const;  

use_count 函数返回指针的引用计数。它在调试的时候特别有用，因为它可以在程序执行的关键点获得引用计数的快照。小心地使用它，因为在某些可能的shared_ptr实现中，计算引用计数可能是昂贵的，甚至是不行的。这个函数不会抛出异常。

[cpp] view plaincopyprint?
  1. operator unspecified-bool-type() const;  

这是个到unspecified-bool-type类型的隐式转换函数，它可以在Boolean上下文中测试一个智能指针。如果shared_ptr保存着一个有效的指针，返回值为True；否则为false。注意，转换函数返回的类型是不确定的。把返回类型当成bool用会导致一些荒谬的操作，所以典型的实现采用了safe bool idiom,它很好地确保了只有可适用的Boolean测试可以使用。这个函数不会抛出异常。

[cpp] view plaincopyprint?
  1. void swap(shared_ptr<T>& b);  

这可以很方便地交换两个shared_ptr。swap 函数交换保存的指针(以及它们的引用计数)。这个函数不会抛出异常。

普通函数

[cpp] view plaincopyprint?
  1. template <typename T,typename U>  
  2.   shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r);   

要对保存在shared_ptr里的指针执行static_cast，我们可以取出指针然后强制转换它，但我们不能把它存到另一个shared_ptr里；新的 shared_ptr 会认为它是第一个管理这些资源的。解决的方法是用static_pointer_cast. 使用这个函数可以确保被指物的引用计数保持正确。static_pointer_cast 不会抛出异常。

用法

使用shared_ptr解决的主要问题是知道删除一个被多个客户共享的资源的正确时机。下面是一个简单易懂的例子，有两个类 A 和 B, 它们共享一个int实例。使用 boost::shared_ptr, 你需要必须包含"boost/shared_ptr.hpp".

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. #include "boost/shared_ptr.hpp"   
  2. #include <cassert>   
  3.   
  4. class A {  
  5.   boost::shared_ptr<int> no_;  
  6. public:  
  7.   A(boost::shared_ptr<int> no) : no_(no) {}  
  8.   void value(int i) { *no_=i; }  
  9. };  
  10.   
  11. class B {  
  12.   boost::shared_ptr<int> no_;  
  13. public:  
  14.   B(boost::shared_ptr<int> no) : no_(no) {}  
  15.   int value() const { return *no_; }  
  16. };  
  17.   
  18. int main() {  
  19.     boost::shared_ptr<int> temp(new int(14));  
  20.     A a(temp);  
  21.     B b(temp);  
  22.     a.value(28);  
  23.     assert(b.value()==28);  
  24. }  

类 A 和 B都保存了一个 shared_ptr<int>. 在创建 A 和 B的实例时，shared_ptr temp 被传送到它们的构造函数。这意味着共有三个 shared_ptr：a, b, 和 temp，它们都引向同一个int实例。如果我们用指针来实现对一个的共享，A 和 B 必须能够在某个时间指出这个int要被删除。在这个例子中，直到main的结束，引用计数为3，当所有 shared_ptr离开了作用域，计数将达到0，而最后一个智能指针将负责删除共享的 int.

shared_ptr 与标准库容器

把对象直接存入容器中有时会有些麻烦。以值的方式保存对象意味着使用者将获得容器中的元素的拷贝，对于那些复制是一种昂贵的操作的类型来说可能会有性能的问题。此外，有些容器，特别是 std::vector, 当你加入元素时可能会复制所有元素，这更加重了性能的问题。最后，传值的语义意味着没有多态的行为。如果你需要在容器中存放多态的对象而且你不想切割它们，你必须用指针。如果你用裸指针，维护元素的完整性会非常复杂。从容器中删除元素时，你必须知道容器的使用者是否还在引用那些要删除的元素，不用担心多个使用者使用同一个元素。这些问题都可以用shared_ptr来解决。

下面是如何把共享指针存入标准库容器的例子。

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. #include "boost/shared_ptr.hpp"   
  2. #include <vector>   
  3. #include <iostream>   
  4.   
  5. class A {  
  6. public:  
  7.   virtual void sing()=0;  
  8. protected:  
  9.   virtual ~A() {};  
  10. };  
  11.   
  12. class B : public A {  
  13. public:  
  14.   virtual void sing() { std::cout << "Do re mi fa so la"; }  
  15. };  
  16.   
  17. boost::shared_ptr<A> createA()   
  18. {  
  19.   boost::shared_ptr<A> p(new B());  
  20.   return p;  
  21. }  
  22.   
  23. int main()   
  24. {  
  25.   typedef std::vector<boost::shared_ptr<A> > container_type;  
  26.   typedef container_type::iterator iterator;  
  27.   
  28.   container_type container;  
  29.   for (int i=0;i<10;++i) {  
  30.     container.push_back(createA());  
  31.   }  
  32.   
  33.   std::cout << "The choir is gathered: /n";  
  34.   iterator end=container.end();  
  35.   for (iterator it=container.begin();it!=end;++it) {  
  36.     (*it)->sing();  
  37.   }  
  38. }  

这里有两个类, A 和 B, 各有一个虚拟成员函数 sing. B 从 A公有继承而来，并且如你所见，工厂函数 createA 返回一个动态分配的B的实例，包装在shared_ptr<A>里。在 main里, 一个包含shared_ptr<A>的 std::vector 被放入10个元素，最后对每个元素调用sing。如果我们用裸指针作为元素，那些对象需要被手工删除。而在这个例子里，删除是自动的，因为在vector的生存期中，每个shared_ptr的引用计数都保持为1；当 vector 被销毁，所有引用计数器都将变为零，所有对象都被删除。有趣的是，即使 A 的析构函数没有声明为 virtual,shared_ptr 也会正确调用 B的析构函数！

上面的例子示范了一个强有力的技术，它涉及A里面的protected析构函数。因为函数 createA 返回的是shared_ptr<A>, 因此不可能对shared_ptr::get返回的指针调用 delete 。这意味着如果为了向某个需要裸指针的函数传送裸指针而从shared_ptr中取出裸指针的话，它不会由于意外地被删除而导致灾难。那么，又是如何允许 shared_ptr 删除它的对象的呢？ 这是因为指针指向的真正类型是 B; 而B的析构函数不是protected的。这是非常有用的方法，用于给shared_ptr中的对象增加额外的安全性。

shared_ptr 与其它资源

有时你会发现你要把shared_ptr用于某个特别的类型，它需要其它清除操作而不是简单的delete. shared_ptr可以通过客户化删除器来支持这种需要。那些处理象 FILE*这样的操作系统句柄的资源通常要使用象fclose这样的操作来释放。要在shared_ptr里使用 FILE* ，我们要定义一个类来负责释放相应的资源。

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. class FileCloser {  
  2. public:  
  3.    void operator()(FILE* file) {  
  4.     std::cout << "The FileCloser has been called with a FILE*, "  
  5.       "which will now be closed.\n";  
  6.     if (file!=0)   
  7.       fclose(file);  
  8.   }  
  9. };  

这是一个函数对象，我们用它来确保在资源要释放时调用 fclose 。下面是使用FileCloser类的示例程序。

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. int main() {  
  2.   std::cout << "shared_ptr example with a custom deallocator.\n";   
  3.   {  
  4.     FILE* f=fopen("test.txt","r");  
  5.     if (f==0) {  
  6.       std::cout << "Unable to open file/n";  
  7.       throw "Unable to open file";  
  8.     }  
  9.   
  10.     boost::shared_ptr<FILE>   
  11.       my_shared_file(f, FileCloser());  
  12.   
  13.     // 定位文件指针   
  14.     fseek(my_shared_file.get(),42,SEEK_SET);  
  15.   }  
  16.   std::cout << "By now, the FILE has been closed!\n";  
  17. }  

注意，在访问资源时，我们需要对shared_ptr使用 &* 用法, get, 或 get_pointer。(请注意最好使用 &*. 另两个选择不太清晰) 这个例子还可以更简单，如果我们在释放资源时只需要调用一个单参数函数的话，就根本不需要创建一个客户化删除器类型。上面的例子可以重写如下：

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. {  
  2.   FILE* f=fopen("test.txt","r");  
  3.   if (f==0) {  
  4.     std::cout << "Unable to open file/n";  
  5.     throw file_exception();  
  6.   }  
  7.     
  8.   boost::shared_ptr<FILE> my_shared_file(f,&fclose);  
  9.   
  10.   // 定位文件指针   
  11.   fseek(&*my_shared_file,42,SEEK_SET);   
  12. }  
  13. std::cout << "By now, the FILE* has been closed!\n";  

定制删除器在处理需要特殊释放程序的资源时非常有用。由于删除器不是 shared_ptr 类型的一部分，所以使用者不需要知道关于智能指针所拥有的资源的任何信息(当然除了如何使用它！)。例如，你可以使用对象池，定制删除器只需简单地把对象返还到池中。或者，一个 singleton 对象应该使用一个什么都不做的删除器。

使用定制删除器的安全性

我们已经看到对基类使用 protected 析构函数有助于增加使用shared_ptr的类的安全性。另一个达到同样安全级别的方法是，声明析构函数为 protected (或 private) 并使用一个定制删除器来负责销毁对象。这个定制删除器必须是它要删除的类的友元，这样它才可以工作。封装这个删除器的好方法是把它实现为私有的嵌套类，如下例所示：

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. #include "boost/shared_ptr.hpp"   
  2. #include <iostream>   
  3.   
  4. class A {  
  5.   class deleter {  
  6.     public:  
  7.       void operator()(A* p) { delete p; }  
  8.   };  
  9.   friend class deleter;  
  10. public:  
  11.   
  12.   virtual void sing() {  
  13.     std::cout << "Lalalalalalalalalalala";  
  14.   }  
  15.   
  16.   static boost::shared_ptr<A> createA() {  
  17.     boost::shared_ptr<A> p(new A(),A::deleter());  
  18.     return p;  
  19.   }  
  20.   
  21. protected:  
  22.   virtual ~A() {};  
  23. };  
  24.   
  25. int main() {  
  26.   boost::shared_ptr<A> p=A::createA();  
  27. }  

注意，我们在这里不能使用普通函数来作为 shared_ptr<A> 的工厂函数，因为嵌套的删除器是A私有的。使用这个方法，用户不可能在栈上创建 A的对象，也不可能对A的指针调用 delete 。

从this创建shared_ptr  

有时候，需要从this获得 shared_ptr ，即是说，你希望你的类被shared_ptr所管理，你需要把"自身"转换为shared_ptr的方法。看起来不可能？好的，解决方案来自于我们即将讨论的另一个智能指针boost::weak_ptr. weak_ptr 是 shared_ptr的一个观察者；它只是安静地坐着并看着它们，但不会影响引用计数。通过存储一个指向this的 weak_ptr 作为类的成员，就可以在需要的时候获得一个指向this的shared_ptr。为了你可以不必编写代码来保存一个指向this的 weak_ptr，接着又从weak_ptr获shared_ptr得，Boost.Smart_ptr 为这个任务提供了一个助手类，称为enable_shared_from_this. 只要简单地让你的类公有地派生自 enable_shared_from_this，然后在需要访问管理this的shared_ptr时，使用函数 shared_from_this 就行了。下面的例子示范了如何使用enable_shared_from_this ：

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. #include "boost/shared_ptr.hpp"   
  2. #include "boost/enable_shared_from_this.hpp"  
  3.   
  4. class A;  
  5.   
  6. void do_stuff(boost::shared_ptr<A> p) {  
  7.   ...  
  8. }  
  9.   
  10. class A : public boost::enable_shared_from_this<A> {  
  11. public:  
  12.   void call_do_stuff() {  
  13.     do_stuff(shared_from_this());  
  14.   }  
  15. };  
  16.   
  17. int main() {  
  18.   boost::shared_ptr<A> p(new A());  
  19.   p->call_do_stuff();  
  20. }  

这个例子还示范了你要用shared_ptr管理this的情形。类 A 有一个成员函数 call_do_stuff 需要调用一个普通函数 do_stuff, 这个普通函数需要一个类型为 boost:: shared_ptr<A>的参数。现在，在 A::call_do_stuff里,this 不过是一个 A指针, 但由于 A 派生自 enable_shared_from_this, 调用 shared_from_this 将返回我们所要的 shared_ptr 。在enable_shared_from_this的成员函数 shared_from_this里，内部存储的 weak_ptr 被转换为 shared_ptr, 从而增加了相应的引用计数，以确保相应的对象不会被删除。

总结

引用计数智能指针是非常重要的工具。Boost的 shared_ptr 提供了坚固而灵活的解决方案，它已被广泛用于多种环境下。需要在使用者之间共享对象是常见的，而且通常没有办法通知使用者何时删除对象是安全的。shared_ptr 让使用者无需知道也在使用共享对象的其它对象，并让它们无需担心在没有对象引用时的资源释放。这对于Boost的智能指针类而言是最重要的。你会看到Boost.Smart_ptr中还有其它的智能指针，但这一个肯定是你最想要的。通过使用定制删除器，几乎所有资源类型都可以存入 shared_ptr。这使得shared_ptr 成为处理资源管理的通用类，而不仅仅是处理动态分配对象。与裸指针相比，shared_ptr会有一点点额外的空间代价。我还没有发现由于这些代价太大而需要另外寻找一个解决方案的情形。不要去创建你自己的引用计数智能指针类。没有比使用 shared_ptr智能指针更好的了。

在以下情况时使用 shared_ptr ：

  • 当有多个使用者使用同一个对象，而没有一个明显的拥有者时

  • 当要把指针存入标准库容器时

  • 当要传送对象到库或从库获取对象，而没有明确的所有权时

  • 当管理一些需要特殊清除方式的资源时[9]

    [9] 通过定制删除器的帮助。

0 0
爱剪辑mac版下载 爱剪辑mac版下载
原创粉丝点击
热门IT博客
知乎app ios7 下载知乎app ios7 下载
sybase12.5数据库下载sybase12.5数据库下载
淘宝卖家延迟发货时间
coc龙升级数据
众惠微交易源码
拍萌萌兔耳朵照片软件
软件开发的职业规划
广州淘宝摄影培训班
pubmed数据库官网外国
淘宝千人千面精刷平台
淘宝卖家不交保证金
在境外储存网络数据
coreldraw mac
ubuntu安装中文支持
淘宝搬家到微店怎么弄
php curl post xml
虎嗅网 源码 2016
数组对象去重
php erp系统下载
淘宝退货运费怎么算
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 悦步跳舞毯歌曲添加 悦步跳舞毯usb驱动 悦步跳舞毯下载歌曲 悦步跳舞毯 歌曲下载 悦步跳舞毯驱动安装 悦步跳舞毯歌曲更新 悦步跳舞毯按键设置 悦步跳舞毯驱动程序下载 悦步跳舞毯安装程序下载 yuebu 悦泰 悦泰春天 汕头悦泰春天 资生堂优悦活颜系列 悦游 叶繁星傅澋遇全文目录 澋 澋怎么读 51299澋视 叶繁星傅澋遇全文免费阅读 国产第一1浮力澋院 悦然 哈尔滨悦然臻城 瑞界 锦界 悦饰界 进口锐界 悦本草瘦瘦包 悦享瘦 赏心悦目 爽心悦目 爽心悦目和赏心悦目 悦目娱心 悦目 赏心悦目意思 赏心悦目造句 赏心悦目的意思 赏心悦目的近义词 赏心悦目的意思是什么 18款悦动自动悦目板 蓬莱仙山之赏心悦目1 12全

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里