boost：智能指针
简介：
智能指针是一种具备指针类似行为的对象，当不在需要它的时候自动删除其引用的c++对象。直接点说就是自动析构C++对象。
boost提供了6种智能指针，如下所示：
| scoped_ptr | <boost/scoped_ptr.hpp> | 单个对象的简单的唯一所有权. 不能拷贝. |
| scoped_array | <boost/scoped_array.hpp> | 数组对象的唯一所有权. 不能拷贝. |
| shared_ptr | <boost/shared_ptr.hpp> | 多个指针间共享对象所有权. |
| shared_array | <boost/shared_array.hpp> | 多个指针间共享数组所有权 |
| weak_ptr | <boost/weak_ptr.hpp> | 访问被shared_ptr所有的对象，但并不拥有这个对象。通常与shared_prt 联合使用来避免环形引用 |
| intrusive_ptr | <boost/intrusive_ptr.hpp> | 共享有着嵌入了引用计数对象的所有权。它在性能上比shared_ptr更好， 但需要对象类型实现自己的引用计数机制 |
基本用法：
1、scoped ptr
就跟它的名字一样，局部作用域指针对象，控制局部对象的自动删除。
| 使用delete删除对象 | 使用scoped_ptr |
|---|---|
void manual_del()
{
test* p(new test);
if (!p->prepared() )
{
delete p;
return;
}
p->do_some_thing();
delete p;
} |
#include "boost/smart_ptr.h"
void auto_del()
{
boost::scoped_ptr<test>
sp(new test);
if (!sp->prepared() )
return;
sp->do_some_thing();
} |
示例：
#include <iostream>
#include <boost/smart_ptr/scoped_ptr.hpp>
#include <boost/smart_ptr/scoped_array.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/format.hpp>
using namespace std;
using namespace boost;
class scoped_ptr_test_class
{
public:
scoped_ptr_test_class()
{
cout<<boost::format("object constructed. address: %1%")%int((int*)this)<<endl;
}
~scoped_ptr_test_class()
{
cout<<boost::format("object destructed. address: %1%")%int((int*)this)<<endl;
}
};
void scoped_ptr_test()
{
cout<<"******************scopted_ptr_test**************"<<endl;
scoped_ptr_test_class *obj = new scoped_ptr_test_class;
{
scoped_ptr<scoped_ptr_test_class> sp(obj);
}
//scoped_ptr在删除引用对象时，并不会将其引用指针置0
//参照其构造函数： explicit scoped_ptr( T * p = 0 ): px( p )
BOOST_TEST(obj != 0);
cout<<"****************scopted_ptr_array_test************"<<endl;
scoped_ptr_test_class* obj_array = new scoped_ptr_test_class[2];
scoped_array<scoped_ptr_test_class> sar(obj_array);
}
int main()
{
scoped_ptr_test();
return 0;
}
2、shared ptr
共享指针能对其其所属对象的引用计数进行管理，这在一处生成多处使用的场合下特别有用，因为你不用四处查看代码确保没有多次delete那些对象。
与scoped_ptr不同，shared_ptr可以和标准库的容器一起使用，并且可以安全的应用在多线程环境中。
示例：
#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/format.hpp>
#include <boost/detail/lightweight_test.hpp>
using namespace std;
using namespace boost;
class shared_ptr_test_class
{
public:
shared_ptr_test_class()
{
cout<<boost::format("object constructed. address: %1%")%int((int*)this)<<endl;
}
~shared_ptr_test_class()
{
cout<<boost::format("object destructed. address: %1%")%int((int*)this)<<endl;
}
void print()
{
cout<<boost::format("object still exist:%1%")%int((int*)this)<<endl;
}
};
typedef boost::shared_ptr<shared_ptr_test_class> test_ptr;
typedef vector<test_ptr> test_vector;
//基本功能测试
void shared_ptr_test()
{
cout<<"******************basic_test**************"<<endl;
shared_ptr_test_class *obj = new shared_ptr_test_class;
test_ptr sp1(obj);
{
//注意，此处不能使用下面的方式初始化一个共享指针，会多次析构对象
//boost::shared_ptr<shared_ptr_test_class> sp2(obj);//error
test_ptr sp2(sp1);
BOOST_TEST( (sp1.use_count() == sp2.use_count() ) && sp1.use_count() ==2 ) ;
}
BOOST_TEST( sp1.use_count() == 1);
sp1.reset();
BOOST_TEST(sp1.use_count() ==0);
}
//容器测试
void vector_test_fun()
{
cout<<"******************container_test**************"<<endl;
test_vector vec;
const int obj_num =2;
for(int i =0; i<obj_num; i++)
{
vec.push_back(test_ptr(new shared_ptr_test_class));
}
test_ptr ps[obj_num];
for(int i=0; i<obj_num; i++)
{
BOOST_TEST(vec[i].use_count() == 1);
ps[i] = vec[i];
BOOST_TEST(vec[i].use_count() == 2);
}
vec.clear();
//对象仍然存在
for(int i=0; i<obj_num; i++)
{
BOOST_TEST(ps[i].use_count() == 1);
ps[i].get()->print();
}
}
int main()
{
shared_ptr_test();
vector_test_fun();
return 0;
}
3、intrusive ptr
与intrusive智能指针一起使用的类型或者其父类必须定义两个函数
intrusive_ptr_add_ref
intrusive_ptr_release
示例：
#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/format.hpp>
using std::cout;
using std::endl;
class test_class_base
{
public:
virtual ~test_class_base(){}
protected:
test_class_base():_ref(0)
{
}
int _ref;
private:
friend void intrusive_ptr_add_ref(test_class_base* p);
friend void intrusive_ptr_release(test_class_base* p);
};
void intrusive_ptr_add_ref(test_class_base* p)
{
++(p->_ref);
}
void intrusive_ptr_release(test_class_base* p)
{
if(--(p->_ref) ==0)
delete p;
}
class intrusive_ptr_test_class : public test_class_base
{
public:
intrusive_ptr_test_class()
{
cout<<boost::format("object constructed. address: %1%")%int((int*)this)<<endl;
}
~intrusive_ptr_test_class()
{
cout<<boost::format("object destructed. address: %1%")%int((int*)this)<<endl;
}
};
void intrusive_ptr_test()
{
intrusive_ptr_test_class *obj = new intrusive_ptr_test_class;
{
boost::intrusive_ptr<intrusive_ptr_test_class> sp(obj);
}
}
int main()
{
intrusive_ptr_test();
return 0;
}
使用weak_ptr解决循环引用
来看下面的代码
#include <boost/smart_ptr.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/format.hpp>
class left;
class right;
typedef boost::shared_ptr<left> left_ptr;
typedef boost::shared_ptr<right> right_ptr;
using std::cout;
using std::endl;
class node
{
public:
node()
{
cout<<boost::format("object constructed. address: %1%")%int((int*)this)<<endl;
}
virtual ~node()
{
cout<<boost::format("object destructed. address: %1%")%int((int*)this)<<endl;
}
};
class left : public node
{
public:
right_ptr _child;
};
class right : public node
{
public:
left_ptr _parent;
};
void test()
{
left_ptr left(new left);
right_ptr right(new right);
left.get()->_child = right;
right.get()->_parent = left;
BOOST_TEST(left.use_count() == 2);
BOOST_TEST(right.use_count() == 2);
left.reset();
//经过一次reset后，这里的实际的引用计数却是0
//BOOST_TEST(left.use_count() == 1);//会出错
BOOST_TEST(left.use_count() ==0);
right.reset();
BOOST_TEST(right.use_count() ==0);
//虽然引用计数都为0，但创建的对象都没有析构
}
int main()
{
test();
return 0;
}
可以使用weak_ptr来解决此问题
#include <boost/smart_ptr.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/format.hpp>
class left;
class right;
typedef boost::shared_ptr<left> left_shared_ptr;
typedef boost::shared_ptr<right> right_shared_ptr;
typedef boost::weak_ptr<left> left_weak_ptr;
typedef boost::weak_ptr<right> right_weak_ptr;
using std::cout;
using std::endl;
class node
{
public:
node()
{
cout<<boost::format("object constructed. address: %1%")%int((int*)this)<<endl;
}
virtual ~node()
{
cout<<boost::format("object destructed. address: %1%")%int((int*)this)<<endl;
}
};
class left : public node
{
public:
right_weak_ptr _child;
void print()
{
cout<<"left object"<<endl;
}
};
class right : public node
{
public:
left_weak_ptr _parent;
void other_print()
{
{
//该作用域结束后lp自动析构
left_shared_ptr lp = _parent.lock();
if(lp)
lp.get()->print();
}
}
};
void test()
{
left_shared_ptr left(new left);
right_shared_ptr right(new right);
left.get()->_child = right;
right.get()->_parent = left;
BOOST_TEST(left.use_count() == 1);
BOOST_TEST(right.use_count() == 1);
left.reset();
//left 对象析构
right.reset();
//right 对象析构
}
int main()
{
test();
return 0;
}
(boost库目前的最新版本为1.48，关于智能指针的官方资料可以通过链接查看）