关闭

boost :Smart ptr

标签: nulldeleteiostreamstructc++windows
681人阅读 评论(0) 收藏 举报
分类:

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_ptrscoped_array

对于scoped_ptrscoped_array是不可以拷贝构造和赋值的(拷贝构造函数和operator=都是私有成员)。所以它们不像auto_ptr那样传递指针的拥有权,而是独占拥有权,直至对象的销毁(当scoped_ptrscropted_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_ptrscoped_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指向NULLb指向一个int

bool

scoped_ptrscoped_array可以隐式的转换为bool类型,当指向NULL的时候返回false,否则返回true

类型

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

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

shared_ptrshared_array

shared_ptrshared_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<swapget,流输出(输出指针地址)

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_ptrscoped_array不可以作为STL容器的成员外,其它的都可以。

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

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

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

等等等等。。。
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:462970次
    • 积分:4816
    • 等级:
    • 排名:第6185名
    • 原创:55篇
    • 转载:44篇
    • 译文:4篇
    • 评论:144条
    最新评论