boost ：Smart ptr

boost ：Smart ptr

　

作者：heroboy2000

Boost中提供的5类智能指针。分别是：

l         scoped_ptr            独占的指针

l         scoped_array         独占的数组

l         shared_ptr             引用计数指针

l         shared_array          引用计数数组

l         weak_ptr               shared_ptr的一个弱指针（不参与引用计数）

l         intrusive_ptr          自定义的引用计数指针

 

scoped_ptr和scoped_array

对于scoped_ptr和scoped_array是不可以拷贝构造和赋值的（拷贝构造函数和operator=都是私有成员）。所以它们不像auto_ptr那样传递指针的拥有权，而是独占拥有权，直至对象的销毁（当scoped_ptr和scropted_array析构的时候，所指向的对象也会被析构）。

构造：

scoped_ptr<int> a(new int);

scoped_ptr<int> b;

scoped_array<int> c(new int[100]);

scoped_array<int> d;

scoped_ptr使用new T或者是NULL来初始化对象。scoped_array使用new T[]或者NULL来初始化对象。

它们的默认构造函数，是使用NULL来初始化。

访问：

scoped_ptr重载了operator*和operator->操作符，而scoped_array重载了operator[]下标运算符。通过这几个操作符来操作它们所指向的对象。它们都可以通过T* get()成员函数得到原始的指针。

例如：

  scoped_array<char> str(new char[100]);

  strcpy(str.get(),"hello");

  cout<<str[0]<<str[4]<<endl;//输出 ho

void reset(T * p = 0)

reset用于重置指针指向的对象，当调用reset的时候scoped_ptr或scoped_array会先删除原来指向的对象（如果不是指向NULL的话）。reset的参数和它们构造函数的要求是一样的，必须是new T（或new T[]）或者是NULL。

swap

swap全局函数和swap成员函数，交换两个智能指针指向的对象。例如：

scoped_ptr<int> a(new int);//a指向一个int

scoped_ptr<int> b;//b指向NULL

swap(a,b);//这时，a指向NULL，b指向一个int

bool

scoped_ptr和scoped_array可以隐式的转换为bool类型，当指向NULL的时候返回false，否则返回true。

类型

scoped_ptr<T>和scoped_array<T>中的类型T不能是void类型。

并且scoped_ptr<T>和scoped_ptr<U>不存在类型转换，即使T和U是可以转换的，scoped_ptr<T>和scoped_ptr<const T>也不能转换。

shared_ptr和shared_array

shared_ptr和shared_array是引用计数的智能指针。

下面仅仅介绍shared_ptr的使用。

构造：

对于shared_ptr<T>来说一共有6个构造函数：

shared_ptr(Y * p);

最普通的构造函数，p一定是一个new Y的指针或NULL。注意这里p的类型是Y*，而不是shared_ptr<T>中的T*，所以p一定要存在一个到T*的类型转换。同时shared_ptr会记住p的类型是Y，当p所指向的对象要被析构的时候，shared_ptr会使用正确的析构函数（Y类型的析构函数，而不是T类型的析构函数）。例如：

struct A

{

  A(){cout<<"A construct"<<endl;}

  ~A(){cout<<"A destory"<<endl;}

};

int main()

{

  shared_ptr<void> a(new A);

  return 0;

}

/*

程序输出：

A construct

A destroy

 

这就说明A被正确的析构的，并不因为shared_ptr<void>的void而不能析构A，例如：

void del(void *p){delete p;}这就是错的

*/

 

shared_ptr(Y * p,D d);

同上。d是一个仿函数，用来析构p的，例如：

template <class T>

void my_delete(T * p)

{

  delete p;

}

int main()

{

  shared_ptr<void> a(new A,my_delete<A>);

  return 0;

}

 

shared_ptr(shared_ptr<Y> const & r);

拷贝构造函数，注意也存在类型转换哦。

shared_ptr(weak_ptr<Y> const & r);

虽然weak_ptr不参与引用计数，但是shared_ptr会的。

shared_ptr(std::auto_ptr<Y> & r);

这时r就指向NULL了。

 

重置 reset：

void reset();

void reset(Y * p);

void reset(Y * p,D d);

 

shared_ptr<T> & operator=(shared_ptr<T> const & r);

shared_ptr<T> & operator=(shared_ptr<Y> const & r);

shared_ptr<T> & operator=(std::auto_ptr<Y> & r);

使原来shared_ptr指向的对象引用计数减一，并指向另一个对象，类似于重新构造，所以它们的参数和构造函数一样。

