boost-智能指针

boost中智能指针主要包括scoped_ptr,scoped_array,shared_ptr,shared_array;

1.scoped_ptr

scoped_ptr:跟auto_ptr很像，但是它有更严格的管理权也更安全。当离开作用域能够自动释放的指针。因为它是不传递所有权的。事实上它

明确禁止任何想要这样做的企图！这在你需要确保指针任何时候只有一个拥有者时的任何一种情境下都是非常重要的。

头文件：#include <boost/scoped_ptr.hpp>using namespace boost;
函数接口定义：

namespace boost {

  template<class T> class scoped_ptr : noncopyable {

   public:
     typedef T element_type;

     explicit scoped_ptr(T * p = 0); // never throws
     ~scoped_ptr(); // never throws

     void reset(T * p = 0); // never throws

     T & operator*() const; // never throws
     T * operator->() const; // never throws
     T * get() const; // never throws
     
     operator unspecified-bool-type() const; // never throws

     void swap(scoped_ptr & b); // never throws
  };

  template<class T> void swap(scoped_ptr<T> & a, scoped_ptr<T> & b); // never throws

}

用法介绍：

#include <iostream>
#include <boost/intrusive_ptr.hpp>

using namespace boost;
using std::cout;
using std::endl;

int main() 
{
    scoped_ptr<string> sp(new string("test"));
    cout<<*sp<<endl;//获取string的值。 test
    cout<<sp->size()<<endl;//不需要使用delete操作。不允许拷贝构造和自增操作。
    sp.reset();//将sp置为0；当为0时自动删除。调用string的析构函数。
    int *a = sp.get();//可以得到原始指针。不推荐这么做。
}

意义：代码清晰，错误更少，没有多余的操作，同时效率很高，能够跟原始指针同样的速度。

2.shared_ptr

shared_ptr实现了引用计数型的智能指针，可以被自由拷贝和赋值，任意地方共享他，只有当计数为0时，才能删除它。

它更像一个智能指针，同时也是smart_ptr库中左右价值的、最重要，用的最多的一个组件。

boost::shared_ptr的管理机制其实并不复杂，就是对所管理的对象进行了引用计数，当新增一个boost::shared_ptr对该对象进行管理时

，就将该对象的引用计数加一；减少一个boost::shared_ptr对该对象进行管理时，就将该对象的引用计数减一，

如果该对象的引用计数为0的时候，说明没有任何指针对其管理，才调用delete释放其所占的内存。

位置：#include <boost/shared_ptr.hpp>using namespace boost; 

ps:这些智能指针都包含在：#include <boost/smart_ptr.hpp> 头文件中。

类的部分常用接口定义：

完整文档在这：http://www.boost.org/doc/libs/1_55_0/libs/smart_ptr/shared_ptr.htm

template<class T> class shared_ptr {
	public:
		 shared_ptr(); // never throws
     		 shared_ptr(std::nullptr_t); // never throws
		~shared_ptr(); // never throws
		
		void reset();

		 T & operator*() const; // never throws; only valid when T is not an array type
     		 T * operator->() const; // never throws; only valid when T is not an array type
		 T * get() const;//获取原始指针。
		
		bool unique() const;//返回是否是唯一拥有者。
		long use_count() const;//返回当前引用计数。
		
}

用法示例：

#include <iostream>
#include <boost/smart_ptr.hpp>

using namespace boost;
using std::cout;
using std::endl;
using std::string;

class demo
{
public:
    ~demo() { std::cout <<"destroying demo\n"; }
    void do_something() { std::cout << "did something\n"; }
};

int main() 
{
    boost::shared_ptr<demo> sp1(new demo());//新建shared指针管理demo对象。
    std::cout<<"Now has "<<sp1.use_count()<<" references\n";

    boost::shared_ptr<demo> sp2 = sp1;
    std::cout<<"Now has "<<sp2.use_count()<<" references\n";
    
    sp1.reset();//sp1解除shared对sp1的指针管理。
    std::cout<<"After Reset has "<<sp2.use_count()<<" references\n";

    sp2.reset();
    std::cout<<"After Reset sp2.\n";
}

/*输出：
    Now has 1 references
    Now has 2 references
    After Reset has 1 references
    destroying demo
    After Reset sp2.
*/