引用计数成员函数：

long use_count();返回引用计数

bool unique();返回use_count()==1

其它：

bool类型转换，operator==，operator!=，operator<，swap，get，流输出（输出指针地址）

D* get_deleter()得到deleter，用来析构对象的仿函数指针。

类型转换：

shared_ptr<T> static_pointer_cast<T>(shared_ptr<U> const & r);

shared_ptr<T> const_pointer_cast<T>(shared_ptr<U> const & r);

shared_ptr<T> dynamic_pointer_cast<T>(shared_ptr<U> const & r);

以上是类似于c++类型转换的一些函数。由于shared_ptr支持指针的类型转换，所以shared_ptr可以保存void指针，也可以向基类指针的转换。这点，scoped_ptr就不可以！

 

Weak_ptr

weak_ptr是对shared_ptr的一个访问者，weak_ptr不参与shared_ptr的引用计数，也不会删除所指向的对象。同时，当对象被shared_ptr删除后，weak_ptr就是无效的了。

使用weak_ptr，而不使用T*这样的c++指针的原因是：weak_ptr是可以转换成shared_ptr参与引用计数，而T*不可以（只有new T出来的指针才可以构造shared_ptr）。也就是说，weak_ptr虽然不参与引用计数，但是引用计数这套机制还是存在的，当需要转换成shared_ptr的时候就把这套机制传给shared_ptr。否则的话，使用T*构造shared_ptr的话，相当于有两套机制来管理引用计数，那么一个shared_ptr可能指向无效的对象（对象被另一套引用计数机制删除了）。

构造：

weak_ptr();//构造的weak_ptr指向NULL

weak_ptr(weak_ptr const & r);//拷贝构造函数

weak_ptr(weak_ptr<Y> const & r);//类型转换的构造函数

weak_ptr(shared_ptr<Y> const & r);//通过shared_ptr构造，支持类型转换

 

weak_ptr & operator=(weak_ptr const & r);//赋值运算符的重载

weak_ptr & operator=(weak_ptr<Y> const & r);//类型转换

weak_ptr & operator=(shared_ptr<Y> const & r);//。。。

转换成shared_ptr:

shared_ptr<T> lock();//lock成员函数，通过weak_ptr构造shared_ptr

或者可以使用shared_ptr的构造函数。请参考上面shared_ptr的构造函数。

引用计数：

long use_count();//返回引用计数，虽然不参与引用计数，但是察看还是可以的

bool expired();//返回use_count()==0

其它：

void reset();//重置为NULL

swap成员函数,swap全局函数,operator<重载

intrusive_ptr

intrusive_ptr字面上的意思是侵入式指针，其实就是把引用计数的机制留给使用者来定义。比如windows中的COM对象有自己的一套引用计数机制，那么就可以使用intrusive_ptr来管理引用计数，intrusive_ptr会在适当的时候增加和减少引用计数。

使用intrusive_ptr需要自定义以下两个函数：

void intrusive_ptr_add_ref(T * p);//当增加引用计数时，intrusive_ptr调用

void intrusive_ptr_release(T * p);//当减少引用计数时，intrusive_ptr调用

对于intrusive_ptr我就不多说了，请看下面的一个例子吧。

#include<iostream>

#include <boost/intrusive_ptr.hpp>

using namespace std;

using namespace boost;

struct MyObj

{

  int * ref_count;//引用计数

  MyObj()

  {

      ref_count=new int(0);

      cout<<"MyObj construct"<<endl;

  }

  ~MyObj()

  {

      cout<<"MyObj destory"<<endl;

  }

};

void intrusive_ptr_add_ref(MyObj * p)

{

  cout<<"Add Ref"<<endl;

  ++(*(p->ref_count));

}

void intrusive_ptr_release(MyObj * p)

{

  cout<<"Release"<<endl;

  if (--(*(p->ref_count))==0)

      delete p;

}

void use(intrusive_ptr<MyObj> obj)//using obj

{

}

int main()

{

  intrusive_ptr<MyObj> obj(new MyObj);

  intrusive_ptr<MyObj> obj2=obj;

  use(obj2);

  return 0;

}

一些总结

除了scoped_ptr和scoped_array不可以作为STL容器的成员外，其它的都可以。

除了通过成员函数T*get()之外，还可以使用全局函数get_pointer得到原始指针

T * get_pointer(scoped_ptr<T> const & p);等等。

都可以隐式的转换为bool类型。

等等等等。。。